chore: Bump version to 6.3.54

- Introduced a comprehensive guide for generating workflow templates.
- Detailed usage instructions with examples for creating templates.
- Outlined execution flow across three phases: Template Design, Step Definition, and JSON Generation.
- Included JavaScript code snippets for each phase to facilitate implementation.
- Provided suggested step templates for various development scenarios.
- Documented command port references and minimum execution units for clarity.

.claude/CLAUDE.md

@@ -9,12 +9,7 @@
 
 **Strictly follow the cli-tools.json configuration**
 
-Available CLI endpoints are dynamically defined by the config file:
+Available CLI endpoints are dynamically defined by the config file
-- Built-in tools and their enable/disable status
-- Custom API endpoints registered via the Dashboard
-- Managed through the CCW Dashboard Status page
-
-
 ## Tool Execution
 
 - **Context Requirements**: @~/.claude/workflows/context-tools.md
@@ -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)
+  Execution: Agent executes pre_analysis, then directly implements implementation_approach
-
-"hybrid" →
-  meta.execution_config = { method: "hybrid", cli_tool: userConfig.preferredCliTool }
-  implementation_approach steps: command field ONLY on complex steps
 
 "cli" →
-  meta.execution_config = { method: "cli", cli_tool: userConfig.preferredCliTool }
+  meta.execution_config = { method: "cli", cli_tool: userConfig.preferredCliTool, enable_resume: true }
-  implementation_approach steps: command field on ALL steps
+  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:
+**Note**: implementation_approach steps NO LONGER contain `command` fields. CLI execution is controlled by task-level `meta.execution_config` only.
-- `method: "agent"` → 0 steps have command field
-- `method: "hybrid"` → some steps have command field
-- `method: "cli"` → all steps have command field
 
 **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
+- **Simple Tasks** (≤4 tasks): Flat structure
-- **Medium Tasks** (6-12 tasks): Flat structure
+- **Medium Tasks** (5-8 tasks): Flat structure
-- **Complex Tasks** (>12 tasks): Re-scope required (maximum 12 tasks hard limit)
+- **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
+- **Per-module limit**: ≤6 tasks per module
-- **Total limit**: Sum of all module tasks ≤27 (3 modules × 9 tasks)
+- **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
 
@@ -852,9 +834,35 @@ Use `analysis_results.complexity` or task count to determine structure:
 - Proper linking between documents
 - Consistent navigation and references
 
-### 3.3 Guidelines Checklist
+### 3.3 N+1 Context Recording
+
+**Purpose**: Record decisions and deferred items for N+1 planning continuity.
+
+**When**: After task generation, update `## N+1 Context` in planning-notes.md.
+
+**What to Record**:
+- **Decisions**: Architecture/technology choices with rationale (mark `Revisit?` if may change)
+- **Deferred**: Items explicitly moved to N+1 with reason
+
+**Example**:
+```markdown
+## N+1 Context
+### Decisions
+| Decision | Rationale | Revisit? |
+|----------|-----------|----------|
+| JWT over Session | Stateless scaling | No |
+| CROSS::B::api → IMPL-B1 | B1 defines base | Yes |
+
+### Deferred
+- [ ] Rate limiting - Requires Redis (N+1)
+- [ ] API versioning - Low priority
+```
+
+### 3.4 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
+- **Record N+1 Context**: Update `## N+1 Context` section with key decisions and deferred items
 - **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 +873,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 +887,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-lite-planning-agent.md

@@ -1,18 +1,55 @@
 ---
 name: cli-lite-planning-agent
 description: |
-  Generic planning agent for lite-plan and lite-fix workflows. Generates structured plan JSON based on provided schema reference.
+  Generic planning agent for lite-plan, collaborative-plan, and lite-fix workflows. Generates structured plan JSON based on provided schema reference.
 
   Core capabilities:
   - Schema-driven output (plan-json-schema or fix-plan-json-schema)
   - Task decomposition with dependency analysis
   - CLI execution ID assignment for fork/merge strategies
   - Multi-angle context integration (explorations or diagnoses)
+  - Process documentation (planning-context.md) for collaborative workflows
 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.
+
+## Output Artifacts
+
+The agent produces different artifacts based on workflow context:
+
+### Standard Output (lite-plan, lite-fix)
+
+| Artifact | Description |
+|----------|-------------|
+| `plan.json` | Structured plan following plan-json-schema.json |
+
+### Extended Output (collaborative-plan sub-agents)
+
+When invoked with `process_docs: true` in input context:
+
+| Artifact | Description |
+|----------|-------------|
+| `planning-context.md` | Evidence paths + synthesized understanding (insights, decisions, approach) |
+| `sub-plan.json` | Sub-plan following plan-json-schema.json with source_agent metadata |
+
+**planning-context.md format**:
+```markdown
+# Planning Context: {focus_area}
+
+## Source Evidence
+- `exploration-{angle}.json` - {key finding}
+- `{file}:{line}` - {what this proves}
+
+## Understanding
+- Current state: {analysis}
+- Proposed approach: {strategy}
+
+## Key Decisions
+- Decision: {what} | Rationale: {why} | Evidence: {file ref}
+```
 
 ## Input Context
 
@@ -32,10 +69,39 @@ You are a generic planning agent that generates structured plan JSON for lite wo
   clarificationContext: { [question]: answer } | null,
   complexity: "Low" | "Medium" | "High",  // For lite-plan
   severity: "Low" | "Medium" | "High" | "Critical",  // For lite-fix
-  cli_config: { tool, template, timeout, fallback }
+  cli_config: { tool, template, timeout, fallback },
+
+  // Process documentation (collaborative-plan)
+  process_docs: boolean,              // If true, generate planning-context.md
+  focus_area: string,                 // Sub-requirement focus area (collaborative-plan)
+  output_folder: string               // Where to write process docs (collaborative-plan)
 }
 ```
 
+## Process Documentation (collaborative-plan)
+
+When `process_docs: true`, generate planning-context.md before sub-plan.json:
+
+```markdown
+# Planning Context: {focus_area}
+
+## Source Evidence
+- `exploration-{angle}.json` - {key finding from exploration}
+- `{file}:{line}` - {code evidence for decision}
+
+## Understanding
+- **Current State**: {what exists now}
+- **Problem**: {what needs to change}
+- **Approach**: {proposed solution strategy}
+
+## Key Decisions
+- Decision: {what} | Rationale: {why} | Evidence: {file:line or exploration ref}
+
+## Dependencies
+- Depends on: {other sub-requirements or none}
+- Provides for: {what this enables}
+```
+
 ## Schema-Driven Output
 
 **CRITICAL**: Read the schema reference first to determine output structure:
@@ -72,7 +138,22 @@ 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
@@ -734,3 +815,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):
+// Read task-level execution config (Single Source of Truth)
-  1. Check depends_on: Wait for all listed step numbers to complete
+const executionMethod = task.meta?.execution_config?.method || 'agent';
-  2. Variable Substitution: Replace [variable_name] in description/modification_points
+const cliTool = task.meta?.execution_config?.cli_tool || getDefaultCliTool();  // See ~/.claude/cli-tools.json
-     with values stored from previous steps' output
-  3. Execute step (choose one):
 
-     IF step.command exists:
+// Phase 1: Execute pre_analysis (always by Agent)
-       → Execute the CLI command via Bash tool
+const preAnalysisResults = {};
-       → Capture output
+for (const step of task.flow_control.pre_analysis || []) {
+  const result = executePreAnalysisStep(step);
+  preAnalysisResults[step.output_to] = result;
+}
 
-     ELSE (no command - Agent direct implementation):
+// Phase 2: Determine execution mode
-       → Read modification_points[] as list of files to create/modify
+const hasLegacyCommands = task.flow_control.implementation_approach
-       → Read logic_flow[] as implementation sequence
+  .some(step => step.command);
-       → For each file in modification_points:
-         • If "Create new file: path" → Use Write tool to create
-         • If "Modify file: path" → Use Edit tool to modify
-         • If "Add to file: path" → Use Edit tool to append
-       → Follow logic_flow sequence for implementation logic
-       → Use [focus_paths] from context as working directory scope
 
-  4. Store result in [step.output] variable for later steps
+IF hasLegacyCommands:
-  5. Mark step complete, proceed to next
+  // 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)**:
+**CLI Handoff Functions**:
-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]`
+```javascript
-- Subsequent tasks (has `depends_on`): Use CCW CLI with resume context to maintain session
+// 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/commands/ccw-coordinator.md

@@ -47,14 +47,30 @@ Interactive orchestration tool: analyze task → discover commands → recommend
 
 | Unit Name | Commands | Purpose | Output |
 |-----------|----------|---------|--------|
-| **Code Review (Session)** | review-session-cycle → review-fix | Complete review cycle and apply fixes | Fixed code |
+| **Code Review (Session)** | review-session-cycle → review-cycle-fix | Complete review cycle and apply fixes | Fixed code |
-| **Code Review (Module)** | review-module-cycle → review-fix | Module review cycle and apply fixes | Fixed code |
+| **Code Review (Module)** | review-module-cycle → review-cycle-fix | Module review cycle and apply fixes | Fixed code |
+
+**Issue Units** (Issue单元):
+
+| Unit Name | Commands | Purpose | Output |
+|-----------|----------|---------|--------|
+| **Issue Workflow** | discover → plan → queue → execute | Complete issue lifecycle | Completed issues |
+| **Rapid-to-Issue** | lite-plan → convert-to-plan → queue → execute | Bridge lite workflow to issue workflow | Completed issues |
+| **Brainstorm-to-Issue** | from-brainstorm → queue → execute | Bridge brainstorm session to issue workflow | Completed issues |
+
+**With-File Units** (文档化单元):
+
+| Unit Name | Commands | Purpose | Output |
+|-----------|----------|---------|--------|
+| **Brainstorm With File** | brainstorm-with-file | Multi-perspective ideation with documentation | brainstorm.md |
+| **Debug With File** | debug-with-file | Hypothesis-driven debugging with documentation | understanding.md |
+| **Analyze With File** | analyze-with-file | Collaborative analysis with documentation | discussion.md |
 
 ### Command-to-Unit Mapping (命令与最小单元的映射)
 
 | Command | Can Precede | Atomic Units |
 |---------|-----------|--------------|
-| lite-plan | lite-execute | Quick Implementation |
+| lite-plan | lite-execute, convert-to-plan | Quick Implementation, Rapid-to-Issue |
 | multi-cli-plan | lite-execute | Multi-CLI Planning |
 | lite-fix | lite-execute | Bug Fix |
 | plan | plan-verify, execute | Full Planning + Execution, Verified Planning + Execution |
@@ -62,9 +78,17 @@ Interactive orchestration tool: analyze task → discover commands → recommend
 | replan | execute | Replanning + Execution |
 | test-gen | execute | Test Generation + Execution |
 | tdd-plan | execute | TDD Planning + Execution |
-| review-session-cycle | review-fix | Code Review (Session) |
+| review-session-cycle | review-cycle-fix | Code Review (Session) |
-| review-module-cycle | review-fix | Code Review (Module) |
+| review-module-cycle | review-cycle-fix | Code Review (Module) |
 | test-fix-gen | test-cycle-execute | Test Validation |
+| issue:discover | issue:plan | Issue Workflow |
+| issue:plan | issue:queue | Issue Workflow |
+| convert-to-plan | issue:queue | Rapid-to-Issue |
+| issue:queue | issue:execute | Issue Workflow, Rapid-to-Issue, Brainstorm-to-Issue |
+| issue:from-brainstorm | issue:queue | Brainstorm-to-Issue |
+| brainstorm-with-file | issue:from-brainstorm (optional) | Brainstorm With File, Brainstorm-to-Issue |
+| debug-with-file | (standalone) | Debug With File |
+| analyze-with-file | (standalone) | Analyze With File |
 
 ### Atomic Group Rules
 
@@ -105,6 +129,14 @@ function detectTaskType(text) {
   if (/测试失败|test fail|fix test|failing test/.test(text)) return 'test-fix';
   if (/generate test|写测试|add test|补充测试/.test(text)) return 'test-gen';
   if (/review|审查|code review/.test(text)) return 'review';
+  // Issue workflow patterns
+  if (/issues?.*batch|batch.*issues?|批量.*issue|issue.*批量/.test(text)) return 'issue-batch';
+  if (/issue workflow|structured workflow|queue|multi-stage|转.*issue|issue.*流程/.test(text)) return 'issue-transition';
+  // With-File workflow patterns
+  if (/brainstorm|ideation|头脑风暴|创意|发散思维|creative thinking/.test(text)) return 'brainstorm-file';
+  if (/brainstorm.*issue|头脑风暴.*issue|idea.*issue|想法.*issue|从.*头脑风暴|convert.*brainstorm/.test(text)) return 'brainstorm-to-issue';
+  if (/debug.*document|hypothesis.*debug|深度调试|假设.*验证|systematic debug/.test(text)) return 'debug-file';
+  if (/analyze.*document|collaborative analysis|协作分析|深度.*理解/.test(text)) return 'analyze-file';
   if (/不确定|explore|研究|what if|brainstorm|权衡/.test(text)) return 'brainstorm';
   if (/多视角|比较方案|cross-verify|multi-cli/.test(text)) return 'multi-cli';
   return 'feature';  // Default
@@ -252,8 +284,8 @@ const commandPorts = {
     output: ['review-findings'],
     tags: ['review']
   },
-  'review-fix': {
+  'review-cycle-fix': {
-    name: 'review-fix',
+    name: 'review-cycle-fix',
     input: ['review-findings', 'review-verified'],  // Accept output from review-session-cycle or review-module-cycle
     output: ['fixed-code'],
     tags: ['review'],
@@ -277,14 +309,81 @@ const commandPorts = {
     input: ['code', 'session'],                 // 可接受代码或会话
     output: ['review-verified'],                // 输出端口:审查通过
     tags: ['review'],
-    atomic_group: 'code-review'                // 最小单元：与 review-fix 绑定
+    atomic_group: 'code-review'                // 最小单元：与 review-cycle-fix 绑定
   },
   'review-module-cycle': {
     name: 'review-module-cycle',
     input: ['module-pattern'],                  // 输入端口:模块模式
     output: ['review-verified'],                // 输出端口:审查通过
     tags: ['review'],
-    atomic_group: 'code-review'                // 最小单元：与 review-fix 绑定
+    atomic_group: 'code-review'                // 最小单元：与 review-cycle-fix 绑定
+  },
+
+  // Issue workflow commands
+  'issue:discover': {
+    name: 'issue:discover',
+    input: ['codebase'],                        // 输入端口：代码库
+    output: ['pending-issues'],                 // 输出端口：待处理 issues
+    tags: ['issue'],
+    atomic_group: 'issue-workflow'             // 最小单元：discover → plan → queue → execute
+  },
+  'issue:plan': {
+    name: 'issue:plan',
+    input: ['pending-issues'],                  // 输入端口：待处理 issues
+    output: ['issue-plans'],                    // 输出端口：issue 计划
+    tags: ['issue'],
+    atomic_group: 'issue-workflow'
+  },
+  'issue:queue': {
+    name: 'issue:queue',
+    input: ['issue-plans', 'converted-plan'],   // 可接受 issue:plan 或 convert-to-plan 输出
+    output: ['execution-queue'],                // 输出端口：执行队列
+    tags: ['issue'],
+    atomic_groups: ['issue-workflow', 'rapid-to-issue']
+  },
+  'issue:execute': {
+    name: 'issue:execute',
+    input: ['execution-queue'],                 // 输入端口：执行队列
+    output: ['completed-issues'],               // 输出端口：已完成 issues
+    tags: ['issue'],
+    atomic_groups: ['issue-workflow', 'rapid-to-issue']
+  },
+  'issue:convert-to-plan': {
+    name: 'issue:convert-to-plan',
+    input: ['plan'],                            // 输入端口：lite-plan 输出
+    output: ['converted-plan'],                 // 输出端口：转换后的 issue 计划
+    tags: ['issue', 'planning'],
+    atomic_group: 'rapid-to-issue'             // 最小单元：lite-plan → convert-to-plan → queue → execute
+  },
+
+  // With-File workflows (documented exploration with multi-CLI collaboration)
+  'brainstorm-with-file': {
+    name: 'brainstorm-with-file',
+    input: ['exploration-topic'],               // 输入端口：探索主题
+    output: ['brainstorm-document'],            // 输出端口：brainstorm.md + 综合结论
+    tags: ['brainstorm', 'with-file'],
+    note: 'Self-contained workflow with multi-round diverge-converge cycles'
+  },
+  'issue:from-brainstorm': {
+    name: 'issue:from-brainstorm',
+    input: ['brainstorm-document'],             // 输入端口：brainstorm 产物（synthesis.json）
+    output: ['converted-plan'],                 // 输出端口：issue + solution
+    tags: ['issue', 'brainstorm'],
+    atomic_group: 'brainstorm-to-issue'        // 最小单元：from-brainstorm → queue → execute
+  },
+  'debug-with-file': {
+    name: 'debug-with-file',
+    input: ['bug-report'],                      // 输入端口：bug 报告
+    output: ['understanding-document'],         // 输出端口：understanding.md + 修复
+    tags: ['bugfix', 'with-file'],
+    note: 'Self-contained workflow with hypothesis-driven iteration'
+  },
+  'analyze-with-file': {
+    name: 'analyze-with-file',
+    input: ['analysis-topic'],                  // 输入端口：分析主题
+    output: ['discussion-document'],            // 输出端口：discussion.md + 结论
+    tags: ['analysis', 'with-file'],
+    note: 'Self-contained workflow with multi-round discussion'
   }
 };
 ```
@@ -306,14 +405,22 @@ async function recommendCommandChain(analysis) {
 // 任务类型对应的端口流
 function determinePortFlow(taskType, constraints) {
   const flows = {
-    'bugfix':     { inputPort: 'bug-report', outputPort: constraints?.includes('skip-tests') ? 'fixed-code' : 'test-passed' },
+    'bugfix':         { inputPort: 'bug-report', outputPort: constraints?.includes('skip-tests') ? 'fixed-code' : 'test-passed' },
-    'tdd':        { inputPort: 'requirement', outputPort: 'tdd-verified' },
+    'tdd':            { inputPort: 'requirement', outputPort: 'tdd-verified' },
-    'test-fix':   { inputPort: 'failing-tests', outputPort: 'test-passed' },
+    'test-fix':       { inputPort: 'failing-tests', outputPort: 'test-passed' },
-    'test-gen':   { inputPort: 'code', outputPort: 'test-passed' },
+    'test-gen':       { inputPort: 'code', outputPort: 'test-passed' },
-    'review':     { inputPort: 'code', outputPort: 'review-verified' },
+    'review':         { inputPort: 'code', outputPort: 'review-verified' },
-    'brainstorm': { inputPort: 'exploration-topic', outputPort: 'test-passed' },
+    'brainstorm':     { inputPort: 'exploration-topic', outputPort: 'test-passed' },
-    'multi-cli':  { inputPort: 'requirement', outputPort: 'test-passed' },
+    'multi-cli':      { inputPort: 'requirement', outputPort: 'test-passed' },
-    'feature':    { inputPort: 'requirement', outputPort: constraints?.includes('skip-tests') ? 'code' : 'test-passed' }
+    // Issue workflow types
+    'issue-batch':      { inputPort: 'codebase', outputPort: 'completed-issues' },
+    'issue-transition': { inputPort: 'requirement', outputPort: 'completed-issues' },
+    // With-File workflow types
+    'brainstorm-file':    { inputPort: 'exploration-topic', outputPort: 'brainstorm-document' },
+    'brainstorm-to-issue': { inputPort: 'brainstorm-document', outputPort: 'completed-issues' },
+    'debug-file':         { inputPort: 'bug-report', outputPort: 'understanding-document' },
+    'analyze-file':       { inputPort: 'analysis-topic', outputPort: 'discussion-document' },
+    'feature':            { inputPort: 'requirement', outputPort: constraints?.includes('skip-tests') ? 'code' : 'test-passed' }
   };
   return flows[taskType] || flows['feature'];
 }
@@ -539,7 +646,7 @@ function formatCommand(cmd, previousResults, analysis) {
     if (latest?.session_id) prompt += ` --session="${latest.session_id}"`;
 
   // Review fix - takes session from review
-  } else if (name === 'review-fix') {
+  } else if (name === 'review-cycle-fix') {
     const review = previousResults.find(r => r.command.includes('review'));
     const latest = review || previousResults.filter(r => r.session_id).pop();
     if (latest?.session_id) prompt += ` --session="${latest.session_id}"`;
@@ -553,6 +660,45 @@ function formatCommand(cmd, previousResults, analysis) {
   } else if (name.includes('test') || name.includes('review') || name.includes('verify')) {
     const latest = previousResults.filter(r => r.session_id).pop();
     if (latest?.session_id) prompt += ` --session="${latest.session_id}"`;
+
+  // Issue workflow commands
+  } else if (name === 'issue:discover') {
+    // No parameters needed - discovers from codebase
+    prompt = `/issue:discover -y`;
+
+  } else if (name === 'issue:plan') {
+    prompt = `/issue:plan -y --all-pending`;
+
+  } else if (name === 'issue:queue') {
+    prompt = `/issue:queue -y`;
+
+  } else if (name === 'issue:execute') {
+    prompt = `/issue:execute -y --queue auto`;
+
+  } else if (name === 'issue:convert-to-plan' || name === 'convert-to-plan') {
+    // Convert latest lite-plan to issue plan
+    prompt = `/issue:convert-to-plan -y --latest-lite-plan`;
+
+  // With-File workflows (self-contained)
+  } else if (name === 'brainstorm-with-file') {
+    prompt = `/workflow:brainstorm-with-file -y "${analysis.goal}"`;
+
+  } else if (name === 'debug-with-file') {
+    prompt = `/workflow:debug-with-file -y "${analysis.goal}"`;
+
+  } else if (name === 'analyze-with-file') {
+    prompt = `/workflow:analyze-with-file -y "${analysis.goal}"`;
+
+  // Brainstorm-to-issue bridge
+  } else if (name === 'issue:from-brainstorm' || name === 'from-brainstorm') {
+    // Extract session ID from analysis.goal or latest brainstorm
+    const sessionMatch = analysis.goal.match(/BS-[\w-]+/);
+    if (sessionMatch) {
+      prompt = `/issue:from-brainstorm -y SESSION="${sessionMatch[0]}" --auto`;
+    } else {
+      // Find latest brainstorm session
+      prompt = `/issue:from-brainstorm -y --auto`;
+    }
   }
 
   return prompt;
@@ -904,18 +1050,20 @@ break; // ⚠️ STOP HERE - DO NOT use TaskOutput polling
 
 ## Available Commands
 
-All from `~/.claude/commands/workflow/`:
+All from `~/.claude/commands/workflow/` and `~/.claude/commands/issue/`:
 
 **Planning**: lite-plan, plan, multi-cli-plan, plan-verify, tdd-plan
 **Execution**: lite-execute, execute, develop-with-file
 **Testing**: test-cycle-execute, test-gen, test-fix-gen, tdd-verify
-**Review**: review, review-session-cycle, review-module-cycle, review-fix
+**Review**: review, review-session-cycle, review-module-cycle, review-cycle-fix
 **Bug Fixes**: lite-fix, debug, debug-with-file
 **Brainstorming**: brainstorm:auto-parallel, brainstorm:artifacts, brainstorm:synthesis
 **Design**: ui-design:*, animation-extract, layout-extract, style-extract, codify-style
 **Session Management**: session:start, session:resume, session:complete, session:solidify, session:list
 **Tools**: context-gather, test-context-gather, task-generate, conflict-resolution, action-plan-verify
 **Utility**: clean, init, replan
+**Issue Workflow**: issue:discover, issue:plan, issue:queue, issue:execute, issue:convert-to-plan, issue:from-brainstorm
+**With-File Workflows**: brainstorm-with-file, debug-with-file, analyze-with-file
 
 ### Testing Commands Distinction
 
@@ -941,8 +1089,14 @@ All from `~/.claude/commands/workflow/`:
 | **tdd** | 需求 → tdd-plan → TDD任务 → execute → 代码 → tdd-verify | TDD Planning + Execution |
 | **test-fix** | 失败测试 →【test-fix-gen → test-cycle-execute】→ 测试通过 | Test Validation |
 | **test-gen** | 代码/会话 →【test-gen → execute】→ 测试通过 | Test Generation + Execution |
-| **review** | 代码 →【review-* → review-fix】→ 修复代码 →【test-fix-gen → test-cycle-execute】→ 测试通过 | Code Review + Testing |
+| **review** | 代码 →【review-* → review-cycle-fix】→ 修复代码 →【test-fix-gen → test-cycle-execute】→ 测试通过 | Code Review + Testing |
 | **brainstorm** | 探索主题 → brainstorm → 分析 →【plan → plan-verify】→ execute → test | Exploration + Planning + Execution |
 | **multi-cli** | 需求 → multi-cli-plan → 对比分析 → lite-execute → test | Multi-Perspective + Testing |
+| **issue-batch** | 代码库 →【discover → plan → queue → execute】→ 完成 issues | Issue Workflow |
+| **issue-transition** | 需求 →【lite-plan → convert-to-plan → queue → execute】→ 完成 issues | Rapid-to-Issue |
+| **brainstorm-file** | 主题 → brainstorm-with-file → brainstorm.md (自包含) | Brainstorm With File |
+| **brainstorm-to-issue** | brainstorm.md →【from-brainstorm → queue → execute】→ 完成 issues | Brainstorm to Issue |
+| **debug-file** | Bug报告 → debug-with-file → understanding.md (自包含) | Debug With File |
+| **analyze-file** | 分析主题 → analyze-with-file → discussion.md (自包含) | Analyze With File |
 
 Use `CommandRegistry.getAllCommandsSummary()` to discover all commands dynamically.

.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

@@ -24,7 +24,7 @@ Main process orchestrator: intent analysis → workflow selection → command ch
 |-----------|---------|---------|
 | **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-fix |
+| **Review** | review-cmd → fix-cmd | review-session-cycle → review-cycle-fix |
 
 **Atomic Rules**:
 1. CCW automatically groups commands into minimum units - never splits them
@@ -67,10 +67,16 @@ function analyzeIntent(input) {
 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/,
-    'multi-perspective': /multi-perspective|compare|cross-verify/,
     'quick-task': /quick|simple|small/ && /feature|function/,
     'ui-design': /ui|design|component|style/,
     'tdd': /tdd|test-driven|test first/,
@@ -111,14 +117,21 @@ async function clarifyRequirements(analysis) {
 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-fix' },
+    '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' }
   };
@@ -147,6 +160,16 @@ function buildCommandChain(workflow, analysis) {
       ])
     ],
 
+    // 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' },
@@ -179,6 +202,30 @@ function buildCommandChain(workflow, analysis) {
       { 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】
@@ -186,9 +233,9 @@ function buildCommandChain(workflow, analysis) {
       { cmd: '/workflow:plan-verify', args: '', unit: 'verified-planning' },
       // Execution
       { cmd: '/workflow:execute', args: '' },
-      // Unit: Code Review【review-session-cycle → review-fix】
+      // Unit: Code Review【review-session-cycle → review-cycle-fix】
       { cmd: '/workflow:review-session-cycle', args: '', unit: 'code-review' },
-      { cmd: '/workflow:review-fix', 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' },
@@ -210,10 +257,10 @@ function buildCommandChain(workflow, analysis) {
       { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
     ],
 
-    'review-fix': [
+    'review-cycle-fix': [
-      // Unit: Code Review【review-session-cycle → review-fix】
+      // Unit: Code Review【review-session-cycle → review-cycle-fix】
       { cmd: '/workflow:review-session-cycle', args: '', unit: 'code-review' },
-      { cmd: '/workflow:review-fix', 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' }
@@ -409,7 +456,12 @@ Phase 5: Execute Command Chain
 |-------|------|-------|-----------------------|
 | "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】|
-| "OAuth2 system" | feature (high) | 3 |【plan → plan-verify】→ execute →【review-session-cycle → review-fix】→【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】|
 
@@ -452,6 +504,29 @@ todos = [
 
 ---
 
+## 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 |
@@ -483,4 +558,10 @@ 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/codex-coordinator.md

@@ -0,0 +1,513 @@
+---
+name: codex-coordinator
+description: Command orchestration tool for Codex - analyze requirements, recommend command chain, execute sequentially with state persistence
+argument-hint: "TASK=\"<task description>\" [--depth=standard|deep] [--auto-confirm] [--verbose]"
+---
+
+# Codex Coordinator Command
+
+Interactive orchestration tool for Codex commands: analyze task → discover commands → recommend chain → execute sequentially → track state.
+
+**Execution Model**: Intelligent agent-driven workflow. Claude analyzes each phase and orchestrates command execution.
+
+## Core Concept: Minimum Execution Units (最小执行单元)
+
+### What is a Minimum Execution Unit?
+
+**Definition**: A set of commands that must execute together as an atomic group to achieve a meaningful workflow milestone. Splitting these commands breaks the logical flow and creates incomplete states.
+
+**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
+
+### Codex Minimum Execution Units
+
+**Planning + Execution Units** (规划+执行单元):
+
+| Unit Name | Commands | Purpose | Output |
+|-----------|----------|---------|--------|
+| **Quick Implementation** | lite-plan-a → execute | Lightweight plan and immediate execution | Working code |
+| **Bug Fix** | lite-fix → execute | Quick bug diagnosis and fix execution | Fixed code |
+| **Issue Workflow** | issue-discover → issue-plan → issue-queue → issue-execute | Complete issue lifecycle | Completed issues |
+| **Discovery & Analysis** | issue-discover → issue-discover-by-prompt | Issue discovery with multiple perspectives | Generated issues |
+| **Brainstorm to Execution** | brainstorm-with-file → execute | Brainstorm ideas then implement | Working code |
+
+**With-File Workflows** (文档化单元):
+
+| Unit Name | Commands | Purpose | Output |
+|-----------|----------|---------|--------|
+| **Brainstorm With File** | brainstorm-with-file | Multi-perspective ideation with documentation | brainstorm.md |
+| **Debug With File** | debug-with-file | Hypothesis-driven debugging with documentation | understanding.md |
+| **Analyze With File** | analyze-with-file | Collaborative analysis with documentation | discussion.md |
+| **Clean & Analyze** | clean → analyze-with-file | Cleanup then analyze | Cleaned code + analysis |
+
+### Command-to-Unit Mapping (命令与最小单元的映射)
+
+| Command | Precedes | Atomic Units |
+|---------|----------|--------------|
+| lite-plan-a | execute, brainstorm-with-file | Quick Implementation |
+| lite-fix | execute | Bug Fix |
+| issue-discover | issue-plan | Issue Workflow |
+| issue-plan | issue-queue | Issue Workflow |
+| issue-queue | issue-execute | Issue Workflow |
+| brainstorm-with-file | execute, issue-execute | Brainstorm to Execution |
+| debug-with-file | execute | Debug With File |
+| analyze-with-file | (standalone) | Analyze With File |
+| clean | analyze-with-file, execute | Clean & Analyze |
+| quick-plan-with-file | execute | Quick Planning with File |
+| merge-plans-with-file | execute | Merge Multiple Plans |
+| unified-execute-with-file | (terminal) | Execute with File Tracking |
+
+### Atomic Group Rules
+
+1. **Never Split Units**: Coordinator must recommend complete units, not partial chains
+2. **Multi-Unit Participation**: Some commands can participate in multiple units
+3. **User Override**: User can explicitly request partial execution (advanced mode)
+4. **Visualization**: Pipeline view shows unit boundaries with 【 】markers
+5. **Validation**: Before execution, verify all unit commands are included
+
+**Example Pipeline with Units**:
+```
+需求 → 【lite-plan-a → execute】→ 代码 → 【issue-discover → issue-plan → issue-queue → issue-execute】→ 完成
+       └──── Quick Implementation ────┘         └────────── Issue Workflow ─────────┘
+```
+
+## 3-Phase Workflow
+
+### Phase 1: Analyze Requirements
+
+Parse task to extract: goal, scope, complexity, and task type.
+
+```javascript
+function analyzeRequirements(taskDescription) {
+  return {
+    goal: extractMainGoal(taskDescription),           // e.g., "Fix login bug"
+    scope: extractScope(taskDescription),             // e.g., ["auth", "login"]
+    complexity: determineComplexity(taskDescription), // 'simple' | 'medium' | 'complex'
+    task_type: detectTaskType(taskDescription)        // See task type patterns below
+  };
+}
+
+// Task Type Detection Patterns
+function detectTaskType(text) {
+  // Priority order (first match wins)
+  if (/fix|bug|error|crash|fail|debug|diagnose/.test(text)) return 'bugfix';
+  if (/生成|generate|discover|找出|issue|问题/.test(text)) return 'discovery';
+  if (/plan|规划|设计|design|analyze|分析/.test(text)) return 'analysis';
+  if (/清理|cleanup|clean|refactor|重构/.test(text)) return 'cleanup';
+  if (/头脑|brainstorm|创意|ideation/.test(text)) return 'brainstorm';
+  if (/合并|merge|combine|batch/.test(text)) return 'batch-planning';
+  return 'feature';  // Default
+}
+
+// Complexity Assessment
+function determineComplexity(text) {
+  let score = 0;
+  if (/refactor|重构|migrate|迁移|architect|架构|system|系统/.test(text)) score += 2;
+  if (/multiple|多个|across|跨|all|所有|entire|整个/.test(text)) score += 2;
+  if (/integrate|集成|api|database|数据库/.test(text)) score += 1;
+  if (/security|安全|performance|性能|scale|扩展/.test(text)) score += 1;
+  return score >= 4 ? 'complex' : score >= 2 ? 'medium' : 'simple';
+}
+```
+
+**Display to user**:
+```
+Analysis Complete:
+  Goal: [extracted goal]
+  Scope: [identified areas]
+  Complexity: [level]
+  Task Type: [detected type]
+```
+
+### Phase 2: Discover Commands & Recommend Chain
+
+Dynamic command chain assembly using task type and complexity matching.
+
+#### Available Codex Commands (Discovery)
+
+All commands from `~/.codex/prompts/`:
+- **Planning**: @~/.codex/prompts/lite-plan-a.md, @~/.codex/prompts/lite-plan-b.md, @~/.codex/prompts/lite-plan-c.md, @~/.codex/prompts/quick-plan-with-file.md, @~/.codex/prompts/merge-plans-with-file.md
+- **Execution**: @~/.codex/prompts/execute.md, @~/.codex/prompts/unified-execute-with-file.md
+- **Bug Fixes**: @~/.codex/prompts/lite-fix.md, @~/.codex/prompts/debug-with-file.md
+- **Discovery**: @~/.codex/prompts/issue-discover.md, @~/.codex/prompts/issue-discover-by-prompt.md, @~/.codex/prompts/issue-plan.md, @~/.codex/prompts/issue-queue.md, @~/.codex/prompts/issue-execute.md
+- **Analysis**: @~/.codex/prompts/analyze-with-file.md
+- **Brainstorming**: @~/.codex/prompts/brainstorm-with-file.md, @~/.codex/prompts/brainstorm-to-cycle.md
+- **Cleanup**: @~/.codex/prompts/clean.md, @~/.codex/prompts/compact.md
+
+#### Recommendation Algorithm
+
+```javascript
+async function recommendCommandChain(analysis) {
+  // Step 1: 根据任务类型确定流程
+  const { inputPort, outputPort } = determinePortFlow(analysis.task_type, analysis.complexity);
+
+  // Step 2: Claude 根据命令特性和任务特征，智能选择命令序列
+  const chain = selectChainByTaskType(analysis);
+
+  return chain;
+}
+
+// 任务类型对应的端口流
+function determinePortFlow(taskType, complexity) {
+  const flows = {
+    'bugfix':       { flow: ['lite-fix', 'execute'], depth: complexity === 'complex' ? 'deep' : 'standard' },
+    'discovery':    { flow: ['issue-discover', 'issue-plan', 'issue-queue', 'issue-execute'], depth: 'standard' },
+    'analysis':     { flow: ['analyze-with-file'], depth: complexity === 'complex' ? 'deep' : 'standard' },
+    'cleanup':      { flow: ['clean'], depth: 'standard' },
+    'brainstorm':   { flow: ['brainstorm-with-file', 'execute'], depth: complexity === 'complex' ? 'deep' : 'standard' },
+    'batch-planning': { flow: ['merge-plans-with-file', 'execute'], depth: 'standard' },
+    'feature':      { flow: complexity === 'complex' ? ['lite-plan-b'] : ['lite-plan-a', 'execute'], depth: complexity === 'complex' ? 'deep' : 'standard' }
+  };
+  return flows[taskType] || flows['feature'];
+}
+```
+
+#### Display to User
+
+```
+Recommended Command Chain:
+
+Pipeline (管道视图):
+需求 → @~/.codex/prompts/lite-plan-a.md → 计划 → @~/.codex/prompts/execute.md → 代码完成
+
+Commands (命令列表):
+1. @~/.codex/prompts/lite-plan-a.md
+2. @~/.codex/prompts/execute.md
+
+Proceed? [Confirm / Show Details / Adjust / Cancel]
+```
+
+### Phase 2b: Get User Confirmation
+
+Ask user for confirmation before proceeding with execution.
+
+```javascript
+async function getUserConfirmation(chain) {
+  const response = await AskUserQuestion({
+    questions: [{
+      question: 'Proceed with this command chain?',
+      header: 'Confirm Chain',
+      multiSelect: false,
+      options: [
+        { label: 'Confirm and execute', description: 'Proceed with commands' },
+        { label: 'Show details', description: 'View each command' },
+        { label: 'Adjust chain', description: 'Remove or reorder' },
+        { label: 'Cancel', description: 'Abort' }
+      ]
+    }]
+  });
+
+  return response;
+}
+```
+
+### Phase 3: Execute Sequential Command Chain
+
+```javascript
+async function executeCommandChain(chain, analysis) {
+  const sessionId = `codex-coord-${Date.now()}`;
+  const stateDir = `.workflow/.codex-coordinator/${sessionId}`;
+
+  // Create state directory
+  const state = {
+    session_id: sessionId,
+    status: 'running',
+    created_at: new Date().toISOString(),
+    analysis: analysis,
+    command_chain: chain.map((cmd, idx) => ({ ...cmd, index: idx, status: 'pending' })),
+    execution_results: [],
+  };
+
+  // Save initial state
+  Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
+
+  for (let i = 0; i < chain.length; i++) {
+    const cmd = chain[i];
+    console.log(`[${i+1}/${chain.length}] Executing: @~/.codex/prompts/${cmd.name}.md`);
+
+    // Update status to running
+    state.command_chain[i].status = 'running';
+    state.updated_at = new Date().toISOString();
+    Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
+
+    try {
+      // Build command with parameters using full path
+      let commandStr = `@~/.codex/prompts/${cmd.name}.md`;
+
+      // Add parameters based on previous results and task context
+      if (i > 0 && state.execution_results.length > 0) {
+        const lastResult = state.execution_results[state.execution_results.length - 1];
+        commandStr += ` --resume="${lastResult.session_id || lastResult.artifact}"`;
+      }
+
+      // For analysis-based commands, add depth parameter
+      if (analysis.complexity === 'complex' && (cmd.name.includes('analyze') || cmd.name.includes('plan'))) {
+        commandStr += ` --depth=deep`;
+      }
+
+      // Add task description for planning commands
+      if (cmd.type === 'planning' && i === 0) {
+        commandStr += ` TASK="${analysis.goal}"`;
+      }
+
+      // Execute command via Bash (spawning as background task)
+      // Format: @~/.codex/prompts/command-name.md [] parameters
+      // Note: This simulates the execution; actual implementation uses hook callbacks
+      console.log(`Executing: ${commandStr}`);
+
+      // Save execution record
+      state.execution_results.push({
+        index: i,
+        command: cmd.name,
+        status: 'in-progress',
+        started_at: new Date().toISOString(),
+        session_id: null,
+        artifact: null
+      });
+
+      state.command_chain[i].status = 'completed';
+      state.updated_at = new Date().toISOString();
+      Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
+
+      console.log(`[${i+1}/${chain.length}] ✓ Completed: @~/.codex/prompts/${cmd.name}.md`);
+
+    } catch (error) {
+      state.command_chain[i].status = 'failed';
+      state.updated_at = new Date().toISOString();
+      Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
+
+      console.log(`❌ Command failed: ${error.message}`);
+      break;
+    }
+  }
+
+  state.status = 'completed';
+  state.updated_at = new Date().toISOString();
+  Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
+
+  console.log(`\n✅ Orchestration Complete: ${state.session_id}`);
+  return state;
+}
+```
+
+## State File Structure
+
+**Location**: `.workflow/.codex-coordinator/{session_id}/state.json`
+
+```json
+{
+  "session_id": "codex-coord-20250129-143025",
+  "status": "running|waiting|completed|failed",
+  "created_at": "2025-01-29T14:30:25Z",
+  "updated_at": "2025-01-29T14:35:45Z",
+  "analysis": {
+    "goal": "Fix login authentication bug",
+    "scope": ["auth", "login"],
+    "complexity": "medium",
+    "task_type": "bugfix"
+  },
+  "command_chain": [
+    {
+      "index": 0,
+      "name": "lite-fix",
+      "type": "bugfix",
+      "status": "completed"
+    },
+    {
+      "index": 1,
+      "name": "execute",
+      "type": "execution",
+      "status": "pending"
+    }
+  ],
+  "execution_results": [
+    {
+      "index": 0,
+      "command": "lite-fix",
+      "status": "completed",
+      "started_at": "2025-01-29T14:30:25Z",
+      "session_id": "fix-login-2025-01-29",
+      "artifact": ".workflow/.lite-fix/fix-login-2025-01-29/fix-plan.json"
+    }
+  ]
+}
+```
+
+### Status Values
+
+- `running`: Orchestrator actively executing
+- `waiting`: Paused, waiting for external events
+- `completed`: All commands finished successfully
+- `failed`: Error occurred or user aborted
+
+## Task Type Routing (Pipeline Summary)
+
+**Note**: 【 】marks Minimum Execution Units (最小执行单元) - these commands must execute together.
+
+| Task Type | Pipeline | Minimum Units |
+|-----------|----------|---|
+| **bugfix** | Bug报告 →【@~/.codex/prompts/lite-fix.md → @~/.codex/prompts/execute.md】→ 修复代码 | Bug Fix |
+| **discovery** | 需求 →【@~/.codex/prompts/issue-discover.md → @~/.codex/prompts/issue-plan.md → @~/.codex/prompts/issue-queue.md → @~/.codex/prompts/issue-execute.md】→ 完成 issues | Issue Workflow |
+| **analysis** | 需求 → @~/.codex/prompts/analyze-with-file.md → 分析报告 | Analyze With File |
+| **cleanup** | 代码库 → @~/.codex/prompts/clean.md → 清理完成 | Cleanup |
+| **brainstorm** | 主题 →【@~/.codex/prompts/brainstorm-with-file.md → @~/.codex/prompts/execute.md】→ 实现代码 | Brainstorm to Execution |
+| **batch-planning** | 需求集合 →【@~/.codex/prompts/merge-plans-with-file.md → @~/.codex/prompts/execute.md】→ 代码完成 | Merge Multiple Plans |
+| **feature** (simple) | 需求 →【@~/.codex/prompts/lite-plan-a.md → @~/.codex/prompts/execute.md】→ 代码 | Quick Implementation |
+| **feature** (complex) | 需求 → @~/.codex/prompts/lite-plan-b.md → 详细计划 → @~/.codex/prompts/execute.md → 代码 | Complex Planning |
+
+## Available Commands Reference
+
+### Planning Commands
+
+| Command | Purpose | Usage | Output |
+|---------|---------|-------|--------|
+| **lite-plan-a** | Lightweight merged-mode planning | `@~/.codex/prompts/lite-plan-a.md TASK="..."` | plan.json |
+| **lite-plan-b** | Multi-angle exploration planning | `@~/.codex/prompts/lite-plan-b.md TASK="..."` | plan.json |
+| **lite-plan-c** | Parallel angle planning | `@~/.codex/prompts/lite-plan-c.md TASK="..."` | plan.json |
+| **quick-plan-with-file** | Quick planning with file tracking | `@~/.codex/prompts/quick-plan-with-file.md TASK="..."` | plan + docs |
+| **merge-plans-with-file** | Merge multiple plans | `@~/.codex/prompts/merge-plans-with-file.md PLANS="..."` | merged-plan.json |
+
+### Execution Commands
+
+| Command | Purpose | Usage | Output |
+|---------|---------|-------|--------|
+| **execute** | Execute tasks from plan | `@~/.codex/prompts/execute.md SESSION=".../plan/"` | Working code |
+| **unified-execute-with-file** | Execute with file tracking | `@~/.codex/prompts/unified-execute-with-file.md SESSION="..."` | Code + tracking |
+
+### Bug Fix Commands
+
+| Command | Purpose | Usage | Output |
+|---------|---------|-------|--------|
+| **lite-fix** | Quick bug diagnosis and planning | `@~/.codex/prompts/lite-fix.md BUG="..."` | fix-plan.json |
+| **debug-with-file** | Hypothesis-driven debugging | `@~/.codex/prompts/debug-with-file.md BUG="..."` | understanding.md |
+
+### Discovery Commands
+
+| Command | Purpose | Usage | Output |
+|---------|---------|-------|--------|
+| **issue-discover** | Multi-perspective issue discovery | `@~/.codex/prompts/issue-discover.md PATTERN="src/**"` | issues.jsonl |
+| **issue-discover-by-prompt** | Prompt-based discovery | `@~/.codex/prompts/issue-discover-by-prompt.md PROMPT="..."` | issues |
+| **issue-plan** | Plan issue solutions | `@~/.codex/prompts/issue-plan.md --all-pending` | issue-plans.json |
+| **issue-queue** | Form execution queue | `@~/.codex/prompts/issue-queue.md --from-plan` | queue.json |
+| **issue-execute** | Execute issue queue | `@~/.codex/prompts/issue-execute.md QUEUE="..."` | Completed |
+
+### Analysis Commands
+
+| Command | Purpose | Usage | Output |
+|---------|---------|-------|--------|
+| **analyze-with-file** | Collaborative analysis | `@~/.codex/prompts/analyze-with-file.md TOPIC="..."` | discussion.md |
+
+### Brainstorm Commands
+
+| Command | Purpose | Usage | Output |
+|---------|---------|-------|--------|
+| **brainstorm-with-file** | Multi-perspective brainstorming | `@~/.codex/prompts/brainstorm-with-file.md TOPIC="..."` | brainstorm.md |
+| **brainstorm-to-cycle** | Bridge brainstorm to execution | `@~/.codex/prompts/brainstorm-to-cycle.md` | Executable plan |
+
+### Utility Commands
+
+| Command | Purpose | Usage | Output |
+|---------|---------|-------|--------|
+| **clean** | Intelligent code cleanup | `@~/.codex/prompts/clean.md` | Cleaned code |
+| **compact** | Compact session memory | `@~/.codex/prompts/compact.md SESSION="..."` | Compressed state |
+
+## Execution Flow
+
+```
+User Input: TASK="..."
+    ↓
+Phase 1: analyzeRequirements(task)
+    ↓
+Phase 2: recommendCommandChain(analysis)
+         Display pipeline and commands
+    ↓
+User Confirmation
+    ↓
+Phase 3: executeCommandChain(chain, analysis)
+    ├─ For each command:
+    │  ├─ Update state to "running"
+    │  ├─ Build command string with parameters
+    │  ├─ Execute @command [] with parameters
+    │  ├─ Save execution results
+    │  └─ Update state to "completed"
+    ↓
+Output completion summary
+```
+
+## Key Design Principles
+
+1. **Atomic Execution** - Never split minimum execution units
+2. **State Persistence** - All state saved to JSON
+3. **User Control** - Confirmation before execution
+4. **Context Passing** - Parameters chain across commands
+5. **Resume Support** - Can resume from state.json
+6. **Intelligent Routing** - Task type determines command chain
+7. **Complexity Awareness** - Different paths for simple vs complex tasks
+
+## Command Invocation Format
+
+**Format**: `@~/.codex/prompts/<command-name>.md <parameters>`
+
+**Examples**:
+```bash
+@~/.codex/prompts/lite-plan-a.md TASK="Implement user authentication"
+@~/.codex/prompts/execute.md SESSION=".workflow/.lite-plan/..."
+@~/.codex/prompts/lite-fix.md BUG="Login fails with 404 error"
+@~/.codex/prompts/issue-discover.md PATTERN="src/auth/**"
+@~/.codex/prompts/brainstorm-with-file.md TOPIC="Improve user onboarding"
+```
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Unknown task type | Default to feature implementation |
+| Command not found | Error: command not available |
+| Execution fails | Report error, offer retry or skip |
+| Invalid parameters | Validate and ask for correction |
+| Circular dependency | Detect and report |
+| All commands fail | Report and suggest manual intervention |
+
+## Session Management
+
+**Resume Previous Session**:
+```
+1. Find session in .workflow/.codex-coordinator/
+2. Load state.json
+3. Identify last completed command
+4. Restart from next pending command
+```
+
+**View Session Progress**:
+```
+cat .workflow/.codex-coordinator/{session-id}/state.json
+```
+
+---
+
+## Execution Instructions
+
+The coordinator workflow follows these steps:
+
+1. **Parse Input**: Extract task description from TASK parameter
+2. **Analyze**: Determine goal, scope, complexity, and task type
+3. **Recommend**: Build optimal command chain based on analysis
+4. **Confirm**: Display pipeline and request user approval
+5. **Execute**: Run commands sequentially with state tracking
+6. **Report**: Display final results and artifacts
+
+To use this coordinator, invoke it as a Claude Code command (not a Codex command):
+
+From the Claude Code CLI, you would call Codex commands like:
+```bash
+@~/.codex/prompts/lite-plan-a.md TASK="Your task description"
+```
+
+Or with options:
+```bash
+@~/.codex/prompts/lite-plan-a.md TASK="..." --depth=deep
+```
+
+This coordinator orchestrates such Codex commands based on your task requirements.

.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/flow-create.md

@@ -0,0 +1,675 @@
+# Flow Template Generator
+
+Generate workflow templates for meta-skill/flow-coordinator.
+
+## Usage
+
+```
+/meta-skill:flow-create [template-name] [--output <path>]
+```
+
+**Examples**:
+```bash
+/meta-skill:flow-create bugfix-v2
+/meta-skill:flow-create my-workflow --output ~/.claude/skills/my-skill/templates/
+```
+
+## Execution Flow
+
+```
+User Input → Phase 1: Template Design → Phase 2: Step Definition → Phase 3: Generate JSON
+                ↓                            ↓                           ↓
+         Name + Description           Define workflow steps        Write template file
+```
+
+---
+
+## Phase 1: Template Design
+
+Gather basic template information:
+
+```javascript
+async function designTemplate(input) {
+  const templateName = parseTemplateName(input) || await askTemplateName();
+
+  const metadata = await AskUserQuestion({
+    questions: [
+      {
+        question: "What is the purpose of this workflow template?",
+        header: "Purpose",
+        options: [
+          { label: "Feature Development", description: "Implement new features with planning and testing" },
+          { label: "Bug Fix", description: "Diagnose and fix bugs with verification" },
+          { label: "TDD Development", description: "Test-driven development workflow" },
+          { label: "Code Review", description: "Review cycle with findings and fixes" },
+          { label: "Testing", description: "Test generation and validation" },
+          { label: "Issue Workflow", description: "Complete issue lifecycle (discover → plan → queue → execute)" },
+          { label: "With-File Workflow", description: "Documented exploration (brainstorm/debug/analyze)" },
+          { label: "Custom", description: "Define custom workflow purpose" }
+        ],
+        multiSelect: false
+      },
+      {
+        question: "What complexity level?",
+        header: "Level",
+        options: [
+          { label: "Level 1 (Rapid)", description: "1-2 steps, ultra-lightweight (lite-lite-lite)" },
+          { label: "Level 2 (Lightweight)", description: "2-4 steps, quick implementation" },
+          { label: "Level 3 (Standard)", description: "4-6 steps, with verification and testing" },
+          { label: "Level 4 (Full)", description: "6+ steps, brainstorm + full workflow" }
+        ],
+        multiSelect: false
+      }
+    ]
+  });
+
+  return {
+    name: templateName,
+    description: generateDescription(templateName, metadata.Purpose),
+    level: parseLevel(metadata.Level),
+    purpose: metadata.Purpose
+  };
+}
+```
+
+---
+
+## Phase 2: Step Definition
+
+### Step 2.1: Select Command Category
+
+```javascript
+async function selectCommandCategory() {
+  return await AskUserQuestion({
+    questions: [{
+      question: "Select command category",
+      header: "Category",
+      options: [
+        { label: "Planning", description: "lite-plan, plan, multi-cli-plan, tdd-plan, quick-plan-with-file" },
+        { label: "Execution", description: "lite-execute, execute, unified-execute-with-file" },
+        { label: "Testing", description: "test-fix-gen, test-cycle-execute, test-gen, tdd-verify" },
+        { label: "Review", description: "review-session-cycle, review-module-cycle, review-cycle-fix" },
+        { label: "Bug Fix", description: "lite-fix, debug-with-file" },
+        { label: "Brainstorm", description: "brainstorm-with-file, brainstorm:auto-parallel" },
+        { label: "Analysis", description: "analyze-with-file" },
+        { label: "Issue", description: "discover, plan, queue, execute, from-brainstorm, convert-to-plan" },
+        { label: "Utility", description: "clean, init, replan, status" }
+      ],
+      multiSelect: false
+    }]
+  });
+}
+```
+
+### Step 2.2: Select Specific Command
+
+```javascript
+async function selectCommand(category) {
+  const commandOptions = {
+    'Planning': [
+      { label: "/workflow:lite-plan", description: "Lightweight merged-mode planning" },
+      { label: "/workflow:plan", description: "Full planning with architecture design" },
+      { label: "/workflow:multi-cli-plan", description: "Multi-CLI collaborative planning (Gemini+Codex+Claude)" },
+      { label: "/workflow:tdd-plan", description: "TDD workflow planning with Red-Green-Refactor" },
+      { label: "/workflow:quick-plan-with-file", description: "Rapid planning with minimal docs" },
+      { label: "/workflow:plan-verify", description: "Verify plan against requirements" },
+      { label: "/workflow:replan", description: "Update plan and execute changes" }
+    ],
+    'Execution': [
+      { label: "/workflow:lite-execute", description: "Execute from in-memory plan" },
+      { label: "/workflow:execute", description: "Execute from planning session" },
+      { label: "/workflow:unified-execute-with-file", description: "Universal execution engine" },
+      { label: "/workflow:lite-lite-lite", description: "Ultra-lightweight multi-tool execution" }
+    ],
+    'Testing': [
+      { label: "/workflow:test-fix-gen", description: "Generate test tasks for specific issues" },
+      { label: "/workflow:test-cycle-execute", description: "Execute iterative test-fix cycle (>=95% pass)" },
+      { label: "/workflow:test-gen", description: "Generate comprehensive test suite" },
+      { label: "/workflow:tdd-verify", description: "Verify TDD workflow compliance" }
+    ],
+    'Review': [
+      { label: "/workflow:review-session-cycle", description: "Session-based multi-dimensional code review" },
+      { label: "/workflow:review-module-cycle", description: "Module-focused code review" },
+      { label: "/workflow:review-cycle-fix", description: "Fix review findings with prioritization" },
+      { label: "/workflow:review", description: "Post-implementation review" }
+    ],
+    'Bug Fix': [
+      { label: "/workflow:lite-fix", description: "Lightweight bug diagnosis and fix" },
+      { label: "/workflow:debug-with-file", description: "Hypothesis-driven debugging with documentation" }
+    ],
+    'Brainstorm': [
+      { label: "/workflow:brainstorm-with-file", description: "Multi-perspective ideation with documentation" },
+      { label: "/workflow:brainstorm:auto-parallel", description: "Parallel multi-role brainstorming" }
+    ],
+    'Analysis': [
+      { label: "/workflow:analyze-with-file", description: "Collaborative analysis with documentation" }
+    ],
+    'Issue': [
+      { label: "/issue:discover", description: "Multi-perspective issue discovery" },
+      { label: "/issue:discover-by-prompt", description: "Prompt-based issue discovery with Gemini" },
+      { label: "/issue:plan", description: "Plan issue solutions" },
+      { label: "/issue:queue", description: "Form execution queue with conflict analysis" },
+      { label: "/issue:execute", description: "Execute issue queue with DAG orchestration" },
+      { label: "/issue:from-brainstorm", description: "Convert brainstorm to issue" },
+      { label: "/issue:convert-to-plan", description: "Convert planning artifacts to issue solutions" }
+    ],
+    'Utility': [
+      { label: "/workflow:clean", description: "Intelligent code cleanup" },
+      { label: "/workflow:init", description: "Initialize project-level state" },
+      { label: "/workflow:replan", description: "Interactive workflow replanning" },
+      { label: "/workflow:status", description: "Generate workflow status views" }
+    ]
+  };
+
+  return await AskUserQuestion({
+    questions: [{
+      question: `Select ${category} command`,
+      header: "Command",
+      options: commandOptions[category] || commandOptions['Planning'],
+      multiSelect: false
+    }]
+  });
+}
+```
+
+### Step 2.3: Select Execution Unit
+
+```javascript
+async function selectExecutionUnit() {
+  return await AskUserQuestion({
+    questions: [{
+      question: "Select execution unit (atomic command group)",
+      header: "Unit",
+      options: [
+        // Planning + Execution Units
+        { label: "quick-implementation", description: "【lite-plan → lite-execute】" },
+        { label: "multi-cli-planning", description: "【multi-cli-plan → lite-execute】" },
+        { label: "full-planning-execution", description: "【plan → execute】" },
+        { label: "verified-planning-execution", description: "【plan → plan-verify → execute】" },
+        { label: "replanning-execution", description: "【replan → execute】" },
+        { label: "tdd-planning-execution", description: "【tdd-plan → execute】" },
+        // Testing Units
+        { label: "test-validation", description: "【test-fix-gen → test-cycle-execute】" },
+        { label: "test-generation-execution", description: "【test-gen → execute】" },
+        // Review Units
+        { label: "code-review", description: "【review-*-cycle → review-cycle-fix】" },
+        // Bug Fix Units
+        { label: "bug-fix", description: "【lite-fix → lite-execute】" },
+        // Issue Units
+        { label: "issue-workflow", description: "【discover → plan → queue → execute】" },
+        { label: "rapid-to-issue", description: "【lite-plan → convert-to-plan → queue → execute】" },
+        { label: "brainstorm-to-issue", description: "【from-brainstorm → queue → execute】" },
+        // With-File Units (self-contained)
+        { label: "brainstorm-with-file", description: "Self-contained brainstorming workflow" },
+        { label: "debug-with-file", description: "Self-contained debugging workflow" },
+        { label: "analyze-with-file", description: "Self-contained analysis workflow" },
+        // Standalone
+        { label: "standalone", description: "Single command, no atomic grouping" }
+      ],
+      multiSelect: false
+    }]
+  });
+}
+```
+
+### Step 2.4: Select Execution Mode
+
+```javascript
+async function selectExecutionMode() {
+  return await AskUserQuestion({
+    questions: [{
+      question: "Execution mode for this step?",
+      header: "Mode",
+      options: [
+        { label: "mainprocess", description: "Run in main process (blocking, synchronous)" },
+        { label: "async", description: "Run asynchronously (background, hook callbacks)" }
+      ],
+      multiSelect: false
+    }]
+  });
+}
+```
+
+### Complete Step Definition Flow
+
+```javascript
+async function defineSteps(templateDesign) {
+  // Suggest steps based on purpose
+  const suggestedSteps = getSuggestedSteps(templateDesign.purpose);
+
+  const customize = await AskUserQuestion({
+    questions: [{
+      question: "Use suggested steps or customize?",
+      header: "Steps",
+      options: [
+        { label: "Use Suggested", description: `Suggested: ${suggestedSteps.map(s => s.cmd).join(' → ')}` },
+        { label: "Customize", description: "Modify or add custom steps" },
+        { label: "Start Empty", description: "Define all steps from scratch" }
+      ],
+      multiSelect: false
+    }]
+  });
+
+  if (customize.Steps === "Use Suggested") {
+    return suggestedSteps;
+  }
+
+  // Interactive step definition
+  const steps = [];
+  let addMore = true;
+  while (addMore) {
+    const category = await selectCommandCategory();
+    const command = await selectCommand(category.Category);
+    const unit = await selectExecutionUnit();
+    const execMode = await selectExecutionMode();
+    const contextHint = await askContextHint(command.Command);
+
+    steps.push({
+      cmd: command.Command,
+      args: command.Command.includes('plan') || command.Command.includes('fix') ? '"{{goal}}"' : undefined,
+      unit: unit.Unit,
+      execution: {
+        type: "slash-command",
+        mode: execMode.Mode
+      },
+      contextHint: contextHint
+    });
+
+    const continueAdding = await AskUserQuestion({
+      questions: [{
+        question: `Added step ${steps.length}: ${command.Command}. Add another?`,
+        header: "Continue",
+        options: [
+          { label: "Add More", description: "Define another step" },
+          { label: "Done", description: "Finish step definition" }
+        ],
+        multiSelect: false
+      }]
+    });
+    addMore = continueAdding.Continue === "Add More";
+  }
+
+  return steps;
+}
+```
+
+---
+
+## Suggested Step Templates
+
+### Feature Development (Level 2 - Rapid)
+```json
+{
+  "name": "rapid",
+  "description": "Quick implementation with testing",
+  "level": 2,
+  "steps": [
+    { "cmd": "/workflow:lite-plan", "args": "\"{{goal}}\"", "unit": "quick-implementation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create lightweight implementation plan" },
+    { "cmd": "/workflow:lite-execute", "args": "--in-memory", "unit": "quick-implementation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Execute implementation based on plan" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test tasks" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle until pass rate >= 95%" }
+  ]
+}
+```
+
+### Feature Development (Level 3 - Coupled)
+```json
+{
+  "name": "coupled",
+  "description": "Full workflow with verification, review, and testing",
+  "level": 3,
+  "steps": [
+    { "cmd": "/workflow:plan", "args": "\"{{goal}}\"", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create detailed implementation plan" },
+    { "cmd": "/workflow:plan-verify", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify plan against requirements" },
+    { "cmd": "/workflow:execute", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute implementation" },
+    { "cmd": "/workflow:review-session-cycle", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Multi-dimensional code review" },
+    { "cmd": "/workflow:review-cycle-fix", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Fix review findings" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test tasks" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle" }
+  ]
+}
+```
+
+### Bug Fix (Level 2)
+```json
+{
+  "name": "bugfix",
+  "description": "Bug diagnosis and fix with testing",
+  "level": 2,
+  "steps": [
+    { "cmd": "/workflow:lite-fix", "args": "\"{{goal}}\"", "unit": "bug-fix", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Diagnose and plan bug fix" },
+    { "cmd": "/workflow:lite-execute", "args": "--in-memory", "unit": "bug-fix", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Execute bug fix" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate regression tests" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Verify fix with tests" }
+  ]
+}
+```
+
+### Bug Fix Hotfix (Level 2)
+```json
+{
+  "name": "bugfix-hotfix",
+  "description": "Urgent production bug fix (no tests)",
+  "level": 2,
+  "steps": [
+    { "cmd": "/workflow:lite-fix", "args": "--hotfix \"{{goal}}\"", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Emergency hotfix mode" }
+  ]
+}
+```
+
+### TDD Development (Level 3)
+```json
+{
+  "name": "tdd",
+  "description": "Test-driven development with Red-Green-Refactor",
+  "level": 3,
+  "steps": [
+    { "cmd": "/workflow:tdd-plan", "args": "\"{{goal}}\"", "unit": "tdd-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create TDD task chain" },
+    { "cmd": "/workflow:execute", "unit": "tdd-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute TDD cycle" },
+    { "cmd": "/workflow:tdd-verify", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify TDD compliance" }
+  ]
+}
+```
+
+### Code Review (Level 3)
+```json
+{
+  "name": "review",
+  "description": "Code review cycle with fixes and testing",
+  "level": 3,
+  "steps": [
+    { "cmd": "/workflow:review-session-cycle", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Multi-dimensional code review" },
+    { "cmd": "/workflow:review-cycle-fix", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Fix review findings" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate tests for fixes" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Verify fixes pass tests" }
+  ]
+}
+```
+
+### Test Fix (Level 3)
+```json
+{
+  "name": "test-fix",
+  "description": "Fix failing tests",
+  "level": 3,
+  "steps": [
+    { "cmd": "/workflow:test-fix-gen", "args": "\"{{goal}}\"", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test fix tasks" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle" }
+  ]
+}
+```
+
+### Issue Workflow (Level Issue)
+```json
+{
+  "name": "issue",
+  "description": "Complete issue lifecycle",
+  "level": "Issue",
+  "steps": [
+    { "cmd": "/issue:discover", "unit": "issue-workflow", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Discover issues from codebase" },
+    { "cmd": "/issue:plan", "args": "--all-pending", "unit": "issue-workflow", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Plan issue solutions" },
+    { "cmd": "/issue:queue", "unit": "issue-workflow", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Form execution queue" },
+    { "cmd": "/issue:execute", "unit": "issue-workflow", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute issue queue" }
+  ]
+}
+```
+
+### Rapid to Issue (Level 2.5)
+```json
+{
+  "name": "rapid-to-issue",
+  "description": "Bridge lightweight planning to issue workflow",
+  "level": 2,
+  "steps": [
+    { "cmd": "/workflow:lite-plan", "args": "\"{{goal}}\"", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create lightweight plan" },
+    { "cmd": "/issue:convert-to-plan", "args": "--latest-lite-plan -y", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Convert to issue plan" },
+    { "cmd": "/issue:queue", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Form execution queue" },
+    { "cmd": "/issue:execute", "args": "--queue auto", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute issue queue" }
+  ]
+}
+```
+
+### Brainstorm to Issue (Level 4)
+```json
+{
+  "name": "brainstorm-to-issue",
+  "description": "Bridge brainstorm session to issue workflow",
+  "level": 4,
+  "steps": [
+    { "cmd": "/issue:from-brainstorm", "args": "SESSION=\"{{session}}\" --auto", "unit": "brainstorm-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Convert brainstorm to issue" },
+    { "cmd": "/issue:queue", "unit": "brainstorm-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Form execution queue" },
+    { "cmd": "/issue:execute", "args": "--queue auto", "unit": "brainstorm-to-issue", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute issue queue" }
+  ]
+}
+```
+
+### With-File: Brainstorm (Level 4)
+```json
+{
+  "name": "brainstorm",
+  "description": "Multi-perspective ideation with documentation",
+  "level": 4,
+  "steps": [
+    { "cmd": "/workflow:brainstorm-with-file", "args": "\"{{goal}}\"", "unit": "brainstorm-with-file", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Multi-CLI brainstorming with documented diverge-converge cycles" }
+  ]
+}
+```
+
+### With-File: Debug (Level 3)
+```json
+{
+  "name": "debug",
+  "description": "Hypothesis-driven debugging with documentation",
+  "level": 3,
+  "steps": [
+    { "cmd": "/workflow:debug-with-file", "args": "\"{{goal}}\"", "unit": "debug-with-file", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Hypothesis-driven debugging with Gemini validation" }
+  ]
+}
+```
+
+### With-File: Analyze (Level 3)
+```json
+{
+  "name": "analyze",
+  "description": "Collaborative analysis with documentation",
+  "level": 3,
+  "steps": [
+    { "cmd": "/workflow:analyze-with-file", "args": "\"{{goal}}\"", "unit": "analyze-with-file", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Multi-round collaborative analysis with CLI exploration" }
+  ]
+}
+```
+
+### Full Workflow (Level 4)
+```json
+{
+  "name": "full",
+  "description": "Complete workflow: brainstorm → plan → execute → test",
+  "level": 4,
+  "steps": [
+    { "cmd": "/workflow:brainstorm:auto-parallel", "args": "\"{{goal}}\"", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Parallel multi-perspective brainstorming" },
+    { "cmd": "/workflow:plan", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create detailed plan from brainstorm" },
+    { "cmd": "/workflow:plan-verify", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify plan quality" },
+    { "cmd": "/workflow:execute", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute implementation" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate comprehensive tests" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test cycle" }
+  ]
+}
+```
+
+### Multi-CLI Planning (Level 3)
+```json
+{
+  "name": "multi-cli-plan",
+  "description": "Multi-CLI collaborative planning with cross-verification",
+  "level": 3,
+  "steps": [
+    { "cmd": "/workflow:multi-cli-plan", "args": "\"{{goal}}\"", "unit": "multi-cli-planning", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Gemini+Codex+Claude collaborative planning" },
+    { "cmd": "/workflow:lite-execute", "args": "--in-memory", "unit": "multi-cli-planning", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Execute converged plan" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate tests" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test cycle" }
+  ]
+}
+```
+
+### Ultra-Lightweight (Level 1)
+```json
+{
+  "name": "lite-lite-lite",
+  "description": "Ultra-lightweight multi-tool execution",
+  "level": 1,
+  "steps": [
+    { "cmd": "/workflow:lite-lite-lite", "args": "\"{{goal}}\"", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Direct execution with minimal overhead" }
+  ]
+}
+```
+
+---
+
+## Command Port Reference
+
+Each command has input/output ports for pipeline composition:
+
+| Command | Input Port | Output Port | Atomic Unit |
+|---------|------------|-------------|-------------|
+| **Planning** |
+| lite-plan | requirement | plan | quick-implementation |
+| plan | requirement | detailed-plan | full-planning-execution |
+| plan-verify | detailed-plan | verified-plan | verified-planning-execution |
+| multi-cli-plan | requirement | multi-cli-plan | multi-cli-planning |
+| tdd-plan | requirement | tdd-tasks | tdd-planning-execution |
+| replan | session, feedback | replan | replanning-execution |
+| **Execution** |
+| lite-execute | plan, multi-cli-plan, lite-fix | code | (multiple) |
+| execute | detailed-plan, verified-plan, replan, tdd-tasks | code | (multiple) |
+| **Testing** |
+| test-fix-gen | failing-tests, session | test-tasks | test-validation |
+| test-cycle-execute | test-tasks | test-passed | test-validation |
+| test-gen | code, session | test-tasks | test-generation-execution |
+| tdd-verify | code | tdd-verified | standalone |
+| **Review** |
+| review-session-cycle | code, session | review-verified | code-review |
+| review-module-cycle | module-pattern | review-verified | code-review |
+| review-cycle-fix | review-findings | fixed-code | code-review |
+| **Bug Fix** |
+| lite-fix | bug-report | lite-fix | bug-fix |
+| debug-with-file | bug-report | understanding-document | debug-with-file |
+| **With-File** |
+| brainstorm-with-file | exploration-topic | brainstorm-document | brainstorm-with-file |
+| analyze-with-file | analysis-topic | discussion-document | analyze-with-file |
+| **Issue** |
+| issue:discover | codebase | pending-issues | issue-workflow |
+| issue:plan | pending-issues | issue-plans | issue-workflow |
+| issue:queue | issue-plans, converted-plan | execution-queue | issue-workflow |
+| issue:execute | execution-queue | completed-issues | issue-workflow |
+| issue:convert-to-plan | plan | converted-plan | rapid-to-issue |
+| issue:from-brainstorm | brainstorm-document | converted-plan | brainstorm-to-issue |
+
+---
+
+## Minimum Execution Units (最小执行单元)
+
+**Definition**: Commands that must execute together as an atomic group.
+
+| Unit Name | Commands | Purpose |
+|-----------|----------|---------|
+| **quick-implementation** | lite-plan → lite-execute | Lightweight plan and execution |
+| **multi-cli-planning** | multi-cli-plan → lite-execute | Multi-perspective planning and execution |
+| **bug-fix** | lite-fix → lite-execute | Bug diagnosis and fix |
+| **full-planning-execution** | plan → execute | Detailed planning and execution |
+| **verified-planning-execution** | plan → plan-verify → execute | Planning with verification |
+| **replanning-execution** | replan → execute | Update plan and execute |
+| **tdd-planning-execution** | tdd-plan → execute | TDD planning and execution |
+| **test-validation** | test-fix-gen → test-cycle-execute | Test generation and fix cycle |
+| **test-generation-execution** | test-gen → execute | Generate and execute tests |
+| **code-review** | review-*-cycle → review-cycle-fix | Review and fix findings |
+| **issue-workflow** | discover → plan → queue → execute | Complete issue lifecycle |
+| **rapid-to-issue** | lite-plan → convert-to-plan → queue → execute | Bridge to issue workflow |
+| **brainstorm-to-issue** | from-brainstorm → queue → execute | Brainstorm to issue bridge |
+| **brainstorm-with-file** | (self-contained) | Multi-perspective ideation |
+| **debug-with-file** | (self-contained) | Hypothesis-driven debugging |
+| **analyze-with-file** | (self-contained) | Collaborative analysis |
+
+---
+
+## Phase 3: Generate JSON
+
+```javascript
+async function generateTemplate(design, steps, outputPath) {
+  const template = {
+    name: design.name,
+    description: design.description,
+    level: design.level,
+    steps: steps
+  };
+
+  const finalPath = outputPath || `~/.claude/skills/flow-coordinator/templates/${design.name}.json`;
+
+  // Write template
+  Write(finalPath, JSON.stringify(template, null, 2));
+
+  // Validate
+  const validation = validateTemplate(template);
+
+  console.log(`✅ Template created: ${finalPath}`);
+  console.log(`   Steps: ${template.steps.length}`);
+  console.log(`   Level: ${template.level}`);
+  console.log(`   Units: ${[...new Set(template.steps.map(s => s.unit))].join(', ')}`);
+
+  return { path: finalPath, template, validation };
+}
+```
+
+---
+
+## Output Format
+
+```json
+{
+  "name": "template-name",
+  "description": "Template description",
+  "level": 2,
+  "steps": [
+    {
+      "cmd": "/workflow:command",
+      "args": "\"{{goal}}\"",
+      "unit": "unit-name",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Description of what this step does"
+    }
+  ]
+}
+```
+
+---
+
+## Examples
+
+**Create a quick bugfix template**:
+```
+/meta-skill:flow-create hotfix-simple
+
+→ Purpose: Bug Fix
+→ Level: 2 (Lightweight)
+→ Steps: Use Suggested
+→ Output: ~/.claude/skills/flow-coordinator/templates/hotfix-simple.json
+```
+
+**Create a custom multi-stage workflow**:
+```
+/meta-skill:flow-create complex-feature --output ~/.claude/skills/my-project/templates/
+
+→ Purpose: Feature Development
+→ Level: 3 (Standard)
+→ Steps: Customize
+  → Step 1: /workflow:brainstorm:auto-parallel (standalone, mainprocess)
+  → Step 2: /workflow:plan (verified-planning-execution, mainprocess)
+  → Step 3: /workflow:plan-verify (verified-planning-execution, mainprocess)
+  → Step 4: /workflow:execute (verified-planning-execution, async)
+  → Step 5: /workflow:review-session-cycle (code-review, mainprocess)
+  → Step 6: /workflow:review-cycle-fix (code-review, mainprocess)
+  → Done
+→ Output: ~/.claude/skills/my-project/templates/complex-feature.json
+```

.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/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

@@ -413,5 +413,4 @@ function parseMarkdownBody(body) {
 
 ## Related Commands
 
-- `/issue:plan` - Plan solution for issue
+- `/issue:plan` - Plan solution for issue
-

.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,208 +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: "[-y|--yes] task-id"
----
-
-## Auto Mode
-
-When `--yes` or `-y`: Auto-confirm breakdown, use recommended subtask structure.
-
-# 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,441 +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: "[-y|--yes] task-id [\"text\"|file.md] | --batch [verification-report.md]"
-allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
----
-
-## Auto Mode
-
-When `--yes` or `-y`: Auto-confirm updates, use recommended changes.
-
-# 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: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,485 +0,0 @@
----
-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/ACTION_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/ACTION_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 (Token-Efficient Analysis)
-
-**Token Budget Strategy**:
-- **Total Limit**: 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 priority checks
-
-**Execution Order** (Process in sequence; skip if token budget exhausted):
-
-1. **Tier 1 (CRITICAL Path)**: A, B, C - User intent, coverage, consistency (process fully)
-2. **Tier 2 (HIGH Priority)**: D, E - Dependencies, synthesis alignment (limit 15 findings total)
-3. **Tier 3 (MEDIUM Priority)**: F - Specification quality (limit 20 findings)
-4. **Tier 4 (LOW Priority)**: G, H - Duplication, feasibility (limit 15 findings total)
-
----
-
-#### A. User Intent Alignment (CRITICAL - Tier 1)
-
-- **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/auto-parallel.md

@@ -132,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): "
+SlashCommand(command="/workflow:brainstorm:role-analysis {role-name} --session {session-id} --skip-questions")
-[FLOW_CONTROL]
-
-Execute {role-name} analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: {role-name}
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/{role}/
-TOPIC: {user-provided-topic}
-
-## Flow Control Steps
-1. load_topic_framework → .workflow/active/WFS-{session}/.brainstorming/guidance-specification.md
-2. load_role_template → ~/.claude/workflows/cli-templates/planning-roles/{role}.md
-3. load_session_metadata → .workflow/active/WFS-{session}/workflow-session.json
-4. load_style_skill (ui-designer only, if style_skill_package) → .claude/skills/style-{style_skill_package}/
-
-## Analysis Requirements
-**Primary Reference**: Original user prompt from workflow-session.json is authoritative
-**Framework Source**: Address all discussion points in guidance-specification.md from {role-name} perspective
-**Role Focus**: {role-name} domain expertise aligned with user intent
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md** (optionally with analysis-{slug}.md sub-documents)
-2. **Framework Reference**: @../guidance-specification.md
-3. **User Intent Alignment**: Validate against session_context
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with {role-name} expertise
-- Provide actionable recommendations from {role-name} perspective within analysis files
-- All output files MUST start with `analysis` prefix (no recommendations.md or other naming)
-- Reference framework document using @ notation for integration
-- Update workflow-session.json with completion status
-"
 ```
 
-**Parallel Execute**:
+**What It Does**:
-- Launch N agents simultaneously (one message with multiple Task calls)
+- Unified command execution for each role
-- Each agent task **attached** to orchestrator's TodoWrite
+- Loads topic framework from guidance-specification.md
-- All agents execute concurrently, each attaching their own analysis sub-tasks
+- Applies role-specific template and context
-- Each agent operates independently reading same guidance-specification.md
+- 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`
@@ -189,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
 [
@@ -455,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/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/collaborative-plan-with-file.md

@@ -0,0 +1,761 @@
+---
+name: workflow:collaborative-plan-with-file
+description: Unified collaborative planning with dynamic requirement splitting, parallel sub-agent exploration/understanding/planning, and automatic merge. Each agent maintains process files for full traceability.
+argument-hint: "[-y|--yes] <task description> [--max-agents=5] [--depth=normal|deep] [--merge-rule=consensus|priority]"
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-approve splits, use default merge rule, skip confirmations.
+
+# Collaborative Planning Command
+
+## Quick Start
+
+```bash
+# Basic usage
+/workflow:collaborative-plan-with-file "Implement real-time notification system"
+
+# With options
+/workflow:collaborative-plan-with-file "Refactor authentication module" --max-agents=4
+/workflow:collaborative-plan-with-file "Add payment gateway support" --depth=deep
+/workflow:collaborative-plan-with-file "Migrate to microservices" --merge-rule=priority
+```
+
+**Context Source**: ACE semantic search + Per-agent CLI exploration
+**Output Directory**: `.workflow/.planning/{session-id}/`
+**Default Max Agents**: 5 (actual count based on requirement complexity)
+**CLI Tools**: cli-lite-planning-agent (internally calls ccw cli with gemini/codex/qwen)
+**Schema**: plan-json-schema.json (sub-plans & final plan share same base schema)
+
+## Output Artifacts
+
+### Per Sub-Agent (Phase 2)
+
+| Artifact | Description |
+|----------|-------------|
+| `planning-context.md` | Evidence paths + synthesized understanding |
+| `sub-plan.json` | Sub-plan following plan-json-schema.json |
+
+### Final Output (Phase 4)
+
+| Artifact | Description |
+|----------|-------------|
+| `requirement-analysis.json` | Requirement breakdown and sub-agent assignments |
+| `conflicts.json` | Detected conflicts between sub-plans |
+| `plan.json` | Merged plan (plan-json-schema + merge_metadata) |
+| `plan.md` | Human-readable plan summary |
+
+**Agent**: `cli-lite-planning-agent` with `process_docs: true` for sub-agents
+
+## Overview
+
+Unified collaborative planning workflow that:
+
+1. **Analyzes** complex requirements and splits into sub-requirements
+2. **Spawns** parallel sub-agents, each responsible for one sub-requirement
+3. **Each agent** maintains process files: planning-refs.md + sub-plan.json
+4. **Merges** all sub-plans into unified plan.json with conflict resolution
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                         COLLABORATIVE PLANNING                           │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│  Phase 1: Requirement Analysis & Splitting                               │
+│     ├─ Analyze requirement complexity                                    │
+│     ├─ Identify 2-5 sub-requirements (focus areas)                       │
+│     └─ Write requirement-analysis.json                                   │
+│                                                                          │
+│  Phase 2: Parallel Sub-Agent Execution                                   │
+│     ┌──────────────┬──────────────┬──────────────┐                       │
+│     │   Agent 1    │   Agent 2    │   Agent N    │                       │
+├──────────────┼──────────────┼──────────────┤                       │
+│     │ planning     │ planning     │ planning     │  → planning-context.md│
+│     │ + sub-plan   │ + sub-plan   │ + sub-plan   │  → sub-plan.json      │
+│     └──────────────┴──────────────┴──────────────┘                       │
+│                                                                          │
+│  Phase 3: Cross-Verification & Conflict Detection                        │
+│     ├─ Load all sub-plan.json files                                      │
+│     ├─ Detect conflicts (effort, approach, dependencies)                 │
+│     └─ Write conflicts.json                                              │
+│                                                                          │
+│  Phase 4: Merge & Synthesis                                              │
+│     ├─ Resolve conflicts using merge-rule                                │
+│     ├─ Merge all sub-plans into unified plan                             │
+│     └─ Write plan.json + plan.md                                         │
+│                                                                          │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+## Output Structure
+
+```
+.workflow/.planning/{CPLAN-slug-YYYY-MM-DD}/
+├── requirement-analysis.json     # Phase 1: Requirement breakdown
+├── agents/                       # Phase 2: Per-agent process files
+│   ├── {focus-area-1}/
+│   │   ├── planning-context.md  # Evidence + understanding
+│   │   └── sub-plan.json        # Agent's plan for this focus area
+│   ├── {focus-area-2}/
+│   │   └── ...
+│   └── {focus-area-N}/
+│       └── ...
+├── conflicts.json                # Phase 3: Detected conflicts
+├── plan.json                     # Phase 4: Unified merged plan
+└── plan.md                       # Phase 4: Human-readable plan
+```
+
+## Implementation
+
+### Session Initialization
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const taskDescription = "$ARGUMENTS"
+const taskSlug = taskDescription.toLowerCase()
+  .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+  .substring(0, 30)
+
+const sessionId = `CPLAN-${taskSlug}-${getUtc8ISOString().substring(0, 10)}`
+const sessionFolder = `.workflow/.planning/${sessionId}`
+
+// Parse options
+const maxAgents = parseInt($ARGUMENTS.match(/--max-agents=(\d+)/)?.[1] || '5')
+const depth = $ARGUMENTS.match(/--depth=(normal|deep)/)?.[1] || 'normal'
+const mergeRule = $ARGUMENTS.match(/--merge-rule=(consensus|priority)/)?.[1] || 'consensus'
+const autoMode = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+Bash(`mkdir -p ${sessionFolder}/agents`)
+```
+
+### Phase 1: Requirement Analysis & Splitting
+
+Use CLI to analyze and split requirements:
+
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Requirement Analysis", status: "in_progress", activeForm: "Analyzing requirements" },
+  { content: "Phase 2: Parallel Agent Execution", status: "pending", activeForm: "Running agents" },
+  { content: "Phase 3: Conflict Detection", status: "pending", activeForm: "Detecting conflicts" },
+  { content: "Phase 4: Merge & Synthesis", status: "pending", activeForm: "Merging plans" }
+]})
+
+// Step 1.1: Use CLI to analyze requirement and propose splits
+Bash({
+  command: `ccw cli -p "
+PURPOSE: Analyze requirement and identify distinct sub-requirements/focus areas
+Success: 2-${maxAgents} clearly separated sub-requirements that can be planned independently
+
+TASK:
+• Understand the overall requirement: '${taskDescription}'
+• Identify major components, features, or concerns
+• Split into 2-${maxAgents} independent sub-requirements
+• Each sub-requirement should be:
+  - Self-contained (can be planned independently)
+  - Non-overlapping (minimal dependency on other sub-requirements)
+  - Roughly equal in complexity
+• For each sub-requirement, provide:
+  - focus_area: Short identifier (e.g., 'auth-backend', 'ui-components')
+  - description: What this sub-requirement covers
+  - key_concerns: Main challenges or considerations
+  - suggested_cli_tool: Which CLI tool is best suited (gemini/codex/qwen)
+
+MODE: analysis
+
+CONTEXT: @**/*
+
+EXPECTED: JSON output with structure:
+{
+  \"original_requirement\": \"...\",
+  \"complexity\": \"low|medium|high\",
+  \"sub_requirements\": [
+    {
+      \"index\": 1,
+      \"focus_area\": \"...\",
+      \"description\": \"...\",
+      \"key_concerns\": [\"...\"],
+      \"suggested_cli_tool\": \"gemini|codex|qwen\",
+      \"estimated_effort\": \"low|medium|high\"
+    }
+  ],
+  \"dependencies_between_subs\": [
+    { \"from\": 1, \"to\": 2, \"reason\": \"...\" }
+  ],
+  \"rationale\": \"Why this split was chosen\"
+}
+
+CONSTRAINTS: Maximum ${maxAgents} sub-requirements | Ensure clear boundaries
+" --tool gemini --mode analysis`,
+  run_in_background: true
+})
+
+// Wait for CLI completion and parse result
+// ... (hook callback will provide result)
+```
+
+**After CLI completes**:
+
+```javascript
+// Parse CLI output to extract sub-requirements
+const analysisResult = parseCLIOutput(cliOutput)
+const subRequirements = analysisResult.sub_requirements
+
+// Write requirement-analysis.json
+Write(`${sessionFolder}/requirement-analysis.json`, JSON.stringify({
+  session_id: sessionId,
+  original_requirement: taskDescription,
+  analysis_timestamp: getUtc8ISOString(),
+  complexity: analysisResult.complexity,
+  sub_requirements: subRequirements,
+  dependencies_between_subs: analysisResult.dependencies_between_subs,
+  rationale: analysisResult.rationale,
+  options: { maxAgents, depth, mergeRule }
+}, null, 2))
+
+// Create agent folders
+subRequirements.forEach(sub => {
+  Bash(`mkdir -p ${sessionFolder}/agents/${sub.focus_area}`)
+})
+
+// User confirmation (unless auto mode)
+if (!autoMode) {
+  AskUserQuestion({
+    questions: [{
+      question: `已识别 ${subRequirements.length} 个子需求:\n${subRequirements.map((s, i) => `${i+1}. ${s.focus_area}: ${s.description}`).join('\n')}\n\n确认开始并行规划?`,
+      header: "Confirm Split",
+      multiSelect: false,
+      options: [
+        { label: "开始规划", description: "启动并行sub-agent" },
+        { label: "调整拆分", description: "修改子需求划分" },
+        { label: "取消", description: "退出规划" }
+      ]
+    }]
+  })
+}
+```
+
+### Phase 2: Parallel Sub-Agent Execution
+
+Launch one agent per sub-requirement, each maintaining its own process files:
+
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Requirement Analysis", status: "completed", activeForm: "Analyzing requirements" },
+  { content: "Phase 2: Parallel Agent Execution", status: "in_progress", activeForm: "Running agents" },
+  ...subRequirements.map((sub, i) => ({
+    content: `  → Agent ${i+1}: ${sub.focus_area}`,
+    status: "pending",
+    activeForm: `Planning ${sub.focus_area}`
+  })),
+  { content: "Phase 3: Conflict Detection", status: "pending", activeForm: "Detecting conflicts" },
+  { content: "Phase 4: Merge & Synthesis", status: "pending", activeForm: "Merging plans" }
+]})
+
+// Launch all sub-agents in parallel
+const agentPromises = subRequirements.map((sub, index) => {
+  return Task({
+    subagent_type: "cli-lite-planning-agent",
+    run_in_background: false,
+    description: `Plan: ${sub.focus_area}`,
+    prompt: `
+## Sub-Agent Context
+
+You are planning ONE sub-requirement. Generate process docs + sub-plan.
+
+**Focus Area**: ${sub.focus_area}
+**Description**: ${sub.description}
+**Key Concerns**: ${sub.key_concerns.join(', ')}
+**CLI Tool**: ${sub.suggested_cli_tool}
+**Depth**: ${depth}
+
+## Input Context
+
+\`\`\`json
+{
+  "task_description": "${sub.description}",
+  "schema_path": "~/.claude/workflows/cli-templates/schemas/plan-json-schema.json",
+  "session": { "id": "${sessionId}", "folder": "${sessionFolder}" },
+  "process_docs": true,
+  "focus_area": "${sub.focus_area}",
+  "output_folder": "${sessionFolder}/agents/${sub.focus_area}",
+  "cli_config": { "tool": "${sub.suggested_cli_tool}" },
+  "parent_requirement": "${taskDescription}"
+}
+\`\`\`
+
+## Output Requirements
+
+Write 2 files to \`${sessionFolder}/agents/${sub.focus_area}/\`:
+1. **planning-context.md** - Evidence paths + synthesized understanding
+2. **sub-plan.json** - Plan with \`_metadata.source_agent: "${sub.focus_area}"\`
+
+See cli-lite-planning-agent documentation for file formats.
+`
+  })
+})
+
+// Wait for all agents to complete
+const agentResults = await Promise.all(agentPromises)
+```
+
+### Phase 3: Cross-Verification & Conflict Detection
+
+Load all sub-plans and detect conflicts:
+
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Requirement Analysis", status: "completed", activeForm: "Analyzing requirements" },
+  { content: "Phase 2: Parallel Agent Execution", status: "completed", activeForm: "Running agents" },
+  { content: "Phase 3: Conflict Detection", status: "in_progress", activeForm: "Detecting conflicts" },
+  { content: "Phase 4: Merge & Synthesis", status: "pending", activeForm: "Merging plans" }
+]})
+
+// Load all sub-plans
+const subPlans = subRequirements.map(sub => {
+  const planPath = `${sessionFolder}/agents/${sub.focus_area}/sub-plan.json`
+  const content = Read(planPath)
+  return {
+    focus_area: sub.focus_area,
+    index: sub.index,
+    plan: JSON.parse(content)
+  }
+})
+
+// Detect conflicts
+const conflicts = {
+  detected_at: getUtc8ISOString(),
+  total_sub_plans: subPlans.length,
+  conflicts: []
+}
+
+// 1. Effort conflicts (same task estimated differently)
+const effortConflicts = detectEffortConflicts(subPlans)
+conflicts.conflicts.push(...effortConflicts)
+
+// 2. File conflicts (multiple agents modifying same file)
+const fileConflicts = detectFileConflicts(subPlans)
+conflicts.conflicts.push(...fileConflicts)
+
+// 3. Approach conflicts (different approaches to same problem)
+const approachConflicts = detectApproachConflicts(subPlans)
+conflicts.conflicts.push(...approachConflicts)
+
+// 4. Dependency conflicts (circular or missing dependencies)
+const dependencyConflicts = detectDependencyConflicts(subPlans)
+conflicts.conflicts.push(...dependencyConflicts)
+
+// Write conflicts.json
+Write(`${sessionFolder}/conflicts.json`, JSON.stringify(conflicts, null, 2))
+
+console.log(`
+## Conflict Detection Complete
+
+**Total Sub-Plans**: ${subPlans.length}
+**Conflicts Found**: ${conflicts.conflicts.length}
+
+${conflicts.conflicts.length > 0 ? `
+### Conflicts:
+${conflicts.conflicts.map((c, i) => `
+${i+1}. **${c.type}** (${c.severity})
+   - Agents: ${c.agents_involved.join(' vs ')}
+   - Issue: ${c.description}
+   - Suggested Resolution: ${c.suggested_resolution}
+`).join('\n')}
+` : '✅ No conflicts detected - sub-plans are compatible'}
+`)
+```
+
+**Conflict Detection Functions**:
+
+```javascript
+function detectFileConflicts(subPlans) {
+  const fileModifications = {}
+  const conflicts = []
+
+  subPlans.forEach(sp => {
+    sp.plan.tasks.forEach(task => {
+      task.modification_points?.forEach(mp => {
+        if (!fileModifications[mp.file]) {
+          fileModifications[mp.file] = []
+        }
+        fileModifications[mp.file].push({
+          focus_area: sp.focus_area,
+          task_id: task.id,
+          target: mp.target,
+          change: mp.change
+        })
+      })
+    })
+  })
+
+  Object.entries(fileModifications).forEach(([file, mods]) => {
+    if (mods.length > 1) {
+      const agents = [...new Set(mods.map(m => m.focus_area))]
+      if (agents.length > 1) {
+        conflicts.push({
+          type: "file_conflict",
+          severity: "high",
+          file: file,
+          agents_involved: agents,
+          modifications: mods,
+          description: `Multiple agents modifying ${file}`,
+          suggested_resolution: "Sequence modifications or consolidate"
+        })
+      }
+    }
+  })
+
+  return conflicts
+}
+
+function detectEffortConflicts(subPlans) {
+  // Compare effort estimates across similar tasks
+  // Return conflicts where estimates differ by >50%
+  return []
+}
+
+function detectApproachConflicts(subPlans) {
+  // Analyze approaches for contradictions
+  // Return conflicts where approaches are incompatible
+  return []
+}
+
+function detectDependencyConflicts(subPlans) {
+  // Check for circular dependencies
+  // Check for missing dependencies
+  return []
+}
+```
+
+### Phase 4: Merge & Synthesis
+
+Use cli-lite-planning-agent to merge all sub-plans:
+
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Requirement Analysis", status: "completed", activeForm: "Analyzing requirements" },
+  { content: "Phase 2: Parallel Agent Execution", status: "completed", activeForm: "Running agents" },
+  { content: "Phase 3: Conflict Detection", status: "completed", activeForm: "Detecting conflicts" },
+  { content: "Phase 4: Merge & Synthesis", status: "in_progress", activeForm: "Merging plans" }
+]})
+
+// Collect all planning context documents for context
+const contextDocs = subRequirements.map(sub => {
+  const path = `${sessionFolder}/agents/${sub.focus_area}/planning-context.md`
+  return {
+    focus_area: sub.focus_area,
+    content: Read(path)
+  }
+})
+
+// Invoke planning agent to merge
+Task({
+  subagent_type: "cli-lite-planning-agent",
+  run_in_background: false,
+  description: "Merge sub-plans into unified plan",
+  prompt: `
+## Mission: Merge Multiple Sub-Plans
+
+Merge ${subPlans.length} sub-plans into a single unified plan.
+
+## Schema Reference
+
+Execute: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json
+
+The merged plan follows the SAME schema as lite-plan, with ONE additional field:
+- \`merge_metadata\`: Object containing merge-specific information
+
+## Project Context
+
+1. Read: .workflow/project-tech.json
+2. Read: .workflow/project-guidelines.json
+
+## Original Requirement
+
+${taskDescription}
+
+## Sub-Plans to Merge
+
+${subPlans.map(sp => `
+### Sub-Plan: ${sp.focus_area}
+\`\`\`json
+${JSON.stringify(sp.plan, null, 2)}
+\`\`\`
+`).join('\n')}
+
+## Planning Context Documents
+
+${contextDocs.map(cd => `
+### Context: ${cd.focus_area}
+${cd.content}
+`).join('\n')}
+
+## Detected Conflicts
+
+\`\`\`json
+${JSON.stringify(conflicts, null, 2)}
+\`\`\`
+
+## Merge Rules
+
+**Rule**: ${mergeRule}
+${mergeRule === 'consensus' ? `
+- Equal weight to all sub-plans
+- Conflicts resolved by finding middle ground
+- Combine overlapping tasks
+` : `
+- Priority based on sub-requirement index
+- Earlier agents' decisions take precedence
+- Later agents adapt to earlier decisions
+`}
+
+## Requirements
+
+1. **Task Consolidation**:
+   - Combine tasks that modify same files
+   - Preserve unique tasks from each sub-plan
+   - Ensure no task duplication
+   - Maintain clear task boundaries
+
+2. **Dependency Resolution**:
+   - Cross-reference dependencies between sub-plans
+   - Create global task ordering
+   - Handle inter-sub-plan dependencies
+
+3. **Conflict Resolution**:
+   - Apply ${mergeRule} rule to resolve conflicts
+   - Document resolution rationale
+   - Ensure no contradictions in final plan
+
+4. **Metadata Preservation**:
+   - Track which sub-plan each task originated from (source_agent field)
+   - Include merge_metadata with:
+     - merged_from: list of sub-plan focus areas
+     - conflicts_resolved: count
+     - merge_rule: ${mergeRule}
+
+## Output
+
+Write to ${sessionFolder}/plan.json following plan-json-schema.json.
+
+Add ONE extension field for merge tracking:
+
+\`\`\`json
+{
+  // ... all standard plan-json-schema fields ...
+
+  "merge_metadata": {
+    "source_session": "${sessionId}",
+    "merged_from": ["focus-area-1", "focus-area-2"],
+    "sub_plan_count": N,
+    "conflicts_detected": N,
+    "conflicts_resolved": N,
+    "merge_rule": "${mergeRule}",
+    "merged_at": "ISO-timestamp"
+  }
+}
+\`\`\`
+
+Each task should include \`source_agent\` field indicating which sub-plan it originated from.
+
+## Success Criteria
+
+- [ ] All sub-plan tasks included (or explicitly merged)
+- [ ] Conflicts resolved per ${mergeRule} rule
+- [ ] Dependencies form valid DAG (no cycles)
+- [ ] merge_metadata present
+- [ ] Schema compliance verified
+- [ ] plan.json written to ${sessionFolder}/plan.json
+`
+})
+
+// Generate human-readable plan.md
+const plan = JSON.parse(Read(`${sessionFolder}/plan.json`))
+const planMd = generatePlanMarkdown(plan, subRequirements, conflicts)
+Write(`${sessionFolder}/plan.md`, planMd)
+```
+
+**Markdown Generation**:
+
+```javascript
+function generatePlanMarkdown(plan, subRequirements, conflicts) {
+  return `# Collaborative Planning Session
+
+**Session ID**: ${plan._metadata?.session_id || sessionId}
+**Original Requirement**: ${taskDescription}
+**Created**: ${getUtc8ISOString()}
+
+---
+
+## Sub-Requirements Analyzed
+
+${subRequirements.map((sub, i) => `
+### ${i+1}. ${sub.focus_area}
+${sub.description}
+- **Key Concerns**: ${sub.key_concerns.join(', ')}
+- **Estimated Effort**: ${sub.estimated_effort}
+`).join('\n')}
+
+---
+
+## Conflict Resolution
+
+${conflicts.conflicts.length > 0 ? `
+**Conflicts Detected**: ${conflicts.conflicts.length}
+**Merge Rule**: ${mergeRule}
+
+${conflicts.conflicts.map((c, i) => `
+${i+1}. **${c.type}** - ${c.description}
+   - Resolution: ${c.suggested_resolution}
+`).join('\n')}
+` : '✅ No conflicts detected'}
+
+---
+
+## Merged Plan
+
+### Summary
+${plan.summary}
+
+### Approach
+${plan.approach}
+
+---
+
+## Tasks
+
+${plan.tasks.map((task, i) => `
+### ${task.id}: ${task.title}
+
+**Source**: ${task.source_agent || 'merged'}
+**Scope**: ${task.scope}
+**Action**: ${task.action}
+**Complexity**: ${task.effort?.complexity || 'medium'}
+
+${task.description}
+
+**Modification Points**:
+${task.modification_points?.map(mp => `- \`${mp.file}\` → ${mp.target}: ${mp.change}`).join('\n') || 'N/A'}
+
+**Implementation**:
+${task.implementation?.map((step, idx) => `${idx+1}. ${step}`).join('\n') || 'N/A'}
+
+**Acceptance Criteria**:
+${task.acceptance?.map(ac => `- ${ac}`).join('\n') || 'N/A'}
+
+**Dependencies**: ${task.depends_on?.join(', ') || 'None'}
+
+---
+`).join('\n')}
+
+## Execution
+
+\`\`\`bash
+# Execute this plan
+/workflow:unified-execute-with-file -p ${sessionFolder}/plan.json
+
+# Or with auto-confirmation
+/workflow:unified-execute-with-file -y -p ${sessionFolder}/plan.json
+\`\`\`
+
+---
+
+## Agent Process Files
+
+${subRequirements.map(sub => `
+### ${sub.focus_area}
+- Context: \`${sessionFolder}/agents/${sub.focus_area}/planning-context.md\`
+- Sub-Plan: \`${sessionFolder}/agents/${sub.focus_area}/sub-plan.json\`
+`).join('\n')}
+
+---
+
+**Generated by**: /workflow:collaborative-plan-with-file
+**Merge Rule**: ${mergeRule}
+`
+}
+```
+
+### Completion
+
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Requirement Analysis", status: "completed", activeForm: "Analyzing requirements" },
+  { content: "Phase 2: Parallel Agent Execution", status: "completed", activeForm: "Running agents" },
+  { content: "Phase 3: Conflict Detection", status: "completed", activeForm: "Detecting conflicts" },
+  { content: "Phase 4: Merge & Synthesis", status: "completed", activeForm: "Merging plans" }
+]})
+
+console.log(`
+✅ Collaborative Planning Complete
+
+**Session**: ${sessionId}
+**Sub-Agents**: ${subRequirements.length}
+**Conflicts Resolved**: ${conflicts.conflicts.length}
+
+## Output Files
+
+📁 ${sessionFolder}/
+├── requirement-analysis.json   # Requirement breakdown
+├── agents/                     # Per-agent process files
+${subRequirements.map(sub => `│   ├── ${sub.focus_area}/
+│   │   ├── planning-context.md
+│   │   └── sub-plan.json`).join('\n')}
+├── conflicts.json              # Detected conflicts
+├── plan.json                   # Unified plan (execution-ready)
+└── plan.md                     # Human-readable plan
+
+## Next Steps
+
+Execute the plan:
+\`\`\`bash
+/workflow:unified-execute-with-file -p ${sessionFolder}/plan.json
+\`\`\`
+
+Review a specific agent's work:
+\`\`\`bash
+cat ${sessionFolder}/agents/{focus-area}/planning-context.md
+\`\`\`
+`)
+```
+
+## Configuration
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--max-agents` | 5 | Maximum sub-agents to spawn |
+| `--depth` | normal | Exploration depth: normal or deep |
+| `--merge-rule` | consensus | Conflict resolution: consensus or priority |
+| `-y, --yes` | false | Auto-confirm all decisions |
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Requirement too simple | Use single-agent lite-plan instead |
+| Agent fails | Retry once, then continue with partial results |
+| Merge conflicts unresolvable | Ask user for manual resolution |
+| CLI timeout | Use fallback CLI tool |
+| File write fails | Retry with alternative path |
+
+## vs Other Planning Commands
+
+| Command | Use Case |
+|---------|----------|
+| **collaborative-plan-with-file** | Complex multi-aspect requirements needing parallel exploration |
+| lite-plan | Simple single-focus tasks |
+| multi-cli-plan | Iterative cross-verification with convergence |
+
+## Best Practices
+
+1. **Be Specific**: Detailed requirements lead to better splits
+2. **Review Process Files**: Check planning-context.md for insights
+3. **Trust the Merge**: Conflict resolution follows defined rules
+4. **Iterate if Needed**: Re-run with different --merge-rule if results unsatisfactory
+
+---
+
+**Now execute collaborative-plan-with-file for**: $ARGUMENTS

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

@@ -17,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
@@ -44,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:
@@ -216,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**
 
@@ -441,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.
 
 ---
 
@@ -647,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,331 +0,0 @@
----
-name: debug
-description: Interactive hypothesis-driven debugging with NDJSON logging, iterative until resolved
-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 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

@@ -477,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}")
 ```
 
@@ -486,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)
+- Reads and parses task JSON (requirements, acceptance, flow_control, execution_config)
-- Loads tech stack guidelines based on detected language
+- Executes pre_analysis steps (Phase 1: context gathering)
-- Executes pre_analysis steps and implementation_approach
+- 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-fix.md

@@ -37,6 +37,23 @@ Intelligent lightweight bug fixing command with dynamic workflow adaptation base
 /workflow:lite-fix -y --hotfix "生产环境数据库连接失败"   # Auto + hotfix mode
 ```
 
+## Output Artifacts
+
+| Artifact | Description |
+|----------|-------------|
+| `diagnosis-{angle}.json` | Per-angle diagnosis results (1-4 files based on severity) |
+| `diagnoses-manifest.json` | Index of all diagnosis files |
+| `planning-context.md` | Evidence paths + synthesized understanding |
+| `fix-plan.json` | Structured fix plan (fix-plan-json-schema.json) |
+
+**Output Directory**: `.workflow/.lite-fix/{bug-slug}-{YYYY-MM-DD}/`
+
+**Agent Usage**:
+- Low/Medium severity → Direct Claude planning (no agent)
+- High/Critical severity → `cli-lite-planning-agent` generates `fix-plan.json`
+
+**Schema Reference**: `~/.claude/workflows/cli-templates/schemas/fix-plan-json-schema.json`
+
 ## Auto Mode Defaults
 
 When `--yes` or `-y` flag is used:
@@ -192,11 +209,15 @@ const diagnosisTasks = selectedAngles.map((angle, index) =>
 ## Task Objective
 Execute **${angle}** diagnosis for bug root cause analysis. Analyze codebase from this specific angle to discover root cause, affected paths, and fix hints.
 
+## Output Location
+
+**Session Folder**: ${sessionFolder}
+**Output File**: ${sessionFolder}/diagnosis-${angle}.json
+
 ## Assigned Context
 - **Diagnosis Angle**: ${angle}
 - **Bug Description**: ${bug_description}
 - **Diagnosis Index**: ${index + 1} of ${selectedAngles.length}
-- **Output File**: ${sessionFolder}/diagnosis-${angle}.json
 
 ## MANDATORY FIRST STEPS (Execute by Agent)
 **You (cli-explore-agent) MUST execute these steps in order:**
@@ -225,8 +246,6 @@ Execute **${angle}** diagnosis for bug root cause analysis. Analyze codebase fro
 
 ## Expected Output
 
-**File**: ${sessionFolder}/diagnosis-${angle}.json
-
 **Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 3, follow schema exactly
 
 **Required Fields** (all ${angle} focused):
@@ -255,9 +274,9 @@ Execute **${angle}** diagnosis for bug root cause analysis. Analyze codebase fro
 - [ ] JSON output follows schema exactly
 - [ ] clarification_needs includes options + recommended
 
-## Output
+## Execution
-Write: ${sessionFolder}/diagnosis-${angle}.json
+**Write**: \`${sessionFolder}/diagnosis-${angle}.json\`
-Return: 2-3 sentence summary of ${angle} diagnosis findings
+**Return**: 2-3 sentence summary of ${angle} diagnosis findings
 `
   )
 )
@@ -493,6 +512,13 @@ Task(
   prompt=`
 Generate fix plan and write fix-plan.json.
 
+## Output Location
+
+**Session Folder**: ${sessionFolder}
+**Output Files**:
+- ${sessionFolder}/planning-context.md (evidence + understanding)
+- ${sessionFolder}/fix-plan.json (fix plan)
+
 ## Output Schema Reference
 Execute: cat ~/.claude/workflows/cli-templates/schemas/fix-plan-json-schema.json (get schema reference before generating plan)
 
@@ -588,8 +614,9 @@ Generate fix-plan.json 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)
+6. **Write**: \`${sessionFolder}/planning-context.md\` (evidence paths + understanding)
-7. Return brief completion summary
+7. **Write**: \`${sessionFolder}/fix-plan.json\`
+8. Return brief completion summary
 
 ## Output Format for CLI
 Include these sections in your fix-plan output:
@@ -747,22 +774,24 @@ SlashCommand(command="/workflow:lite-execute --in-memory --mode bugfix")
 
 ```
 .workflow/.lite-fix/{bug-slug}-{YYYY-MM-DD}/
-|- diagnosis-{angle1}.json      # Diagnosis angle 1
+├── diagnosis-{angle1}.json      # Diagnosis angle 1
-|- diagnosis-{angle2}.json      # Diagnosis angle 2
+├── diagnosis-{angle2}.json      # Diagnosis angle 2
-|- diagnosis-{angle3}.json      # Diagnosis angle 3 (if applicable)
+├── diagnosis-{angle3}.json      # Diagnosis angle 3 (if applicable)
-|- diagnosis-{angle4}.json      # Diagnosis angle 4 (if applicable)
+├── diagnosis-{angle4}.json      # Diagnosis angle 4 (if applicable)
-|- diagnoses-manifest.json      # Diagnosis index
+├── diagnoses-manifest.json      # Diagnosis index
-+- fix-plan.json                # Fix plan
+├── planning-context.md          # Evidence + understanding
+└── fix-plan.json                # Fix plan
 ```
 
 **Example**:
 ```
-.workflow/.lite-fix/user-avatar-upload-fails-413-2025-11-25-14-30-25/
+.workflow/.lite-fix/user-avatar-upload-fails-413-2025-11-25/
-|- diagnosis-error-handling.json
+├── diagnosis-error-handling.json
-|- diagnosis-dataflow.json
+├── diagnosis-dataflow.json
-|- diagnosis-validation.json
+├── diagnosis-validation.json
-|- diagnoses-manifest.json
+├── diagnoses-manifest.json
-+- fix-plan.json
+├── planning-context.md
+└── fix-plan.json
 ```
 
 ## Error Handling

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

@@ -37,6 +37,23 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 /workflow:lite-plan -y -e "优化数据库查询性能"       # Auto mode + force exploration
 ```
 
+## Output Artifacts
+
+| Artifact | Description |
+|----------|-------------|
+| `exploration-{angle}.json` | Per-angle exploration results (1-4 files based on complexity) |
+| `explorations-manifest.json` | Index of all exploration files |
+| `planning-context.md` | Evidence paths + synthesized understanding |
+| `plan.json` | Structured implementation plan (plan-json-schema.json) |
+
+**Output Directory**: `.workflow/.lite-plan/{task-slug}-{YYYY-MM-DD}/`
+
+**Agent Usage**:
+- Low complexity → Direct Claude planning (no agent)
+- Medium/High complexity → `cli-lite-planning-agent` generates `plan.json`
+
+**Schema Reference**: `~/.claude/workflows/cli-templates/schemas/plan-json-schema.json`
+
 ## Auto Mode Defaults
 
 When `--yes` or `-y` flag is used:
@@ -72,8 +89,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
+      ├─ 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 → MUST proceed to Phase 4
+      └─ Medium/High → cli-lite-planning-agent → plan.json (agent internally executes quality check)
 
 Phase 4: Confirmation & Selection
    ├─ Display plan summary (tasks, complexity, estimated time)
@@ -193,11 +210,15 @@ const explorationTasks = selectedAngles.map((angle, index) =>
 ## Task Objective
 Execute **${angle}** exploration for task planning context. Analyze codebase from this specific angle to discover relevant structure, patterns, and constraints.
 
+## Output Location
+
+**Session Folder**: ${sessionFolder}
+**Output File**: ${sessionFolder}/exploration-${angle}.json
+
 ## Assigned Context
 - **Exploration Angle**: ${angle}
 - **Task Description**: ${task_description}
 - **Exploration Index**: ${index + 1} of ${selectedAngles.length}
-- **Output File**: ${sessionFolder}/exploration-${angle}.json
 
 ## MANDATORY FIRST STEPS (Execute by Agent)
 **You (cli-explore-agent) MUST execute these steps in order:**
@@ -225,8 +246,6 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 
 ## Expected Output
 
-**File**: ${sessionFolder}/exploration-${angle}.json
-
 **Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 3, follow schema exactly
 
 **Required Fields** (all ${angle} focused):
@@ -252,9 +271,9 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 - [ ] JSON output follows schema exactly
 - [ ] clarification_needs includes options + recommended
 
-## Output
+## Execution
-Write: ${sessionFolder}/exploration-${angle}.json
+**Write**: \`${sessionFolder}/exploration-${angle}.json\`
-Return: 2-3 sentence summary of ${angle} findings
+**Return**: 2-3 sentence summary of ${angle} findings
 `
   )
 )
@@ -443,6 +462,13 @@ Task(
   prompt=`
 Generate implementation plan and write plan.json.
 
+## Output Location
+
+**Session Folder**: ${sessionFolder}
+**Output Files**:
+- ${sessionFolder}/planning-context.md (evidence + understanding)
+- ${sessionFolder}/plan.json (implementation plan)
+
 ## Output Schema Reference
 Execute: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json (get schema reference before generating plan)
 
@@ -492,8 +518,9 @@ Generate plan.json following the schema obtained above. Key constraints:
 2. Execute CLI planning using Gemini (Qwen fallback)
 3. Read ALL exploration files for comprehensive context
 4. Synthesize findings and generate plan following schema
-5. Write JSON: Write('${sessionFolder}/plan.json', jsonContent)
+5. **Write**: \`${sessionFolder}/planning-context.md\` (evidence paths + understanding)
-6. Return brief completion summary
+6. **Write**: \`${sessionFolder}/plan.json\`
+7. Return brief completion summary
 `
 )
 ```

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

@@ -150,378 +150,213 @@ Create internal representations (do not include raw artifacts in output):
 - Task-to-task dependencies (depends_on, blocks)
 - Requirement-level dependencies (from synthesis)
 
-### 4. Detection Passes (Token-Efficient Analysis)
+### 4. Detection Passes (Agent-Driven Multi-Dimensional Analysis)
 
-**Token Budget Strategy**:
+**Execution Strategy**:
-- **Total Limit**: 50 findings maximum (aggregate remainder in overflow summary)
+- Single `cli-explore-agent` invocation
-- **Priority Allocation**: CRITICAL (unlimited) → HIGH (15) → MEDIUM (20) → LOW (15)
+- Agent executes multiple CLI analyses internally (different dimensions: A-H)
-- **Early Exit**: If CRITICAL findings > 0 in User Intent/Requirements Coverage, skip LOW/MEDIUM priority checks
+- 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** (Process in sequence; skip if token budget exhausted):
+**Execution Order** (Agent orchestrates internally):
 
-1. **Tier 1 (CRITICAL Path)**: A, B, C - User intent, coverage, consistency (process fully)
+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 total)
+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 total)
+4. **Tier 4 (LOW Priority)**: G, H - Duplication, feasibility (limit 15 findings)
 
 ---
 
-#### A. User Intent Alignment (CRITICAL - Tier 1)
+#### Phase 4.1: Launch Unified Verification Agent
 
-- **Goal Alignment**: IMPL_PLAN objectives match user's original intent
+```javascript
-- **Scope Drift**: Plan covers user's stated scope without unauthorized expansion
+Task(
-- **Success Criteria Match**: Plan's success criteria reflect user's expectations
+  subagent_type="cli-explore-agent",
-- **Intent Conflicts**: Tasks contradicting user's original objectives
+  run_in_background=false,
+  description="Multi-dimensional plan verification",
+  prompt=`
+## Plan Verification Task
 
-#### B. Requirements Coverage Analysis
+### 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)
 
-- **Orphaned Requirements**: Requirements in synthesis with zero associated tasks
+### Execution Flow
-- **Unmapped Tasks**: Tasks with no clear requirement linkage
-- **NFR Coverage Gaps**: Non-functional requirements (performance, security, scalability) not reflected in tasks
 
-#### C. Consistency Validation
+**Load schema → Execute tiered CLI analysis → Aggregate findings → Write JSON**
 
-- **Requirement Conflicts**: Tasks contradicting synthesis requirements
+FOR each tier in [1, 2, 3, 4]:
-- **Architecture Drift**: IMPL_PLAN architecture not matching synthesis ADRs
+  - Load tier config from plan-verify-agent-schema.json
-- **Terminology Drift**: Same concept named differently across IMPL_PLAN and tasks
+  - Execute: ccw cli -p "PURPOSE: Verify dimensions {tier.dimensions}
-- **Data Model Inconsistency**: Tasks referencing entities/fields not in synthesis data model
+    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
 
-#### D. Dependency Integrity
+### Output
+Write: ${process_dir}/verification-findings.json (follow verify-json-schema.json)
+Return: Quality gate decision + 2-3 sentence summary
+`
+)
+```
 
-- **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
+#### Phase 4.2: Load and Organize Findings
 
-- **Priority Conflicts**: High-priority synthesis requirements mapped to low-priority tasks
+```javascript
-- **Success Criteria Mismatch**: IMPL_PLAN success criteria not covering synthesis acceptance criteria
+// Load findings (single parse for all subsequent use)
-- **Risk Mitigation Gaps**: Critical risks in synthesis without corresponding mitigation tasks
+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
 
-#### F. Task Specification Quality
+// Group by severity and dimension
+const bySeverity = Object.groupBy(findings, f => f.severity)
+const byDimension = Object.groupBy(findings, f => f.dimension)
 
-- **Ambiguous Focus Paths**: Tasks with vague or missing focus_paths
+// Dimension metadata (from schema)
-- **Underspecified Acceptance**: Tasks without clear acceptance criteria
+const DIMS = {
-- **Missing Artifacts References**: Tasks not referencing relevant brainstorming artifacts in context.artifacts
+  A: "User Intent Alignment", B: "Requirements Coverage", C: "Consistency Validation",
-- **Weak Flow Control**: Tasks without clear implementation_approach or pre_analysis steps
+  D: "Dependency Integrity", E: "Synthesis Alignment", F: "Task Specification Quality",
-- **Missing Target Files**: Tasks without flow_control.target_files specification
+  G: "Duplication Detection", H: "Feasibility Assessment"
+}
+```
 
-#### G. Duplication Detection
+### 5. Generate Report
 
-- **Overlapping Task Scope**: Multiple tasks with nearly identical descriptions
+```javascript
-- **Redundant Requirements Coverage**: Same requirement covered by multiple tasks without clear partitioning
+// 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.`
+}
 
-#### H. Feasibility Assessment
+// 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.`
+}
 
-- **Complexity Misalignment**: Task marked "simple" but requires multiple file modifications
+// Build Markdown report
-- **Resource Conflicts**: Parallel tasks requiring same resources/files
+const fullReport = `
-- **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
 # Plan Verification Report
 
-**Session**: WFS-{session-id}
+**Session**: WFS-${session_id} | **Generated**: ${timestamp}
-**Generated**: {timestamp}
+**Tiers Completed**: ${verification_tiers_completed.join(', ')}
-**Artifacts Analyzed**: role analysis documents, IMPL_PLAN.md, {N} task files
-**User Intent Analysis**: {user_intent_analysis or "SKIPPED: workflow-session.json not found"}
 
 ---
 
 ## Executive Summary
 
-### Quality Gate Decision
-
 | Metric | Value | Status |
 |--------|-------|--------|
-| Overall Risk Level | CRITICAL \| HIGH \| MEDIUM \| LOW | {status_emoji} |
+| 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 Issues | {count} | 🔴 |
+| Critical/High/Medium/Low | ${critical_count}/${high_count}/${medium_count}/${low_count} | |
-| High Issues | {count} | 🟠 |
+| Coverage | ${coverage_percentage}% | ${coverage_percentage >= 90 ? '🟢' : coverage_percentage >= 75 ? '🟡' : '🔴'} |
-| Medium Issues | {count} | 🟡 |
-| Low Issues | {count} | 🟢 |
 
-### Recommendation
+**Recommendation**: **${recommendation}**
-
-**{RECOMMENDATION}**
-
-**Decision Rationale**:
-{brief explanation based on severity criteria}
-
-**Quality Gate Criteria**:
-- **BLOCK_EXECUTION**: Critical issues > 0 (must fix before proceeding)
-- **PROCEED_WITH_FIXES**: Critical = 0, High > 0 (fix recommended before execution)
-- **PROCEED_WITH_CAUTION**: Critical = 0, High = 0, Medium > 0 (proceed with awareness)
-- **PROCEED**: Only Low issues or None (safe to execute)
 
 ---
 
 ## Findings Summary
 
-| ID | Category | Severity | Location(s) | Summary | Recommendation |
+| ID | Dimension | Severity | Location | Summary |
-|----|----------|----------|-------------|---------|----------------|
+|----|-----------|----------|----------|---------|
-| C1 | Coverage | CRITICAL | synthesis:FR-03 | Requirement "User auth" has zero task coverage | Add authentication implementation task |
+${findings.map(f => `| ${f.id} | ${f.dimension_name} | ${f.severity} | ${f.location.join(', ')} | ${f.summary} |`).join('\n')}
-| 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 |
-
-(Generate stable IDs prefixed by severity initial: C/H/M/L + number)
 
 ---
 
-## User Intent Alignment Analysis
+## Analysis by Dimension
 
-{IF user_intent_analysis != "SKIPPED"}
+${['A','B','C','D','E','F','G','H'].map(d => `### ${d}. ${DIMS[d]}\n\n${renderDimension(d)}`).join('\n\n---\n\n')}
-
-### Goal Alignment
-- **User Intent**: {user_original_intent}
-- **IMPL_PLAN Objectives**: {plan_objectives}
-- **Alignment Status**: {ALIGNED/MISALIGNED/PARTIAL}
-- **Findings**: {specific alignment issues}
-
-### Scope Verification
-- **User Scope**: {user_defined_scope}
-- **Plan Scope**: {plan_actual_scope}
-- **Drift Detection**: {NONE/MINOR/MAJOR}
-- **Findings**: {specific scope issues}
-
-{ELSE}
-> ⚠️ User intent alignment analysis was skipped because workflow-session.json was not found.
-
-{END IF}
 
 ---
 
-## Requirements Coverage Analysis
+## Findings by Severity
 
-### Functional Requirements
+### CRITICAL (${critical_count})
+${renderSeverity('CRITICAL', 'Blocks execution')}
 
-| Requirement ID | Requirement Summary | Has Task? | Task IDs | Priority Match | Notes |
+### HIGH (${high_count})
-|----------------|---------------------|-----------|----------|----------------|-------|
+${renderSeverity('HIGH', 'Fix before execution recommended')}
-| 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** |
 
-### Non-Functional Requirements
+### MEDIUM (${medium_count})
+${renderSeverity('MEDIUM', 'Address during/after implementation')}
 
-| Requirement ID | Requirement Summary | Has Task? | Task IDs | Notes |
+### LOW (${low_count})
-|----------------|---------------------|-----------|----------|-------|
+${renderSeverity('LOW', 'Optional improvement')}
-| NFR-01 | Response time <200ms | No | - | **HIGH: No performance tasks** |
-| NFR-02 | Security compliance | Yes | IMPL-4.1 | Complete |
-
-### Business Requirements
-
-| Requirement ID | Requirement Summary | Has Task? | Task IDs | Notes |
-|----------------|---------------------|-----------|----------|-------|
-| BR-01 | Launch by Q2 | Yes | IMPL-1.* through IMPL-5.* | Timeline realistic |
-
-### Coverage Metrics
-
-| Requirement Type | Total | Covered | Coverage % |
-|------------------|-------|---------|------------|
-| Functional | {count} | {count} | {percent}% |
-| Non-Functional | {count} | {count} | {percent}% |
-| Business | {count} | {count} | {percent}% |
-| **Overall** | **{total}** | **{covered}** | **{percent}%** |
 
 ---
 
-## Dependency Integrity
+## Next Steps
 
-### Dependency Graph Analysis
+${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'}
 
-**Circular Dependencies**: {None or List}
+Re-verify: \`/workflow:plan-verify --session ${session_id}\`
+Execute: \`/workflow:execute --resume-session="${session_id}"\`
+`
 
-**Broken Dependencies**:
+// Write report
-- IMPL-2.3 depends on "IMPL-2.4" (non-existent)
+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}%`)
-**Missing Dependencies**:
-- IMPL-5.1 (integration test) has no dependency on IMPL-1.* (implementation tasks)
-
-**Logical Ordering Issues**:
-{List or "None detected"}
-
----
-
-## 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
-
-### Aggregate Statistics
-
-| Quality Dimension | Tasks Affected | Percentage |
-|-------------------|----------------|------------|
-| Missing Artifacts References | {count} | {percent}% |
-| Weak Flow Control | {count} | {percent}% |
-| Missing Target Files | {count} | {percent}% |
-| Ambiguous Focus Paths | {count} | {percent}% |
-
-### 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 |
-
----
-
-## Detailed Findings by Severity
-
-### CRITICAL Issues ({count})
-
-{Detailed breakdown of each critical issue with location, impact, and recommendation}
-
-### HIGH Issues ({count})
-
-{Detailed breakdown of each high issue with location, impact, and recommendation}
-
-### MEDIUM Issues ({count})
-
-{Detailed breakdown of each medium issue with location, impact, and recommendation}
-
-### LOW Issues ({count})
-
-{Detailed breakdown of each low issue with location, impact, and recommendation}
-
----
-
-## Metrics Summary
-
-| Metric | Value |
-|--------|-------|
-| Total Requirements | {count} ({functional} functional, {nonfunctional} non-functional, {business} business) |
-| Total Tasks | {count} |
-| Overall Coverage | {percent}% ({covered}/{total} requirements with ≥1 task) |
-| Critical Issues | {count} |
-| High Issues | {count} |
-| Medium Issues | {count} |
-| Low Issues | {count} |
-| Total Findings | {total_findings} |
-
----
-
-## Remediation Recommendations
-
-### Priority Order
-
-1. **CRITICAL** - Must fix before proceeding
-2. **HIGH** - Fix before execution
-3. **MEDIUM** - Fix during or after implementation
-4. **LOW** - Optional improvements
-
-### Next Steps
-
-Based on the quality gate recommendation ({RECOMMENDATION}):
-
-{IF BLOCK_EXECUTION}
-**🛑 BLOCK EXECUTION**
-
-You must resolve all CRITICAL issues before proceeding with implementation:
-
-1. Review each critical issue in detail
-2. Determine remediation approach (modify IMPL_PLAN.md, update task.json, or add new tasks)
-3. Apply fixes systematically
-4. Re-run verification to confirm resolution
-
-{ELSE IF PROCEED_WITH_FIXES}
-**⚠️ PROCEED WITH FIXES RECOMMENDED**
-
-No critical issues detected, but HIGH issues exist. Recommended workflow:
-
-1. Review high-priority issues
-2. Apply fixes before execution for optimal results
-3. Re-run verification (optional)
-
-{ELSE IF PROCEED_WITH_CAUTION}
-**✅ PROCEED WITH CAUTION**
-
-Only MEDIUM issues detected. You may proceed with implementation:
-
-- Address medium issues during or after implementation
-- Maintain awareness of identified concerns
-
-{ELSE}
-**✅ PROCEED**
-
-No significant issues detected. Safe to execute implementation workflow.
-
-{END IF}
-
----
-
-**Report End**
 ```
 
-### 7. Save and Display Report
+### 6. Next Step Selection
 
-**Step 7.1: Save Report**:
+```javascript
-```bash
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
-report_path = ".workflow/active/WFS-{session}/.process/PLAN_VERIFICATION.md"
+const canExecute = recommendation !== 'BLOCK_EXECUTION'
-Write(report_path, full_report_content)
+
+// 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}")
+}
 ```
-
-**Step 7.2: Display Summary to User**:
-```bash
-# Display executive summary in terminal
-echo "=== Plan Verification Complete ==="
-echo "Report saved to: {report_path}"
-echo ""
-echo "Quality Gate: {RECOMMENDATION}"
-echo "Critical: {count} | High: {count} | Medium: {count} | Low: {count}"
-echo ""
-echo "Next: Review full report for detailed findings and recommendations"
-```
-
-**Step 7.3: Completion**:
-- Report is saved to `.process/PLAN_VERIFICATION.md`
-- User can review findings and decide on remediation approach
-- No automatic modifications are made to source artifacts
-- User can manually apply fixes or use separate remediation command (if available)

.claude/commands/workflow/plan.md

@@ -3,6 +3,7 @@ name: plan
 description: 5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs
 argument-hint: "[-y|--yes] \"text description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
+group: workflow
 ---
 
 ## Auto Mode
@@ -115,7 +116,51 @@ 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 planning notes document with N+1 context support
+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}
+
+---
+
+## Task Generation (Phase 4)
+(To be filled by action-planning-agent)
+
+## N+1 Context
+### Decisions
+| Decision | Rationale | Revisit? |
+|----------|-----------|----------|
+
+### Deferred
+- [ ] (For N+1)
+`)
+```
+
+Return to user showing Phase 1 results, then auto-continue to Phase 2
 
 ---
 
@@ -138,6 +183,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 -->
 
@@ -168,7 +214,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)
 
 ---
 
@@ -229,7 +305,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
@@ -282,7 +396,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
@@ -315,20 +434,55 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]"
 
 **Note**: Agent task completed. No collapse needed (single task).
 
-**Return to User**:
+**Step 4.2: User Decision** - Choose next action
-```
-Planning complete for session: [sessionId]
-Tasks generated: [count]
-Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
 
-Recommended Next Steps:
+After Phase 4 completes, present user with action choices:
-1. /workflow:plan-verify --session [sessionId]  # Verify plan quality before execution
-2. /workflow:status  # Review task breakdown
-3. /workflow:execute  # Start implementation (after verification)
 
-Quality Gate: Consider running /workflow: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.
@@ -404,26 +558,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
+    ↓ Input: sessionId + structured description
-    ↓ Output: contextPath (context-package.json) + conflict_risk
+    ↓ 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)
+    ↓ Output: Modified brainstorm artifacts
-    ↓ AskUserQuestion: Present conflicts + resolution strategies
+    ↓ Update: planning-notes.md (Conflict Decisions + Consolidated Constraints)
-    ↓ User selects strategies (or skip)
-    ↓ Apply modifications via Edit tool:
-    ↓   - Update guidance-specification.md
-    ↓   - Update role analyses (*.md)
-    ↓   - Mark context-package.json as "resolved"
-    ↓ Output: Modified brainstorm artifacts (NO report file)
     ↓ Skip if conflict_risk is none/low → proceed directly to Phase 4
     ↓
 Phase 4: task-generate-agent --session sessionId
-    ↓ Input: sessionId + 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

.claude/commands/workflow/replan.md

@@ -113,7 +113,40 @@ 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**
 
 ---
 
@@ -356,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({
@@ -365,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:
@@ -570,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

.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/tools/conflict-resolution.md

@@ -25,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 |
+| **Iterative Clarification** | Ask unlimited questions until scenario boundaries are clear and unique |
-| **Agent Re-analysis** | **NEW**: Dynamically update strategies based on user clarifications |
+| **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 |
@@ -57,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
@@ -134,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)
@@ -186,28 +186,18 @@ 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):
+  ### 5. Planning Notes Record (REQUIRED)
-```
+  After analysis complete, append a brief execution record to planning-notes.md:
-1. Load context package
+
-2. Check conflict_risk (exit if none/low)
+  **File**: .workflow/active/{session_id}/planning-notes.md
-3. Read existing files + plan artifacts
+  **Location**: Under "## Conflict Decisions (Phase 3)" section
-4. Run CLI analysis (Gemini→Qwen→Claude) with enhanced tasks:
+  **Format**:
-   - Standard conflict detection (Architecture/API/Data/Dependency)
+  \`\`\`
-   - **NEW: Module scenario uniqueness detection**
+  ### [Conflict-Resolution Agent] YYYY-MM-DD
-     * Extract new module functionality from plan
+  - **Note**: [智能补充：简短总结冲突类型、解决策略、关键决策等]
-     * Search all existing modules with similar keywords/functionality
+  \`\`\`
-     * Compare scenario coverage and responsibilities
+`)
-     * Identify functional overlaps and boundary ambiguities
-     * Generate ModuleOverlap conflicts with overlap_analysis
-5. Parse conflict findings (including ModuleOverlap category)
-6. Generate 2-4 strategies per conflict:
-   - Include modifications for each strategy
-   - **For ModuleOverlap**: Add clarification_needed questions for boundary definition
-7. Return JSON to stdout (NOT file write)
-8. Return execution log path
 ```
 
 ### Phase 3: User Interaction Loop

.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.
+2. **Synthesize 5-source data** (including Track -1): Merge findings from all sources
-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.
+   - Priority order: User Intent > Archive > Docs > Exploration > Code > Web
-4. **Populate `project_guidelines`**: Load conventions, constraints, and learnings from `project-guidelines.json` into a dedicated section.
+   - **Prioritize the context from `project-tech.json`** for architecture and tech stack unless code analysis reveals it's outdated
-5. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
+3. **Context Priority Sorting**:
-6. Perform conflict detection with risk assessment
+   a. Combine scores from Track -1 (user intent alignment) + relevance scores + exploration critical_files
-7. **Inject historical conflicts** from archive analysis into conflict_detection
+   b. Classify files into priority tiers:
-8. Generate and validate context-package.json
+      - **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)
-
+- **prioritized_context**: Pre-sorted context with user intent and priority tiers (critical/high/medium/low)
-## Historical Archive Analysis
-
-### Track 1: Query Archive Manifest
-
-The context-search-agent MUST perform historical archive analysis as Track 1 in Phase 2:
-
-**Step 1: Check for Archive Manifest**
-```bash
-# Check if archive manifest exists
-if [[ -f .workflow/archives/manifest.json ]]; then
-  # Manifest available for querying
-fi
-```
-
-**Step 2: Extract Task Keywords**
-```javascript
-// From current task description, extract key entities and operations
-const keywords = extractKeywords(task_description);
-// Examples: ["User", "model", "authentication", "JWT", "reporting"]
-```
-
-**Step 3: Search Archive for Relevant Sessions**
-```javascript
-// Query manifest for sessions with matching tags or descriptions
-const relevantArchives = archives.filter(archive => {
-  return archive.tags.some(tag => keywords.includes(tag)) ||
-         keywords.some(kw => archive.description.toLowerCase().includes(kw.toLowerCase()));
-});
-```
-
-**Step 4: Extract Watch Patterns**
-```javascript
-// For each relevant archive, check watch_patterns for applicability
-const historicalConflicts = [];
-
-relevantArchives.forEach(archive => {
-  archive.lessons.watch_patterns?.forEach(pattern => {
-    // Check if pattern trigger matches current task
-    if (isPatternRelevant(pattern.pattern, task_description)) {
-      historicalConflicts.push({
-        source_session: archive.session_id,
-        pattern: pattern.pattern,
-        action: pattern.action,
-        files_to_check: pattern.related_files,
-        archived_at: archive.archived_at
-      });
-    }
-  });
-});
-```
-
-**Step 5: Inject into Context Package**
-```json
-{
-  "conflict_detection": {
-    "risk_level": "medium",
-    "risk_factors": ["..."],
-    "affected_modules": ["..."],
-    "mitigation_strategy": "...",
-    "historical_conflicts": [
-      {
-        "source_session": "WFS-auth-feature",
-        "pattern": "When modifying User model",
-        "action": "Check reporting-service and auditing-service dependencies",
-        "files_to_check": ["src/models/User.ts", "src/services/reporting.ts"],
-        "archived_at": "2025-09-16T09:00:00Z"
-      }
-    ]
-  }
-}
-```
-
-### Risk Level Escalation
-
-If `historical_conflicts` array is not empty, minimum risk level should be "medium":
-
-```javascript
-if (historicalConflicts.length > 0 && currentRisk === "low") {
-  conflict_detection.risk_level = "medium";
-  conflict_detection.risk_factors.push(
-    `${historicalConflicts.length} historical conflict pattern(s) detected from past sessions`
-  );
-}
-```
-
-### Archive Query Algorithm
-
-```markdown
-1. IF .workflow/archives/manifest.json does NOT exist → Skip Track 1, continue to Track 2
-2. IF manifest exists:
-   a. Load manifest.json
-   b. Extract keywords from task_description (nouns, verbs, technical terms)
-   c. Filter archives where:
-      - ANY tag matches keywords (case-insensitive) OR
-      - description contains keywords (case-insensitive substring match)
-   d. For each relevant archive:
-      - Read lessons.watch_patterns array
-      - Check if pattern.pattern keywords overlap with task_description
-      - If relevant: Add to historical_conflicts array
-   e. IF historical_conflicts.length > 0:
-      - Set risk_level = max(current_risk, "medium")
-      - Add to risk_factors
-3. Continue to Track 2 (reference documentation)
-```
 
 ## Notes
 
 - **Detection-first**: Always check for existing package before invoking agent
-- **Dual project file integration**: Agent reads both `.workflow/project-tech.json` (tech analysis) and `.workflow/project-guidelines.json` (user constraints) as primary sources
+- **User intent integration**: Load user intent from planning-notes.md (Phase 1 output)
-- **Guidelines injection**: Project guidelines are included in context-package to ensure task generation respects user-defined constraints
+- **Output**: Generates `context-package.json` with `prioritized_context` field
-- **No redundancy**: This command is a thin orchestrator, all logic in agent
 - **Plan-specific**: Use this for implementation planning; brainstorm mode uses direct agent call

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

@@ -19,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
@@ -161,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
@@ -248,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:
@@ -278,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
@@ -298,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**
+   - **focus_paths generated directly from prioritized_context.priority_tiers (critical + high)**
-   - Flow control with pre_analysis steps (include exploration integration_points analysis)
+     - 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)
@@ -347,6 +376,29 @@ 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, update planning-notes.md:
+
+**File**: .workflow/active/{session_id}/planning-notes.md
+
+1. **Task Generation (Phase 4)**: Task count and key tasks
+2. **N+1 Context**: Key decisions (with rationale) + deferred items
+
+\`\`\`markdown
+## Task Generation (Phase 4)
+### [Action-Planning Agent] YYYY-MM-DD
+- **Tasks**: [count] ([IDs])
+
+## N+1 Context
+### Decisions
+| Decision | Rationale | Revisit? |
+|----------|-----------|----------|
+| [choice] | [why] | [Yes/No] |
+
+### Deferred
+- [ ] [item] - [reason]
+\`\`\`
 `
 )
 ```
@@ -376,16 +428,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:
@@ -411,7 +469,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
@@ -438,8 +505,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)**
+  - **focus_paths generated directly from prioritized_context.priority_tiers filtered by ${module.paths.join(', ')}**
-  - Flow control with pre_analysis steps (include exploration integration_points analysis)
+    - 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
 
@@ -482,6 +551,15 @@ 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, append to planning-notes.md:
+
+\`\`\`markdown
+### [${module.name}] YYYY-MM-DD
+- **Tasks**: [count] ([IDs])
+- **CROSS deps**: [placeholders used]
+\`\`\`
     `
   )
 );
@@ -562,6 +640,24 @@ 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 integration, update planning-notes.md:
+
+\`\`\`markdown
+### [Coordinator] YYYY-MM-DD
+- **Total**: [count] tasks
+- **Resolved**: [CROSS:: resolutions]
+
+## N+1 Context
+### Decisions
+| Decision | Rationale | Revisit? |
+|----------|-----------|----------|
+| CROSS::X → IMPL-Y | [why this resolution] | [Yes/No] |
+
+### Deferred
+- [ ] [unresolved CROSS or conflict] - [reason]
+\`\`\`
   `
 )
 ```
@@ -579,5 +675,4 @@ function resolveCrossModuleDependency(placeholder, allTasks) {
     ? candidates.sort((a, b) => a.id.localeCompare(b.id))[0].id
     : placeholder; // Keep for manual resolution
 }
-```
+```
-

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

@@ -0,0 +1,889 @@
+---
+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 (all JSON plans follow plan-json-schema.json):
+
+```javascript
+function parsePlan(content, filePath) {
+  const ext = filePath.split('.').pop()
+
+  if (filePath.includes('IMPL_PLAN')) {
+    return parseImplPlan(content) // From /workflow:plan (markdown)
+  } 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 parsePlanJson(content) // Standard plan-json-schema (lite-plan, collaborative-plan, sub-plans)
+  }
+
+  throw new Error(`Unsupported plan format: ${filePath}`)
+}
+
+// Standard plan-json-schema parser
+// Handles: lite-plan, collaborative-plan, sub-plans (all follow same schema)
+function parsePlanJson(content) {
+  const plan = JSON.parse(content)
+
+  return {
+    type: plan.merge_metadata ? 'collaborative-plan' : 'lite-plan',
+    title: plan.summary?.split('.')[0] || 'Untitled Plan',
+    slug: plan._metadata?.session_id || generateSlug(plan.summary),
+    summary: plan.summary,
+    approach: plan.approach,
+    tasks: plan.tasks.map(task => ({
+      id: task.id,
+      type: inferTaskTypeFromAction(task.action),
+      title: task.title,
+      description: task.description,
+      dependencies: task.depends_on || [],
+      agent_type: selectAgentFromTask(task),
+      prompt: buildPromptFromTask(task),
+      files_to_modify: task.modification_points?.map(mp => mp.file) || [],
+      expected_output: task.acceptance || [],
+      priority: task.effort?.complexity === 'high' ? 'high' : 'normal',
+      estimated_duration: task.effort?.estimated_hours ? `${task.effort.estimated_hours}h` : null,
+      verification: task.verification,
+      risks: task.risks,
+      source_agent: task.source_agent // From collaborative-plan sub-agents
+    })),
+    flow_control: plan.flow_control,
+    data_flow: plan.data_flow,
+    design_decisions: plan.design_decisions,
+    estimatedDuration: plan.estimated_time,
+    recommended_execution: plan.recommended_execution,
+    complexity: plan.complexity,
+    merge_metadata: plan.merge_metadata, // Present if from collaborative-plan
+    _metadata: plan._metadata
+  }
+}
+
+// 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
+  }
+}
+
+// Helper: Infer task type from action field
+function inferTaskTypeFromAction(action) {
+  const actionMap = {
+    'Create': 'code',
+    'Update': 'code',
+    'Implement': 'code',
+    'Refactor': 'code',
+    'Add': 'code',
+    'Delete': 'code',
+    'Configure': 'config',
+    'Test': 'test',
+    'Fix': 'debug'
+  }
+  return actionMap[action] || 'code'
+}
+
+// Helper: Select agent based on task properties
+function selectAgentFromTask(task) {
+  if (task.verification?.unit_tests?.length > 0) {
+    return 'tdd-developer'
+  } else if (task.action === 'Test') {
+    return 'test-fix-agent'
+  } else if (task.action === 'Fix') {
+    return 'debug-explore-agent'
+  } else {
+    return 'code-developer'
+  }
+}
+
+// Helper: Build prompt from task details
+function buildPromptFromTask(task) {
+  let prompt = `## Task: ${task.title}\n\n${task.description}\n\n`
+
+  if (task.modification_points?.length > 0) {
+    prompt += `### Modification Points\n`
+    task.modification_points.forEach(mp => {
+      prompt += `- **${mp.file}**: ${mp.target} → ${mp.change}\n`
+    })
+    prompt += '\n'
+  }
+
+  if (task.implementation?.length > 0) {
+    prompt += `### Implementation Steps\n`
+    task.implementation.forEach((step, i) => {
+      prompt += `${i + 1}. ${step}\n`
+    })
+    prompt += '\n'
+  }
+
+  if (task.acceptance?.length > 0) {
+    prompt += `### Acceptance Criteria\n`
+    task.acceptance.forEach(ac => {
+      prompt += `- ${ac}\n`
+    })
+  }
+
+  return prompt
+}
+```
+
+---
+
+### 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` |
+
+
+## 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 "task description"          # Auto-select workflow and execute
-/ccw-help search <keyword>   # 搜索命令
+/ccw-help                        # General help entry
-/ccw-help next <command>     # 获取下一步建议
+/ccw-help search <keyword>       # Search commands
-/ccw-issue                   # 问题报告
+/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/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/README.md

@@ -1,303 +0,0 @@
-# CCW Loop Skill
-
-无状态迭代开发循环工作流，支持开发 (Develop)、调试 (Debug)、验证 (Validate) 三个阶段，每个阶段都有独立的文件记录进展。
-
-## Overview
-
-CCW Loop 是一个自主模式 (Autonomous) 的 Skill，通过文件驱动的无状态循环，帮助开发者系统化地完成开发任务。
-
-### 核心特性
-
-1. **无状态循环**: 每次执行从文件读取状态，不依赖内存
-2. **文件驱动**: 所有进度记录在 Markdown 文件中，可审计、可回顾
-3. **Gemini 辅助**: 关键决策点使用 CLI 工具进行深度分析
-4. **可恢复**: 任何时候中断后可继续
-5. **双模式**: 支持交互式和自动循环
-
-### 三大阶段
-
-- **Develop**: 任务分解 → 代码实现 → 进度记录
-- **Debug**: 假设生成 → 证据收集 → 根因分析 → 修复验证
-- **Validate**: 测试执行 → 覆盖率检查 → 质量评估
-
-## Installation
-
-已包含在 `.claude/skills/ccw-loop/`，无需额外安装。
-
-## Usage
-
-### 基本用法
-
-```bash
-# 启动新循环
-/ccw-loop "实现用户认证功能"
-
-# 继续现有循环
-/ccw-loop --resume LOOP-auth-2026-01-22
-
-# 自动循环模式
-/ccw-loop --auto "修复登录bug并添加测试"
-```
-
-### 交互式流程
-
-```
-1. 启动: /ccw-loop "任务描述"
-2. 初始化: 自动分析任务并生成子任务列表
-3. 显示菜单:
-   - 📝 继续开发 (Develop)
-   - 🔍 开始调试 (Debug)
-   - ✅ 运行验证 (Validate)
-   - 📊 查看详情 (Status)
-   - 🏁 完成循环 (Complete)
-   - 🚪 退出 (Exit)
-4. 执行选择的动作
-5. 重复步骤 3-4 直到完成
-```
-
-### 自动循环流程
-
-```
-Develop (所有任务) → Debug (如有需要) → Validate → 完成
-```
-
-## Directory Structure
-
-```
-.workflow/.loop/{session-id}/
-├── meta.json              # 会话元数据 (不可修改)
-├── state.json             # 当前状态 (每次更新)
-├── summary.md             # 完成报告 (结束时生成)
-├── develop/
-│   ├── progress.md        # 开发进度时间线
-│   ├── tasks.json         # 任务列表
-│   └── changes.log        # 代码变更日志 (NDJSON)
-├── debug/
-│   ├── understanding.md   # 理解演变文档
-│   ├── hypotheses.json    # 假设历史
-│   └── debug.log          # 调试日志 (NDJSON)
-└── validate/
-    ├── validation.md      # 验证报告
-    ├── test-results.json  # 测试结果
-    └── coverage.json      # 覆盖率数据
-```
-
-## Action Reference
-
-| Action | 描述 | 触发条件 |
-|--------|------|----------|
-| action-init | 初始化会话 | 首次启动 |
-| action-menu | 显示操作菜单 | 交互模式下每次循环 |
-| action-develop-with-file | 执行开发任务 | 有待处理任务 |
-| action-debug-with-file | 假设驱动调试 | 需要调试 |
-| action-validate-with-file | 运行测试验证 | 需要验证 |
-| action-complete | 完成并生成报告 | 所有任务完成 |
-
-详细说明见 [specs/action-catalog.md](specs/action-catalog.md)
-
-## CLI Integration
-
-CCW Loop 在关键决策点集成 CLI 工具:
-
-### 任务分解 (action-init)
-```bash
-ccw cli -p "PURPOSE: 分解开发任务..."
-  --tool gemini
-  --mode analysis
-  --rule planning-breakdown-task-steps
-```
-
-### 代码实现 (action-develop)
-```bash
-ccw cli -p "PURPOSE: 实现功能代码..."
-  --tool gemini
-  --mode write
-  --rule development-implement-feature
-```
-
-### 假设生成 (action-debug - 探索)
-```bash
-ccw cli -p "PURPOSE: Generate debugging hypotheses..."
-  --tool gemini
-  --mode analysis
-  --rule analysis-diagnose-bug-root-cause
-```
-
-### 证据分析 (action-debug - 分析)
-```bash
-ccw cli -p "PURPOSE: Analyze debug log evidence..."
-  --tool gemini
-  --mode analysis
-  --rule analysis-diagnose-bug-root-cause
-```
-
-### 质量评估 (action-validate)
-```bash
-ccw cli -p "PURPOSE: Analyze test results and coverage..."
-  --tool gemini
-  --mode analysis
-  --rule analysis-review-code-quality
-```
-
-## State Management
-
-### State Schema
-
-参见 [phases/state-schema.md](phases/state-schema.md)
-
-### State Transitions
-
-```
-pending → running → completed
-              ↓
-         user_exit
-              ↓
-            failed
-```
-
-### State Recovery
-
-如果 `state.json` 损坏，可从其他文件重建:
-- develop/tasks.json → develop.*
-- debug/hypotheses.json → debug.*
-- validate/test-results.json → validate.*
-
-## Examples
-
-### Example 1: 功能开发
-
-```bash
-# 1. 启动循环
-/ccw-loop "Add user profile page"
-
-# 2. 系统初始化，生成任务:
-#    - task-001: Create profile component
-#    - task-002: Add API endpoints
-#    - task-003: Implement tests
-
-# 3. 选择 "继续开发"
-#    → 执行 task-001 (Gemini 辅助实现)
-#    → 更新 progress.md
-
-# 4. 重复开发直到所有任务完成
-
-# 5. 选择 "运行验证"
-#    → 运行测试
-#    → 检查覆盖率
-#    → 生成 validation.md
-
-# 6. 选择 "完成循环"
-#    → 生成 summary.md
-#    → 询问是否扩展为 Issue
-```
-
-### Example 2: Bug 修复
-
-```bash
-# 1. 启动循环
-/ccw-loop "Fix login timeout issue"
-
-# 2. 选择 "开始调试"
-#    → 输入 bug 描述: "Login times out after 30s"
-#    → Gemini 生成假设 (H1, H2, H3)
-#    → 添加 NDJSON 日志
-#    → 提示复现 bug
-
-# 3. 复现 bug (在应用中操作)
-
-# 4. 再次选择 "开始调试"
-#    → 解析 debug.log
-#    → Gemini 分析证据
-#    → H2 确认为根因
-#    → 生成修复代码
-#    → 更新 understanding.md
-
-# 5. 选择 "运行验证"
-#    → 测试通过
-
-# 6. 完成
-```
-
-## Templates
-
-- [progress-template.md](templates/progress-template.md): 开发进度文档模板
-- [understanding-template.md](templates/understanding-template.md): 调试理解文档模板
-- [validation-template.md](templates/validation-template.md): 验证报告模板
-
-## Specifications
-
-- [loop-requirements.md](specs/loop-requirements.md): 循环需求规范
-- [action-catalog.md](specs/action-catalog.md): 动作目录
-
-## Integration
-
-### Dashboard Integration
-
-CCW Loop 与 Dashboard Loop Monitor 集成:
-- Dashboard 创建 Loop → 触发此 Skill
-- state.json → Dashboard 实时显示
-- 任务列表双向同步
-- 控制按钮映射到 actions
-
-### Issue System Integration
-
-完成后可扩展为 Issue:
-- 维度: test, enhance, refactor, doc
-- 自动调用 `/issue:new`
-- 上下文自动填充
-
-## Error Handling
-
-| 情况 | 处理 |
-|------|------|
-| Session 不存在 | 创建新会话 |
-| state.json 损坏 | 从文件重建 |
-| CLI 工具失败 | 回退到手动模式 |
-| 测试失败 | 循环回到 develop/debug |
-| >10 迭代 | 警告用户，建议拆分 |
-
-## Limitations
-
-1. **单会话限制**: 同一时间只能有一个活跃会话
-2. **迭代限制**: 建议不超过 10 次迭代
-3. **CLI 依赖**: 部分功能依赖 Gemini CLI 可用性
-4. **测试框架**: 需要 package.json 中定义测试脚本
-
-## Troubleshooting
-
-### Q: 如何查看当前会话状态？
-
-A: 在菜单中选择 "查看详情 (Status)"
-
-### Q: 如何恢复中断的会话？
-
-A: 使用 `--resume` 参数:
-```bash
-/ccw-loop --resume LOOP-xxx-2026-01-22
-```
-
-### Q: 如果 CLI 工具失败怎么办？
-
-A: Skill 会自动降级到手动模式，提示用户手动输入
-
-### Q: 如何添加自定义 action？
-
-A: 参见 [specs/action-catalog.md](specs/action-catalog.md) 的 "Action Extensions" 部分
-
-## Contributing
-
-添加新功能:
-1. 创建 action 文件在 `phases/actions/`
-2. 更新 orchestrator 决策逻辑
-3. 添加到 action-catalog.md
-4. 更新 action-menu.md
-
-## License
-
-MIT
-
----
-
-**Version**: 1.0.0
-**Last Updated**: 2026-01-22
-**Author**: CCW Team

.claude/skills/flow-coordinator/SKILL.md

@@ -0,0 +1,394 @@
+---
+name: flow-coordinator
+description: Template-driven workflow coordinator with minimal state tracking. Executes command chains from workflow templates with slash-command execution (mainprocess/async). Triggers on "flow-coordinator", "workflow template", "orchestrate".
+allowed-tools: Task, AskUserQuestion, Read, Write, Bash, Glob, Grep
+---
+
+# Flow Coordinator
+
+Lightweight workflow coordinator that executes command chains from predefined templates, supporting slash-command execution with mainprocess (blocking) and async (background) modes.
+
+## Architecture
+
+```
+User Task → Select Template → status.json Init → Execute Steps → Complete
+     ↑                                                │
+     └──────────────── Resume (from status.json) ─────┘
+
+Step Execution:
+  execution mode?
+    ├─ mainprocess  → SlashCommand (blocking, main process)
+    └─ async        → ccw cli --tool claude --mode write (background)
+```
+
+## Core Concepts
+
+**Template-Driven**: Workflows defined as JSON templates in `templates/`, decoupled from coordinator logic.
+
+**Execution Type**: `slash-command` only
+- ALL workflow commands (`/workflow:*`) use `slash-command` type
+- Two execution modes:
+  - `mainprocess`: SlashCommand (blocking, main process)
+  - `async`: CLI background (ccw cli with claude tool)
+
+**Dynamic Discovery**: Templates discovered at runtime via Glob, not hardcoded.
+
+---
+
+## Execution Flow
+
+```javascript
+async function execute(task) {
+  // 1. Discover and select template
+  const templates = await discoverTemplates();
+  const template = await selectTemplate(templates);
+
+  // 2. Init status
+  const sessionId = `fc-${timestamp()}`;
+  const statusPath = `.workflow/.flow-coordinator/${sessionId}/status.json`;
+  const status = initStatus(template, task);
+  write(statusPath, JSON.stringify(status, null, 2));
+
+  // 3. Execute steps based on execution config
+  await executeSteps(status, statusPath);
+}
+
+async function executeSteps(status, statusPath) {
+  for (let i = status.current; i < status.steps.length; i++) {
+    const step = status.steps[i];
+    status.current = i;
+
+    // Execute based on step mode (all steps use slash-command type)
+    const execConfig = step.execution || { type: 'slash-command', mode: 'mainprocess' };
+
+    if (execConfig.mode === 'async') {
+      // Async execution - stop and wait for hook callback
+      await executeSlashCommandAsync(step, status, statusPath);
+      break;
+    } else {
+      // Mainprocess execution - continue immediately
+      await executeSlashCommandSync(step, status);
+      step.status = 'done';
+      write(statusPath, JSON.stringify(status, null, 2));
+    }
+  }
+
+  // All steps complete
+  if (status.current >= status.steps.length) {
+    status.complete = true;
+    write(statusPath, JSON.stringify(status, null, 2));
+  }
+}
+```
+
+---
+
+## Template Discovery
+
+**Dynamic query** - never hardcode template list:
+
+```javascript
+async function discoverTemplates() {
+  // Discover all JSON templates
+  const files = Glob('*.json', { path: 'templates/' });
+
+  // Parse each template
+  const templates = [];
+  for (const file of files) {
+    const content = JSON.parse(Read(file));
+    templates.push({
+      name: content.name,
+      description: content.description,
+      steps: content.steps.map(s => s.cmd).join(' → '),
+      file: file
+    });
+  }
+
+  return templates;
+}
+```
+
+---
+
+## Template Selection
+
+User chooses from discovered templates:
+
+```javascript
+async function selectTemplate(templates) {
+  // Build options from discovered templates
+  const options = templates.slice(0, 4).map(t => ({
+    label: t.name,
+    description: t.steps
+  }));
+
+  const response = await AskUserQuestion({
+    questions: [{
+      question: 'Select workflow template:',
+      header: 'Template',
+      options: options,
+      multiSelect: false
+    }]
+  });
+
+  // Handle "Other" - show remaining templates or custom input
+  if (response.template === 'Other') {
+    return await selectFromRemainingTemplates(templates.slice(4));
+  }
+
+  return templates.find(t => t.name === response.template);
+}
+```
+
+---
+
+## Status Schema
+
+**Creation**: Copy template JSON → Update `id`, `template`, `goal`, set all steps `status: "pending"`
+
+**Location**: `.workflow/.flow-coordinator/{session-id}/status.json`
+
+**Core Fields**:
+- `id`: Session ID (fc-YYYYMMDD-HHMMSS)
+- `template`: Template name
+- `goal`: User task description
+- `current`: Current step index
+- `steps[]`: Step array from template (with runtime `status`, `session`, `taskId`)
+- `complete`: All steps done?
+
+**Step Status**: `pending` → `running` → `done` | `failed` | `skipped`
+
+---
+
+## Extended Template Schema
+
+**Templates stored in**: `templates/*.json` (discovered at runtime via Glob)
+
+**TemplateStep Fields**:
+- `cmd`: Full command path (e.g., `/workflow:lite-plan`, `/workflow:execute`)
+- `args?`: Arguments with `{{goal}}` and `{{prev}}` placeholders
+- `unit?`: Minimum execution unit name (groups related commands)
+- `optional?`: Can be skipped by user
+- `execution`: Type and mode configuration
+  - `type`: Always `'slash-command'` (for all workflow commands)
+  - `mode`: `'mainprocess'` (blocking) or `'async'` (background)
+- `contextHint?`: Natural language guidance for context assembly
+
+**Template Example**:
+```json
+{
+  "name": "rapid",
+  "steps": [
+    {
+      "cmd": "/workflow:lite-plan",
+      "args": "\"{{goal}}\"",
+      "unit": "quick-implementation",
+      "execution": { "type": "slash-command", "mode": "mainprocess" },
+      "contextHint": "Create lightweight implementation plan"
+    },
+    {
+      "cmd": "/workflow:lite-execute",
+      "args": "--in-memory",
+      "unit": "quick-implementation",
+      "execution": { "type": "slash-command", "mode": "async" },
+      "contextHint": "Execute plan from previous step"
+    }
+  ]
+}
+```
+
+---
+
+## Execution Implementation
+
+### Mainprocess Mode (Blocking)
+
+```javascript
+async function executeSlashCommandSync(step, status) {
+  // Build command: /workflow:cmd -y args
+  const cmd = buildCommand(step, status);
+  const result = await SlashCommand({ command: cmd });
+
+  step.session = result.session_id;
+  step.status = 'done';
+  return result;
+}
+```
+
+### Async Mode (Background)
+
+```javascript
+async function executeSlashCommandAsync(step, status, statusPath) {
+  // Build prompt: /workflow:cmd -y args + context
+  const prompt = buildCommandPrompt(step, status);
+
+  step.status = 'running';
+  write(statusPath, JSON.stringify(status, null, 2));
+
+  // Execute via ccw cli in background
+  const taskId = Bash(
+    `ccw cli -p "${escapePrompt(prompt)}" --tool claude --mode write`,
+    { run_in_background: true }
+  ).task_id;
+
+  step.taskId = taskId;
+  write(statusPath, JSON.stringify(status, null, 2));
+
+  console.log(`Executing: ${step.cmd} (async)`);
+  console.log(`Resume: /flow-coordinator --resume ${status.id}`);
+}
+```
+
+---
+
+## Prompt Building
+
+Prompts are built in format: `/workflow:cmd -y args` + context
+
+```javascript
+function buildCommandPrompt(step, status) {
+  // step.cmd already contains full path: /workflow:lite-plan, /workflow:execute, etc.
+  let prompt = `${step.cmd} -y`;
+
+  // Add arguments (with placeholder replacement)
+  if (step.args) {
+    const args = step.args
+      .replace('{{goal}}', status.goal)
+      .replace('{{prev}}', getPreviousSessionId(status));
+    prompt += ` ${args}`;
+  }
+
+  // Add context based on contextHint
+  if (step.contextHint) {
+    const context = buildContextFromHint(step.contextHint, status);
+    prompt += `\n\nContext:\n${context}`;
+  } else {
+    // Default context: previous session IDs
+    const previousContext = collectPreviousResults(status);
+    if (previousContext) {
+      prompt += `\n\nPrevious results:\n${previousContext}`;
+    }
+  }
+
+  return prompt;
+}
+
+function buildContextFromHint(hint, status) {
+  // Parse contextHint instruction and build context accordingly
+  // Examples:
+  // "Summarize IMPL_PLAN.md" → read and summarize plan
+  // "List test coverage gaps" → analyze previous test results
+  // "Pass session ID" → just return session reference
+
+  return parseAndBuildContext(hint, status);
+}
+```
+
+### Example Prompt Output
+
+```
+/workflow:lite-plan -y "Implement user registration"
+
+Context:
+Task: Implement user registration
+Previous results:
+- None (first step)
+```
+
+```
+/workflow:execute -y --in-memory
+
+Context:
+Task: Implement user registration
+Previous results:
+- lite-plan: WFS-plan-20250130 (planning-context.md)
+```
+
+---
+
+## User Interaction
+
+### Step 1: Select Template
+
+```
+Select workflow template:
+
+○ rapid      lite-plan → lite-execute → test-cycle-execute
+○ coupled    plan → plan-verify → execute → review → test
+○ bugfix     lite-fix → lite-execute → test-cycle-execute
+○ tdd        tdd-plan → execute → tdd-verify
+○ Other      (more templates or custom)
+```
+
+### Step 2: Review Execution Plan
+
+```
+Template: coupled
+Steps:
+  1. /workflow:plan (slash-command mainprocess)
+  2. /workflow:plan-verify (slash-command mainprocess)
+  3. /workflow:execute (slash-command async)
+  4. /workflow:review-session-cycle (slash-command mainprocess)
+  5. /workflow:review-cycle-fix (slash-command mainprocess)
+  6. /workflow:test-fix-gen (slash-command mainprocess)
+  7. /workflow:test-cycle-execute (slash-command async)
+
+Proceed? [Confirm / Cancel]
+```
+
+---
+
+## Resume Capability
+
+```javascript
+async function resume(sessionId) {
+  const statusPath = `.workflow/.flow-coordinator/${sessionId}/status.json`;
+  const status = JSON.parse(Read(statusPath));
+
+  // Find first incomplete step
+  status.current = status.steps.findIndex(s => s.status !== 'done');
+  if (status.current === -1) {
+    console.log('All steps complete');
+    return;
+  }
+
+  // Continue executing steps
+  await executeSteps(status, statusPath);
+}
+```
+
+---
+
+## Available Templates
+
+Templates discovered from `templates/*.json`:
+
+| Template | Use Case | Steps |
+|----------|----------|-------|
+| rapid | Simple feature | /workflow:lite-plan → /workflow:lite-execute → /workflow:test-cycle-execute |
+| coupled | Complex feature | /workflow:plan → /workflow:plan-verify → /workflow:execute → /workflow:review-session-cycle → /workflow:test-fix-gen |
+| bugfix | Bug fix | /workflow:lite-fix → /workflow:lite-execute → /workflow:test-cycle-execute |
+| tdd | Test-driven | /workflow:tdd-plan → /workflow:execute → /workflow:tdd-verify |
+| test-fix | Fix failing tests | /workflow:test-fix-gen → /workflow:test-cycle-execute |
+| brainstorm | Exploration | /workflow:brainstorm-with-file |
+| debug | Debug with docs | /workflow:debug-with-file |
+| analyze | Collaborative analysis | /workflow:analyze-with-file |
+| issue | Issue workflow | /workflow:issue:plan → /workflow:issue:queue → /workflow:issue:execute |
+
+---
+
+## Design Principles
+
+1. **Minimal fields**: Only essential tracking data
+2. **Flat structure**: No nested objects beyond steps array
+3. **Step-level execution**: Each step defines how it's executed
+4. **Resumable**: Any step can be resumed from status
+5. **Human readable**: Clear JSON format
+
+---
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| templates/*.json | Workflow templates (dynamic discovery) |

.claude/skills/flow-coordinator/templates/analyze.json

@@ -0,0 +1,16 @@
+{
+  "name": "analyze",
+  "description": "Collaborative analysis with multi-round discussion - deep exploration and understanding",
+  "level": 3,
+  "steps": [
+    {
+      "cmd": "/workflow:analyze-with-file",
+      "args": "\"{{goal}}\"",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Multi-round collaborative analysis with iterative understanding. Generate discussion.md with comprehensive analysis and conclusions"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/brainstorm-to-issue.json

@@ -0,0 +1,36 @@
+{
+  "name": "brainstorm-to-issue",
+  "description": "Bridge brainstorm session to issue workflow - convert exploration insights to executable issues",
+  "level": 4,
+  "steps": [
+    {
+      "cmd": "/workflow:issue:from-brainstorm",
+      "args": "--auto",
+      "unit": "brainstorm-to-issue",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Convert brainstorm session findings into issue plans and solutions"
+    },
+    {
+      "cmd": "/workflow:issue:queue",
+      "unit": "brainstorm-to-issue",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Build execution queue from converted brainstorm issues"
+    },
+    {
+      "cmd": "/workflow:issue:execute",
+      "args": "--queue auto",
+      "unit": "brainstorm-to-issue",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute issues from queue with state tracking"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/brainstorm.json

@@ -0,0 +1,16 @@
+{
+  "name": "brainstorm",
+  "description": "Multi-perspective ideation with documentation - explore possibilities with multiple analytical viewpoints",
+  "level": 4,
+  "steps": [
+    {
+      "cmd": "/workflow:brainstorm-with-file",
+      "args": "\"{{goal}}\"",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Multi-perspective ideation with interactive diverge-converge cycles. Generate brainstorm.md with synthesis of ideas and recommendations"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/bugfix-hotfix.json

@@ -0,0 +1,16 @@
+{
+  "name": "bugfix-hotfix",
+  "description": "Urgent production fix - immediate diagnosis and fix with minimal overhead",
+  "level": 1,
+  "steps": [
+    {
+      "cmd": "/workflow:lite-fix",
+      "args": "--hotfix \"{{goal}}\"",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Urgent hotfix mode: quick diagnosis and immediate fix for critical production issue"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/bugfix.json

@@ -0,0 +1,47 @@
+{
+  "name": "bugfix",
+  "description": "Standard bug fix workflow - lightweight diagnosis and execution with testing",
+  "level": 2,
+  "steps": [
+    {
+      "cmd": "/workflow:lite-fix",
+      "args": "\"{{goal}}\"",
+      "unit": "bug-fix",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Analyze bug report, trace execution flow, identify root cause with fix strategy"
+    },
+    {
+      "cmd": "/workflow:lite-execute",
+      "args": "--in-memory",
+      "unit": "bug-fix",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Implement fix based on diagnosis. Execute against in-memory state from lite-fix analysis."
+    },
+    {
+      "cmd": "/workflow:test-fix-gen",
+      "unit": "test-validation",
+      "optional": true,
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Generate test tasks to verify bug fix and prevent regression"
+    },
+    {
+      "cmd": "/workflow:test-cycle-execute",
+      "unit": "test-validation",
+      "optional": true,
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute test-fix cycle until all tests pass"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/coupled.json

@@ -0,0 +1,71 @@
+{
+  "name": "coupled",
+  "description": "Full workflow for complex features - detailed planning with verification, execution, review, and testing",
+  "level": 3,
+  "steps": [
+    {
+      "cmd": "/workflow:plan",
+      "args": "\"{{goal}}\"",
+      "unit": "verified-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Create detailed implementation plan with architecture design, file structure, dependencies, and milestones"
+    },
+    {
+      "cmd": "/workflow:plan-verify",
+      "unit": "verified-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Verify IMPL_PLAN.md against requirements, check for missing details, conflicts, and quality gates"
+    },
+    {
+      "cmd": "/workflow:execute",
+      "unit": "verified-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute implementation based on verified plan. Resume from planning session with all context preserved."
+    },
+    {
+      "cmd": "/workflow:review-session-cycle",
+      "unit": "code-review",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Perform multi-dimensional code review across correctness, security, performance, maintainability. Reference execution session for full code context."
+    },
+    {
+      "cmd": "/workflow:review-cycle-fix",
+      "unit": "code-review",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Fix issues identified in review findings with prioritization by severity levels"
+    },
+    {
+      "cmd": "/workflow:test-fix-gen",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Generate comprehensive test tasks for the implementation with coverage analysis"
+    },
+    {
+      "cmd": "/workflow:test-cycle-execute",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute iterative test-fix cycle until pass rate >= 95%"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/debug.json

@@ -0,0 +1,16 @@
+{
+  "name": "debug",
+  "description": "Hypothesis-driven debugging with documentation - systematic troubleshooting and logging",
+  "level": 3,
+  "steps": [
+    {
+      "cmd": "/workflow:debug-with-file",
+      "args": "\"{{goal}}\"",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Systematic debugging with hypothesis formation and verification. Generate understanding.md with root cause analysis and fix recommendations"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/docs.json

@@ -0,0 +1,27 @@
+{
+  "name": "docs",
+  "description": "Documentation generation workflow",
+  "level": 2,
+  "steps": [
+    {
+      "cmd": "/workflow:lite-plan",
+      "args": "\"{{goal}}\"",
+      "unit": "quick-documentation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Plan documentation structure and content organization"
+    },
+    {
+      "cmd": "/workflow:lite-execute",
+      "args": "--in-memory",
+      "unit": "quick-documentation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute documentation generation from plan"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/full.json

@@ -0,0 +1,61 @@
+{
+  "name": "full",
+  "description": "Comprehensive workflow - brainstorm exploration, planning verification, execution, and testing",
+  "level": 4,
+  "steps": [
+    {
+      "cmd": "/workflow:brainstorm:auto-parallel",
+      "args": "\"{{goal}}\"",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Multi-perspective exploration of requirements and possible approaches"
+    },
+    {
+      "cmd": "/workflow:plan",
+      "unit": "verified-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Create detailed implementation plan based on brainstorm insights"
+    },
+    {
+      "cmd": "/workflow:plan-verify",
+      "unit": "verified-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Verify plan quality and completeness"
+    },
+    {
+      "cmd": "/workflow:execute",
+      "unit": "verified-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute implementation from verified plan"
+    },
+    {
+      "cmd": "/workflow:test-fix-gen",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Generate comprehensive test tasks"
+    },
+    {
+      "cmd": "/workflow:test-cycle-execute",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute test-fix cycle until pass rate >= 95%"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/issue.json

@@ -0,0 +1,43 @@
+{
+  "name": "issue",
+  "description": "Issue workflow - discover issues, create plans, queue execution, and resolve",
+  "level": "issue",
+  "steps": [
+    {
+      "cmd": "/workflow:issue:discover",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Discover pending issues from codebase for potential fixes"
+    },
+    {
+      "cmd": "/workflow:issue:plan",
+      "args": "--all-pending",
+      "unit": "issue-workflow",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Create execution plans for all discovered pending issues"
+    },
+    {
+      "cmd": "/workflow:issue:queue",
+      "unit": "issue-workflow",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Build execution queue with issue prioritization and dependencies"
+    },
+    {
+      "cmd": "/workflow:issue:execute",
+      "unit": "issue-workflow",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute issues from queue with state tracking and completion reporting"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/lite-lite-lite.json

@@ -0,0 +1,16 @@
+{
+  "name": "lite-lite-lite",
+  "description": "Ultra-lightweight for immediate simple tasks - minimal overhead, direct execution",
+  "level": 1,
+  "steps": [
+    {
+      "cmd": "/workflow:lite-lite-lite",
+      "args": "\"{{goal}}\"",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Direct task execution with minimal analysis and zero documentation overhead"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/multi-cli-plan.json

@@ -0,0 +1,47 @@
+{
+  "name": "multi-cli-plan",
+  "description": "Multi-perspective planning with cross-tool verification and execution",
+  "level": 3,
+  "steps": [
+    {
+      "cmd": "/workflow:multi-cli-plan",
+      "args": "\"{{goal}}\"",
+      "unit": "multi-cli-planning",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Multi-perspective analysis comparing different implementation approaches with trade-off analysis"
+    },
+    {
+      "cmd": "/workflow:lite-execute",
+      "args": "--in-memory",
+      "unit": "multi-cli-planning",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute best approach selected from multi-perspective analysis"
+    },
+    {
+      "cmd": "/workflow:test-fix-gen",
+      "unit": "test-validation",
+      "optional": true,
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Generate test tasks for the implementation"
+    },
+    {
+      "cmd": "/workflow:test-cycle-execute",
+      "unit": "test-validation",
+      "optional": true,
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute test-fix cycle until pass rate >= 95%"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/rapid-to-issue.json

@@ -0,0 +1,46 @@
+{
+  "name": "rapid-to-issue",
+  "description": "Bridge lite workflow to issue workflow - convert simple plan to structured issue execution",
+  "level": 2.5,
+  "steps": [
+    {
+      "cmd": "/workflow:lite-plan",
+      "args": "\"{{goal}}\"",
+      "unit": "rapid-to-issue",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Create lightweight plan for the task"
+    },
+    {
+      "cmd": "/workflow:issue:convert-to-plan",
+      "args": "--latest-lite-plan -y",
+      "unit": "rapid-to-issue",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Convert lite plan to structured issue plan"
+    },
+    {
+      "cmd": "/workflow:issue:queue",
+      "unit": "rapid-to-issue",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Build execution queue from converted plan"
+    },
+    {
+      "cmd": "/workflow:issue:execute",
+      "args": "--queue auto",
+      "unit": "rapid-to-issue",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute issues from queue with state tracking"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/rapid.json

@@ -0,0 +1,47 @@
+{
+  "name": "rapid",
+  "description": "Quick implementation - lightweight plan and immediate execution for simple features",
+  "level": 2,
+  "steps": [
+    {
+      "cmd": "/workflow:lite-plan",
+      "args": "\"{{goal}}\"",
+      "unit": "quick-implementation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Analyze requirements and create a lightweight implementation plan with key decisions and file structure"
+    },
+    {
+      "cmd": "/workflow:lite-execute",
+      "args": "--in-memory",
+      "unit": "quick-implementation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Use the plan from previous step to implement code. Execute against in-memory state."
+    },
+    {
+      "cmd": "/workflow:test-fix-gen",
+      "unit": "test-validation",
+      "optional": true,
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Generate test tasks from the implementation session"
+    },
+    {
+      "cmd": "/workflow:test-cycle-execute",
+      "unit": "test-validation",
+      "optional": true,
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute test-fix cycle until all tests pass"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/review.json

@@ -0,0 +1,43 @@
+{
+  "name": "review",
+  "description": "Code review workflow - multi-dimensional review, fix issues, and test validation",
+  "level": 3,
+  "steps": [
+    {
+      "cmd": "/workflow:review-session-cycle",
+      "unit": "code-review",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Perform comprehensive multi-dimensional code review across correctness, security, performance, maintainability dimensions"
+    },
+    {
+      "cmd": "/workflow:review-cycle-fix",
+      "unit": "code-review",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Fix all review findings prioritized by severity level (critical → high → medium → low)"
+    },
+    {
+      "cmd": "/workflow:test-fix-gen",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Generate test tasks for fixed code with coverage analysis"
+    },
+    {
+      "cmd": "/workflow:test-cycle-execute",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute iterative test-fix cycle until pass rate >= 95%"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/tdd.json

@@ -0,0 +1,34 @@
+{
+  "name": "tdd",
+  "description": "Test-driven development - write tests first, implement to pass tests, verify Red-Green-Refactor cycles",
+  "level": 3,
+  "steps": [
+    {
+      "cmd": "/workflow:tdd-plan",
+      "args": "\"{{goal}}\"",
+      "unit": "tdd-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Create TDD task plan with Red-Green-Refactor cycles, test specifications, and implementation strategy"
+    },
+    {
+      "cmd": "/workflow:execute",
+      "unit": "tdd-planning-execution",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute TDD tasks following Red-Green-Refactor workflow with test-first development"
+    },
+    {
+      "cmd": "/workflow:tdd-verify",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Verify TDD cycle compliance, test coverage, and code quality against Red-Green-Refactor principles"
+    }
+  ]
+}

.claude/skills/flow-coordinator/templates/test-fix.json

@@ -0,0 +1,26 @@
+{
+  "name": "test-fix",
+  "description": "Fix failing tests - generate test tasks and execute iterative test-fix cycle",
+  "level": 2,
+  "steps": [
+    {
+      "cmd": "/workflow:test-fix-gen",
+      "args": "\"{{goal}}\"",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "mainprocess"
+      },
+      "contextHint": "Analyze failing tests, generate targeted test tasks with root cause and fix strategy"
+    },
+    {
+      "cmd": "/workflow:test-cycle-execute",
+      "unit": "test-validation",
+      "execution": {
+        "type": "slash-command",
+        "mode": "async"
+      },
+      "contextHint": "Execute iterative test-fix cycle with pass rate tracking until >= 95% pass rate achieved"
+    }
+  ]
+}

.claude/skills/lite-skill-generator/SKILL.md

@@ -0,0 +1,650 @@
+---
+name: lite-skill-generator
+description: Lightweight skill generator with style learning - creates simple skills using flow-based execution and style imitation. Use for quick skill scaffolding, simple workflow creation, or style-aware skill generation.
+allowed-tools: Read, Write, Bash, Glob, Grep, AskUserQuestion
+---
+
+# Lite Skill Generator
+
+Lightweight meta-skill for rapid skill creation with intelligent style learning and flow-based execution.
+
+## Core Concept
+
+**Simplicity First**: Generate simple, focused skills quickly with minimal overhead. Learn from existing skills to maintain consistent style and structure.
+
+**Progressive Disclosure**: Follow anthropics' three-layer loading principle:
+1. **Metadata** - name, description, triggers (always loaded)
+2. **SKILL.md** - core instructions (loaded when triggered)
+3. **Bundled resources** - scripts, references, assets (loaded on demand)
+
+## Execution Model
+
+**3-Phase Flow**: Style Learning → Requirements Gathering → Generation
+
+```
+User Input → Phase 1: Style Analysis → Phase 2: Requirements → Phase 3: Generate → Skill Package
+                ↓                            ↓                        ↓
+         Learn from examples      Interactive prompts      Write files + validate
+```
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    Lite Skill Generator                          │
+│                                                                  │
+│  Input: Skill name, purpose, reference skills                   │
+│                         ↓                                        │
+│  ┌─────────────────────────────────────────────────────────┐    │
+│  │  Phase 1-3: Lightweight Pipeline                        │    │
+│  │  ┌────┐ ┌────┐ ┌────┐                                  │    │
+│  │  │ P1 │→│ P2 │→│ P3 │                                  │    │
+│  │  │Styl│ │Req │ │Gen │                                  │    │
+│  │  └────┘ └────┘ └────┘                                  │    │
+│  └─────────────────────────────────────────────────────────┘    │
+│                         ↓                                        │
+│  Output: .claude/skills/{skill-name}/ (minimal package)         │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 3-Phase Workflow
+
+### Phase 1: Style Analysis & Learning
+
+Analyze reference skills to extract language patterns, structural conventions, and writing style.
+
+```javascript
+// Phase 1 Execution Flow
+async function analyzeStyle(referencePaths) {
+  // Step 1: Load reference skills
+  const references = [];
+  for (const path of referencePaths) {
+    const content = Read(path);
+    references.push({
+      path: path,
+      content: content,
+      metadata: extractYAMLFrontmatter(content)
+    });
+  }
+
+  // Step 2: Extract style patterns
+  const styleProfile = {
+    // Structural patterns
+    structure: {
+      hasFrontmatter: references.every(r => r.metadata !== null),
+      sectionHeaders: extractCommonSections(references),
+      codeBlockUsage: detectCodeBlockPatterns(references),
+      flowDiagramUsage: detectFlowDiagrams(references)
+    },
+
+    // Language patterns
+    language: {
+      instructionStyle: detectInstructionStyle(references), // 'imperative' | 'declarative' | 'procedural'
+      pseudocodeUsage: detectPseudocodePatterns(references),
+      verbosity: calculateVerbosityLevel(references),      // 'concise' | 'detailed' | 'verbose'
+      terminology: extractCommonTerms(references)
+    },
+
+    // Organization patterns
+    organization: {
+      phaseStructure: detectPhasePattern(references),      // 'sequential' | 'autonomous' | 'flat'
+      exampleDensity: calculateExampleRatio(references),
+      templateUsage: detectTemplateReferences(references)
+    }
+  };
+
+  // Step 3: Generate style guide
+  return {
+    profile: styleProfile,
+    recommendations: generateStyleRecommendations(styleProfile),
+    examples: extractStyleExamples(references, styleProfile)
+  };
+}
+
+// Structural pattern detection
+function extractCommonSections(references) {
+  const allSections = references.map(r =>
+    r.content.match(/^##? (.+)$/gm)?.map(s => s.replace(/^##? /, ''))
+  ).flat();
+  return findMostCommon(allSections);
+}
+
+// Language style detection
+function detectInstructionStyle(references) {
+  const imperativePattern = /^(Use|Execute|Run|Call|Create|Generate)\s/gim;
+  const declarativePattern = /^(The|This|Each|All)\s.*\s(is|are|will be)\s/gim;
+  const proceduralPattern = /^(Step \d+|Phase \d+|First|Then|Finally)\s/gim;
+
+  const scores = references.map(r => ({
+    imperative: (r.content.match(imperativePattern) || []).length,
+    declarative: (r.content.match(declarativePattern) || []).length,
+    procedural: (r.content.match(proceduralPattern) || []).length
+  }));
+
+  return getMaxStyle(scores);
+}
+
+// Pseudocode pattern detection
+function detectPseudocodePatterns(references) {
+  const hasJavaScriptBlocks = references.some(r => r.content.includes('```javascript'));
+  const hasFunctionDefs = references.some(r => /function\s+\w+\(/m.test(r.content));
+  const hasFlowComments = references.some(r => /\/\/.*→/m.test(r.content));
+
+  return {
+    usePseudocode: hasJavaScriptBlocks && hasFunctionDefs,
+    flowAnnotations: hasFlowComments,
+    style: hasFunctionDefs ? 'functional' : 'imperative'
+  };
+}
+```
+
+**Output**:
+```
+Style Analysis Complete:
+  Structure: Flow-based with pseudocode
+  Language: Procedural, detailed
+  Organization: Sequential phases
+  Key Patterns: 3-5 phases, function definitions, ASCII diagrams
+
+Recommendations:
+  ✓ Use phase-based structure (3-4 phases)
+  ✓ Include pseudocode for complex logic
+  ✓ Add ASCII flow diagrams
+  ✓ Maintain concise documentation style
+```
+
+---
+
+### Phase 2: Requirements Gathering
+
+Interactive discovery of skill requirements using learned style patterns.
+
+```javascript
+async function gatherRequirements(styleProfile) {
+  // Step 1: Basic information
+  const basicInfo = await AskUserQuestion({
+    questions: [
+      {
+        question: "What is the skill name? (kebab-case, e.g., 'pdf-generator')",
+        header: "Name",
+        options: [
+          { label: "pdf-generator", description: "Example: PDF generation skill" },
+          { label: "code-analyzer", description: "Example: Code analysis skill" },
+          { label: "Custom", description: "Enter custom name" }
+        ]
+      },
+      {
+        question: "What is the primary purpose?",
+        header: "Purpose",
+        options: [
+          { label: "Generation", description: "Create/generate artifacts" },
+          { label: "Analysis", description: "Analyze/inspect code or data" },
+          { label: "Transformation", description: "Convert/transform content" },
+          { label: "Orchestration", description: "Coordinate multiple operations" }
+        ]
+      }
+    ]
+  });
+
+  // Step 2: Execution complexity
+  const complexity = await AskUserQuestion({
+    questions: [{
+      question: "How many main steps does this skill need?",
+      header: "Steps",
+      options: [
+        { label: "2-3 steps", description: "Simple workflow (recommended for lite-skill)" },
+        { label: "4-5 steps", description: "Moderate workflow" },
+        { label: "6+ steps", description: "Complex workflow (consider full skill-generator)" }
+      ]
+    }]
+  });
+
+  // Step 3: Tool requirements
+  const tools = await AskUserQuestion({
+    questions: [{
+      question: "Which tools will this skill use? (select multiple)",
+      header: "Tools",
+      multiSelect: true,
+      options: [
+        { label: "Read", description: "Read files" },
+        { label: "Write", description: "Write files" },
+        { label: "Bash", description: "Execute commands" },
+        { label: "Task", description: "Launch agents" },
+        { label: "AskUserQuestion", description: "Interactive prompts" }
+      ]
+    }]
+  });
+
+  // Step 4: Output format
+  const output = await AskUserQuestion({
+    questions: [{
+      question: "What does this skill produce?",
+      header: "Output",
+      options: [
+        { label: "Single file", description: "One main output file" },
+        { label: "Multiple files", description: "Several related files" },
+        { label: "Directory structure", description: "Complete directory tree" },
+        { label: "Modified files", description: "Edits to existing files" }
+      ]
+    }]
+  });
+
+  // Step 5: Build configuration
+  return {
+    name: basicInfo.Name,
+    purpose: basicInfo.Purpose,
+    description: generateDescription(basicInfo.Name, basicInfo.Purpose),
+    steps: parseStepCount(complexity.Steps),
+    allowedTools: tools.Tools,
+    outputType: output.Output,
+    styleProfile: styleProfile,
+    triggerPhrases: generateTriggerPhrases(basicInfo.Name, basicInfo.Purpose)
+  };
+}
+
+// Generate skill description from name and purpose
+function generateDescription(name, purpose) {
+  const templates = {
+    Generation: `Generate ${humanize(name)} with intelligent scaffolding`,
+    Analysis: `Analyze ${humanize(name)} with detailed reporting`,
+    Transformation: `Transform ${humanize(name)} with format conversion`,
+    Orchestration: `Orchestrate ${humanize(name)} workflow with multi-step coordination`
+  };
+  return templates[purpose] || `${humanize(name)} skill for ${purpose.toLowerCase()} tasks`;
+}
+
+// Generate trigger phrases
+function generateTriggerPhrases(name, purpose) {
+  const base = [name, name.replace(/-/g, ' ')];
+  const purposeVariants = {
+    Generation: ['generate', 'create', 'build'],
+    Analysis: ['analyze', 'inspect', 'review'],
+    Transformation: ['transform', 'convert', 'format'],
+    Orchestration: ['orchestrate', 'coordinate', 'manage']
+  };
+  return [...base, ...purposeVariants[purpose].map(v => `${v} ${humanize(name)}`)];
+}
+```
+
+**Display to User**:
+```
+Requirements Gathered:
+  Name: pdf-generator
+  Purpose: Generation
+  Steps: 3 (Setup → Generate → Validate)
+  Tools: Read, Write, Bash
+  Output: Single file (PDF document)
+  Triggers: "pdf-generator", "generate pdf", "create pdf"
+
+Style Application:
+  Using flow-based structure (from style analysis)
+  Including pseudocode blocks
+  Adding ASCII diagrams for clarity
+```
+
+---
+
+### Phase 3: Generate Skill Package
+
+Create minimal skill structure with style-aware content generation.
+
+```javascript
+async function generateSkillPackage(requirements) {
+  const skillDir = `.claude/skills/${requirements.name}`;
+  const workDir = `.workflow/.scratchpad/lite-skill-gen-${Date.now()}`;
+
+  // Step 1: Create directory structure
+  Bash(`mkdir -p "${skillDir}" "${workDir}"`);
+
+  // Step 2: Generate SKILL.md (using learned style)
+  const skillContent = generateSkillMd(requirements);
+  Write(`${skillDir}/SKILL.md`, skillContent);
+
+  // Step 3: Conditionally add bundled resources
+  if (requirements.outputType === 'Directory structure') {
+    Bash(`mkdir -p "${skillDir}/templates"`);
+    const templateContent = generateTemplate(requirements);
+    Write(`${skillDir}/templates/base-template.md`, templateContent);
+  }
+
+  if (requirements.allowedTools.includes('Bash')) {
+    Bash(`mkdir -p "${skillDir}/scripts"`);
+    const scriptContent = generateScript(requirements);
+    Write(`${skillDir}/scripts/helper.sh`, scriptContent);
+  }
+
+  // Step 4: Generate README
+  const readmeContent = generateReadme(requirements);
+  Write(`${skillDir}/README.md`, readmeContent);
+
+  // Step 5: Validate structure
+  const validation = validateSkillStructure(skillDir, requirements);
+  Write(`${workDir}/validation-report.json`, JSON.stringify(validation, null, 2));
+
+  // Step 6: Return summary
+  return {
+    skillPath: skillDir,
+    filesCreated: [
+      `${skillDir}/SKILL.md`,
+      ...(validation.hasTemplates ? [`${skillDir}/templates/`] : []),
+      ...(validation.hasScripts ? [`${skillDir}/scripts/`] : []),
+      `${skillDir}/README.md`
+    ],
+    validation: validation,
+    nextSteps: generateNextSteps(requirements)
+  };
+}
+
+// Generate SKILL.md with style awareness
+function generateSkillMd(req) {
+  const { styleProfile } = req;
+
+  // YAML frontmatter
+  const frontmatter = `---
+name: ${req.name}
+description: ${req.description}
+allowed-tools: ${req.allowedTools.join(', ')}
+---
+`;
+
+  // Main content structure (adapts to style)
+  let content = frontmatter;
+
+  content += `\n# ${humanize(req.name)}\n\n`;
+  content += `${req.description}\n\n`;
+
+  // Add architecture diagram if style uses them
+  if (styleProfile.structure.flowDiagramUsage) {
+    content += generateArchitectureDiagram(req);
+  }
+
+  // Add execution flow
+  content += `## Execution Flow\n\n`;
+  if (styleProfile.language.pseudocodeUsage.usePseudocode) {
+    content += generatePseudocodeFlow(req);
+  } else {
+    content += generateProceduralFlow(req);
+  }
+
+  // Add phase sections
+  for (let i = 0; i < req.steps; i++) {
+    content += generatePhaseSection(i + 1, req, styleProfile);
+  }
+
+  // Add examples if style is verbose
+  if (styleProfile.language.verbosity !== 'concise') {
+    content += generateExamplesSection(req);
+  }
+
+  return content;
+}
+
+// Generate architecture diagram
+function generateArchitectureDiagram(req) {
+  return `## Architecture
+\`\`\`
+┌─────────────────────────────────────────────────┐
+│               ${humanize(req.name)}              │
+│                                                 │
+│  Input → Phase 1 → Phase 2 → Phase 3 → Output  │
+│          ${getPhaseName(1, req)}                 │
+│          ${getPhaseName(2, req)}                 │
+│          ${getPhaseName(3, req)}                 │
+└─────────────────────────────────────────────────┘
+\`\`\`
+
+`;
+}
+
+// Generate pseudocode flow
+function generatePseudocodeFlow(req) {
+  return `\`\`\`javascript
+async function ${toCamelCase(req.name)}(input) {
+  // Phase 1: ${getPhaseName(1, req)}
+  const prepared = await phase1Prepare(input);
+
+  // Phase 2: ${getPhaseName(2, req)}
+  const processed = await phase2Process(prepared);
+
+  // Phase 3: ${getPhaseName(3, req)}
+  const result = await phase3Finalize(processed);
+
+  return result;
+}
+\`\`\`
+
+`;
+}
+
+// Generate phase section
+function generatePhaseSection(phaseNum, req, styleProfile) {
+  const phaseName = getPhaseName(phaseNum, req);
+
+  let section = `### Phase ${phaseNum}: ${phaseName}\n\n`;
+
+  if (styleProfile.language.pseudocodeUsage.usePseudocode) {
+    section += `\`\`\`javascript\n`;
+    section += `async function phase${phaseNum}${toCamelCase(phaseName)}(input) {\n`;
+    section += `  // TODO: Implement ${phaseName.toLowerCase()} logic\n`;
+    section += `  return output;\n`;
+    section += `}\n\`\`\`\n\n`;
+  } else {
+    section += `**Steps**:\n`;
+    section += `1. Load input data\n`;
+    section += `2. Process according to ${phaseName.toLowerCase()} logic\n`;
+    section += `3. Return result to next phase\n\n`;
+  }
+
+  return section;
+}
+
+// Validation
+function validateSkillStructure(skillDir, req) {
+  const requiredFiles = [`${skillDir}/SKILL.md`, `${skillDir}/README.md`];
+  const exists = requiredFiles.map(f => Bash(`test -f "${f}"`).exitCode === 0);
+
+  return {
+    valid: exists.every(e => e),
+    hasTemplates: Bash(`test -d "${skillDir}/templates"`).exitCode === 0,
+    hasScripts: Bash(`test -d "${skillDir}/scripts"`).exitCode === 0,
+    filesPresent: requiredFiles.filter((f, i) => exists[i]),
+    styleCompliance: checkStyleCompliance(skillDir, req.styleProfile)
+  };
+}
+```
+
+**Output**:
+```
+Skill Package Generated:
+  Location: .claude/skills/pdf-generator/
+
+Structure:
+  ✓ SKILL.md (entry point)
+  ✓ README.md (usage guide)
+  ✓ templates/ (directory templates)
+  ✓ scripts/ (helper scripts)
+
+Validation:
+  ✓ All required files present
+  ✓ Style compliance: 95%
+  ✓ Frontmatter valid
+  ✓ Tool references correct
+
+Next Steps:
+  1. Review SKILL.md and customize phases
+  2. Test skill: /skill:pdf-generator "test input"
+  3. Iterate based on usage
+```
+
+---
+
+## Complete Execution Flow
+
+```
+User: "Create a PDF generator skill"
+    ↓
+Phase 1: Style Analysis
+    |-- Read reference skills (ccw.md, ccw-coordinator.md)
+    |-- Extract style patterns (flow diagrams, pseudocode, structure)
+    |-- Generate style profile
+    +-- Output: Style recommendations
+    ↓
+Phase 2: Requirements
+    |-- Ask: Name, purpose, steps
+    |-- Ask: Tools, output format
+    |-- Generate: Description, triggers
+    +-- Output: Requirements config
+    ↓
+Phase 3: Generation
+    |-- Create: Directory structure
+    |-- Write: SKILL.md (style-aware)
+    |-- Write: README.md
+    |-- Optionally: templates/, scripts/
+    |-- Validate: Structure and style
+    +-- Output: Skill package
+    ↓
+Return: Skill location + next steps
+```
+
+## Phase Execution Protocol
+
+```javascript
+// Main entry point
+async function liteSkillGenerator(input) {
+  // Phase 1: Style Learning
+  const references = [
+    '.claude/commands/ccw.md',
+    '.claude/commands/ccw-coordinator.md',
+    ...discoverReferenceSkills(input)
+  ];
+  const styleProfile = await analyzeStyle(references);
+  console.log(`Style Analysis: ${styleProfile.organization.phaseStructure}, ${styleProfile.language.verbosity}`);
+
+  // Phase 2: Requirements
+  const requirements = await gatherRequirements(styleProfile);
+  console.log(`Requirements: ${requirements.name} (${requirements.steps} phases)`);
+
+  // Phase 3: Generation
+  const result = await generateSkillPackage(requirements);
+  console.log(`✅ Generated: ${result.skillPath}`);
+
+  return result;
+}
+```
+
+## Output Structure
+
+**Minimal Package** (default):
+```
+.claude/skills/{skill-name}/
+├── SKILL.md                # Entry point with frontmatter
+└── README.md               # Usage guide
+```
+
+**With Templates** (if needed):
+```
+.claude/skills/{skill-name}/
+├── SKILL.md
+├── README.md
+└── templates/
+    └── base-template.md
+```
+
+**With Scripts** (if using Bash):
+```
+.claude/skills/{skill-name}/
+├── SKILL.md
+├── README.md
+└── scripts/
+    └── helper.sh
+```
+
+## Key Design Principles
+
+1. **Style Learning** - Analyze reference skills to maintain consistency
+2. **Minimal Overhead** - Generate only essential files (SKILL.md + README)
+3. **Progressive Disclosure** - Follow anthropics' three-layer loading
+4. **Flow-Based** - Use pseudocode and flow diagrams (when style appropriate)
+5. **Interactive** - Guided requirements gathering via AskUserQuestion
+6. **Fast Generation** - 3 phases instead of 6, focused on simplicity
+7. **Style Awareness** - Adapt output based on detected patterns
+
+## Style Pattern Detection
+
+**Structural Patterns**:
+- YAML frontmatter usage (100% in references)
+- Section headers (H2 for major, H3 for sub-sections)
+- Code blocks (JavaScript pseudocode, Bash examples)
+- ASCII diagrams (architecture, flow charts)
+
+**Language Patterns**:
+- Instruction style: Procedural with function definitions
+- Pseudocode: JavaScript-based with flow annotations
+- Verbosity: Detailed but focused
+- Terminology: Phase, workflow, pipeline, orchestrator
+
+**Organization Patterns**:
+- Phase structure: 3-5 sequential phases
+- Example density: Moderate (1-2 per major section)
+- Template usage: Minimal (only when necessary)
+
+## Usage Examples
+
+**Basic Generation**:
+```
+User: "Create a markdown formatter skill"
+Lite-Skill-Generator:
+  → Analyzes ccw.md style
+  → Asks: Name? "markdown-formatter"
+  → Asks: Purpose? "Transformation"
+  → Asks: Steps? "3 steps"
+  → Generates: .claude/skills/markdown-formatter/
+```
+
+**With Custom References**:
+```
+User: "Create a skill like software-manual but simpler"
+Lite-Skill-Generator:
+  → Analyzes software-manual skill
+  → Learns: Multi-phase, agent-based, template-heavy
+  → Simplifies: 3 phases, direct execution, minimal templates
+  → Generates: Simplified version
+```
+
+## Comparison: lite-skill-generator vs skill-generator
+
+| Aspect | lite-skill-generator | skill-generator |
+|--------|---------------------|-----------------|
+| **Phases** | 3 (Style → Req → Gen) | 6 (Spec → Req → Dir → Gen → Specs → Val) |
+| **Style Learning** | Yes (analyze references) | No (fixed templates) |
+| **Complexity** | Simple skills only | Full-featured skills |
+| **Output** | Minimal (SKILL.md + README) | Complete (phases/, specs/, templates/) |
+| **Generation Time** | Fast (~2 min) | Thorough (~10 min) |
+| **Use Case** | Quick scaffolding | Production-ready skills |
+
+## Workflow Integration
+
+**Standalone**:
+```bash
+/skill:lite-skill-generator "Create a log analyzer skill"
+```
+
+**With References**:
+```bash
+/skill:lite-skill-generator "Create a skill based on ccw-coordinator.md style"
+```
+
+**Batch Generation** (for multiple simple skills):
+```bash
+/skill:lite-skill-generator "Create 3 skills: json-validator, yaml-parser, toml-converter"
+```
+
+---
+
+**Next Steps After Generation**:
+1. Review `.claude/skills/{name}/SKILL.md`
+2. Customize phase logic for your use case
+3. Add examples to README.md
+4. Test skill with sample input
+5. Iterate based on real usage

.claude/skills/lite-skill-generator/templates/simple-skill.md

@@ -0,0 +1,68 @@
+---
+name: {{SKILL_NAME}}
+description: {{SKILL_DESCRIPTION}}
+allowed-tools: {{ALLOWED_TOOLS}}
+---
+
+# {{SKILL_TITLE}}
+
+{{SKILL_DESCRIPTION}}
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│               {{SKILL_TITLE}}                    │
+│                                                 │
+│  Input → {{PHASE_1}} → {{PHASE_2}} → Output    │
+└─────────────────────────────────────────────────┘
+```
+
+## Execution Flow
+
+```javascript
+async function {{SKILL_FUNCTION}}(input) {
+  // Phase 1: {{PHASE_1}}
+  const prepared = await phase1(input);
+
+  // Phase 2: {{PHASE_2}}
+  const result = await phase2(prepared);
+
+  return result;
+}
+```
+
+### Phase 1: {{PHASE_1}}
+
+```javascript
+async function phase1(input) {
+  // TODO: Implement {{PHASE_1_LOWER}} logic
+  return output;
+}
+```
+
+### Phase 2: {{PHASE_2}}
+
+```javascript
+async function phase2(input) {
+  // TODO: Implement {{PHASE_2_LOWER}} logic
+  return output;
+}
+```
+
+## Usage
+
+```bash
+/skill:{{SKILL_NAME}} "input description"
+```
+
+## Examples
+
+**Basic Usage**:
+```
+User: "{{EXAMPLE_INPUT}}"
+{{SKILL_NAME}}:
+  → Phase 1: {{PHASE_1_ACTION}}
+  → Phase 2: {{PHASE_2_ACTION}}
+  → Output: {{EXAMPLE_OUTPUT}}
+```

.claude/skills/lite-skill-generator/templates/style-guide.md

@@ -0,0 +1,64 @@
+# Style Guide Template
+
+Generated by lite-skill-generator style analysis phase.
+
+## Detected Patterns
+
+### Structural Patterns
+
+| Pattern | Detected | Recommendation |
+|---------|----------|----------------|
+| YAML Frontmatter | {{HAS_FRONTMATTER}} | {{FRONTMATTER_REC}} |
+| ASCII Diagrams | {{HAS_DIAGRAMS}} | {{DIAGRAMS_REC}} |
+| Code Blocks | {{HAS_CODE_BLOCKS}} | {{CODE_BLOCKS_REC}} |
+| Phase Structure | {{PHASE_STRUCTURE}} | {{PHASE_REC}} |
+
+### Language Patterns
+
+| Pattern | Value | Notes |
+|---------|-------|-------|
+| Instruction Style | {{INSTRUCTION_STYLE}} | imperative/declarative/procedural |
+| Pseudocode Usage | {{PSEUDOCODE_USAGE}} | functional/imperative/none |
+| Verbosity Level | {{VERBOSITY}} | concise/detailed/verbose |
+| Common Terms | {{TERMINOLOGY}} | domain-specific vocabulary |
+
+### Organization Patterns
+
+| Pattern | Value |
+|---------|-------|
+| Phase Count | {{PHASE_COUNT}} |
+| Example Density | {{EXAMPLE_DENSITY}} |
+| Template Usage | {{TEMPLATE_USAGE}} |
+
+## Style Compliance Checklist
+
+- [ ] YAML frontmatter with name, description, allowed-tools
+- [ ] Architecture diagram (if pattern detected)
+- [ ] Execution flow section with pseudocode
+- [ ] Phase sections (sequential numbered)
+- [ ] Usage examples section
+- [ ] README.md for external documentation
+
+## Reference Skills Analyzed
+
+{{#REFERENCES}}
+- `{{REF_PATH}}`: {{REF_NOTES}}
+{{/REFERENCES}}
+
+## Generated Configuration
+
+```json
+{
+  "style": {
+    "structure": "{{STRUCTURE_TYPE}}",
+    "language": "{{LANGUAGE_TYPE}}",
+    "organization": "{{ORG_TYPE}}"
+  },
+  "recommendations": {
+    "usePseudocode": {{USE_PSEUDOCODE}},
+    "includeDiagrams": {{INCLUDE_DIAGRAMS}},
+    "verbosityLevel": "{{VERBOSITY}}",
+    "phaseCount": {{PHASE_COUNT}}
+  }
+}
+```

.claude/skills/skill-generator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: skill-generator
-description: Meta-skill for creating new Claude Code skills with configurable execution modes. Supports sequential (fixed order) and autonomous (stateless) phase patterns. Use for skill scaffolding, skill creation, or building new workflows. Triggers on "create skill", "new skill", "skill generator", "生成技能", "创建技能".
+description: Meta-skill for creating new Claude Code skills with configurable execution modes. Supports sequential (fixed order) and autonomous (stateless) phase patterns. Use for skill scaffolding, skill creation, or building new workflows. Triggers on "create skill", "new skill", "skill generator".
 allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write
 ---
 
@@ -12,215 +12,454 @@ Meta-skill for creating new Claude Code skills with configurable execution modes
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
-│  Skill Generator Architecture                                    │
+│                    Skill Generator                               │
-├─────────────────────────────────────────────────────────────────┤
 │                                                                  │
-│  ⚠️ Phase 0: Specification  → 阅读并理解设计规范 (强制前置)      │
+│  Input: User Request (skill name, purpose, mode)                │
-│              Study              SKILL-DESIGN-SPEC.md + 模板     │
+│                         ↓                                        │
-│           ↓                                                      │
+│  ┌─────────────────────────────────────────────────────────┐    │
-│  Phase 1: Requirements    → skill-config.json                   │
+│  │  Phase 0-5: Sequential Pipeline                          │    │
-│           Discovery           (name, type, mode, agents)        │
+│  │  ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐             │    │
-│           ↓                                                      │
+│  │  │ P0 │→│ P1 │→│ P2 │→│ P3 │→│ P4 │→│ P5 │             │    │
-│  Phase 2: Structure       → 目录结构 + 核心文件骨架              │
+│  │  │Spec│ │Req │ │Dir │ │Gen │ │Spec│ │Val │             │    │
-│           Generation                                             │
+│  │  └────┘ └────┘ └────┘ └─┬──┘ └────┘ └────┘             │    │
-│           ↓                                                      │
+│  │                         │                                │    │
-│  Phase 3: Phase           → phases/*.md (根据 mode 生成)         │
+│  │                    ┌────┴────┐                           │    │
-│           Generation          Sequential | Autonomous            │
+│  │                    ↓         ↓                           │    │
-│           ↓                                                      │
+│  │              Sequential  Autonomous                      │    │
-│  Phase 4: Specs &         → specs/*.md + templates/*.md         │
+│  │              (phases/)   (actions/)                      │    │
-│           Templates                                              │
+│  └─────────────────────────────────────────────────────────┘    │
-│           ↓                                                      │
+│                         ↓                                        │
-│  Phase 5: Validation      → 验证完整性 + 生成使用说明            │
+│  Output: .claude/skills/{skill-name}/ (complete package)        │
-│           & Documentation                                        │
 │                                                                  │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
 ## Execution Modes
 
-### Mode 1: Sequential (固定顺序)
+### Mode 1: Sequential (Fixed Order)
 
-传统线性执行模式，阶段按数字前缀顺序执行。
+Traditional linear execution model, phases execute in numeric prefix order.
 
 ```
-Phase 01 → Phase 02 → Phase 03 → ... → Phase N
+Phase 01 -> Phase 02 -> Phase 03 -> ... -> Phase N
 ```
 
-**适用场景**:
+**Use Cases**:
-- 流水线式任务（收集 → 分析 → 生成）
+- Pipeline tasks (collect -> analyze -> generate)
-- 阶段间有强依赖关系
+- Strong dependencies between phases
-- 输出结构固定
+- Fixed output structure
 
-**示例**: `software-manual`, `copyright-docs`
+**Examples**: `software-manual`, `copyright-docs`
 
-### Mode 2: Autonomous (无状态自主选择)
+### Mode 2: Autonomous (Stateless Auto-Select)
 
-智能路由模式，根据上下文动态选择执行路径。
+Intelligent routing model, dynamically selects execution path based on context.
 
 ```
-┌─────────────────────────────────────────┐
+---------------------------------------------------
-│           Orchestrator Agent            │
+                Orchestrator Agent
-│  (读取状态 → 选择 Phase → 执行 → 更新)  │
+   (Read state -> Select Phase -> Execute -> Update)
-└───────────────┬─────────────────────────┘
+---------------------------------------------------
-                │
+                |
-    ┌───────────┼───────────┐
+    ---------+----------+----------
-    ↓           ↓           ↓
+    |        |          |
-┌───────┐  ┌───────┐  ┌───────┐
+  Phase A   Phase B    Phase C
-│Phase A│  │Phase B│  │Phase C│
+  (standalone)  (standalone)  (standalone)
-│(独立) │  │(独立) │  │(独立) │
-└───────┘  └───────┘  └───────┘
 ```
 
-**适用场景**:
+**Use Cases**:
-- 交互式任务（对话、问答）
+- Interactive tasks (chat, Q&A)
-- 阶段间无强依赖
+- No strong dependencies between phases
-- 需要动态响应用户意图
+- Dynamic user intent response required
 
-**示例**: `issue-manage`, `workflow-debug`
+**Examples**: `issue-manage`, `workflow-debug`
 
 ## Key Design Principles
 
-1. **模式感知**: 根据任务特性自动推荐执行模式
+1. **Mode Awareness**: Automatically recommend execution mode based on task characteristics
-2. **骨架生成**: 生成完整目录结构和文件骨架
+2. **Skeleton Generation**: Generate complete directory structure and file skeletons
-3. **规范遵循**: 严格遵循 `_shared/SKILL-DESIGN-SPEC.md`
+3. **Standards Compliance**: Strictly follow `_shared/SKILL-DESIGN-SPEC.md`
-4. **可扩展性**: 生成的 Skill 易于扩展和修改
+4. **Extensibility**: Generated Skills are easy to extend and modify
 
 ---
 
-## ⚠️ Mandatory Prerequisites (强制前置条件)
+## Required Prerequisites
 
-> **⛔ 禁止跳过**: 在执行任何生成操作之前，**必须**完整阅读以下文档。未阅读规范直接生成将导致输出不符合质量标准。
+IMPORTANT: Before any generation operation, read the following specification documents. Generating without understanding these standards will result in non-conforming output.
 
-### 核心规范 (必读)
+### Core Specifications (Mandatory Read)
 
 | Document | Purpose | Priority |
 |----------|---------|----------|
-| [../_shared/SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) | 通用设计规范 - 定义所有 Skill 的结构、命名、质量标准 | **P0 - 最高** |
+| [../_shared/SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) | Universal design spec - defines structure, naming, quality standards for all Skills | **P0 - Critical** |
+| [specs/reference-docs-spec.md](specs/reference-docs-spec.md) | Reference document generation spec - ensures generated Skills have proper phase-based Reference Documents with usage timing guidance | **P0 - Critical** |
 
-### 模板文件 (生成前必读)
+### Template Files (Read Before Generation)
 
 | Document | Purpose |
 |----------|---------|
-| [templates/skill-md.md](templates/skill-md.md) | SKILL.md 入口文件模板 |
+| [templates/skill-md.md](templates/skill-md.md) | SKILL.md entry file template |
-| [templates/sequential-phase.md](templates/sequential-phase.md) | Sequential Phase 模板 |
+| [templates/sequential-phase.md](templates/sequential-phase.md) | Sequential Phase template |
-| [templates/autonomous-orchestrator.md](templates/autonomous-orchestrator.md) | Autonomous 编排器模板 |
+| [templates/autonomous-orchestrator.md](templates/autonomous-orchestrator.md) | Autonomous Orchestrator template |
-| [templates/autonomous-action.md](templates/autonomous-action.md) | Autonomous Action 模板 |
+| [templates/autonomous-action.md](templates/autonomous-action.md) | Autonomous Action template |
-| [templates/code-analysis-action.md](templates/code-analysis-action.md) | 代码分析 Action 模板 |
+| [templates/code-analysis-action.md](templates/code-analysis-action.md) | Code Analysis Action template |
-| [templates/llm-action.md](templates/llm-action.md) | LLM Action 模板 |
+| [templates/llm-action.md](templates/llm-action.md) | LLM Action template |
-| [templates/script-bash.md](templates/script-bash.md) | Bash 脚本模板 |
+| [templates/script-template.md](templates/script-template.md) | Unified Script Template (Bash + Python) |
-| [templates/script-python.md](templates/script-python.md) | Python 脚本模板 |
 
-### 规范文档 (按需阅读)
+### Specification Documents (Read as Needed)
 
 | Document | Purpose |
 |----------|---------|
-| [specs/execution-modes.md](specs/execution-modes.md) | 执行模式规范 |
+| [specs/execution-modes.md](specs/execution-modes.md) | Execution Modes Specification |
-| [specs/skill-requirements.md](specs/skill-requirements.md) | Skill 需求规范 |
+| [specs/skill-requirements.md](specs/skill-requirements.md) | Skill Requirements Specification |
-| [specs/cli-integration.md](specs/cli-integration.md) | CLI 集成规范 |
+| [specs/cli-integration.md](specs/cli-integration.md) | CLI Integration Specification |
-| [specs/scripting-integration.md](specs/scripting-integration.md) | 脚本集成规范 |
+| [specs/scripting-integration.md](specs/scripting-integration.md) | Script Integration Specification |
 
-### Phase 执行指南 (执行时参考)
+### Phase Execution Guides (Reference During Execution)
 
 | Document | Purpose |
 |----------|---------|
-| [phases/01-requirements-discovery.md](phases/01-requirements-discovery.md) | 收集 Skill 需求 |
+| [phases/01-requirements-discovery.md](phases/01-requirements-discovery.md) | Collect Skill Requirements |
-| [phases/02-structure-generation.md](phases/02-structure-generation.md) | 生成目录结构 |
+| [phases/02-structure-generation.md](phases/02-structure-generation.md) | Generate Directory Structure |
-| [phases/03-phase-generation.md](phases/03-phase-generation.md) | 生成 Phase 文件 |
+| [phases/03-phase-generation.md](phases/03-phase-generation.md) | Generate Phase Files |
-| [phases/04-specs-templates.md](phases/04-specs-templates.md) | 生成规范和模板 |
+| [phases/04-specs-templates.md](phases/04-specs-templates.md) | Generate Specs and Templates |
-| [phases/05-validation.md](phases/05-validation.md) | 验证和文档 |
+| [phases/05-validation.md](phases/05-validation.md) | Validation and Documentation |
 
 ---
 
 ## Execution Flow
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
+Input Parsing:
-│  ⚠️ Phase 0: Specification Study (强制前置 - 禁止跳过)           │
+   └─ Convert user request to structured format (skill-name/purpose/mode)
-│  → Read: ../_shared/SKILL-DESIGN-SPEC.md (通用设计规范)         │
+
-│  → Read: templates/*.md (所有相关模板文件)                       │
+Phase 0: Specification Study (MANDATORY - Must complete before proceeding)
-│  → 理解: Skill 结构规范、命名约定、质量标准                      │
+   - Read specification documents
-│  → Output: 内化规范要求，确保后续生成符合标准                    │
+   - Load: ../_shared/SKILL-DESIGN-SPEC.md
-│  ⛔ 未完成 Phase 0 禁止进入 Phase 1                              │
+   - Load: All templates/*.md files
-├─────────────────────────────────────────────────────────────────┤
+   - Understand: Structure rules, naming conventions, quality standards
-│  Phase 1: Requirements Discovery                                 │
+   - Output: Internalized requirements (in-memory, no file output)
-│  → AskUserQuestion: Skill 名称、目标、执行模式                   │
+   - Validation: MUST complete before Phase 1
-│  → Output: skill-config.json                                    │
+
-├─────────────────────────────────────────────────────────────────┤
+Phase 1: Requirements Discovery
-│  Phase 2: Structure Generation                                   │
+   - Gather skill requirements via user interaction
-│  → 创建目录结构: phases/, specs/, templates/, scripts/          │
+   - Tool: AskUserQuestion
-│  → 生成 SKILL.md 入口文件                                        │
+   - Collect: Skill name, purpose, execution mode
-│  → Output: 完整目录结构                                          │
+   - Collect: Phase/Action definition
-├─────────────────────────────────────────────────────────────────┤
+   - Collect: Tool dependencies, output format
-│  Phase 3: Phase Generation                                       │
+   - Process: Generate configuration object
-│  → Sequential: 生成 01-xx.md, 02-xx.md, ...                     │
+   - Output: skill-config.json
-│  → Autonomous: 生成 orchestrator.md + actions/*.md              │
+   - Contains: skill_name, execution_mode, phases/actions, allowed_tools
-│  → Output: phases/*.md                                          │
+
-├─────────────────────────────────────────────────────────────────┤
+Phase 2: Structure Generation
-│  Phase 4: Specs & Templates                                      │
+   - Create directory structure and entry file
-│  → 生成领域规范: specs/{domain}-requirements.md                  │
+   - Input: skill-config.json (from Phase 1)
-│  → 生成质量标准: specs/quality-standards.md                      │
+   - Tool: Bash
-│  → 生成模板: templates/agent-base.md                             │
+   - Execute: mkdir -p .claude/skills/{skill-name}/{phases,specs,templates,scripts}
-│  → Output: specs/*.md, templates/*.md                           │
+   - Tool: Write
-├─────────────────────────────────────────────────────────────────┤
+   - Generate: SKILL.md (entry point with architecture diagram)
-│  Phase 5: Validation & Documentation                             │
+   - Output: Complete directory structure
-│  → 验证文件完整性                                                 │
+
-│  → 生成 README.md 使用说明                                       │
+Phase 3: Phase/Action Generation
-│  → Output: 验证报告 + README.md                                  │
+   - Decision (execution_mode check):
-└─────────────────────────────────────────────────────────────────┘
+   - IF execution_mode === "sequential": Generate Sequential Phases
+   - Read template: templates/sequential-phase.md
+   - Loop: For each phase in config.sequential_config.phases
+   - Generate: phases/{phase-id}.md
+   - Link: Previous phase output -> Current phase input
+   - Write: phases/_orchestrator.md
+   - Write: workflow.json
+   - Output: phases/01-{name}.md, phases/02-{name}.md, ...
+
+   - ELSE IF execution_mode === "autonomous": Generate Orchestrator + Actions
+   - Read template: templates/autonomous-orchestrator.md
+   - Write: phases/state-schema.md
+   - Write: phases/orchestrator.md
+   - Write: specs/action-catalog.md
+   - Loop: For each action in config.autonomous_config.actions
+   - Read template: templates/autonomous-action.md
+   - Generate: phases/actions/{action-id}.md
+   - Output: phases/orchestrator.md, phases/actions/*.md
+
+Phase 4: Specs & Templates
+   - Generate domain specifications and templates
+   - Input: skill-config.json (domain context)
+   - Reference: [specs/reference-docs-spec.md](specs/reference-docs-spec.md) for document organization
+   - Tool: Write
+   - Generate: specs/{domain}-requirements.md
+   - Generate: specs/quality-standards.md
+   - Generate: templates/agent-base.md (if needed)
+   - Output: Domain-specific documentation
+
+Phase 5: Validation & Documentation
+   - Verify completeness and generate usage guide
+   - Input: All generated files from previous phases
+   - Tool: Glob + Read
+   - Check: Required files exist and contain proper structure
+   - Tool: Write
+   - Generate: README.md (usage instructions)
+   - Generate: validation-report.json (completeness check)
+   - Output: Final documentation
 ```
 
-## Directory Setup
+**Execution Protocol**:
 
 ```javascript
-const skillName = config.skill_name;
+// Phase 0: Read specifications (in-memory)
-const skillDir = `.claude/skills/${skillName}`;
+Read('.claude/skills/_shared/SKILL-DESIGN-SPEC.md');
+Read('.claude/skills/skill-generator/templates/*.md'); // All templates
 
-// 创建目录结构
+// Phase 1: Gather requirements
-Bash(`mkdir -p "${skillDir}/phases"`);
+const answers = AskUserQuestion({
-Bash(`mkdir -p "${skillDir}/specs"`);
+  questions: [
-Bash(`mkdir -p "${skillDir}/templates"`);
+    { question: "Skill name?", header: "Name", options: [...] },
+    { question: "Execution mode?", header: "Mode", options: ["Sequential", "Autonomous"] }
+  ]
+});
 
-// Autonomous 模式额外目录
+const config = generateConfig(answers);
-if (config.execution_mode === 'autonomous') {
+const workDir = `.workflow/.scratchpad/skill-gen-${timestamp}`;
-  Bash(`mkdir -p "${skillDir}/phases/actions"`);
+Write(`${workDir}/skill-config.json`, JSON.stringify(config));
+
+// Phase 2: Create structure
+const skillDir = `.claude/skills/${config.skill_name}`;
+Bash(`mkdir -p "${skillDir}/phases" "${skillDir}/specs" "${skillDir}/templates"`);
+Write(`${skillDir}/SKILL.md`, generateSkillEntry(config));
+
+// Phase 3: Generate phases (mode-dependent)
+if (config.execution_mode === 'sequential') {
+  Write(`${skillDir}/phases/_orchestrator.md`, generateOrchestrator(config));
+  Write(`${skillDir}/workflow.json`, generateWorkflowDef(config));
+  config.sequential_config.phases.forEach(phase => {
+    Write(`${skillDir}/phases/${phase.id}.md`, generatePhase(phase, config));
+  });
+} else {
+  Write(`${skillDir}/phases/orchestrator.md`, generateAutonomousOrchestrator(config));
+  Write(`${skillDir}/phases/state-schema.md`, generateStateSchema(config));
+  config.autonomous_config.actions.forEach(action => {
+    Write(`${skillDir}/phases/actions/${action.id}.md`, generateAction(action, config));
+  });
 }
+
+// Phase 4: Generate specs
+Write(`${skillDir}/specs/${config.skill_name}-requirements.md`, generateRequirements(config));
+Write(`${skillDir}/specs/quality-standards.md`, generateQualityStandards(config));
+
+
+// Phase 5: Validate & Document
+const validation = validateStructure(skillDir);
+Write(`${skillDir}/validation-report.json`, JSON.stringify(validation));
+Write(`${skillDir}/README.md`, generateReadme(config, validation));
 ```
 
+---
+
+
+## Reference Documents by Phase
+
+IMPORTANT: This section demonstrates how skill-generator organizes its own reference documentation. This is the pattern that all generated Skills should emulate. See [specs/reference-docs-spec.md](specs/reference-docs-spec.md) for details.
+
+### Phase 0: Specification Study (Mandatory Prerequisites)
+
+Specification documents that must be read before any generation operation
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [../_shared/SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) | Universal Skill design specification | Understand Skill structure and naming conventions - **REQUIRED** |
+| [specs/reference-docs-spec.md](specs/reference-docs-spec.md) | Reference document generation specification | Ensure Reference Documents have proper phase-based organization - **REQUIRED** |
+
+### Phase 1: Requirements Discovery
+
+Collect Skill requirements and configuration
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/01-requirements-discovery.md](phases/01-requirements-discovery.md) | Phase 1 execution guide | Understand how to collect user requirements and generate configuration |
+| [specs/skill-requirements.md](specs/skill-requirements.md) | Skill requirements specification | Understand what information a Skill should contain |
+
+### Phase 2: Structure Generation
+
+Generate directory structure and entry file
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/02-structure-generation.md](phases/02-structure-generation.md) | Phase 2 execution guide | Understand how to generate directory structure |
+| [templates/skill-md.md](templates/skill-md.md) | SKILL.md template | Learn how to generate the entry file |
+
+### Phase 3: Phase/Action Generation
+
+Generate specific phase or action files based on execution mode
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/03-phase-generation.md](phases/03-phase-generation.md) | Phase 3 execution guide | Understand Sequential vs Autonomous generation logic |
+| [templates/sequential-phase.md](templates/sequential-phase.md) | Sequential Phase template | Generate phase files for Sequential mode |
+| [templates/autonomous-orchestrator.md](templates/autonomous-orchestrator.md) | Orchestrator template | Generate orchestrator for Autonomous mode |
+| [templates/autonomous-action.md](templates/autonomous-action.md) | Action template | Generate action files for Autonomous mode |
+
+### Phase 4: Specs & Templates
+
+Generate domain-specific specifications and templates
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/04-specs-templates.md](phases/04-specs-templates.md) | Phase 4 execution guide | Understand how to generate domain-specific documentation |
+| [specs/reference-docs-spec.md](specs/reference-docs-spec.md) | Reference document specification | IMPORTANT: Follow this spec when generating Specs |
+
+### Phase 5: Validation & Documentation
+
+Verify results and generate final documentation
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/05-validation.md](phases/05-validation.md) | Phase 5 execution guide | Understand how to verify generated Skill completeness |
+
+### Debugging & Troubleshooting
+
+Reference documents when encountering issues
+
+| Issue | Solution Document |
+|-------|------------------|
+| Generated Skill missing Reference Documents | [specs/reference-docs-spec.md](specs/reference-docs-spec.md) - verify phase-based organization is followed |
+| Reference document organization unclear | [specs/reference-docs-spec.md](specs/reference-docs-spec.md) - Core Principles section |
+| Generated documentation does not meet quality standards | [../_shared/SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) |
+
+### Reference & Background
+
+Documents for deep learning and design decisions
+
+| Document | Purpose | Notes |
+|----------|---------|-------|
+| [specs/execution-modes.md](specs/execution-modes.md) | Detailed execution modes specification | Comparison and use cases for Sequential vs Autonomous |
+| [specs/cli-integration.md](specs/cli-integration.md) | CLI integration specification | How generated Skills integrate with CLI |
+| [specs/scripting-integration.md](specs/scripting-integration.md) | Script integration specification | How to use scripts in Phases |
+| [templates/script-template.md](templates/script-template.md) | Script template | Unified Bash + Python template |
+
+---
+
 ## Output Structure
 
 ### Sequential Mode
 
 ```
 .claude/skills/{skill-name}/
-├── SKILL.md
+├── SKILL.md                        # Entry file
 ├── phases/
-│   ├── 01-{step-one}.md
+│   ├── _orchestrator.md            # Declarative orchestrator
-│   ├── 02-{step-two}.md
+│   ├── workflow.json               # Workflow definition
-│   └── 03-{step-three}.md
+│   ├── 01-{step-one}.md           # Phase 1
+│   ├── 02-{step-two}.md           # Phase 2
+│   └── 03-{step-three}.md         # Phase 3
 ├── specs/
-│   ├── {domain}-requirements.md
+│   ├── {skill-name}-requirements.md
 │   └── quality-standards.md
-└── templates/
+├── templates/
-    └── agent-base.md
+│   └── agent-base.md
+├── scripts/
+└── README.md
 ```
 
 ### Autonomous Mode
 
 ```
 .claude/skills/{skill-name}/
-├── SKILL.md
+├── SKILL.md                        # Entry file
 ├── phases/
-│   ├── orchestrator.md          # 编排器：读取状态 → 选择动作
+│   ├── orchestrator.md             # Orchestrator (state-driven)
-│   ├── state-schema.md          # 状态结构定义
+│   ├── state-schema.md             # State schema definition
-│   └── actions/                 # 独立动作（无顺序）
+│   └── actions/
-│       ├── action-{a}.md
+│       ├── action-init.md
-│       ├── action-{b}.md
+│       ├── action-create.md
-│       └── action-{c}.md
+│       └── action-list.md
 ├── specs/
-│   ├── {domain}-requirements.md
+│   ├── {skill-name}-requirements.md
-│   ├── action-catalog.md        # 动作目录（描述、前置条件、效果）
+│   ├── action-catalog.md
 │   └── quality-standards.md
-└── templates/
+├── templates/
-    ├── orchestrator-base.md     # 编排器模板
+│   ├── orchestrator-base.md
-    └── action-base.md           # 动作模板
+│   └── action-base.md
+├── scripts/
+└── README.md
 ```
+
+---
+
+## Reference Documents by Phase
+
+IMPORTANT: This section demonstrates how skill-generator organizes its own reference documentation. This is the pattern that all generated Skills should emulate. See [specs/reference-docs-spec.md](specs/reference-docs-spec.md) for details.
+
+### Phase 0: Specification Study (Mandatory Prerequisites)
+
+Specification documents that must be read before any generation operation
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [../_shared/SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) | Universal Skill design specification | Understand Skill structure and naming conventions - **REQUIRED** |
+| [specs/reference-docs-spec.md](specs/reference-docs-spec.md) | Reference document generation specification | Ensure Reference Documents have proper phase-based organization - **REQUIRED** |
+
+### Phase 1: Requirements Discovery
+
+Collect Skill requirements and configuration
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/01-requirements-discovery.md](phases/01-requirements-discovery.md) | Phase 1 execution guide | Understand how to collect user requirements and generate configuration |
+| [specs/skill-requirements.md](specs/skill-requirements.md) | Skill requirements specification | Understand what information a Skill should contain |
+
+### Phase 2: Structure Generation
+
+Generate directory structure and entry file
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/02-structure-generation.md](phases/02-structure-generation.md) | Phase 2 execution guide | Understand how to generate directory structure |
+| [templates/skill-md.md](templates/skill-md.md) | SKILL.md template | Learn how to generate the entry file |
+
+### Phase 3: Phase/Action Generation
+
+Generate specific phase or action files based on execution mode
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/03-phase-generation.md](phases/03-phase-generation.md) | Phase 3 execution guide | Understand Sequential vs Autonomous generation logic |
+| [templates/sequential-phase.md](templates/sequential-phase.md) | Sequential Phase template | Generate phase files for Sequential mode |
+| [templates/autonomous-orchestrator.md](templates/autonomous-orchestrator.md) | Orchestrator template | Generate orchestrator for Autonomous mode |
+| [templates/autonomous-action.md](templates/autonomous-action.md) | Action template | Generate action files for Autonomous mode |
+
+### Phase 4: Specs & Templates
+
+Generate domain-specific specifications and templates
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/04-specs-templates.md](phases/04-specs-templates.md) | Phase 4 execution guide | Understand how to generate domain-specific documentation |
+| [specs/reference-docs-spec.md](specs/reference-docs-spec.md) | Reference document specification | IMPORTANT: Follow this spec when generating Specs |
+
+### Phase 5: Validation & Documentation
+
+Verify results and generate final documentation
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/05-validation.md](phases/05-validation.md) | Phase 5 execution guide | Understand how to verify generated Skill completeness |
+
+### Debugging & Troubleshooting
+
+Reference documents when encountering issues
+
+| Issue | Solution Document |
+|-------|------------------|
+| Generated Skill missing Reference Documents | [specs/reference-docs-spec.md](specs/reference-docs-spec.md) - verify phase-based organization is followed |
+| Reference document organization unclear | [specs/reference-docs-spec.md](specs/reference-docs-spec.md) - Core Principles section |
+| Generated documentation does not meet quality standards | [../_shared/SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) |
+
+### Reference & Background
+
+Documents for deep learning and design decisions
+
+| Document | Purpose | Notes |
+|----------|---------|-------|
+| [specs/execution-modes.md](specs/execution-modes.md) | Detailed execution modes specification | Comparison and use cases for Sequential vs Autonomous |
+| [specs/cli-integration.md](specs/cli-integration.md) | CLI integration specification | How generated Skills integrate with CLI |
+| [specs/scripting-integration.md](specs/scripting-integration.md) | Script integration specification | How to use scripts in Phases |
+| [templates/script-template.md](templates/script-template.md) | Script template | Unified Bash + Python template |

.claude/skills/skill-generator/phases/01-requirements-discovery.md

@@ -1,125 +1,125 @@
 # Phase 1: Requirements Discovery
 
-收集新 Skill 的需求信息，生成配置文件。
+Collect basic skill information, configuration, and execution mode based on user input.
 
 ## Objective
 
-- 收集 Skill 基本信息（名称、描述、触发词）
+- Collect skill basic information (name, description, trigger words)
-- 确定执行模式（Sequential / Autonomous）
+- Determine execution mode (Sequential/Autonomous/Hybrid)
-- 定义阶段/动作
+- Define phases or actions
-- 配置工具依赖和输出格式
+- Generate initial configuration file
 
 ## Execution Steps
 
-### Step 1: 基本信息收集
+### Step 1: Basic Information Collection
 
 ```javascript
 const basicInfo = await AskUserQuestion({
   questions: [
     {
-      question: "新 Skill 的名称是什么？（英文，小写-连字符格式，如 'api-docs'）",
+      question: "What is the name of the new Skill? (English, lowercase with hyphens, e.g., 'api-docs')",
-      header: "Skill 名称",
+      header: "Skill Name",
       multiSelect: false,
       options: [
-        { label: "自动生成", description: "根据后续描述自动生成名称" },
+        { label: "Auto-generate", description: "Generate name automatically based on description" },
-        { label: "手动输入", description: "现在输入自定义名称" }
+        { label: "Manual Input", description: "Enter custom name now" }
       ]
     },
     {
-      question: "Skill 的主要用途是什么？",
+      question: "What is the primary purpose of the Skill?",
-      header: "用途类型",
+      header: "Purpose Type",
       multiSelect: false,
       options: [
-        { label: "文档生成", description: "生成 Markdown/HTML 文档（如手册、报告）" },
+        { label: "Document Generation", description: "Generate Markdown/HTML documents (manuals, reports)" },
-        { label: "代码分析", description: "分析代码结构、质量、安全性" },
+        { label: "Code Analysis", description: "Analyze code structure, quality, security" },
-        { label: "交互管理", description: "管理 Issue、任务、工作流（CRUD 操作）" },
+        { label: "Interactive Management", description: "Manage Issues, tasks, workflows (CRUD operations)" },
-        { label: "数据处理", description: "ETL、格式转换、报告生成" }
+        { label: "Data Processing", description: "ETL, format conversion, report generation" }
       ]
     }
   ]
 });
 
-// 如果选择手动输入，进一步询问
+// If manual input is selected, prompt further
-if (basicInfo["Skill 名称"] === "手动输入") {
+if (basicInfo["Skill Name"] === "Manual Input") {
-  // 用户会在 "Other" 中输入
+  // User will input in "Other"
 }
 
-// 根据用途类型推断描述模板
+// Infer description template based on purpose type
 const purposeTemplates = {
-  "文档生成": "Generate {type} documents from {source}",
+  "Document Generation": "Generate {type} documents from {source}",
-  "代码分析": "Analyze {target} for {purpose}",
+  "Code Analysis": "Analyze {target} for {purpose}",
-  "交互管理": "Manage {entity} with interactive operations",
+  "Interactive Management": "Manage {entity} with interactive operations",
-  "数据处理": "Process {data} and generate {output}"
+  "Data Processing": "Process {data} and generate {output}"
 };
 ```
 
-### Step 2: 执行模式选择
+### Step 2: Execution Mode Selection
 
 ```javascript
 const modeInfo = await AskUserQuestion({
   questions: [
     {
-      question: "选择执行模式：",
+      question: "Select execution mode:",
-      header: "执行模式",
+      header: "Execution Mode",
       multiSelect: false,
       options: [
-        { 
+        {
-          label: "Sequential (顺序模式)", 
+          label: "Sequential (Sequential Mode)",
-          description: "阶段按固定顺序执行（收集→分析→生成），适合流水线任务（推荐）" 
+          description: "Phases execute in fixed order (collect→analyze→generate), suitable for pipeline tasks (recommended)"
         },
-        { 
+        {
-          label: "Autonomous (自主模式)", 
+          label: "Autonomous (Autonomous Mode)",
-          description: "动态选择执行路径，适合交互式任务（如 Issue 管理）" 
+          description: "Dynamically select execution path, suitable for interactive tasks (e.g., Issue management)"
         },
-        { 
+        {
-          label: "Hybrid (混合模式)", 
+          label: "Hybrid (Hybrid Mode)",
-          description: "初始化和收尾固定，中间交互灵活" 
+          description: "Fixed initialization and finalization, flexible interaction in the middle"
         }
       ]
     }
   ]
 });
 
-const executionMode = modeInfo["执行模式"].includes("Sequential") ? "sequential" :
+const executionMode = modeInfo["Execution Mode"].includes("Sequential") ? "sequential" :
-                      modeInfo["执行模式"].includes("Autonomous") ? "autonomous" : "hybrid";
+                      modeInfo["Execution Mode"].includes("Autonomous") ? "autonomous" : "hybrid";
 ```
 
-### Step 3: 阶段/动作定义
+### Step 3: Phase/Action Definition
 
-#### Sequential 模式
+#### Sequential Mode
 
 ```javascript
 if (executionMode === "sequential") {
   const phaseInfo = await AskUserQuestion({
     questions: [
       {
-        question: "需要多少个执行阶段？",
+        question: "How many execution phases are needed?",
-        header: "阶段数量",
+        header: "Phase Count",
         multiSelect: false,
         options: [
-          { label: "3 阶段（简单）", description: "收集 → 处理 → 输出" },
+          { label: "3 Phases (Simple)", description: "Collection → Processing → Output" },
-          { label: "5 阶段（标准）", description: "收集 → 探索 → 分析 → 组装 → 验证" },
+          { label: "5 Phases (Standard)", description: "Collection → Exploration → Analysis → Assembly → Validation" },
-          { label: "7 阶段（完整）", description: "含并行处理、汇总、迭代优化" }
+          { label: "7 Phases (Complete)", description: "Includes parallel processing, consolidation, iterative optimization" }
         ]
       }
     ]
   });
-  
+
-  // 根据选择生成阶段定义
+  // Generate phase definitions based on selection
   const phaseTemplates = {
-    "3 阶段": [
+    "3 Phases": [
       { id: "01-collection", name: "Data Collection" },
       { id: "02-processing", name: "Processing" },
       { id: "03-output", name: "Output Generation" }
     ],
-    "5 阶段": [
+    "5 Phases": [
       { id: "01-collection", name: "Requirements Collection" },
       { id: "02-exploration", name: "Project Exploration" },
       { id: "03-analysis", name: "Deep Analysis" },
       { id: "04-assembly", name: "Document Assembly" },
       { id: "05-validation", name: "Validation" }
     ],
-    "7 阶段": [
+    "7 Phases": [
       { id: "01-collection", name: "Requirements Collection" },
       { id: "02-exploration", name: "Project Exploration" },
       { id: "03-parallel", name: "Parallel Analysis" },
@@ -132,23 +132,23 @@ if (executionMode === "sequential") {
 }
 ```
 
-#### Autonomous 模式
+#### Autonomous Mode
 
 ```javascript
 if (executionMode === "autonomous") {
   const actionInfo = await AskUserQuestion({
     questions: [
       {
-        question: "核心动作有哪些？（可多选）",
+        question: "What are the core actions? (Multiple selection allowed)",
-        header: "动作定义",
+        header: "Action Definition",
         multiSelect: true,
         options: [
-          { label: "初始化 (init)", description: "设置初始状态" },
+          { label: "Initialize (init)", description: "Set initial state" },
-          { label: "列表 (list)", description: "显示当前项目列表" },
+          { label: "List (list)", description: "Display current item list" },
-          { label: "创建 (create)", description: "创建新项目" },
+          { label: "Create (create)", description: "Create new item" },
-          { label: "编辑 (edit)", description: "修改现有项目" },
+          { label: "Edit (edit)", description: "Modify existing item" },
-          { label: "删除 (delete)", description: "删除项目" },
+          { label: "Delete (delete)", description: "Delete item" },
-          { label: "搜索 (search)", description: "搜索/过滤项目" }
+          { label: "Search (search)", description: "Search/filter items" }
         ]
       }
     ]
@@ -156,37 +156,37 @@ if (executionMode === "autonomous") {
 }
 ```
 
-### Step 4: 工具和输出配置
+### Step 4: Tool and Output Configuration
 
 ```javascript
 const toolsInfo = await AskUserQuestion({
   questions: [
     {
-      question: "需要哪些特殊工具？（基础工具已默认包含）",
+      question: "Which special tools are needed? (Basic tools are included by default)",
-      header: "工具选择",
+      header: "Tool Selection",
       multiSelect: true,
       options: [
-        { label: "用户交互 (AskUserQuestion)", description: "需要与用户对话" },
+        { label: "User Interaction (AskUserQuestion)", description: "Need to dialog with user" },
-        { label: "Chrome 截图 (mcp__chrome__*)", description: "需要网页截图" },
+        { label: "Chrome Screenshot (mcp__chrome__*)", description: "Need web page screenshots" },
-        { label: "外部搜索 (mcp__exa__search)", description: "需要搜索外部信息" },
+        { label: "External Search (mcp__exa__search)", description: "Need to search external information" },
-        { label: "无特殊需求", description: "仅使用基础工具" }
+        { label: "No Special Requirements", description: "Use basic tools only" }
       ]
     },
     {
-      question: "输出格式是什么？",
+      question: "What is the output format?",
-      header: "输出格式",
+      header: "Output Format",
       multiSelect: false,
       options: [
-        { label: "Markdown", description: "适合文档和报告" },
+        { label: "Markdown", description: "Suitable for documents and reports" },
-        { label: "HTML", description: "适合交互式文档" },
+        { label: "HTML", description: "Suitable for interactive documents" },
-        { label: "JSON", description: "适合数据和配置" }
+        { label: "JSON", description: "Suitable for data and configuration" }
       ]
     }
   ]
 });
 ```
 
-### Step 5: 生成配置文件
+### Step 5: Generate Configuration File
 
 ```javascript
 const config = {
@@ -195,45 +195,44 @@ const config = {
   description: description,
   triggers: triggers,
   execution_mode: executionMode,
-  
+
-  // 模式特定配置
+  // Mode-specific configuration
   ...(executionMode === "sequential" ? {
     sequential_config: { phases: phases }
   } : {
-    autonomous_config: { 
+    autonomous_config: {
       state_schema: stateSchema,
       actions: actions,
       termination_conditions: ["user_exit", "error_limit", "task_completed"]
     }
   }),
-  
+
   allowed_tools: [
     "Task", "Read", "Write", "Glob", "Grep", "Bash",
     ...selectedTools
   ],
-  
+
   output: {
     format: outputFormat.toLowerCase(),
     location: `.workflow/.scratchpad/${skillName}-{timestamp}`,
     filename_pattern: `{name}-output.${outputFormat === "HTML" ? "html" : outputFormat === "JSON" ? "json" : "md"}`
   },
-  
+
   created_at: new Date().toISOString(),
   version: "1.0.0"
 };
 
-// 写入配置文件
+// Write configuration file
 const workDir = `.workflow/.scratchpad/skill-gen-${timestamp}`;
 Bash(`mkdir -p "${workDir}"`);
 Write(`${workDir}/skill-config.json`, JSON.stringify(config, null, 2));
 ```
 
-## Output
-
-- **File**: `skill-config.json`
-- **Location**: `.workflow/.scratchpad/skill-gen-{timestamp}/`
-- **Format**: JSON
 
 ## Next Phase
 
 → [Phase 2: Structure Generation](02-structure-generation.md)
+
+**Data Flow to Phase 2**:
+- skill-config.json with all configuration parameters
+- Execution mode decision drives directory structure creation

.claude/skills/skill-generator/phases/02-structure-generation.md

@@ -1,44 +1,101 @@
 # Phase 2: Structure Generation
 
-根据配置创建 Skill 目录结构和入口文件。
+Create Skill directory structure and entry file based on configuration.
 
 ## Objective
 
-- 创建标准目录结构
+- Create standard directory structure
-- 生成 SKILL.md 入口文件
+- Generate SKILL.md entry file
-- 根据执行模式创建对应的子目录
+- Create corresponding subdirectories based on execution mode
 
-## Input
-
-- 依赖: `skill-config.json` (Phase 1 产出)
 
 ## Execution Steps
 
-### Step 1: 读取配置
+### Step 1: Read Configuration
 
 ```javascript
 const config = JSON.parse(Read(`${workDir}/skill-config.json`));
 const skillDir = `.claude/skills/${config.skill_name}`;
 ```
 
-### Step 2: 创建目录结构
+### Step 2: Create Directory Structure
+
+#### Base Directories (All Modes)
 
 ```javascript
-// 基础目录
+// Base infrastructure
-Bash(`mkdir -p "${skillDir}/phases"`);
+Bash(`mkdir -p "${skillDir}/{phases,specs,templates,scripts}"`);
-Bash(`mkdir -p "${skillDir}/specs"`);
+```
-Bash(`mkdir -p "${skillDir}/templates"`);
 
-// Autonomous 模式额外目录
+#### Execution Mode-Specific Directories
+
+```
+config.execution_mode
+    ↓
+    ├─ "sequential"
+    │   ↓ Creates:
+    │   └─ phases/ (base directory already included)
+    │      ├─ _orchestrator.md
+    │      └─ workflow.json
+    │
+    └─ "autonomous" | "hybrid"
+        ↓ Creates:
+        └─ phases/actions/
+           ├─ state-schema.md
+           └─ *.md (action files)
+```
+
+```javascript
+// Additional directories for Autonomous/Hybrid mode
 if (config.execution_mode === 'autonomous' || config.execution_mode === 'hybrid') {
   Bash(`mkdir -p "${skillDir}/phases/actions"`);
 }
-
-// scripts 目录（默认创建，用于存放确定性脚本）
-Bash(`mkdir -p "${skillDir}/scripts"`);
 ```
 
-### Step 3: 生成 SKILL.md
+#### Context Strategy-Specific Directories (P0 Enhancement)
+
+```javascript
+// ========== P0: Create directories based on context strategy ==========
+const contextStrategy = config.context_strategy || 'file';
+
+if (contextStrategy === 'file') {
+  // File strategy: Create persistent context directory
+  Bash(`mkdir -p "${skillDir}/.scratchpad-template/context"`);
+
+  // Create context template file
+  Write(
+    `${skillDir}/.scratchpad-template/context/.gitkeep`,
+    "# Runtime context storage for file-based strategy"
+  );
+}
+// Memory strategy does not require directory creation (in-memory only)
+```
+
+**Directory Tree View**:
+
+```
+Sequential + File Strategy:
+  .claude/skills/{skill-name}/
+  ├── phases/
+  │   ├── _orchestrator.md
+  │   ├── workflow.json
+  │   ├── 01-*.md
+  │   └── 02-*.md
+  ├── .scratchpad-template/
+  │   └── context/           <- File strategy persistent storage
+  └── specs/
+
+Autonomous + Memory Strategy:
+  .claude/skills/{skill-name}/
+  ├── phases/
+  │   ├── orchestrator.md
+  │   ├── state-schema.md
+  │   └── actions/
+  │       └── *.md
+  └── specs/
+```
+
+### Step 3: Generate SKILL.md
 
 ```javascript
 const skillMdTemplate = `---
@@ -72,8 +129,8 @@ const timestamp = new Date().toISOString().slice(0,19).replace(/[-:T]/g, '');
 const workDir = \`${config.output.location.replace('{timestamp}', '${timestamp}')}\`;
 
 Bash(\`mkdir -p "\${workDir}"\`);
-${config.execution_mode === 'sequential' ? 
+${config.execution_mode === 'sequential' ?
-  `Bash(\`mkdir -p "\${workDir}/sections"\`);` : 
+  `Bash(\`mkdir -p "\${workDir}/sections"\`);` :
   `Bash(\`mkdir -p "\${workDir}/state"\`);`}
 \`\`\`
 
@@ -91,53 +148,53 @@ ${generateReferenceTable(config)}
 Write(`${skillDir}/SKILL.md`, skillMdTemplate);
 ```
 
-### Step 4: 架构图生成函数
+### Step 4: Architecture Diagram Generation Functions
 
 ```javascript
 function generateArchitectureDiagram(config) {
   if (config.execution_mode === 'sequential') {
-    return config.sequential_config.phases.map((p, i) => 
+    return config.sequential_config.phases.map((p, i) =>
       `│  Phase ${i+1}: ${p.name.padEnd(15)} → ${p.output || 'output-' + (i+1) + '.json'}${' '.repeat(10)}│`
     ).join('\n│           ↓' + ' '.repeat(45) + '│\n');
   } else {
     return `
 ┌─────────────────────────────────────────────────────────────────┐
-│           Orchestrator (状态驱动决策)                             │
+│           Orchestrator (State-driven decision-making)             │
 └───────────────┬─────────────────────────────────────────────────┘
                 │
     ┌───────────┼───────────┐
     ↓           ↓           ↓
-${config.autonomous_config.actions.slice(0, 3).map(a => 
+${config.autonomous_config.actions.slice(0, 3).map(a =>
   `┌─────────┐  `).join('')}
-${config.autonomous_config.actions.slice(0, 3).map(a => 
+${config.autonomous_config.actions.slice(0, 3).map(a =>
   `│${a.name.slice(0, 7).padEnd(7)}│  `).join('')}
-${config.autonomous_config.actions.slice(0, 3).map(a => 
+${config.autonomous_config.actions.slice(0, 3).map(a =>
   `└─────────┘  `).join('')}`;
   }
 }
 
 function generateDesignPrinciples(config) {
   const common = [
-    "1. **规范遵循**: 严格遵循 `_shared/SKILL-DESIGN-SPEC.md`",
+    "1. **Specification Compliance**: Strictly follow `_shared/SKILL-DESIGN-SPEC.md`",
-    "2. **简要返回**: Agent 返回路径+摘要，避免上下文溢出"
+    "2. **Brief Return**: Agent returns path+summary, avoiding context overflow"
   ];
-  
+
   if (config.execution_mode === 'sequential') {
     return [...common,
-      "3. **阶段隔离**: 每个阶段独立可测",
+      "3. **Phase Isolation**: Each phase is independently testable",
-      "4. **链式输出**: 阶段产出作为下阶段输入"
+      "4. **Chained Output**: Phase output becomes next phase input"
     ].join('\n');
   } else {
     return [...common,
-      "3. **状态驱动**: 显式状态管理，动态决策",
+      "3. **State-driven**: Explicit state management, dynamic decision-making",
-      "4. **动作独立**: 每个动作无副作用依赖"
+      "4. **Action Independence**: Each action has no side-effect dependencies"
     ].join('\n');
   }
 }
 
 function generateExecutionFlow(config) {
   if (config.execution_mode === 'sequential') {
-    return '```\n' + config.sequential_config.phases.map((p, i) => 
+    return '```\n' + config.sequential_config.phases.map((p, i) =>
       `├─ Phase ${i+1}: ${p.name}\n│  → Output: ${p.output || 'output.json'}`
     ).join('\n') + '\n```';
   } else {
@@ -158,9 +215,9 @@ function generateExecutionFlow(config) {
 function generateOutputStructure(config) {
   const base = `${config.output.location}/
 ├── ${config.execution_mode === 'sequential' ? 'sections/' : 'state.json'}`;
-  
+
   if (config.execution_mode === 'sequential') {
-    return base + '\n' + config.sequential_config.phases.map(p => 
+    return base + '\n' + config.sequential_config.phases.map(p =>
       `│   └── ${p.output || 'section-' + p.id + '.md'}`
     ).join('\n') + `\n└── ${config.output.filename_pattern}`;
   } else {
@@ -172,36 +229,33 @@ function generateOutputStructure(config) {
 
 function generateReferenceTable(config) {
   const rows = [];
-  
+
   if (config.execution_mode === 'sequential') {
     config.sequential_config.phases.forEach(p => {
       rows.push(`| [phases/${p.id}.md](phases/${p.id}.md) | ${p.name} |`);
     });
   } else {
-    rows.push(`| [phases/orchestrator.md](phases/orchestrator.md) | 编排器 |`);
+    rows.push(`| [phases/orchestrator.md](phases/orchestrator.md) | Orchestrator |`);
-    rows.push(`| [phases/state-schema.md](phases/state-schema.md) | 状态定义 |`);
+    rows.push(`| [phases/state-schema.md](phases/state-schema.md) | State Definition |`);
     config.autonomous_config.actions.forEach(a => {
       rows.push(`| [phases/actions/${a.id}.md](phases/actions/${a.id}.md) | ${a.name} |`);
     });
   }
-  
+
-  rows.push(`| [specs/${config.skill_name}-requirements.md](specs/${config.skill_name}-requirements.md) | 领域规范 |`);
+  rows.push(`| [specs/${config.skill_name}-requirements.md](specs/${config.skill_name}-requirements.md) | Domain Requirements |`);
-  rows.push(`| [specs/quality-standards.md](specs/quality-standards.md) | 质量标准 |`);
+  rows.push(`| [specs/quality-standards.md](specs/quality-standards.md) | Quality Standards |`);
-  
+
   return `| Document | Purpose |\n|----------|---------||\n` + rows.join('\n');
 }
 ```
 
-## Output
 
-- **Directory**: `.claude/skills/{skill-name}/`
-- **Files**:
-  - `SKILL.md` (入口文件)
-  - `phases/` (执行阶段目录)
-  - `specs/` (规范文档目录)
-  - `templates/` (模板目录)
-  - `scripts/` (脚本目录，存放 Python/Bash 确定性脚本)
 
 ## Next Phase
 
 → [Phase 3: Phase Generation](03-phase-generation.md)
+
+**Data Flow to Phase 3**:
+- Complete directory structure in .claude/skills/{skill-name}/
+- SKILL.md entry file ready for phase/action generation
+- skill-config.json for template population

.claude/skills/skill-generator/phases/04-specs-templates.md

@@ -1,26 +1,107 @@
-# Phase 4: Specs & Templates Generation
+# Phase 4: Specifications & Templates Generation
 
-生成规范文件和模板文件。
+Generate domain requirements, quality standards, agent templates, and action catalogs.
 
 ## Objective
 
-- 生成领域规范 (`specs/{domain}-requirements.md`)
+Generate comprehensive specifications and templates:
-- 生成质量标准 (`specs/quality-standards.md`)
+- Domain requirements document with validation function
-- 生成 Agent 模板 (`templates/agent-base.md`)
+- Quality standards with automated check system
-- Autonomous 模式额外生成动作目录 (`specs/action-catalog.md`)
+- Agent base template with prompt structure
+- Action catalog for autonomous mode (conditional)
 
 ## Input
 
-- 依赖: `skill-config.json`, SKILL.md, phases/*.md
+**File Dependencies**:
+- `skill-config.json` (from Phase 1)
+- `.claude/skills/{skill-name}/` directory (from Phase 2)
+- Generated phase/action files (from Phase 3)
 
-## Execution Steps
+**Required Information**:
+- Skill name, display name, description
+- Execution mode (determines if action-catalog.md is generated)
+- Output format and location
+- Phase/action definitions
 
-### Step 1: 生成领域规范
+## Output
+
+**Generated Files**:
+
+| File | Purpose | Generation Condition |
+|------|---------|---------------------|
+| `specs/{skill-name}-requirements.md` | Domain requirements with validation | Always |
+| `specs/quality-standards.md` | Quality evaluation criteria | Always |
+| `templates/agent-base.md` | Agent prompt template | Always |
+| `specs/action-catalog.md` | Action dependency graph and selection priority | Autonomous/Hybrid mode only |
+
+**File Structure**:
+
+**Domain Requirements** (`specs/{skill-name}-requirements.md`):
+```markdown
+# {display_name} Requirements
+- When to Use (phase/action reference table)
+- Domain Requirements (Functional requirements, Output requirements, Quality requirements)
+- Validation Function (JavaScript code)
+- Error Handling (recovery strategies)
+```
+
+**Quality Standards** (`specs/quality-standards.md`):
+```markdown
+# Quality Standards
+- Quality Dimensions (Completeness 25%, Consistency 25%, Accuracy 25%, Usability 25%)
+- Quality Gates (Pass ≥80%, Review 60-79%, Fail <60%)
+- Issue Classification (Errors, Warnings, Info)
+- Automated Checks (runQualityChecks function)
+```
+
+**Agent Base** (`templates/agent-base.md`):
+```markdown
+# Agent Base Template
+- Universal Prompt Structure (ROLE, PROJECT CONTEXT, TASK, CONSTRAINTS, OUTPUT_FORMAT, QUALITY_CHECKLIST)
+- Variable Description (workDir, output_path)
+- Return Format (AgentReturn interface)
+- Role Definition Reference (phase/action specific agents)
+```
+
+**Action Catalog** (`specs/action-catalog.md`, Autonomous/Hybrid only):
+```markdown
+# Action Catalog
+- Available Actions (table with Purpose, Preconditions, Effects)
+- Action Dependencies (Mermaid diagram)
+- State Transitions (state machine table)
+- Selection Priority (ordered action list)
+```
+
+## Decision Logic
+
+```
+Decision (execution_mode check):
+   ├─ mode === 'sequential' → Generate 3 files only
+   │  └─ Files: requirements.md, quality-standards.md, agent-base.md
+   │
+   ├─ mode === 'autonomous' → Generate 4 files
+   │  ├─ Files: requirements.md, quality-standards.md, agent-base.md
+   │  └─ Additional: action-catalog.md (with action dependencies)
+   │
+   └─ mode === 'hybrid' → Generate 4 files
+      ├─ Files: requirements.md, quality-standards.md, agent-base.md
+      └─ Additional: action-catalog.md (with hybrid logic)
+```
+
+## Execution Protocol
 
 ```javascript
+// Phase 4: Generate Specifications & Templates
+// Reference: phases/04-specs-templates.md
+
+// Load config and setup
 const config = JSON.parse(Read(`${workDir}/skill-config.json`));
 const skillDir = `.claude/skills/${config.skill_name}`;
 
+// Ensure specs and templates directories exist (created in Phase 2)
+// skillDir structure: phases/, specs/, templates/
+
+// Step 1: Generate domain requirements
 const domainRequirements = `# ${config.display_name} Requirements
 
 ${config.description}
@@ -29,45 +110,45 @@ ${config.description}
 
 | Phase | Usage | Reference |
 |-------|-------|-----------|
-${config.execution_mode === 'sequential' ? 
+${config.execution_mode === 'sequential' ?
-  config.sequential_config.phases.map((p, i) => 
+  config.sequential_config.phases.map((p, i) =>
     `| Phase ${i+1} | ${p.name} | ${p.id}.md |`
   ).join('\n') :
-  `| Orchestrator | 动作选择 | orchestrator.md |
+  `| Orchestrator | Action selection | orchestrator.md |
-| Actions | 动作执行 | actions/*.md |`}
+| Actions | Action execution | actions/*.md |`}
 
 ---
 
 ## Domain Requirements
 
-### 功能要求
+### Functional Requirements
 
-- [ ] 要求1: TODO
+- [ ] Requirement 1: TODO
-- [ ] 要求2: TODO
+- [ ] Requirement 2: TODO
-- [ ] 要求3: TODO
+- [ ] Requirement 3: TODO
 
-### 输出要求
+### Output Requirements
 
-- [ ] 格式: ${config.output.format}
+- [ ] Format: ${config.output.format}
-- [ ] 位置: ${config.output.location}
+- [ ] Location: ${config.output.location}
-- [ ] 命名: ${config.output.filename_pattern}
+- [ ] Naming: ${config.output.filename_pattern}
 
-### 质量要求
+### Quality Requirements
 
-- [ ] 完整性: 所有必需内容存在
+- [ ] Completeness: All necessary content exists
-- [ ] 一致性: 术语和格式统一
+- [ ] Consistency: Terminology and format unified
-- [ ] 准确性: 内容基于实际分析
+- [ ] Accuracy: Content based on actual analysis
 
 ## Validation Function
 
 \`\`\`javascript
 function validate${toPascalCase(config.skill_name)}(output) {
   const checks = [
-    // TODO: 添加验证规则
+    // TODO: Add validation rules
-    { name: "格式正确", pass: output.format === "${config.output.format}" },
+    { name: "Format correct", pass: output.format === "${config.output.format}" },
-    { name: "内容完整", pass: output.content?.length > 0 }
+    { name: "Content complete", pass: output.content?.length > 0 }
   ];
-  
+
   return {
     passed: checks.filter(c => c.pass).length,
     total: checks.length,
@@ -80,81 +161,78 @@ function validate${toPascalCase(config.skill_name)}(output) {
 
 | Error | Recovery |
 |-------|----------|
-| 输入数据缺失 | 返回明确错误信息 |
+| Missing input data | Return clear error message |
-| 处理超时 | 缩小范围，重试 |
+| Processing timeout | Reduce scope, retry |
-| 输出验证失败 | 记录问题，人工审核 |
+| Output validation failure | Log issue, manual review |
 `;
 
 Write(`${skillDir}/specs/${config.skill_name}-requirements.md`, domainRequirements);
-```
 
-### Step 2: 生成质量标准
+// Step 2: Generate quality standards
-
-```javascript
 const qualityStandards = `# Quality Standards
 
-${config.display_name} 的质量评估标准。
+Quality assessment standards for ${config.display_name}.
 
 ## Quality Dimensions
 
-### 1. Completeness (完整性) - 25%
+### 1. Completeness (Completeness) - 25%
 
-| 要求 | 权重 | 检查方式 |
+| Requirement | Weight | Validation Method |
-|------|------|----------|
+|------------|--------|-----------------|
-| 所有必需输出存在 | 10 | 文件检查 |
+| All necessary outputs exist | 10 | File check |
-| 内容覆盖完整 | 10 | 内容分析 |
+| Content coverage complete | 10 | Content analysis |
-| 无占位符残留 | 5 | 文本搜索 |
+| No placeholder remnants | 5 | Text search |
 
-### 2. Consistency (一致性) - 25%
+### 2. Consistency (Consistency) - 25%
 
-| 方面 | 检查 |
+| Aspect | Check |
-|------|------|
+|--------|-------|
-| 术语 | 同一概念使用相同术语 |
+| Terminology | Use same term for same concept |
-| 格式 | 标题层级、代码块格式一致 |
+| Format | Title levels, code block format consistent |
-| 风格 | 语气和表达方式统一 |
+| Style | Tone and expression unified |
 
-### 3. Accuracy (准确性) - 25%
+### 3. Accuracy (Accuracy) - 25%
 
-| 要求 | 说明 |
+| Requirement | Description |
-|------|------|
+|-------------|------------|
-| 数据正确 | 引用和数据无错误 |
+| Data correct | References and data error-free |
-| 逻辑正确 | 流程和关系描述准确 |
+| Logic correct | Process and relationship descriptions accurate |
-| 代码正确 | 代码示例可运行 |
+| Code correct | Code examples runnable |
 
-### 4. Usability (可用性) - 25%
+### 4. Usability (Usability) - 25%
 
-| 指标 | 目标 |
+| Metric | Goal |
-|------|------|
+|--------|------|
-| 可读性 | 结构清晰，易于理解 |
+| Readability | Clear structure, easy to understand |
-| 可导航 | 目录和链接正确 |
+| Navigability | Table of contents and links correct |
-| 可操作 | 步骤明确，可执行 |
+| Operability | Steps clear, executable |
 
 ## Quality Gates
 
 | Gate | Threshold | Action |
 |------|-----------|--------|
-| Pass | ≥ 80% | 输出最终产物 |
+| Pass | >= 80% | Output final deliverables |
-| Review | 60-79% | 处理警告后继续 |
+| Review | 60-79% | Process warnings then continue |
-| Fail | < 60% | 必须修复 |
+| Fail | < 60% | Must fix |
 
 ## Issue Classification
 
 ### Errors (Must Fix)
 
-- 必需输出缺失
+- Necessary output missing
-- 数据错误
+- Data error
-- 代码不可运行
+- Code not runnable
 
 ### Warnings (Should Fix)
 
-- 格式不一致
+- Format inconsistency
-- 内容深度不足
+- Content depth insufficient
-- 缺少示例
+- Missing examples
 
 ### Info (Nice to Have)
 
-- 优化建议
+- Optimization suggestions
-- 增强机会
+- Enhancement opportunities
 
 ## Automated Checks
 
@@ -176,7 +254,7 @@ function runQualityChecks(workDir) {
 
   return {
     score: results.overall,
-    gate: results.overall >= 80 ? 'pass' : 
+    gate: results.overall >= 80 ? 'pass' :
           results.overall >= 60 ? 'review' : 'fail',
     details: results
   };
@@ -185,51 +263,48 @@ function runQualityChecks(workDir) {
 `;
 
 Write(`${skillDir}/specs/quality-standards.md`, qualityStandards);
-```
 
-### Step 3: 生成 Agent 模板
+// Step 3: Generate agent base template
-
-```javascript
 const agentBase = `# Agent Base Template
 
-${config.display_name} 的 Agent 基础模板。
+Agent base template for ${config.display_name}.
 
-## 通用 Prompt 结构
+## Universal Prompt Structure
 
 \`\`\`
-[ROLE] 你是{角色}，专注于{职责}。
+[ROLE] You are {role}, focused on {responsibility}.
 
 [PROJECT CONTEXT]
 Skill: ${config.skill_name}
-目标: ${config.description}
+Objective: ${config.description}
 
 [TASK]
-{任务描述}
+{task description}
-- 输出: {output_path}
+- Output: {output_path}
-- 格式: ${config.output.format}
+- Format: ${config.output.format}
 
 [CONSTRAINTS]
-- 约束1
+- Constraint 1
-- 约束2
+- Constraint 2
 
 [OUTPUT_FORMAT]
-1. 执行任务
+1. Execute task
-2. 返回 JSON 简要信息
+2. Return JSON summary information
 
 [QUALITY_CHECKLIST]
-- [ ] 输出格式正确
+- [ ] Output format correct
-- [ ] 内容完整无遗漏
+- [ ] Content complete without omission
-- [ ] 无占位符残留
+- [ ] No placeholder remnants
 \`\`\`
 
-## 变量说明
+## Variable Description
 
-| 变量 | 来源 | 示例 |
+| Variable | Source | Example |
-|------|------|------|
+|----------|--------|---------|
-| {workDir} | 运行时 | .workflow/.scratchpad/${config.skill_name}-xxx |
+| {workDir} | Runtime | .workflow/.scratchpad/${config.skill_name}-xxx |
-| {output_path} | 配置 | ${config.output.location}/${config.output.filename_pattern} |
+| {output_path} | Configuration | ${config.output.location}/${config.output.filename_pattern} |
 
-## 返回格式
+## Return Format
 
 \`\`\`typescript
 interface AgentReturn {
@@ -243,33 +318,30 @@ interface AgentReturn {
 }
 \`\`\`
 
-## 角色定义参考
+## Role Definition Reference
 
 ${config.execution_mode === 'sequential' ?
-  config.sequential_config.phases.map((p, i) => 
+  config.sequential_config.phases.map((p, i) =>
-    `- **Phase ${i+1} Agent**: ${p.name} 专家`
+    `- **Phase ${i+1} Agent**: ${p.name} Expert`
   ).join('\n') :
-  config.autonomous_config.actions.map(a => 
+  config.autonomous_config.actions.map(a =>
-    `- **${a.name} Agent**: ${a.description || a.name + ' 执行者'}`
+    `- **${a.name} Agent**: ${a.description || a.name + ' Executor'}`
   ).join('\n')}
 `;
 
 Write(`${skillDir}/templates/agent-base.md`, agentBase);
-```
 
-### Step 4: Autonomous 模式 - 动作目录
+// Step 4: Conditional - Generate action catalog for autonomous/hybrid mode
-
-```javascript
 if (config.execution_mode === 'autonomous' || config.execution_mode === 'hybrid') {
   const actionCatalog = `# Action Catalog
 
-${config.display_name} 的可用动作目录。
+Available action catalog for ${config.display_name}.
 
 ## Available Actions
 
 | Action | Purpose | Preconditions | Effects |
 |--------|---------|---------------|---------|
-${config.autonomous_config.actions.map(a => 
+${config.autonomous_config.actions.map(a =>
   `| [${a.id}](../phases/actions/${a.id}.md) | ${a.description || a.name} | ${a.preconditions?.join(', ') || '-'} | ${a.effects?.join(', ') || '-'} |`
 ).join('\n')}
 
@@ -278,9 +350,9 @@ ${config.autonomous_config.actions.map(a =>
 \`\`\`mermaid
 graph TD
 ${config.autonomous_config.actions.map((a, i, arr) => {
-  if (i === 0) return `    ${a.id.replace(/-/g, '_')}[${a.name}]`;
+  if (i === 0) return \`    ${a.id.replace(/-/g, '_')}[${a.name}]\`;
   const prev = arr[i-1];
-  return `    ${prev.id.replace(/-/g, '_')} --> ${a.id.replace(/-/g, '_')}[${a.name}]`;
+  return \`    ${prev.id.replace(/-/g, '_')} --> ${a.id.replace(/-/g, '_')}[${a.name}]\`;
 }).join('\n')}
 \`\`\`
 
@@ -289,7 +361,7 @@ ${config.autonomous_config.actions.map((a, i, arr) => {
 | From State | Action | To State |
 |------------|--------|----------|
 | pending | action-init | running |
-${config.autonomous_config.actions.slice(1).map(a => 
+${config.autonomous_config.actions.slice(1).map(a =>
   `| running | ${a.id} | running |`
 ).join('\n')}
 | running | action-complete | completed |
@@ -297,32 +369,30 @@ ${config.autonomous_config.actions.slice(1).map(a =>
 
 ## Selection Priority
 
-当多个动作的前置条件都满足时，按以下优先级选择：
+When multiple actions' preconditions are met, select based on the following priority:
 
-${config.autonomous_config.actions.map((a, i) => 
+${config.autonomous_config.actions.map((a, i) =>
-  `${i + 1}. \`${a.id}\` - ${a.name}`
+  \`${i + 1}. \\\`${a.id}\\\` - ${a.name}\`
 ).join('\n')}
 `;
 
   Write(`${skillDir}/specs/action-catalog.md`, actionCatalog);
 }
-```
 
-### Step 5: 辅助函数
+// Helper function
-
-```javascript
 function toPascalCase(str) {
   return str.split('-').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('');
 }
+
+// Phase output summary
+console.log('Phase 4 complete: Generated specs and templates');
 ```
 
-## Output
-
-- `specs/{skill-name}-requirements.md` - 领域规范
-- `specs/quality-standards.md` - 质量标准
-- `specs/action-catalog.md` - 动作目录 (Autonomous 模式)
-- `templates/agent-base.md` - Agent 模板
-
 ## Next Phase
 
 → [Phase 5: Validation](05-validation.md)
+
+**Data Flow to Phase 5**:
+- All generated files in `specs/` and `templates/`
+- skill-config.json for validation reference
+- Complete skill directory structure ready for final validation

.claude/skills/skill-generator/phases/05-validation.md

@@ -1,27 +1,119 @@
 # Phase 5: Validation & Documentation
 
-验证生成的 Skill 完整性并生成使用说明。
+Verify generated skill completeness and generate user documentation.
 
 ## Objective
 
-- 验证所有必需文件存在
+Comprehensive validation and documentation:
-- 检查文件内容完整性
+- Verify all required files exist
-- 生成 README.md 使用说明
+- Check file content quality and completeness
-- 输出验证报告
+- Generate validation report with issues and recommendations
+- Generate README.md usage documentation
+- Output final status and next steps
 
 ## Input
 
-- 依赖: 所有前序阶段产出
+**File Dependencies**:
-- 生成的 Skill 目录
+- `skill-config.json` (from Phase 1)
+- `.claude/skills/{skill-name}/` directory (from Phase 2)
+- All generated phase/action files (from Phase 3)
+- All generated specs/templates files (from Phase 4)
 
-## Execution Steps
+**Required Information**:
+- Skill name, display name, description
+- Execution mode
+- Trigger words
+- Output configuration
+- Complete skill directory structure
 
-### Step 1: 文件完整性检查
+## Output
+
+**Generated Files**:
+
+| File | Purpose | Content |
+|------|---------|---------|
+| `validation-report.json` (workDir) | Validation report with detailed checks | File completeness, content quality, issues, recommendations |
+| `README.md` (skillDir) | User documentation | Quick Start, Usage, Output, Directory Structure, Customization |
+
+**Validation Report Structure** (`validation-report.json`):
+```json
+{
+  "skill_name": "...",
+  "execution_mode": "sequential|autonomous",
+  "generated_at": "ISO timestamp",
+  "file_checks": {
+    "total": N,
+    "existing": N,
+    "with_content": N,
+    "with_todos": N,
+    "details": [...]
+  },
+  "content_checks": {
+    "files_checked": N,
+    "all_passed": true|false,
+    "details": [...]
+  },
+  "summary": {
+    "status": "PASS|REVIEW|FAIL",
+    "issues": [...],
+    "recommendations": [...]
+  }
+}
+```
+
+**README Structure** (`README.md`):
+```markdown
+# {display_name}
+- Quick Start (Triggers, Execution Mode)
+- Usage (Examples)
+- Output (Format, Location, Filename)
+- Directory Structure (Tree view)
+- Customization (How to modify)
+- Related Documents (Links)
+```
+
+**Validation Status Gates**:
+
+| Status | Condition | Meaning |
+|--------|-----------|---------|
+| PASS | All files exist + All content checks passed | Ready for use |
+| REVIEW | All files exist + Some content checks failed | Needs refinement |
+| FAIL | Missing files | Incomplete generation |
+
+## Decision Logic
+
+```
+Decision (Validation Flow):
+   ├─ File Completeness Check
+   │  ├─ All files exist → Continue to content checks
+   │  └─ Missing files → Status = FAIL, collect missing file errors
+   │
+   ├─ Content Quality Check
+   │  ├─ Sequential mode → Check phase files for structure
+   │  ├─ Autonomous mode → Check orchestrator + action files
+   │  └─ Common → Check SKILL.md, specs/, templates/
+   │
+   ├─ Status Calculation
+   │  ├─ All files exist + All checks pass → Status = PASS
+   │  ├─ All files exist + Some checks fail → Status = REVIEW
+   │  └─ Missing files → Status = FAIL
+   │
+   └─ Generate Report & README
+      ├─ validation-report.json (with issues and recommendations)
+      └─ README.md (with usage documentation)
+```
+
+## Execution Protocol
 
 ```javascript
+// Phase 5: Validation & Documentation
+// Reference: phases/05-validation.md
+
+// Load config and setup
 const config = JSON.parse(Read(`${workDir}/skill-config.json`));
 const skillDir = `.claude/skills/${config.skill_name}`;
 
+// Step 1: File completeness check
 const requiredFiles = {
   common: [
     'SKILL.md',
@@ -64,14 +156,11 @@ const fileCheckResults = filesToCheck.map(file => {
     };
   }
 });
-```
 
-### Step 2: 内容质量检查
+// Step 2: Content quality check
-
-```javascript
 const contentChecks = [];
 
-// 检查 SKILL.md
+// Check SKILL.md structure
 const skillMd = Read(`${skillDir}/SKILL.md`);
 contentChecks.push({
   file: 'SKILL.md',
@@ -83,11 +172,11 @@ contentChecks.push({
   ]
 });
 
-// 检查 Phase 文件
+// Check phase files
 const phaseFiles = Glob(`${skillDir}/phases/*.md`);
 for (const phaseFile of phaseFiles) {
-  if (phaseFile.includes('/actions/')) continue; // 单独检查
+  if (phaseFile.includes('/actions/')) continue; // Check separately
-  
+
   const content = Read(phaseFile);
   contentChecks.push({
     file: phaseFile.replace(skillDir + '/', ''),
@@ -100,7 +189,7 @@ for (const phaseFile of phaseFiles) {
   });
 }
 
-// 检查 Specs 文件
+// Check specs files
 const specFiles = Glob(`${skillDir}/specs/*.md`);
 for (const specFile of specFiles) {
   const content = Read(specFile);
@@ -113,16 +202,13 @@ for (const specFile of specFiles) {
     ]
   });
 }
-```
 
-### Step 3: 生成验证报告
+// Step 3: Generate validation report
-
-```javascript
 const report = {
   skill_name: config.skill_name,
   execution_mode: config.execution_mode,
   generated_at: new Date().toISOString(),
-  
+
   file_checks: {
     total: fileCheckResults.length,
     existing: fileCheckResults.filter(f => f.exists).length,
@@ -130,13 +216,13 @@ const report = {
     with_todos: fileCheckResults.filter(f => f.hasTodo).length,
     details: fileCheckResults
   },
-  
+
   content_checks: {
     files_checked: contentChecks.length,
     all_passed: contentChecks.every(c => c.checks.every(ch => ch.pass)),
     details: contentChecks
   },
-  
+
   summary: {
     status: calculateOverallStatus(fileCheckResults, contentChecks),
     issues: collectIssues(fileCheckResults, contentChecks),
@@ -146,10 +232,11 @@ const report = {
 
 Write(`${workDir}/validation-report.json`, JSON.stringify(report, null, 2));
 
+// Helper functions
 function calculateOverallStatus(fileResults, contentResults) {
   const allFilesExist = fileResults.every(f => f.exists);
   const allContentPassed = contentResults.every(c => c.checks.every(ch => ch.pass));
-  
+
   if (allFilesExist && allContentPassed) return 'PASS';
   if (allFilesExist) return 'REVIEW';
   return 'FAIL';
@@ -157,125 +244,122 @@ function calculateOverallStatus(fileResults, contentResults) {
 
 function collectIssues(fileResults, contentResults) {
   const issues = [];
-  
+
   fileResults.filter(f => !f.exists).forEach(f => {
-    issues.push({ type: 'ERROR', message: `文件缺失: ${f.file}` });
+    issues.push({ type: 'ERROR', message: `Missing file: ${f.file}` });
   });
-  
+
   fileResults.filter(f => f.hasTodo).forEach(f => {
-    issues.push({ type: 'WARNING', message: `包含 TODO: ${f.file}` });
+    issues.push({ type: 'WARNING', message: `Contains TODO: ${f.file}` });
   });
-  
+
   contentResults.forEach(c => {
     c.checks.filter(ch => !ch.pass).forEach(ch => {
-      issues.push({ type: 'WARNING', message: `${c.file}: 缺少 ${ch.name}` });
+      issues.push({ type: 'WARNING', message: `${c.file}: Missing ${ch.name}` });
     });
   });
-  
+
   return issues;
 }
 
 function generateRecommendations(fileResults, contentResults) {
   const recommendations = [];
-  
+
   if (fileResults.some(f => f.hasTodo)) {
-    recommendations.push('替换所有 TODO 占位符为实际内容');
+    recommendations.push('Replace all TODO placeholders with actual content');
   }
-  
+
   contentResults.forEach(c => {
     if (c.checks.some(ch => !ch.pass)) {
-      recommendations.push(`完善 ${c.file} 的结构`);
+      recommendations.push(`Improve structure of ${c.file}`);
     }
   });
-  
+
   return recommendations;
 }
-```
 
-### Step 4: 生成 README.md
+// Step 4: Generate README.md
-
-```javascript
 const readme = `# ${config.display_name}
 
 ${config.description}
 
 ## Quick Start
 
-### 触发词
+### Trigger Words
 
 ${config.triggers.map(t => `- "${t}"`).join('\n')}
 
-### 执行模式
+### Execution Mode
 
-**${config.execution_mode === 'sequential' ? 'Sequential (顺序)' : 'Autonomous (自主)'}**
+**${config.execution_mode === 'sequential' ? 'Sequential (Sequential)' : 'Autonomous (Autonomous)'}**
 
 ${config.execution_mode === 'sequential' ?
-  `阶段按固定顺序执行：\n${config.sequential_config.phases.map((p, i) => 
+  \`Phases execute in fixed order:\n\${config.sequential_config.phases.map((p, i) =>
-    `${i + 1}. ${p.name}`
+    \`\${i + 1}. \${p.name}\`
-  ).join('\n')}` :
+  ).join('\n')}\` :
-  `动作由编排器动态选择：\n${config.autonomous_config.actions.map(a => 
+  \`Actions selected dynamically by orchestrator:\n\${config.autonomous_config.actions.map(a =>
-    `- ${a.name}: ${a.description || ''}`
+    \`- \${a.name}: \${a.description || ''}\`
-  ).join('\n')}`}
+  ).join('\n')}\`}
 
 ## Usage
 
 \`\`\`
-# 直接触发
+# Direct trigger
-用户: ${config.triggers[0]}
+User: ${config.triggers[0]}
 
-# 或使用 Skill 名称
+# Or use Skill name
-用户: /skill ${config.skill_name}
+User: /skill ${config.skill_name}
 \`\`\`
 
 ## Output
 
-- **格式**: ${config.output.format}
+- **Format**: ${config.output.format}
-- **位置**: \`${config.output.location}\`
+- **Location**: \`${config.output.location}\`
-- **文件名**: \`${config.output.filename_pattern}\`
+- **Filename**: \`${config.output.filename_pattern}\`
 
 ## Directory Structure
 
 \`\`\`
 .claude/skills/${config.skill_name}/
-├── SKILL.md                    # 入口文件
+├── SKILL.md                    # Entry file
-├── phases/                     # 执行阶段
+├── phases/                     # Execution phases
 ${config.execution_mode === 'sequential' ?
-  config.sequential_config.phases.map(p => `│   ├── ${p.id}.md`).join('\n') :
+  config.sequential_config.phases.map(p => \`│   ├── \${p.id}.md\`).join('\n') :
-  `│   ├── orchestrator.md
+  \`│   ├── orchestrator.md
 │   ├── state-schema.md
 │   └── actions/
-${config.autonomous_config.actions.map(a => `│       ├── ${a.id}.md`).join('\n')}`}
+\${config.autonomous_config.actions.map(a => \`│       ├── \${a.id}.md\`).join('\n')}\`}
-├── specs/                      # 规范文件
+├── specs/                      # Specification files
 │   ├── ${config.skill_name}-requirements.md
 │   ├── quality-standards.md
 ${config.execution_mode === 'autonomous' ? '│   └── action-catalog.md' : ''}
-└── templates/                  # 模板文件
+└── templates/                  # Template files
     └── agent-base.md
 \`\`\`
 
 ## Customization
 
-### 修改执行逻辑
+### Modify Execution Logic
 
-编辑 \`phases/\` 目录下的阶段文件。
+Edit phase files in the \`phases/\` directory.
 
-### 调整质量标准
+### Adjust Quality Standards
 
-编辑 \`specs/quality-standards.md\`。
+Edit \`specs/quality-standards.md\`.
 
-### 添加新${config.execution_mode === 'sequential' ? '阶段' : '动作'}
+### Add New ${config.execution_mode === 'sequential' ? 'Phase' : 'Action'}
 
 ${config.execution_mode === 'sequential' ?
-  `1. 在 \`phases/\` 创建新的阶段文件 (如 \`03.5-new-step.md\`)
+  \`1. Create new phase file in \`phases/\` (e.g., \`03.5-new-step.md\`)
-2. 更新 SKILL.md 的执行流程` :
+2. Update execution flow in SKILL.md\` :
-  `1. 在 \`phases/actions/\` 创建新的动作文件
+  \`1. Create new action file in \`phases/actions/\`
-2. 更新 \`specs/action-catalog.md\`
+2. Update \`specs/action-catalog.md\`
-3. 在 \`phases/orchestrator.md\` 添加选择逻辑`}
+3. Add selection logic in \`phases/orchestrator.md\`\`}
 
 ## Related Documents
 
-- [设计规范](../_shared/SKILL-DESIGN-SPEC.md)
+- [Design Specification](../_shared/SKILL-DESIGN-SPEC.md)
-- [执行模式规范](specs/../../../skill-generator/specs/execution-modes.md)
+- [Execution Modes Specification](specs/../../../skill-generator/specs/execution-modes.md)
 
 ---
 
@@ -283,52 +367,51 @@ ${config.execution_mode === 'sequential' ?
 `;
 
 Write(`${skillDir}/README.md`, readme);
-```
 
-### Step 5: 输出最终结果
+// Step 5: Output final result
-
-```javascript
 const finalResult = {
   skill_name: config.skill_name,
   skill_path: skillDir,
   execution_mode: config.execution_mode,
-  
+
   generated_files: [
     'SKILL.md',
     'README.md',
     ...filesToCheck
   ],
-  
+
   validation: report.summary,
-  
+
   next_steps: [
-    '1. 审阅生成的文件结构',
+    '1. Review generated file structure',
-    '2. 替换 TODO 占位符',
+    '2. Replace TODO placeholders',
-    '3. 根据实际需求调整阶段逻辑',
+    '3. Adjust phase logic based on actual requirements',
-    '4. 测试 Skill 执行流程',
+    '4. Test Skill execution flow',
-    '5. 更新触发词和描述'
+    '5. Update trigger words and descriptions'
   ]
 };
 
-console.log('=== Skill 生成完成 ===');
+console.log('=== Skill Generation Complete ===');
-console.log(`路径: ${skillDir}`);
+console.log(\`Path: \${skillDir}\`);
-console.log(`模式: ${config.execution_mode}`);
+console.log(\`Mode: \${config.execution_mode}\`);
-console.log(`状态: ${report.summary.status}`);
+console.log(\`Status: \${report.summary.status}\`);
 console.log('');
-console.log('下一步:');
+console.log('Next Steps:');
 finalResult.next_steps.forEach(s => console.log(s));
 ```
 
-## Output
+## Workflow Completion
 
-- `{workDir}/validation-report.json` - 验证报告
+**Final Status**: Skill generation pipeline complete
-- `{skillDir}/README.md` - 使用说明
 
-## Completion
+**Generated Artifacts**:
+- Complete skill directory structure in `.claude/skills/{skill-name}/`
+- Validation report in `{workDir}/validation-report.json`
+- User documentation in `{skillDir}/README.md`
 
-Skill 生成流程完成。用户可以：
+**Next Steps**:
-
+1. Review validation report for any issues or recommendations
-1. 查看生成的 Skill 目录
+2. Replace TODO placeholders with actual implementation
-2. 根据验证报告修复问题
+3. Test skill execution with trigger words
-3. 自定义执行逻辑
+4. Customize phase logic based on specific requirements
-4. 测试 Skill 功能
+5. Update triggers and descriptions as needed

.claude/skills/skill-generator/specs/cli-integration.md

@@ -1,111 +1,111 @@
 # CLI Integration Specification
 
-CCW CLI 集成规范，定义 Skill 中如何正确调用外部 CLI 工具。
+CCW CLI integration specification that defines how to properly call external CLI tools within Skills.
 
 ---
 
-## 执行模式
+## Execution Modes
 
-### 1. 同步执行 (Blocking)
+### 1. Synchronous Execution (Blocking)
 
-适用于需要立即获取结果的场景。
+Suitable for scenarios that need immediate results.
 
 ```javascript
-// Agent 调用 - 同步
+// Agent call - synchronous
 const result = Task({
   subagent_type: 'universal-executor',
-  prompt: '执行任务...',
+  prompt: 'Execute task...',
-  run_in_background: false  // 关键: 同步执行
+  run_in_background: false  // Key: synchronous execution
 });
 
-// 结果立即可用
+// Result immediately available
 console.log(result);
 ```
 
-### 2. 异步执行 (Background)
+### 2. Asynchronous Execution (Background)
 
-适用于长时间运行的 CLI 命令。
+Suitable for long-running CLI commands.
 
 ```javascript
-// CLI 调用 - 异步
+// CLI call - asynchronous
 const task = Bash({
   command: 'ccw cli -p "..." --tool gemini --mode analysis',
-  run_in_background: true  // 关键: 后台执行
+  run_in_background: true  // Key: background execution
 });
 
-// 立即返回，不等待结果
+// Returns immediately without waiting for result
-// task.task_id 可用于后续查询
+// task.task_id available for later queries
 ```
 
 ---
 
-## CCW CLI 调用规范
+## CCW CLI Call Specification
 
-### 基础命令结构
+### Basic Command Structure
 
 ```bash
 ccw cli -p "<PROMPT>" --tool <gemini|qwen|codex> --mode <analysis|write>
 ```
 
-### 参数说明
+### Parameter Description
 
-| 参数 | 必需 | 说明 |
+| Parameter | Required | Description |
-|------|------|------|
+|-----------|----------|-------------|
-| `-p "<prompt>"` | ✓ | 提示词（使用双引号） |
+| `-p "<prompt>"` | Yes | Prompt text (use double quotes) |
-| `--tool <tool>` | ✓ | 工具选择: gemini, qwen, codex |
+| `--tool <tool>` | Yes | Tool selection: gemini, qwen, codex |
-| `--mode <mode>` | ✓ | 执行模式: analysis, write |
+| `--mode <mode>` | Yes | Execution mode: analysis, write |
-| `--cd <path>` | - | 工作目录 |
+| `--cd <path>` | - | Working directory |
-| `--includeDirs <dirs>` | - | 包含额外目录（逗号分隔） |
+| `--includeDirs <dirs>` | - | Additional directories (comma-separated) |
-| `--resume [id]` | - | 恢复会话 |
+| `--resume [id]` | - | Resume session |
 
-### 模式选择
+### Mode Selection
 
 ```
-┌─ 分析/文档任务?
+- Analysis/Documentation tasks?
-│  └─→ --mode analysis (只读)
+  → --mode analysis (read-only)
-│
+
-└─ 实现/修改任务?
+- Implementation/Modification tasks?
-   └─→ --mode write (读写)
+  → --mode write (read-write)
 ```
 
 ---
 
-## Agent 类型与选择
+## Agent Types and Selection
 
 ### universal-executor
 
-通用执行器，最常用的 Agent 类型。
+General-purpose executor, the most commonly used agent type.
 
 ```javascript
 Task({
   subagent_type: 'universal-executor',
   prompt: `
-执行任务:
+Execute task:
-1. 读取配置文件
+1. Read configuration file
-2. 分析依赖关系
+2. Analyze dependencies
-3. 生成报告到 ${outputPath}
+3. Generate report to ${outputPath}
   `,
   run_in_background: false
 });
 ```
 
-**适用场景**:
+**Applicable Scenarios**:
-- 多步骤任务执行
+- Multi-step task execution
-- 文件操作（读/写/编辑）
+- File operations (read/write/edit)
-- 需要工具调用的任务
+- Tasks that require tool invocation
 
 ### Explore
 
-代码探索 Agent，快速理解代码库。
+Code exploration agent for quick codebase understanding.
 
 ```javascript
 Task({
   subagent_type: 'Explore',
   prompt: `
-探索 src/ 目录:
+Explore src/ directory:
-- 识别主要模块
+- Identify main modules
-- 理解目录结构
+- Understand directory structure
-- 找到入口点
+- Find entry points
 
 Thoroughness: medium
   `,
@@ -113,104 +113,104 @@ Thoroughness: medium
 });
 ```
 
-**适用场景**:
+**Applicable Scenarios**:
-- 代码库探索
+- Codebase exploration
-- 文件发现
+- File discovery
-- 结构理解
+- Structure understanding
 
 ### cli-explore-agent
 
-深度代码分析 Agent。
+Deep code analysis agent.
 
 ```javascript
 Task({
   subagent_type: 'cli-explore-agent',
   prompt: `
-深度分析 src/auth/ 模块:
+Deep analysis of src/auth/ module:
-- 认证流程
+- Authentication flow
-- 会话管理
+- Session management
-- 安全机制
+- Security mechanisms
   `,
   run_in_background: false
 });
 ```
 
-**适用场景**:
+**Applicable Scenarios**:
-- 深度代码理解
+- Deep code understanding
-- 设计模式识别
+- Design pattern identification
-- 复杂逻辑分析
+- Complex logic analysis
 
 ---
 
-## 会话管理
+## Session Management
 
-### 会话恢复
+### Session Recovery
 
 ```javascript
-// 保存会话 ID
+// Save session ID
 const session = Bash({
-  command: 'ccw cli -p "初始分析..." --tool gemini --mode analysis',
+  command: 'ccw cli -p "Initial analysis..." --tool gemini --mode analysis',
   run_in_background: true
 });
 
-// 后续恢复
+// Resume later
 const continuation = Bash({
-  command: `ccw cli -p "继续分析..." --tool gemini --mode analysis --resume ${session.id}`,
+  command: `ccw cli -p "Continue analysis..." --tool gemini --mode analysis --resume ${session.id}`,
   run_in_background: true
 });
 ```
 
-### 多会话合并
+### Multi-Session Merge
 
 ```javascript
-// 合并多个会话的上下文
+// Merge context from multiple sessions
 const merged = Bash({
-  command: `ccw cli -p "汇总分析..." --tool gemini --mode analysis --resume ${id1},${id2}`,
+  command: `ccw cli -p "Aggregate analysis..." --tool gemini --mode analysis --resume ${id1},${id2}`,
   run_in_background: true
 });
 ```
 
 ---
 
-## Skill 中的 CLI 集成模式
+## CLI Integration Patterns in Skills
 
-### 模式 1: 单次调用
+### Pattern 1: Single Call
 
-简单任务，一次调用完成。
+Simple tasks completed in one call.
 
 ```javascript
-// Phase 执行
+// Phase execution
 async function executePhase(context) {
   const result = Bash({
     command: `ccw cli -p "
-PURPOSE: 分析项目结构
+PURPOSE: Analyze project structure
-TASK: 识别模块、依赖、入口点
+TASK: Identify modules, dependencies, entry points
 MODE: analysis
 CONTEXT: @src/**/*
-EXPECTED: JSON 格式的结构报告
+EXPECTED: JSON format structure report
 " --tool gemini --mode analysis --cd ${context.projectRoot}`,
     run_in_background: true,
     timeout: 600000
   });
 
-  // 等待完成
+  // Wait for completion
   return await waitForCompletion(result.task_id);
 }
 ```
 
-### 模式 2: 链式调用
+### Pattern 2: Chained Calls
 
-多步骤任务，每步依赖前一步结果。
+Multi-step tasks where each step depends on previous results.
 
 ```javascript
 async function executeChain(context) {
-  // Step 1: 收集
+  // Step 1: Collect
   const collectId = await runCLI('collect', context);
 
-  // Step 2: 分析 (依赖 Step 1)
+  // Step 2: Analyze (depends on Step 1)
   const analyzeId = await runCLI('analyze', context, `--resume ${collectId}`);
 
-  // Step 3: 生成 (依赖 Step 2)
+  // Step 3: Generate (depends on Step 2)
   const generateId = await runCLI('generate', context, `--resume ${analyzeId}`);
 
   return generateId;
@@ -218,9 +218,9 @@ async function executeChain(context) {
 
 async function runCLI(step, context, resumeFlag = '') {
   const prompts = {
-    collect: 'PURPOSE: 收集代码文件...',
+    collect: 'PURPOSE: Collect code files...',
-    analyze: 'PURPOSE: 分析代码模式...',
+    analyze: 'PURPOSE: Analyze code patterns...',
-    generate: 'PURPOSE: 生成文档...'
+    generate: 'PURPOSE: Generate documentation...'
   };
 
   const result = Bash({
@@ -232,9 +232,9 @@ async function runCLI(step, context, resumeFlag = '') {
 }
 ```
 
-### 模式 3: 并行调用
+### Pattern 3: Parallel Calls
 
-独立任务并行执行。
+Independent tasks executed in parallel.
 
 ```javascript
 async function executeParallel(context) {
@@ -244,15 +244,15 @@ async function executeParallel(context) {
     { type: 'patterns', tool: 'qwen' }
   ];
 
-  // 并行启动
+  // Start tasks in parallel
   const taskIds = tasks.map(task =>
     Bash({
-      command: `ccw cli -p "分析 ${task.type}..." --tool ${task.tool} --mode analysis`,
+      command: `ccw cli -p "Analyze ${task.type}..." --tool ${task.tool} --mode analysis`,
       run_in_background: true
     }).task_id
   );
 
-  // 等待全部完成
+  // Wait for all to complete
   const results = await Promise.all(
     taskIds.map(id => waitForCompletion(id))
   );
@@ -261,9 +261,9 @@ async function executeParallel(context) {
 }
 ```
 
-### 模式 4: Fallback 链
+### Pattern 4: Fallback Chain
 
-工具失败时自动切换。
+Automatically switch tools on failure.
 
 ```javascript
 async function executeWithFallback(context) {
@@ -299,9 +299,9 @@ async function runWithTool(tool, context) {
 
 ---
 
-## 提示词模板集成
+## Prompt Template Integration
 
-### 引用协议模板
+### Reference Protocol Templates
 
 ```bash
 # Analysis mode - use --rule to auto-load protocol and template (appended to prompt)
@@ -315,7 +315,7 @@ CONSTRAINTS: ...
 ..." --tool codex --mode write --rule development-feature
 ```
 
-### 动态模板构建
+### Dynamic Template Building
 
 ```javascript
 function buildPrompt(config) {
@@ -334,21 +334,21 @@ CONSTRAINTS: ${constraints || ''}
 
 ---
 
-## 超时配置
+## Timeout Configuration
 
-### 推荐超时值
+### Recommended Timeout Values
 
-| 任务类型 | 超时 (ms) | 说明 |
+| Task Type | Timeout (ms) | Description |
-|---------|----------|------|
+|-----------|--------------|-------------|
-| 快速分析 | 300000 | 5 分钟 |
+| Quick analysis | 300000 | 5 minutes |
-| 标准分析 | 600000 | 10 分钟 |
+| Standard analysis | 600000 | 10 minutes |
-| 深度分析 | 1200000 | 20 分钟 |
+| Deep analysis | 1200000 | 20 minutes |
-| 代码生成 | 1800000 | 30 分钟 |
+| Code generation | 1800000 | 30 minutes |
-| 复杂任务 | 3600000 | 60 分钟 |
+| Complex tasks | 3600000 | 60 minutes |
 
-### Codex 特殊处理
+### Special Codex Handling
 
-Codex 需要更长的超时时间（建议 3x）。
+Codex requires longer timeout (recommend 3x).
 
 ```javascript
 const timeout = tool === 'codex' ? baseTimeout * 3 : baseTimeout;
@@ -362,17 +362,17 @@ Bash({
 
 ---
 
-## 错误处理
+## Error Handling
 
-### 常见错误
+### Common Errors
 
-| 错误 | 原因 | 处理 |
+| Error | Cause | Handler |
-|------|------|------|
+|-------|-------|---------|
-| ETIMEDOUT | 网络超时 | 重试或切换工具 |
+| ETIMEDOUT | Network timeout | Retry or switch tool |
-| Exit code 1 | 命令执行失败 | 检查参数，切换工具 |
+| Exit code 1 | Command execution failed | Check parameters, switch tool |
-| Context overflow | 上下文过大 | 减少输入范围 |
+| Context overflow | Input context too large | Reduce input scope |
 
-### 重试策略
+### Retry Strategy
 
 ```javascript
 async function executeWithRetry(command, maxRetries = 3) {
@@ -391,7 +391,7 @@ async function executeWithRetry(command, maxRetries = 3) {
       lastError = error;
       console.log(`Attempt ${attempt} failed: ${error.message}`);
 
-      // 指数退避
+      // Exponential backoff
       if (attempt < maxRetries) {
         await sleep(Math.pow(2, attempt) * 1000);
       }
@@ -404,30 +404,30 @@ async function executeWithRetry(command, maxRetries = 3) {
 
 ---
 
-## 最佳实践
+## Best Practices
 
-### 1. run_in_background 规则
+### 1. run_in_background Rule
 
 ```
-Agent 调用 (Task):
+Agent calls (Task):
-  run_in_background: false  → 同步，立即获取结果
+  run_in_background: false  → Synchronous, get result immediately
 
-CLI 调用 (Bash + ccw cli):
+CLI calls (Bash + ccw cli):
-  run_in_background: true   → 异步，后台执行
+  run_in_background: true   → Asynchronous, run in background
 ```
 
-### 2. 工具选择
+### 2. Tool Selection
 
 ```
-分析任务: gemini > qwen
+Analysis tasks: gemini > qwen
-生成任务: codex > gemini > qwen
+Generation tasks: codex > gemini > qwen
-代码修改: codex > gemini
+Code modification: codex > gemini
 ```
 
-### 3. 会话管理
+### 3. Session Management
 
-- 相关任务使用 `--resume` 保持上下文
+- Use `--resume` for related tasks to maintain context
-- 独立任务不使用 `--resume`
+- Do not use `--resume` for independent tasks
 
 ### 4. Prompt Specification
 
@@ -435,8 +435,8 @@ CLI 调用 (Bash + ccw cli):
 - Use `--rule <template>` to auto-append protocol + template to prompt
 - Template name format: `category-function` (e.g., `analysis-code-patterns`)
 
-### 5. 结果处理
+### 5. Result Processing
 
-- 持久化重要结果到 workDir
+- Persist important results to workDir
-- Brief returns: 路径 + 摘要，避免上下文溢出
+- Brief returns: path + summary, avoid context overflow
-- JSON 格式便于后续处理
+- JSON format convenient for downstream processing

.claude/skills/skill-generator/specs/execution-modes.md

@@ -1,40 +1,40 @@
 # Execution Modes Specification
 
-两种 Skill 执行模式的详细规范定义。
+Detailed specification definitions for two Skill execution modes.
 
 ---
 
-## 模式概览
+## Mode Overview
 
-| 特性 | Sequential (顺序) | Autonomous (自主) |
+| Feature | Sequential (Fixed Order) | Autonomous (Dynamic) |
-|------|-------------------|-------------------|
+|---------|--------------------------|----------------------|
-| 执行顺序 | 固定（数字前缀） | 动态（编排器决策） |
+| Execution Order | Fixed (numeric prefix) | Dynamic (orchestrator decision) |
-| 阶段依赖 | 强依赖 | 弱依赖/无依赖 |
+| Phase Dependencies | Strong dependencies | Weak/no dependencies |
-| 状态管理 | 隐式（阶段产出） | 显式（状态文件） |
+| State Management | Implicit (phase output) | Explicit (state file) |
-| 适用场景 | 流水线任务 | 交互式任务 |
+| Use Cases | Pipeline tasks | Interactive tasks |
-| 复杂度 | 低 | 中-高 |
+| Complexity | Low | Medium-High |
-| 可扩展性 | 插入子阶段 | 添加新动作 |
+| Extensibility | Insert sub-phases | Add new actions |
 
 ---
 
-## Mode 1: Sequential (顺序模式)
+## Mode 1: Sequential (Fixed Order Mode)
 
-### 定义
+### Definition
 
-阶段按固定顺序线性执行，每个阶段的输出作为下一阶段的输入。
+Phases execute linearly in fixed order, with each phase's output serving as input to the next phase.
 
-### 目录结构
+### Directory Structure
 
 ```
 phases/
 ├── 01-{first-step}.md
 ├── 02-{second-step}.md
-├── 02.5-{sub-step}.md      # 可选：子阶段
+├── 02.5-{sub-step}.md      # Optional: sub-phase
 ├── 03-{third-step}.md
 └── ...
 ```
 
-### 执行流程
+### Execution Flow
 
 ```
 ┌─────────┐     ┌─────────┐     ┌─────────┐
@@ -45,33 +45,33 @@ phases/
   output1.json   output2.md      output3.md
 ```
 
-### Phase 文件规范
+### Phase File Specification
 
 ```markdown
-# Phase N: {阶段名称}
+# Phase N: {Phase Name}
 
-{一句话描述}
+{One-sentence description}
 
 ## Objective
 
-{详细目标}
+{Detailed objective}
 
 ## Input
 
-- 依赖: {上一阶段产出}
+- Dependencies: {Previous phase output}
-- 配置: {配置文件}
+- Configuration: {Configuration file}
 
 ## Execution Steps
 
-### Step 1: {步骤}
+### Step 1: {Step}
-{执行代码或说明}
+{Execution code or description}
 
-### Step 2: {步骤}
+### Step 2: {Step}
-{执行代码或说明}
+{Execution code or description}
 
 ## Output
 
-- **File**: `{输出文件}`
+- **File**: `{Output file}`
 - **Format**: {JSON/Markdown}
 
 ## Next Phase
@@ -79,74 +79,74 @@ phases/
 → [Phase N+1: xxx](0N+1-xxx.md)
 ```
 
-### 适用场景
+### Applicable Scenarios
 
-- **文档生成**: 收集 → 分析 → 组装 → 优化
+- **Document Generation**: Collect → Analyze → Assemble → Optimize
-- **代码分析**: 扫描 → 解析 → 报告
+- **Code Analysis**: Scan → Parse → Report
-- **数据处理**: 提取 → 转换 → 加载
+- **Data Processing**: Extract → Transform → Load
 
-### 优点
+### Advantages
 
-- 逻辑清晰，易于理解
+- Clear logic, easy to understand
-- 调试简单，可逐阶段验证
+- Simple debugging, can validate phase by phase
-- 输出可预测
+- Predictable output
 
-### 缺点
+### Disadvantages
 
-- 灵活性低
+- Low flexibility
-- 难以处理分支逻辑
+- Difficult to handle branching logic
-- 用户交互受限
+- Limited user interaction
 
 ---
 
-## Mode 2: Autonomous (自主模式)
+## Mode 2: Autonomous (Dynamic Mode)
 
-### 定义
+### Definition
 
-无固定执行顺序，由编排器 (Orchestrator) 根据当前状态动态选择下一个动作。
+No fixed execution order. The orchestrator dynamically selects the next action based on current state.
 
-### 目录结构
+### Directory Structure
 
 ```
 phases/
-├── orchestrator.md          # 编排器：核心决策逻辑
+├── orchestrator.md          # Orchestrator: core decision logic
-├── state-schema.md          # 状态结构定义
+├── state-schema.md          # State structure definition
-└── actions/                 # 独立动作（无顺序）
+└── actions/                 # Independent actions (no order)
     ├── action-{a}.md
     ├── action-{b}.md
     ├── action-{c}.md
     └── ...
 ```
 
-### 核心组件
+### Core Components
 
-#### 1. Orchestrator (编排器)
+#### 1. Orchestrator
 
 ```markdown
 # Orchestrator
 
 ## Role
 
-根据当前状态选择并执行下一个动作。
+Select and execute the next action based on current state.
 
 ## State Reading
 
-读取状态文件: `{workDir}/state.json`
+Read state file: `{workDir}/state.json`
 
 ## Decision Logic
 
 ```javascript
 function selectNextAction(state) {
-  // 1. 检查终止条件
+  // 1. Check termination conditions
   if (state.status === 'completed') return null;
   if (state.error_count > MAX_RETRIES) return 'action-abort';
-  
+
-  // 2. 根据状态选择动作
+  // 2. Select action based on state
   if (!state.initialized) return 'action-init';
   if (state.pending_items.length > 0) return 'action-process';
   if (state.needs_review) return 'action-review';
-  
+
-  // 3. 默认动作
+  // 3. Default action
   return 'action-complete';
 }
 ```
@@ -158,42 +158,42 @@ while (true) {
   state = readState();
   action = selectNextAction(state);
   if (!action) break;
-  
+
   result = executeAction(action, state);
   updateState(result);
 }
 ```
 ```
 
-#### 2. State Schema (状态结构)
+#### 2. State Schema
 
 ```markdown
 # State Schema
 
-## 状态文件
+## State File
 
-位置: `{workDir}/state.json`
+Location: `{workDir}/state.json`
 
-## 结构定义
+## Structure Definition
 
 ```typescript
 interface SkillState {
-  // 元信息
+  // Metadata
   skill_name: string;
   started_at: string;
   updated_at: string;
-  
+
-  // 执行状态
+  // Execution state
   status: 'pending' | 'running' | 'completed' | 'failed';
   current_action: string | null;
   completed_actions: string[];
-  
+
-  // 业务数据
+  // Business data
   context: Record<string, any>;
   pending_items: any[];
   results: Record<string, any>;
-  
+
-  // 错误追踪
+  // Error tracking
   errors: Array<{
     action: string;
     message: string;
@@ -203,7 +203,7 @@ interface SkillState {
 }
 ```
 
-## 初始状态
+## Initial State
 
 ```json
 {
@@ -222,23 +222,23 @@ interface SkillState {
 ```
 ```
 
-#### 3. Action (动作)
+#### 3. Action
 
 ```markdown
 # Action: {action-name}
 
 ## Purpose
 
-{动作目的}
+{Action purpose}
 
 ## Preconditions
 
-- [ ] 条件1
+- [ ] Condition 1
-- [ ] 条件2
+- [ ] Condition 2
 
 ## Execution
 
-{执行逻辑}
+{Execution logic}
 
 ## State Updates
 
@@ -247,19 +247,19 @@ return {
   completed_actions: [...state.completed_actions, 'action-name'],
   results: {
     ...state.results,
-    action_name: { /* 结果 */ }
+    action_name: { /* result */ }
   },
-  // 其他状态更新
+  // Other state updates
 };
 ```
 
 ## Next Actions (Hints)
 
-- 成功时: `action-{next}`
+- On success: `action-{next}`
-- 失败时: `action-retry` 或 `action-abort`
+- On failure: `action-retry` or `action-abort`
 ```
 
-### 执行流程
+### Execution Flow
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
@@ -289,9 +289,9 @@ return {
 └─────────────────────────────────────────────────────────────────┘
 ```
 
-### 动作目录 (Action Catalog)
+### Action Catalog
 
-在 `specs/action-catalog.md` 中定义：
+Defined in `specs/action-catalog.md`:
 
 ```markdown
 # Action Catalog
@@ -300,11 +300,11 @@ return {
 
 | Action | Purpose | Preconditions | Effects |
 |--------|---------|---------------|---------|
-| action-init | 初始化状态 | status=pending | status=running |
+| action-init | Initialize state | status=pending | status=running |
-| action-process | 处理待办项 | pending_items.length>0 | pending_items-- |
+| action-process | Process pending items | pending_items.length>0 | pending_items-- |
-| action-review | 用户审核 | needs_review=true | needs_review=false |
+| action-review | User review | needs_review=true | needs_review=false |
-| action-complete | 完成任务 | pending_items.length=0 | status=completed |
+| action-complete | Complete task | pending_items.length=0 | status=completed |
-| action-abort | 中止任务 | error_count>MAX | status=failed |
+| action-abort | Abort task | error_count>MAX | status=failed |
 
 ## Action Dependencies Graph
 
@@ -319,78 +319,81 @@ graph TD
 ```
 ```
 
-### 适用场景
+### Applicable Scenarios
 
-- **交互式任务**: 问答、对话、表单填写
+- **Interactive Tasks**: Q&A, dialog, form filling
-- **状态机任务**: Issue 管理、工作流审批
+- **State Machine Tasks**: Issue management, workflow approval
-- **探索式任务**: 调试、诊断、搜索
+- **Exploratory Tasks**: Debugging, diagnosis, search
 
-### 优点
+### Advantages
 
-- 高度灵活，适应动态需求
+- Highly flexible, adapts to dynamic requirements
-- 支持复杂分支逻辑
+- Supports complex branching logic
-- 易于扩展新动作
+- Easy to extend with new actions
 
-### 缺点
+### Disadvantages
 
-- 复杂度高
+- High complexity
-- 状态管理开销
+- State management overhead
-- 调试难度大
+- Large debugging difficulty
 
 ---
 
-## 模式选择指南
+## Mode Selection Guide
 
-### 决策流程
+### Decision Flow
 
 ```
-用户需求分析
+Analyze user requirements
      │
      ▼
 ┌────────────────────────────┐
-│ 阶段间是否有强依赖关系？     │
+│ Are there strong           │
+│ dependencies between       │
+│ phases?                    │
 └────────────────────────────┘
      │
-     ├── 是 → Sequential
+     ├── Yes → Sequential
      │
-     └── 否 → 继续判断
+     └── No → Continue decision
               │
               ▼
      ┌────────────────────────────┐
-     │ 是否需要动态响应用户意图？   │
+     │ Do you need dynamic         │
+     │ response to user intent?    │
      └────────────────────────────┘
               │
-              ├── 是 → Autonomous
+              ├── Yes → Autonomous
               │
-              └── 否 → Sequential
+              └── No → Sequential
 ```
 
-### 快速判断表
+### Quick Decision Table
 
-| 问题 | Sequential | Autonomous |
+| Question | Sequential | Autonomous |
-|------|------------|------------|
+|----------|------------|------------|
-| 输出结构是否固定？ | ✓ | ✗ |
+| Is output structure fixed? | Yes | No |
-| 是否需要用户多轮交互？ | ✗ | ✓ |
+| Do you need multi-turn user interaction? | No | Yes |
-| 阶段是否可以跳过/重复？ | ✗ | ✓ |
+| Can phases be skipped/repeated? | No | Yes |
-| 是否有复杂分支逻辑？ | ✗ | ✓ |
+| Is there complex branching logic? | No | Yes |
-| 调试是否需要简单？ | ✓ | ✗ |
+| Should debugging be simple? | Yes | No |
 
 ---
 
-## 混合模式
+## Hybrid Mode
 
-某些复杂 Skill 可能需要混合使用两种模式：
+Some complex Skills may need to use both modes in combination:
 
 ```
 phases/
-├── 01-init.md                 # Sequential: 初始化
+├── 01-init.md                 # Sequential: initialization
-├── 02-orchestrator.md         # Autonomous: 核心交互循环
+├── 02-orchestrator.md         # Autonomous: core interaction loop
 │   └── actions/
 │       ├── action-a.md
 │       └── action-b.md
-└── 03-finalize.md             # Sequential: 收尾
+└── 03-finalize.md             # Sequential: finalization
 ```
 
-**适用场景**:
+**Applicable Scenarios**:
-- 初始化和收尾固定，中间交互灵活
+- Initialization and finalization are fixed, middle interaction is flexible
-- 多阶段任务，某阶段需要动态决策
+- Multi-phase tasks where certain phases need dynamic decisions

.claude/skills/skill-generator/specs/reference-docs-spec.md

@@ -0,0 +1,271 @@
+# Reference Documents Generation Specification
+
+> **IMPORTANT**: This specification defines how to organize and present reference documents in generated skills to avoid duplication issues.
+
+## Core Principles
+
+### 1. Phase-Based Organization
+
+Reference documents must be organized by skill execution phases, not as a flat list.
+
+**Wrong Approach** (Flat List):
+```markdown
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| doc1.md | ... |
+| doc2.md | ... |
+| doc3.md | ... |
+```
+
+**Correct Approach** (Phase-Based Navigation):
+```markdown
+## Reference Documents by Phase
+
+### Phase 1: Analysis
+Documents to refer to when executing Phase 1
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| doc1.md | ... | Understand concept x |
+
+### Phase 2: Implementation
+Documents to refer to when executing Phase 2
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| doc2.md | ... | Implement feature y |
+```
+
+### 2. Four Standard Groupings
+
+Reference documents must be divided into the following four groupings:
+
+| Grouping | When to Use | Content |
+|----------|------------|---------|
+| **Phase N: [Name]** | When executing this phase | All documents related to this phase |
+| **Debugging** | When encountering problems | Issue to documentation mapping table |
+| **Reference** | When learning in depth | Templates, original implementations, best practices |
+| (Optional) **Quick Links** | Quick navigation | Most frequently consulted 5-7 documents |
+
+### 3. Each Document Entry Must Include
+
+```
+| [path](path) | Purpose | When to Use |
+```
+
+**When to Use Column Requirements**:
+- Clear explanation of usage scenarios
+- Describe what problem is solved
+- Do not simply say "refer to" or "learn about"
+
+**Good Examples**:
+- "Understand issue data structure"
+- "Learn about the Planning Agent role"
+- "Check if implementation meets quality standards"
+- "Quickly locate the reason for status anomalies"
+
+**Poor Examples**:
+- "Reference document"
+- "More information"
+- "Background knowledge"
+
+### 4. Embedding Document Guidance in Execution Flow
+
+In the "Execution Flow" section, each Phase description should include "Refer to" hints:
+
+```markdown
+### Phase 2: Planning Pipeline
+→ **Refer to**: action-plan.md, subagent-roles.md
+→ Detailed flow description...
+```
+
+### 5. Quick Troubleshooting Reference Table
+
+Should contain common issue to documentation mapping:
+
+```markdown
+### Debugging & Troubleshooting
+
+| Issue | Solution Document |
+|-------|------------------|
+| Phase execution failed | Refer to corresponding phase documentation |
+| Output format incorrect | specs/quality-standards.md |
+| Data validation failed | specs/schema-validation.md |
+```
+
+---
+
+## Generation Rules
+
+### Rule 1: Document Classification Recognition
+
+Automatically generate groupings based on skill phases:
+
+```javascript
+const phaseEmojis = {
+  'discovery': '📋',      // Collection, exploration
+  'generation': '🔧',     // Generation, creation
+  'analysis': '🔍',       // Analysis, review
+  'implementation': '⚙️', // Implementation, execution
+  'validation': '✅',     // Validation, testing
+  'completion': '🏁',     // Completion, wrap-up
+};
+
+// Generate a section for each phase
+phases.forEach((phase, index) => {
+  const emoji = phaseEmojis[phase.type] || '📌';
+  const title = `### ${emoji} Phase ${index + 1}: ${phase.name}`;
+  // List all documents related to this phase
+});
+```
+
+### Rule 2: Document to Phase Mapping
+
+In config, specs and templates should be annotated with their belonging phases:
+
+```json
+{
+  "specs": [
+    {
+      "path": "specs/issue-handling.md",
+      "purpose": "Issue data specification",
+      "phases": ["phase-2", "phase-3"],  // Which phases this spec is related to
+      "context": "Understand issue structure and validation rules"
+    }
+  ]
+}
+```
+
+### Rule 3: Priority and Mandatory Reading
+
+Use visual symbols to distinguish document importance:
+
+```markdown
+| Document | When | Notes |
+|----------|------|-------|
+| spec.md | **Must Read Before Execution** | Mandatory prerequisite |
+| action.md | Refer to during execution | Operation guide |
+| template.md | Reference for learning | Optional in-depth |
+```
+
+### Rule 4: Avoid Duplication
+
+- **Mandatory Prerequisites** section: List mandatory P0 specifications
+- **Reference Documents by Phase** section: List all documents (including mandatory prerequisites)
+- Documents in both sections can overlap, but their purposes differ:
+  - Prerequisites: Emphasize "must read first"
+  - Reference: Provide "complete navigation"
+
+---
+
+## Implementation Example
+
+### Sequential Skill Example
+
+```markdown
+## Mandatory Prerequisites
+
+| Document | Purpose | When |
+|----------|---------|------|
+| [specs/issue-handling.md](specs/issue-handling.md) | Issue data specification | **Must Read Before Execution** |
+| [specs/solution-schema.md](specs/solution-schema.md) | Solution structure | **Must Read Before Execution** |
+
+---
+
+## Reference Documents by Phase
+
+### Phase 1: Issue Collection
+Documents to refer to when executing Phase 1
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/actions/action-list.md](phases/actions/action-list.md) | Issue loading logic | Understand how to collect issues |
+| [specs/issue-handling.md](specs/issue-handling.md) | Issue data specification | Verify issue format **Required Reading** |
+
+### Phase 2: Planning
+Documents to refer to when executing Phase 2
+
+| Document | Purpose | When to Use |
+|----------|---------|-------------|
+| [phases/actions/action-plan.md](phases/actions/action-plan.md) | Planning process | Understand issue to solution transformation |
+| [specs/solution-schema.md](specs/solution-schema.md) | Solution structure | Verify solution JSON format **Required Reading** |
+
+### Debugging & Troubleshooting
+
+| Issue | Solution Document |
+|-------|------------------|
+| Phase 1 failed | [phases/actions/action-list.md](phases/actions/action-list.md) |
+| Planning output incorrect | [phases/actions/action-plan.md](phases/actions/action-plan.md) + [specs/solution-schema.md](specs/solution-schema.md) |
+| Data validation failed | [specs/issue-handling.md](specs/issue-handling.md) |
+
+### Reference & Background
+
+| Document | Purpose | Notes |
+|----------|---------|-------|
+| [../issue-plan.md](../../.codex/prompts/issue-plan.md) | Original implementation | Planning Agent system prompt |
+```
+
+---
+
+## Generation Algorithm
+
+```javascript
+function generateReferenceDocuments(config) {
+  let result = '## Reference Documents by Phase\n\n';
+
+  // Generate a section for each phase
+  const phases = config.phases || config.actions || [];
+
+  phases.forEach((phase, index) => {
+    const phaseNum = index + 1;
+    const emoji = getPhaseEmoji(phase.type);
+    const title = phase.display_name || phase.name;
+
+    result += `### ${emoji} Phase ${phaseNum}: ${title}\n`;
+    result += `Documents to refer to when executing Phase ${phaseNum}\n\n`;
+
+    // Find all documents related to this phase
+    const docs = config.specs.filter(spec =>
+      (spec.phases || []).includes(`phase-${phaseNum}`) ||
+      matchesByName(spec.path, phase.name)
+    );
+
+    if (docs.length > 0) {
+      result += '| Document | Purpose | When to Use |\n';
+      result += '|----------|---------|-------------|\n';
+      docs.forEach(doc => {
+        const required = doc.phases && doc.phases[0] === `phase-${phaseNum}` ? ' **Required Reading**' : '';
+        result += `| [${doc.path}](${doc.path}) | ${doc.purpose} | ${doc.context}${required} |\n`;
+      });
+      result += '\n';
+    }
+  });
+
+  // Troubleshooting section
+  result += '### Debugging & Troubleshooting\n\n';
+  result += generateDebuggingTable(config);
+
+  // In-depth reference learning
+  result += '### Reference & Background\n\n';
+  result += generateReferenceTable(config);
+
+  return result;
+}
+```
+
+---
+
+## Checklist
+
+When generating skill's SKILL.md, the reference documents section should satisfy:
+
+- [ ] Has clear "## Reference Documents by Phase" heading
+- [ ] Each phase has a corresponding section (identified with symbols)
+- [ ] Each document entry includes "When to Use" column
+- [ ] Includes "Debugging & Troubleshooting" section
+- [ ] Includes "Reference & Background" section
+- [ ] Mandatory reading documents are marked with **bold** text
+- [ ] Execution Flow section includes "→ **Refer to**: ..." guidance
+- [ ] Avoid overly long document lists (maximum 5-8 documents per phase)