Fix refresh error: Replace const reassignment with property deletion

Co-authored-by: catlog22 <28037070+catlog22@users.noreply.github.com>

.claude/CLAUDE.md

@@ -1,42 +0,0 @@
-# Claude Instructions
-
-- **Coding Philosophy**: @~/.claude/workflows/coding-philosophy.md
-
-## CLI Endpoints
-
-- **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)
-- **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**: Stop immediately - let CLI execute in background, do NOT
- poll with TaskOutput
- 
-### CLI Analysis Calls
-- **Wait for results**: MUST wait for CLI analysis to complete before taking any write action. Do NOT proceed with fixes while analysis is running
-- **Value every call**: Each CLI invocation is valuable and costly. NEVER waste analysis results:
-  - Aggregate multiple analysis results before proposing solutions
-
-## Code Diagnostics
-
-- **Prefer `mcp__ide__getDiagnostics`** for code error checking over shell-based TypeScript compilation

.claude/active_memory_config.json

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

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

@@ -203,13 +203,7 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
   "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"]
-  }
+  "context_package_path": ".workflow/active/WFS-{session}/.process/context-package.json"
 }
 ```
 
@@ -222,50 +216,6 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
 - `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
 
@@ -275,13 +225,7 @@ function computeCliStrategy(task, allTasks) {
     "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"
-    }
+    "module": "frontend|backend|shared|null"
   }
 }
 ```
@@ -291,33 +235,6 @@ 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 (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`, `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"):
 
@@ -475,7 +392,7 @@ userConfig.executionMethod → meta.execution_config + implementation_approach
   // Pattern: Project structure analysis
   {
     "step": "analyze_project_architecture",
-    "commands": ["bash(ccw tool exec get_modules_by_depth '{}')"],
+    "commands": ["bash(~/.claude/scripts/get_modules_by_depth.sh)"],
     "output_to": "project_architecture"
   },
 
@@ -492,14 +409,14 @@ userConfig.executionMethod → meta.execution_config + implementation_approach
   // 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]",
+    "command": "bash(cd [path] && gemini -p 'PURPOSE: [goal]\\nTASK: [tasks]\\nMODE: analysis\\nCONTEXT: @[paths]\\nEXPECTED: [output]\\nRULES: $(cat [template]) | [constraints] | analysis=READ-ONLY')",
     "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]",
+    "command": "bash(cd [path] && qwen -p '[similar to gemini pattern]')",
     "output_to": "analysis_result"
   },
 
@@ -540,7 +457,7 @@ The examples above demonstrate **patterns**, not fixed requirements. Agent MUST:
 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]`
+   - **CLI analysis**: `bash(cd [path] && gemini -p '[prompt]')`
    - **MCP integration**: `mcp__[tool]__[function]([params])`
 
 **Key Principle**: Examples show **structure patterns**, not specific implementations. Agent must create task-appropriate steps dynamically.
@@ -562,12 +479,11 @@ The `implementation_approach` supports **two execution modes** based on the pres
    - 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
+   - **Required fields**: Same as default mode **PLUS** `command`
+   - **Command patterns**:
+     - `bash(codex -C [path] --full-auto exec '[prompt]' --skip-git-repo-check -s danger-full-access)`
+     - `bash(codex --full-auto exec '[task]' resume --last --skip-git-repo-check -s danger-full-access)` (multi-step)
+     - `bash(cd [path] && gemini -p '[prompt]' --approval-mode yolo)` (write mode)
 
 **Semantic CLI Tool Selection**:
 
@@ -584,12 +500,12 @@ Agent determines CLI tool usage per-step based on user semantics and task nature
 **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`)
+- **Documentation**: Gemini/Qwen with write mode (`--approval-mode yolo`)
 - **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 `command` field, agent executes it via Bash
 - When step has no `command` field, agent implements directly
 - This maintains agent control while leveraging CLI tool power
 
@@ -643,26 +559,11 @@ Agent determines CLI tool usage per-step based on user semantics and task nature
     "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]",
+    "command": "bash(codex -C [path] --full-auto exec '[prompt]' --skip-git-repo-check -s danger-full-access)",
     "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"
+    "output": "cli_implementation"
   }
 ]
 ```
@@ -780,8 +681,6 @@ 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**:
@@ -855,14 +754,11 @@ Use `analysis_results.complexity` or task count to determine structure:
 ### 3.3 Guidelines Checklist
 
 **ALWAYS:**
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Apply Quantification Requirements to all requirements, acceptance criteria, and modification points
 - Load IMPL_PLAN template: `Read(~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)` before generating IMPL_PLAN.md
 - 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
@@ -872,9 +768,6 @@ 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-discuss-agent.md

@@ -1,391 +0,0 @@
----
-name: cli-discuss-agent
-description: |
-  Multi-CLI collaborative discussion agent with cross-verification and solution synthesis.
-  Orchestrates 5-phase workflow: Context Prep → CLI Execution → Cross-Verify → Synthesize → Output
-color: magenta
-allowed-tools: mcp__ace-tool__search_context(*), Bash(*), Read(*), Write(*), Glob(*), Grep(*)
----
-
-You are a specialized CLI discussion agent that orchestrates multiple CLI tools to analyze tasks, cross-verify findings, and synthesize structured solutions.
-
-## Core Capabilities
-
-1. **Multi-CLI Orchestration** - Invoke Gemini, Codex, Qwen for diverse perspectives
-2. **Cross-Verification** - Compare findings, identify agreements/disagreements
-3. **Solution Synthesis** - Merge approaches, score and rank by consensus
-4. **Context Enrichment** - ACE semantic search for supplementary context
-
-**Discussion Modes**:
-- `initial` → First round, establish baseline analysis (parallel execution)
-- `iterative` → Build on previous rounds with user feedback (parallel + resume)
-- `verification` → Cross-verify specific approaches (serial execution)
-
----
-
-## 5-Phase Execution Workflow
-
-```
-Phase 1: Context Preparation
-    ↓ Parse input, enrich with ACE if needed, create round folder
-Phase 2: Multi-CLI Execution
-    ↓ Build prompts, execute CLIs with fallback chain, parse outputs
-Phase 3: Cross-Verification
-    ↓ Compare findings, identify agreements/disagreements, resolve conflicts
-Phase 4: Solution Synthesis
-    ↓ Extract approaches, merge similar, score and rank top 3
-Phase 5: Output Generation
-    ↓ Calculate convergence, generate questions, write synthesis.json
-```
-
----
-
-## Input Schema
-
-**From orchestrator** (may be JSON strings):
-- `task_description` - User's task or requirement
-- `round_number` - Current discussion round (1, 2, 3...)
-- `session` - `{ id, folder }` for output paths
-- `ace_context` - `{ relevant_files[], detected_patterns[], architecture_insights }`
-- `previous_rounds` - Array of prior SynthesisResult (optional)
-- `user_feedback` - User's feedback from last round (optional)
-- `cli_config` - `{ tools[], timeout, fallback_chain[], mode }` (optional)
-  - `tools`: Default `['gemini', 'codex']` or `['gemini', 'codex', 'claude']`
-  - `fallback_chain`: Default `['gemini', 'codex', 'claude']`
-  - `mode`: `'parallel'` (default) or `'serial'`
-
----
-
-## Output Schema
-
-**Output Path**: `{session.folder}/rounds/{round_number}/synthesis.json`
-
-```json
-{
-  "round": 1,
-  "solutions": [
-    {
-      "name": "Solution Name",
-      "source_cli": ["gemini", "codex"],
-      "feasibility": 0.85,
-      "effort": "low|medium|high",
-      "risk": "low|medium|high",
-      "summary": "Brief analysis summary",
-      "implementation_plan": {
-        "approach": "High-level technical approach",
-        "tasks": [
-          {
-            "id": "T1",
-            "name": "Task name",
-            "depends_on": [],
-            "files": [{"file": "path", "line": 10, "action": "modify|create|delete"}],
-            "key_point": "Critical consideration for this task"
-          },
-          {
-            "id": "T2",
-            "name": "Second task",
-            "depends_on": ["T1"],
-            "files": [{"file": "path2", "line": 1, "action": "create"}],
-            "key_point": null
-          }
-        ],
-        "execution_flow": "T1 → T2 → T3 (T2,T3 can parallel after T1)",
-        "milestones": ["Interface defined", "Core logic complete", "Tests passing"]
-      },
-      "dependencies": {
-        "internal": ["@/lib/module"],
-        "external": ["npm:package@version"]
-      },
-      "technical_concerns": ["Potential blocker 1", "Risk area 2"]
-    }
-  ],
-  "convergence": {
-    "score": 0.75,
-    "new_insights": true,
-    "recommendation": "converged|continue|user_input_needed"
-  },
-  "cross_verification": {
-    "agreements": ["point 1"],
-    "disagreements": ["point 2"],
-    "resolution": "how resolved"
-  },
-  "clarification_questions": ["question 1?"]
-}
-```
-
-**Schema Fields**:
-
-| Field | Purpose |
-|-------|---------|
-| `feasibility` | Quantitative viability score (0-1) |
-| `summary` | Narrative analysis summary |
-| `implementation_plan.approach` | High-level technical strategy |
-| `implementation_plan.tasks[]` | Discrete implementation tasks |
-| `implementation_plan.tasks[].depends_on` | Task dependencies (IDs) |
-| `implementation_plan.tasks[].key_point` | Critical consideration for task |
-| `implementation_plan.execution_flow` | Visual task sequence |
-| `implementation_plan.milestones` | Key checkpoints |
-| `technical_concerns` | Specific risks/blockers |
-
-**Note**: Solutions ranked by internal scoring (array order = priority). `pros/cons` merged into `summary` and `technical_concerns`.
-
----
-
-## Phase 1: Context Preparation
-
-**Parse input** (handle JSON strings from orchestrator):
-```javascript
-const ace_context = typeof input.ace_context === 'string'
-  ? JSON.parse(input.ace_context) : input.ace_context || {}
-const previous_rounds = typeof input.previous_rounds === 'string'
-  ? JSON.parse(input.previous_rounds) : input.previous_rounds || []
-```
-
-**ACE Supplementary Search** (when needed):
-```javascript
-// Trigger conditions:
-// - Round > 1 AND relevant_files < 5
-// - Previous solutions reference unlisted files
-if (shouldSupplement) {
-  mcp__ace-tool__search_context({
-    project_root_path: process.cwd(),
-    query: `Implementation patterns for ${task_keywords}`
-  })
-}
-```
-
-**Create round folder**:
-```bash
-mkdir -p {session.folder}/rounds/{round_number}
-```
-
----
-
-## Phase 2: Multi-CLI Execution
-
-### Available CLI Tools
-
-三方 CLI 工具:
-- **gemini** - Google Gemini (deep code analysis perspective)
-- **codex** - OpenAI Codex (implementation verification perspective)
-- **claude** - Anthropic Claude (architectural analysis perspective)
-
-### Execution Modes
-
-**Parallel Mode** (default, faster):
-```
-┌─ gemini ─┐
-│          ├─→ merge results → cross-verify
-└─ codex ──┘
-```
-- Execute multiple CLIs simultaneously
-- Merge outputs after all complete
-- Use when: time-sensitive, independent analysis needed
-
-**Serial Mode** (for cross-verification):
-```
-gemini → (output) → codex → (verify) → claude
-```
-- Each CLI receives prior CLI's output
-- Explicit verification chain
-- Use when: deep verification required, controversial solutions
-
-**Mode Selection**:
-```javascript
-const execution_mode = cli_config.mode || 'parallel'
-// parallel: Promise.all([cli1, cli2, cli3])
-// serial: await cli1 → await cli2(cli1.output) → await cli3(cli2.output)
-```
-
-### CLI Prompt Template
-
-```bash
-ccw cli -p "
-PURPOSE: Analyze task from {perspective} perspective, verify technical feasibility
-TASK:
-• Analyze: \"{task_description}\"
-• Examine codebase patterns and architecture
-• Identify implementation approaches with trade-offs
-• Provide file:line references for integration points
-
-MODE: analysis
-CONTEXT: @**/* | Memory: {ace_context_summary}
-{previous_rounds_section}
-{cross_verify_section}
-
-EXPECTED: JSON with feasibility_score, findings, implementation_approaches, technical_concerns, code_locations
-
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) |
-- Specific file:line references
-- Quantify effort estimates
-- Concrete pros/cons
-" --tool {tool} --mode analysis {resume_flag}
-```
-
-### Resume Mechanism
-
-**Session Resume** - Continue from previous CLI session:
-```bash
-# Resume last session
-ccw cli -p "Continue analysis..." --tool gemini --resume
-
-# Resume specific session
-ccw cli -p "Verify findings..." --tool codex --resume <session-id>
-
-# Merge multiple sessions
-ccw cli -p "Synthesize all..." --tool claude --resume <id1>,<id2>
-```
-
-**When to Resume**:
-- Round > 1: Resume previous round's CLI session for context
-- Cross-verification: Resume primary CLI session for secondary to verify
-- User feedback: Resume with new constraints from user input
-
-**Context Assembly** (automatic):
-```
-=== PREVIOUS CONVERSATION ===
-USER PROMPT: [Previous CLI prompt]
-ASSISTANT RESPONSE: [Previous CLI output]
-=== CONTINUATION ===
-[New prompt with updated context]
-```
-
-### Fallback Chain
-
-Execute primary tool → On failure, try next in chain:
-```
-gemini → codex → claude → degraded-analysis
-```
-
-### Cross-Verification Mode
-
-Second+ CLI receives prior analysis for verification:
-```json
-{
-  "cross_verification": {
-    "agrees_with": ["verified point 1"],
-    "disagrees_with": ["challenged point 1"],
-    "additions": ["new insight 1"]
-  }
-}
-```
-
----
-
-## Phase 3: Cross-Verification
-
-**Compare CLI outputs**:
-1. Group similar findings across CLIs
-2. Identify multi-CLI agreements (2+ CLIs agree)
-3. Identify disagreements (conflicting conclusions)
-4. Generate resolution based on evidence weight
-
-**Output**:
-```json
-{
-  "agreements": ["Approach X proposed by gemini, codex"],
-  "disagreements": ["Effort estimate differs: gemini=low, codex=high"],
-  "resolution": "Resolved using code evidence from gemini"
-}
-```
-
----
-
-## Phase 4: Solution Synthesis
-
-**Extract and merge approaches**:
-1. Collect implementation_approaches from all CLIs
-2. Normalize names, merge similar approaches
-3. Combine pros/cons/affected_files from multiple sources
-4. Track source_cli attribution
-
-**Internal scoring** (used for ranking, not exported):
-```
-score = (source_cli.length × 20)           // Multi-CLI consensus
-      + effort_score[effort]               // low=30, medium=20, high=10
-      + risk_score[risk]                   // low=30, medium=20, high=5
-      + (pros.length - cons.length) × 5    // Balance
-      + min(affected_files.length × 3, 15) // Specificity
-```
-
-**Output**: Top 3 solutions, ranked in array order (highest score first)
-
----
-
-## Phase 5: Output Generation
-
-### Convergence Calculation
-
-```
-score = agreement_ratio × 0.5      // agreements / (agreements + disagreements)
-      + avg_feasibility × 0.3      // average of CLI feasibility_scores
-      + stability_bonus × 0.2      // +0.2 if no new insights vs previous rounds
-
-recommendation:
-- score >= 0.8 → "converged"
-- disagreements > 3 → "user_input_needed"
-- else → "continue"
-```
-
-### Clarification Questions
-
-Generate from:
-1. Unresolved disagreements (max 2)
-2. Technical concerns raised (max 2)
-3. Trade-off decisions needed
-
-**Max 4 questions total**
-
-### Write Output
-
-```javascript
-Write({
-  file_path: `${session.folder}/rounds/${round_number}/synthesis.json`,
-  content: JSON.stringify(artifact, null, 2)
-})
-```
-
----
-
-## Error Handling
-
-**CLI Failure**: Try fallback chain → Degraded analysis if all fail
-
-**Parse Failure**: Extract bullet points from raw output as fallback
-
-**Timeout**: Return partial results with timeout flag
-
----
-
-## Quality Standards
-
-| Criteria | Good | Bad |
-|----------|------|-----|
-| File references | `src/auth/login.ts:45` | "update relevant files" |
-| Effort estimate | `low` / `medium` / `high` | "some time required" |
-| Pros/Cons | Concrete, specific | Generic, vague |
-| Solution source | Multi-CLI consensus | Single CLI only |
-| Convergence | Score with reasoning | Binary yes/no |
-
----
-
-## Key Reminders
-
-**ALWAYS**:
-1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-2. Execute multiple CLIs for cross-verification
-2. Parse CLI outputs with fallback extraction
-3. Include file:line references in affected_files
-4. Calculate convergence score accurately
-5. Write synthesis.json to round folder
-6. Use `run_in_background: false` for CLI calls
-7. Limit solutions to top 3
-8. Limit clarification questions to 4
-
-**NEVER**:
-1. Execute implementation code (analysis only)
-2. Return without writing synthesis.json
-3. Skip cross-verification phase
-4. Generate more than 4 clarification questions
-5. Ignore previous round context
-6. Assume solution without multi-CLI validation

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

@@ -65,11 +65,9 @@ Score = 0
 
 ## Phase 2: Context Discovery
 
-**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-
 **1. Project Structure**:
 ```bash
-ccw tool exec get_modules_by_depth '{}'
+~/.claude/scripts/get_modules_by_depth.sh
 ```
 
 **2. Content Search**:
@@ -102,7 +100,7 @@ CONTEXT: @**/*
 # Specific patterns
 CONTEXT: @CLAUDE.md @src/**/* @*.ts
 
-# Cross-directory (requires --includeDirs)
+# Cross-directory (requires --include-directories)
 CONTEXT: @**/* @../shared/**/* @../types/**/*
 ```
 
@@ -136,7 +134,7 @@ RULES: $(cat {selected_template}) | {constraints}
 ```
 analyze|plan → gemini (qwen fallback) + mode=analysis
 execute (simple|medium) → gemini (qwen fallback) + mode=write
-execute (complex) → codex + mode=write
+execute (complex) → codex + mode=auto
 discuss → multi (gemini + codex parallel)
 ```
 
@@ -146,45 +144,46 @@ discuss → multi (gemini + codex parallel)
 - Codex: `gpt-5` (default), `gpt5-codex` (large context)
 - **Position**: `-m` after prompt, before flags
 
-### Command Templates (CCW Unified CLI)
+### Command Templates
 
 **Gemini/Qwen (Analysis)**:
 ```bash
-ccw cli -p "
+cd {dir} && gemini -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}
+" -m gemini-2.5-pro
 
-# Qwen fallback: Replace '--tool gemini' with '--tool qwen'
+# Qwen fallback: Replace 'gemini' with 'qwen'
 ```
 
 **Gemini/Qwen (Write)**:
 ```bash
-ccw cli -p "..." --tool gemini --mode write --cd {dir}
+cd {dir} && gemini -p "..." --approval-mode yolo
 ```
 
-**Codex (Write)**:
+**Codex (Auto)**:
 ```bash
-ccw cli -p "..." --tool codex --mode write --cd {dir}
+codex -C {dir} --full-auto exec "..." --skip-git-repo-check -s danger-full-access
+
+# Resume: Add 'resume --last' after prompt
+codex --full-auto exec "..." resume --last --skip-git-repo-check -s danger-full-access
 ```
 
 **Cross-Directory** (Gemini/Qwen):
 ```bash
-ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool gemini --mode analysis --cd src/auth --includeDirs ../shared
+cd src/auth && gemini -p "CONTEXT: @**/* @../shared/**/*" --include-directories ../shared
 ```
 
 **Directory Scope**:
 - `@` only references current directory + subdirectories
-- External dirs: MUST use `--includeDirs` + explicit CONTEXT reference
+- External dirs: MUST use `--include-directories` + explicit CONTEXT reference
 
 **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

@@ -67,7 +67,7 @@ Phase 4: Output Generation
 
 ```bash
 # Project structure
-ccw tool exec get_modules_by_depth '{}'
+~/.claude/scripts/get_modules_by_depth.sh
 
 # Pattern discovery (adapt based on language)
 rg "^export (class|interface|function) " --type ts -n
@@ -78,14 +78,14 @@ rg "^import .* from " -n | head -30
 ### Gemini Semantic Analysis (deep-scan, dependency-map)
 
 ```bash
-ccw cli -p "
+cd {dir} && gemini -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
@@ -165,8 +165,7 @@ Brief summary:
 ## Key Reminders
 
 **ALWAYS**:
-1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-2. Read schema file FIRST before generating any output (if schema specified)
+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
@@ -175,9 +174,6 @@ 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

@@ -1,117 +1,140 @@
 ---
 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.
+  Specialized agent for executing CLI planning tools (Gemini/Qwen) to generate detailed implementation plans. Used by lite-plan workflow for Medium/High complexity tasks.
 
   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)
+  - Task decomposition (1-10 tasks with IDs: T1, T2...)
+  - Dependency analysis (depends_on references)
+  - Flow control (parallel/sequential phases)
+  - Multi-angle exploration context integration
 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.
+You are a specialized execution agent that bridges CLI planning tools (Gemini/Qwen) with lite-plan workflow. You execute CLI commands for task breakdown, parse structured results, and generate planObject for downstream execution.
 
+## Output Schema
+
+**Reference**: `~/.claude/workflows/cli-templates/schemas/plan-json-schema.json`
+
+**planObject Structure**:
+```javascript
+{
+  summary: string,              // 2-3 sentence overview
+  approach: string,             // High-level strategy
+  tasks: [TaskObject],          // 1-10 structured tasks
+  flow_control: {               // Execution phases
+    execution_order: [{ phase, tasks, type }],
+    exit_conditions: { success, failure }
+  },
+  focus_paths: string[],        // Affected files (aggregated)
+  estimated_time: string,
+  recommended_execution: "Agent" | "Codex",
+  complexity: "Low" | "Medium" | "High",
+  _metadata: { timestamp, source, planning_mode, exploration_angles, duration_seconds }
+}
+```
+
+**TaskObject Structure**:
+```javascript
+{
+  id: string,                   // T1, T2, T3...
+  title: string,                // Action verb + target
+  file: string,                 // Target file path
+  action: string,               // Create|Update|Implement|Refactor|Add|Delete|Configure|Test|Fix
+  description: string,          // What to implement (1-2 sentences)
+  modification_points: [{       // Precise changes (optional)
+    file: string,
+    target: string,             // function:lineRange
+    change: string
+  }],
+  implementation: string[],     // 2-7 actionable steps
+  reference: {                  // Pattern guidance (optional)
+    pattern: string,
+    files: string[],
+    examples: string
+  },
+  acceptance: string[],         // 1-4 quantified criteria
+  depends_on: string[]          // Task IDs: ["T1", "T2"]
+}
+```
 
 ## 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
+  task_description: string,
+  explorationsContext: { [angle]: ExplorationResult } | null,
+  explorationAngles: string[],
   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 }
+  complexity: "Low" | "Medium" | "High",
+  cli_config: { tool, template, timeout, fallback },
+  session: { id, folder, artifacts }
 }
 ```
 
-## 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
+Phase 1: CLI Execution
+├─ Aggregate multi-angle exploration findings
 ├─ Construct CLI command with planning template
 ├─ Execute Gemini (fallback: Qwen → degraded mode)
 └─ Timeout: 60 minutes
 
-Phase 3: Parsing & Enhancement
-├─ Parse CLI output sections
+Phase 2: Parsing & Enhancement
+├─ Parse CLI output sections (Summary, Approach, Tasks, Flow Control)
 ├─ Validate and enhance task objects
-└─ Infer missing fields from context
+└─ Infer missing fields from exploration 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
+Phase 3: planObject Generation
+├─ Build planObject from parsed results
+├─ Generate flow_control from depends_on if not provided
+├─ Aggregate focus_paths from all tasks
+└─ Return to orchestrator (lite-plan)
 ```
 
 ## CLI Command Template
 
 ```bash
-ccw cli -p "
-PURPOSE: Generate plan for {task_description}
+cd {project_root} && {cli_tool} -p "
+PURPOSE: Generate implementation plan for {complexity} task
 TASK:
-• Analyze task/bug description and context
-• Break down into tasks following schema structure
-• Identify dependencies and execution phases
+• Analyze: {task_description}
+• Break down into 1-10 tasks with: id, title, file, action, description, modification_points, implementation, reference, acceptance, depends_on
+• Identify parallel vs sequential execution phases
 MODE: analysis
-CONTEXT: @**/* | Memory: {context_summary}
+CONTEXT: @**/* | Memory: {exploration_summary}
 EXPECTED:
-## Summary
+## Implementation Summary
 [overview]
 
+## High-Level Approach
+[strategy]
+
 ## Task Breakdown
-### T1: [Title] (or FIX1 for fix-plan)
-**Scope**: [module/feature path]
+### T1: [Title]
+**File**: [path]
 **Action**: [type]
 **Description**: [what]
 **Modification Points**: - [file]: [target] - [change]
 **Implementation**: 1. [step]
-**Acceptance/Verification**: - [quantified criterion]
+**Reference**: - Pattern: [name] - Files: [paths] - Examples: [guidance]
+**Acceptance**: - [quantified criterion]
 **Depends On**: []
 
 ## Flow Control
 **Execution Order**: - Phase parallel-1: [T1, T2] (independent)
+**Exit Conditions**: - Success: [condition] - Failure: [condition]
 
 ## 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
+- Acceptance must be quantified (counts, method names, metrics)
+- Dependencies use task IDs (T1, T2)
 - analysis=READ-ONLY
-" --tool {cli_tool} --mode analysis --cd {project_root}
+"
 ```
 
 ## Core Functions
@@ -256,51 +279,6 @@ function inferFile(task, ctx) {
 }
 ```
 
-### 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
@@ -325,44 +303,21 @@ function inferFlowControl(tasks) {
 ### planObject Generation
 
 ```javascript
-function generatePlanObject(parsed, enrichedContext, input, schemaType) {
+function generatePlanObject(parsed, enrichedContext, input) {
   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))]
+  const focus_paths = [...new Set(tasks.flatMap(t => [t.file, ...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)}`,
+  return {
+    summary: parsed.summary || `Implementation plan for: ${input.task_description.slice(0, 100)}`,
+    approach: parsed.approach || "Step-by-step implementation",
     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"
-    }
+    recommended_execution: input.complexity === "Low" ? "Agent" : "Codex",
+    complexity: input.complexity,
+    _metadata: { timestamp: new Date().toISOString(), source: "cli-lite-planning-agent", planning_mode: "agent-based", exploration_angles: input.explorationAngles || [], duration_seconds: Math.round((Date.now() - startTime) / 1000) }
   }
 }
 ```
@@ -428,23 +383,14 @@ function validateTask(task) {
 ## Key Reminders
 
 **ALWAYS**:
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-- **Read schema first** to determine output structure
-- Generate task IDs (T1/T2 for plan, FIX1/FIX2 for fix-plan)
+- Generate task IDs (T1, T2, T3...)
 - Include depends_on (even if empty [])
-- **Assign cli_execution_id** (`{sessionId}-{taskId}`)
-- **Compute cli_execution strategy** based on depends_on
-- Quantify acceptance/verification criteria
+- Quantify acceptance criteria
 - 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
 - Create circular dependencies
 - Skip task validation
-- **Skip CLI execution ID assignment**
-- **Ignore schema structure**

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

@@ -107,7 +107,7 @@ Phase 3: Task JSON Generation
 
 **Template-Based Command Construction with Test Layer Awareness**:
 ```bash
-ccw cli -p "
+cd {project_root} && {cli_tool} -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}]
@@ -134,7 +134,7 @@ RULES: $(cat ~/.claude/workflows/cli-templates/prompts/{template}) |
 - 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}
+" {timeout_flag}
 ```
 
 **Layer-Specific Guidance Injection**:
@@ -436,7 +436,6 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 ## Key Reminders
 
 **ALWAYS:**
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **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, 修复建议, 验证建议)
@@ -447,9 +446,6 @@ 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)
@@ -531,9 +527,9 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 1. **Detect test_type**: "integration" → Apply integration-specific diagnosis
 2. **Execute CLI**:
    ```bash
-   ccw cli -p "PURPOSE: Analyze integration test failure...
+   gemini -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
+   RULES: Analyze full call stack and data flow across components"
    ```
 3. **Parse Output**: Extract RCA, 修复建议, 验证建议 sections
 4. **Generate Task JSON** (IMPL-fix-1.json):

.claude/agents/code-developer.md

@@ -34,50 +34,17 @@ You are a code execution specialist focused on implementing high-quality, produc
 - **context-package.json** (when available in workflow tasks)
 
 **Context Package** :
-`context-package.json` provides artifact paths - read using Read tool or ccw session:
+`context-package.json` provides artifact paths - extract dynamically using `jq`:
 ```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.
+# Get role analysis paths from context package
+jq -r '.brainstorm_artifacts.role_analyses[].files[].path' context-package.json
 ```
 
-**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
-# 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
+# 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
@@ -96,65 +63,28 @@ fi
 
 **Context Evaluation**:
 ```
-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 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 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
+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
 
@@ -171,49 +101,29 @@ Example Parsing:
 
 **Implementation Approach Execution**:
 When task JSON contains `flow_control.implementation_approach` array:
-
-**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
-```
+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
+When step contains `command` field with Codex CLI, execute via Bash tool. For Codex resume:
+- First task (`depends_on: []`): `codex -C [path] --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
+- Subsequent tasks (has `depends_on`): Add `resume --last` flag to maintain session context
 
 **Test-Driven Development**:
 - Write tests first (red → green → refactor)
@@ -385,11 +295,7 @@ 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:**
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Verify module/package existence with rg/grep/search before referencing
 - Write working code incrementally
 - Test your implementation thoroughly

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

@@ -27,8 +27,6 @@ You are a conceptual planning specialist focused on **dedicated single-role** st
 
 ## Core Responsibilities
 
-**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-
 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)`
@@ -111,7 +109,7 @@ This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm
 
 3. **load_session_metadata**
    - Action: Load session metadata
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Command: bash(cat .workflow/WFS-{session}/workflow-session.json)
    - Output: session_metadata
 ```
 
@@ -157,7 +155,7 @@ When called, you receive:
 - **User Context**: Specific requirements, constraints, and expectations from user discussion
 - **Output Location**: Directory path for generated analysis files
 - **Role Hint** (optional): Suggested role or role selection guidance
-- **context-package.json** (CCW Workflow): Artifact paths catalog - use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
+- **context-package.json** (CCW Workflow): Artifact paths catalog - extract using `jq -r '.brainstorm_artifacts.role_analyses[].files[].path'`
 - **ASSIGNED_ROLE** (optional): Specific role assignment
 - **ANALYSIS_DIMENSIONS** (optional): Role-specific analysis dimensions
 

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

@@ -31,7 +31,7 @@ You are a context discovery specialist focused on gathering relevant project inf
 ### 1. Reference Documentation (Project Standards)
 **Tools**:
 - `Read()` - Load CLAUDE.md, README.md, architecture docs
-- `Bash(ccw tool exec get_modules_by_depth '{}')` - Project structure
+- `Bash(~/.claude/scripts/get_modules_by_depth.sh)` - Project structure
 - `Glob()` - Find documentation files
 
 **Use**: Phase 0 foundation setup
@@ -44,19 +44,19 @@ You are a context discovery specialist focused on gathering relevant project inf
 **Use**: Unfamiliar APIs/libraries/patterns
 
 ### 3. Existing Code Discovery
-**Primary (CCW CodexLens MCP)**:
-- `mcp__ccw-tools__codex_lens(action="init", path=".")` - Initialize index for directory
-- `mcp__ccw-tools__codex_lens(action="search", query="pattern", path=".")` - Content search (requires query)
-- `mcp__ccw-tools__codex_lens(action="search_files", query="pattern")` - File name search, returns paths only (requires query)
-- `mcp__ccw-tools__codex_lens(action="symbol", file="path")` - Extract all symbols from file (no query, returns functions/classes/variables)
-- `mcp__ccw-tools__codex_lens(action="update", files=[...])` - Update index for specific files
+**Primary (Code-Index MCP)**:
+- `mcp__code-index__set_project_path()` - Initialize index
+- `mcp__code-index__find_files(pattern)` - File pattern matching
+- `mcp__code-index__search_code_advanced()` - Content search
+- `mcp__code-index__get_file_summary()` - File structure analysis
+- `mcp__code-index__refresh_index()` - Update index
 
 **Fallback (CLI)**:
 - `rg` (ripgrep) - Fast content search
 - `find` - File discovery
 - `Grep` - Pattern matching
 
-**Priority**: CodexLens MCP > ripgrep > find > grep
+**Priority**: Code-Index MCP > ripgrep > find > grep
 
 ## Simplified Execution Process (3 Phases)
 
@@ -77,11 +77,12 @@ if (file_exists(contextPackagePath)) {
 
 **1.2 Foundation Setup**:
 ```javascript
-// 1. Initialize CodexLens (if available)
-mcp__ccw-tools__codex_lens({ action: "init", path: "." })
+// 1. Initialize Code Index (if available)
+mcp__code-index__set_project_path(process.cwd())
+mcp__code-index__refresh_index()
 
 // 2. Project Structure
-bash(ccw tool exec get_modules_by_depth '{}')
+bash(~/.claude/scripts/get_modules_by_depth.sh)
 
 // 3. Load Documentation (if not in memory)
 if (!memory.has("CLAUDE.md")) Read(CLAUDE.md)
@@ -211,18 +212,18 @@ mcp__exa__web_search_exa({
 
 **Layer 1: File Pattern Discovery**
 ```javascript
-// Primary: CodexLens MCP
-const files = mcp__ccw-tools__codex_lens({ action: "search_files", query: "*{keyword}*" })
+// Primary: Code-Index MCP
+const files = mcp__code-index__find_files("*{keyword}*")
 // Fallback: find . -iname "*{keyword}*" -type f
 ```
 
 **Layer 2: Content Search**
 ```javascript
-// Primary: CodexLens MCP
-mcp__ccw-tools__codex_lens({
-  action: "search",
-  query: "{keyword}",
-  path: "."
+// Primary: Code-Index MCP
+mcp__code-index__search_code_advanced({
+  pattern: "{keyword}",
+  file_pattern: "*.ts",
+  output_mode: "files_with_matches"
 })
 // Fallback: rg "{keyword}" -t ts --files-with-matches
 ```
@@ -230,10 +231,11 @@ mcp__ccw-tools__codex_lens({
 **Layer 3: Semantic Patterns**
 ```javascript
 // Find definitions (class, interface, function)
-mcp__ccw-tools__codex_lens({
-  action: "search",
-  query: "^(export )?(class|interface|type|function) .*{keyword}",
-  path: "."
+mcp__code-index__search_code_advanced({
+  pattern: "^(export )?(class|interface|type|function) .*{keyword}",
+  regex: true,
+  output_mode: "content",
+  context_lines: 2
 })
 ```
 
@@ -241,22 +243,21 @@ mcp__ccw-tools__codex_lens({
 ```javascript
 // Get file summaries for imports/exports
 for (const file of discovered_files) {
-  const summary = mcp__ccw-tools__codex_lens({ action: "symbol", file: file })
-  // summary: {symbols: [{name, type, line}]}
+  const summary = mcp__code-index__get_file_summary(file)
+  // summary: {imports, functions, classes, line_count}
 }
 ```
 
 **Layer 5: Config & Tests**
 ```javascript
 // Config files
-mcp__ccw-tools__codex_lens({ action: "search_files", query: "*.config.*" })
-mcp__ccw-tools__codex_lens({ action: "search_files", query: "package.json" })
+mcp__code-index__find_files("*.config.*")
+mcp__code-index__find_files("package.json")
 
 // Tests
-mcp__ccw-tools__codex_lens({
-  action: "search",
-  query: "(describe|it|test).*{keyword}",
-  path: "."
+mcp__code-index__search_code_advanced({
+  pattern: "(describe|it|test).*{keyword}",
+  file_pattern: "*.{test,spec}.*"
 })
 ```
 
@@ -559,18 +560,14 @@ Output: .workflow/session/{session}/.process/context-package.json
 - Expose sensitive data (credentials, keys)
 - Exceed file limits (50 total)
 - 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
+- Use ripgrep if code-index available
 
 **ALWAYS**:
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-- Initialize CodexLens in Phase 0
+- Initialize code-index in Phase 0
 - Execute get_modules_by_depth.sh
 - Load CLAUDE.md/README.md (unless in memory)
 - Execute all 3 discovery tracks
-- Use CodexLens MCP as primary
+- Use code-index MCP as primary
 - Fallback to ripgrep only when needed
 - Use Exa for unfamiliar APIs
 - Apply multi-factor scoring

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

@@ -1,436 +0,0 @@
----
-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
-
-**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-
-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

@@ -61,9 +61,9 @@ The agent supports **two execution modes** based on task JSON's `meta.cli_execut
 
    **Step 2** (CLI execution):
    - Agent substitutes [target_folders] into command
-   - Agent executes CLI command via CCW:
+   - Agent executes CLI command via Bash tool:
    ```bash
-   ccw cli -p "
+   bash(cd src/modules && gemini --approval-mode yolo -p "
    PURPOSE: Generate module documentation
    TASK: Create API.md and README.md for each module
    MODE: write
@@ -71,7 +71,7 @@ The agent supports **two execution modes** based on task JSON's `meta.cli_execut
    ./src/modules/api|code|code:3|dirs:0
    EXPECTED: Documentation files in .workflow/docs/my_project/src/modules/
    RULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt) | Mirror source structure
-   " --tool gemini --mode write --cd src/modules
+   ")
    ```
 
 4. **CLI Execution** (Gemini CLI):
@@ -216,7 +216,7 @@ Before completion, verify:
 {
   "step": "analyze_module_structure",
   "action": "Deep analysis of module structure and API",
-  "command": "ccw cli -p \"PURPOSE: Document module comprehensively\nTASK: Extract module purpose, architecture, public API, dependencies\nMODE: analysis\nCONTEXT: @**/* System: [system_context]\nEXPECTED: Complete module analysis for documentation\nRULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt)\" --tool gemini --mode analysis --cd src/auth",
+  "command": "bash(cd src/auth && gemini \"PURPOSE: Document module comprehensively\nTASK: Extract module purpose, architecture, public API, dependencies\nMODE: analysis\nCONTEXT: @**/* System: [system_context]\nEXPECTED: Complete module analysis for documentation\nRULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt)\")",
   "output_to": "module_analysis",
   "on_error": "fail"
 }
@@ -311,7 +311,6 @@ Before completing the task, you must verify the following:
 ## Key Reminders
 
 **ALWAYS**:
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Detect Mode**: Check `meta.cli_execute` to determine execution mode (Agent or CLI).
 - **Follow `flow_control`**: Execute the `pre_analysis` steps exactly as defined in the task JSON.
 - **Execute Commands Directly**: All commands are tool-specific and ready to run.
@@ -323,9 +322,6 @@ 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

@@ -1,340 +0,0 @@
----
-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) {
-  const tasks = 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)
-  }));
-
-  // GitHub Reply Task: Add final task if issue has github_url
-  if (issue.github_url || issue.github_number) {
-    const lastTaskId = tasks[tasks.length - 1]?.id;
-    tasks.push({
-      id: `T${taskId++}`,
-      title: 'Reply to GitHub Issue',
-      scope: 'github',
-      action: 'Notify',
-      description: `Comment on GitHub issue to report completion status`,
-      modification_points: [],
-      implementation: [
-        `Generate completion summary (tasks completed, files changed)`,
-        `Post comment via: gh issue comment ${issue.github_number || extractNumber(issue.github_url)} --body "..."`,
-        `Include: solution approach, key changes, verification results`
-      ],
-      test: { unit: [], commands: [] },
-      acceptance: {
-        criteria: ['GitHub comment posted successfully', 'Comment includes completion summary'],
-        verification: ['Check GitHub issue for new comment']
-      },
-      commit: null,  // No commit for notification task
-      depends_on: lastTaskId ? [lastTaskId] : [],  // Depends on last implementation task
-      priority: 5    // Lowest priority (run last)
-    });
-  }
-
-  return tasks;
-}
-```
-
-#### 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-a7x9","description":"...","approach":"...","analysis":{...},"score":0.85,"tasks":[...]}
-{"id":"SOL-GH-123-b2k4","description":"...","approach":"...","analysis":{...},"score":0.75,"tasks":[...]}
-```
-
-**Solution Schema** (must match CLI `Solution` interface):
-```typescript
-{
-  id: string;                    // Format: SOL-{issue-id}-{uid}
-  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)
-// Use 4-char random uid to avoid collisions across multiple plan runs
-const uid = Math.random().toString(36).slice(2, 6);  // e.g., "a7x9"
-const solutionId = `SOL-${issueId}-${uid}`;
-const solutionLine = JSON.stringify({ id: solutionId, ...solution });
-
-// Bash equivalent for uid generation:
-// uid=$(cat /dev/urandom | tr -dc 'a-z0-9' | head -c 4)
-
-// 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. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-2. Read schema first: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
-2. Use ACE semantic search as PRIMARY exploration tool
-3. Fetch issue details via `ccw issue status <id> --json`
-4. Quantify acceptance.criteria with testable conditions
-5. Validate DAG before output
-6. Evaluate each solution with `analysis` and `score`
-7. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (append mode)
-8. For HIGH complexity: generate 2-3 candidate solutions
-9. **Solution ID format**: `SOL-{issue-id}-{uid}` where uid is 4 random alphanumeric chars (e.g., `SOL-GH-123-a7x9`)
-10. **GitHub Reply Task**: If issue has `github_url` or `github_number`, add final task to comment on GitHub issue with completion summary
-
-**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

@@ -1,311 +0,0 @@
----
-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. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-2. 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/memory-bridge.md

@@ -8,7 +8,7 @@ You are a documentation update coordinator for complex projects. Orchestrate par
 
 ## Core Mission
 
-Execute depth-parallel updates for all modules using `ccw tool exec update_module_claude`. **Every module path must be processed**.
+Execute depth-parallel updates for all modules using `~/.claude/scripts/update_module_claude.sh`. **Every module path must be processed**.
 
 ## Input Context
 
@@ -42,12 +42,12 @@ TodoWrite([
 # 3. Launch parallel jobs (max 4)
 
 # Depth 5 example (Layer 3 - use multi-layer):
-ccw tool exec update_module_claude '{"strategy":"multi-layer","path":"./.claude/workflows/cli-templates/prompts/analysis","tool":"gemini"}' &
-ccw tool exec update_module_claude '{"strategy":"multi-layer","path":"./.claude/workflows/cli-templates/prompts/development","tool":"gemini"}' &
+~/.claude/scripts/update_module_claude.sh "multi-layer" "./.claude/workflows/cli-templates/prompts/analysis" "gemini" &
+~/.claude/scripts/update_module_claude.sh "multi-layer" "./.claude/workflows/cli-templates/prompts/development" "gemini" &
 
 # Depth 1 example (Layer 2 - use single-layer):
-ccw tool exec update_module_claude '{"strategy":"single-layer","path":"./src/auth","tool":"gemini"}' &
-ccw tool exec update_module_claude '{"strategy":"single-layer","path":"./src/api","tool":"gemini"}' &
+~/.claude/scripts/update_module_claude.sh "single-layer" "./src/auth" "gemini" &
+~/.claude/scripts/update_module_claude.sh "single-layer" "./src/api" "gemini" &
 # ... up to 4 concurrent jobs
 
 # 4. Wait for all depth jobs to complete
@@ -75,8 +75,6 @@ Examples:
 
 ## Execution Rules
 
-**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-
 1. **Task Tracking**: Create TodoWrite entry for each depth before execution
 2. **Parallelism**: Max 4 jobs per depth, sequential across depths
 3. **Strategy Assignment**: Assign strategy based on depth:

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

@@ -28,8 +28,6 @@ You are a test context discovery specialist focused on gathering test coverage i
 
 ## Tool Arsenal
 
-**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-
 ### 1. Session & Implementation Context
 **Tools**:
 - `Read()` - Load session metadata and implementation summaries
@@ -38,10 +36,10 @@ You are a test context discovery specialist focused on gathering test coverage i
 **Use**: Phase 1 source context loading
 
 ### 2. Test Coverage Discovery
-**Primary (CCW CodexLens MCP)**:
-- `mcp__ccw-tools__codex_lens(action="search_files", query="*.test.*")` - Find test files
-- `mcp__ccw-tools__codex_lens(action="search", query="pattern")` - Search test patterns
-- `mcp__ccw-tools__codex_lens(action="symbol", file="path")` - Analyze test structure
+**Primary (Code-Index MCP)**:
+- `mcp__code-index__find_files(pattern)` - Find test files (*.test.*, *.spec.*)
+- `mcp__code-index__search_code_advanced()` - Search test patterns
+- `mcp__code-index__get_file_summary()` - Analyze test structure
 
 **Fallback (CLI)**:
 - `rg` (ripgrep) - Fast test pattern search
@@ -122,10 +120,9 @@ for (const summary_path of summaries) {
 
 **2.1 Existing Test Discovery**:
 ```javascript
-// Method 1: CodexLens MCP (preferred)
-const test_files = mcp__ccw-tools__codex_lens({
-  action: "search_files",
-  query: "*.test.* OR *.spec.* OR test_*.py OR *_test.go"
+// Method 1: Code-Index MCP (preferred)
+const test_files = mcp__code-index__find_files({
+  patterns: ["*.test.*", "*.spec.*", "*test_*.py", "*_test.go"]
 });
 
 // Method 2: Fallback CLI

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

@@ -59,14 +59,6 @@ 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
@@ -81,12 +73,6 @@ 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
@@ -97,18 +83,17 @@ When task JSON contains implementation_approach array:
   - L1 (Unit): `*.test.*`, `*.spec.*` in `__tests__/`, `tests/unit/`
   - L2 (Integration): `tests/integration/`, `*.integration.test.*`
   - L3 (E2E): `tests/e2e/`, `*.e2e.test.*`, `cypress/`, `playwright/`
-- **context-package.json** (CCW Workflow): Use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
+- **context-package.json** (CCW Workflow): Extract artifact paths using `jq -r '.brainstorm_artifacts.role_analyses[].files[].path'`
 - Identify test commands from project configuration
 
 ```bash
 # Detect test framework and multi-layered commands
 if [ -f "package.json" ]; then
-    # Extract layer-specific test commands using Read tool or jq
-    PKG_JSON=$(cat package.json)
-    LINT_CMD=$(echo "$PKG_JSON" | jq -r '.scripts.lint // "eslint ."')
-    UNIT_CMD=$(echo "$PKG_JSON" | jq -r '.scripts["test:unit"] // .scripts.test')
-    INTEGRATION_CMD=$(echo "$PKG_JSON" | jq -r '.scripts["test:integration"] // ""')
-    E2E_CMD=$(echo "$PKG_JSON" | jq -r '.scripts["test:e2e"] // ""')
+    # Extract layer-specific test commands
+    LINT_CMD=$(cat package.json | jq -r '.scripts.lint // "eslint ."')
+    UNIT_CMD=$(cat package.json | jq -r '.scripts["test:unit"] // .scripts.test')
+    INTEGRATION_CMD=$(cat package.json | jq -r '.scripts["test:integration"] // ""')
+    E2E_CMD=$(cat package.json | jq -r '.scripts["test:e2e"] // ""')
 elif [ -f "pytest.ini" ] || [ -f "setup.py" ]; then
     LINT_CMD="ruff check . || flake8 ."
     UNIT_CMD="pytest tests/unit/"
@@ -332,7 +317,6 @@ When generating test results for orchestrator (saved to `.process/test-results.j
 ## Important Reminders
 
 **ALWAYS:**
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Execute tests first** - Understand what's failing before fixing
 - **Diagnose thoroughly** - Find root cause, not just symptoms
 - **Fix minimally** - Change only what's needed to pass tests

.claude/agents/ui-design-agent.md

@@ -284,8 +284,6 @@ You execute 6 distinct task types organized into 3 patterns. Each task includes
 
 ### ALWAYS
 
-**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-
 **W3C Format Compliance**: ✅ Include $schema in all token files | ✅ Use $type metadata for all tokens | ✅ Use $value wrapper for color (light/dark), duration, easing | ✅ Validate token structure against W3C spec
 
 **Pattern Recognition**: ✅ Identify pattern from [TASK_TYPE_IDENTIFIER] first | ✅ Apply pattern-specific execution rules | ✅ Follow autonomy level

.claude/agents/universal-executor.md

@@ -120,11 +120,7 @@ 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:**
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Verify resource/dependency existence before referencing
 - Execute tasks systematically and incrementally
 - Test and validate work thoroughly

.claude/cli-settings.json

@@ -1,18 +0,0 @@
-{
-  "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/commands/cli/cli-init.md

@@ -191,7 +191,7 @@ target/
 ### Step 2: Workspace Analysis (MANDATORY FIRST)
 ```bash
 # Analyze workspace structure
-bash(ccw tool exec get_modules_by_depth '{"format":"json"}')
+bash(~/.claude/scripts/get_modules_by_depth.sh json)
 ```
 
 ### Step 3: Technology Detection

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

@@ -1,764 +0,0 @@
----
-name: issue:discover-by-prompt
-description: Discover issues from user prompt with Gemini-planned iterative multi-agent exploration. Uses ACE semantic search for context gathering and supports cross-module comparison (e.g., frontend vs backend API contracts).
-argument-hint: "<prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]"
-allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*), mcp__exa__search(*)
----
-
-# Issue Discovery by Prompt
-
-## Quick Start
-
-```bash
-# Discover issues based on user description
-/issue:discover-by-prompt "Check if frontend API calls match backend implementations"
-
-# Compare specific modules
-/issue:discover-by-prompt "Verify auth flow consistency between mobile and web clients" --scope=src/auth/**,src/mobile/**
-
-# Deep exploration with more iterations
-/issue:discover-by-prompt "Find all places where error handling is inconsistent" --depth=deep --max-iterations=8
-
-# Focused backend-frontend contract check
-/issue:discover-by-prompt "Compare REST API definitions with frontend fetch calls"
-```
-
-**Core Difference from `/issue:discover`**:
-- `discover`: Pre-defined perspectives (bug, security, etc.), parallel execution
-- `discover-by-prompt`: User-driven prompt, Gemini-planned strategy, iterative exploration
-
-## What & Why
-
-### Core Concept
-
-Prompt-driven issue discovery with intelligent planning. Instead of fixed perspectives, this command:
-
-1. **Analyzes user intent** via Gemini to understand what to find
-2. **Plans exploration strategy** dynamically based on codebase structure
-3. **Executes iterative multi-agent exploration** with feedback loops
-4. **Performs cross-module comparison** when detecting comparison intent
-
-### Value Proposition
-
-1. **Natural Language Input**: Describe what you want to find, not how to find it
-2. **Intelligent Planning**: Gemini designs optimal exploration strategy
-3. **Iterative Refinement**: Each round builds on previous discoveries
-4. **Cross-Module Analysis**: Compare frontend/backend, mobile/web, old/new implementations
-5. **Adaptive Exploration**: Adjusts direction based on findings
-
-### Use Cases
-
-| Scenario | Example Prompt |
-|----------|----------------|
-| API Contract | "Check if frontend calls match backend endpoints" |
-| Error Handling | "Find inconsistent error handling patterns" |
-| Migration Gap | "Compare old auth with new auth implementation" |
-| Feature Parity | "Verify mobile has all web features" |
-| Schema Drift | "Check if TypeScript types match API responses" |
-| Integration | "Find mismatches between service A and service B" |
-
-## How It Works
-
-### Execution Flow
-
-```
-Phase 1: Prompt Analysis & Initialization
-   ├─ Parse user prompt and flags
-   ├─ Detect exploration intent (comparison/search/verification)
-   └─ Initialize discovery session
-
-Phase 1.5: ACE Context Gathering
-   ├─ Use ACE semantic search to understand codebase structure
-   ├─ Identify relevant modules based on prompt keywords
-   ├─ Collect architecture context for Gemini planning
-   └─ Build initial context package
-
-Phase 2: Gemini Strategy Planning
-   ├─ Feed ACE context + prompt to Gemini CLI
-   ├─ Gemini analyzes and generates exploration strategy
-   ├─ Create exploration dimensions with search targets
-   ├─ Define comparison matrix (if comparison intent)
-   └─ Set success criteria and iteration limits
-
-Phase 3: Iterative Agent Exploration (with ACE)
-   ├─ Iteration 1: Initial exploration by assigned agents
-   │   ├─ Agent A: ACE search + explore dimension 1
-   │   ├─ Agent B: ACE search + explore dimension 2
-   │   └─ Collect findings, update shared context
-   ├─ Iteration 2-N: Refined exploration
-   │   ├─ Analyze previous findings
-   │   ├─ ACE search for related code paths
-   │   ├─ Execute targeted exploration
-   │   └─ Update cumulative findings
-   └─ Termination: Max iterations or convergence
-
-Phase 4: Cross-Analysis & Synthesis
-   ├─ Compare findings across dimensions
-   ├─ Identify discrepancies and issues
-   ├─ Calculate confidence scores
-   └─ Generate issue candidates
-
-Phase 5: Issue Generation & Summary
-   ├─ Convert findings to issue format
-   ├─ Write discovery outputs
-   └─ Prompt user for next action
-```
-
-### Exploration Dimensions
-
-Dimensions are **dynamically generated by Gemini** based on the user prompt. Not limited to predefined categories.
-
-**Examples**:
-
-| Prompt | Generated Dimensions |
-|--------|---------------------|
-| "Check API contracts" | frontend-calls, backend-handlers |
-| "Find auth issues" | auth-module (single dimension) |
-| "Compare old/new implementations" | legacy-code, new-code |
-| "Audit payment flow" | payment-service, validation, logging |
-| "Find error handling gaps" | error-handlers, error-types, recovery-logic |
-
-Gemini analyzes the prompt + ACE context to determine:
-- How many dimensions are needed (1 to N)
-- What each dimension should focus on
-- Whether comparison is needed between dimensions
-
-### Iteration Strategy
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    Iteration Loop                           │
-├─────────────────────────────────────────────────────────────┤
-│  1. Plan: What to explore this iteration                    │
-│     └─ Based on: previous findings + unexplored areas       │
-│                                                             │
-│  2. Execute: Launch agents for this iteration               │
-│     └─ Each agent: explore → collect → return summary       │
-│                                                             │
-│  3. Analyze: Process iteration results                      │
-│     └─ New findings? Gaps? Contradictions?                  │
-│                                                             │
-│  4. Decide: Continue or terminate                           │
-│     └─ Terminate if: max iterations OR convergence OR       │
-│                      high confidence on all questions       │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## Core Responsibilities
-
-### Phase 1: Prompt Analysis & Initialization
-
-```javascript
-// Step 1: Parse arguments
-const { prompt, scope, depth, maxIterations } = parseArgs(args);
-
-// Step 2: Generate discovery ID
-const discoveryId = `DBP-${formatDate(new Date(), 'YYYYMMDD-HHmmss')}`;
-
-// Step 3: Create output directory
-const outputDir = `.workflow/issues/discoveries/${discoveryId}`;
-await mkdir(outputDir, { recursive: true });
-await mkdir(`${outputDir}/iterations`, { recursive: true });
-
-// Step 4: Detect intent type from prompt
-const intentType = detectIntent(prompt);
-// Returns: 'comparison' | 'search' | 'verification' | 'audit'
-
-// Step 5: Initialize discovery state
-await writeJson(`${outputDir}/discovery-state.json`, {
-  discovery_id: discoveryId,
-  type: 'prompt-driven',
-  prompt: prompt,
-  intent_type: intentType,
-  scope: scope || '**/*',
-  depth: depth || 'standard',
-  max_iterations: maxIterations || 5,
-  phase: 'initialization',
-  created_at: new Date().toISOString(),
-  iterations: [],
-  cumulative_findings: [],
-  comparison_matrix: null  // filled for comparison intent
-});
-```
-
-### Phase 1.5: ACE Context Gathering
-
-**Purpose**: Use ACE semantic search to gather codebase context before Gemini planning.
-
-```javascript
-// Step 1: Extract keywords from prompt for semantic search
-const keywords = extractKeywords(prompt);
-// e.g., "frontend API calls match backend" → ["frontend", "API", "backend", "endpoints"]
-
-// Step 2: Use ACE to understand codebase structure
-const aceQueries = [
-  `Project architecture and module structure for ${keywords.join(', ')}`,
-  `Where are ${keywords[0]} implementations located?`,
-  `How does ${keywords.slice(0, 2).join(' ')} work in this codebase?`
-];
-
-const aceResults = [];
-for (const query of aceQueries) {
-  const result = await mcp__ace-tool__search_context({
-    project_root_path: process.cwd(),
-    query: query
-  });
-  aceResults.push({ query, result });
-}
-
-// Step 3: Build context package for Gemini (kept in memory)
-const aceContext = {
-  prompt_keywords: keywords,
-  codebase_structure: aceResults[0].result,
-  relevant_modules: aceResults.slice(1).map(r => r.result),
-  detected_patterns: extractPatterns(aceResults)
-};
-
-// Step 4: Update state (no separate file)
-await updateDiscoveryState(outputDir, {
-  phase: 'context-gathered',
-  ace_context: {
-    queries_executed: aceQueries.length,
-    modules_identified: aceContext.relevant_modules.length
-  }
-});
-
-// aceContext passed to Phase 2 in memory
-```
-
-**ACE Query Strategy by Intent Type**:
-
-| Intent | ACE Queries |
-|--------|-------------|
-| **comparison** | "frontend API calls", "backend API handlers", "API contract definitions" |
-| **search** | "{keyword} implementations", "{keyword} usage patterns" |
-| **verification** | "expected behavior for {feature}", "test coverage for {feature}" |
-| **audit** | "all {category} patterns", "{category} security concerns" |
-
-### Phase 2: Gemini Strategy Planning
-
-**Purpose**: Gemini analyzes user prompt + ACE context to design optimal exploration strategy.
-
-```javascript
-// Step 1: Load ACE context gathered in Phase 1.5
-const aceContext = await readJson(`${outputDir}/ace-context.json`);
-
-// Step 2: Build Gemini planning prompt with ACE context
-const planningPrompt = `
-PURPOSE: Analyze discovery prompt and create exploration strategy based on codebase context
-TASK:
-• Parse user intent from prompt: "${prompt}"
-• Use codebase context to identify specific modules and files to explore
-• Create exploration dimensions with precise search targets
-• Define comparison matrix structure (if comparison intent)
-• Set success criteria and iteration strategy
-MODE: analysis
-CONTEXT: @${scope || '**/*'} | Discovery type: ${intentType}
-
-## Codebase Context (from ACE semantic search)
-${JSON.stringify(aceContext, null, 2)}
-
-EXPECTED: JSON exploration plan following exploration-plan-schema.json:
-{
-  "intent_analysis": { "type": "${intentType}", "primary_question": "...", "sub_questions": [...] },
-  "dimensions": [{ "name": "...", "description": "...", "search_targets": [...], "focus_areas": [...], "agent_prompt": "..." }],
-  "comparison_matrix": { "dimension_a": "...", "dimension_b": "...", "comparison_points": [...] },
-  "success_criteria": [...],
-  "estimated_iterations": N,
-  "termination_conditions": [...]
-}
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Use ACE context to inform targets | Focus on actionable plan
-`;
-
-// Step 3: Execute Gemini planning
-Bash({
-  command: `ccw cli -p "${planningPrompt}" --tool gemini --mode analysis`,
-  run_in_background: true,
-  timeout: 300000
-});
-
-// Step 4: Parse Gemini output and validate against schema
-const explorationPlan = await parseGeminiPlanOutput(geminiResult);
-validateAgainstSchema(explorationPlan, 'exploration-plan-schema.json');
-
-// Step 5: Enhance plan with ACE-discovered file paths
-explorationPlan.dimensions = explorationPlan.dimensions.map(dim => ({
-  ...dim,
-  ace_suggested_files: aceContext.relevant_modules
-    .filter(m => m.relevance_to === dim.name)
-    .map(m => m.file_path)
-}));
-
-// Step 6: Update state (plan kept in memory, not persisted)
-await updateDiscoveryState(outputDir, {
-  phase: 'planned',
-  exploration_plan: {
-    dimensions_count: explorationPlan.dimensions.length,
-    has_comparison_matrix: !!explorationPlan.comparison_matrix,
-    estimated_iterations: explorationPlan.estimated_iterations
-  }
-});
-
-// explorationPlan passed to Phase 3 in memory
-```
-
-**Gemini Planning Responsibilities**:
-
-| Responsibility | Input | Output |
-|----------------|-------|--------|
-| Intent Analysis | User prompt | type, primary_question, sub_questions |
-| Dimension Design | ACE context + prompt | dimensions with search_targets |
-| Comparison Matrix | Intent type + modules | comparison_points (if applicable) |
-| Iteration Strategy | Depth setting | estimated_iterations, termination_conditions |
-
-**Gemini Planning Output Schema**:
-
-```json
-{
-  "intent_analysis": {
-    "type": "comparison|search|verification|audit",
-    "primary_question": "string",
-    "sub_questions": ["string"]
-  },
-  "dimensions": [
-    {
-      "name": "frontend",
-      "description": "Client-side API calls and error handling",
-      "search_targets": ["src/api/**", "src/hooks/**"],
-      "focus_areas": ["fetch calls", "error boundaries", "response parsing"],
-      "agent_prompt": "Explore frontend API consumption patterns..."
-    },
-    {
-      "name": "backend",
-      "description": "Server-side API implementations",
-      "search_targets": ["src/server/**", "src/routes/**"],
-      "focus_areas": ["endpoint handlers", "response schemas", "error responses"],
-      "agent_prompt": "Explore backend API implementations..."
-    }
-  ],
-  "comparison_matrix": {
-    "dimension_a": "frontend",
-    "dimension_b": "backend",
-    "comparison_points": [
-      {"aspect": "endpoints", "frontend_check": "fetch URLs", "backend_check": "route paths"},
-      {"aspect": "methods", "frontend_check": "HTTP methods used", "backend_check": "methods accepted"},
-      {"aspect": "payloads", "frontend_check": "request body structure", "backend_check": "expected schema"},
-      {"aspect": "responses", "frontend_check": "response parsing", "backend_check": "response format"},
-      {"aspect": "errors", "frontend_check": "error handling", "backend_check": "error responses"}
-    ]
-  },
-  "success_criteria": [
-    "All API endpoints mapped between frontend and backend",
-    "Discrepancies identified with file:line references",
-    "Each finding includes remediation suggestion"
-  ],
-  "estimated_iterations": 3,
-  "termination_conditions": [
-    "All comparison points verified",
-    "No new findings in last iteration",
-    "Confidence > 0.8 on primary question"
-  ]
-}
-```
-
-### Phase 3: Iterative Agent Exploration (with ACE)
-
-**Purpose**: Multi-agent iterative exploration using ACE for semantic search within each iteration.
-
-```javascript
-let iteration = 0;
-let cumulativeFindings = [];
-let sharedContext = { aceDiscoveries: [], crossReferences: [] };
-let shouldContinue = true;
-
-while (shouldContinue && iteration < maxIterations) {
-  iteration++;
-  const iterationDir = `${outputDir}/iterations/${iteration}`;
-  await mkdir(iterationDir, { recursive: true });
-
-  // Step 1: ACE-assisted iteration planning
-  // Use previous findings to guide ACE queries for this iteration
-  const iterationAceQueries = iteration === 1
-    ? explorationPlan.dimensions.map(d => d.focus_areas[0])  // Initial queries from plan
-    : deriveQueriesFromFindings(cumulativeFindings);         // Follow-up queries from findings
-
-  // Execute ACE searches to find related code
-  const iterationAceResults = [];
-  for (const query of iterationAceQueries) {
-    const result = await mcp__ace-tool__search_context({
-      project_root_path: process.cwd(),
-      query: `${query} in ${explorationPlan.scope}`
-    });
-    iterationAceResults.push({ query, result });
-  }
-
-  // Update shared context with ACE discoveries
-  sharedContext.aceDiscoveries.push(...iterationAceResults);
-
-  // Step 2: Plan this iteration based on ACE results
-  const iterationPlan = planIteration(iteration, explorationPlan, cumulativeFindings, iterationAceResults);
-
-  // Step 3: Launch dimension agents with ACE context
-  const agentPromises = iterationPlan.dimensions.map(dimension =>
-    Task({
-      subagent_type: "cli-explore-agent",
-      run_in_background: false,
-      description: `Explore ${dimension.name} (iteration ${iteration})`,
-      prompt: buildDimensionPromptWithACE(dimension, iteration, cumulativeFindings, iterationAceResults, iterationDir)
-    })
-  );
-
-  // Wait for iteration agents
-  const iterationResults = await Promise.all(agentPromises);
-
-  // Step 4: Collect and analyze iteration findings
-  const iterationFindings = await collectIterationFindings(iterationDir, iterationPlan.dimensions);
-
-  // Step 5: Cross-reference findings between dimensions
-  if (iterationPlan.dimensions.length > 1) {
-    const crossRefs = findCrossReferences(iterationFindings, iterationPlan.dimensions);
-    sharedContext.crossReferences.push(...crossRefs);
-  }
-
-  cumulativeFindings.push(...iterationFindings);
-
-  // Step 6: Decide whether to continue
-  const convergenceCheck = checkConvergence(iterationFindings, cumulativeFindings, explorationPlan);
-  shouldContinue = !convergenceCheck.converged;
-
-  // Step 7: Update state (iteration summary embedded in state)
-  await updateDiscoveryState(outputDir, {
-    iterations: [...state.iterations, {
-      number: iteration,
-      findings_count: iterationFindings.length,
-      ace_queries: iterationAceQueries.length,
-      cross_references: sharedContext.crossReferences.length,
-      new_discoveries: convergenceCheck.newDiscoveries,
-      confidence: convergenceCheck.confidence,
-      continued: shouldContinue
-    }],
-    cumulative_findings: cumulativeFindings
-  });
-}
-```
-
-**ACE in Iteration Loop**:
-
-```
-Iteration N
-    │
-    ├─→ ACE Search (based on previous findings)
-    │   └─ Query: "related code paths for {finding.category}"
-    │   └─ Result: Additional files to explore
-    │
-    ├─→ Agent Exploration (with ACE context)
-    │   └─ Agent receives: dimension targets + ACE suggestions
-    │   └─ Agent can call ACE for deeper search
-    │
-    ├─→ Cross-Reference Analysis
-    │   └─ Compare findings between dimensions
-    │   └─ Identify discrepancies
-    │
-    └─→ Convergence Check
-        └─ New findings? Continue
-        └─ No new findings? Terminate
-```
-
-**Dimension Agent Prompt Template (with ACE)**:
-
-```javascript
-function buildDimensionPromptWithACE(dimension, iteration, previousFindings, aceResults, outputDir) {
-  // Filter ACE results relevant to this dimension
-  const relevantAceResults = aceResults.filter(r =>
-    r.query.includes(dimension.name) || dimension.focus_areas.some(fa => r.query.includes(fa))
-  );
-
-  return `
-    ## Task Objective
-    Explore ${dimension.name} dimension for issue discovery (Iteration ${iteration})
-
-    ## Context
-    - Dimension: ${dimension.name}
-    - Description: ${dimension.description}
-    - Search Targets: ${dimension.search_targets.join(', ')}
-    - Focus Areas: ${dimension.focus_areas.join(', ')}
-
-    ## ACE Semantic Search Results (Pre-gathered)
-    The following files/code sections were identified by ACE as relevant to this dimension:
-    ${JSON.stringify(relevantAceResults.map(r => ({ query: r.query, files: r.result.slice(0, 5) })), null, 2)}
-
-    **Use ACE for deeper exploration**: You have access to mcp__ace-tool__search_context.
-    When you find something interesting, use ACE to find related code:
-    - mcp__ace-tool__search_context({ project_root_path: ".", query: "related to {finding}" })
-
-    ${iteration > 1 ? `
-    ## Previous Findings to Build Upon
-    ${summarizePreviousFindings(previousFindings, dimension.name)}
-
-    ## This Iteration Focus
-    - Explore areas not yet covered (check ACE results for new files)
-    - Verify/deepen previous findings
-    - Follow leads from previous discoveries
-    - Use ACE to find cross-references between dimensions
-    ` : ''}
-
-    ## MANDATORY FIRST STEPS
-    1. Read exploration plan: ${outputDir}/../exploration-plan.json
-    2. Read schema: ~/.claude/workflows/cli-templates/schemas/discovery-finding-schema.json
-    3. Review ACE results above for starting points
-    4. Explore files identified by ACE
-
-    ## Exploration Instructions
-    ${dimension.agent_prompt}
-
-    ## ACE Usage Guidelines
-    - Use ACE when you need to find:
-      - Where a function/class is used
-      - Related implementations in other modules
-      - Cross-module dependencies
-      - Similar patterns elsewhere in codebase
-    - Query format: Natural language, be specific
-    - Example: "Where is UserService.authenticate called from?"
-
-    ## Output Requirements
-
-    **1. Write JSON file**: ${outputDir}/${dimension.name}.json
-    Follow discovery-finding-schema.json:
-    - findings: [{id, title, category, description, file, line, snippet, confidence, related_dimension}]
-    - coverage: {files_explored, areas_covered, areas_remaining}
-    - leads: [{description, suggested_search}] // for next iteration
-    - ace_queries_used: [{query, result_count}] // track ACE usage
-
-    **2. Return summary**:
-    - Total findings this iteration
-    - Key discoveries
-    - ACE queries that revealed important code
-    - Recommended next exploration areas
-
-    ## Success Criteria
-    - [ ] JSON written to ${outputDir}/${dimension.name}.json
-    - [ ] Each finding has file:line reference
-    - [ ] ACE used for cross-references where applicable
-    - [ ] Coverage report included
-    - [ ] Leads for next iteration identified
-  `;
-}
-```
-
-### Phase 4: Cross-Analysis & Synthesis
-
-```javascript
-// For comparison intent, perform cross-analysis
-if (intentType === 'comparison' && explorationPlan.comparison_matrix) {
-  const comparisonResults = [];
-
-  for (const point of explorationPlan.comparison_matrix.comparison_points) {
-    const dimensionAFindings = cumulativeFindings.filter(f =>
-      f.related_dimension === explorationPlan.comparison_matrix.dimension_a &&
-      f.category.includes(point.aspect)
-    );
-
-    const dimensionBFindings = cumulativeFindings.filter(f =>
-      f.related_dimension === explorationPlan.comparison_matrix.dimension_b &&
-      f.category.includes(point.aspect)
-    );
-
-    // Compare and find discrepancies
-    const discrepancies = findDiscrepancies(dimensionAFindings, dimensionBFindings, point);
-
-    comparisonResults.push({
-      aspect: point.aspect,
-      dimension_a_count: dimensionAFindings.length,
-      dimension_b_count: dimensionBFindings.length,
-      discrepancies: discrepancies,
-      match_rate: calculateMatchRate(dimensionAFindings, dimensionBFindings)
-    });
-  }
-
-  // Write comparison analysis
-  await writeJson(`${outputDir}/comparison-analysis.json`, {
-    matrix: explorationPlan.comparison_matrix,
-    results: comparisonResults,
-    summary: {
-      total_discrepancies: comparisonResults.reduce((sum, r) => sum + r.discrepancies.length, 0),
-      overall_match_rate: average(comparisonResults.map(r => r.match_rate)),
-      critical_mismatches: comparisonResults.filter(r => r.match_rate < 0.5)
-    }
-  });
-}
-
-// Prioritize all findings
-const prioritizedFindings = prioritizeFindings(cumulativeFindings, explorationPlan);
-```
-
-### Phase 5: Issue Generation & Summary
-
-```javascript
-// Convert high-confidence findings to issues
-const issueWorthy = prioritizedFindings.filter(f =>
-  f.confidence >= 0.7 || f.priority === 'critical' || f.priority === 'high'
-);
-
-const issues = issueWorthy.map(finding => ({
-  id: `ISS-${discoveryId}-${finding.id}`,
-  title: finding.title,
-  description: finding.description,
-  source: {
-    discovery_id: discoveryId,
-    finding_id: finding.id,
-    dimension: finding.related_dimension
-  },
-  file: finding.file,
-  line: finding.line,
-  priority: finding.priority,
-  category: finding.category,
-  suggested_fix: finding.suggested_fix,
-  confidence: finding.confidence,
-  status: 'discovered',
-  created_at: new Date().toISOString()
-}));
-
-// Write issues
-await writeJsonl(`${outputDir}/discovery-issues.jsonl`, issues);
-
-// Update final state (summary embedded in state, no separate file)
-await updateDiscoveryState(outputDir, {
-  phase: 'complete',
-  updated_at: new Date().toISOString(),
-  results: {
-    total_iterations: iteration,
-    total_findings: cumulativeFindings.length,
-    issues_generated: issues.length,
-    comparison_match_rate: comparisonResults
-      ? average(comparisonResults.map(r => r.match_rate))
-      : null
-  }
-});
-
-// Prompt user for next action
-await AskUserQuestion({
-  questions: [{
-    question: `Discovery complete: ${issues.length} issues from ${cumulativeFindings.length} findings across ${iteration} iterations. What next?`,
-    header: "Next Step",
-    multiSelect: false,
-    options: [
-      { label: "Export to Issues (Recommended)", description: `Export ${issues.length} issues for planning` },
-      { label: "Review Details", description: "View comparison analysis and iteration details" },
-      { label: "Run Deeper", description: "Continue with more iterations" },
-      { label: "Skip", description: "Complete without exporting" }
-    ]
-  }]
-});
-```
-
-## Output File Structure
-
-```
-.workflow/issues/discoveries/
-└── {DBP-YYYYMMDD-HHmmss}/
-    ├── discovery-state.json          # Session state with iteration tracking
-    ├── iterations/
-    │   ├── 1/
-    │   │   └── {dimension}.json      # Dimension findings
-    │   ├── 2/
-    │   │   └── {dimension}.json
-    │   └── ...
-    ├── comparison-analysis.json      # Cross-dimension comparison (if applicable)
-    └── discovery-issues.jsonl        # Generated issue candidates
-```
-
-**Simplified Design**:
-- ACE context and Gemini plan kept in memory, not persisted
-- Iteration summaries embedded in state
-- No separate summary.md (state.json contains all needed info)
-
-## Schema References
-
-| Schema | Path | Used By |
-|--------|------|---------|
-| **Discovery State** | `discovery-state-schema.json` | Orchestrator (state tracking) |
-| **Discovery Finding** | `discovery-finding-schema.json` | Dimension agents (output) |
-| **Exploration Plan** | `exploration-plan-schema.json` | Gemini output validation (memory only) |
-
-## Configuration Options
-
-| Flag | Default | Description |
-|------|---------|-------------|
-| `--scope` | `**/*` | File pattern to explore |
-| `--depth` | `standard` | `standard` (3 iterations) or `deep` (5+ iterations) |
-| `--max-iterations` | 5 | Maximum exploration iterations |
-| `--tool` | `gemini` | Planning tool (gemini/qwen) |
-| `--plan-only` | `false` | Stop after Phase 2 (Gemini planning), show plan for user review |
-
-## Examples
-
-### Example 1: Single Module Deep Dive
-
-```bash
-/issue:discover-by-prompt "Find all potential issues in the auth module" --scope=src/auth/**
-```
-
-**Gemini plans** (single dimension):
-- Dimension: auth-module
-- Focus: security vulnerabilities, edge cases, error handling, test gaps
-
-**Iterations**: 2-3 (until no new findings)
-
-### Example 2: API Contract Comparison
-
-```bash
-/issue:discover-by-prompt "Check if API calls match implementations" --scope=src/**
-```
-
-**Gemini plans** (comparison):
-- Dimension 1: api-consumers (fetch calls, hooks, services)
-- Dimension 2: api-providers (handlers, routes, controllers)
-- Comparison matrix: endpoints, methods, payloads, responses
-
-### Example 3: Multi-Module Audit
-
-```bash
-/issue:discover-by-prompt "Audit the payment flow for issues" --scope=src/payment/**
-```
-
-**Gemini plans** (multi-dimension):
-- Dimension 1: payment-logic (calculations, state transitions)
-- Dimension 2: validation (input checks, business rules)
-- Dimension 3: error-handling (failure modes, recovery)
-
-### Example 4: Plan Only Mode
-
-```bash
-/issue:discover-by-prompt "Find inconsistent patterns" --plan-only
-```
-
-Stops after Gemini planning, outputs:
-```
-Gemini Plan:
-- Intent: search
-- Dimensions: 2 (pattern-definitions, pattern-usages)
-- Estimated iterations: 3
-
-Continue with exploration? [Y/n]
-```
-
-## Related Commands
-
-```bash
-# After discovery, plan solutions
-/issue:plan DBP-001-01,DBP-001-02
-
-# View all discoveries
-/issue:manage
-
-# Standard perspective-based discovery
-/issue:discover src/auth/** --perspectives=security,bug
-```
-
-## Best Practices
-
-1. **Be Specific in Prompts**: More specific prompts lead to better Gemini planning
-2. **Scope Appropriately**: Narrow scope for focused comparison, wider for audits
-3. **Review Exploration Plan**: Check `exploration-plan.json` before long explorations
-4. **Use Standard Depth First**: Start with standard, go deep only if needed
-5. **Combine with `/issue:discover`**: Use prompt-based for comparisons, perspective-based for audits

.claude/commands/issue/discover.md

@@ -1,468 +0,0 @@
----
-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

@@ -1,466 +0,0 @@
----
-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**
-- **Single worktree for entire queue**: One worktree isolates ALL queue execution from main workspace
-
-## Usage
-
-```bash
-/issue:execute                           # Execute active queue(s)
-/issue:execute --queue QUE-xxx           # Execute specific queue
-/issue:execute --worktree                # Execute entire queue in isolated worktree
-/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 ONE worktree for the entire queue execution (not per-solution)
-
-**⭐ 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 Queue Worktree
-   ├─ Create ONE worktree for entire queue: .ccw/worktrees/queue-<timestamp>
-   ├─ All subsequent execution happens in this worktree
-   └─ Main workspace remains clean and untouched
-
-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)
-   ├─ All executors work in the SAME worktree (or main if no worktree)
-   ├─ For each solution ID in batch (parallel - all at once):
-   │   ├─ 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>
-   └─ Wait for batch completion
-
-Phase 3: Next Batch (repeat Phase 2)
-   └─ ccw issue queue dag → check for newly-ready solutions
-
-Phase 4 (if --worktree): Worktree Completion
-   ├─ All batches complete → prompt for merge strategy
-   └─ Options: Create PR / Merge to main / Keep branch
-```
-
-## 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 worktree for queue isolation?',
-      header: 'Worktree',
-      multiSelect: false,
-      options: [
-        { label: 'Yes (Recommended)', description: 'Create ONE worktree for entire queue - main stays clean' },
-        { label: 'No', description: 'Work directly in current directory' }
-      ]
-    }
-  ]
-});
-
-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 0 & 2: Setup Queue Worktree & Dispatch
-
-```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(', ')}`);
-
-// 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;
-
-// Setup ONE worktree for entire queue (not per-solution)
-let worktreePath = null;
-let worktreeBranch = null;
-
-if (useWorktree) {
-  const repoRoot = Bash('git rev-parse --show-toplevel').trim();
-  const worktreeBase = `${repoRoot}/.ccw/worktrees`;
-  Bash(`mkdir -p "${worktreeBase}"`);
-  Bash('git worktree prune');  // Cleanup stale worktrees
-
-  if (existingWorktree) {
-    // Resume mode: Use existing worktree
-    worktreePath = existingWorktree;
-    worktreeBranch = Bash(`git -C "${worktreePath}" branch --show-current`).trim();
-    console.log(`Resuming in existing worktree: ${worktreePath} (branch: ${worktreeBranch})`);
-  } else {
-    // Create mode: ONE worktree for the entire queue
-    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
-    worktreeBranch = `queue-exec-${dag.queue_id || timestamp}`;
-    worktreePath = `${worktreeBase}/${worktreeBranch}`;
-    Bash(`git worktree add "${worktreePath}" -b "${worktreeBranch}"`);
-    console.log(`Created queue worktree: ${worktreePath}`);
-  }
-}
-
-// Launch ALL solutions in batch in parallel (DAG guarantees no conflicts)
-// All executors work in the SAME worktree (or main if no worktree)
-const executions = batch.map(solutionId => {
-  updateTodo(solutionId, 'in_progress');
-  return dispatchExecutor(solutionId, executor, worktreePath);
-});
-
-await Promise.all(executions);
-batch.forEach(id => updateTodo(id, 'completed'));
-```
-
-### Executor Dispatch
-
-```javascript
-// worktreePath: path to shared worktree (null if not using worktree)
-function dispatchExecutor(solutionId, executorType, worktreePath = null) {
-  // If worktree is provided, executor works in that directory
-  // No per-solution worktree creation - ONE worktree for entire queue
-  const cdCommand = worktreePath ? `cd "${worktreePath}"` : '';
-
-  const prompt = `
-## Execute Solution ${solutionId}
-${worktreePath ? `
-### Step 0: Enter Queue Worktree
-\`\`\`bash
-cd "${worktreePath}"
-\`\`\`
-` : ''}
-### Step 1: Get Solution (read-only)
-\`\`\`bash
-ccw issue detail ${solutionId}
-\`\`\`
-
-### 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": "..."}'
-\`\`\`
-
-**Note**: Do NOT cleanup worktree after this solution. Worktree is shared by all solutions in the queue.
-`;
-
-  // For CLI tools, pass --cd to set working directory
-  const cdOption = worktreePath ? ` --cd "${worktreePath}"` : '';
-
-  if (executorType === 'codex') {
-    return Bash(
-      `ccw cli -p "${escapePrompt(prompt)}" --tool codex --mode write --id exec-${solutionId}${cdOption}`,
-      { 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}${cdOption}`,
-      { timeout: 3600000, run_in_background: true }
-    );
-  } else {
-    return Task({
-      subagent_type: 'code-developer',
-      run_in_background: false,
-      description: `Execute solution ${solutionId}`,
-      prompt: worktreePath ? `Working directory: ${worktreePath}\n\n${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.');
-  // Note: If resuming, pass existing worktree path:
-  // /issue:execute --worktree <worktreePath>
-}
-```
-
-### Phase 4: Worktree Completion (after ALL batches)
-
-```javascript
-// Only run when ALL solutions completed AND using worktree
-if (useWorktree && refreshedDag.ready_count === 0 && refreshedDag.completed_count === refreshedDag.total) {
-  console.log('\n## All Solutions Completed - Worktree Cleanup');
-
-  const answer = AskUserQuestion({
-    questions: [{
-      question: `Queue complete. What to do with worktree branch "${worktreeBranch}"?`,
-      header: 'Merge',
-      multiSelect: false,
-      options: [
-        { label: 'Create PR (Recommended)', description: 'Push branch and create pull request' },
-        { label: 'Merge to main', description: 'Merge all commits and cleanup worktree' },
-        { label: 'Keep branch', description: 'Cleanup worktree, keep branch for manual handling' }
-      ]
-    }]
-  });
-
-  const repoRoot = Bash('git rev-parse --show-toplevel').trim();
-
-  if (answer['Merge'].includes('Create PR')) {
-    Bash(`git -C "${worktreePath}" push -u origin "${worktreeBranch}"`);
-    Bash(`gh pr create --title "Queue ${dag.queue_id}" --body "Issue queue execution - all solutions completed" --head "${worktreeBranch}"`);
-    Bash(`git worktree remove "${worktreePath}"`);
-    console.log(`PR created for branch: ${worktreeBranch}`);
-  } else if (answer['Merge'].includes('Merge to main')) {
-    // Check main is clean
-    const mainDirty = Bash('git status --porcelain').trim();
-    if (mainDirty) {
-      console.log('Warning: Main has uncommitted changes. Falling back to PR.');
-      Bash(`git -C "${worktreePath}" push -u origin "${worktreeBranch}"`);
-      Bash(`gh pr create --title "Queue ${dag.queue_id}" --body "Issue queue execution (main had uncommitted changes)" --head "${worktreeBranch}"`);
-    } else {
-      Bash(`git merge --no-ff "${worktreeBranch}" -m "Merge queue ${dag.queue_id}"`);
-      Bash(`git branch -d "${worktreeBranch}"`);
-    }
-    Bash(`git worktree remove "${worktreePath}"`);
-  } else {
-    Bash(`git worktree remove "${worktreePath}"`);
-    console.log(`Branch ${worktreeBranch} kept for manual handling`);
-  }
-}
-```
-
-## Parallel Execution Model
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│ Orchestrator                                                    │
-├─────────────────────────────────────────────────────────────────┤
-│ 0. (if --worktree) Create ONE worktree for entire queue         │
-│    → .ccw/worktrees/queue-exec-<queue-id>                       │
-│                                                                 │
-│ 1. ccw issue queue dag                                          │
-│    → { parallel_batches: [["S-1","S-2"], ["S-3"]] }             │
-│                                                                 │
-│ 2. Dispatch batch 1 (parallel, SAME worktree):                  │
-│    ┌──────────────────────────────────────────────────────┐     │
-│    │        Shared Queue Worktree (or main)               │     │
-│    │  ┌──────────────────┐ ┌──────────────────┐          │     │
-│    │  │ Executor 1       │ │ Executor 2       │          │     │
-│    │  │ detail S-1       │ │ detail S-2       │          │     │
-│    │  │ [T1→T2→T3]       │ │ [T1→T2]          │          │     │
-│    │  │ commit S-1       │ │ commit S-2       │          │     │
-│    │  │ done S-1         │ │ done S-2         │          │     │
-│    │  └──────────────────┘ └──────────────────┘          │     │
-│    └──────────────────────────────────────────────────────┘     │
-│                                                                 │
-│ 3. ccw issue queue dag (refresh)                                │
-│    → S-3 now ready → dispatch batch 2 (same worktree)           │
-│                                                                 │
-│ 4. (if --worktree) ALL batches complete → cleanup worktree      │
-│    → Prompt: Create PR / Merge to main / Keep branch            │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-**Why this works for parallel:**
-- **ONE worktree for entire queue** → all solutions share same isolated workspace
-- `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 (DAG guarantees)
-- **Main workspace stays clean** until merge/PR decision
-
-## 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

@@ -1,413 +0,0 @@
----
-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[];
-
-  // GitHub binding (for non-GitHub sources that publish to GitHub)
-  github_url?: string;           // https://github.com/owner/repo/issues/123
-  github_number?: number;        // 123
-
-  // 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: GitHub Publishing Decision (Non-GitHub Sources)
-
-```javascript
-// For non-GitHub sources, ask if user wants to publish to GitHub
-let publishToGitHub = false;
-
-if (issueData.source !== 'github') {
-  const publishAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Would you like to publish this issue to GitHub?',
-      header: 'Publish',
-      multiSelect: false,
-      options: [
-        { label: 'Yes, publish to GitHub', description: 'Create issue on GitHub and link it' },
-        { label: 'No, keep local only', description: 'Store as local issue without GitHub sync' }
-      ]
-    }]
-  });
-
-  publishToGitHub = publishAnswer.answers?.['Publish']?.includes('Yes');
-}
-```
-
-### Phase 6: 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",
-  ...
-}
-```
-
-**GitHub Publishing** (if user opted in):
-```javascript
-// Step 1: Create local issue FIRST
-const localIssue = createLocalIssue(issueData);  // ccw issue create
-
-// Step 2: Publish to GitHub if requested
-if (publishToGitHub) {
-  const ghResult = Bash(`gh issue create --title "${issueData.title}" --body "${issueData.context}"`);
-  // Parse GitHub URL from output
-  const ghUrl = ghResult.match(/https:\/\/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/)?.[0];
-  const ghNumber = parseInt(ghUrl?.match(/\/issues\/(\d+)/)?.[1]);
-
-  if (ghNumber) {
-    // Step 3: Update local issue with GitHub binding
-    Bash(`ccw issue update ${localIssue.id} --github-url "${ghUrl}" --github-number ${ghNumber}`);
-    // Or via pipe:
-    // echo '{"github_url":"${ghUrl}","github_number":${ghNumber}}' | ccw issue update ${localIssue.id}
-  }
-}
-```
-
-**Workflow:**
-```
-1. Create local issue (ISS-YYYYMMDD-NNN) → stored in .workflow/issues.jsonl
-2. If publishToGitHub:
-   a. gh issue create → returns GitHub URL
-   b. Update local issue with github_url + github_number binding
-3. Both local and GitHub issues exist, linked together
-```
-
-**Example with GitHub Publishing:**
-```bash
-# User creates text issue
-/issue:new "Login fails with special chars. Expected: success. Actual: 500"
-
-# System asks: "Would you like to publish this issue to GitHub?"
-# User selects: "Yes, publish to GitHub"
-
-# Output:
-# ✓ Local issue created: ISS-20251229-001
-# ✓ Published to GitHub: https://github.com/org/repo/issues/123
-# ✓ GitHub binding saved to local issue
-# → Next step: /issue:plan ISS-20251229-001
-
-# Resulting issue JSON:
-{
-  "id": "ISS-20251229-001",
-  "title": "Login fails with special chars",
-  "source": "text",
-  "github_url": "https://github.com/org/repo/issues/123",
-  "github_number": 123,
-  ...
-}
-```
-
-**Completion:**
-- Display created issue ID
-- Show GitHub URL (if published)
-- 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: GitHub Publishing Decision (non-GitHub only)
-   ├─ Source = github: Skip (already from GitHub)
-   └─ Source ≠ github: AskUserQuestion
-      ├─ Yes → publishToGitHub = true
-      └─ No  → publishToGitHub = false
-
-Phase 4: Create Issue
-   ├─ Score ≥ 2: Direct creation
-   └─ Score < 2: Confirm first → Create
-   └─ If publishToGitHub: gh issue create → link URL
-
-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

@@ -1,330 +0,0 @@
----
-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. **If github_url exists**: Add final task to comment on GitHub issue
-6. Write solution to: .workflow/issues/solutions/{issue-id}.jsonl
-7. Single solution → auto-bind; Multiple → return for selection
-
-### Rules
-- Solution ID format: SOL-{issue-id}-{uid} (uid: 4 random alphanumeric chars, e.g., a7x9)
-- 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

@@ -1,382 +0,0 @@
----
-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/compact.md

@@ -1,383 +0,0 @@
----
-name: 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
-argument-hint: "[optional: session description]"
-allowed-tools: mcp__ccw-tools__core_memory(*), Read(*)
-examples:
-  - /memory:compact
-  - /memory:compact "completed core-memory module"
----
-
-# Memory Compact Command (/memory:compact)
-
-## 1. Overview
-
-The `memory:compact` command **compresses current session working memory** into structured text optimized for **session recovery**, extracts critical information, and saves it to persistent storage via MCP `core_memory` tool.
-
-**Core Philosophy**:
-- **Session Recovery First**: Capture everything needed to resume work seamlessly
-- **Minimize Re-exploration**: Include file paths, decisions, and state to avoid redundant analysis
-- **Preserve Train of Thought**: Keep notes and hypotheses for complex debugging
-- **Actionable State**: Record last action result and known issues
-
-## 2. Parameters
-
-- `"session description"` (Optional): Session description to supplement objective
-  - Example: "completed core-memory module"
-  - Example: "debugging JWT refresh - suspected memory leak"
-
-## 3. Structured Output Format
-
-```markdown
-## Session ID
-[WFS-ID if workflow session active, otherwise (none)]
-
-## Project Root
-[Absolute path to project root, e.g., D:\Claude_dms3]
-
-## Objective
-[High-level goal - the "North Star" of this session]
-
-## Execution Plan
-[CRITICAL: Embed the LATEST plan in its COMPLETE and DETAILED form]
-
-### Source: [workflow | todo | user-stated | inferred]
-
-<details>
-<summary>Full Execution Plan (Click to expand)</summary>
-
-[PRESERVE COMPLETE PLAN VERBATIM - DO NOT SUMMARIZE]
-- ALL phases, tasks, subtasks
-- ALL file paths (absolute)
-- ALL dependencies and prerequisites
-- ALL acceptance criteria
-- ALL status markers ([x] done, [ ] pending)
-- ALL notes and context
-
-Example:
-## Phase 1: Setup
-- [x] Initialize project structure
-  - Created D:\Claude_dms3\src\core\index.ts
-  - Added dependencies: lodash, zod
-- [ ] Configure TypeScript
-  - Update tsconfig.json for strict mode
-
-## Phase 2: Implementation
-- [ ] Implement core API
-  - Target: D:\Claude_dms3\src\api\handler.ts
-  - Dependencies: Phase 1 complete
-  - Acceptance: All tests pass
-
-</details>
-
-## Working Files (Modified)
-[Absolute paths to actively modified files]
-- D:\Claude_dms3\src\file1.ts (role: main implementation)
-- D:\Claude_dms3\tests\file1.test.ts (role: unit tests)
-
-## Reference Files (Read-Only)
-[Absolute paths to context files - NOT modified but essential for understanding]
-- D:\Claude_dms3\.claude\CLAUDE.md (role: project instructions)
-- D:\Claude_dms3\src\types\index.ts (role: type definitions)
-- D:\Claude_dms3\package.json (role: dependencies)
-
-## Last Action
-[Last significant action and its result/status]
-
-## Decisions
-- [Decision]: [Reasoning]
-- [Decision]: [Reasoning]
-
-## Constraints
-- [User-specified limitation or preference]
-
-## Dependencies
-- [Added/changed packages or environment requirements]
-
-## Known Issues
-- [Deferred bug or edge case]
-
-## Changes Made
-- [Completed modification]
-
-## Pending
-- [Next step] or (none)
-
-## Notes
-[Unstructured thoughts, hypotheses, debugging trails]
-```
-
-## 4. Field Definitions
-
-| Field | Purpose | Recovery Value |
-|-------|---------|----------------|
-| **Session ID** | Workflow session identifier (WFS-*) | Links memory to specific stateful task execution |
-| **Project Root** | Absolute path to project directory | Enables correct path resolution in new sessions |
-| **Objective** | Ultimate goal of the session | Prevents losing track of broader feature |
-| **Execution Plan** | Complete plan from any source (verbatim) | Preserves full planning context, avoids re-planning |
-| **Working Files** | Actively modified files (absolute paths) | Immediately identifies where work was happening |
-| **Reference Files** | Read-only context files (absolute paths) | Eliminates re-exploration for critical context |
-| **Last Action** | Final tool output/status | Immediate state awareness (success/failure) |
-| **Decisions** | Architectural choices + reasoning | Prevents re-litigating settled decisions |
-| **Constraints** | User-imposed limitations | Maintains personalized coding style |
-| **Dependencies** | Package/environment changes | Prevents missing dependency errors |
-| **Known Issues** | Deferred bugs/edge cases | Ensures issues aren't forgotten |
-| **Changes Made** | Completed modifications | Clear record of what was done |
-| **Pending** | Next steps | Immediate action items |
-| **Notes** | Hypotheses, debugging trails | Preserves "train of thought" |
-
-## 5. Execution Flow
-
-### Step 1: Analyze Current Session
-
-Extract the following from conversation history:
-
-```javascript
-const sessionAnalysis = {
-  sessionId: "",       // WFS-* if workflow session active, null otherwise
-  projectRoot: "",     // Absolute path: D:\Claude_dms3
-  objective: "",       // High-level goal (1-2 sentences)
-  executionPlan: {
-    source: "workflow" | "todo" | "user-stated" | "inferred",
-    content: ""        // Full plan content - ALWAYS preserve COMPLETE and DETAILED form
-  },
-  workingFiles: [],    // {absolutePath, role} - modified files
-  referenceFiles: [],  // {absolutePath, role} - read-only context files
-  lastAction: "",      // Last significant action + result
-  decisions: [],       // {decision, reasoning}
-  constraints: [],     // User-specified limitations
-  dependencies: [],    // Added/changed packages
-  knownIssues: [],     // Deferred bugs
-  changesMade: [],     // Completed modifications
-  pending: [],         // Next steps
-  notes: ""            // Unstructured thoughts
-}
-```
-
-### Step 2: Generate Structured Text
-
-```javascript
-// Helper: Generate execution plan section
-const generateExecutionPlan = (plan) => {
-  const sourceLabels = {
-    'workflow': 'workflow (IMPL_PLAN.md)',
-    'todo': 'todo (TodoWrite)',
-    'user-stated': 'user-stated',
-    'inferred': 'inferred'
-  };
-
-  // CRITICAL: Preserve complete plan content verbatim - DO NOT summarize
-  return `### Source: ${sourceLabels[plan.source] || plan.source}
-
-<details>
-<summary>Full Execution Plan (Click to expand)</summary>
-
-${plan.content}
-
-</details>`;
-};
-
-const structuredText = `## Session ID
-${sessionAnalysis.sessionId || '(none)'}
-
-## Project Root
-${sessionAnalysis.projectRoot}
-
-## Objective
-${sessionAnalysis.objective}
-
-## Execution Plan
-${generateExecutionPlan(sessionAnalysis.executionPlan)}
-
-## Working Files (Modified)
-${sessionAnalysis.workingFiles.map(f => `- ${f.absolutePath} (role: ${f.role})`).join('\n') || '(none)'}
-
-## Reference Files (Read-Only)
-${sessionAnalysis.referenceFiles.map(f => `- ${f.absolutePath} (role: ${f.role})`).join('\n') || '(none)'}
-
-## Last Action
-${sessionAnalysis.lastAction}
-
-## Decisions
-${sessionAnalysis.decisions.map(d => `- ${d.decision}: ${d.reasoning}`).join('\n') || '(none)'}
-
-## Constraints
-${sessionAnalysis.constraints.map(c => `- ${c}`).join('\n') || '(none)'}
-
-## Dependencies
-${sessionAnalysis.dependencies.map(d => `- ${d}`).join('\n') || '(none)'}
-
-## Known Issues
-${sessionAnalysis.knownIssues.map(i => `- ${i}`).join('\n') || '(none)'}
-
-## Changes Made
-${sessionAnalysis.changesMade.map(c => `- ${c}`).join('\n') || '(none)'}
-
-## Pending
-${sessionAnalysis.pending.length > 0
-  ? sessionAnalysis.pending.map(p => `- ${p}`).join('\n')
-  : '(none)'}
-
-## Notes
-${sessionAnalysis.notes || '(none)'}`
-```
-
-### Step 3: Import to Core Memory via MCP
-
-Use the MCP `core_memory` tool to save the structured text:
-
-```javascript
-mcp__ccw-tools__core_memory({
-  operation: "import",
-  text: structuredText
-})
-```
-
-Or via CLI (pipe structured text to import):
-
-```bash
-# Write structured text to temp file, then import
-echo "$structuredText" | ccw core-memory import
-
-# Or from a file
-ccw core-memory import --file /path/to/session-memory.md
-```
-
-**Response Format**:
-```json
-{
-  "operation": "import",
-  "id": "CMEM-YYYYMMDD-HHMMSS",
-  "message": "Created memory: CMEM-YYYYMMDD-HHMMSS"
-}
-```
-
-### Step 4: Report Recovery ID
-
-After successful import, **clearly display the Recovery ID** to the user:
-
-```
-╔════════════════════════════════════════════════════════════════════════════╗
-║  ✓ Session Memory Saved                                                    ║
-║                                                                            ║
-║  Recovery ID: CMEM-YYYYMMDD-HHMMSS                                         ║
-║                                                                            ║
-║  To restore: "Please import memory <ID>"                                   ║
-║  (MCP: core_memory export | CLI: ccw core-memory export --id <ID>)         ║
-╚════════════════════════════════════════════════════════════════════════════╝
-```
-
-## 6. Quality Checklist
-
-Before generating:
-- [ ] Session ID captured if workflow session active (WFS-*)
-- [ ] Project Root is absolute path (e.g., D:\Claude_dms3)
-- [ ] Objective clearly states the "North Star" goal
-- [ ] Execution Plan: COMPLETE plan preserved VERBATIM (no summarization)
-- [ ] Plan Source: Clearly identified (workflow | todo | user-stated | inferred)
-- [ ] Plan Details: ALL phases, tasks, file paths, dependencies, status markers included
-- [ ] All file paths are ABSOLUTE (not relative)
-- [ ] Working Files: 3-8 modified files with roles
-- [ ] Reference Files: Key context files (CLAUDE.md, types, configs)
-- [ ] Last Action captures final state (success/failure)
-- [ ] Decisions include reasoning, not just choices
-- [ ] Known Issues separates deferred from forgotten bugs
-- [ ] Notes preserve debugging hypotheses if any
-
-## 7. Path Resolution Rules
-
-### Project Root Detection
-1. Check current working directory from environment
-2. Look for project markers: `.git/`, `package.json`, `.claude/`
-3. Use the topmost directory containing these markers
-
-### Absolute Path Conversion
-```javascript
-// Convert relative to absolute
-const toAbsolutePath = (relativePath, projectRoot) => {
-  if (path.isAbsolute(relativePath)) return relativePath;
-  return path.join(projectRoot, relativePath);
-};
-
-// Example: "src/api/auth.ts" → "D:\Claude_dms3\src\api\auth.ts"
-```
-
-### Reference File Categories
-| Category | Examples | Priority |
-|----------|----------|----------|
-| Project Config | `.claude/CLAUDE.md`, `package.json`, `tsconfig.json` | High |
-| Type Definitions | `src/types/*.ts`, `*.d.ts` | High |
-| Related Modules | Parent/sibling modules with shared interfaces | Medium |
-| Test Files | Corresponding test files for modified code | Medium |
-| Documentation | `README.md`, `ARCHITECTURE.md` | Low |
-
-## 8. Plan Detection (Priority Order)
-
-### Priority 1: Workflow Session (IMPL_PLAN.md)
-```javascript
-// Check for active workflow session
-const manifest = await mcp__ccw-tools__session_manager({
-  operation: "list",
-  location: "active"
-});
-
-if (manifest.sessions?.length > 0) {
-  const session = manifest.sessions[0];
-  const plan = await mcp__ccw-tools__session_manager({
-    operation: "read",
-    session_id: session.id,
-    content_type: "plan"
-  });
-  sessionAnalysis.sessionId = session.id;
-  sessionAnalysis.executionPlan.source = "workflow";
-  sessionAnalysis.executionPlan.content = plan.content;
-}
-```
-
-### Priority 2: TodoWrite (Current Session Todos)
-```javascript
-// Extract from conversation - look for TodoWrite tool calls
-// Preserve COMPLETE todo list with all details
-const todos = extractTodosFromConversation();
-if (todos.length > 0) {
-  sessionAnalysis.executionPlan.source = "todo";
-  // Format todos with full context - preserve status markers
-  sessionAnalysis.executionPlan.content = todos.map(t =>
-    `- [${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '>' : ' '}] ${t.content}`
-  ).join('\n');
-}
-```
-
-### Priority 3: User-Stated Plan
-```javascript
-// Look for explicit plan statements in user messages:
-// - "Here's my plan: 1. ... 2. ... 3. ..."
-// - "I want to: first..., then..., finally..."
-// - Numbered or bulleted lists describing steps
-const userPlan = extractUserStatedPlan();
-if (userPlan) {
-  sessionAnalysis.executionPlan.source = "user-stated";
-  sessionAnalysis.executionPlan.content = userPlan;
-}
-```
-
-### Priority 4: Inferred Plan
-```javascript
-// If no explicit plan, infer from:
-// - Task description and breakdown discussion
-// - Sequence of actions taken
-// - Outstanding work mentioned
-const inferredPlan = inferPlanFromDiscussion();
-if (inferredPlan) {
-  sessionAnalysis.executionPlan.source = "inferred";
-  sessionAnalysis.executionPlan.content = inferredPlan;
-}
-```
-
-## 9. Notes
-
-- **Timing**: Execute at task completion or before context switch
-- **Frequency**: Once per independent task or milestone
-- **Recovery**: New session can immediately continue with full context
-- **Knowledge Graph**: Entity relationships auto-extracted for visualization
-- **Absolute Paths**: Critical for cross-session recovery on different machines

.claude/commands/memory/docs-full-cli.md

@@ -101,10 +101,10 @@ src/ (depth 1) → SINGLE STRATEGY
 Bash({command: "pwd && basename \"$(pwd)\" && git rev-parse --show-toplevel 2>/dev/null || pwd", run_in_background: false});
 
 // Get module structure with classification
-Bash({command: "ccw tool exec get_modules_by_depth '{\"format\":\"list\"}' | ccw tool exec classify_folders '{}'", run_in_background: false});
+Bash({command: "~/.claude/scripts/get_modules_by_depth.sh list | ~/.claude/scripts/classify-folders.sh", run_in_background: false});
 
 // OR with path parameter
-Bash({command: "cd <target-path> && ccw tool exec get_modules_by_depth '{\"format\":\"list\"}' | ccw tool exec classify_folders '{}'", run_in_background: false});
+Bash({command: "cd <target-path> && ~/.claude/scripts/get_modules_by_depth.sh list | ~/.claude/scripts/classify-folders.sh", run_in_background: false});
 ```
 
 **Parse output** `depth:N|path:<PATH>|type:<code|navigation>|...` to extract module paths, types, and count.
@@ -200,7 +200,7 @@ for (let layer of [3, 2, 1]) {
         let strategy = module.depth >= 3 ? "full" : "single";
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ccw tool exec generate_module_docs '{"strategy":"${strategy}","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
+            command: `cd ${module.path} && ~/.claude/scripts/generate_module_docs.sh "${strategy}" "." "${project_name}" "${tool}"`,
             run_in_background: false
           });
           if (bash_result.exit_code === 0) {
@@ -263,7 +263,7 @@ MODULES:
 
 TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
 
-EXECUTION SCRIPT: ccw tool exec generate_module_docs
+EXECUTION SCRIPT: ~/.claude/scripts/generate_module_docs.sh
   - Accepts strategy parameter: full | single
   - Accepts folder type detection: code | navigation
   - Tool execution via direct CLI commands (gemini/qwen/codex)
@@ -273,7 +273,7 @@ EXECUTION FLOW (for each module):
   1. Tool fallback loop (exit on first success):
      for tool in {{tool_1}} {{tool_2}} {{tool_3}}; do
        Bash({
-         command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"{{strategy}}","sourcePath":".","projectName":"{{project_name}}","tool":"${tool}"}'`,
+         command: `cd "{{module_path}}" && ~/.claude/scripts/generate_module_docs.sh "{{strategy}}" "." "{{project_name}}" "${tool}"`,
          run_in_background: false
        })
        exit_code=$?
@@ -322,7 +322,7 @@ let project_root = get_project_root();
 report("Generating project README.md...");
 for (let tool of tool_order) {
   Bash({
-    command: `cd ${project_root} && ccw tool exec generate_module_docs '{"strategy":"project-readme","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
+    command: `cd ${project_root} && ~/.claude/scripts/generate_module_docs.sh "project-readme" "." "${project_name}" "${tool}"`,
     run_in_background: false
   });
   if (bash_result.exit_code === 0) {
@@ -335,7 +335,7 @@ for (let tool of tool_order) {
 report("Generating ARCHITECTURE.md and EXAMPLES.md...");
 for (let tool of tool_order) {
   Bash({
-    command: `cd ${project_root} && ccw tool exec generate_module_docs '{"strategy":"project-architecture","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
+    command: `cd ${project_root} && ~/.claude/scripts/generate_module_docs.sh "project-architecture" "." "${project_name}" "${tool}"`,
     run_in_background: false
   });
   if (bash_result.exit_code === 0) {
@@ -350,7 +350,7 @@ if (bash_result.stdout.includes("API_FOUND")) {
   report("Generating HTTP API documentation...");
   for (let tool of tool_order) {
     Bash({
-      command: `cd ${project_root} && ccw tool exec generate_module_docs '{"strategy":"http-api","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
+      command: `cd ${project_root} && ~/.claude/scripts/generate_module_docs.sh "http-api" "." "${project_name}" "${tool}"`,
       run_in_background: false
     });
     if (bash_result.exit_code === 0) {

.claude/commands/memory/docs-related-cli.md

@@ -51,7 +51,7 @@ Orchestrates context-aware documentation generation/update for changed modules u
 Bash({command: "pwd && basename \"$(pwd)\" && git rev-parse --show-toplevel 2>/dev/null || pwd", run_in_background: false});
 
 // Detect changed modules
-Bash({command: "ccw tool exec detect_changed_modules '{\"format\":\"list\"}'", run_in_background: false});
+Bash({command: "~/.claude/scripts/detect_changed_modules.sh list", run_in_background: false});
 
 // Cache git changes
 Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
@@ -123,7 +123,7 @@ for (let depth of sorted_depths.reverse()) {  // N → 0
       return async () => {
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
+            command: `cd ${module.path} && ~/.claude/scripts/generate_module_docs.sh "single" "." "${project_name}" "${tool}"`,
             run_in_background: false
           });
           if (bash_result.exit_code === 0) {
@@ -207,21 +207,21 @@ EXECUTION:
 For each module above:
   1. Try tool 1:
      Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_1}}"}'`,
+       command: `cd "{{module_path}}" && ~/.claude/scripts/generate_module_docs.sh "single" "." "{{project_name}}" "{{tool_1}}"`,
        run_in_background: false
      })
      → Success: Report "✅ {{module_path}} docs generated with {{tool_1}}", proceed to next module
      → Failure: Try tool 2
   2. Try tool 2:
      Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_2}}"}'`,
+       command: `cd "{{module_path}}" && ~/.claude/scripts/generate_module_docs.sh "single" "." "{{project_name}}" "{{tool_2}}"`,
        run_in_background: false
      })
      → Success: Report "✅ {{module_path}} docs generated with {{tool_2}}", proceed to next module
      → Failure: Try tool 3
   3. Try tool 3:
      Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_3}}"}'`,
+       command: `cd "{{module_path}}" && ~/.claude/scripts/generate_module_docs.sh "single" "." "{{project_name}}" "{{tool_3}}"`,
        run_in_background: false
      })
      → Success: Report "✅ {{module_path}} docs generated with {{tool_3}}", proceed to next module

.claude/commands/memory/docs.md

@@ -85,10 +85,10 @@ bash(jq '. + {"target_path":"{target_path}","project_root":"{project_root}","pro
 
 ```bash
 # 1. Run folder analysis
-bash(ccw tool exec get_modules_by_depth '{}' | ccw tool exec classify_folders '{}')
+bash(~/.claude/scripts/get_modules_by_depth.sh | ~/.claude/scripts/classify-folders.sh)
 
 # 2. Get top-level directories (first 2 path levels)
-bash(ccw tool exec get_modules_by_depth '{}' | ccw tool exec classify_folders '{}' | awk -F'|' '{print $1}' | sed 's|^\./||' | awk -F'/' '{if(NF>=2) print $1"/"$2; else if(NF==1) print $1}' | sort -u)
+bash(~/.claude/scripts/get_modules_by_depth.sh | ~/.claude/scripts/classify-folders.sh | awk -F'|' '{print $1}' | sed 's|^\./||' | awk -F'/' '{if(NF>=2) print $1"/"$2; else if(NF==1) print $1}' | sort -u)
 
 # 3. Find existing docs (if directory exists)
 bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${project_name} -type f -name "*.md" ! -path "*/README.md" ! -path "*/ARCHITECTURE.md" ! -path "*/EXAMPLES.md" ! -path "*/api/*" 2>/dev/null; fi)
@@ -235,12 +235,12 @@ api_id=$((group_count + 3))
 | Mode | cli_execute | Placement | CLI MODE | Approval Flag | Agent Role |
 |------|-------------|-----------|----------|---------------|------------|
 | **Agent** | false | pre_analysis | analysis | (none) | Generate docs in implementation_approach |
-| **CLI** | true | implementation_approach | write | --mode write | Execute CLI commands, validate output |
+| **CLI** | true | implementation_approach | write | --approval-mode yolo | Execute CLI commands, validate output |
 
 **Command Patterns**:
-- Gemini/Qwen: `ccw cli -p "..." --tool gemini --mode analysis --cd dir`
-- CLI Mode: `ccw cli -p "..." --tool gemini --mode write --cd dir`
-- Codex: `ccw cli -p "..." --tool codex --mode write --cd dir`
+- Gemini/Qwen: `cd dir && gemini -p "..."`
+- CLI Mode: `cd dir && gemini --approval-mode yolo -p "..."`
+- Codex: `codex -C dir --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
 
 **Generation Process**:
 1. Read configuration values (tool, cli_execute, mode) from workflow-session.json
@@ -331,7 +331,7 @@ api_id=$((group_count + 3))
 {
   "step": 2,
   "title": "Batch generate documentation via CLI",
-  "command": "ccw cli -p 'PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure' --tool gemini --mode write --cd ${dirs_from_group}",
+  "command": "bash(dirs=$(jq -r '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories[]' ${session_dir}/.process/doc-planning-data.json); for dir in $dirs; do cd \"$dir\" && gemini --approval-mode yolo -p \"PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure\" || echo \"Failed: $dir\"; cd -; done)",
   "depends_on": [1],
   "output": "generated_docs"
 }
@@ -363,7 +363,7 @@ api_id=$((group_count + 3))
       },
       {
         "step": "analyze_project",
-        "command": "bash(ccw cli -p \"PURPOSE: Analyze project structure\\nTASK: Extract overview from modules\\nMODE: analysis\\nCONTEXT: [all_module_docs]\\nEXPECTED: Project outline\" --tool gemini --mode analysis)",
+        "command": "bash(gemini \"PURPOSE: Analyze project structure\\nTASK: Extract overview from modules\\nMODE: analysis\\nCONTEXT: [all_module_docs]\\nEXPECTED: Project outline\")",
         "output_to": "project_outline"
       }
     ],
@@ -403,7 +403,7 @@ api_id=$((group_count + 3))
     "pre_analysis": [
       {"step": "load_existing_docs", "command": "bash(cat .workflow/docs/${project_name}/{ARCHITECTURE,EXAMPLES}.md 2>/dev/null || echo 'No existing docs')", "output_to": "existing_arch_examples"},
       {"step": "load_all_docs", "command": "bash(cat .workflow/docs/${project_name}/README.md && find .workflow/docs/${project_name} -type f -name '*.md' ! -path '*/README.md' ! -path '*/ARCHITECTURE.md' ! -path '*/EXAMPLES.md' ! -path '*/api/*' | xargs cat)", "output_to": "all_docs"},
-      {"step": "analyze_architecture", "command": "bash(ccw cli -p \"PURPOSE: Analyze system architecture\\nTASK: Synthesize architectural overview and examples\\nMODE: analysis\\nCONTEXT: [all_docs]\\nEXPECTED: Architecture + Examples outline\" --tool gemini --mode analysis)", "output_to": "arch_examples_outline"}
+      {"step": "analyze_architecture", "command": "bash(gemini \"PURPOSE: Analyze system architecture\\nTASK: Synthesize architectural overview and examples\\nMODE: analysis\\nCONTEXT: [all_docs]\\nEXPECTED: Architecture + Examples outline\")", "output_to": "arch_examples_outline"}
     ],
     "implementation_approach": [
       {
@@ -440,7 +440,7 @@ api_id=$((group_count + 3))
     "pre_analysis": [
       {"step": "discover_api", "command": "bash(rg 'router\\.| @(Get|Post)' -g '*.{ts,js}')", "output_to": "endpoint_discovery"},
       {"step": "load_existing_api", "command": "bash(cat .workflow/docs/${project_name}/api/README.md 2>/dev/null || echo 'No existing API docs')", "output_to": "existing_api_docs"},
-      {"step": "analyze_api", "command": "bash(ccw cli -p \"PURPOSE: Document HTTP API\\nTASK: Analyze endpoints\\nMODE: analysis\\nCONTEXT: @src/api/**/* [endpoint_discovery]\\nEXPECTED: API outline\" --tool gemini --mode analysis)", "output_to": "api_outline"}
+      {"step": "analyze_api", "command": "bash(gemini \"PURPOSE: Document HTTP API\\nTASK: Analyze endpoints\\nMODE: analysis\\nCONTEXT: @src/api/**/* [endpoint_discovery]\\nEXPECTED: API outline\")", "output_to": "api_outline"}
     ],
     "implementation_approach": [
       {
@@ -601,7 +601,7 @@ api_id=$((group_count + 3))
 | Mode | CLI Placement | CLI MODE | Approval Flag | Agent Role |
 |------|---------------|----------|---------------|------------|
 | **Agent (default)** | pre_analysis | analysis | (none) | Generates documentation content |
-| **CLI (--cli-execute)** | implementation_approach | write | --mode write | Executes CLI commands, validates output |
+| **CLI (--cli-execute)** | implementation_approach | write | --approval-mode yolo | Executes CLI commands, validates output |
 
 **Execution Flow**:
 - **Phase 2**: Unified analysis once, results in `.process/`

.claude/commands/memory/load.md

@@ -5,7 +5,7 @@ argument-hint: "[--tool gemini|qwen] \"task context description\""
 allowed-tools: Task(*), Bash(*)
 examples:
   - /memory:load "在当前前端基础上开发用户认证功能"
-  - /memory:load --tool qwen "重构支付模块API"
+  - /memory:load --tool qwen -p "重构支付模块API"
 ---
 
 # Memory Load Command (/memory:load)
@@ -39,7 +39,7 @@ The command fully delegates to **universal-executor agent**, which autonomously:
 1. **Analyzes Project Structure**: Executes `get_modules_by_depth.sh` to understand architecture
 2. **Loads Documentation**: Reads CLAUDE.md, README.md and other key docs
 3. **Extracts Keywords**: Derives core keywords from task description
-4. **Discovers Files**: Uses CodexLens MCP or rg/find to locate relevant files
+4. **Discovers Files**: Uses MCP code-index or rg/find to locate relevant files
 5. **CLI Deep Analysis**: Executes Gemini/Qwen CLI for deep context analysis
 6. **Generates Content Package**: Returns structured JSON core content package
 
@@ -109,7 +109,7 @@ Task(
 
 1. **Project Structure**
    \`\`\`bash
-   bash(ccw tool exec get_modules_by_depth '{}')
+   bash(~/.claude/scripts/get_modules_by_depth.sh)
    \`\`\`
 
 2. **Core Documentation**
@@ -136,7 +136,7 @@ Task(
 Execute Gemini/Qwen CLI for deep analysis (saves main thread tokens):
 
 \`\`\`bash
-ccw cli -p "
+cd . && ${tool} -p "
 PURPOSE: Extract project core context for task: ${task_description}
 TASK: Analyze project architecture, tech stack, key patterns, relevant files
 MODE: analysis
@@ -147,7 +147,7 @@ RULES:
 - Identify key architecture patterns and technical constraints
 - Extract integration points and development standards
 - Output concise, structured format
-" --tool ${tool} --mode analysis
+"
 \`\`\`
 
 ### Step 4: Generate Core Content Package
@@ -212,7 +212,7 @@ Before returning:
 ### Example 2: Using Qwen Tool
 
 ```bash
-/memory:load --tool qwen "重构支付模块API"
+/memory:load --tool qwen -p "重构支付模块API"
 ```
 
 Agent uses Qwen CLI for analysis, returns same structured package.

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

@@ -1,773 +0,0 @@
----
-name: swagger-docs
-description: Generate complete Swagger/OpenAPI documentation following RESTful standards with global security, API details, error codes, and validation tests
-argument-hint: "[path] [--tool <gemini|qwen|codex>] [--format <yaml|json>] [--version <v3.0|v3.1>] [--lang <zh|en>]"
----
-
-# Swagger API Documentation Workflow (/memory:swagger-docs)
-
-## Overview
-
-Professional Swagger/OpenAPI documentation generator that strictly follows RESTful API design standards to produce enterprise-grade API documentation.
-
-**Core Features**:
-- **RESTful Standards**: Strict adherence to REST architecture and HTTP semantics
-- **Global Security**: Unified Authorization Token validation mechanism
-- **Complete API Docs**: Descriptions, methods, URLs, parameters for each endpoint
-- **Organized Structure**: Clear directory hierarchy by business domain
-- **Detailed Fields**: Type, required, example, description for each field
-- **Error Code Standards**: Unified error response format and code definitions
-- **Validation Tests**: Boundary conditions and exception handling tests
-
-**Output Structure** (--lang zh):
-```
-.workflow/docs/{project_name}/api/
-├── swagger.yaml              # Main OpenAPI spec file
-├── 概述/
-│   ├── README.md             # API overview
-│   ├── 认证说明.md           # Authentication guide
-│   ├── 错误码规范.md         # Error code definitions
-│   └── 版本历史.md           # Version history
-├── 用户模块/                 # Grouped by business domain
-│   ├── 用户认证.md
-│   ├── 用户管理.md
-│   └── 权限控制.md
-├── 业务模块/
-│   └── ...
-└── 测试报告/
-    ├── 接口测试.md           # API test results
-    └── 边界测试.md           # Boundary condition tests
-```
-
-**Output Structure** (--lang en):
-```
-.workflow/docs/{project_name}/api/
-├── swagger.yaml              # Main OpenAPI spec file
-├── overview/
-│   ├── README.md             # API overview
-│   ├── authentication.md     # Authentication guide
-│   ├── error-codes.md        # Error code definitions
-│   └── changelog.md          # Version history
-├── users/                    # Grouped by business domain
-│   ├── authentication.md
-│   ├── management.md
-│   └── permissions.md
-├── orders/
-│   └── ...
-└── test-reports/
-    ├── api-tests.md          # API test results
-    └── boundary-tests.md     # Boundary condition tests
-```
-
-## Parameters
-
-```bash
-/memory:swagger-docs [path] [--tool <gemini|qwen|codex>] [--format <yaml|json>] [--version <v3.0|v3.1>] [--lang <zh|en>]
-```
-
-- **path**: API source code directory (default: current directory)
-- **--tool**: CLI tool selection (default: gemini)
-  - `gemini`: Comprehensive analysis, pattern recognition
-  - `qwen`: Architecture analysis, system design
-  - `codex`: Implementation validation, code quality
-- **--format**: OpenAPI spec format (default: yaml)
-  - `yaml`: YAML format (recommended, better readability)
-  - `json`: JSON format
-- **--version**: OpenAPI version (default: v3.0)
-  - `v3.0`: OpenAPI 3.0.x
-  - `v3.1`: OpenAPI 3.1.0 (supports JSON Schema 2020-12)
-- **--lang**: Documentation language (default: zh)
-  - `zh`: Chinese documentation with Chinese directory names
-  - `en`: English documentation with English directory names
-
-## Planning Workflow
-
-### Phase 1: Initialize Session
-
-```bash
-# Get project info
-bash(pwd && basename "$(pwd)" && git rev-parse --show-toplevel 2>/dev/null || pwd && date +%Y%m%d-%H%M%S)
-```
-
-```javascript
-// Create swagger-docs session
-SlashCommand(command="/workflow:session:start --type swagger-docs --new \"{project_name}-swagger-{timestamp}\"")
-// Parse output to get sessionId
-```
-
-```bash
-# Update workflow-session.json
-bash(jq '. + {"target_path":"{target_path}","project_root":"{project_root}","project_name":"{project_name}","format":"yaml","openapi_version":"3.0.3","lang":"{lang}","tool":"gemini"}' .workflow/active/{sessionId}/workflow-session.json > tmp.json && mv tmp.json .workflow/active/{sessionId}/workflow-session.json)
-```
-
-### Phase 2: Scan API Endpoints
-
-**Discovery Patterns**: Auto-detect framework signatures and API definition styles.
-
-**Supported Frameworks**:
-| Framework | Detection Pattern | Example |
-|-----------|-------------------|---------|
-| Express.js | `router.get/post/put/delete` | `router.get('/users/:id')` |
-| Fastify | `fastify.route`, `@Route` | `fastify.get('/api/users')` |
-| NestJS | `@Controller`, `@Get/@Post` | `@Get('users/:id')` |
-| Koa | `router.get`, `ctx.body` | `router.get('/users')` |
-| Hono | `app.get/post`, `c.json` | `app.get('/users/:id')` |
-| FastAPI | `@app.get`, `@router.post` | `@app.get("/users/{id}")` |
-| Flask | `@app.route`, `@bp.route` | `@app.route('/users')` |
-| Spring | `@GetMapping`, `@PostMapping` | `@GetMapping("/users/{id}")` |
-| Go Gin | `r.GET`, `r.POST` | `r.GET("/users/:id")` |
-| Go Chi | `r.Get`, `r.Post` | `r.Get("/users/{id}")` |
-
-**Commands**:
-
-```bash
-# 1. Detect API framework type
-bash(
-  if rg -q "@Controller|@Get|@Post|@Put|@Delete" --type ts 2>/dev/null; then echo "NESTJS";
-  elif rg -q "router\.(get|post|put|delete|patch)" --type ts --type js 2>/dev/null; then echo "EXPRESS";
-  elif rg -q "fastify\.(get|post|route)" --type ts --type js 2>/dev/null; then echo "FASTIFY";
-  elif rg -q "@app\.(get|post|put|delete)" --type py 2>/dev/null; then echo "FASTAPI";
-  elif rg -q "@GetMapping|@PostMapping|@RequestMapping" --type java 2>/dev/null; then echo "SPRING";
-  elif rg -q 'r\.(GET|POST|PUT|DELETE)' --type go 2>/dev/null; then echo "GO_GIN";
-  else echo "UNKNOWN"; fi
-)
-
-# 2. Scan all API endpoint definitions
-bash(rg -n "(router|app|fastify)\.(get|post|put|delete|patch)|@(Get|Post|Put|Delete|Patch|Controller|RequestMapping)" --type ts --type js --type py --type java --type go -g '!*.test.*' -g '!*.spec.*' -g '!node_modules/**' 2>/dev/null | head -200)
-
-# 3. Extract route paths
-bash(rg -o "['\"](/api)?/[a-zA-Z0-9/:_-]+['\"]" --type ts --type js --type py -g '!*.test.*' 2>/dev/null | sort -u | head -100)
-
-# 4. Detect existing OpenAPI/Swagger files
-bash(find . -type f \( -name "swagger.yaml" -o -name "swagger.json" -o -name "openapi.yaml" -o -name "openapi.json" \) ! -path "*/node_modules/*" 2>/dev/null)
-
-# 5. Extract DTO/Schema definitions
-bash(rg -n "export (interface|type|class).*Dto|@ApiProperty|class.*Schema" --type ts -g '!*.test.*' 2>/dev/null | head -100)
-```
-
-**Data Processing**: Parse outputs, use **Write tool** to create `${session_dir}/.process/swagger-planning-data.json`:
-
-```json
-{
-  "metadata": {
-    "generated_at": "2025-01-01T12:00:00+08:00",
-    "project_name": "project_name",
-    "project_root": "/path/to/project",
-    "openapi_version": "3.0.3",
-    "format": "yaml",
-    "lang": "zh"
-  },
-  "framework": {
-    "type": "NESTJS",
-    "detected_patterns": ["@Controller", "@Get", "@Post"],
-    "base_path": "/api/v1"
-  },
-  "endpoints": [
-    {
-      "file": "src/modules/users/users.controller.ts",
-      "line": 25,
-      "method": "GET",
-      "path": "/api/v1/users/:id",
-      "handler": "getUser",
-      "controller": "UsersController"
-    }
-  ],
-  "existing_specs": {
-    "found": false,
-    "files": []
-  },
-  "dto_schemas": [
-    {
-      "name": "CreateUserDto",
-      "file": "src/modules/users/dto/create-user.dto.ts",
-      "properties": ["email", "password", "name"]
-    }
-  ],
-  "statistics": {
-    "total_endpoints": 45,
-    "by_method": {"GET": 20, "POST": 15, "PUT": 5, "DELETE": 5},
-    "by_module": {"users": 12, "auth": 8, "orders": 15, "products": 10}
-  }
-}
-```
-
-### Phase 3: Analyze API Structure
-
-**Commands**:
-
-```bash
-# 1. Analyze controller/route file structure
-bash(cat ${session_dir}/.process/swagger-planning-data.json | jq -r '.endpoints[].file' | sort -u | head -20)
-
-# 2. Extract request/response types
-bash(for f in $(jq -r '.dto_schemas[].file' ${session_dir}/.process/swagger-planning-data.json | head -20); do echo "=== $f ===" && cat "$f" 2>/dev/null; done)
-
-# 3. Analyze authentication middleware
-bash(rg -n "auth|guard|middleware|jwt|bearer|token" -i --type ts --type js -g '!*.test.*' -g '!node_modules/**' 2>/dev/null | head -50)
-
-# 4. Detect error handling patterns
-bash(rg -n "HttpException|BadRequest|Unauthorized|Forbidden|NotFound|throw new" --type ts --type js -g '!*.test.*' 2>/dev/null | head -50)
-```
-
-**Deep Analysis via Gemini CLI**:
-
-```bash
-ccw cli -p "
-PURPOSE: Analyze API structure and generate OpenAPI specification outline for comprehensive documentation
-TASK: 
-• Parse all API endpoints and identify business module boundaries
-• Extract request parameters, request bodies, and response formats
-• Identify authentication mechanisms and security requirements
-• Discover error handling patterns and error codes
-• Map endpoints to logical module groups
-MODE: analysis
-CONTEXT: @src/**/*.controller.ts @src/**/*.routes.ts @src/**/*.dto.ts @src/**/middleware/**/*
-EXPECTED: JSON format API structure analysis report with modules, endpoints, security schemes, and error codes
-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/memory/tech-research-rules.md

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

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

@@ -0,0 +1,477 @@
+---
+name: tech-research
+description: 3-phase orchestrator: extract tech stack from session/name → delegate to agent for Exa research and module generation → generate SKILL.md index (skips phase 2 if exists)
+argument-hint: "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*), Task(*)
+---
+
+# Tech Stack Research SKILL Generator
+
+## Overview
+
+**Pure Orchestrator with Agent Delegation**: Prepares context paths and delegates ALL work to agent. Agent produces files directly.
+
+**Auto-Continue Workflow**: Runs fully autonomously once triggered. Each phase completes and automatically triggers the next phase.
+
+**Execution Paths**:
+- **Full Path**: All 3 phases (no existing SKILL OR `--regenerate` specified)
+- **Skip Path**: Phase 1 → Phase 3 (existing SKILL found AND no `--regenerate` flag)
+- **Phase 3 Always Executes**: SKILL index is always generated or updated
+
+**Agent Responsibility**:
+- Agent does ALL the work: context reading, Exa research, content synthesis, file writing
+- Orchestrator only provides context paths and waits for completion
+
+## Core Rules
+
+1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
+2. **Context Path Delegation**: Pass session directory or tech stack name to agent, let agent do discovery
+3. **Agent Produces Files**: Agent directly writes all module files, orchestrator does NOT parse agent output
+4. **Auto-Continue**: After completing each phase, update TodoWrite and immediately execute next phase
+5. **No User Prompts**: Never ask user questions or wait for input between phases
+6. **Track Progress**: Update TodoWrite after EVERY phase completion before starting next phase
+7. **Lightweight Index**: Phase 3 only generates SKILL.md index by reading existing files
+
+---
+
+## 3-Phase Execution
+
+### Phase 1: Prepare Context Paths
+
+**Goal**: Detect input mode, prepare context paths for agent, check existing SKILL
+
+**Input Mode Detection**:
+```bash
+# Get input parameter
+input="$1"
+
+# Detect mode
+if [[ "$input" == WFS-* ]]; then
+  MODE="session"
+  SESSION_ID="$input"
+  CONTEXT_PATH=".workflow/${SESSION_ID}"
+else
+  MODE="direct"
+  TECH_STACK_NAME="$input"
+  CONTEXT_PATH="$input"  # Pass tech stack name as context
+fi
+```
+
+**Check Existing SKILL**:
+```bash
+# For session mode, peek at session to get tech stack name
+if [[ "$MODE" == "session" ]]; then
+  bash(test -f ".workflow/${SESSION_ID}/workflow-session.json")
+  Read(.workflow/${SESSION_ID}/workflow-session.json)
+  # Extract tech_stack_name (minimal extraction)
+fi
+
+# Normalize and check
+normalized_name=$(echo "$TECH_STACK_NAME" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
+bash(test -d ".claude/skills/${normalized_name}" && echo "exists" || echo "not_exists")
+bash(find ".claude/skills/${normalized_name}" -name "*.md" 2>/dev/null | wc -l || echo 0)
+```
+
+**Skip Decision**:
+```javascript
+if (existing_files > 0 && !regenerate_flag) {
+  SKIP_GENERATION = true
+  message = "Tech stack SKILL already exists, skipping Phase 2. Use --regenerate to force regeneration."
+} else if (regenerate_flag) {
+  bash(rm -rf ".claude/skills/${normalized_name}")
+  SKIP_GENERATION = false
+  message = "Regenerating tech stack SKILL from scratch."
+} else {
+  SKIP_GENERATION = false
+  message = "No existing SKILL found, generating new tech stack documentation."
+}
+```
+
+**Output Variables**:
+- `MODE`: `session` or `direct`
+- `SESSION_ID`: Session ID (if session mode)
+- `CONTEXT_PATH`: Path to session directory OR tech stack name
+- `TECH_STACK_NAME`: Extracted or provided tech stack name
+- `SKIP_GENERATION`: Boolean - whether to skip Phase 2
+
+**TodoWrite**:
+- If skipping: Mark phase 1 completed, phase 2 completed, phase 3 in_progress
+- If not skipping: Mark phase 1 completed, phase 2 in_progress
+
+---
+
+### Phase 2: Agent Produces All Files
+
+**Skip Condition**: Skipped if `SKIP_GENERATION = true`
+
+**Goal**: Delegate EVERYTHING to agent - context reading, Exa research, content synthesis, and file writing
+
+**Agent Task Specification**:
+
+```
+Task(
+  subagent_type: "general-purpose",
+  description: "Generate tech stack SKILL: {CONTEXT_PATH}",
+  prompt: "
+Generate a complete tech stack SKILL package with Exa research.
+
+**Context Provided**:
+- Mode: {MODE}
+- Context Path: {CONTEXT_PATH}
+
+**Templates Available**:
+- Module Format: ~/.claude/workflows/cli-templates/prompts/tech/tech-module-format.txt
+- SKILL Index: ~/.claude/workflows/cli-templates/prompts/tech/tech-skill-index.txt
+
+**Your Responsibilities**:
+
+1. **Extract Tech Stack Information**:
+
+   IF MODE == 'session':
+     - Read `.workflow/active/{session_id}/workflow-session.json`
+     - Read `.workflow/active/{session_id}/.process/context-package.json`
+     - Extract tech_stack: {language, frameworks, libraries}
+     - Build tech stack name: \"{language}-{framework1}-{framework2}\"
+     - Example: \"typescript-react-nextjs\"
+
+   IF MODE == 'direct':
+     - Tech stack name = CONTEXT_PATH
+     - Parse composite: split by '-' delimiter
+     - Example: \"typescript-react-nextjs\" → [\"typescript\", \"react\", \"nextjs\"]
+
+2. **Execute Exa Research** (4-6 parallel queries):
+
+   Base Queries (always execute):
+   - mcp__exa__get_code_context_exa(query: \"{tech} core principles best practices 2025\", tokensNum: 8000)
+   - mcp__exa__get_code_context_exa(query: \"{tech} common patterns architecture examples\", tokensNum: 7000)
+   - mcp__exa__web_search_exa(query: \"{tech} configuration setup tooling 2025\", numResults: 5)
+   - mcp__exa__get_code_context_exa(query: \"{tech} testing strategies\", tokensNum: 5000)
+
+   Component Queries (if composite):
+   - For each additional component:
+     mcp__exa__get_code_context_exa(query: \"{main_tech} {component} integration\", tokensNum: 5000)
+
+3. **Read Module Format Template**:
+
+   Read template for structure guidance:
+   ```bash
+   Read(~/.claude/workflows/cli-templates/prompts/tech/tech-module-format.txt)
+   ```
+
+4. **Synthesize Content into 6 Modules**:
+
+   Follow template structure from tech-module-format.txt:
+   - **principles.md** - Core concepts, philosophies (~3K tokens)
+   - **patterns.md** - Implementation patterns with code examples (~5K tokens)
+   - **practices.md** - Best practices, anti-patterns, pitfalls (~4K tokens)
+   - **testing.md** - Testing strategies, frameworks (~3K tokens)
+   - **config.md** - Setup, configuration, tooling (~3K tokens)
+   - **frameworks.md** - Framework integration (only if composite, ~4K tokens)
+
+   Each module follows template format:
+   - Frontmatter (YAML)
+   - Main sections with clear headings
+   - Code examples from Exa research
+   - Best practices sections
+   - References to Exa sources
+
+5. **Write Files Directly**:
+
+   ```javascript
+   // Create directory
+   bash(mkdir -p \".claude/skills/{tech_stack_name}\")
+
+   // Write each module file using Write tool
+   Write({ file_path: \".claude/skills/{tech_stack_name}/principles.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/patterns.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/practices.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/testing.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/config.md\", content: ... })
+   // Write frameworks.md only if composite
+
+   // Write metadata.json
+   Write({
+     file_path: \".claude/skills/{tech_stack_name}/metadata.json\",
+     content: JSON.stringify({
+       tech_stack_name,
+       components,
+       is_composite,
+       generated_at: timestamp,
+       source: \"exa-research\",
+       research_summary: { total_queries, total_sources }
+     })
+   })
+   ```
+
+6. **Report Completion**:
+
+   Provide summary:
+   - Tech stack name
+   - Files created (count)
+   - Exa queries executed
+   - Sources consulted
+
+**CRITICAL**:
+- MUST read external template files before generating content (step 3 for modules, step 4 for index)
+- You have FULL autonomy - read files, execute Exa, synthesize content, write files
+- Do NOT return JSON or structured data - produce actual .md files
+- Handle errors gracefully (Exa failures, missing files, template read failures)
+- If tech stack cannot be determined, ask orchestrator to clarify
+  "
+)
+```
+
+**Completion Criteria**:
+- Agent task executed successfully
+- 5-6 modular files written to `.claude/skills/{tech_stack_name}/`
+- metadata.json written
+- Agent reports completion
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+---
+
+### Phase 3: Generate SKILL.md Index
+
+**Note**: This phase **ALWAYS executes** - generates or updates the SKILL index.
+
+**Goal**: Read generated module files and create SKILL.md index with loading recommendations
+
+**Steps**:
+
+1. **Verify Generated Files**:
+   ```bash
+   bash(find ".claude/skills/${TECH_STACK_NAME}" -name "*.md" -type f | sort)
+   ```
+
+2. **Read metadata.json**:
+   ```javascript
+   Read(.claude/skills/${TECH_STACK_NAME}/metadata.json)
+   // Extract: tech_stack_name, components, is_composite, research_summary
+   ```
+
+3. **Read Module Headers** (optional, first 20 lines):
+   ```javascript
+   Read(.claude/skills/${TECH_STACK_NAME}/principles.md, limit: 20)
+   // Repeat for other modules
+   ```
+
+4. **Read SKILL Index Template**:
+
+   ```javascript
+   Read(~/.claude/workflows/cli-templates/prompts/tech/tech-skill-index.txt)
+   ```
+
+5. **Generate SKILL.md Index**:
+
+   Follow template from tech-skill-index.txt with variable substitutions:
+   - `{TECH_STACK_NAME}`: From metadata.json
+   - `{MAIN_TECH}`: Primary technology
+   - `{ISO_TIMESTAMP}`: Current timestamp
+   - `{QUERY_COUNT}`: From research_summary
+   - `{SOURCE_COUNT}`: From research_summary
+   - Conditional sections for composite tech stacks
+
+   Template provides structure for:
+   - Frontmatter with metadata
+   - Overview and tech stack description
+   - Module organization (Core/Practical/Config sections)
+   - Loading recommendations (Quick/Implementation/Complete)
+   - Usage guidelines and auto-trigger keywords
+   - Research metadata and version history
+
+6. **Write SKILL.md**:
+   ```javascript
+   Write({
+     file_path: `.claude/skills/${TECH_STACK_NAME}/SKILL.md`,
+     content: generatedIndexMarkdown
+   })
+   ```
+
+**Completion Criteria**:
+- SKILL.md index written
+- All module files verified
+- Loading recommendations included
+
+**TodoWrite**: Mark phase 3 completed
+
+**Final Report**:
+```
+Tech Stack SKILL Package Complete
+
+Tech Stack: {TECH_STACK_NAME}
+Location: .claude/skills/{TECH_STACK_NAME}/
+
+Files: SKILL.md + 5-6 modules + metadata.json
+Exa Research: {queries} queries, {sources} sources
+
+Usage: Skill(command: "{TECH_STACK_NAME}")
+```
+
+---
+
+## Implementation Details
+
+### TodoWrite Patterns
+
+**Initialization** (Before Phase 1):
+```javascript
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "in_progress", "activeForm": "Preparing context paths"},
+  {"content": "Agent produces all module files", "status": "pending", "activeForm": "Agent producing files"},
+  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL index"}
+]})
+```
+
+**Full Path** (SKIP_GENERATION = false):
+```javascript
+// After Phase 1
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "in_progress", ...},
+  {"content": "Generate SKILL.md index", "status": "pending", ...}
+]})
+
+// After Phase 2
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "completed", ...},
+  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
+]})
+
+// After Phase 3
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "completed", ...},
+  {"content": "Generate SKILL.md index", "status": "completed", ...}
+]})
+```
+
+**Skip Path** (SKIP_GENERATION = true):
+```javascript
+// After Phase 1 (skip Phase 2)
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "completed", ...},  // Skipped
+  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
+]})
+```
+
+### Execution Flow
+
+**Full Path**:
+```
+User → TodoWrite Init → Phase 1 (prepare) → Phase 2 (agent writes files) → Phase 3 (write index) → Report
+```
+
+**Skip Path**:
+```
+User → TodoWrite Init → Phase 1 (detect existing) → Phase 3 (update index) → Report
+```
+
+### Error Handling
+
+**Phase 1 Errors**:
+- Invalid session ID: Report error, verify session exists
+- Missing context-package: Warn, fall back to direct mode
+- No tech stack detected: Ask user to specify tech stack name
+
+**Phase 2 Errors (Agent)**:
+- Agent task fails: Retry once, report if fails again
+- Exa API failures: Agent handles internally with retries
+- Incomplete results: Warn user, proceed with partial data if minimum sections available
+
+**Phase 3 Errors**:
+- Write failures: Report which files failed
+- Missing files: Note in SKILL.md, suggest regeneration
+
+---
+
+## Parameters
+
+```bash
+/memory:tech-research [session-id | "tech-stack-name"] [--regenerate] [--tool <gemini|qwen>]
+```
+
+**Arguments**:
+- **session-id | tech-stack-name**: Input source (auto-detected by WFS- prefix)
+  - Session mode: `WFS-user-auth-v2` - Extract tech stack from workflow
+  - Direct mode: `"typescript"`, `"typescript-react-nextjs"` - User specifies
+- **--regenerate**: Force regenerate existing SKILL (deletes and recreates)
+- **--tool**: Reserved for future CLI integration (default: gemini)
+
+---
+
+## Examples
+
+**Generated File Structure** (for all examples):
+```
+.claude/skills/{tech-stack}/
+├── SKILL.md           # Index (Phase 3)
+├── principles.md      # Agent (Phase 2)
+├── patterns.md        # Agent
+├── practices.md       # Agent
+├── testing.md         # Agent
+├── config.md          # Agent
+├── frameworks.md      # Agent (if composite)
+└── metadata.json      # Agent
+```
+
+### Direct Mode - Single Stack
+
+```bash
+/memory:tech-research "typescript"
+```
+
+**Workflow**:
+1. Phase 1: Detects direct mode, checks existing SKILL
+2. Phase 2: Agent executes 4 Exa queries, writes 5 modules
+3. Phase 3: Generates SKILL.md index
+
+### Direct Mode - Composite Stack
+
+```bash
+/memory:tech-research "typescript-react-nextjs"
+```
+
+**Workflow**:
+1. Phase 1: Decomposes into ["typescript", "react", "nextjs"]
+2. Phase 2: Agent executes 6 Exa queries (4 base + 2 components), writes 6 modules (adds frameworks.md)
+3. Phase 3: Generates SKILL.md index with framework integration
+
+### Session Mode - Extract from Workflow
+
+```bash
+/memory:tech-research WFS-user-auth-20251104
+```
+
+**Workflow**:
+1. Phase 1: Reads session, extracts tech stack: `python-fastapi-sqlalchemy`
+2. Phase 2: Agent researches Python + FastAPI + SQLAlchemy, writes 6 modules
+3. Phase 3: Generates SKILL.md index
+
+### Regenerate Existing
+
+```bash
+/memory:tech-research "react" --regenerate
+```
+
+**Workflow**:
+1. Phase 1: Deletes existing SKILL due to --regenerate
+2. Phase 2: Agent executes fresh Exa research (latest 2025 practices)
+3. Phase 3: Generates updated SKILL.md
+
+### Skip Path - Fast Update
+
+```bash
+/memory:tech-research "python"
+```
+
+**Scenario**: SKILL already exists with 7 files
+
+**Workflow**:
+1. Phase 1: Detects existing SKILL, sets SKIP_GENERATION = true
+2. Phase 2: **SKIPPED**
+3. Phase 3: Updates SKILL.md index only (5-10x faster)
+
+

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

@@ -99,10 +99,10 @@ src/ (depth 1) → SINGLE-LAYER STRATEGY
 Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
 
 // Get module structure
-Bash({command: "ccw tool exec get_modules_by_depth '{\"format\":\"list\"}'", run_in_background: false});
+Bash({command: "~/.claude/scripts/get_modules_by_depth.sh list", run_in_background: false});
 
 // OR with --path
-Bash({command: "cd <target-path> && ccw tool exec get_modules_by_depth '{\"format\":\"list\"}'", run_in_background: false});
+Bash({command: "cd <target-path> && ~/.claude/scripts/get_modules_by_depth.sh list", run_in_background: false});
 ```
 
 **Parse output** `depth:N|path:<PATH>|...` to extract module paths and count.
@@ -185,7 +185,7 @@ for (let layer of [3, 2, 1]) {
         let strategy = module.depth >= 3 ? "multi-layer" : "single-layer";
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ccw tool exec update_module_claude '{"strategy":"${strategy}","path":".","tool":"${tool}"}'`,
+            command: `cd ${module.path} && ~/.claude/scripts/update_module_claude.sh "${strategy}" "." "${tool}"`,
             run_in_background: false
           });
           if (bash_result.exit_code === 0) {
@@ -244,7 +244,7 @@ MODULES:
 
 TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
 
-EXECUTION SCRIPT: ccw tool exec update_module_claude
+EXECUTION SCRIPT: ~/.claude/scripts/update_module_claude.sh
   - Accepts strategy parameter: multi-layer | single-layer
   - Tool execution via direct CLI commands (gemini/qwen/codex)
 
@@ -252,7 +252,7 @@ EXECUTION FLOW (for each module):
   1. Tool fallback loop (exit on first success):
      for tool in {{tool_1}} {{tool_2}} {{tool_3}}; do
        Bash({
-         command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"{{strategy}}","path":".","tool":"${tool}"}'`,
+         command: `cd "{{module_path}}" && ~/.claude/scripts/update_module_claude.sh "{{strategy}}" "." "${tool}"`,
          run_in_background: false
        })
        exit_code=$?

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

@@ -41,7 +41,7 @@ Orchestrates context-aware CLAUDE.md updates for changed modules using batched a
 
 ```javascript
 // Detect changed modules
-Bash({command: "ccw tool exec detect_changed_modules '{\"format\":\"list\"}'", run_in_background: false});
+Bash({command: "~/.claude/scripts/detect_changed_modules.sh list", run_in_background: false});
 
 // Cache git changes
 Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
@@ -102,7 +102,7 @@ for (let depth of sorted_depths.reverse()) {  // N → 0
       return async () => {
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"${tool}"}'`,
+            command: `cd ${module.path} && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "${tool}"`,
             run_in_background: false
           });
           if (bash_result.exit_code === 0) {
@@ -184,21 +184,21 @@ EXECUTION:
 For each module above:
   1. Try tool 1:
      Bash({
-       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_1}}"}'`,
+       command: `cd "{{module_path}}" && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "{{tool_1}}"`,
        run_in_background: false
      })
      → Success: Report "✅ {{module_path}} updated with {{tool_1}}", proceed to next module
      → Failure: Try tool 2
   2. Try tool 2:
      Bash({
-       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_2}}"}'`,
+       command: `cd "{{module_path}}" && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "{{tool_2}}"`,
        run_in_background: false
      })
      → Success: Report "✅ {{module_path}} updated with {{tool_2}}", proceed to next module
      → Failure: Try tool 3
   3. Try tool 3:
      Bash({
-       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_3}}"}'`,
+       command: `cd "{{module_path}}" && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "{{tool_3}}"`,
        run_in_background: false
      })
      → Success: Report "✅ {{module_path}} updated with {{tool_3}}", proceed to next module

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

@@ -187,7 +187,7 @@ Objectives:
 
 3. Use Gemini for aggregation (optional):
    Command pattern:
-   ccw cli -p "
+   cd .workflow/.archives/{session_id} && gemini -p "
    PURPOSE: Extract lessons and conflicts from workflow session
    TASK:
    • Analyze IMPL_PLAN and lessons from manifest
@@ -198,7 +198,7 @@ Objectives:
    CONTEXT: @IMPL_PLAN.md @workflow-session.json
    EXPECTED: Structured lessons and conflicts in JSON format
    RULES: Template reference from skill-aggregation.txt
-   " --tool gemini --mode analysis --cd .workflow/.archives/{session_id}
+   "
 
 3.5. **Generate SKILL.md Description** (CRITICAL for auto-loading):
 
@@ -334,7 +334,7 @@ Objectives:
    - Sort sessions by date
 
 2. Use Gemini for final aggregation:
-   ccw cli -p "
+   gemini -p "
    PURPOSE: Aggregate lessons and conflicts from all workflow sessions
    TASK:
    • Group successes by functional domain
@@ -345,7 +345,7 @@ Objectives:
    CONTEXT: [Provide aggregated JSON data]
    EXPECTED: Final aggregated structure for SKILL documents
    RULES: Template reference from skill-aggregation.txt
-   " --tool gemini --mode analysis
+   "
 
 3. Read templates for formatting (same 4 templates as single mode)
 

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

@@ -81,7 +81,6 @@ ELSE:
 **Framework-Based Analysis** (when guidance-specification.md exists):
 ```bash
 Task(subagent_type="conceptual-planning-agent",
-     run_in_background=false,
      prompt="Generate API designer analysis addressing topic framework
 
      ## Framework Integration Required
@@ -137,7 +136,6 @@ Task(subagent_type="conceptual-planning-agent",
 # For existing analysis updates
 IF update_mode = "incremental":
     Task(subagent_type="conceptual-planning-agent",
-         run_in_background=false,
          prompt="Update existing API designer analysis
 
          ## Current Analysis Context

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

@@ -128,7 +128,6 @@ for (let i = 0; i < allQuestions.length; i += BATCH_SIZE) {
 ```javascript
 Task(
   subagent_type="context-search-agent",
-  run_in_background=false,
   description="Gather project context for brainstorm",
   prompt=`
 Execute context-search-agent in BRAINSTORM MODE (Phase 1-2 only).

.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**: Executes 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
+**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.
 
 **Task Attachment Model**:
-- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
-- Task agent execute **attaches analysis tasks** to orchestrator's TodoWrite
+- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
+- Task agent dispatch **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. **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
+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
 
 **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 execute Phase 1 command
+1. **Start Immediately**: First action is TodoWrite initialization, second action is dispatch 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 execute next pending phase automatically
+4. **Auto-Continue via TodoList**: Check TodoList status to dispatch next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-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
+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
 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: Execute** - Interactive framework generation via artifacts command
+**Step 1: Dispatch** - 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 executed - tasks attached)**:
+**TodoWrite Update (Phase 1 SlashCommand dispatched - 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 execute **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand dispatch **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 Execute**:
+**Parallel Dispatch**:
 - 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 executed - tasks attached in parallel)**:
+**TodoWrite Update (Phase 2 agents dispatched - 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 executes **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
+**Note**: Multiple Task dispatches **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: Execute** - Synthesis integration via synthesis command
+**Step 3: Dispatch** - 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 executed - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand dispatched - 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 execute **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand dispatch **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 executed):
+1. **Task Attachment** (when SlashCommand/Task dispatched):
    - 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 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.
+**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.
 
 ### Brainstorming Workflow Specific Features
 

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

@@ -81,7 +81,6 @@ ELSE:
 **Framework-Based Analysis** (when guidance-specification.md exists):
 ```bash
 Task(subagent_type="conceptual-planning-agent",
-     run_in_background=false,
      prompt="Generate system architect analysis addressing topic framework
 
      ## Framework Integration Required
@@ -137,7 +136,6 @@ Task(subagent_type="conceptual-planning-agent",
 # For existing analysis updates
 IF update_mode = "incremental":
     Task(subagent_type="conceptual-planning-agent",
-         run_in_background=false,
          prompt="Update existing system architect analysis
 
          ## Current Analysis Context

.claude/commands/workflow/clean.md

@@ -1,516 +0,0 @@
----
-name: clean
-description: Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution
-argument-hint: "[--dry-run] [\"focus area\"]"
-allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Glob(*), Bash(*), Write(*)
----
-
-# Clean Command (/workflow:clean)
-
-## Overview
-
-Intelligent cleanup command that explores the codebase to identify the development mainline, discovers artifacts that have drifted from it, and safely removes stale sessions, abandoned documents, and dead code.
-
-**Core capabilities:**
-- Mainline detection: Identify active development branches and core modules
-- Drift analysis: Find sessions, documents, and code that deviate from mainline
-- Intelligent discovery: cli-explore-agent based artifact scanning
-- Safe execution: Confirmation-based cleanup with dry-run preview
-
-## Usage
-
-```bash
-/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
-
-```
-Phase 1: Mainline Detection
-   ├─ Analyze git history for development trends
-   ├─ Identify core modules (high commit frequency)
-   ├─ Map active vs stale branches
-   └─ Build mainline profile
-
-Phase 2: Drift Discovery (cli-explore-agent)
-   ├─ Scan workflow sessions for orphaned artifacts
-   ├─ Identify documents drifted from mainline
-   ├─ Detect dead code and unused exports
-   └─ Generate cleanup manifest
-
-Phase 3: Confirmation
-   ├─ Display cleanup summary by category
-   ├─ Show impact analysis (files, size, risk)
-   └─ AskUserQuestion: Select categories to clean
-
-Phase 4: Execution (unless --dry-run)
-   ├─ Execute cleanup by category
-   ├─ Update manifests and indexes
-   └─ Report results
-```
-
-## Implementation
-
-### Phase 1: Mainline Detection
-
-**Session Setup**:
-```javascript
-const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
-
-const dateStr = getUtc8ISOString().substring(0, 10)
-const sessionId = `clean-${dateStr}`
-const sessionFolder = `.workflow/.clean/${sessionId}`
-
-Bash(`mkdir -p ${sessionFolder}`)
-```
-
-**Step 1.1: Git History Analysis**
-```bash
-# Get commit frequency by directory (last 30 days)
-bash(git log --since="30 days ago" --name-only --pretty=format: | grep -v "^$" | cut -d/ -f1-2 | sort | uniq -c | sort -rn | head -20)
-
-# Get recent active branches
-bash(git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname:short) %(committerdate:relative)' | head -10)
-
-# Get files with most recent changes
-bash(git log --since="7 days ago" --name-only --pretty=format: | grep -v "^$" | sort | uniq -c | sort -rn | head -30)
-```
-
-**Step 1.2: Build Mainline Profile**
-```javascript
-const mainlineProfile = {
-  coreModules: [],        // High-frequency directories
-  activeFiles: [],        // Recently modified files
-  activeBranches: [],     // Branches with recent commits
-  staleThreshold: {
-    sessions: 7,          // Days
-    branches: 30,
-    documents: 14
-  },
-  timestamp: getUtc8ISOString()
-}
-
-// Parse git log output to identify core modules
-// Modules with >5 commits in last 30 days = core
-// Modules with 0 commits in last 30 days = potentially stale
-
-Write(`${sessionFolder}/mainline-profile.json`, JSON.stringify(mainlineProfile, null, 2))
-```
-
----
-
-### Phase 2: Drift Discovery
-
-**Launch cli-explore-agent for intelligent artifact scanning**:
-
-```javascript
-Task(
-  subagent_type="cli-explore-agent",
-  run_in_background=false,
-  description="Discover stale artifacts",
-  prompt=`
-## Task Objective
-Discover artifacts that have drifted from the development mainline. Identify stale sessions, abandoned documents, and dead code for cleanup.
-
-## Context
-- **Session Folder**: ${sessionFolder}
-- **Mainline Profile**: ${sessionFolder}/mainline-profile.json
-- **Focus Area**: ${focusArea || "全项目"}
-
-## Discovery Categories
-
-### Category 1: Stale Workflow Sessions
-Scan and analyze workflow session directories:
-
-**Locations to scan**:
-- .workflow/active/WFS-* (active sessions)
-- .workflow/archives/WFS-* (archived sessions)
-- .workflow/.lite-plan/* (lite-plan sessions)
-- .workflow/.debug/DBG-* (debug sessions)
-
-**Staleness criteria**:
-- Active sessions: No modification >7 days + no related git commits
-- Archives: >30 days old + no feature references in project.json
-- Lite-plan: >7 days old + plan.json not executed
-- Debug: >3 days old + issue not in recent commits
-
-**Analysis steps**:
-1. List all session directories with modification times
-2. Cross-reference with git log (are session topics in recent commits?)
-3. Check manifest.json for orphan entries
-4. Identify sessions with .archiving marker (interrupted)
-
-### Category 2: Drifted Documents
-Scan documentation that no longer aligns with code:
-
-**Locations to scan**:
-- .claude/rules/tech/* (generated tech rules)
-- .workflow/.scratchpad/* (temporary notes)
-- **/CLAUDE.md (module documentation)
-- **/README.md (outdated descriptions)
-
-**Drift criteria**:
-- Tech rules: Referenced files no longer exist
-- Scratchpad: Any file (always temporary)
-- Module docs: Describe functions/classes that were removed
-- READMEs: Reference deleted directories
-
-**Analysis steps**:
-1. Parse document content for file/function references
-2. Verify referenced entities still exist in codebase
-3. Flag documents with >30% broken references
-
-### Category 3: Dead Code
-Identify code that is no longer used:
-
-**Scan patterns**:
-- Unused exports (exported but never imported)
-- Orphan files (not imported anywhere)
-- Commented-out code blocks (>10 lines)
-- TODO/FIXME comments >90 days old
-
-**Analysis steps**:
-1. Build import graph using rg/grep
-2. Identify exports with no importers
-3. Find files not in import graph
-4. Scan for large comment blocks
-
-## Output Format
-
-Write to: ${sessionFolder}/cleanup-manifest.json
-
-\`\`\`json
-{
-  "generated_at": "ISO timestamp",
-  "mainline_summary": {
-    "core_modules": ["src/core", "src/api"],
-    "active_branches": ["main", "feature/auth"],
-    "health_score": 0.85
-  },
-  "discoveries": {
-    "stale_sessions": [
-      {
-        "path": ".workflow/active/WFS-old-feature",
-        "type": "active",
-        "age_days": 15,
-        "reason": "No related commits in 15 days",
-        "size_kb": 1024,
-        "risk": "low"
-      }
-    ],
-    "drifted_documents": [
-      {
-        "path": ".claude/rules/tech/deprecated-lib",
-        "type": "tech_rules",
-        "broken_references": 5,
-        "total_references": 6,
-        "drift_percentage": 83,
-        "reason": "Referenced library removed",
-        "risk": "low"
-      }
-    ],
-    "dead_code": [
-      {
-        "path": "src/utils/legacy.ts",
-        "type": "orphan_file",
-        "reason": "Not imported by any file",
-        "last_modified": "2025-10-01",
-        "risk": "medium"
-      }
-    ]
-  },
-  "summary": {
-    "total_items": 12,
-    "total_size_mb": 45.2,
-    "by_category": {
-      "stale_sessions": 5,
-      "drifted_documents": 4,
-      "dead_code": 3
-    },
-    "by_risk": {
-      "low": 8,
-      "medium": 3,
-      "high": 1
-    }
-  }
-}
-\`\`\`
-
-## Execution Commands
-
-\`\`\`bash
-# Session directories
-find .workflow -type d -name "WFS-*" -o -name "DBG-*" 2>/dev/null
-
-# Check modification times (Linux/Mac)
-stat -c "%Y %n" .workflow/active/WFS-* 2>/dev/null
-
-# Check modification times (Windows PowerShell via bash)
-powershell -Command "Get-ChildItem '.workflow/active/WFS-*' | ForEach-Object { Write-Output \"$($_.LastWriteTime) $($_.FullName)\" }"
-
-# Find orphan exports (TypeScript)
-rg "export (const|function|class|interface|type)" --type ts -l
-
-# Find imports
-rg "import.*from" --type ts
-
-# Find large comment blocks
-rg "^\\s*/\\*" -A 10 --type ts
-
-# Find old TODOs
-rg "TODO|FIXME" --type ts -n
-\`\`\`
-
-## Success Criteria
-- [ ] All session directories scanned with age calculation
-- [ ] Documents cross-referenced with existing code
-- [ ] Dead code detection via import graph analysis
-- [ ] cleanup-manifest.json written with complete data
-- [ ] Each item has risk level and cleanup reason
-`
-)
-```
-
----
-
-### Phase 3: Confirmation
-
-**Step 3.1: Display Summary**
-```javascript
-const manifest = JSON.parse(Read(`${sessionFolder}/cleanup-manifest.json`))
-
-console.log(`
-## Cleanup Discovery Report
-
-**Mainline Health**: ${Math.round(manifest.mainline_summary.health_score * 100)}%
-**Core Modules**: ${manifest.mainline_summary.core_modules.join(', ')}
-
-### Summary
-| Category | Count | Size | Risk |
-|----------|-------|------|------|
-| Stale Sessions | ${manifest.summary.by_category.stale_sessions} | - | ${getRiskSummary('sessions')} |
-| Drifted Documents | ${manifest.summary.by_category.drifted_documents} | - | ${getRiskSummary('documents')} |
-| Dead Code | ${manifest.summary.by_category.dead_code} | - | ${getRiskSummary('code')} |
-
-**Total**: ${manifest.summary.total_items} items, ~${manifest.summary.total_size_mb} MB
-
-### Stale Sessions
-${manifest.discoveries.stale_sessions.map(s =>
-  `- ${s.path} (${s.age_days}d, ${s.risk}): ${s.reason}`
-).join('\n')}
-
-### Drifted Documents
-${manifest.discoveries.drifted_documents.map(d =>
-  `- ${d.path} (${d.drift_percentage}% broken, ${d.risk}): ${d.reason}`
-).join('\n')}
-
-### Dead Code
-${manifest.discoveries.dead_code.map(c =>
-  `- ${c.path} (${c.type}, ${c.risk}): ${c.reason}`
-).join('\n')}
-`)
-```
-
-**Step 3.2: Dry-Run Exit**
-```javascript
-if (flags.includes('--dry-run')) {
-  console.log(`
----
-**Dry-run mode**: No changes made.
-Manifest saved to: ${sessionFolder}/cleanup-manifest.json
-
-To execute cleanup: /workflow:clean
-`)
-  return
-}
-```
-
-**Step 3.3: User Confirmation**
-```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: "Which categories to clean?",
-      header: "Categories",
-      multiSelect: true,
-      options: [
-        {
-          label: "Sessions",
-          description: `${manifest.summary.by_category.stale_sessions} stale workflow sessions`
-        },
-        {
-          label: "Documents",
-          description: `${manifest.summary.by_category.drifted_documents} drifted documents`
-        },
-        {
-          label: "Dead Code",
-          description: `${manifest.summary.by_category.dead_code} unused code files`
-        }
-      ]
-    },
-    {
-      question: "Risk level to include?",
-      header: "Risk",
-      multiSelect: false,
-      options: [
-        { label: "Low only", description: "Safest - only obviously stale items" },
-        { label: "Low + Medium", description: "Recommended - includes likely unused items" },
-        { label: "All", description: "Aggressive - includes high-risk items" }
-      ]
-    }
-  ]
-})
-```
-
----
-
-### Phase 4: Execution
-
-**Step 4.1: Filter Items by Selection**
-```javascript
-const selectedCategories = userSelection.categories  // ['Sessions', 'Documents', ...]
-const riskLevel = userSelection.risk                 // 'Low only', 'Low + Medium', 'All'
-
-const riskFilter = {
-  'Low only': ['low'],
-  'Low + Medium': ['low', 'medium'],
-  'All': ['low', 'medium', 'high']
-}[riskLevel]
-
-const itemsToClean = []
-
-if (selectedCategories.includes('Sessions')) {
-  itemsToClean.push(...manifest.discoveries.stale_sessions.filter(s => riskFilter.includes(s.risk)))
-}
-if (selectedCategories.includes('Documents')) {
-  itemsToClean.push(...manifest.discoveries.drifted_documents.filter(d => riskFilter.includes(d.risk)))
-}
-if (selectedCategories.includes('Dead Code')) {
-  itemsToClean.push(...manifest.discoveries.dead_code.filter(c => riskFilter.includes(c.risk)))
-}
-
-TodoWrite({
-  todos: itemsToClean.map(item => ({
-    content: `Clean: ${item.path}`,
-    status: "pending",
-    activeForm: `Cleaning ${item.path}`
-  }))
-})
-```
-
-**Step 4.2: Execute Cleanup**
-```javascript
-const results = { deleted: [], failed: [], skipped: [] }
-
-for (const item of itemsToClean) {
-  TodoWrite({ todos: [...] })  // Mark current as in_progress
-
-  try {
-    if (item.type === 'orphan_file' || item.type === 'dead_export') {
-      // Dead code: Delete file or remove export
-      Bash({ command: `rm -rf "${item.path}"` })
-    } else {
-      // Sessions and documents: Delete directory/file
-      Bash({ command: `rm -rf "${item.path}"` })
-    }
-
-    results.deleted.push(item.path)
-    TodoWrite({ todos: [...] })  // Mark as completed
-  } catch (error) {
-    results.failed.push({ path: item.path, error: error.message })
-  }
-}
-```
-
-**Step 4.3: Update Manifests**
-```javascript
-// Update archives manifest if sessions were deleted
-if (selectedCategories.includes('Sessions')) {
-  const archiveManifestPath = '.workflow/archives/manifest.json'
-  if (fileExists(archiveManifestPath)) {
-    const archiveManifest = JSON.parse(Read(archiveManifestPath))
-    const deletedSessionIds = results.deleted
-      .filter(p => p.includes('WFS-'))
-      .map(p => p.split('/').pop())
-
-    const updatedManifest = archiveManifest.filter(entry =>
-      !deletedSessionIds.includes(entry.session_id)
-    )
-
-    Write(archiveManifestPath, JSON.stringify(updatedManifest, null, 2))
-  }
-}
-
-// Update project.json if features referenced deleted sessions
-const projectPath = '.workflow/project.json'
-if (fileExists(projectPath)) {
-  const project = JSON.parse(Read(projectPath))
-  const deletedPaths = new Set(results.deleted)
-
-  project.features = project.features.filter(f =>
-    !deletedPaths.has(f.traceability?.archive_path)
-  )
-
-  project.statistics.total_features = project.features.length
-  project.statistics.last_updated = getUtc8ISOString()
-
-  Write(projectPath, JSON.stringify(project, null, 2))
-}
-```
-
-**Step 4.4: Report Results**
-```javascript
-console.log(`
-## Cleanup Complete
-
-**Deleted**: ${results.deleted.length} items
-**Failed**: ${results.failed.length} items
-**Skipped**: ${results.skipped.length} items
-
-### Deleted Items
-${results.deleted.map(p => `- ${p}`).join('\n')}
-
-${results.failed.length > 0 ? `
-### Failed Items
-${results.failed.map(f => `- ${f.path}: ${f.error}`).join('\n')}
-` : ''}
-
-Cleanup manifest archived to: ${sessionFolder}/cleanup-manifest.json
-`)
-```
-
----
-
-## Session Folder Structure
-
-```
-.workflow/.clean/{YYYY-MM-DD}/
-├── mainline-profile.json     # Git history analysis
-└── cleanup-manifest.json     # Discovery results
-```
-
-## Risk Level Definitions
-
-| Risk | Description | Examples |
-|------|-------------|----------|
-| **Low** | Safe to delete, no dependencies | Empty sessions, scratchpad files, 100% broken docs |
-| **Medium** | Likely unused, verify before delete | Orphan files, old archives, partially broken docs |
-| **High** | May have hidden dependencies | Files with some imports, recent modifications |
-
-## Error Handling
-
-| Situation | Action |
-|-----------|--------|
-| No git repository | Skip mainline detection, use file timestamps only |
-| Session in use (.archiving) | Skip with warning |
-| Permission denied | Report error, continue with others |
-| Manifest parse error | Regenerate from filesystem scan |
-| Empty discovery | Report "codebase is clean" |
-
-## Related Commands
-
-- `/workflow:session:complete` - Properly archive active sessions
-- `/memory:compact` - Save session memory before cleanup
-- `/workflow:status` - View current workflow state

.claude/commands/workflow/debug.md

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

.claude/commands/workflow/execute.md

@@ -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.**
-**User-choice completion: When all tasks finished, ask user to choose review or complete.**
+**Auto-complete session when all tasks finished: Call `/workflow:session:complete` upon workflow completion.**
 **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 User-Choice Completion**: Ask user to choose review or complete when all tasks finished
+- **Session Auto-Complete**: Call `/workflow:session:complete` when all workflow tasks finished
 
 ## Execution Philosophy
 - **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
@@ -56,7 +56,6 @@ Phase 2: Planning Document Validation
    └─ Validate .task/ contains IMPL-*.json files
 
 Phase 3: TodoWrite Generation
-   ├─ Update session status to "active" (Step 0)
    ├─ Parse TODO_LIST.md for task statuses
    ├─ Generate TodoWrite for entire workflow
    └─ Prepare session context paths
@@ -68,22 +67,17 @@ Phase 4: Execution Strategy & Task Execution
          ├─ Get next in_progress task from TodoWrite
          ├─ Lazy load task JSON
          ├─ Launch agent with task context
-         ├─ Mark task completed (update IMPL-*.json status)
-         │  # Quick fix: Update task status for ccw dashboard
-         │  # TS=$(date -Iseconds) && jq --arg ts "$TS" '.status="completed" | .status_history=(.status_history // [])+[{"from":"in_progress","to":"completed","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json
+         ├─ Mark task completed
          └─ Advance to next task
 
 Phase 5: Completion
    ├─ Update task statuses in JSON files
    ├─ Generate summaries
-   └─ AskUserQuestion: Choose next step
-      ├─ "Enter Review" → /workflow:review
-      └─ "Complete Session" → /workflow:session:complete
+   └─ Auto-call /workflow:session:complete
 
 Resume Mode (--resume-session):
    ├─ Skip Phase 1 & Phase 2
    └─ Entry Point: Phase 3 (TodoWrite Generation)
-      ├─ Update session status to "active" (if not already)
       └─ Continue: Phase 4 → Phase 5
 ```
 
@@ -119,7 +113,14 @@ Auto-select and continue to Phase 2.
 
 List sessions with metadata and prompt user selection:
 ```bash
-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)
+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)
 ```
 
 Use AskUserQuestion to present formatted options (max 4 options shown):
@@ -176,16 +177,6 @@ bash(cat .workflow/active/${sessionId}/workflow-session.json)
 ### Phase 3: TodoWrite Generation
 **Applies to**: Both normal and resume modes (resume mode entry point)
 
-**Step 0: Update Session Status to Active**
-Before generating TodoWrite, update session status from "planning" to "active":
-```bash
-# Update session status (idempotent - safe to run if already active)
-jq '.status = "active" | .execution_started_at = (.execution_started_at // now | todate)' \
-  .workflow/active/${sessionId}/workflow-session.json > tmp.json && \
-  mv tmp.json .workflow/active/${sessionId}/workflow-session.json
-```
-This ensures the dashboard shows the session as "ACTIVE" during execution.
-
 **Process**:
 1. **Create TodoWrite List**: Generate task list from TODO_LIST.md (not from task JSONs)
    - Parse TODO_LIST.md to extract all tasks with current statuses
@@ -249,31 +240,7 @@ 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. **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`
+6. **Auto-Complete Session**: Call `/workflow:session:complete` when all tasks finished
 
 ## Execution Strategy (IMPL_PLAN-Driven)
 
@@ -349,7 +316,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`, prompt user to choose review or complete session
+- When all tasks marked `completed`, auto-call `/workflow:session:complete`
 
 ### TodoWrite Tool Usage
 
@@ -407,40 +374,39 @@ TodoWrite({
 **Note**: Orchestrator does NOT execute flow control steps - Agent interprets and executes them autonomously.
 
 ### Agent Prompt Template
-**Path-Based Invocation**: Pass paths and trigger markers, let agent parse task JSON autonomously.
+**Dynamic Generation**: Before agent invocation, read task JSON and extract key requirements.
 
 ```bash
 Task(subagent_type="{meta.agent}",
-     run_in_background=false,
-     prompt="Implement task {task.id}: {task.title}
+     prompt="Execute task: {task.title}
 
-     [FLOW_CONTROL]
+     {[FLOW_CONTROL]}
 
-     **Input**:
-     - Task JSON: {session.task_json_path}
+     **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}
      - Context Package: {session.context_package_path}
 
-     **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}")
+     **Success Criteria**: Complete all objectives, meet all quality standards, deliver all outputs as specified above.",
+     description="Executing: {task.title}")
 ```
 
-**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,11 +10,7 @@ examples:
 # Workflow Init Command (/workflow:init)
 
 ## Overview
-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)
+Initialize `.workflow/project.json` with comprehensive project understanding by delegating analysis to **cli-explore-agent**.
 
 **Note**: This command may be called by other workflow commands. Upon completion, return immediately to continue the calling workflow without interrupting the task flow.
 
@@ -31,7 +27,7 @@ Input Parsing:
    └─ Parse --regenerate flag → regenerate = true | false
 
 Decision:
-   ├─ BOTH_EXIST + no --regenerate → Exit: "Already initialized"
+   ├─ EXISTS + no --regenerate → Exit: "Already initialized"
    ├─ EXISTS + --regenerate → Backup existing → Continue analysis
    └─ NOT_FOUND → Continue analysis
 
@@ -41,14 +37,11 @@ Analysis Flow:
    │   ├─ Structural scan (get_modules_by_depth.sh, find, wc)
    │   ├─ Semantic analysis (Gemini CLI)
    │   ├─ Synthesis and merge
-   │   └─ Write .workflow/project-tech.json
-   ├─ Create guidelines scaffold (if not exists)
-   │   └─ Write .workflow/project-guidelines.json (empty structure)
+   │   └─ Write .workflow/project.json
    └─ Display summary
 
 Output:
-   ├─ .workflow/project-tech.json (+ .backup if regenerate)
-   └─ .workflow/project-guidelines.json (scaffold if new)
+   └─ .workflow/project.json (+ .backup if regenerate)
 ```
 
 ## Implementation
@@ -63,18 +56,13 @@ const regenerate = $ARGUMENTS.includes('--regenerate')
 **Check existing state**:
 
 ```bash
-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")
+bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
 ```
 
-**If BOTH_EXIST and no --regenerate**: Exit early
+**If EXISTS and no --regenerate**: Exit early
 ```
-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
+Project already initialized at .workflow/project.json
+Use /workflow:init --regenerate to rebuild
 Use /workflow:status --project to view state
 ```
 
@@ -90,7 +78,7 @@ bash(mkdir -p .workflow)
 
 **For --regenerate**: Backup and preserve existing data
 ```bash
-bash(cp .workflow/project-tech.json .workflow/project-tech.json.backup)
+bash(cp .workflow/project.json .workflow/project.json.backup)
 ```
 
 **Delegate analysis to agent**:
@@ -98,20 +86,22 @@ bash(cp .workflow/project-tech.json .workflow/project-tech.json.backup)
 ```javascript
 Task(
   subagent_type="cli-explore-agent",
-  run_in_background=false,
   description="Deep project analysis",
   prompt=`
-Analyze project for workflow initialization and generate .workflow/project-tech.json.
+Analyze project for workflow initialization and generate .workflow/project.json.
 
 ## MANDATORY FIRST STEPS
-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)
+1. Execute: cat ~/.claude/workflows/cli-templates/schemas/project-json-schema.json (get schema reference)
+2. Execute: ~/.claude/scripts/get_modules_by_depth.sh (get project structure)
 
 ## Task
-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}}'}
+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}'}
 - _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp, analysis_mode}
 
 ## Analysis Requirements
@@ -132,8 +122,8 @@ Generate complete project-tech.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 development_status from .workflow/project-tech.json.backup' : ''}
-5. Write JSON: Write('.workflow/project-tech.json', jsonContent)
+4. ${regenerate ? 'Merge with preserved features/development_index/statistics from .workflow/project.json.backup' : ''}
+5. Write JSON: Write('.workflow/project.json', jsonContent)
 6. Report: Return brief completion summary
 
 Project root: ${projectRoot}
@@ -141,66 +131,29 @@ 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 projectTech = JSON.parse(Read('.workflow/project-tech.json'));
-const guidelinesExists = file_exists('.workflow/project-guidelines.json');
+const projectJson = JSON.parse(Read('.workflow/project.json'));
 
 console.log(`
 ✓ Project initialized successfully
 
 ## Project Overview
-Name: ${projectTech.project_metadata.name}
-Description: ${projectTech.technology_analysis.description}
+Name: ${projectJson.project_name}
+Description: ${projectJson.overview.description}
 
 ### Technology Stack
-Languages: ${projectTech.technology_analysis.languages.map(l => l.name).join(', ')}
-Frameworks: ${projectTech.technology_analysis.frameworks.join(', ')}
+Languages: ${projectJson.overview.technology_stack.languages.map(l => l.name).join(', ')}
+Frameworks: ${projectJson.overview.technology_stack.frameworks.join(', ')}
 
 ### Architecture
-Style: ${projectTech.technology_analysis.architecture.style}
-Components: ${projectTech.technology_analysis.key_components.length} core modules
+Style: ${projectJson.overview.architecture.style}
+Components: ${projectJson.overview.key_components.length} core modules
 
 ---
-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
+Project state: .workflow/project.json
+${regenerate ? 'Backup: .workflow/project.json.backup' : ''}
 `);
 ```
 

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

@@ -258,33 +258,6 @@ TodoWrite({
 
 ### Step 3: Launch Execution
 
-**Executor Resolution** (任务级 executor 优先于全局设置):
-```javascript
-// 获取任务的 executor（优先使用 executorAssignments，fallback 到全局 executionMethod）
-function getTaskExecutor(task) {
-  const assignments = executionContext?.executorAssignments || {}
-  if (assignments[task.id]) {
-    return assignments[task.id].executor  // 'gemini' | 'codex' | 'agent'
-  }
-  // Fallback: 全局 executionMethod 映射
-  const method = executionContext?.executionMethod || 'Auto'
-  if (method === 'Agent') return 'agent'
-  if (method === 'Codex') return 'codex'
-  // Auto: 根据复杂度
-  return planObject.complexity === 'Low' ? 'agent' : 'codex'
-}
-
-// 按 executor 分组任务
-function groupTasksByExecutor(tasks) {
-  const groups = { gemini: [], codex: [], agent: [] }
-  tasks.forEach(task => {
-    const executor = getTaskExecutor(task)
-    groups[executor].push(task)
-  })
-  return groups
-}
-```
-
 **Execution Flow**: Parallel batches concurrently → Sequential batches in order
 ```javascript
 const parallel = executionCalls.filter(c => c.executionType === "parallel")
@@ -307,74 +280,118 @@ 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:
-- `getTaskExecutor(task) === "agent"`
-- 或 `executionMethod = "Agent"` (全局 fallback)
-- 或 `executionMethod = "Auto" AND complexity = "Low"` (全局 fallback)
+- `executionMethod = "Agent"`
+- `executionMethod = "Auto" AND complexity = "Low"`
 
+**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=buildExecutionPrompt(batch)
+  prompt=formatBatchPrompt({
+    tasks: batch.tasks,
+    context: buildRelevantContext(batch.tasks)
+  })
 )
+
+// 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)
@@ -382,15 +399,84 @@ Task(
 **Option B: CLI Execution (Codex)**
 
 When to use:
-- `getTaskExecutor(task) === "codex"`
-- 或 `executionMethod = "Codex"` (全局 fallback)
-- 或 `executionMethod = "Auto" AND complexity = "Medium/High"` (全局 fallback)
+- `executionMethod = "Codex"`
+- `executionMethod = "Auto" AND complexity = "Medium" or "High"`
 
+**Task Formatting Principle**: Same as Agent - each task is a self-contained checklist. No task numbering or position awareness.
+
+Command format:
 ```bash
-ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write
+// 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
+}
+
+codex --full-auto exec "${buildCLIPrompt(batch)}" --skip-git-repo-check -s danger-full-access
 ```
 
-**Execution with fixed IDs** (predictable ID pattern):
+**Execution with tracking**:
 ```javascript
 // Launch CLI in foreground (NOT background)
 // Timeout based on complexity: Low=40min, Medium=60min, High=100min
@@ -400,57 +486,15 @@ const timeoutByComplexity = {
   "High": 6000000    // 100 minutes
 }
 
-// Generate fixed execution ID: ${sessionId}-${groupId}
-// This enables predictable ID lookup without relying on resume context chains
-const sessionId = executionContext?.session?.id || 'standalone'
-const fixedExecutionId = `${sessionId}-${batch.groupId}`  // e.g., "implement-auth-2025-12-13-P1"
-
-// Check if resuming from previous failed execution
-const previousCliId = batch.resumeFromCliId || null
-
-// Build command with fixed ID (and optional resume for continuation)
-const cli_command = previousCliId
-  ? `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,
   timeout=timeoutByComplexity[planObject.complexity] || 3600000
 )
 
-// Execution ID is now predictable: ${fixedExecutionId}
-// Can also extract from output: "ID: implement-auth-2025-12-13-P1"
-const cliExecutionId = fixedExecutionId
-
 // Update TodoWrite when execution completes
 ```
 
-**Resume on Failure** (with fixed ID):
-```javascript
-// If execution failed or timed out, offer resume option
-if (bash_result.status === 'failed' || bash_result.status === 'timeout') {
-  console.log(`
-⚠️ Execution incomplete. Resume available:
-   Fixed ID: ${fixedExecutionId}
-   Lookup: ccw cli detail ${fixedExecutionId}
-   Resume: ccw cli -p "Continue tasks" --resume ${fixedExecutionId} --tool codex --mode write --id ${fixedExecutionId}-retry
-`)
-
-  // Store for potential retry in same session
-  batch.resumeFromCliId = fixedExecutionId
-}
-```
-
-**Result Collection**: After completion, analyze output and collect result following `executionResult` structure (include `cliExecutionId` for resume capability)
-
-**Option C: CLI Execution (Gemini)**
-
-When to use: `getTaskExecutor(task) === "gemini"` (分析类任务)
-
-```bash
-# 使用统一的 buildExecutionPrompt，切换 tool 和 mode
-ccw cli -p "${buildExecutionPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
-```
+**Result Collection**: After completion, analyze output and collect result following `executionResult` structure
 
 ### Step 4: Progress Tracking
 
@@ -497,30 +541,15 @@ RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-q
 # - Report findings directly
 
 # Method 2: Gemini Review (recommended)
-ccw cli -p "[Shared Prompt Template with artifacts]" --tool gemini --mode analysis
+gemini -p "[Shared Prompt Template with artifacts]"
 # CONTEXT includes: @**/* @${plan.json} [@${exploration.json}]
 
 # Method 3: Qwen Review (alternative)
-ccw cli -p "[Shared Prompt Template with artifacts]" --tool qwen --mode analysis
+qwen -p "[Shared Prompt Template with artifacts]"
 # Same prompt as Gemini, different execution engine
 
 # Method 4: Codex Review (autonomous)
-ccw cli -p "[Verify plan acceptance criteria at ${plan.json}]" --tool codex --mode write
-```
-
-**Multi-Round Review with Fixed IDs**:
-```javascript
-// Generate fixed review ID
-const reviewId = `${sessionId}-review`
-
-// First review pass with fixed ID
-const reviewResult = Bash(`ccw cli -p "[Review prompt]" --tool gemini --mode analysis --id ${reviewId}`)
-
-// If issues found, continue review dialog with fixed ID chain
-if (hasUnresolvedIssues(reviewResult)) {
-  // Resume with follow-up questions
-  Bash(`ccw cli -p "Clarify the security concerns you mentioned" --resume ${reviewId} --tool gemini --mode analysis --id ${reviewId}-followup`)
-}
+codex --full-auto exec "[Verify plan acceptance criteria at ${plan.json}]" --skip-git-repo-check -s danger-full-access
 ```
 
 **Implementation Note**: Replace `[Shared Prompt Template with artifacts]` placeholder with actual template content, substituting:
@@ -594,10 +623,8 @@ console.log(`✓ Development index: [${category}] ${entry.title}`)
 | Empty file | File exists but no content | Error: "File is empty: {path}. Provide task description." |
 | Invalid Enhanced Task JSON | JSON missing required fields | Warning: "Missing required fields. Treating as plain text." |
 | Malformed JSON | JSON parsing fails | Treat as plain text (expected for non-JSON files) |
-| Execution failure | Agent/Codex crashes | Display error, use fixed ID `${sessionId}-${groupId}` for resume: `ccw cli -p "Continue" --resume <fixed-id> --id <fixed-id>-retry` |
-| Execution timeout | CLI exceeded timeout | Use fixed ID for resume with extended timeout |
+| Execution failure | Agent/Codex crashes | Display error, save partial progress, suggest retry |
 | Codex unavailable | Codex not installed | Show installation instructions, offer Agent execution |
-| Fixed ID not found | Custom ID lookup failed | Check `ccw cli history`, verify date directories |
 
 ## Data Structures
 
@@ -619,15 +646,10 @@ Passed from lite-plan via global variable:
   explorationAngles: string[],             // List of exploration angles
   explorationManifest: {...} | null,       // Exploration manifest
   clarificationContext: {...} | null,
-  executionMethod: "Agent" | "Codex" | "Auto",  // 全局默认
+  executionMethod: "Agent" | "Codex" | "Auto",
   codeReviewTool: "Skip" | "Gemini Review" | "Agent Review" | string,
   originalUserInput: string,
 
-  // 任务级 executor 分配（优先于 executionMethod）
-  executorAssignments: {
-    [taskId]: { executor: "gemini" | "codex" | "agent", reason: string }
-  },
-
   // Session artifacts location (saved by lite-plan)
   session: {
     id: string,                        // Session identifier: {taskSlug}-{shortTimestamp}
@@ -657,20 +679,8 @@ Collected after each execution call completes:
   tasksSummary: string,                // Brief description of tasks handled
   completionSummary: string,           // What was completed
   keyOutputs: string,                  // Files created/modified, key changes
-  notes: string,                       // Important context for next execution
-  fixedCliId: string | null            // Fixed CLI execution ID (e.g., "implement-auth-2025-12-13-P1")
+  notes: string                        // Important context for next execution
 }
 ```
 
 Appended to `previousExecutionResults` array for context continuity in multi-execution scenarios.
-
-**Fixed ID Pattern**: `${sessionId}-${groupId}` enables predictable lookup without auto-generated timestamps.
-
-**Resume Usage**: If `status` is "partial" or "failed", use `fixedCliId` to resume:
-```bash
-# Lookup previous execution
-ccw cli detail ${fixedCliId}
-
-# Resume with new fixed ID for retry
-ccw cli -p "Continue from where we left off" --resume ${fixedCliId} --tool codex --mode write --id ${fixedCliId}-retry
-```

.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 execute with complete context handoff to lite-execute
+- Execution dispatch 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: Execute
+Phase 5: Dispatch
    |- Build executionContext (fix-plan + diagnoses + clarifications + selections)
    +- SlashCommand("/workflow:lite-execute --in-memory --mode bugfix")
 ```
@@ -164,7 +164,6 @@ Launching ${selectedAngles.length} parallel diagnoses...
 const diagnosisTasks = selectedAngles.map((angle, index) =>
   Task(
     subagent_type="cli-explore-agent",
-    run_in_background=false,
     description=`Diagnose: ${angle}`,
     prompt=`
 ## Task Objective
@@ -178,11 +177,9 @@ Execute **${angle}** diagnosis for bug root cause analysis. Analyze codebase fro
 
 ## MANDATORY FIRST STEPS (Execute by Agent)
 **You (cli-explore-agent) MUST execute these steps in order:**
-1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
+1. Run: ~/.claude/scripts/get_modules_by_depth.sh (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)
 
@@ -403,7 +400,6 @@ Write(`${sessionFolder}/fix-plan.json`, JSON.stringify(fixPlan, null, 2))
 ```javascript
 Task(
   subagent_type="cli-lite-planning-agent",
-  run_in_background=false,
   description="Generate detailed fix plan",
   prompt=`
 Generate fix plan and write fix-plan.json.
@@ -411,12 +407,6 @@ 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}
 
@@ -543,7 +533,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Execute to Execution
+### Phase 5: Dispatch to Execution
 
 **CRITICAL**: lite-fix NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -588,7 +578,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Execute**
+**Step 5.2: Dispatch**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory --mode bugfix")

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

@@ -1,798 +0,0 @@
----
-name: workflow:lite-lite-lite
-description: Ultra-lightweight multi-tool analysis and direct execution. No artifacts, auto tool selection based on task analysis, user-driven iteration via AskUser.
-argument-hint: "<task description>"
-allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), mcp__ace-tool__search_context(*)
----
-
-# Ultra-Lite Multi-Tool Workflow
-
-## Quick Start
-
-```bash
-# Basic usage
-/workflow:lite-lite-lite "Fix the login bug"
-
-# Complex task
-/workflow:lite-lite-lite "Refactor payment module for multi-gateway support"
-```
-
-**Core Philosophy**: Minimal friction, maximum velocity. No files, no artifacts - just analyze and execute.
-
-## What & Why
-
-### Core Concept
-
-**Zero-artifact workflow**: Clarify requirements → Auto-select tools → Mixed tool analysis → User decision → Direct execution. All state in memory, all decisions via AskUser.
-
-**vs multi-cli-plan**:
-- **multi-cli-plan**: Full artifacts (IMPL_PLAN.md, plan.json, synthesis.json)
-- **lite-lite-lite**: No files, direct in-memory flow, immediate execution
-
-### Value Proposition
-
-1. **Ultra-Fast**: No file I/O overhead, no session management
-2. **Smart Selection**: Auto-select optimal tool combination based on task
-3. **Interactive**: Key decisions validated via AskUser
-4. **Direct**: Analysis → Execution without intermediate artifacts
-
-## Execution Flow
-
-```
-Phase 1: Clarify Requirements
-   └─ Parse input → AskUser for missing details (if needed)
-
-Phase 2: Auto-Select Tools
-   └─ Analyze task → Match to tool strengths → Confirm selection
-
-Phase 3: Mixed Tool Analysis
-   └─ Execute selected tools in parallel → Aggregate results
-
-Phase 4: User Decision
-   ├─ Present analysis summary
-   ├─ AskUser: Execute / Refine / Change tools / Cancel
-   └─ Loop to Phase 3 if refinement needed
-
-Phase 5: Direct Execution
-   └─ Execute solution directly (no plan files)
-```
-
-## Phase Details
-
-### Phase 1: Clarify Requirements
-
-**Parse Task Description**:
-```javascript
-// Extract intent from user input
-const taskDescription = $ARGUMENTS
-
-// Check if clarification needed
-if (taskDescription.length < 20 || isAmbiguous(taskDescription)) {
-  AskUserQuestion({
-    questions: [{
-      question: "Please provide more details: target files/modules, expected behavior, constraints?",
-      header: "Details",
-      options: [
-        { label: "I'll provide more", description: "Add more context" },
-        { label: "Continue analysis", description: "Let tools explore autonomously" }
-      ],
-      multiSelect: false
-    }]
-  })
-}
-```
-
-**Quick ACE Context** (optional, for complex tasks):
-```javascript
-// Only if task seems to need codebase context
-mcp__ace-tool__search_context({
-  project_root_path: process.cwd(),
-  query: `${taskDescription} implementation patterns`
-})
-```
-
-### Phase 2: Auto-Select Analysis Tools
-
-**Tool Categories**:
-
-| Category | Source | Execution |
-|----------|--------|-----------|
-| **CLI Tools** | cli-tools.json | `ccw cli -p "..." --tool <name>` |
-| **Sub Agents** | Task tool | `Task({ subagent_type: "...", prompt: "..." })` |
-
-**Task Analysis Dimensions**:
-```javascript
-function analyzeTask(taskDescription) {
-  return {
-    complexity: detectComplexity(taskDescription),  // simple, medium, complex
-    taskType: detectTaskType(taskDescription),      // bugfix, feature, refactor, analysis, etc.
-    domain: detectDomain(taskDescription),          // frontend, backend, fullstack
-    needsExecution: detectExecutionNeed(taskDescription)  // analysis-only vs needs-write
-  }
-}
-```
-
-**CLI Tools** (dynamically loaded from cli-tools.json):
-
-```javascript
-// Load CLI tools from config file
-const cliConfig = JSON.parse(Read("~/.claude/cli-tools.json"))
-const cliTools = Object.entries(cliConfig.tools)
-  .filter(([_, config]) => config.enabled)
-  .map(([name, config]) => ({
-    name,
-    type: 'cli',
-    tags: config.tags || [],
-    model: config.primaryModel,
-    toolType: config.type  // builtin, cli-wrapper, api-endpoint
-  }))
-```
-
-**Tags** (user-defined in cli-tools.json, no fixed specification):
-
-Tags are completely user-defined. Users can create any tags that match their workflow needs.
-
-**Config Example** (cli-tools.json):
-```json
-{
-  "tools": {
-    "gemini": {
-      "enabled": true,
-      "tags": ["architecture", "reasoning", "performance"],
-      "primaryModel": "gemini-2.5-pro"
-    },
-    "codex": {
-      "enabled": true,
-      "tags": ["implementation", "fast"],
-      "primaryModel": "gpt-5.2"
-    },
-    "qwen": {
-      "enabled": true,
-      "tags": ["implementation", "chinese", "documentation"],
-      "primaryModel": "coder-model"
-    }
-  }
-}
-```
-
-**Sub Agents** (predefined, canExecute marks execution capability):
-
-```javascript
-const agents = [
-  { name: 'code-developer', type: 'agent', strength: 'Code implementation, test writing', canExecute: true },
-  { name: 'Explore', type: 'agent', strength: 'Fast code exploration', canExecute: false },
-  { name: 'cli-explore-agent', type: 'agent', strength: 'Dual-source deep analysis', canExecute: false },
-  { name: 'cli-discuss-agent', type: 'agent', strength: 'Multi-CLI collaborative verification', canExecute: false },
-  { name: 'debug-explore-agent', type: 'agent', strength: 'Hypothesis-driven debugging', canExecute: false },
-  { name: 'context-search-agent', type: 'agent', strength: 'Context collection', canExecute: false },
-  { name: 'test-fix-agent', type: 'agent', strength: 'Test execution and fixing', canExecute: true },
-  { name: 'universal-executor', type: 'agent', strength: 'General multi-step execution', canExecute: true }
-]
-```
-
-| Agent | Strengths | canExecute |
-|-------|-----------|------------|
-| **code-developer** | Code implementation, test writing, incremental development | ✅ |
-| **Explore** | Fast code exploration, file search, pattern discovery | ❌ |
-| **cli-explore-agent** | Dual-source analysis (Bash+CLI), read-only exploration | ❌ |
-| **cli-discuss-agent** | Multi-CLI collaboration, cross-verification, solution synthesis | ❌ |
-| **debug-explore-agent** | Hypothesis-driven debugging, NDJSON logging, iterative verification | ❌ |
-| **context-search-agent** | Multi-layer file discovery, dependency analysis, conflict assessment | ❌ |
-| **test-fix-agent** | Test execution, failure diagnosis, code fixing | ✅ |
-| **universal-executor** | General execution, multi-domain adaptation | ✅ |
-
-**Three-Step Selection Flow** (CLI → Mode → Agent):
-
-```javascript
-// Step 1: Present CLI options from config (multiSelect for multi-CLI modes)
-function getCliDescription(cli) {
-  return cli.tags.length > 0 ? cli.tags.join(', ') : cli.model || 'general'
-}
-
-const cliOptions = cliTools.map(cli => ({
-  label: cli.name,
-  description: getCliDescription(cli)
-}))
-
-AskUserQuestion({
-  questions: [{
-    question: "Select CLI tools for analysis (select 1-3 for collaboration modes)",
-    header: "CLI Tools",
-    options: cliOptions,
-    multiSelect: true  // Allow multiple selection for collaboration modes
-  }]
-})
-```
-
-```javascript
-// Step 2: Select Analysis Mode
-const analysisModes = [
-  {
-    name: 'parallel',
-    label: 'Parallel',
-    description: 'All CLIs analyze simultaneously, aggregate results',
-    minCLIs: 1,
-    pattern: 'A || B || C → Aggregate'
-  },
-  {
-    name: 'sequential',
-    label: 'Sequential',
-    description: 'Chain analysis: each CLI builds on previous via --resume',
-    minCLIs: 2,
-    pattern: 'A → B(resume A) → C(resume B)'
-  },
-  {
-    name: 'collaborative',
-    label: 'Collaborative',
-    description: 'Multi-round synthesis: CLIs take turns refining analysis',
-    minCLIs: 2,
-    pattern: 'A → B(resume A) → A(resume B) → Synthesize'
-  },
-  {
-    name: 'debate',
-    label: 'Debate',
-    description: 'Adversarial: CLI B challenges CLI A findings, A responds',
-    minCLIs: 2,
-    pattern: 'A(propose) → B(challenge, resume A) → A(defend, resume B)'
-  },
-  {
-    name: 'challenge',
-    label: 'Challenge',
-    description: 'Stress test: CLI B finds flaws/alternatives in CLI A analysis',
-    minCLIs: 2,
-    pattern: 'A(analyze) → B(challenge, resume A) → Evaluate'
-  }
-]
-
-// Filter modes based on selected CLI count
-const availableModes = analysisModes.filter(m => selectedCLIs.length >= m.minCLIs)
-
-AskUserQuestion({
-  questions: [{
-    question: "Select analysis mode",
-    header: "Mode",
-    options: availableModes.map(m => ({
-      label: m.label,
-      description: `${m.description} [${m.pattern}]`
-    })),
-    multiSelect: false
-  }]
-})
-```
-
-```javascript
-// Step 3: Present Agent options for execution
-const agentOptions = agents.map(agent => ({
-  label: agent.name,
-  description: agent.strength
-}))
-
-AskUserQuestion({
-  questions: [{
-    question: "Select Sub Agent for execution",
-    header: "Agent",
-    options: agentOptions,
-    multiSelect: false
-  }]
-})
-```
-
-**Selection Summary**:
-```javascript
-console.log(`
-## Selected Configuration
-
-**CLI Tools**: ${selectedCLIs.map(c => c.name).join(' → ')}
-**Analysis Mode**: ${selectedMode.label} - ${selectedMode.pattern}
-**Execution Agent**: ${selectedAgent.name} - ${selectedAgent.strength}
-
-> Mode determines how CLIs collaborate, Agent handles final execution
-`)
-
-AskUserQuestion({
-  questions: [{
-    question: "Confirm selection?",
-    header: "Confirm",
-    options: [
-      { label: "Confirm and continue", description: `${selectedMode.label} mode with ${selectedCLIs.length} CLIs` },
-      { label: "Re-select CLIs", description: "Choose different CLI tools" },
-      { label: "Re-select Mode", description: "Choose different analysis mode" },
-      { label: "Re-select Agent", description: "Choose different Sub Agent" }
-    ],
-    multiSelect: false
-  }]
-})
-```
-
-### Phase 3: Multi-Mode Analysis
-
-**Mode-Specific Execution Patterns**:
-
-#### Mode 1: Parallel (并行)
-```javascript
-// All CLIs run simultaneously, no resume dependency
-async function executeParallel(clis, taskDescription) {
-  const promises = clis.map(cli => Bash({
-    command: `ccw cli -p "
-PURPOSE: Analyze and provide solution for: ${taskDescription}
-TASK: • Identify affected files • Analyze implementation approach • List specific changes needed
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Concise analysis with: 1) Root cause/approach 2) Files to modify 3) Key changes 4) Risks
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Focus on actionable insights
-" --tool ${cli.name} --mode analysis`,
-    run_in_background: true
-  }))
-
-  return await Promise.all(promises)
-}
-```
-
-#### Mode 2: Sequential (串联)
-```javascript
-// Chain analysis: each CLI builds on previous via --resume
-async function executeSequential(clis, taskDescription) {
-  const results = []
-  let previousSessionId = null
-
-  for (const cli of clis) {
-    const resumeFlag = previousSessionId ? `--resume ${previousSessionId}` : ''
-
-    const result = await Bash({
-      command: `ccw cli -p "
-PURPOSE: ${previousSessionId ? 'Build on previous analysis and deepen' : 'Initial analysis'}: ${taskDescription}
-TASK: • ${previousSessionId ? 'Review previous findings • Extend analysis • Add new insights' : 'Identify affected files • Analyze implementation approach'}
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: ${previousSessionId ? 'Extended analysis building on previous findings' : 'Initial analysis with root cause and approach'}
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | ${previousSessionId ? 'Build incrementally, avoid repetition' : 'Focus on actionable insights'}
-" --tool ${cli.name} --mode analysis ${resumeFlag}`,
-      run_in_background: false
-    })
-
-    results.push(result)
-    previousSessionId = extractSessionId(result)  // Extract session ID for next iteration
-  }
-
-  return results
-}
-```
-
-#### Mode 3: Collaborative (协同)
-```javascript
-// Multi-round synthesis: CLIs take turns refining analysis
-async function executeCollaborative(clis, taskDescription, rounds = 2) {
-  const results = []
-  let previousSessionId = null
-
-  for (let round = 0; round < rounds; round++) {
-    for (const cli of clis) {
-      const resumeFlag = previousSessionId ? `--resume ${previousSessionId}` : ''
-      const roundContext = round === 0 ? 'Initial analysis' : `Round ${round + 1}: Refine and synthesize`
-
-      const result = await Bash({
-        command: `ccw cli -p "
-PURPOSE: ${roundContext} for: ${taskDescription}
-TASK: • ${round === 0 ? 'Initial analysis of the problem' : 'Review previous analysis • Identify gaps • Add complementary insights • Synthesize findings'}
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: ${round === 0 ? 'Foundational analysis' : 'Refined synthesis with new perspectives'}
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | ${round === 0 ? 'Be thorough' : 'Build collaboratively, add value not repetition'}
-" --tool ${cli.name} --mode analysis ${resumeFlag}`,
-        run_in_background: false
-      })
-
-      results.push({ cli: cli.name, round, result })
-      previousSessionId = extractSessionId(result)
-    }
-  }
-
-  return results
-}
-```
-
-#### Mode 4: Debate (辩论)
-```javascript
-// Adversarial: CLI B challenges CLI A findings, A responds
-async function executeDebate(clis, taskDescription) {
-  const [cliA, cliB] = clis
-  const results = []
-
-  // Step 1: CLI A proposes initial analysis
-  const proposeResult = await Bash({
-    command: `ccw cli -p "
-PURPOSE: Propose comprehensive analysis for: ${taskDescription}
-TASK: • Analyze problem thoroughly • Propose solution approach • Identify implementation details • State assumptions clearly
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Well-reasoned proposal with clear assumptions and trade-offs stated
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be clear about assumptions and trade-offs
-" --tool ${cliA.name} --mode analysis`,
-    run_in_background: false
-  })
-  results.push({ phase: 'propose', cli: cliA.name, result: proposeResult })
-  const proposeSessionId = extractSessionId(proposeResult)
-
-  // Step 2: CLI B challenges the proposal
-  const challengeResult = await Bash({
-    command: `ccw cli -p "
-PURPOSE: Challenge and stress-test the previous analysis for: ${taskDescription}
-TASK: • Identify weaknesses in proposed approach • Question assumptions • Suggest alternative approaches • Highlight potential risks overlooked
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Constructive critique with specific counter-arguments and alternatives
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be adversarial but constructive, focus on improving the solution
-" --tool ${cliB.name} --mode analysis --resume ${proposeSessionId}`,
-    run_in_background: false
-  })
-  results.push({ phase: 'challenge', cli: cliB.name, result: challengeResult })
-  const challengeSessionId = extractSessionId(challengeResult)
-
-  // Step 3: CLI A defends and refines
-  const defendResult = await Bash({
-    command: `ccw cli -p "
-PURPOSE: Respond to challenges and refine analysis for: ${taskDescription}
-TASK: • Address each challenge point • Defend valid aspects • Acknowledge valid criticisms • Propose refined solution incorporating feedback
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Refined proposal that addresses criticisms and incorporates valid alternatives
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be open to valid criticism, synthesize best ideas
-" --tool ${cliA.name} --mode analysis --resume ${challengeSessionId}`,
-    run_in_background: false
-  })
-  results.push({ phase: 'defend', cli: cliA.name, result: defendResult })
-
-  return results
-}
-```
-
-#### Mode 5: Challenge (挑战)
-```javascript
-// Stress test: CLI B finds flaws/alternatives in CLI A analysis
-async function executeChallenge(clis, taskDescription) {
-  const [cliA, cliB] = clis
-  const results = []
-
-  // Step 1: CLI A provides initial analysis
-  const analyzeResult = await Bash({
-    command: `ccw cli -p "
-PURPOSE: Provide comprehensive analysis for: ${taskDescription}
-TASK: • Deep analysis of problem space • Propose implementation approach • List specific changes • Identify risks
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Thorough analysis with clear reasoning
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be thorough and explicit about reasoning
-" --tool ${cliA.name} --mode analysis`,
-    run_in_background: false
-  })
-  results.push({ phase: 'analyze', cli: cliA.name, result: analyzeResult })
-  const analyzeSessionId = extractSessionId(analyzeResult)
-
-  // Step 2: CLI B challenges with focus on finding flaws
-  const challengeResult = await Bash({
-    command: `ccw cli -p "
-PURPOSE: Stress-test and find weaknesses in the analysis for: ${taskDescription}
-TASK: • Find logical flaws in reasoning • Identify missed edge cases • Propose better alternatives • Rate confidence in each criticism (High/Medium/Low)
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Detailed critique with severity ratings: [CRITICAL] [HIGH] [MEDIUM] [LOW] for each issue found
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be ruthlessly critical, find every possible flaw
-" --tool ${cliB.name} --mode analysis --resume ${analyzeSessionId}`,
-    run_in_background: false
-  })
-  results.push({ phase: 'challenge', cli: cliB.name, result: challengeResult })
-
-  return results
-}
-```
-
-**Mode Router**:
-```javascript
-async function executeAnalysis(mode, clis, taskDescription) {
-  switch (mode.name) {
-    case 'parallel':
-      return await executeParallel(clis, taskDescription)
-    case 'sequential':
-      return await executeSequential(clis, taskDescription)
-    case 'collaborative':
-      return await executeCollaborative(clis, taskDescription)
-    case 'debate':
-      return await executeDebate(clis, taskDescription)
-    case 'challenge':
-      return await executeChallenge(clis, taskDescription)
-    default:
-      return await executeParallel(clis, taskDescription)
-  }
-}
-
-// Execute based on selected mode
-const analysisResults = await executeAnalysis(selectedMode, selectedCLIs, taskDescription)
-```
-
-**Result Aggregation** (mode-aware):
-```javascript
-function aggregateResults(mode, results) {
-  const base = {
-    mode: mode.name,
-    pattern: mode.pattern,
-    tools_used: results.map(r => r.cli || 'unknown')
-  }
-
-  switch (mode.name) {
-    case 'parallel':
-      return {
-        ...base,
-        findings: results.map(r => parseOutput(r)),
-        consensus: findCommonPoints(results),
-        divergences: findDifferences(results)
-      }
-
-    case 'sequential':
-      return {
-        ...base,
-        evolution: results.map((r, i) => ({ step: i + 1, analysis: parseOutput(r) })),
-        finalAnalysis: parseOutput(results[results.length - 1])
-      }
-
-    case 'collaborative':
-      return {
-        ...base,
-        rounds: groupByRound(results),
-        synthesis: extractSynthesis(results[results.length - 1])
-      }
-
-    case 'debate':
-      return {
-        ...base,
-        proposal: parseOutput(results.find(r => r.phase === 'propose')?.result),
-        challenges: parseOutput(results.find(r => r.phase === 'challenge')?.result),
-        resolution: parseOutput(results.find(r => r.phase === 'defend')?.result),
-        confidence: calculateDebateConfidence(results)
-      }
-
-    case 'challenge':
-      return {
-        ...base,
-        originalAnalysis: parseOutput(results.find(r => r.phase === 'analyze')?.result),
-        critiques: parseCritiques(results.find(r => r.phase === 'challenge')?.result),
-        riskScore: calculateRiskScore(results)
-      }
-  }
-}
-
-const aggregatedAnalysis = aggregateResults(selectedMode, analysisResults)
-```
-
-### Phase 4: User Decision
-
-**Present Mode-Specific Summary**:
-
-```javascript
-function presentSummary(aggregatedAnalysis) {
-  const { mode, pattern } = aggregatedAnalysis
-
-  console.log(`
-## Analysis Result Summary
-
-**Mode**: ${mode} (${pattern})
-**Tools**: ${aggregatedAnalysis.tools_used.join(' → ')}
-`)
-
-  switch (mode) {
-    case 'parallel':
-      console.log(`
-### Consensus Points
-${aggregatedAnalysis.consensus.map(c => `- ${c}`).join('\n')}
-
-### Divergence Points
-${aggregatedAnalysis.divergences.map(d => `- ${d}`).join('\n')}
-`)
-      break
-
-    case 'sequential':
-      console.log(`
-### Analysis Evolution
-${aggregatedAnalysis.evolution.map(e => `**Step ${e.step}**: ${e.analysis.summary}`).join('\n')}
-
-### Final Analysis
-${aggregatedAnalysis.finalAnalysis.summary}
-`)
-      break
-
-    case 'collaborative':
-      console.log(`
-### Collaboration Rounds
-${Object.entries(aggregatedAnalysis.rounds).map(([round, analyses]) =>
-  `**Round ${round}**: ${analyses.map(a => a.cli).join(' + ')}`
-).join('\n')}
-
-### Synthesized Result
-${aggregatedAnalysis.synthesis}
-`)
-      break
-
-    case 'debate':
-      console.log(`
-### Debate Summary
-**Proposal**: ${aggregatedAnalysis.proposal.summary}
-**Challenges**: ${aggregatedAnalysis.challenges.points?.length || 0} points raised
-**Resolution**: ${aggregatedAnalysis.resolution.summary}
-**Confidence**: ${aggregatedAnalysis.confidence}%
-`)
-      break
-
-    case 'challenge':
-      console.log(`
-### Challenge Summary
-**Original Analysis**: ${aggregatedAnalysis.originalAnalysis.summary}
-**Critiques Found**: ${aggregatedAnalysis.critiques.length} issues
-${aggregatedAnalysis.critiques.map(c => `- [${c.severity}] ${c.description}`).join('\n')}
-**Risk Score**: ${aggregatedAnalysis.riskScore}/100
-`)
-      break
-  }
-}
-
-presentSummary(aggregatedAnalysis)
-```
-
-**Decision Options**:
-```javascript
-AskUserQuestion({
-  questions: [{
-    question: "How to proceed?",
-    header: "Next Step",
-    options: [
-      { label: "Execute directly", description: "Implement immediately based on analysis" },
-      { label: "Refine analysis", description: "Provide more constraints, re-analyze" },
-      { label: "Change tools", description: "Select different tool combination" },
-      { label: "Cancel", description: "End current workflow" }
-    ],
-    multiSelect: false
-  }]
-})
-```
-
-**Routing Logic**:
-- **Execute directly** → Phase 5
-- **Refine analysis** → Collect feedback, return to Phase 3
-- **Change tools** → Return to Phase 2
-- **Cancel** → End workflow
-
-### Phase 5: Direct Execution
-
-**No Artifacts - Direct Implementation**:
-```javascript
-// Use the aggregated analysis directly
-// No IMPL_PLAN.md, no plan.json, no session files
-
-console.log("Starting direct execution based on analysis...")
-
-// Execution-capable agents (canExecute: true)
-const executionAgents = agents.filter(a => a.canExecute)
-
-// Select execution tool: prefer execution-capable agent, fallback to CLI
-const executionTool = selectedTools.find(t =>
-  t.type === 'agent' && executionAgents.some(ea => ea.name === t.name)
-) || selectedTools.find(t => t.type === 'cli')
-
-if (executionTool.type === 'agent') {
-  // Use Agent for execution (preferred if available)
-  Task({
-    subagent_type: executionTool.name,
-    run_in_background: false,
-    description: `Execute: ${taskDescription.slice(0, 30)}`,
-    prompt: `
-## Task
-${taskDescription}
-
-## Analysis Results (from previous tools)
-${JSON.stringify(aggregatedAnalysis, null, 2)}
-
-## Instructions
-Based on the analysis above, implement the solution:
-1. Apply changes to identified files
-2. Follow the recommended approach
-3. Handle identified risks
-4. Verify changes work correctly
-`
-  })
-} else {
-  // Use CLI with write mode
-  Bash({
-    command: `ccw cli -p "
-PURPOSE: Implement the solution based on analysis: ${taskDescription}
-TASK: ${extractedTasks.join(' • ')}
-MODE: write
-CONTEXT: @${affectedFiles.join(' @')}
-EXPECTED: Working implementation with all changes applied
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) | Apply analysis findings directly
-" --tool ${executionTool.name} --mode write`,
-    run_in_background: false
-  })
-}
-```
-
-## TodoWrite Structure
-
-```javascript
-TodoWrite({ todos: [
-  { content: "Phase 1: Clarify requirements", status: "in_progress", activeForm: "Clarifying requirements" },
-  { content: "Phase 2: Auto-select tools", status: "pending", activeForm: "Analyzing task" },
-  { content: "Phase 3: Mixed tool analysis", status: "pending", activeForm: "Running analysis" },
-  { content: "Phase 4: User decision", status: "pending", activeForm: "Awaiting decision" },
-  { content: "Phase 5: Direct execution", status: "pending", activeForm: "Executing implementation" }
-]})
-```
-
-## Iteration Patterns
-
-### Pattern A: Direct Path (Most Common)
-```
-Phase 1 → Phase 2 (auto) → Phase 3 → Phase 4 (execute) → Phase 5
-```
-
-### Pattern B: Refinement Loop
-```
-Phase 3 → Phase 4 (refine) → Phase 3 → Phase 4 → Phase 5
-```
-
-### Pattern C: Tool Adjustment
-```
-Phase 2 (adjust) → Phase 3 → Phase 4 → Phase 5
-```
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| CLI timeout | Retry with secondary model |
-| No enabled tools | Load cli-tools.json, ask user to enable tools |
-| Task type unclear | Default to first available CLI + code-developer |
-| Ambiguous task | Force clarification via AskUser |
-| Execution fails | Present error, ask user for direction |
-
-## Analysis Modes Reference
-
-| Mode | Pattern | Use Case | CLI Count |
-|------|---------|----------|-----------|
-| **Parallel** | `A \|\| B \|\| C → Aggregate` | Fast multi-perspective analysis | 1+ |
-| **Sequential** | `A → B(resume) → C(resume)` | Deep incremental analysis | 2+ |
-| **Collaborative** | `A → B → A → B → Synthesize` | Multi-round refinement | 2+ |
-| **Debate** | `A(propose) → B(challenge) → A(defend)` | Stress-test solutions | 2 |
-| **Challenge** | `A(analyze) → B(challenge)` | Find flaws and risks | 2 |
-
-## Comparison
-
-| Aspect | lite-lite-lite | multi-cli-plan |
-|--------|----------------|----------------|
-| **Artifacts** | None | IMPL_PLAN.md, plan.json, synthesis.json |
-| **Session** | Stateless (uses --resume for chaining) | Persistent session folder |
-| **Tool Selection** | Multi-CLI + Agent via 3-step selection | Config-driven with fixed tools |
-| **Analysis Modes** | 5 modes (parallel/sequential/collaborative/debate/challenge) | Fixed synthesis rounds |
-| **CLI Collaboration** | Auto --resume chaining | Manual session management |
-| **Iteration** | Via AskUser | Via rounds/synthesis |
-| **Execution** | Direct | Via lite-execute |
-| **Best For** | Quick analysis, adversarial validation, rapid iteration | Complex multi-step implementations |
-
-## Best Practices
-
-1. **Be Specific**: Clear task description improves auto-selection accuracy
-2. **Trust Auto-Selection**: Algorithm matches task type to tool strengths
-3. **Adjust When Needed**: Use "Adjust tools" if auto-selection doesn't fit
-4. **Trust Consensus**: When tools agree, confidence is high
-5. **Iterate Fast**: Use refinement loop for complex requirements
-6. **Direct is Fast**: Skip artifacts when task is straightforward
-
-## Related Commands
-
-```bash
-# Full planning workflow
-/workflow:multi-cli-plan "complex task"
-
-# Single CLI planning
-/workflow:lite-plan "task"
-
-# Direct execution
-/workflow:lite-execute --in-memory
-```

.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 execute to lite-execute after user confirmation
+description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation
 argument-hint: "[-e|--explore] \"task description\"|file.md"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
 ---
@@ -15,9 +15,9 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 - Intelligent task analysis with automatic exploration detection
 - Dynamic code exploration (cli-explore-agent) when codebase understanding needed
 - Interactive clarification after exploration to gather missing information
-- Adaptive planning: Low complexity → Direct Claude; Medium/High → cli-lite-planning-agent
+- Adaptive planning strategy (direct Claude vs cli-lite-planning-agent) based on complexity
 - Two-step confirmation: plan display → multi-dimensional input collection
-- Execution execute with complete context handoff to lite-execute
+- Execution dispatch with complete context handoff to lite-execute
 
 ## Usage
 
@@ -38,7 +38,7 @@ Phase 1: Task Analysis & Exploration
    ├─ Parse input (description or .md file)
    ├─ intelligent complexity assessment (Low/Medium/High)
    ├─ Exploration decision (auto-detect or --explore flag)
-   ├─ Context protection: If file reading ≥50k chars → force cli-explore-agent
+   ├─ ⚠️ Context protection: If file reading ≥50k chars → force cli-explore-agent
    └─ Decision:
       ├─ needsExploration=true → Launch parallel cli-explore-agents (1-4 based on complexity)
       └─ needsExploration=false → Skip to Phase 2/3
@@ -62,7 +62,7 @@ Phase 4: Confirmation & Selection
       ├─ Execution: Agent / Codex / Auto
       └─ Review: Gemini / Agent / Skip
 
-Phase 5: Execute
+Phase 5: Dispatch
    ├─ Build executionContext (plan + explorations + clarifications + selections)
    └─ SlashCommand("/workflow:lite-execute --in-memory")
 ```
@@ -140,17 +140,11 @@ function selectAngles(taskDescription, count) {
 
 const selectedAngles = selectAngles(task_description, complexity === 'High' ? 4 : (complexity === 'Medium' ? 3 : 1))
 
-// Planning strategy determination
-const planningStrategy = complexity === 'Low'
-  ? 'Direct Claude Planning'
-  : 'cli-lite-planning-agent'
-
 console.log(`
 ## Exploration Plan
 
 Task Complexity: ${complexity}
 Selected Angles: ${selectedAngles.join(', ')}
-Planning Strategy: ${planningStrategy}
 
 Launching ${selectedAngles.length} parallel explorations...
 `)
@@ -158,16 +152,11 @@ Launching ${selectedAngles.length} parallel explorations...
 
 **Launch Parallel Explorations** - Orchestrator assigns angle to each agent:
 
-**⚠️ CRITICAL - NO BACKGROUND EXECUTION**:
-- **MUST NOT use `run_in_background: true`** - exploration results are REQUIRED before planning
-
-
 ```javascript
 // Launch agents with pre-assigned angles
 const explorationTasks = selectedAngles.map((angle, index) =>
   Task(
     subagent_type="cli-explore-agent",
-    run_in_background=false,  // ⚠️ MANDATORY: Must wait for results
     description=`Explore: ${angle}`,
     prompt=`
 ## Task Objective
@@ -181,11 +170,9 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 
 ## MANDATORY FIRST STEPS (Execute by Agent)
 **You (cli-explore-agent) MUST execute these steps in order:**
-1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
+1. Run: ~/.claude/scripts/get_modules_by_depth.sh (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)
 
@@ -317,11 +304,14 @@ explorations.forEach(exp => {
   }
 })
 
-// Intelligent deduplication: analyze allClarifications by intent
-// - Identify questions with similar intent across different angles
-// - Merge similar questions: combine options, consolidate context
-// - Produce dedupedClarifications with unique intents only
-const dedupedClarifications = intelligentMerge(allClarifications)
+// Deduplicate exact same questions only
+const seen = new Set()
+const dedupedClarifications = allClarifications.filter(c => {
+  const key = c.question.toLowerCase()
+  if (seen.has(key)) return false
+  seen.add(key)
+  return true
+})
 
 // Multi-round clarification: batch questions (max 4 per round)
 if (dedupedClarifications.length > 0) {
@@ -361,34 +351,12 @@ if (dedupedClarifications.length > 0) {
 
 **IMPORTANT**: Phase 3 is **planning only** - NO code execution. All execution happens in Phase 5 via lite-execute.
 
-**Executor Assignment** (Claude 智能分配，plan 生成后执行):
-
-```javascript
-// 分配规则（优先级从高到低）：
-// 1. 用户明确指定："用 gemini 分析..." → gemini, "codex 实现..." → codex
-// 2. 默认 → agent
-
-const executorAssignments = {}  // { taskId: { executor: 'gemini'|'codex'|'agent', reason: string } }
-plan.tasks.forEach(task => {
-  // Claude 根据上述规则语义分析，为每个 task 分配 executor
-  executorAssignments[task.id] = { executor: '...', reason: '...' }
-})
-```
-
 **Low Complexity** - Direct planning by Claude:
 ```javascript
 // Step 1: Read schema
 const schema = Bash(`cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json`)
 
-// Step 2: ⚠️ MANDATORY - Read and review ALL exploration files
-const manifest = JSON.parse(Read(`${sessionFolder}/explorations-manifest.json`))
-manifest.explorations.forEach(exp => {
-  const explorationData = Read(exp.path)
-  console.log(`\n### Exploration: ${exp.angle}\n${explorationData}`)
-})
-
-// Step 3: Generate plan following schema (Claude directly, no agent)
-// ⚠️ Plan MUST incorporate insights from exploration files read in Step 2
+// Step 2: Generate plan following schema (Claude directly, no agent)
 const plan = {
   summary: "...",
   approach: "...",
@@ -399,10 +367,10 @@ const plan = {
   _metadata: { timestamp: getUtc8ISOString(), source: "direct-planning", planning_mode: "direct" }
 }
 
-// Step 4: Write plan to session folder
+// Step 3: Write plan to session folder
 Write(`${sessionFolder}/plan.json`, JSON.stringify(plan, null, 2))
 
-// Step 5: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
+// Step 4: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
 ```
 
 **Medium/High Complexity** - Invoke cli-lite-planning-agent:
@@ -410,7 +378,6 @@ Write(`${sessionFolder}/plan.json`, JSON.stringify(plan, null, 2))
 ```javascript
 Task(
   subagent_type="cli-lite-planning-agent",
-  run_in_background=false,
   description="Generate detailed implementation plan",
   prompt=`
 Generate implementation plan and write plan.json.
@@ -418,12 +385,6 @@ 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}
 
@@ -446,9 +407,23 @@ ${JSON.stringify(clarificationContext) || "None"}
 ${complexity}
 
 ## Requirements
-Generate plan.json following the schema obtained above. Key constraints:
-- tasks: 2-7 structured tasks (**group by feature/module, NOT by file**)
-- _metadata.exploration_angles: ${JSON.stringify(manifest.explorations.map(e => e.angle))}
+Generate plan.json with:
+- summary: 2-3 sentence overview
+- approach: High-level implementation strategy (incorporating insights from all exploration angles)
+- tasks: 2-7 structured tasks (**IMPORTANT: group by feature/module, NOT by file**)
+  - **Task Granularity Principle**: Each task = one complete feature unit or module
+  - title: action verb + target module/feature (e.g., "Implement auth token refresh")
+  - scope: module path (src/auth/) or feature name, prefer module-level over single file
+  - action, description
+  - modification_points: ALL files to modify for this feature (group related changes)
+  - implementation (3-7 steps covering all modification_points)
+  - reference (pattern, files, examples)
+  - acceptance (2-4 criteria for the entire feature)
+  - depends_on: task IDs this task depends on (use sparingly, only for true dependencies)
+- estimated_time, recommended_execution, complexity
+- _metadata:
+  - timestamp, source, planning_mode
+  - exploration_angles: ${JSON.stringify(manifest.explorations.map(e => e.angle))}
 
 ## Task Grouping Rules
 1. **Group by feature**: All changes for one feature = one task (even if 3-5 files)
@@ -460,10 +435,10 @@ Generate plan.json following the schema obtained above. Key constraints:
 7. **Prefer parallel**: Most tasks should be independent (no depends_on)
 
 ## Execution
-1. Read schema file (cat command above)
+1. Read ALL exploration files for comprehensive context
 2. Execute CLI planning using Gemini (Qwen fallback)
-3. Read ALL exploration files for comprehensive context
-4. Synthesize findings and generate plan following schema
+3. Synthesize findings from multiple exploration angles
+4. Parse output and structure plan
 5. Write JSON: Write('${sessionFolder}/plan.json', jsonContent)
 6. Return brief completion summary
 `
@@ -535,7 +510,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Execute to Execution
+### Phase 5: Dispatch to Execution
 
 **CRITICAL**: lite-plan NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -560,13 +535,9 @@ executionContext = {
   explorationAngles: manifest.explorations.map(e => e.angle),
   explorationManifest: manifest,
   clarificationContext: clarificationContext || null,
-  executionMethod: userSelection.execution_method,  // 全局默认，可被 executorAssignments 覆盖
+  executionMethod: userSelection.execution_method,
   codeReviewTool: userSelection.code_review_tool,
   originalUserInput: task_description,
-
-  // 任务级 executor 分配（优先于全局 executionMethod）
-  executorAssignments: executorAssignments,  // { taskId: { executor, reason } }
-
   session: {
     id: sessionId,
     folder: sessionFolder,
@@ -582,7 +553,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Execute**
+**Step 5.2: Dispatch**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory")

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

@@ -1,510 +0,0 @@
----
-name: workflow:multi-cli-plan
-description: Multi-CLI collaborative planning workflow with ACE context gathering and iterative cross-verification. Uses cli-discuss-agent for Gemini+Codex+Claude analysis to converge on optimal execution plan.
-argument-hint: "<task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]"
-allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*)
----
-
-# Multi-CLI Collaborative Planning Command
-
-## Quick Start
-
-```bash
-# Basic usage
-/workflow:multi-cli-plan "Implement user authentication"
-
-# With options
-/workflow:multi-cli-plan "Add dark mode support" --max-rounds=3
-/workflow:multi-cli-plan "Refactor payment module" --tools=gemini,codex,claude
-/workflow:multi-cli-plan "Fix memory leak" --mode=serial
-
-# Resume session
-/workflow:lite-execute --session=MCP-xxx
-```
-
-**Context Source**: ACE semantic search + Multi-CLI analysis
-**Output Directory**: `.workflow/.multi-cli-plan/{session-id}/`
-**Default Max Rounds**: 3 (convergence may complete earlier)
-**CLI Tools**: @cli-discuss-agent (analysis), @cli-lite-planning-agent (plan generation)
-
-## What & Why
-
-### Core Concept
-
-Multi-CLI collaborative planning with **three-phase architecture**: ACE context gathering → Iterative multi-CLI discussion → Plan generation. Orchestrator delegates analysis to agents, only handles user decisions and session management.
-
-**Process**:
-- **Phase 1**: ACE semantic search gathers codebase context
-- **Phase 2**: cli-discuss-agent orchestrates Gemini/Codex/Claude for cross-verified analysis
-- **Phase 3-5**: User decision → Plan generation → Execution handoff
-
-**vs Single-CLI Planning**:
-- **Single**: One model perspective, potential blind spots
-- **Multi-CLI**: Cross-verification catches inconsistencies, builds consensus on solutions
-
-### Value Proposition
-
-1. **Multi-Perspective Analysis**: Gemini + Codex + Claude analyze from different angles
-2. **Cross-Verification**: Identify agreements/disagreements, build confidence
-3. **User-Driven Decisions**: Every round ends with user decision point
-4. **Iterative Convergence**: Progressive refinement until consensus reached
-
-### Orchestrator Boundary (CRITICAL)
-
-- **ONLY command** for multi-CLI collaborative planning
-- Manages: Session state, user decisions, agent delegation, phase transitions
-- Delegates: CLI execution to @cli-discuss-agent, plan generation to @cli-lite-planning-agent
-
-### Execution Flow
-
-```
-Phase 1: Context Gathering
-   └─ ACE semantic search, extract keywords, build context package
-
-Phase 2: Multi-CLI Discussion (Iterative, via @cli-discuss-agent)
-   ├─ Round N: Agent executes Gemini + Codex + Claude
-   ├─ Cross-verify findings, synthesize solutions
-   ├─ Write synthesis.json to rounds/{N}/
-   └─ Loop until convergence or max rounds
-
-Phase 3: Present Options
-   └─ Display solutions with trade-offs from agent output
-
-Phase 4: User Decision
-   ├─ Approve solution → Phase 5
-   ├─ Need clarification → Return to Phase 2
-   └─ Change direction → Reset with feedback
-
-Phase 5: Plan Generation (via @cli-lite-planning-agent)
-   ├─ Generate IMPL_PLAN.md + plan.json
-   └─ Hand off to /workflow:lite-execute
-```
-
-### Agent Roles
-
-| Agent | Responsibility |
-|-------|---------------|
-| **Orchestrator** | Session management, ACE context, user decisions, phase transitions |
-| **@cli-discuss-agent** | Multi-CLI execution (Gemini/Codex/Claude), cross-verification, solution synthesis, synthesis.json output |
-| **@cli-lite-planning-agent** | Task decomposition, IMPL_PLAN.md + plan.json generation |
-
-## Core Responsibilities
-
-### Phase 1: Context Gathering
-
-**Session Initialization**:
-```javascript
-const sessionId = `MCP-${taskSlug}-${date}`
-const sessionFolder = `.workflow/.multi-cli-plan/${sessionId}`
-Bash(`mkdir -p ${sessionFolder}/rounds`)
-```
-
-**ACE Context Queries**:
-```javascript
-const aceQueries = [
-  `Project architecture related to ${keywords}`,
-  `Existing implementations of ${keywords[0]}`,
-  `Code patterns for ${keywords} features`,
-  `Integration points for ${keywords[0]}`
-]
-// Execute via mcp__ace-tool__search_context
-```
-
-**Context Package** (passed to agent):
-- `relevant_files[]` - Files identified by ACE
-- `detected_patterns[]` - Code patterns found
-- `architecture_insights` - Structure understanding
-
-### Phase 2: Agent Delegation
-
-**Core Principle**: Orchestrator only delegates and reads output - NO direct CLI execution.
-
-**Agent Invocation**:
-```javascript
-Task({
-  subagent_type: "cli-discuss-agent",
-  run_in_background: false,
-  description: `Discussion round ${currentRound}`,
-  prompt: `
-## Input Context
-- task_description: ${taskDescription}
-- round_number: ${currentRound}
-- session: { id: "${sessionId}", folder: "${sessionFolder}" }
-- ace_context: ${JSON.stringify(contextPackageage)}
-- previous_rounds: ${JSON.stringify(analysisResults)}
-- user_feedback: ${userFeedback || 'None'}
-- cli_config: { tools: ["gemini", "codex"], mode: "parallel", fallback_chain: ["gemini", "codex", "claude"] }
-
-## Execution Process
-1. Parse input context (handle JSON strings)
-2. Check if ACE supplementary search needed
-3. Build CLI prompts with context
-4. Execute CLIs (parallel or serial per cli_config.mode)
-5. Parse CLI outputs, handle failures with fallback
-6. Perform cross-verification between CLI results
-7. Synthesize solutions, calculate scores
-8. Calculate convergence, generate clarification questions
-9. Write synthesis.json
-
-## Output
-Write: ${sessionFolder}/rounds/${currentRound}/synthesis.json
-
-## Completion Checklist
-- [ ] All configured CLI tools executed (or fallback triggered)
-- [ ] Cross-verification completed with agreements/disagreements
-- [ ] 2-3 solutions generated with file:line references
-- [ ] Convergence score calculated (0.0-1.0)
-- [ ] synthesis.json written with all Primary Fields
-`
-})
-```
-
-**Read Agent Output**:
-```javascript
-const synthesis = JSON.parse(Read(`${sessionFolder}/rounds/${round}/synthesis.json`))
-// Access top-level fields: solutions, convergence, cross_verification, clarification_questions
-```
-
-**Convergence Decision**:
-```javascript
-if (synthesis.convergence.recommendation === 'converged') {
-  // Proceed to Phase 3
-} else if (synthesis.convergence.recommendation === 'user_input_needed') {
-  // Collect user feedback, return to Phase 2
-} else {
-  // Continue to next round if new_insights && round < maxRounds
-}
-```
-
-### Phase 3: Present Options
-
-**Display from Agent Output** (no processing):
-```javascript
-console.log(`
-## Solution Options
-
-${synthesis.solutions.map((s, i) => `
-**Option ${i+1}: ${s.name}**
-Source: ${s.source_cli.join(' + ')}
-Effort: ${s.effort} | Risk: ${s.risk}
-
-Pros: ${s.pros.join(', ')}
-Cons: ${s.cons.join(', ')}
-
-Files: ${s.affected_files.slice(0,3).map(f => `${f.file}:${f.line}`).join(', ')}
-`).join('\n')}
-
-## Cross-Verification
-Agreements: ${synthesis.cross_verification.agreements.length}
-Disagreements: ${synthesis.cross_verification.disagreements.length}
-`)
-```
-
-### Phase 4: User Decision
-
-**Decision Options**:
-```javascript
-AskUserQuestion({
-  questions: [{
-    question: "Which solution approach?",
-    header: "Solution",
-    options: solutions.map((s, i) => ({
-      label: `Option ${i+1}: ${s.name}`,
-      description: `${s.effort} effort, ${s.risk} risk`
-    })).concat([
-      { label: "Need More Analysis", description: "Return to Phase 2" }
-    ])
-  }]
-})
-```
-
-**Routing**:
-- Approve → Phase 5
-- Need More Analysis → Phase 2 with feedback
-- Add constraints → Collect details, then Phase 5
-
-### Phase 5: Plan Generation
-
-**Step 1: Build Context-Package** (Orchestrator responsibility):
-```javascript
-// Extract key information from user decision and synthesis
-const contextPackage = {
-  // Core solution details
-  solution: {
-    name: selectedSolution.name,
-    source_cli: selectedSolution.source_cli,
-    feasibility: selectedSolution.feasibility,
-    effort: selectedSolution.effort,
-    risk: selectedSolution.risk,
-    summary: selectedSolution.summary
-  },
-  // Implementation plan (tasks, flow, milestones)
-  implementation_plan: selectedSolution.implementation_plan,
-  // Dependencies
-  dependencies: selectedSolution.dependencies || { internal: [], external: [] },
-  // Technical concerns
-  technical_concerns: selectedSolution.technical_concerns || [],
-  // Consensus from cross-verification
-  consensus: {
-    agreements: synthesis.cross_verification.agreements,
-    resolved_conflicts: synthesis.cross_verification.resolution
-  },
-  // User constraints (from Phase 4 feedback)
-  constraints: userConstraints || [],
-  // Task context
-  task_description: taskDescription,
-  session_id: sessionId
-}
-
-// Write context-package for traceability
-Write(`${sessionFolder}/context-package.json`, JSON.stringify(contextPackage, null, 2))
-```
-
-**Context-Package Schema**:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `solution` | object | User-selected solution from synthesis |
-| `solution.name` | string | Solution identifier |
-| `solution.feasibility` | number | Viability score (0-1) |
-| `solution.summary` | string | Brief analysis summary |
-| `implementation_plan` | object | Task breakdown with flow and dependencies |
-| `implementation_plan.approach` | string | High-level technical strategy |
-| `implementation_plan.tasks[]` | array | Discrete tasks with id, name, depends_on, files |
-| `implementation_plan.execution_flow` | string | Task sequence (e.g., "T1 → T2 → T3") |
-| `implementation_plan.milestones` | string[] | Key checkpoints |
-| `dependencies` | object | Module and package dependencies |
-| `technical_concerns` | string[] | Risks and blockers |
-| `consensus` | object | Cross-verified agreements from multi-CLI |
-| `constraints` | string[] | User-specified constraints from Phase 4 |
-
-```json
-{
-  "solution": {
-    "name": "Strategy Pattern Refactoring",
-    "source_cli": ["gemini", "codex"],
-    "feasibility": 0.88,
-    "effort": "medium",
-    "risk": "low",
-    "summary": "Extract payment gateway interface, implement strategy pattern for multi-gateway support"
-  },
-  "implementation_plan": {
-    "approach": "Define interface → Create concrete strategies → Implement factory → Migrate existing code",
-    "tasks": [
-      {"id": "T1", "name": "Define PaymentGateway interface", "depends_on": [], "files": [{"file": "src/types/payment.ts", "line": 1, "action": "create"}], "key_point": "Include all existing Stripe methods"},
-      {"id": "T2", "name": "Implement StripeGateway", "depends_on": ["T1"], "files": [{"file": "src/payment/stripe.ts", "line": 1, "action": "create"}], "key_point": "Wrap existing logic"},
-      {"id": "T3", "name": "Create GatewayFactory", "depends_on": ["T1"], "files": [{"file": "src/payment/factory.ts", "line": 1, "action": "create"}], "key_point": null},
-      {"id": "T4", "name": "Migrate processor to use factory", "depends_on": ["T2", "T3"], "files": [{"file": "src/payment/processor.ts", "line": 45, "action": "modify"}], "key_point": "Backward compatible"}
-    ],
-    "execution_flow": "T1 → (T2 | T3) → T4",
-    "milestones": ["Interface defined", "Gateway implementations complete", "Migration done"]
-  },
-  "dependencies": {
-    "internal": ["@/lib/payment-gateway", "@/types/payment"],
-    "external": ["stripe@^14.0.0"]
-  },
-  "technical_concerns": ["Existing tests must pass", "No breaking API changes"],
-  "consensus": {
-    "agreements": ["Use strategy pattern", "Keep existing API"],
-    "resolved_conflicts": "Factory over DI for simpler integration"
-  },
-  "constraints": ["backward compatible", "no breaking changes to PaymentResult type"],
-  "task_description": "Refactor payment processing for multi-gateway support",
-  "session_id": "MCP-payment-refactor-2026-01-14"
-}
-```
-
-**Step 2: Invoke Planning Agent**:
-```javascript
-Task({
-  subagent_type: "cli-lite-planning-agent",
-  run_in_background: false,
-  description: "Generate implementation plan",
-  prompt: `
-## Schema Reference
-Execute: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json
-
-## Context-Package (from orchestrator)
-${JSON.stringify(contextPackage, null, 2)}
-
-## Execution Process
-1. Read plan-json-schema.json for output structure
-2. Read project-tech.json and project-guidelines.json
-3. Parse context-package fields:
-   - solution: name, feasibility, summary
-   - implementation_plan: tasks[], execution_flow, milestones
-   - dependencies: internal[], external[]
-   - technical_concerns: risks/blockers
-   - consensus: agreements, resolved_conflicts
-   - constraints: user requirements
-4. Use implementation_plan.tasks[] as task foundation
-5. Preserve task dependencies (depends_on) and execution_flow
-6. Expand tasks with detailed acceptance criteria
-7. Generate IMPL_PLAN.md documenting milestones and key_points
-8. Generate plan.json following schema exactly
-
-## Output
-- ${sessionFolder}/IMPL_PLAN.md
-- ${sessionFolder}/plan.json
-
-## Completion Checklist
-- [ ] IMPL_PLAN.md documents approach, milestones, technical_concerns
-- [ ] plan.json preserves task dependencies from implementation_plan
-- [ ] Task execution order follows execution_flow
-- [ ] Key_points reflected in task descriptions
-- [ ] User constraints applied to implementation
-- [ ] Acceptance criteria are testable
-`
-})
-```
-
-**Hand off to Execution**:
-```javascript
-if (userConfirms) {
-  SlashCommand("/workflow:lite-execute --in-memory")
-}
-```
-
-## Output File Structure
-
-```
-.workflow/.multi-cli-plan/{MCP-task-slug-YYYY-MM-DD}/
-├── session-state.json          # Session tracking (orchestrator)
-├── rounds/
-│   ├── 1/synthesis.json        # Round 1 analysis (cli-discuss-agent)
-│   ├── 2/synthesis.json        # Round 2 analysis (cli-discuss-agent)
-│   └── .../
-├── context-package.json        # Extracted context for planning (orchestrator)
-├── IMPL_PLAN.md                # Documentation (cli-lite-planning-agent)
-└── plan.json                   # Structured plan (cli-lite-planning-agent)
-```
-
-**File Producers**:
-
-| File | Producer | Content |
-|------|----------|---------|
-| `session-state.json` | Orchestrator | Session metadata, rounds, decisions |
-| `rounds/*/synthesis.json` | cli-discuss-agent | Solutions, convergence, cross-verification |
-| `context-package.json` | Orchestrator | Extracted solution, dependencies, consensus for planning |
-| `IMPL_PLAN.md` | cli-lite-planning-agent | Human-readable plan |
-| `plan.json` | cli-lite-planning-agent | Structured tasks for execution |
-
-## synthesis.json Schema
-
-```json
-{
-  "round": 1,
-  "solutions": [{
-    "name": "Solution Name",
-    "source_cli": ["gemini", "codex"],
-    "feasibility": 0.85,
-    "effort": "low|medium|high",
-    "risk": "low|medium|high",
-    "summary": "Brief analysis summary",
-    "implementation_plan": {
-      "approach": "High-level technical approach",
-      "tasks": [
-        {"id": "T1", "name": "Task", "depends_on": [], "files": [], "key_point": "..."}
-      ],
-      "execution_flow": "T1 → T2 → T3",
-      "milestones": ["Checkpoint 1", "Checkpoint 2"]
-    },
-    "dependencies": {"internal": [], "external": []},
-    "technical_concerns": ["Risk 1", "Blocker 2"]
-  }],
-  "convergence": {
-    "score": 0.85,
-    "new_insights": false,
-    "recommendation": "converged|continue|user_input_needed"
-  },
-  "cross_verification": {
-    "agreements": [],
-    "disagreements": [],
-    "resolution": "..."
-  },
-  "clarification_questions": []
-}
-```
-
-**Key Planning Fields**:
-
-| Field | Purpose |
-|-------|---------|
-| `feasibility` | Viability score (0-1) |
-| `implementation_plan.tasks[]` | Discrete tasks with dependencies |
-| `implementation_plan.execution_flow` | Task sequence visualization |
-| `implementation_plan.milestones` | Key checkpoints |
-| `technical_concerns` | Risks and blockers |
-
-**Note**: Solutions ranked by internal scoring (array order = priority)
-
-## TodoWrite Structure
-
-**Initialization**:
-```javascript
-TodoWrite({ todos: [
-  { content: "Phase 1: Context Gathering", status: "in_progress", activeForm: "Gathering context" },
-  { content: "Phase 2: Multi-CLI Discussion", status: "pending", activeForm: "Running discussion" },
-  { content: "Phase 3: Present Options", status: "pending", activeForm: "Presenting options" },
-  { content: "Phase 4: User Decision", status: "pending", activeForm: "Awaiting decision" },
-  { content: "Phase 5: Plan Generation", status: "pending", activeForm: "Generating plan" }
-]})
-```
-
-**During Discussion Rounds**:
-```javascript
-TodoWrite({ todos: [
-  { content: "Phase 1: Context Gathering", status: "completed", activeForm: "Gathering context" },
-  { content: "Phase 2: Multi-CLI Discussion", status: "in_progress", activeForm: "Running discussion" },
-  { content: "  → Round 1: Initial analysis", status: "completed", activeForm: "Analyzing" },
-  { content: "  → Round 2: Deep verification", status: "in_progress", activeForm: "Verifying" },
-  { content: "Phase 3: Present Options", status: "pending", activeForm: "Presenting options" },
-  // ...
-]})
-```
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| ACE search fails | Fall back to Glob/Grep for file discovery |
-| Agent fails | Retry once, then present partial results |
-| CLI timeout (in agent) | Agent uses fallback: gemini → codex → claude |
-| No convergence | Present best options, flag uncertainty |
-| synthesis.json parse error | Request agent retry |
-| User cancels | Save session for later resumption |
-
-## Configuration
-
-| Flag | Default | Description |
-|------|---------|-------------|
-| `--max-rounds` | 3 | Maximum discussion rounds |
-| `--tools` | gemini,codex | CLI tools for analysis |
-| `--mode` | parallel | Execution mode: parallel or serial |
-| `--auto-execute` | false | Auto-execute after approval |
-
-## Best Practices
-
-1. **Be Specific**: Detailed task descriptions improve ACE context quality
-2. **Provide Feedback**: Use clarification rounds to refine requirements
-3. **Trust Cross-Verification**: Multi-CLI consensus indicates high confidence
-4. **Review Trade-offs**: Consider pros/cons before selecting solution
-5. **Check synthesis.json**: Review agent output for detailed analysis
-6. **Iterate When Needed**: Don't hesitate to request more analysis
-
-## Related Commands
-
-```bash
-# Resume saved session
-/workflow:lite-execute --session=MCP-xxx
-
-# Simpler single-round planning
-/workflow:lite-plan "task description"
-
-# Issue-driven discovery
-/issue:discover-by-prompt "find issues"
-
-# View session files
-cat .workflow/.multi-cli-plan/{session-id}/IMPL_PLAN.md
-cat .workflow/.multi-cli-plan/{session-id}/rounds/1/synthesis.json
-```

.claude/commands/workflow/plan.md

@@ -9,7 +9,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**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**.
+**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**.
 
 **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 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
+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
 
 **Task Attachment Model**:
-- 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
+- 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
 - 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 execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+6. **Task Attachment Model**: SlashCommand dispatch **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
@@ -61,7 +61,7 @@ Phase 2: Context Gathering
       ├─ Tasks attached: Analyze structure → Identify integration → Generate package
       └─ Output: contextPath + conflict_risk
 
-Phase 3: Conflict Resolution 
+Phase 3: Conflict Resolution (conditional)
    └─ Decision (conflict_risk check):
       ├─ conflict_risk ≥ medium → Execute /workflow:tools:conflict-resolution
       │   ├─ Tasks attached: Detect conflicts → Present to user → Apply strategies
@@ -80,7 +80,7 @@ Return:
 
 ### Phase 1: Session Discovery
 
-**Step 1.1: Execute** - Create or discover workflow session
+**Step 1.1: Dispatch** - 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: Execute** - Gather project context and analyze codebase
+**Step 2.1: Dispatch** - 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 executed, INSERT 3 context-gather tasks, mark first as in_progress -->
+<!-- TodoWrite: When context-gather dispatched, INSERT 3 context-gather tasks, mark first as in_progress -->
 
-**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand dispatched - 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 execute **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand dispatch **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 -->
 
@@ -168,11 +168,11 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 
 ---
 
-### Phase 3: Conflict Resolution
+### Phase 3: Conflict Resolution (Optional - auto-triggered by conflict risk)
 
 **Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Step 3.1: Execute** - Detect and resolve conflicts with CLI analysis
+**Step 3.1: Dispatch** - Detect and resolve conflicts with CLI analysis
 
 ```javascript
 SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
@@ -185,10 +185,10 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 **Parse Output**:
 - Extract: Execution status (success/skipped/failed)
-- Verify: conflict-resolution.json file path (if executed)
+- Verify: CONFLICT_RESOLUTION.md file path (if executed)
 
 **Validation**:
-- File `.workflow/active/[sessionId]/.process/conflict-resolution.json` exists (if executed)
+- File `.workflow/active/[sessionId]/.process/CONFLICT_RESOLUTION.md` exists (if executed)
 
 **Skip Behavior**:
 - If conflict_risk is "none" or "low", skip directly to Phase 3.5
@@ -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 executed - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 3 SlashCommand dispatched - 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 execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand dispatch **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: Execute** - Optimize memory before proceeding
+  **Step 3.2: Dispatch** - 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: Execute** - Generate implementation plan and task JSONs
+**Step 4.1: Dispatch** - 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 executed, ATTACH 1 agent task -->
+<!-- TodoWrite: When task-generate-agent dispatched, ATTACH 1 agent task -->
 
-**TodoWrite Update (Phase 4 SlashCommand executed - agent task attached)**:
+**TodoWrite Update (Phase 4 SlashCommand dispatched - 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 executed):
+1. **Task Attachment** (when SlashCommand dispatched):
    - 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 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.
+**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.
 
 
 
@@ -442,7 +442,7 @@ User triggers: /workflow:plan "Build authentication system"
 Phase 1: Session Discovery
   → sessionId extracted
   ↓
-Phase 2: Context Gathering (SlashCommand executed)
+Phase 2: Context Gathering (SlashCommand dispatched)
   → ATTACH 3 sub-tasks: ← ATTACHED
     - → Analyze codebase structure
     - → Identify integration points
@@ -453,7 +453,7 @@ Phase 2: Context Gathering (SlashCommand executed)
   ↓
 Conditional Branch: Check conflict_risk
   ├─ IF conflict_risk ≥ medium:
-  │   Phase 3: Conflict Resolution (SlashCommand executed)
+  │   Phase 3: Conflict Resolution (SlashCommand dispatched)
   │     → 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 executed)
+Phase 4: Task Generation (SlashCommand dispatched)
   → 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 executed
+- **← ATTACHED**: Tasks attached to TodoWrite when SlashCommand dispatched
   - 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 executes if conflict_risk ≥ medium
+- **Conditional Branch**: Phase 3 only dispatches if conflict_risk ≥ medium
 - **Continuous Flow**: No user intervention between phases
 
 ## Error Handling
@@ -497,7 +497,7 @@ Return summary to user
 - Parse context path from Phase 2 output, store in memory
 - **Extract conflict_risk from context-package.json**: Determine Phase 3 execution
 - **If conflict_risk ≥ medium**: Launch Phase 3 conflict-resolution with sessionId and contextPath
-- Wait for Phase 3 to finish executing (if executed), verify conflict-resolution.json created
+- Wait for Phase 3 to finish executing (if executed), verify CONFLICT_RESOLUTION.md created
 - **If conflict_risk is none/low**: Skip Phase 3, proceed directly to Phase 4
 - **Build Phase 4 command**: `/workflow:tools:task-generate-agent --session [sessionId]`
 - Pass session ID to Phase 4 command

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

@@ -391,7 +391,6 @@ done
 ```javascript
 Task(
   subagent_type="cli-explore-agent",
-  run_in_background=false,
   description=`Execute ${dimension} review analysis via Deep Scan`,
   prompt=`
     ## Task Objective
@@ -409,8 +408,6 @@ 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)
@@ -479,7 +476,6 @@ Task(
 ```javascript
 Task(
   subagent_type="cli-explore-agent",
-  run_in_background=false,
   description=`Deep-dive analysis for critical finding: ${findingTitle} via Dependency Map + Deep Scan`,
   prompt=`
     ## Task Objective
@@ -513,8 +509,6 @@ 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

@@ -401,7 +401,6 @@ git log --since="${sessionCreatedAt}" --name-only --pretty=format: | sort -u
 ```javascript
 Task(
   subagent_type="cli-explore-agent",
-  run_in_background=false,
   description=`Execute ${dimension} review analysis via Deep Scan`,
   prompt=`
     ## Task Objective
@@ -420,8 +419,6 @@ 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}
@@ -490,7 +487,6 @@ Task(
 ```javascript
 Task(
   subagent_type="cli-explore-agent",
-  run_in_background=false,
   description=`Deep-dive analysis for critical finding: ${findingTitle} via Dependency Map + Deep Scan`,
   prompt=`
     ## Task Objective
@@ -524,8 +520,6 @@ 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] [--archived] [optional: session-id]"
+argument-hint: "[--type=security|architecture|action-items|quality] [optional: session-id]"
 ---
 
 ## Command Overview: /workflow:review
@@ -34,17 +34,15 @@ argument-hint: "[--type=security|architecture|action-items|quality] [--archived]
 ```
 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 + --archived → Search .workflow/archives/
-      ├─ session-id provided → Search .workflow/active/ first, then archives
+      ├─ session-id provided → Use provided session
       └─ Not provided → Auto-detect from .workflow/active/
 
 Step 2: Validation
-   ├─ Check session directory exists (active or archived)
+   ├─ Check session directory exists
    └─ Check for completed implementation (.summaries/IMPL-*.md exists)
 
 Step 3: Type Check
@@ -70,29 +68,21 @@ Step 5: Generate Report
 #!/bin/bash
 # Optional specialized review for completed implementation
 
-# Step 1: Session ID resolution and location detection
+# Step 1: Session ID resolution
 if [ -n "$SESSION_ARG" ]; then
     sessionId="$SESSION_ARG"
 else
     sessionId=$(find .workflow/active/ -name "WFS-*" -type d | head -1 | xargs basename)
 fi
 
-# 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"
+# Step 2: Validation
+if [ ! -d ".workflow/active/${sessionId}" ]; then
+    echo "Session ${sessionId} not found"
     exit 1
 fi
 
 # Check for completed tasks
-if [ ! -d "${sessionPath}/.summaries" ] || [ -z "$(find ${sessionPath}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
+if [ ! -d ".workflow/active/${sessionId}/.summaries" ] || [ -z "$(find .workflow/active/${sessionId}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
     echo "No completed implementation found. Complete implementation first"
     exit 1
 fi
@@ -122,18 +112,14 @@ 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 ${sessionPath}/.summaries/*.md; do
-     cat "$summary"
-   done
+   # Load implementation summaries
+   cat .workflow/active/${sessionId}/.summaries/IMPL-*.md
 
    # Load test results (if available)
-   for test_summary in ${sessionPath}/.summaries/TEST-FIX-*.md 2>/dev/null; do
-     cat "$test_summary"
-   done
+   cat .workflow/active/${sessionId}/.summaries/TEST-FIX-*.md 2>/dev/null
 
    # Get changed files
-   git log --since="$(cat ${sessionPath}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
+   git log --since="$(cat .workflow/active/${sessionId}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
    ```
 
 2. **Perform Specialized Review**: Based on `review_type`
@@ -146,56 +132,54 @@ After bash validation, the model takes control to:
      ```
    - Use Gemini for security analysis:
      ```bash
-     ccw cli -p "
+     cd .workflow/active/${sessionId} && gemini -p "
      PURPOSE: Security audit of completed implementation
      TASK: Review code for security vulnerabilities, insecure patterns, auth/authz issues
-     CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
      EXPECTED: Security findings report with severity levels
      RULES: Focus on OWASP Top 10, authentication, authorization, data validation, injection risks
-     " --tool gemini --mode write --cd ${sessionPath}
+     " --approval-mode yolo
      ```
 
    **Architecture Review** (`--type=architecture`):
    - Use Qwen for architecture analysis:
      ```bash
-     ccw cli -p "
+     cd .workflow/active/${sessionId} && qwen -p "
      PURPOSE: Architecture compliance review
      TASK: Evaluate adherence to architectural patterns, identify technical debt, review design decisions
-     CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
      EXPECTED: Architecture assessment with recommendations
      RULES: Check for patterns, separation of concerns, modularity, scalability
-     " --tool qwen --mode write --cd ${sessionPath}
+     " --approval-mode yolo
      ```
 
    **Quality Review** (`--type=quality`):
    - Use Gemini for code quality:
      ```bash
-     ccw cli -p "
+     cd .workflow/active/${sessionId} && gemini -p "
      PURPOSE: Code quality and best practices review
      TASK: Assess code readability, maintainability, adherence to best practices
-     CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
      EXPECTED: Quality assessment with improvement suggestions
      RULES: Check for code smells, duplication, complexity, naming conventions
-     " --tool gemini --mode write --cd ${sessionPath}
+     " --approval-mode yolo
      ```
 
    **Action Items Review** (`--type=action-items`):
    - Verify all requirements and acceptance criteria met:
      ```bash
      # Load task requirements and acceptance criteria
-     for task_file in ${sessionPath}/.task/*.json; do
-       cat "$task_file" | jq -r '
-         "Task: " + .id + "\n" +
-         "Requirements: " + (.context.requirements | join(", ")) + "\n" +
-         "Acceptance: " + (.context.acceptance | join(", "))
-       '
-     done
+     find .workflow/active/${sessionId}/.task -name "IMPL-*.json" -exec jq -r '
+       "Task: " + .id + "\n" +
+       "Requirements: " + (.context.requirements | join(", ")) + "\n" +
+       "Acceptance: " + (.context.acceptance | join(", "))
+     ' {} \;
 
      # Check implementation summaries against requirements
-     ccw cli -p "
+     cd .workflow/active/${sessionId} && gemini -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,../.. @../../project-tech.json @../../project-guidelines.json
+     CONTEXT: @.task/IMPL-*.json,.summaries/IMPL-*.md,../.. @../../CLAUDE.md
      EXPECTED:
      - Requirements coverage matrix
      - Acceptance criteria verification
@@ -206,7 +190,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 ${sessionPath}
+     " --approval-mode yolo
      ```
 
 
@@ -244,7 +228,7 @@ After bash validation, the model takes control to:
 4. **Output Files**:
    ```bash
    # Save review report
-   Write(${sessionPath}/REVIEW-${review_type}.md)
+   Write(.workflow/active/${sessionId}/REVIEW-${review_type}.md)
 
    # Update session metadata
    # (optional) Update workflow-session.json with review status
@@ -271,12 +255,6 @@ 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
 ```
@@ -286,7 +264,6 @@ 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
@@ -312,11 +289,3 @@ 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/complete.md

@@ -8,146 +8,493 @@ examples:
 
 # Complete Workflow Session (/workflow:session:complete)
 
-Mark the currently active workflow session as complete, archive it, and update manifests.
-
-## Pre-defined Commands
+## Overview
+Mark the currently active workflow session as complete, analyze it for lessons learned, move it to the archive directory, and remove the active flag marker.
 
+## Usage
 ```bash
-# Phase 1: Find active session
-SESSION_PATH=$(find .workflow/active/ -maxdepth 1 -name "WFS-*" -type d | head -1)
-SESSION_ID=$(basename "$SESSION_PATH")
-
-# Phase 3: Move to archive
-mkdir -p .workflow/archives/
-mv .workflow/active/$SESSION_ID .workflow/archives/$SESSION_ID
-
-# Cleanup marker
-rm -f .workflow/archives/$SESSION_ID/.archiving
+/workflow:session:complete           # Complete current active session
+/workflow:session:complete --detailed # Show detailed completion summary
 ```
 
-## Key Files to Read
+## Implementation Flow
 
-**For manifest.json generation**, read ONLY these files:
+### Phase 1: Pre-Archival Preparation (Transactional Setup)
 
-| File | Extract |
-|------|---------|
-| `$SESSION_PATH/workflow-session.json` | session_id, description, started_at, status |
-| `$SESSION_PATH/IMPL_PLAN.md` | title (first # heading), description (first paragraph) |
-| `$SESSION_PATH/.tasks/*.json` | count files |
-| `$SESSION_PATH/.summaries/*.md` | count files |
-| `$SESSION_PATH/.review/dimensions/*.json` | count + findings summary (optional) |
-
-## Execution Flow
-
-### Phase 1: Find Session (2 commands)
+**Purpose**: Find active session, create archiving marker to prevent concurrent operations. Session remains in active location for agent processing.
 
+#### Step 1.1: Find Active Session and Get Name
 ```bash
-# 1. Find and extract session
-SESSION_PATH=$(find .workflow/active/ -maxdepth 1 -name "WFS-*" -type d | head -1)
-SESSION_ID=$(basename "$SESSION_PATH")
+# Find active session directory
+bash(find .workflow/active/ -name "WFS-*" -type d | head -1)
 
-# 2. Check/create archiving marker
-test -f "$SESSION_PATH/.archiving" && echo "RESUMING" || touch "$SESSION_PATH/.archiving"
+# Extract session name from directory path
+bash(basename .workflow/active/WFS-session-name)
+```
+**Output**: Session name `WFS-session-name`
+
+#### Step 1.2: Check for Existing Archiving Marker (Resume Detection)
+```bash
+# Check if session is already being archived
+bash(test -f .workflow/active/WFS-session-name/.archiving && echo "RESUMING" || echo "NEW")
 ```
 
-**Output**: `SESSION_ID` = e.g., `WFS-auth-feature`
+**If RESUMING**:
+- Previous archival attempt was interrupted
+- Skip to Phase 2 to resume agent analysis
 
-### Phase 2: Generate Manifest Entry (Read-only)
+**If NEW**:
+- Continue to Step 1.3
 
-Read the key files above, then build this structure:
+#### Step 1.3: Create Archiving Marker
+```bash
+# Mark session as "archiving in progress"
+bash(touch .workflow/active/WFS-session-name/.archiving)
+```
+**Purpose**:
+- Prevents concurrent operations on this session
+- Enables recovery if archival fails
+- Session remains in `.workflow/active/` for agent analysis
 
-```json
-{
-  "session_id": "<from workflow-session.json>",
-  "description": "<from workflow-session.json>",
-  "archived_at": "<current ISO timestamp>",
-  "archive_path": ".workflow/archives/<SESSION_ID>",
-  "metrics": {
-    "duration_hours": "<(completed_at - started_at) / 3600000>",
-    "tasks_completed": "<count .tasks/*.json>",
-    "summaries_generated": "<count .summaries/*.md>",
-    "review_metrics": {
-      "dimensions_analyzed": "<count .review/dimensions/*.json>",
-      "total_findings": "<sum from dimension JSONs>"
-    }
+**Result**: Session still at `.workflow/active/WFS-session-name/` with `.archiving` marker
+
+### Phase 2: Agent Analysis (In-Place Processing)
+
+**Purpose**: Agent analyzes session WHILE STILL IN ACTIVE LOCATION. Generates metadata but does NOT move files or update manifest.
+
+#### Agent Invocation
+
+Invoke `universal-executor` agent to analyze session and prepare archive metadata.
+
+**Agent Task**:
+```
+Task(
+  subagent_type="universal-executor",
+  description="Analyze session for archival",
+  prompt=`
+Analyze workflow session for archival preparation. Session is STILL in active location.
+
+## Context
+- Session: .workflow/active/WFS-session-name/
+- Status: Marked as archiving (.archiving marker present)
+- Location: Active sessions directory (NOT archived yet)
+
+## Tasks
+
+1. **Extract session data** from workflow-session.json
+   - session_id, description/topic, started_at, completed_at, status
+   - If status != "completed", update it with timestamp
+
+2. **Count files**: tasks (.task/*.json) and summaries (.summaries/*.md)
+
+3. **Extract review data** (if .review/ exists):
+   - Count dimension results: .review/dimensions/*.json
+   - Count deep-dive results: .review/iterations/*.json
+   - Extract findings summary from dimension JSONs (total, critical, high, medium, low)
+   - Check fix results if .review/fixes/ exists (fixed_count, failed_count)
+   - Build review_metrics: {dimensions_analyzed, total_findings, severity_distribution, fix_success_rate}
+
+4. **Generate lessons**: Use gemini with ~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt
+   - Return: {successes, challenges, watch_patterns}
+   - If review data exists, include review-specific lessons (common issue patterns, effective fixes)
+
+5. **Build archive entry**:
+   - Calculate: duration_hours, success_rate, tags (3-5 keywords)
+   - Construct complete JSON with session_id, description, archived_at, metrics, tags, lessons
+   - Include archive_path: ".workflow/archives/WFS-session-name" (future location)
+   - If review data exists, include review_metrics in metrics object
+
+6. **Extract feature metadata** (for Phase 4):
+   - Parse IMPL_PLAN.md for title (first # heading)
+   - Extract description (first paragraph, max 200 chars)
+   - Generate feature tags (3-5 keywords from content)
+
+7. **Return result**: Complete metadata package for atomic commit
+   {
+     "status": "success",
+     "session_id": "WFS-session-name",
+     "archive_entry": {
+       "session_id": "...",
+       "description": "...",
+       "archived_at": "...",
+       "archive_path": ".workflow/archives/WFS-session-name",
+       "metrics": {
+         "duration_hours": 2.5,
+         "tasks_completed": 5,
+         "summaries_generated": 3,
+         "review_metrics": {                    // Optional, only if .review/ exists
+           "dimensions_analyzed": 4,
+           "total_findings": 15,
+           "severity_distribution": {"critical": 1, "high": 3, "medium": 8, "low": 3},
+           "fix_success_rate": 0.87             // Optional, only if .review/fixes/ exists
+         }
+       },
+       "tags": [...],
+       "lessons": {...}
+     },
+     "feature_metadata": {
+       "title": "...",
+       "description": "...",
+       "tags": [...]
+     }
+   }
+
+## Important Constraints
+- DO NOT move or delete any files
+- DO NOT update manifest.json yet
+- Session remains in .workflow/active/ during analysis
+- Return complete metadata package for orchestrator to commit atomically
+
+## Error Handling
+- On failure: return {"status": "error", "task": "...", "message": "..."}
+- Do NOT modify any files on error
+  `
+)
+```
+
+**Expected Output**:
+- Agent returns complete metadata package
+- Session remains in `.workflow/active/` with `.archiving` marker
+- No files moved or manifests updated yet
+
+### Phase 3: Atomic Commit (Transactional File Operations)
+
+**Purpose**: Atomically commit all changes. Only execute if Phase 2 succeeds.
+
+#### Step 3.1: Create Archive Directory
+```bash
+bash(mkdir -p .workflow/archives/)
+```
+
+#### Step 3.2: Move Session to Archive
+```bash
+bash(mv .workflow/active/WFS-session-name .workflow/archives/WFS-session-name)
+```
+**Result**: Session now at `.workflow/archives/WFS-session-name/`
+
+#### Step 3.3: Update Manifest
+```bash
+# Read current manifest (or create empty array if not exists)
+bash(test -f .workflow/archives/manifest.json && cat .workflow/archives/manifest.json || echo "[]")
+```
+
+**JSON Update Logic**:
+```javascript
+// Read agent result from Phase 2
+const agentResult = JSON.parse(agentOutput);
+const archiveEntry = agentResult.archive_entry;
+
+// Read existing manifest
+let manifest = [];
+try {
+  const manifestContent = Read('.workflow/archives/manifest.json');
+  manifest = JSON.parse(manifestContent);
+} catch {
+  manifest = []; // Initialize if not exists
+}
+
+// Append new entry
+manifest.push(archiveEntry);
+
+// Write back
+Write('.workflow/archives/manifest.json', JSON.stringify(manifest, null, 2));
+```
+
+#### Step 3.4: Remove Archiving Marker
+```bash
+bash(rm .workflow/archives/WFS-session-name/.archiving)
+```
+**Result**: Clean archived session without temporary markers
+
+**Output Confirmation**:
+```
+✓ Session "${sessionId}" archived successfully
+  Location: .workflow/archives/WFS-session-name/
+  Lessons: ${archiveEntry.lessons.successes.length} successes, ${archiveEntry.lessons.challenges.length} challenges
+  Manifest: Updated with ${manifest.length} total sessions
+  ${reviewMetrics ? `Review: ${reviewMetrics.total_findings} findings across ${reviewMetrics.dimensions_analyzed} dimensions, ${Math.round(reviewMetrics.fix_success_rate * 100)}% fixed` : ''}
+```
+
+### Phase 4: Update Project Feature Registry
+
+**Purpose**: Record completed session as a project feature in `.workflow/project.json`.
+
+**Execution**: Uses feature metadata from Phase 2 agent result to update project registry.
+
+#### Step 4.1: Check Project State Exists
+```bash
+bash(test -f .workflow/project.json && echo "EXISTS" || echo "SKIP")
+```
+
+**If SKIP**: Output warning and skip Phase 4
+```
+WARNING: No project.json found. Run /workflow:session:start to initialize.
+```
+
+#### Step 4.2: Extract Feature Information from Agent Result
+
+**Data Processing** (Uses Phase 2 agent output):
+```javascript
+// Extract feature metadata from agent result
+const agentResult = JSON.parse(agentOutput);
+const featureMeta = agentResult.feature_metadata;
+
+// Data already prepared by agent:
+const title = featureMeta.title;
+const description = featureMeta.description;
+const tags = featureMeta.tags;
+
+// Create feature ID (lowercase slug)
+const featureId = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 50);
+```
+
+#### Step 4.3: Update project.json
+
+```bash
+# Read current project state
+bash(cat .workflow/project.json)
+```
+
+**JSON Update Logic**:
+```javascript
+// Read existing project.json (created by /workflow:init)
+// Note: overview field is managed by /workflow:init, not modified here
+const projectMeta = JSON.parse(Read('.workflow/project.json'));
+const currentTimestamp = new Date().toISOString();
+const currentDate = currentTimestamp.split('T')[0]; // YYYY-MM-DD
+
+// Extract tags from IMPL_PLAN.md (simple keyword extraction)
+const tags = extractTags(planContent); // e.g., ["auth", "security"]
+
+// Build feature object with complete metadata
+const newFeature = {
+  id: featureId,
+  title: title,
+  description: description,
+  status: "completed",
+  tags: tags,
+  timeline: {
+    created_at: currentTimestamp,
+    implemented_at: currentDate,
+    updated_at: currentTimestamp
   },
-  "tags": ["<3-5 keywords from IMPL_PLAN.md>"],
-  "lessons": {
-    "successes": ["<key wins>"],
-    "challenges": ["<difficulties>"],
-    "watch_patterns": ["<patterns to monitor>"]
+  traceability: {
+    session_id: sessionId,
+    archive_path: archivePath, // e.g., ".workflow/archives/WFS-auth-system"
+    commit_hash: getLatestCommitHash() || "" // Optional: git rev-parse HEAD
+  },
+  docs: [],      // Placeholder for future doc links
+  relations: []  // Placeholder for feature dependencies
+};
+
+// Add new feature to array
+projectMeta.features.push(newFeature);
+
+// Update statistics
+projectMeta.statistics.total_features = projectMeta.features.length;
+projectMeta.statistics.total_sessions += 1;
+projectMeta.statistics.last_updated = currentTimestamp;
+
+// Write back
+Write('.workflow/project.json', JSON.stringify(projectMeta, null, 2));
+```
+
+**Helper Functions**:
+```javascript
+// Extract tags from IMPL_PLAN.md content
+function extractTags(planContent) {
+  const tags = [];
+
+  // Look for common keywords
+  const keywords = {
+    'auth': /authentication|login|oauth|jwt/i,
+    'security': /security|encrypt|hash|token/i,
+    'api': /api|endpoint|rest|graphql/i,
+    'ui': /component|page|interface|frontend/i,
+    'database': /database|schema|migration|sql/i,
+    'test': /test|testing|spec|coverage/i
+  };
+
+  for (const [tag, pattern] of Object.entries(keywords)) {
+    if (pattern.test(planContent)) {
+      tags.push(tag);
+    }
+  }
+
+  return tags.slice(0, 5); // Max 5 tags
+}
+
+// Get latest git commit hash (optional)
+function getLatestCommitHash() {
+  try {
+    const result = Bash({
+      command: "git rev-parse --short HEAD 2>/dev/null",
+      description: "Get latest commit hash"
+    });
+    return result.trim();
+  } catch {
+    return "";
   }
 }
 ```
 
-**Lessons Generation**: Use gemini with `~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt`
+#### Step 4.4: Output Confirmation
 
-### Phase 3: Atomic Commit (4 commands)
-
-```bash
-# 1. Create archive directory
-mkdir -p .workflow/archives/
-
-# 2. Move session
-mv .workflow/active/$SESSION_ID .workflow/archives/$SESSION_ID
-
-# 3. Update manifest.json (Read → Append → Write)
-# Read: .workflow/archives/manifest.json (or [])
-# Append: archive_entry from Phase 2
-# Write: updated JSON
-
-# 4. Remove marker
-rm -f .workflow/archives/$SESSION_ID/.archiving
+```
+✓ Feature "${title}" added to project registry
+  ID: ${featureId}
+  Session: ${sessionId}
+  Location: .workflow/project.json
 ```
 
-**Output**:
-```
-✓ Session "$SESSION_ID" archived successfully
-  Location: .workflow/archives/$SESSION_ID/
-  Manifest: Updated with N total sessions
-```
+**Error Handling**:
+- If project.json malformed: Output error, skip update
+- If feature_metadata missing from agent result: Skip Phase 4
+- If extraction fails: Use minimal defaults
 
-### Phase 4: Update project.json (Optional)
-
-**Skip if**: `.workflow/project.json` doesn't exist
-
-```bash
-# Check
-test -f .workflow/project.json || echo "SKIP"
-```
-
-**If exists**, add feature entry:
-
-```json
-{
-  "id": "<slugified title>",
-  "title": "<from IMPL_PLAN.md>",
-  "status": "completed",
-  "tags": ["<from Phase 2>"],
-  "timeline": { "implemented_at": "<date>" },
-  "traceability": { "session_id": "<SESSION_ID>", "archive_path": "<path>" }
-}
-```
-
-**Output**:
-```
-✓ Feature added to project registry
-```
+**Phase 4 Total Commands**: 1 bash read + JSON manipulation
 
 ## Error Recovery
 
-| Phase | Symptom | Recovery |
-|-------|---------|----------|
-| 1 | No active session | `No active session found` |
-| 2 | Analysis fails | Remove marker: `rm $SESSION_PATH/.archiving`, retry |
-| 3 | Move fails | Session safe in active/, fix issue, retry |
-| 3 | Manifest fails | Session in archives/, manually add entry, remove marker |
+### If Agent Fails (Phase 2)
 
-## Quick Reference
+**Symptoms**:
+- Agent returns `{"status": "error", ...}`
+- Agent crashes or times out
+- Analysis incomplete
 
+**Recovery Steps**:
+```bash
+# Session still in .workflow/active/WFS-session-name
+# Remove archiving marker
+bash(rm .workflow/active/WFS-session-name/.archiving)
 ```
-Phase 1: find session → create .archiving marker
-Phase 2: read key files → build manifest entry (no writes)
-Phase 3: mkdir → mv → update manifest.json → rm marker
-Phase 4: update project.json features array (optional)
+
+**User Notification**:
 ```
+ERROR: Session archival failed during analysis phase
+Reason: [error message from agent]
+Session remains active in: .workflow/active/WFS-session-name
+
+Recovery:
+1. Fix any issues identified in error message
+2. Retry: /workflow:session:complete
+
+Session state: SAFE (no changes committed)
+```
+
+### If Move Fails (Phase 3)
+
+**Symptoms**:
+- `mv` command fails
+- Permission denied
+- Disk full
+
+**Recovery Steps**:
+```bash
+# Archiving marker still present
+# Session still in .workflow/active/ (move failed)
+# No manifest updated yet
+```
+
+**User Notification**:
+```
+ERROR: Session archival failed during move operation
+Reason: [mv error message]
+Session remains in: .workflow/active/WFS-session-name
+
+Recovery:
+1. Fix filesystem issues (permissions, disk space)
+2. Retry: /workflow:session:complete
+   - System will detect .archiving marker
+   - Will resume from Phase 2 (agent analysis)
+
+Session state: SAFE (analysis complete, ready to retry move)
+```
+
+### If Manifest Update Fails (Phase 3)
+
+**Symptoms**:
+- JSON parsing error
+- Write permission denied
+- Session moved but manifest not updated
+
+**Recovery Steps**:
+```bash
+# Session moved to .workflow/archives/WFS-session-name
+# Manifest NOT updated
+# Archiving marker still present in archived location
+```
+
+**User Notification**:
+```
+ERROR: Session archived but manifest update failed
+Reason: [error message]
+Session location: .workflow/archives/WFS-session-name
+
+Recovery:
+1. Fix manifest.json issues (syntax, permissions)
+2. Manual manifest update:
+   - Add archive entry from agent output
+   - Remove .archiving marker: rm .workflow/archives/WFS-session-name/.archiving
+
+Session state: PARTIALLY COMPLETE (session archived, manifest needs update)
+```
+
+## Workflow Execution Strategy
+
+### Transactional Four-Phase Approach
+
+**Phase 1: Pre-Archival Preparation** (Marker creation)
+- Find active session and extract name
+- Check for existing `.archiving` marker (resume detection)
+- Create `.archiving` marker if new
+- **No data processing** - just state tracking
+- **Total**: 2-3 bash commands (find + marker check/create)
+
+**Phase 2: Agent Analysis** (Read-only data processing)
+- Extract all session data from active location
+- Count tasks and summaries
+- Extract review data if .review/ exists (dimension results, findings, fix results)
+- Generate lessons learned analysis (including review-specific lessons if applicable)
+- Extract feature metadata from IMPL_PLAN.md
+- Build complete archive + feature metadata package (with review_metrics if applicable)
+- **No file modifications** - pure analysis
+- **Total**: 1 agent invocation
+
+**Phase 3: Atomic Commit** (Transactional file operations)
+- Create archive directory
+- Move session to archive location
+- Update manifest.json with archive entry
+- Remove `.archiving` marker
+- **All-or-nothing**: Either all succeed or session remains in safe state
+- **Total**: 4 bash commands + JSON manipulation
+
+**Phase 4: Project Registry Update** (Optional feature tracking)
+- Check project.json exists
+- Use feature metadata from Phase 2 agent result
+- Build feature object with complete traceability
+- Update project statistics
+- **Independent**: Can fail without affecting archival
+- **Total**: 1 bash read + JSON manipulation
+
+### Transactional Guarantees
+
+**State Consistency**:
+- Session NEVER in inconsistent state
+- `.archiving` marker enables safe resume
+- Agent failure leaves session in recoverable state
+- Move/manifest operations grouped in Phase 3
+
+**Failure Isolation**:
+- Phase 1 failure: No changes made
+- Phase 2 failure: Session still active, can retry
+- Phase 3 failure: Clear error state, manual recovery documented
+- Phase 4 failure: Does not affect archival success
+
+**Resume Capability**:
+- Detect interrupted archival via `.archiving` marker
+- Resume from Phase 2 (skip marker creation)
+- Idempotent operations (safe to retry)
+
+

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

@@ -1,299 +0,0 @@
----
-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,29 +38,26 @@ 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 files exist by calling `/workflow:init`.
+**Executed before all modes** - Ensures project-level state file exists by calling `/workflow:init`.
 
 ### Check and Initialize
 ```bash
-# 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")
+# Check if project state exists
+bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
 ```
 
-**If either NOT_FOUND**, delegate to `/workflow:init`:
+**If NOT_FOUND**, delegate to `/workflow:init`:
 ```javascript
 // Call workflow:init for intelligent project analysis
 SlashCommand({command: "/workflow:init"});
 
 // Wait for init completion
-// project-tech.json and project-guidelines.json will be created
+// project.json will be created with comprehensive project overview
 ```
 
 **Output**:
-- 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
+- If EXISTS: `PROJECT_STATE: initialized`
+- If NOT_FOUND: Calls `/workflow:init` → creates `.workflow/project.json` with full project analysis
 
 **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**: Executes 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**: Dispatches 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 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
+- 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
 - 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 execute next pending phase
+- When each phase finishes executing, automatically dispatch 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 execute Phase 1
+1. **Start Immediately**: First action is TodoWrite initialization, second action is dispatch 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 execute next pending phase automatically
+4. **Auto-Continue via TodoList**: Check TodoList status to dispatch 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 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
+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
 
 ## 6-Phase Execution (with Conflict Resolution)
 
 ### Phase 1: Session Discovery
 
-**Step 1.1: Execute** - Session discovery and initialization
+**Step 1.1: Dispatch** - 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: Execute** - Context gathering and analysis
+**Step 2.1: Dispatch** - 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: Execute** - Test coverage analysis and framework detection
+**Step 3.1: Dispatch** - 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 executed, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather dispatched, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand dispatched - 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 execute **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand dispatch **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: Execute** - Conflict detection and resolution
+**Step 4.1: Dispatch** - Conflict detection and resolution
 
 ```javascript
 SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
@@ -164,18 +164,18 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 **Parse Output**:
 - Extract: Execution status (success/skipped/failed)
-- Verify: conflict-resolution.json file path (if executed)
+- Verify: CONFLICT_RESOLUTION.md file path (if executed)
 
 **Validation**:
-- File `.workflow/active/[sessionId]/.process/conflict-resolution.json` exists (if executed)
+- File `.workflow/active/[sessionId]/.process/CONFLICT_RESOLUTION.md` exists (if executed)
 
 **Skip Behavior**:
 - If conflict_risk is "none" or "low", skip directly to Phase 5
 - Display: "No significant conflicts detected, proceeding to TDD task generation"
 
-<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when executed -->
+<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when dispatched -->
 
-**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 4 SlashCommand dispatched - 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 execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand dispatch **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: Execute** - Memory compaction
+  **Step 4.5: Dispatch** - 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: Execute** - TDD task generation via action-planning-agent
+**Step 5.1: Dispatch** - 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 executed, INSERT 3 task-generate-tdd tasks -->
+<!-- TodoWrite: When task-generate-tdd dispatched, INSERT 3 task-generate-tdd tasks -->
 
-**TodoWrite Update (Phase 5 SlashCommand executed - tasks attached)**:
+**TodoWrite Update (Phase 5 SlashCommand dispatched - 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 execute **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
+**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.
 
 **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 executed):
+1. **Task Attachment** (when SlashCommand dispatched):
    - 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 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.
+**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.
 
 ### TDD-Specific Features
 
@@ -402,7 +402,7 @@ TDD Workflow Orchestrator
 │     ├─ Phase 4.1: Detect conflicts with CLI
 │     ├─ Phase 4.2: Present conflicts to user
 │     └─ Phase 4.3: Apply resolution strategies
-│     └─ Returns: conflict-resolution.json            ← COLLAPSED
+│     └─ Returns: CONFLICT_RESOLUTION.md              ← COLLAPSED
 │  ELSE:
 │  └─ Skip to Phase 5
 │

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

@@ -77,32 +77,18 @@ find .workflow/active/ -name "WFS-*" -type d | head -1 | sed 's/.*\///'
 
 ```bash
 # Load all task JSONs
-for task_file in .workflow/active/{sessionId}/.task/*.json; do
-  cat "$task_file"
-done
+find .workflow/active/{sessionId}/.task/ -name '*.json'
 
 # Extract task IDs
-for task_file in .workflow/active/{sessionId}/.task/*.json; do
-  cat "$task_file" | jq -r '.id'
-done
+find .workflow/active/{sessionId}/.task/ -name '*.json' -exec jq -r '.id' {} \;
 
-# Check dependencies - read tasks and filter for IMPL/REFACTOR
-for task_file in .workflow/active/{sessionId}/.task/IMPL-*.json; do
-  cat "$task_file" | jq -r '.context.depends_on[]?'
-done
-
-for task_file in .workflow/active/{sessionId}/.task/REFACTOR-*.json; do
-  cat "$task_file" | jq -r '.context.depends_on[]?'
-done
+# Check dependencies
+find .workflow/active/{sessionId}/.task/ -name 'IMPL-*.json' -exec jq -r '.context.depends_on[]?' {} \;
+find .workflow/active/{sessionId}/.task/ -name 'REFACTOR-*.json' -exec jq -r '.context.depends_on[]?' {} \;
 
 # Check meta fields
-for task_file in .workflow/active/{sessionId}/.task/*.json; do
-  cat "$task_file" | jq -r '.meta.tdd_phase'
-done
-
-for task_file in .workflow/active/{sessionId}/.task/*.json; do
-  cat "$task_file" | jq -r '.meta.agent'
-done
+find .workflow/active/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.tdd_phase' {} \;
+find .workflow/active/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.agent' {} \;
 ```
 
 **Validation**:
@@ -141,7 +127,7 @@ done
 **Gemini analysis for comprehensive TDD compliance report**
 
 ```bash
-ccw cli -p "
+cd project-root && gemini -p "
 PURPOSE: Generate TDD compliance report
 TASK: Analyze TDD workflow execution and generate quality report
 CONTEXT: @{.workflow/active/{sessionId}/.task/*.json,.workflow/active/{sessionId}/.summaries/*,.workflow/active/{sessionId}/.process/tdd-cycle-report.md}
@@ -153,7 +139,7 @@ EXPECTED:
 - Red-Green-Refactor cycle validation
 - Best practices adherence assessment
 RULES: Focus on TDD best practices and workflow adherence. Be specific about violations and improvements.
-" --tool gemini --mode analysis --cd project-root > .workflow/active/{sessionId}/TDD_COMPLIANCE_REPORT.md
+" > .workflow/active/{sessionId}/TDD_COMPLIANCE_REPORT.md
 ```
 
 **Output**: TDD_COMPLIANCE_REPORT.md

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

@@ -221,7 +221,6 @@ return "conservative";
 ```javascript
 Task(
   subagent_type="cli-planning-agent",
-  run_in_background=false,
   description=`Analyze test failures (iteration ${N}) - ${strategy} strategy`,
   prompt=`
     ## Task Objective
@@ -272,7 +271,6 @@ Task(
 ```javascript
 Task(
   subagent_type="test-fix-agent",
-  run_in_background=false,
   description=`Execute ${task.meta.type}: ${task.title}`,
   prompt=`
     ## Task Objective

.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 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
+- 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
 - 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 execute Phase 1 session creation
+1. **Start Immediately**: First action is TodoWrite, second is dispatch 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 execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+9. **Task Attachment Model**: SlashCommand dispatch **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: Execute** - Create test workflow session with preserved intent
+**Step 1.1: Dispatch** - 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: Execute** - Gather test context via appropriate method
+**Step 2.1: Dispatch** - 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: Execute** - Generate test requirements using Gemini
+**Step 3.1: Dispatch** - 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: Execute** - Generate test task JSONs
+**Step 4.1: Dispatch** - 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 executed):
+1. **Task Attachment** (when SlashCommand dispatched):
    - 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 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.
+**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.
 
 #### 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 executed (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- When a sub-command is dispatched (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: Execute** - Create new test workflow session with preserved intent
+**Step 1.1: Dispatch** - 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: Execute** - Gather test coverage context from source session
+**Step 2.1: Dispatch** - 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 executed, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather dispatched, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand dispatched - 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: Execute** - Analyze test requirements with Gemini
+**Step 3.1: Dispatch** - 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 executed, INSERT 3 concept-enhanced tasks -->
+<!-- TodoWrite: When test-concept-enhanced dispatched, INSERT 3 concept-enhanced tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand dispatched - 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: Execute** - Generate test task JSON files and planning documents
+**Step 4.1: Dispatch** - 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 executed, INSERT 3 test-task-generate tasks -->
+<!-- TodoWrite: When test-task-generate dispatched, INSERT 3 test-task-generate tasks -->
 
-**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached)**:
+**TodoWrite Update (Phase 4 SlashCommand dispatched - 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 executed):
+1. **Task Attachment** (when SlashCommand dispatched):
    - 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 executed (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 dispatched (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
 
-**Executed by This Command** (4 phases):
+**Dispatched 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

@@ -108,7 +108,7 @@ Phase 4: Apply Modifications
 
 **Agent Delegation**:
 ```javascript
-Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
+Task(subagent_type="cli-execution-agent", prompt=`
   ## Context
   - Session: {session_id}
   - Risk: {conflict_risk}
@@ -124,9 +124,6 @@ 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
@@ -136,7 +133,7 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
   ### 2. Execute CLI Analysis (Enhanced with Exploration + Scenario Uniqueness)
 
   Primary (Gemini):
-  ccw cli -p "
+  cd {project_root} && gemini -p "
   PURPOSE: Detect conflicts between plan and codebase, using exploration insights
   TASK:
   • **Review pre-identified conflict_indicators from exploration results**
@@ -155,7 +152,7 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
     - ModuleOverlap conflicts with overlap_analysis
     - Targeted clarification questions
   RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on breaking changes, migration needs, and functional overlaps | Prioritize exploration-identified conflicts | analysis=READ-ONLY
-  " --tool gemini --mode analysis --cd {project_root}
+  "
 
   Fallback: Qwen (same prompt) → Claude (manual analysis)
 
@@ -172,16 +169,125 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
 
   ### 4. Return Structured Conflict Data
 
-  ⚠️ Output to conflict-resolution.json (generated in Phase 4)
+  ⚠️ DO NOT generate CONFLICT_RESOLUTION.md file
 
-  **Schema Reference**: Execute \`cat ~/.claude/workflows/cli-templates/schemas/conflict-resolution-schema.json\` to get full schema
+  Return JSON format for programmatic processing:
 
-  Return JSON following the schema above. Key requirements:
+  \`\`\`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)
   - Minimum 2 strategies per conflict, max 4
-  - 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
+  - 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.)
 `)
 ```
 
@@ -206,85 +312,143 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
 8. Return execution log path
 ```
 
-### Phase 3: User Interaction Loop
+### Phase 3: Iterative User Interaction with Clarification Loop
 
-```javascript
-FOR each conflict:
-  round = 0, clarified = false, userClarifications = []
+**Execution Flow**:
+```
+FOR each conflict (逐个处理，无数量限制):
+  clarified = false
+  round = 0
+  userClarifications = []
 
-  WHILE (!clarified && round++ < 10):
-    // 1. Display conflict info (text output for context)
-    displayConflictSummary(conflict)  // id, brief, severity, overlap_analysis if ModuleOverlap
+  WHILE (!clarified && round < 10):
+    round++
 
-    // 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('; ')}` }
-        ]
-      }]
-    })
+    // 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}
 
-    // 3. Handle selection
-    if (userChoice === "自定义修改") {
-      customConflicts.push({ id, brief, category, suggestions, overlap_analysis })
-      break
-    }
+    // 2. Display strategies (2-4个策略 + 自定义选项)
+    - FOR each strategy: {name, approach, complexity, risk, effort, pros, cons}
+      * IF clarification_needed: 展示待澄清问题列表
+    - 自定义选项: {suggestions: modification_suggestions[]}
 
-    selectedStrategy = findStrategyByName(userChoice)
+    // 3. User selects strategy
+    userChoice = readInput()
 
-    // 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))
-      }
+    IF userChoice == "自定义":
+      customConflicts.push({id, brief, category, suggestions, overlap_analysis})
+      clarified = true
+      BREAK
 
-      // 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 }`
+    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: [] (如果仍有歧义)
+        }
       })
 
-      if (reanalysisResult.uniqueness_confirmed) {
-        selectedStrategy = { ...reanalysisResult.updated_strategy, clarifications: userClarifications }
+      IF reanalysisResult.uniqueness_confirmed:
+        selectedStrategy = updated_strategy
+        selectedStrategy.clarifications = userClarifications
         clarified = true
-      } else {
-        selectedStrategy.clarification_needed = reanalysisResult.remaining_questions
-      }
-    } else {
+      ELSE:
+        // 更新澄清问题，继续下一轮
+        selectedStrategy.clarification_needed = remaining_questions
+    ELSE:
       clarified = true
-    }
 
-    if (clarified) resolvedConflicts.push({ conflict, strategy: selectedStrategy })
+    resolvedConflicts.push({conflict, strategy: selectedStrategy})
   END WHILE
 END FOR
 
+// Build output
 selectedStrategies = resolvedConflicts.map(r => ({
-  conflict_id: r.conflict.id, strategy: r.strategy, clarifications: r.strategy.clarifications || []
+  conflict_id, strategy, clarifications[]
 }))
 ```
 
-**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 供后续手动处理
+**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场景边界澄清
 
 ### Phase 4: Apply Modifications
 
@@ -303,30 +467,14 @@ selectedStrategies.forEach(item => {
 
 console.log(`\n正在应用 ${modifications.length} 个修改...`);
 
-// 2. Apply each modification using Edit tool (with fallback to context-package.json)
+// 2. Apply each modification using Edit tool
 const appliedModifications = [];
 const failedModifications = [];
-const fallbackConstraints = [];  // For files that don't exist
 
 modifications.forEach((mod, idx) => {
   try {
     console.log(`[${idx + 1}/${modifications.length}] 修改 ${mod.file}...`);
 
-    // Check if target file exists (brainstorm files may not exist in lite workflow)
-    if (!file_exists(mod.file)) {
-      console.log(`  ⚠️ 文件不存在，写入 context-package.json 作为约束`);
-      fallbackConstraints.push({
-        source: "conflict-resolution",
-        conflict_id: mod.conflict_id,
-        target_file: mod.file,
-        section: mod.section,
-        change_type: mod.change_type,
-        content: mod.new_content,
-        rationale: mod.rationale
-      });
-      return;  // Skip to next modification
-    }
-
     if (mod.change_type === "update") {
       Edit({
         file_path: mod.file,
@@ -354,45 +502,14 @@ modifications.forEach((mod, idx) => {
   }
 });
 
-// 2b. Generate conflict-resolution.json output file
-const resolutionOutput = {
-  session_id: sessionId,
-  resolved_at: new Date().toISOString(),
-  summary: {
-    total_conflicts: conflicts.length,
-    resolved_with_strategy: selectedStrategies.length,
-    custom_handling: customConflicts.length,
-    fallback_constraints: fallbackConstraints.length
-  },
-  resolved_conflicts: selectedStrategies.map(s => ({
-    conflict_id: s.conflict_id,
-    strategy_name: s.strategy.name,
-    strategy_approach: s.strategy.approach,
-    clarifications: s.clarifications || [],
-    modifications_applied: s.strategy.modifications?.filter(m =>
-      appliedModifications.some(am => am.conflict_id === s.conflict_id)
-    ) || []
-  })),
-  custom_conflicts: customConflicts.map(c => ({
-    id: c.id,
-    brief: c.brief,
-    category: c.category,
-    suggestions: c.suggestions,
-    overlap_analysis: c.overlap_analysis || null
-  })),
-  planning_constraints: fallbackConstraints,  // Constraints for files that don't exist
-  failed_modifications: failedModifications
-};
-
-const resolutionPath = `.workflow/active/${sessionId}/.process/conflict-resolution.json`;
-Write(resolutionPath, JSON.stringify(resolutionOutput, null, 2));
-console.log(`\n📄 冲突解决结果已保存: ${resolutionPath}`);
-
-// 3. Update context-package.json with resolution details (reference to JSON file)
+// 3. Update context-package.json with resolution details
 const contextPackage = JSON.parse(Read(contextPath));
 contextPackage.conflict_detection.conflict_risk = "resolved";
-contextPackage.conflict_detection.resolution_file = resolutionPath;  // Reference to detailed JSON
-contextPackage.conflict_detection.resolved_conflicts = selectedStrategies.map(s => s.conflict_id);
+contextPackage.conflict_detection.resolved_conflicts = selectedStrategies.map(s => ({
+  conflict_id: s.conflict_id,
+  strategy_name: s.strategy.name,
+  clarifications: s.clarifications
+}));
 contextPackage.conflict_detection.custom_conflicts = customConflicts.map(c => c.id);
 contextPackage.conflict_detection.resolved_at = new Date().toISOString();
 Write(contextPath, JSON.stringify(contextPackage, null, 2));
@@ -465,50 +582,12 @@ return {
 ✓ Agent log saved to .workflow/active/{session_id}/.chat/
 ```
 
-## Output Format
-
-### Primary Output: conflict-resolution.json
-
-**Path**: `.workflow/active/{session_id}/.process/conflict-resolution.json`
-
-**Schema**:
-```json
-{
-  "session_id": "WFS-xxx",
-  "resolved_at": "ISO timestamp",
-  "summary": {
-    "total_conflicts": 3,
-    "resolved_with_strategy": 2,
-    "custom_handling": 1,
-    "fallback_constraints": 0
-  },
-  "resolved_conflicts": [
-    {
-      "conflict_id": "CON-001",
-      "strategy_name": "策略名称",
-      "strategy_approach": "实现方法",
-      "clarifications": [],
-      "modifications_applied": []
-    }
-  ],
-  "custom_conflicts": [
-    {
-      "id": "CON-002",
-      "brief": "冲突摘要",
-      "category": "ModuleOverlap",
-      "suggestions": ["建议1", "建议2"],
-      "overlap_analysis": null
-    }
-  ],
-  "planning_constraints": [],
-  "failed_modifications": []
-}
-```
-
-### Secondary: Agent JSON Response (stdout)
+## Output Format: Agent JSON Response
 
 **Focus**: Structured conflict data with actionable modifications for programmatic processing.
 
+**Format**: JSON to stdout (NO file generation)
+
 **Structure**: Defined in Phase 2, Step 4 (agent prompt)
 
 ### Key Requirements
@@ -556,12 +635,11 @@ If Edit tool fails mid-application:
 - Requires: `conflict_risk ≥ medium`
 
 **Output**:
-- Generated file:
-  - `.workflow/active/{session_id}/.process/conflict-resolution.json` (primary output)
-- Modified files (if exist):
+- Modified files:
   - `.workflow/active/{session_id}/.brainstorm/guidance-specification.md`
   - `.workflow/active/{session_id}/.brainstorm/{role}/analysis.md`
-  - `.workflow/active/{session_id}/.process/context-package.json` (conflict_risk → resolved, resolution_file reference)
+  - `.workflow/active/{session_id}/.process/context-package.json` (conflict_risk → resolved)
+- NO report file generation
 
 **User Interaction**:
 - **Iterative conflict processing**: One conflict at a time, not in batches
@@ -589,7 +667,7 @@ If Edit tool fails mid-application:
 ✓ guidance-specification.md updated with resolved conflicts
 ✓ Role analyses (*.md) updated with resolved conflicts
 ✓ context-package.json marked as "resolved" with clarification records
-✓ conflict-resolution.json generated with full resolution details
+✓ No CONFLICT_RESOLUTION.md file generated
 ✓ Modification summary includes:
   - Total conflicts
   - Resolved with strategy (count)

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

@@ -15,6 +15,7 @@ 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
 
@@ -120,7 +121,6 @@ const sessionFolder = `.workflow/active/${session_id}/.process`;
 const explorationTasks = selectedAngles.map((angle, index) =>
   Task(
     subagent_type="cli-explore-agent",
-    run_in_background=false,
     description=`Explore: ${angle}`,
     prompt=`
 ## Task Objective
@@ -135,7 +135,7 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 
 ## MANDATORY FIRST STEPS (Execute by Agent)
 **You (cli-explore-agent) MUST execute these steps in order:**
-1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
+1. Run: ~/.claude/scripts/get_modules_by_depth.sh (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)
 
@@ -215,7 +215,6 @@ Write(`${sessionFolder}/explorations-manifest.json`, JSON.stringify(explorationM
 ```javascript
 Task(
   subagent_type="context-search-agent",
-  run_in_background=false,
   description="Gather comprehensive context for plan",
   prompt=`
 ## Execution Mode
@@ -236,12 +235,9 @@ Task(
 Execute complete context-search-agent workflow for implementation planning:
 
 ### Phase 1: Initialization & Pre-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.
+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.
 2. **Detection**: Check for existing context-package (early exit if valid)
-3. **Foundation**: Initialize CodexLens, get project structure, load docs
+3. **Foundation**: Initialize code-index, get project structure, load docs
 4. **Analysis**: Extract keywords, determine scope, classify complexity based on task description and project state
 
 ### Phase 2: Multi-Source Context Discovery
@@ -254,19 +250,17 @@ Execute all discovery tracks:
 
 ### Phase 3: Synthesis, Assessment & Packaging
 1. Apply relevance scoring and build dependency graph
-2. **Synthesize 4-source data**: Merge findings from all sources (archive > docs > code > web). **Prioritize the context from `project-tech.json`** for architecture and tech stack unless code analysis reveals it's outdated.
-3. **Populate `project_context`**: Directly use the `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
+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
 
 ## 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-tech.json`)
-- **project_guidelines**: {conventions, constraints, quality_rules, learnings} (sourced from `project-guidelines.json`)
+- **project_context**: description, technology_stack, architecture, key_components (sourced from `project.json` overview)
 - **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
@@ -319,8 +313,7 @@ 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-tech.json`)
-- **project_guidelines**: Conventions, constraints, quality rules, learnings (populated from `project-guidelines.json`)
+- **project_context**: Architecture patterns, conventions, tech stack (populated from `project.json` overview)
 - **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)
@@ -435,7 +428,7 @@ if (historicalConflicts.length > 0 && currentRisk === "low") {
 ## Notes
 
 - **Detection-first**: Always check for existing package before invoking agent
-- **Dual project file integration**: Agent reads both `.workflow/project-tech.json` (tech analysis) and `.workflow/project-guidelines.json` (user constraints) as primary sources
-- **Guidelines injection**: Project guidelines are included in context-package to ensure task generation respects user-defined constraints
+- **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`
 - **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

@@ -28,12 +28,6 @@ Input Parsing:
    ├─ Parse flags: --session
    └─ Validation: session_id REQUIRED
 
-Phase 0: User Configuration (Interactive)
-   ├─ Question 1: Supplementary materials/guidelines?
-   ├─ Question 2: Execution method preference (Agent/CLI/Hybrid)
-   ├─ Question 3: CLI tool preference (if CLI selected)
-   └─ Store: userConfig for agent prompt
-
 Phase 1: Context Preparation & Module Detection (Command)
    ├─ Assemble session paths (metadata, context package, output dirs)
    ├─ Provide metadata (session_id, execution_mode, mcp_capabilities)
@@ -63,82 +57,6 @@ Phase 3: Integration (+1 Coordinator, Multi-Module Only)
 
 ## Document Generation Lifecycle
 
-### Phase 0: User Configuration (Interactive)
-
-**Purpose**: Collect user preferences before task generation to ensure generated tasks match execution expectations.
-
-**User Questions**:
-```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: "Do you have supplementary materials or guidelines to include?",
-      header: "Materials",
-      multiSelect: false,
-      options: [
-        { label: "No additional materials", description: "Use existing context only" },
-        { label: "Provide file paths", description: "I'll specify paths to include" },
-        { label: "Provide inline content", description: "I'll paste content directly" }
-      ]
-    },
-    {
-      question: "Select execution method for generated tasks:",
-      header: "Execution",
-      multiSelect: false,
-      options: [
-        { label: "Agent (Recommended)", description: "Claude agent executes tasks directly" },
-        { label: "Hybrid", description: "Agent orchestrates, calls CLI for complex steps" },
-        { label: "CLI Only", description: "All execution via CLI tools (codex/gemini/qwen)" }
-      ]
-    },
-    {
-      question: "If using CLI, which tool do you prefer?",
-      header: "CLI Tool",
-      multiSelect: false,
-      options: [
-        { label: "Codex (Recommended)", description: "Best for implementation tasks" },
-        { label: "Gemini", description: "Best for analysis and large context" },
-        { label: "Qwen", description: "Alternative analysis tool" },
-        { label: "Auto", description: "Let agent decide per-task" }
-      ]
-    }
-  ]
-})
-```
-
-**Handle Materials Response**:
-```javascript
-if (userConfig.materials === "Provide file paths") {
-  // Follow-up question for file paths
-  const pathsResponse = AskUserQuestion({
-    questions: [{
-      question: "Enter file paths to include (comma-separated or one per line):",
-      header: "Paths",
-      multiSelect: false,
-      options: [
-        { label: "Enter paths", description: "Provide paths in text input" }
-      ]
-    }]
-  })
-  userConfig.supplementaryPaths = parseUserPaths(pathsResponse)
-}
-```
-
-**Build userConfig**:
-```javascript
-const userConfig = {
-  supplementaryMaterials: {
-    type: "none|paths|inline",
-    content: [...],  // Parsed paths or inline content
-  },
-  executionMethod: "agent|hybrid|cli",
-  preferredCliTool: "codex|gemini|qwen|auto",
-  enableResume: true  // Always enable resume for CLI executions
-}
-```
-
-**Pass to Agent**: Include `userConfig` in agent prompt for Phase 2A/2B.
-
 ### Phase 1: Context Preparation & Module Detection (Command Responsibility)
 
 **Command prepares session paths, metadata, and detects module structure.**
@@ -171,14 +89,6 @@ const userConfig = {
 3. **Auto Module Detection** (determines single vs parallel mode):
    ```javascript
    function autoDetectModules(contextPackage, projectRoot) {
-     // === Complexity Gate: Only parallelize for High complexity ===
-     const complexity = contextPackage.metadata?.complexity || 'Medium';
-     if (complexity !== 'High') {
-       // Force single agent mode for Low/Medium complexity
-       // This maximizes agent context reuse for related tasks
-       return [{ name: 'main', prefix: '', paths: ['.'] }];
-     }
-
      // Priority 1: Explicit frontend/backend separation
      if (exists('src/frontend') && exists('src/backend')) {
        return [
@@ -202,9 +112,8 @@ const userConfig = {
    ```
 
 **Decision Logic**:
-- `complexity !== 'High'` → Force Phase 2A (Single Agent, maximize context reuse)
 - `modules.length == 1` → Phase 2A (Single Agent, original flow)
-- `modules.length >= 2 && complexity == 'High'` → Phase 2B + Phase 3 (N+1 Parallel)
+- `modules.length >= 2` → Phase 2B + Phase 3 (N+1 Parallel)
 
 **Note**: CLI tool usage is now determined semantically by action-planning-agent based on user's task description, not by flags.
 
@@ -218,7 +127,6 @@ const userConfig = {
 ```javascript
 Task(
   subagent_type="action-planning-agent",
-  run_in_background=false,
   description="Generate planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md)",
   prompt=`
 ## TASK OBJECTIVE
@@ -242,21 +150,10 @@ 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
+Determine CLI tool usage per-step based on user's task description:
+- If user specifies "use Codex/Gemini/Qwen for X" → Add command field to relevant steps
+- Default: Agent execution (no command field) unless user explicitly requests CLI
 
 ## EXPLORATION CONTEXT (from context-package.exploration_results)
 - Load exploration_results from context-package.json
@@ -266,13 +163,6 @@ CLI Resume Support (MANDATORY for all CLI commands):
 - Use aggregated_insights.all_integration_points for precise modification locations
 - 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 as task constraints (for brainstorm-less workflows)
-  - Reference resolved_conflicts for implementation approach alignment
-  - Handle custom_conflicts with explicit task notes
-
 ## EXPECTED DELIVERABLES
 1. Task JSON Files (.task/IMPL-*.json)
    - 6-field schema (id, title, status, context_package_path, meta, context, flow_control)
@@ -280,7 +170,6 @@ CLI Resume Support (MANDATORY for all CLI commands):
    - Artifacts integration from context package
    - **focus_paths enhanced with exploration critical_files**
    - Flow control with pre_analysis steps (include exploration integration_points analysis)
-   - **CLI Execution IDs and strategies (MANDATORY)**
 
 2. Implementation Plan (IMPL_PLAN.md)
    - Context analysis and artifact references
@@ -292,27 +181,6 @@ CLI Resume Support (MANDATORY for all CLI commands):
    - Links to task JSONs and summaries
    - Matches task JSON hierarchy
 
-## CLI EXECUTION ID REQUIREMENTS (MANDATORY)
-Each task JSON MUST include:
-- **cli_execution_id**: Unique ID for CLI execution (format: `{session_id}-{task_id}`)
-- **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", ...] }`
-
-**CLI Execution Strategy Rules**:
-1. **new**: Task has no dependencies - starts fresh CLI conversation
-2. **resume**: Task has 1 parent AND that parent has only this child - continues same conversation
-3. **fork**: Task has 1 parent BUT parent has multiple children - creates new branch with parent context
-4. **merge_fork**: Task has multiple parents - merges all parent contexts into new conversation
-
-**Execution Command Patterns**:
-- new: `ccw cli -p "[prompt]" --tool [tool] --mode write --id [cli_execution_id]`
-- resume: `ccw cli -p "[prompt]" --resume [resume_from] --tool [tool] --mode write`
-- fork: `ccw cli -p "[prompt]" --resume [resume_from] --id [cli_execution_id] --tool [tool] --mode write`
-- merge_fork: `ccw cli -p "[prompt]" --resume [merge_from.join(',')] --id [cli_execution_id] --tool [tool] --mode write`
-
 ## QUALITY STANDARDS
 Hard Constraints:
   - Task count <= 18 (hard limit - request re-scope if exceeded)
@@ -335,9 +203,7 @@ Hard Constraints:
 
 **Condition**: `modules.length >= 2` (multi-module detected)
 
-**Purpose**: Launch N action-planning-agents simultaneously, one per module, for parallel task JSON generation.
-
-**Note**: Phase 2B agents generate Task JSONs ONLY. IMPL_PLAN.md and TODO_LIST.md are generated by Phase 3 Coordinator.
+**Purpose**: Launch N action-planning-agents simultaneously, one per module, for parallel task generation.
 
 **Parallel Agent Invocation**:
 ```javascript
@@ -345,123 +211,27 @@ Hard Constraints:
 const planningTasks = modules.map(module =>
   Task(
     subagent_type="action-planning-agent",
-    run_in_background=false,
-    description=`Generate ${module.name} module task JSONs`,
+    description=`Plan ${module.name} module`,
     prompt=`
-## TASK OBJECTIVE
-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 the progressive loading strategy defined in agent specification (load analysis.md files incrementally due to file size)
-
-## MODULE SCOPE
+## SCOPE
 - Module: ${module.name} (${module.type})
 - Focus Paths: ${module.paths.join(', ')}
 - Task ID Prefix: IMPL-${module.prefix}
-- Task Limit: ≤9 tasks (hard limit for this module)
-- Other Modules: ${otherModules.join(', ')} (reference only, do NOT generate tasks for them)
+- Task Limit: ≤9 tasks
+- Other Modules: ${otherModules.join(', ')}
+- Cross-module deps format: "CROSS::{module}::{pattern}"
 
 ## 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/
 
-## CONTEXT METADATA
-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
-- 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 (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
-- 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)
+## INSTRUCTIONS
+- Generate tasks ONLY for ${module.name} module
+- Use task ID format: IMPL-${module.prefix}1, IMPL-${module.prefix}2, ...
+- For cross-module dependencies, use: depends_on: ["CROSS::B::api-endpoint"]
+- Maximum 9 tasks per module
     `
   )
 );
@@ -485,79 +255,37 @@ await Promise.all(planningTasks);
 - Prefix: A, B, C... (assigned by detection order)
 - Sequence: 1, 2, 3... (per-module increment)
 
-### Phase 3: Integration (+1 Coordinator Agent, Multi-Module Only)
+### Phase 3: Integration (+1 Coordinator, Multi-Module Only)
 
 **Condition**: Only executed when `modules.length >= 2`
 
-**Purpose**: Collect all module tasks, resolve cross-module dependencies, generate unified IMPL_PLAN.md and TODO_LIST.md documents.
+**Purpose**: Collect all module tasks, resolve cross-module dependencies, generate unified documents.
 
-**Coordinator Agent Invocation**:
+**Integration Logic**:
 ```javascript
-// Wait for all Phase 2B agents to complete
-const moduleResults = await Promise.all(planningTasks);
+// 1. Collect all module task JSONs
+const allTasks = glob('.task/IMPL-*.json').map(loadJson);
 
-// Launch +1 Coordinator Agent
-Task(
-  subagent_type="action-planning-agent",
-  run_in_background=false,
-  description="Integrate module tasks and generate unified documents",
-  prompt=`
-## TASK OBJECTIVE
-Integrate all module task JSONs, resolve cross-module dependencies, and generate unified IMPL_PLAN.md and TODO_LIST.md
-
-IMPORTANT: This is INTEGRATION ONLY - consolidate existing task JSONs, NOT creating new tasks.
-
-## SESSION PATHS
-Input:
-  - Session Metadata: .workflow/active/{session-id}/workflow-session.json
-  - Context Package: .workflow/active/{session-id}/.process/context-package.json
-  - Task JSONs: .workflow/active/{session-id}/.task/IMPL-*.json (from Phase 2B)
-Output:
-  - Updated Task JSONs: .workflow/active/{session-id}/.task/IMPL-*.json (resolved dependencies)
-  - IMPL_PLAN: .workflow/active/{session-id}/IMPL_PLAN.md
-  - TODO_LIST: .workflow/active/{session-id}/TODO_LIST.md
-
-## CONTEXT METADATA
-Session ID: {session-id}
-Modules: ${modules.map(m => m.name + '(' + m.prefix + ')').join(', ')}
-Module Count: ${modules.length}
-
-## INTEGRATION STEPS
-1. Collect all .task/IMPL-*.json, group by module prefix
-2. Resolve CROSS:: dependencies → actual task IDs, update task JSONs
-3. Generate IMPL_PLAN.md (multi-module format per agent specification)
-4. Generate TODO_LIST.md (hierarchical format per agent specification)
-
-## CROSS-MODULE DEPENDENCY RESOLUTION
-- Pattern: CROSS::{module}::{pattern} → IMPL-{module}* matching title/context
-- Example: CROSS::B::api-endpoint → IMPL-B1 (if B1 title contains "api-endpoint")
-- Log unresolved as warnings
-
-## EXPECTED DELIVERABLES
-1. Updated Task JSONs with resolved dependency IDs
-2. IMPL_PLAN.md - multi-module format with cross-dependency section
-3. TODO_LIST.md - hierarchical by module with cross-dependency section
-
-## SUCCESS CRITERIA
-- No CROSS:: placeholders remaining in task JSONs
-- IMPL_PLAN.md and TODO_LIST.md generated with multi-module structure
-- Return: task count, per-module breakdown, resolved dependency count
-  `
-)
-```
-
-**Dependency Resolution Algorithm**:
-```javascript
-function resolveCrossModuleDependency(placeholder, allTasks) {
-  const [, targetModule, pattern] = placeholder.match(/CROSS::(\w+)::(.+)/);
-  const candidates = allTasks.filter(t =>
-    t.id.startsWith(`IMPL-${targetModule}`) &&
-    (t.title.toLowerCase().includes(pattern.toLowerCase()) ||
-     t.context?.description?.toLowerCase().includes(pattern.toLowerCase()))
-  );
-  return candidates.length > 0
-    ? candidates.sort((a, b) => a.id.localeCompare(b.id))[0].id
-    : placeholder; // Keep for manual resolution
+// 2. Resolve cross-module dependencies
+for (const task of allTasks) {
+  if (task.depends_on) {
+    task.depends_on = task.depends_on.map(dep => {
+      if (dep.startsWith('CROSS::')) {
+        // CROSS::B::api-endpoint → find matching IMPL-B* task
+        const [, targetModule, pattern] = dep.match(/CROSS::(\w+)::(.+)/);
+        return findTaskByModuleAndPattern(allTasks, targetModule, pattern);
+      }
+      return dep;
+    });
+  }
 }
+
+// 3. Generate unified IMPL_PLAN.md (grouped by module)
+generateIMPL_PLAN(allTasks, modules);
+
+// 4. Generate TODO_LIST.md (hierarchical structure)
+generateTODO_LIST(allTasks, modules);
 ```
 
+**Note**: IMPL_PLAN.md and TODO_LIST.md structure definitions are in `action-planning-agent.md`.
+

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

@@ -113,7 +113,7 @@ Phase 2: Agent Execution (Document Generation)
     // Existing test patterns and coverage analysis
   },
   "mcp_capabilities": {
-    "codex_lens": true,
+    "code_index": true,
     "exa_code": true,
     "exa_web": true
   }
@@ -152,14 +152,9 @@ Phase 2: Agent Execution (Document Generation)
    roleAnalysisPaths.forEach(path => Read(path));
    ```
 
-5. **Load Conflict Resolution** (from conflict-resolution.json, if exists)
+5. **Load Conflict Resolution** (from context-package.json, if exists)
    ```javascript
-   // Check for new conflict-resolution.json format
-   if (contextPackage.conflict_detection?.resolution_file) {
-     Read(contextPackage.conflict_detection.resolution_file)  // .process/conflict-resolution.json
-   }
-   // Fallback: legacy brainstorm_artifacts path
-   else if (contextPackage.brainstorm_artifacts?.conflict_resolution?.exists) {
+   if (contextPackage.brainstorm_artifacts.conflict_resolution?.exists) {
      Read(contextPackage.brainstorm_artifacts.conflict_resolution.path)
    }
    ```
@@ -194,7 +189,6 @@ const templatePath = hasCliExecuteFlag
 ```javascript
 Task(
   subagent_type="action-planning-agent",
-  run_in_background=false,
   description="Generate TDD task JSON and implementation plan",
   prompt=`
 ## Execution Context
@@ -229,7 +223,7 @@ If conflict_risk was medium/high, modifications have been applied to:
 - **guidance-specification.md**: Design decisions updated to resolve conflicts
 - **Role analyses (*.md)**: Recommendations adjusted for compatibility
 - **context-package.json**: Marked as "resolved" with conflict IDs
-- Conflict resolution results stored in conflict-resolution.json
+- NO separate CONFLICT_RESOLUTION.md file (conflicts resolved in-place)
 
 ### MCP Analysis Results (Optional)
 **Code Structure**: {mcp_code_index_results}
@@ -239,6 +233,15 @@ 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
@@ -330,7 +333,7 @@ Generate all three documents and report completion status:
 - TDD cycles configured: N cycles with quantified test cases
 - Artifacts integrated: synthesis-spec, guidance-specification, N role analyses
 - Test context integrated: existing patterns and coverage
-- MCP enhancements: CodexLens, exa-research
+- MCP enhancements: code-index, exa-research
 - Session ready for TDD execution: /workflow:execute
 `
 )
@@ -370,12 +373,10 @@ const agentContext = {
     .flatMap(role => role.files)
     .map(file => Read(file.path)),
 
-  // Load conflict resolution if exists (prefer new JSON format)
-  conflict_resolution: context_package.conflict_detection?.resolution_file
-    ? Read(context_package.conflict_detection.resolution_file)  // .process/conflict-resolution.json
-    : (brainstorm_artifacts?.conflict_resolution?.exists
-        ? Read(brainstorm_artifacts.conflict_resolution.path)
-        : null),
+  // Load conflict resolution if exists (from context package)
+  conflict_resolution: brainstorm_artifacts.conflict_resolution?.exists
+    ? Read(brainstorm_artifacts.conflict_resolution.path)
+    : null,
 
   // Optional MCP enhancements
   mcp_analysis: executeMcpDiscovery()
@@ -407,7 +408,7 @@ This section provides quick reference for TDD task JSON structure. For complete
 │   ├── IMPL-3.2.json                # Complex feature subtask (if needed)
 │   └── ...
 └── .process/
-    ├── conflict-resolution.json     # Conflict resolution results (if conflict_risk ≥ medium)
+    ├── CONFLICT_RESOLUTION.md       # Conflict resolution strategies (if conflict_risk ≥ medium)
     ├── test-context-package.json    # Test coverage analysis
     ├── context-package.json         # Input from context-gather
     ├── context_package_path         # Path to smart context package

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

@@ -76,7 +76,6 @@ Phase 3: Output Validation (Command)
 ```javascript
 Task(
   subagent_type="cli-execution-agent",
-  run_in_background=false,
   description="Analyze test coverage gaps and generate test strategy",
   prompt=`
 ## TASK OBJECTIVE
@@ -90,7 +89,7 @@ Template: ~/.claude/workflows/cli-templates/prompts/test/test-concept-analysis.t
 
 ## EXECUTION STEPS
 1. Execute Gemini analysis:
-   ccw cli -p "$(cat ~/.claude/workflows/cli-templates/prompts/test/test-concept-analysis.txt)" --tool gemini --mode write --cd .workflow/active/{test_session_id}/.process
+   cd .workflow/active/{test_session_id}/.process && gemini -p "$(cat ~/.claude/workflows/cli-templates/prompts/test/test-concept-analysis.txt)" --approval-mode yolo
 
 2. Generate TEST_ANALYSIS_RESULTS.md:
    Synthesize gemini-test-analysis.md into standardized format for task generation

.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
 
@@ -86,9 +86,9 @@ if (file_exists(testContextPath)) {
 ```javascript
 Task(
   subagent_type="test-context-search-agent",
-  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
@@ -228,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

@@ -94,7 +94,6 @@ Phase 2: Test Document Generation (Agent)
 ```javascript
 Task(
   subagent_type="action-planning-agent",
-  run_in_background=false,
   description="Generate test planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md)",
   prompt=`
 ## TASK OBJECTIVE
@@ -107,6 +106,8 @@ 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 executes Phase 7
-- **Phase 7-10 (Autonomous)**: SlashCommand execute **ATTACHES** tasks to current workflow
+- **Phase 5 (User Interaction)**: User confirms targets → IMMEDIATELY dispatches Phase 7
+- **Phase 7-10 (Autonomous)**: SlashCommand dispatch **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 execute is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
+**Task Attachment Model**: SlashCommand dispatch 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 → Execute /workflow:ui-design:import-from-code
+      ├─ code_only | hybrid → Dispatch /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 → Execute /workflow:ui-design:style-extract
+      ├─ visual_only OR supplement needed → Dispatch /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 → Execute /workflow:ui-design:animation-extract
+      ├─ visual_only OR incomplete OR regenerate → Dispatch /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 → Execute /workflow:ui-design:layout-extract
+      ├─ True → Dispatch /workflow:ui-design:layout-extract
       └─ False → Use code import
 
 Phase 10: UI Assembly
-   └─ Execute /workflow:ui-design:generate → Workflow complete
+   └─ Dispatch /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 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: 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.
 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: Execute** - Import design system from code files
+**Step 6.1: Dispatch** - 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 execute ATTACHES import-from-code's tasks to current workflow
+        # SlashCommand dispatch 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: Execute** - Extract style design systems
+**Step 7.1: Dispatch** - 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 execute ATTACHES style-extract's tasks to current workflow
+    # SlashCommand dispatch 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: Execute** - Extract animation patterns
+**Step 8.1: Dispatch** - Extract animation patterns
 
 ```javascript
 # Determine if animation extraction is needed
@@ -522,7 +522,7 @@ IF should_extract_animation:
 
     command = " ".join(command_parts)
 
-    # SlashCommand execute ATTACHES animation-extract's tasks to current workflow
+    # SlashCommand dispatch 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: Execute** - Extract layout templates
+**Step 9.1: Dispatch** - 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 execute ATTACHES layout-extract's tasks to current workflow
+    # SlashCommand dispatch 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: Execute** - Assemble UI prototypes from design tokens and layout templates
+**Step 10.1: Dispatch** - 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 execute ATTACHES generate's tasks to current workflow
+# SlashCommand dispatch 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 execute ATTACHES tasks to current workflow.
+// **Key Concept**: SlashCommand dispatch ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 7-10 SlashCommand Execute Pattern (when tasks are attached):
+// Phase 7-10 SlashCommand Dispatch 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/generate.md

@@ -320,7 +320,7 @@ Read({base_path}/prototypes/{target}-style-{style_id}-layout-{layout_id}.html)
 
 ### Step 1: Run Preview Generation Script
 ```bash
-bash(ccw tool exec ui_generate_preview '{"prototypesDir":"{base_path}/prototypes"}')
+bash(~/.claude/scripts/ui-generate-preview.sh "{base_path}/prototypes")
 ```
 
 **Script generates**:
@@ -432,7 +432,7 @@ bash(test -f {base_path}/prototypes/compare.html && echo "exists")
 bash(mkdir -p {base_path}/prototypes)
 
 # Run preview script
-bash(ccw tool exec ui_generate_preview '{"prototypesDir":"{base_path}/prototypes"}')
+bash(~/.claude/scripts/ui-generate-preview.sh "{base_path}/prototypes")
 ```
 
 ## Output Structure
@@ -467,7 +467,7 @@ ERROR: Agent assembly failed
 → Check inputs exist, validate JSON structure
 
 ERROR: Script permission denied
-→ Verify ccw tool is available: ccw tool list
+→ chmod +x ~/.claude/scripts/ui-generate-preview.sh
 ```
 
 ### Recovery Strategies

.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 execute **ATTACHES** tasks to current workflow
+- **Task Attachment**: SlashCommand dispatch **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 execute is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
+**Task Attachment Model**: SlashCommand dispatch 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 → Execute /workflow:ui-design:import-from-code
+      ├─ hybrid → Dispatch /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 → Execute /workflow:ui-design:style-extract
+      └─ Otherwise → Dispatch /workflow:ui-design:style-extract
 
 Phase 2.3: Animation Extraction
    └─ Decision (skip_animation):
       ├─ code_only AND animation_complete → Use code import
-      └─ Otherwise → Execute /workflow:ui-design:animation-extract
+      └─ Otherwise → Dispatch /workflow:ui-design:animation-extract
 
 Phase 2.5: Layout Extraction
    └─ Decision (skip_layout):
       ├─ code_only AND layout_complete → Use code import
-      └─ Otherwise → Execute /workflow:ui-design:layout-extract
+      └─ Otherwise → Dispatch /workflow:ui-design:layout-extract
 
 Phase 3: UI Assembly
-   └─ Execute /workflow:ui-design:generate
+   └─ Dispatch /workflow:ui-design:generate
 
 Phase 4: Design System Integration
    └─ Decision (session_id):
-      ├─ Provided → Execute /workflow:ui-design:update
+      ├─ Provided → Dispatch /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 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.
+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.
 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: Execute** - Import design system from code files
+**Step 0.5.1: Dispatch** - 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 execute ATTACHES import-from-code's tasks to current workflow
+        # SlashCommand dispatch 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: Execute** - Extract style design system
+**Step 2.1: Dispatch** - Extract style design system
 
 ```javascript
 # Determine if style extraction needed
@@ -409,7 +409,7 @@ ELSE:
 
     extract_command = " ".join(command_parts)
 
-    # SlashCommand execute ATTACHES style-extract's tasks to current workflow
+    # SlashCommand dispatch 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: Execute** - Extract animation patterns
+**Step 2.3.1: Dispatch** - 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 execute ATTACHES animation-extract's tasks to current workflow
+    # SlashCommand dispatch 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: Execute** - Extract layout templates
+**Step 2.5.1: Dispatch** - 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 execute ATTACHES layout-extract's tasks to current workflow
+    # SlashCommand dispatch 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: Execute** - Assemble UI prototypes from design tokens and layout templates
+**Step 3.1: Dispatch** - 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 execute ATTACHES generate's tasks to current workflow
+# SlashCommand dispatch 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: Execute** - Integrate design system into workflow session
+**Step 4.1: Dispatch** - 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 execute ATTACHES update's tasks to current workflow
+    # SlashCommand dispatch 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 execute ATTACHES tasks to current workflow.
+// **Key Concept**: SlashCommand dispatch ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 2-4 SlashCommand Execute Pattern (when tasks are attached):
+// Phase 2-4 SlashCommand Dispatch 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 Executeed**:
+- **Sub-commands Dispatched**:
   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/commands/workflow/ui-design/import-from-code.md

@@ -106,7 +106,7 @@ echo "  Output: $base_path"
 
 # 3. Discover files using script
 discovery_file="${intermediates_dir}/discovered-files.json"
-ccw tool exec discover_design_files '{"sourceDir":"'"$source"'","outputPath":"'"$discovery_file"'"}'
+~/.claude/scripts/discover-design-files.sh "$source" "$discovery_file"
 
 echo "  Output: $discovery_file"
 ```
@@ -161,7 +161,6 @@ echo "[Phase 1] Starting parallel agent analysis (3 agents)"
 
 ```javascript
 Task(subagent_type="ui-design-agent",
-     run_in_background=false,
      prompt="[STYLE_TOKENS_EXTRACTION]
   Extract visual design tokens from code files using code import extraction pattern.
 
@@ -181,14 +180,14 @@ Task(subagent_type="ui-design-agent",
   - Pattern: rg → Extract values → Compare → If different → Read full context with comments → Record conflict
   - Alternative (if many files): Execute CLI analysis for comprehensive report:
     \`\`\`bash
-    ccw cli -p \"
+    cd ${source} && gemini -p \"
     PURPOSE: Detect color token conflicts across all CSS/SCSS/JS files
     TASK: • Scan all files for color definitions • Identify conflicting values • Extract semantic comments
     MODE: analysis
     CONTEXT: @**/*.css @**/*.scss @**/*.js @**/*.ts
     EXPECTED: JSON report listing conflicts with file:line, values, semantic context
     RULES: Focus on core tokens | Report ALL variants | analysis=READ-ONLY
-    \" --tool gemini --mode analysis --cd ${source}
+    \"
     \`\`\`
 
   **Step 1: Load file list**
@@ -277,7 +276,6 @@ Task(subagent_type="ui-design-agent",
 
 ```javascript
 Task(subagent_type="ui-design-agent",
-     run_in_background=false,
      prompt="[ANIMATION_TOKEN_GENERATION_TASK]
   Extract animation tokens from code files using code import extraction pattern.
 
@@ -297,14 +295,14 @@ Task(subagent_type="ui-design-agent",
   - Pattern: rg → Identify animation types → Map framework usage → Prioritize extraction targets
   - Alternative (if complex framework mix): Execute CLI analysis for comprehensive report:
     \`\`\`bash
-    ccw cli -p \"
+    cd ${source} && gemini -p \"
     PURPOSE: Detect animation frameworks and patterns
     TASK: • Identify frameworks • Map animation patterns • Categorize by complexity
     MODE: analysis
     CONTEXT: @**/*.css @**/*.scss @**/*.js @**/*.ts
     EXPECTED: JSON report listing frameworks, animation types, file locations
     RULES: Focus on framework consistency | Map all animations | analysis=READ-ONLY
-    \" --tool gemini --mode analysis --cd ${source}
+    \"
     \`\`\`
 
   **Step 1: Load file list**
@@ -357,7 +355,6 @@ Task(subagent_type="ui-design-agent",
 
 ```javascript
 Task(subagent_type="ui-design-agent",
-     run_in_background=false,
      prompt="[LAYOUT_TEMPLATE_GENERATION_TASK]
   Extract layout patterns from code files using code import extraction pattern.
 
@@ -377,14 +374,14 @@ Task(subagent_type="ui-design-agent",
   - Pattern: rg → Count occurrences → Classify by frequency → Prioritize universal components
   - Alternative (if large codebase): Execute CLI analysis for comprehensive categorization:
     \`\`\`bash
-    ccw cli -p \"
+    cd ${source} && gemini -p \"
     PURPOSE: Classify components as universal vs specialized
     TASK: • Identify UI components • Classify reusability • Map layout systems
     MODE: analysis
     CONTEXT: @**/*.css @**/*.scss @**/*.js @**/*.ts @**/*.html
     EXPECTED: JSON report categorizing components, layout patterns, naming conventions
     RULES: Focus on component reusability | Identify layout systems | analysis=READ-ONLY
-    \" --tool gemini --mode analysis --cd ${source}
+    \"
     \`\`\`
 
   **Step 1: Load file list**

.claude/scripts/classify-folders.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Classify folders by type for documentation generation
+# Usage: get_modules_by_depth.sh | classify-folders.sh
+# Output: folder_path|folder_type|code:N|dirs:N
+
+while IFS='|' read -r depth_info path_info files_info types_info claude_info; do
+  # Extract folder path from format "path:./src/modules"
+  folder_path=$(echo "$path_info" | cut -d':' -f2-)
+
+  # Skip if path extraction failed
+  [[ -z "$folder_path" || ! -d "$folder_path" ]] && continue
+
+  # Count code files (maxdepth 1)
+  code_files=$(find "$folder_path" -maxdepth 1 -type f \
+    \( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" \
+       -o -name "*.py" -o -name "*.go" -o -name "*.java" -o -name "*.rs" \
+       -o -name "*.c" -o -name "*.cpp" -o -name "*.cs" \) \
+    2>/dev/null | wc -l)
+
+  # Count subdirectories
+  subfolders=$(find "$folder_path" -maxdepth 1 -type d \
+    -not -path "$folder_path" 2>/dev/null | wc -l)
+
+  # Determine folder type
+  if [[ $code_files -gt 0 ]]; then
+    folder_type="code"  # API.md + README.md
+  elif [[ $subfolders -gt 0 ]]; then
+    folder_type="navigation"  # README.md only
+  else
+    folder_type="skip"  # Empty or no relevant content
+  fi
+
+  # Output classification result
+  echo "${folder_path}|${folder_type}|code:${code_files}|dirs:${subfolders}"
+done

.claude/scripts/convert_tokens_to_css.sh

@@ -0,0 +1,225 @@
+#!/bin/bash
+# Convert design-tokens.json to tokens.css with Google Fonts import and global font rules
+# Usage: cat design-tokens.json | ./convert_tokens_to_css.sh > tokens.css
+# Or: ./convert_tokens_to_css.sh < design-tokens.json > tokens.css
+
+# Read JSON from stdin
+json_input=$(cat)
+
+# Extract metadata for header comment
+style_name=$(echo "$json_input" | jq -r '.meta.name // "Unknown Style"' 2>/dev/null || echo "Design Tokens")
+
+# Generate header
+cat <<EOF
+/* ========================================
+   Design Tokens: ${style_name}
+   Auto-generated from design-tokens.json
+   ======================================== */
+
+EOF
+
+# ========================================
+# Google Fonts Import Generation
+# ========================================
+# Extract font families and generate Google Fonts import URL
+fonts=$(echo "$json_input" | jq -r '
+  .typography.font_family | to_entries[] | .value
+' 2>/dev/null | sed "s/'//g" | cut -d',' -f1 | sort -u)
+
+# Build Google Fonts URL
+google_fonts_url="https://fonts.googleapis.com/css2?"
+font_params=""
+
+while IFS= read -r font; do
+  # Skip system fonts and empty lines
+  if [[ -z "$font" ]] || [[ "$font" =~ ^(system-ui|sans-serif|serif|monospace|cursive|fantasy)$ ]]; then
+    continue
+  fi
+
+  # Special handling for common web fonts with weights
+  case "$font" in
+    "Comic Neue")
+      font_params+="family=Comic+Neue:wght@300;400;700&"
+      ;;
+    "Patrick Hand"|"Caveat"|"Dancing Script"|"Architects Daughter"|"Indie Flower"|"Shadows Into Light"|"Permanent Marker")
+      # URL-encode font name and add common weights
+      encoded_font=$(echo "$font" | sed 's/ /+/g')
+      font_params+="family=${encoded_font}:wght@400;700&"
+      ;;
+    "Segoe Print"|"Bradley Hand"|"Chilanka")
+      # These are system fonts, skip
+      ;;
+    *)
+      # Generic font: add with default weights
+      encoded_font=$(echo "$font" | sed 's/ /+/g')
+      font_params+="family=${encoded_font}:wght@400;500;600;700&"
+      ;;
+  esac
+done <<< "$fonts"
+
+# Generate @import if we have fonts
+if [[ -n "$font_params" ]]; then
+  # Remove trailing &
+  font_params="${font_params%&}"
+  echo "/* Import Web Fonts */"
+  echo "@import url('${google_fonts_url}${font_params}&display=swap');"
+  echo ""
+fi
+
+# ========================================
+# CSS Custom Properties Generation
+# ========================================
+echo ":root {"
+
+# Colors - Brand
+echo "  /* Colors - Brand */"
+echo "$json_input" | jq -r '
+  .colors.brand | to_entries[] |
+  "  --color-brand-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Colors - Surface
+echo "  /* Colors - Surface */"
+echo "$json_input" | jq -r '
+  .colors.surface | to_entries[] |
+  "  --color-surface-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Colors - Semantic
+echo "  /* Colors - Semantic */"
+echo "$json_input" | jq -r '
+  .colors.semantic | to_entries[] |
+  "  --color-semantic-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Colors - Text
+echo "  /* Colors - Text */"
+echo "$json_input" | jq -r '
+  .colors.text | to_entries[] |
+  "  --color-text-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Colors - Border
+echo "  /* Colors - Border */"
+echo "$json_input" | jq -r '
+  .colors.border | to_entries[] |
+  "  --color-border-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Typography - Font Family
+echo "  /* Typography - Font Family */"
+echo "$json_input" | jq -r '
+  .typography.font_family | to_entries[] |
+  "  --font-family-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Typography - Font Size
+echo "  /* Typography - Font Size */"
+echo "$json_input" | jq -r '
+  .typography.font_size | to_entries[] |
+  "  --font-size-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Typography - Font Weight
+echo "  /* Typography - Font Weight */"
+echo "$json_input" | jq -r '
+  .typography.font_weight | to_entries[] |
+  "  --font-weight-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Typography - Line Height
+echo "  /* Typography - Line Height */"
+echo "$json_input" | jq -r '
+  .typography.line_height | to_entries[] |
+  "  --line-height-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Typography - Letter Spacing
+echo "  /* Typography - Letter Spacing */"
+echo "$json_input" | jq -r '
+  .typography.letter_spacing | to_entries[] |
+  "  --letter-spacing-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Spacing
+echo "  /* Spacing */"
+echo "$json_input" | jq -r '
+  .spacing | to_entries[] |
+  "  --spacing-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Border Radius
+echo "  /* Border Radius */"
+echo "$json_input" | jq -r '
+  .border_radius | to_entries[] |
+  "  --border-radius-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Shadows
+echo "  /* Shadows */"
+echo "$json_input" | jq -r '
+  .shadows | to_entries[] |
+  "  --shadow-\(.key): \(.value);"
+' 2>/dev/null
+
+echo ""
+
+# Breakpoints
+echo "  /* Breakpoints */"
+echo "$json_input" | jq -r '
+  .breakpoints | to_entries[] |
+  "  --breakpoint-\(.key): \(.value);"
+' 2>/dev/null
+
+echo "}"
+echo ""
+
+# ========================================
+# Global Font Application
+# ========================================
+echo "/* ========================================"
+echo "   Global Font Application"
+echo "   ======================================== */"
+echo ""
+echo "body {"
+echo "  font-family: var(--font-family-body);"
+echo "  font-size: var(--font-size-base);"
+echo "  line-height: var(--line-height-normal);"
+echo "  color: var(--color-text-primary);"
+echo "  background-color: var(--color-surface-background);"
+echo "}"
+echo ""
+echo "h1, h2, h3, h4, h5, h6, legend {"
+echo "  font-family: var(--font-family-heading);"
+echo "}"
+echo ""
+echo "/* Reset default margins for better control */"
+echo "* {"
+echo "  margin: 0;"
+echo "  padding: 0;"
+echo "  box-sizing: border-box;"
+echo "}"

.claude/scripts/detect_changed_modules.sh

@@ -0,0 +1,157 @@
+#!/bin/bash
+# Detect modules affected by git changes or recent modifications
+# Usage: detect_changed_modules.sh [format]
+#   format: list|grouped|paths (default: paths)
+#
+# Features:
+# - Respects .gitignore patterns (current directory or git root)
+# - Detects git changes (staged, unstaged, or last commit)
+# - Falls back to recently modified files (last 24 hours)
+
+# Build exclusion filters from .gitignore
+build_exclusion_filters() {
+    local filters=""
+
+    # Common system/cache directories to exclude
+    local system_excludes=(
+        ".git" "__pycache__" "node_modules" ".venv" "venv" "env"
+        "dist" "build" ".cache" ".pytest_cache" ".mypy_cache"
+        "coverage" ".nyc_output" "logs" "tmp" "temp"
+    )
+
+    for exclude in "${system_excludes[@]}"; do
+        filters+=" -not -path '*/$exclude' -not -path '*/$exclude/*'"
+    done
+
+    # Find and parse .gitignore (current dir first, then git root)
+    local gitignore_file=""
+
+    # Check current directory first
+    if [ -f ".gitignore" ]; then
+        gitignore_file=".gitignore"
+    else
+        # Try to find git root and check for .gitignore there
+        local git_root=$(git rev-parse --show-toplevel 2>/dev/null)
+        if [ -n "$git_root" ] && [ -f "$git_root/.gitignore" ]; then
+            gitignore_file="$git_root/.gitignore"
+        fi
+    fi
+
+    # Parse .gitignore if found
+    if [ -n "$gitignore_file" ]; then
+        while IFS= read -r line; do
+            # Skip empty lines and comments
+            [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
+
+            # Remove trailing slash and whitespace
+            line=$(echo "$line" | sed 's|/$||' | xargs)
+
+            # Skip wildcards patterns (too complex for simple find)
+            [[ "$line" =~ \* ]] && continue
+
+            # Add to filters
+            filters+=" -not -path '*/$line' -not -path '*/$line/*'"
+        done < "$gitignore_file"
+    fi
+
+    echo "$filters"
+}
+
+detect_changed_modules() {
+    local format="${1:-paths}"
+    local changed_files=""
+    local affected_dirs=""
+    local exclusion_filters=$(build_exclusion_filters)
+
+    # Step 1: Try to get git changes (staged + unstaged)
+    if git rev-parse --git-dir > /dev/null 2>&1; then
+        changed_files=$(git diff --name-only HEAD 2>/dev/null; git diff --name-only --cached 2>/dev/null)
+
+        # If no changes in working directory, check last commit
+        if [ -z "$changed_files" ]; then
+            changed_files=$(git diff --name-only HEAD~1 HEAD 2>/dev/null)
+        fi
+    fi
+
+    # Step 2: If no git changes, find recently modified source files (last 24 hours)
+    # Apply exclusion filters from .gitignore
+    if [ -z "$changed_files" ]; then
+        changed_files=$(eval "find . -type f \( \
+            -name '*.md' -o \
+            -name '*.js' -o -name '*.ts' -o -name '*.jsx' -o -name '*.tsx' -o \
+            -name '*.py' -o -name '*.go' -o -name '*.rs' -o \
+            -name '*.java' -o -name '*.cpp' -o -name '*.c' -o -name '*.h' -o \
+            -name '*.sh' -o -name '*.ps1' -o \
+            -name '*.json' -o -name '*.yaml' -o -name '*.yml' \
+        \) $exclusion_filters -mtime -1 2>/dev/null")
+    fi
+    
+    # Step 3: Extract unique parent directories
+    if [ -n "$changed_files" ]; then
+        affected_dirs=$(echo "$changed_files" | \
+            sed 's|/[^/]*$||' | \
+            grep -v '^\.$' | \
+            sort -u)
+        
+        # Add current directory if files are in root
+        if echo "$changed_files" | grep -q '^[^/]*$'; then
+            affected_dirs=$(echo -e ".\n$affected_dirs" | sort -u)
+        fi
+    fi
+    
+    # Step 4: Output in requested format
+    case "$format" in
+        "list")
+            if [ -n "$affected_dirs" ]; then
+                echo "$affected_dirs" | while read dir; do
+                    if [ -d "$dir" ]; then
+                        local file_count=$(find "$dir" -maxdepth 1 -type f 2>/dev/null | wc -l)
+                        local depth=$(echo "$dir" | tr -cd '/' | wc -c)
+                        if [ "$dir" = "." ]; then depth=0; fi
+                        
+                        local types=$(find "$dir" -maxdepth 1 -type f -name "*.*" 2>/dev/null | \
+                                    grep -E '\.[^/]*$' | sed 's/.*\.//' | sort -u | tr '\n' ',' | sed 's/,$//')
+                        local has_claude="no"
+                        [ -f "$dir/CLAUDE.md" ] && has_claude="yes"
+                        echo "depth:$depth|path:$dir|files:$file_count|types:[$types]|has_claude:$has_claude|status:changed"
+                    fi
+                done
+            fi
+            ;;
+            
+        "grouped")
+            if [ -n "$affected_dirs" ]; then
+                echo "📊 Affected modules by changes:"
+                # Group by depth
+                echo "$affected_dirs" | while read dir; do
+                    if [ -d "$dir" ]; then
+                        local depth=$(echo "$dir" | tr -cd '/' | wc -c)
+                        if [ "$dir" = "." ]; then depth=0; fi
+                        local claude_indicator=""
+                        [ -f "$dir/CLAUDE.md" ] && claude_indicator=" [✓]"
+                        echo "$depth:$dir$claude_indicator"
+                    fi
+                done | sort -n | awk -F: '
+                    {
+                        if ($1 != prev_depth) {
+                            if (prev_depth != "") print ""
+                            print "  📁 Depth " $1 ":"
+                            prev_depth = $1
+                        }
+                        print "    - " $2 " (changed)"
+                    }'
+            else
+                echo "📊 No recent changes detected"
+            fi
+            ;;
+            
+        "paths"|*)
+            echo "$affected_dirs"
+            ;;
+    esac
+}
+
+# Execute function if script is run directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    detect_changed_modules "$@"
+fi

.claude/scripts/discover-design-files.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# discover-design-files.sh - Discover design-related files and output JSON
+# Usage: discover-design-files.sh <source_dir> <output_json>
+
+set -euo pipefail
+
+source_dir="${1:-.}"
+output_json="${2:-discovered-files.json}"
+
+# Function to find and format files as JSON array
+find_files() {
+  local pattern="$1"
+  local files
+  files=$(eval "find \"$source_dir\" -type f $pattern \
+    ! -path \"*/node_modules/*\" \
+    ! -path \"*/dist/*\" \
+    ! -path \"*/.git/*\" \
+    ! -path \"*/build/*\" \
+    ! -path \"*/coverage/*\" \
+    2>/dev/null | sort || true")
+
+  local count
+  if [ -z "$files" ]; then
+    count=0
+  else
+    count=$(echo "$files" | grep -c . || echo 0)
+  fi
+  local json_files=""
+
+  if [ "$count" -gt 0 ]; then
+    json_files=$(echo "$files" | awk '{printf "\"%s\"%s\n", $0, (NR<'$count'?",":"")}' | tr '\n' ' ')
+  fi
+
+  echo "$count|$json_files"
+}
+
+# Discover CSS/SCSS files
+css_result=$(find_files '\( -name "*.css" -o -name "*.scss" \)')
+css_count=${css_result%%|*}
+css_files=${css_result#*|}
+
+# Discover JS/TS files (all framework files)
+js_result=$(find_files '\( -name "*.js" -o -name "*.ts" -o -name "*.jsx" -o -name "*.tsx" -o -name "*.mjs" -o -name "*.cjs" -o -name "*.vue" -o -name "*.svelte" \)')
+js_count=${js_result%%|*}
+js_files=${js_result#*|}
+
+# Discover HTML files
+html_result=$(find_files '-name "*.html"')
+html_count=${html_result%%|*}
+html_files=${html_result#*|}
+
+# Calculate total
+total_count=$((css_count + js_count + html_count))
+
+# Generate JSON
+cat > "$output_json" << EOF
+{
+  "discovery_time": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "source_directory": "$(cd "$source_dir" && pwd)",
+  "file_types": {
+    "css": {
+      "count": $css_count,
+      "files": [${css_files}]
+    },
+    "js": {
+      "count": $js_count,
+      "files": [${js_files}]
+    },
+    "html": {
+      "count": $html_count,
+      "files": [${html_files}]
+    }
+  },
+  "total_files": $total_count
+}
+EOF
+
+# Ensure file is fully written and synchronized to disk
+# This prevents race conditions when the file is immediately read by another process
+sync "$output_json" 2>/dev/null || sync  # Sync specific file, fallback to full sync
+sleep 0.1  # Additional safety: 100ms delay for filesystem metadata update
+
+echo "Discovered: CSS=$css_count, JS=$js_count, HTML=$html_count (Total: $total_count)" >&2

.claude/scripts/extract-animations.js

@@ -0,0 +1,243 @@
+/**
+ * Animation & Transition Extraction Script
+ *
+ * Extracts CSS animations, transitions, and transform patterns from a live web page.
+ * This script runs in the browser context via Chrome DevTools Protocol.
+ *
+ * @returns {Object} Structured animation data
+ */
+(() => {
+  const extractionTimestamp = new Date().toISOString();
+  const currentUrl = window.location.href;
+
+  /**
+   * Parse transition shorthand or individual properties
+   */
+  function parseTransition(element, computedStyle) {
+    const transition = computedStyle.transition || computedStyle.webkitTransition;
+
+    if (!transition || transition === 'none' || transition === 'all 0s ease 0s') {
+      return null;
+    }
+
+    // Parse shorthand: "property duration easing delay"
+    const transitions = [];
+    const parts = transition.split(/,\s*/);
+
+    parts.forEach(part => {
+      const match = part.match(/^(\S+)\s+([\d.]+m?s)\s+(\S+)(?:\s+([\d.]+m?s))?/);
+      if (match) {
+        transitions.push({
+          property: match[1],
+          duration: match[2],
+          easing: match[3],
+          delay: match[4] || '0s'
+        });
+      }
+    });
+
+    return transitions.length > 0 ? transitions : null;
+  }
+
+  /**
+   * Extract animation name and properties
+   */
+  function parseAnimation(element, computedStyle) {
+    const animationName = computedStyle.animationName || computedStyle.webkitAnimationName;
+
+    if (!animationName || animationName === 'none') {
+      return null;
+    }
+
+    return {
+      name: animationName,
+      duration: computedStyle.animationDuration || computedStyle.webkitAnimationDuration,
+      easing: computedStyle.animationTimingFunction || computedStyle.webkitAnimationTimingFunction,
+      delay: computedStyle.animationDelay || computedStyle.webkitAnimationDelay || '0s',
+      iterationCount: computedStyle.animationIterationCount || computedStyle.webkitAnimationIterationCount || '1',
+      direction: computedStyle.animationDirection || computedStyle.webkitAnimationDirection || 'normal',
+      fillMode: computedStyle.animationFillMode || computedStyle.webkitAnimationFillMode || 'none'
+    };
+  }
+
+  /**
+   * Extract transform value
+   */
+  function parseTransform(computedStyle) {
+    const transform = computedStyle.transform || computedStyle.webkitTransform;
+
+    if (!transform || transform === 'none') {
+      return null;
+    }
+
+    return transform;
+  }
+
+  /**
+   * Get element selector (simplified for readability)
+   */
+  function getSelector(element) {
+    if (element.id) {
+      return `#${element.id}`;
+    }
+
+    if (element.className && typeof element.className === 'string') {
+      const classes = element.className.trim().split(/\s+/).slice(0, 2).join('.');
+      if (classes) {
+        return `.${classes}`;
+      }
+    }
+
+    return element.tagName.toLowerCase();
+  }
+
+  /**
+   * Extract all stylesheets and find @keyframes rules
+   */
+  function extractKeyframes() {
+    const keyframes = {};
+
+    try {
+      // Iterate through all stylesheets
+      Array.from(document.styleSheets).forEach(sheet => {
+        try {
+          // Skip external stylesheets due to CORS
+          if (sheet.href && !sheet.href.startsWith(window.location.origin)) {
+            return;
+          }
+
+          Array.from(sheet.cssRules || sheet.rules || []).forEach(rule => {
+            // Check for @keyframes rules
+            if (rule.type === CSSRule.KEYFRAMES_RULE || rule.type === CSSRule.WEBKIT_KEYFRAMES_RULE) {
+              const name = rule.name;
+              const frames = {};
+
+              Array.from(rule.cssRules || []).forEach(keyframe => {
+                const key = keyframe.keyText; // e.g., "0%", "50%", "100%"
+                frames[key] = keyframe.style.cssText;
+              });
+
+              keyframes[name] = frames;
+            }
+          });
+        } catch (e) {
+          // Skip stylesheets that can't be accessed (CORS)
+          console.warn('Cannot access stylesheet:', sheet.href, e.message);
+        }
+      });
+    } catch (e) {
+      console.error('Error extracting keyframes:', e);
+    }
+
+    return keyframes;
+  }
+
+  /**
+   * Scan visible elements for animations and transitions
+   */
+  function scanElements() {
+    const elements = document.querySelectorAll('*');
+    const transitionData = [];
+    const animationData = [];
+    const transformData = [];
+
+    const uniqueTransitions = new Set();
+    const uniqueAnimations = new Set();
+    const uniqueEasings = new Set();
+    const uniqueDurations = new Set();
+
+    elements.forEach(element => {
+      // Skip invisible elements
+      const rect = element.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) {
+        return;
+      }
+
+      const computedStyle = window.getComputedStyle(element);
+
+      // Extract transitions
+      const transitions = parseTransition(element, computedStyle);
+      if (transitions) {
+        const selector = getSelector(element);
+        transitions.forEach(t => {
+          const key = `${t.property}-${t.duration}-${t.easing}`;
+          if (!uniqueTransitions.has(key)) {
+            uniqueTransitions.add(key);
+            transitionData.push({
+              selector,
+              ...t
+            });
+            uniqueEasings.add(t.easing);
+            uniqueDurations.add(t.duration);
+          }
+        });
+      }
+
+      // Extract animations
+      const animation = parseAnimation(element, computedStyle);
+      if (animation) {
+        const selector = getSelector(element);
+        const key = `${animation.name}-${animation.duration}`;
+        if (!uniqueAnimations.has(key)) {
+          uniqueAnimations.add(key);
+          animationData.push({
+            selector,
+            ...animation
+          });
+          uniqueEasings.add(animation.easing);
+          uniqueDurations.add(animation.duration);
+        }
+      }
+
+      // Extract transforms (on hover/active, we only get current state)
+      const transform = parseTransform(computedStyle);
+      if (transform) {
+        const selector = getSelector(element);
+        transformData.push({
+          selector,
+          transform
+        });
+      }
+    });
+
+    return {
+      transitions: transitionData,
+      animations: animationData,
+      transforms: transformData,
+      uniqueEasings: Array.from(uniqueEasings),
+      uniqueDurations: Array.from(uniqueDurations)
+    };
+  }
+
+  /**
+   * Main extraction function
+   */
+  function extractAnimations() {
+    const elementData = scanElements();
+    const keyframes = extractKeyframes();
+
+    return {
+      metadata: {
+        timestamp: extractionTimestamp,
+        url: currentUrl,
+        method: 'chrome-devtools',
+        version: '1.0.0'
+      },
+      transitions: elementData.transitions,
+      animations: elementData.animations,
+      transforms: elementData.transforms,
+      keyframes: keyframes,
+      summary: {
+        total_transitions: elementData.transitions.length,
+        total_animations: elementData.animations.length,
+        total_transforms: elementData.transforms.length,
+        total_keyframes: Object.keys(keyframes).length,
+        unique_easings: elementData.uniqueEasings,
+        unique_durations: elementData.uniqueDurations
+      }
+    };
+  }
+
+  // Execute extraction
+  return extractAnimations();
+})();

.claude/scripts/extract-computed-styles.js

@@ -0,0 +1,118 @@
+/**
+ * Extract Computed Styles from DOM
+ *
+ * This script extracts real CSS computed styles from a webpage's DOM
+ * to provide accurate design tokens for UI replication.
+ *
+ * Usage: Execute this function via Chrome DevTools evaluate_script
+ */
+
+(() => {
+  /**
+   * Extract unique values from a set and sort them
+   */
+  const uniqueSorted = (set) => {
+    return Array.from(set)
+      .filter(v => v && v !== 'none' && v !== '0px' && v !== 'rgba(0, 0, 0, 0)')
+      .sort();
+  };
+
+  /**
+   * Parse rgb/rgba to OKLCH format (placeholder - returns original for now)
+   */
+  const toOKLCH = (color) => {
+    // TODO: Implement actual RGB to OKLCH conversion
+    // For now, return the original color with a note
+    return `${color} /* TODO: Convert to OKLCH */`;
+  };
+
+  /**
+   * Extract only key styles from an element
+   */
+  const extractKeyStyles = (element) => {
+    const s = window.getComputedStyle(element);
+    return {
+      color: s.color,
+      bg: s.backgroundColor,
+      borderRadius: s.borderRadius,
+      boxShadow: s.boxShadow,
+      fontSize: s.fontSize,
+      fontWeight: s.fontWeight,
+      padding: s.padding,
+      margin: s.margin
+    };
+  };
+
+  /**
+   * Main extraction function - extract all critical design tokens
+   */
+  const extractDesignTokens = () => {
+    // Include all key UI elements
+    const selectors = [
+      'button', '.btn', '[role="button"]',
+      'input', 'textarea', 'select',
+      'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+      '.card', 'article', 'section',
+      'a', 'p', 'nav', 'header', 'footer'
+    ];
+
+    // Collect all design tokens
+    const tokens = {
+      colors: new Set(),
+      borderRadii: new Set(),
+      shadows: new Set(),
+      fontSizes: new Set(),
+      fontWeights: new Set(),
+      spacing: new Set()
+    };
+
+    // Extract from all elements
+    selectors.forEach(selector => {
+      try {
+        const elements = document.querySelectorAll(selector);
+        elements.forEach(element => {
+          const s = extractKeyStyles(element);
+
+          // Collect all tokens (no limits)
+          if (s.color && s.color !== 'rgba(0, 0, 0, 0)') tokens.colors.add(s.color);
+          if (s.bg && s.bg !== 'rgba(0, 0, 0, 0)') tokens.colors.add(s.bg);
+          if (s.borderRadius && s.borderRadius !== '0px') tokens.borderRadii.add(s.borderRadius);
+          if (s.boxShadow && s.boxShadow !== 'none') tokens.shadows.add(s.boxShadow);
+          if (s.fontSize) tokens.fontSizes.add(s.fontSize);
+          if (s.fontWeight) tokens.fontWeights.add(s.fontWeight);
+
+          // Extract all spacing values
+          [s.padding, s.margin].forEach(val => {
+            if (val && val !== '0px') {
+              val.split(' ').forEach(v => {
+                if (v && v !== '0px') tokens.spacing.add(v);
+              });
+            }
+          });
+        });
+      } catch (e) {
+        console.warn(`Error: ${selector}`, e);
+      }
+    });
+
+    // Return all tokens (no element details to save context)
+    return {
+      metadata: {
+        extractedAt: new Date().toISOString(),
+        url: window.location.href,
+        method: 'computed-styles'
+      },
+      tokens: {
+        colors: uniqueSorted(tokens.colors),
+        borderRadii: uniqueSorted(tokens.borderRadii),  // ALL radius values
+        shadows: uniqueSorted(tokens.shadows),          // ALL shadows
+        fontSizes: uniqueSorted(tokens.fontSizes),
+        fontWeights: uniqueSorted(tokens.fontWeights),
+        spacing: uniqueSorted(tokens.spacing)
+      }
+    };
+  };
+
+  // Execute and return results
+  return extractDesignTokens();
+})();

.claude/scripts/extract-layout-structure.js

@@ -0,0 +1,411 @@
+/**
+ * Extract Layout Structure from DOM - Enhanced Version
+ *
+ * Extracts real layout information from DOM to provide accurate
+ * structural data for UI replication.
+ *
+ * Features:
+ * - Framework detection (Nuxt.js, Next.js, React, Vue, Angular)
+ * - Multi-strategy container detection (strict → relaxed → class-based → framework-specific)
+ * - Intelligent main content detection with common class names support
+ * - Supports modern SPA frameworks
+ * - Detects non-semantic main containers (.main, .content, etc.)
+ * - Progressive exploration: Auto-discovers missing selectors when standard patterns fail
+ * - Suggests new class names to add to script based on actual page structure
+ *
+ * Progressive Exploration:
+ * When fewer than 3 main containers are found, the script automatically:
+ * 1. Analyzes all large visible containers (≥500×300px)
+ * 2. Extracts class name patterns (main/content/wrapper/container/page/etc.)
+ * 3. Suggests new selectors to add to the script
+ * 4. Returns exploration data in result.exploration
+ *
+ * Usage: Execute via Chrome DevTools evaluate_script
+ * Version: 2.2.0
+ */
+
+(() => {
+  /**
+   * Get element's bounding box relative to viewport
+   */
+  const getBounds = (element) => {
+    const rect = element.getBoundingClientRect();
+    return {
+      x: Math.round(rect.x),
+      y: Math.round(rect.y),
+      width: Math.round(rect.width),
+      height: Math.round(rect.height)
+    };
+  };
+
+  /**
+   * Extract layout properties from an element
+   */
+  const extractLayoutProps = (element) => {
+    const s = window.getComputedStyle(element);
+
+    return {
+      // Core layout
+      display: s.display,
+      position: s.position,
+
+      // Flexbox
+      flexDirection: s.flexDirection,
+      justifyContent: s.justifyContent,
+      alignItems: s.alignItems,
+      flexWrap: s.flexWrap,
+      gap: s.gap,
+
+      // Grid
+      gridTemplateColumns: s.gridTemplateColumns,
+      gridTemplateRows: s.gridTemplateRows,
+      gridAutoFlow: s.gridAutoFlow,
+
+      // Dimensions
+      width: s.width,
+      height: s.height,
+      maxWidth: s.maxWidth,
+      minWidth: s.minWidth,
+
+      // Spacing
+      padding: s.padding,
+      margin: s.margin
+    };
+  };
+
+  /**
+   * Identify layout pattern for an element
+   */
+  const identifyPattern = (props) => {
+    const { display, flexDirection, gridTemplateColumns } = props;
+
+    if (display === 'flex' || display === 'inline-flex') {
+      if (flexDirection === 'column') return 'flex-column';
+      if (flexDirection === 'row') return 'flex-row';
+      return 'flex';
+    }
+
+    if (display === 'grid') {
+      const cols = gridTemplateColumns;
+      if (cols && cols !== 'none') {
+        const colCount = cols.split(' ').length;
+        return `grid-${colCount}col`;
+      }
+      return 'grid';
+    }
+
+    if (display === 'block') return 'block';
+
+    return display;
+  };
+
+  /**
+   * Detect frontend framework
+   */
+  const detectFramework = () => {
+    if (document.querySelector('#__nuxt')) return { name: 'Nuxt.js', version: 'unknown' };
+    if (document.querySelector('#__next')) return { name: 'Next.js', version: 'unknown' };
+    if (document.querySelector('[data-reactroot]')) return { name: 'React', version: 'unknown' };
+    if (document.querySelector('[ng-version]')) return { name: 'Angular', version: 'unknown' };
+    if (window.Vue) return { name: 'Vue.js', version: window.Vue.version || 'unknown' };
+    return { name: 'Unknown', version: 'unknown' };
+  };
+
+  /**
+   * Build layout tree recursively
+   */
+  const buildLayoutTree = (element, depth = 0, maxDepth = 3) => {
+    if (depth > maxDepth) return null;
+
+    const props = extractLayoutProps(element);
+    const bounds = getBounds(element);
+    const pattern = identifyPattern(props);
+
+    // Get semantic role
+    const tagName = element.tagName.toLowerCase();
+    const classes = Array.from(element.classList).slice(0, 3); // Max 3 classes
+    const role = element.getAttribute('role');
+
+    // Build node
+    const node = {
+      tag: tagName,
+      classes: classes,
+      role: role,
+      pattern: pattern,
+      bounds: bounds,
+      layout: {
+        display: props.display,
+        position: props.position
+      }
+    };
+
+    // Add flex/grid specific properties
+    if (props.display === 'flex' || props.display === 'inline-flex') {
+      node.layout.flexDirection = props.flexDirection;
+      node.layout.justifyContent = props.justifyContent;
+      node.layout.alignItems = props.alignItems;
+      node.layout.gap = props.gap;
+    }
+
+    if (props.display === 'grid') {
+      node.layout.gridTemplateColumns = props.gridTemplateColumns;
+      node.layout.gridTemplateRows = props.gridTemplateRows;
+      node.layout.gap = props.gap;
+    }
+
+    // Process children for container elements
+    if (props.display === 'flex' || props.display === 'grid' || props.display === 'block') {
+      const children = Array.from(element.children);
+      if (children.length > 0 && children.length < 50) { // Limit to 50 children
+        node.children = children
+          .map(child => buildLayoutTree(child, depth + 1, maxDepth))
+          .filter(child => child !== null);
+      }
+    }
+
+    return node;
+  };
+
+  /**
+   * Find main layout containers with multi-strategy approach
+   */
+  const findMainContainers = () => {
+    const containers = [];
+    const found = new Set();
+
+    // Strategy 1: Strict selectors (body direct children)
+    const strictSelectors = [
+      'body > header',
+      'body > nav',
+      'body > main',
+      'body > footer'
+    ];
+
+    // Strategy 2: Relaxed selectors (any level)
+    const relaxedSelectors = [
+      'header',
+      'nav',
+      'main',
+      'footer',
+      '[role="banner"]',
+      '[role="navigation"]',
+      '[role="main"]',
+      '[role="contentinfo"]'
+    ];
+
+    // Strategy 3: Common class-based main content selectors
+    const commonClassSelectors = [
+      '.main',
+      '.content',
+      '.main-content',
+      '.page-content',
+      '.container.main',
+      '.wrapper > .main',
+      'div[class*="main-wrapper"]',
+      'div[class*="content-wrapper"]'
+    ];
+
+    // Strategy 4: Framework-specific selectors
+    const frameworkSelectors = [
+      '#__nuxt header', '#__nuxt .main', '#__nuxt main', '#__nuxt footer',
+      '#__next header', '#__next .main', '#__next main', '#__next footer',
+      '#app header', '#app .main', '#app main', '#app footer',
+      '[data-app] header', '[data-app] .main', '[data-app] main', '[data-app] footer'
+    ];
+
+    // Try all strategies
+    const allSelectors = [...strictSelectors, ...relaxedSelectors, ...commonClassSelectors, ...frameworkSelectors];
+
+    allSelectors.forEach(selector => {
+      try {
+        const elements = document.querySelectorAll(selector);
+        elements.forEach(element => {
+          // Avoid duplicates and invisible elements
+          if (!found.has(element) && element.offsetParent !== null) {
+            found.add(element);
+            const tree = buildLayoutTree(element, 0, 3);
+            if (tree && tree.bounds.width > 0 && tree.bounds.height > 0) {
+              containers.push(tree);
+            }
+          }
+        });
+      } catch (e) {
+        console.warn(`Selector failed: ${selector}`, e);
+      }
+    });
+
+    // Fallback: If no containers found, use body's direct children
+    if (containers.length === 0) {
+      Array.from(document.body.children).forEach(child => {
+        if (child.offsetParent !== null && !found.has(child)) {
+          const tree = buildLayoutTree(child, 0, 2);
+          if (tree && tree.bounds.width > 100 && tree.bounds.height > 100) {
+            containers.push(tree);
+          }
+        }
+      });
+    }
+
+    return containers;
+  };
+
+  /**
+   * Progressive exploration: Discover main containers when standard selectors fail
+   * Analyzes large visible containers and suggests class name patterns
+   */
+  const exploreMainContainers = () => {
+    const candidates = [];
+    const minWidth = 500;
+    const minHeight = 300;
+
+    // Find all large visible divs
+    const allDivs = document.querySelectorAll('div');
+    allDivs.forEach(div => {
+      const rect = div.getBoundingClientRect();
+      const style = window.getComputedStyle(div);
+
+      // Filter: large size, visible, not header/footer
+      if (rect.width >= minWidth &&
+          rect.height >= minHeight &&
+          div.offsetParent !== null &&
+          !div.closest('header') &&
+          !div.closest('footer')) {
+
+        const classes = Array.from(div.classList);
+        const area = rect.width * rect.height;
+
+        candidates.push({
+          element: div,
+          classes: classes,
+          area: area,
+          bounds: {
+            width: Math.round(rect.width),
+            height: Math.round(rect.height)
+          },
+          display: style.display,
+          depth: getElementDepth(div)
+        });
+      }
+    });
+
+    // Sort by area (largest first) and take top candidates
+    candidates.sort((a, b) => b.area - a.area);
+
+    // Extract unique class patterns from top candidates
+    const classPatterns = new Set();
+    candidates.slice(0, 20).forEach(c => {
+      c.classes.forEach(cls => {
+        // Identify potential main content class patterns
+        if (cls.match(/main|content|container|wrapper|page|body|layout|app/i)) {
+          classPatterns.add(cls);
+        }
+      });
+    });
+
+    return {
+      candidates: candidates.slice(0, 10).map(c => ({
+        classes: c.classes,
+        bounds: c.bounds,
+        display: c.display,
+        depth: c.depth
+      })),
+      suggestedSelectors: Array.from(classPatterns).map(cls => `.${cls}`)
+    };
+  };
+
+  /**
+   * Get element depth in DOM tree
+   */
+  const getElementDepth = (element) => {
+    let depth = 0;
+    let current = element;
+    while (current.parentElement) {
+      depth++;
+      current = current.parentElement;
+    }
+    return depth;
+  };
+
+  /**
+   * Analyze layout patterns
+   */
+  const analyzePatterns = (containers) => {
+    const patterns = {
+      flexColumn: 0,
+      flexRow: 0,
+      grid: 0,
+      sticky: 0,
+      fixed: 0
+    };
+
+    const analyze = (node) => {
+      if (!node) return;
+
+      if (node.pattern === 'flex-column') patterns.flexColumn++;
+      if (node.pattern === 'flex-row') patterns.flexRow++;
+      if (node.pattern && node.pattern.startsWith('grid')) patterns.grid++;
+      if (node.layout.position === 'sticky') patterns.sticky++;
+      if (node.layout.position === 'fixed') patterns.fixed++;
+
+      if (node.children) {
+        node.children.forEach(analyze);
+      }
+    };
+
+    containers.forEach(analyze);
+    return patterns;
+  };
+
+  /**
+   * Main extraction function with progressive exploration
+   */
+  const extractLayout = () => {
+    const framework = detectFramework();
+    const containers = findMainContainers();
+    const patterns = analyzePatterns(containers);
+
+    // Progressive exploration: if too few containers found, explore and suggest
+    let exploration = null;
+    const minExpectedContainers = 3; // At least header, main, footer
+
+    if (containers.length < minExpectedContainers) {
+      exploration = exploreMainContainers();
+
+      // Add warning message
+      exploration.warning = `Only ${containers.length} containers found. Consider adding these selectors to the script:`;
+      exploration.recommendation = exploration.suggestedSelectors.join(', ');
+    }
+
+    const result = {
+      metadata: {
+        extractedAt: new Date().toISOString(),
+        url: window.location.href,
+        framework: framework,
+        method: 'layout-structure-enhanced',
+        version: '2.2.0'
+      },
+      statistics: {
+        totalContainers: containers.length,
+        patterns: patterns
+      },
+      structure: containers
+    };
+
+    // Add exploration results if triggered
+    if (exploration) {
+      result.exploration = {
+        triggered: true,
+        reason: 'Insufficient containers found with standard selectors',
+        discoveredCandidates: exploration.candidates,
+        suggestedSelectors: exploration.suggestedSelectors,
+        warning: exploration.warning,
+        recommendation: exploration.recommendation
+      };
+    }
+
+    return result;
+  };
+
+  // Execute and return results
+  return extractLayout();
+})();

.claude/scripts/generate_module_docs.sh

@@ -0,0 +1,713 @@
+#!/bin/bash
+# Generate documentation for modules and projects with multiple strategies
+# Usage: generate_module_docs.sh <strategy> <source_path> <project_name> [tool] [model]
+#   strategy: full|single|project-readme|project-architecture|http-api
+#   source_path: Path to the source module directory (or project root for project-level docs)
+#   project_name: Project name for output path (e.g., "myproject")
+#   tool: gemini|qwen|codex (default: gemini)
+#   model: Model name (optional, uses tool defaults)
+#
+# Default Models:
+#   gemini: gemini-2.5-flash
+#   qwen: coder-model
+#   codex: gpt5-codex
+#
+# Module-Level Strategies:
+#   full: Full documentation generation
+#     - Read: All files in current and subdirectories (@**/*)
+#     - Generate: API.md + README.md for each directory containing code files
+#     - Use: Deep directories (Layer 3), comprehensive documentation
+#
+#   single: Single-layer documentation
+#     - Read: Current directory code + child API.md/README.md files
+#     - Generate: API.md + README.md only in current directory
+#     - Use: Upper layers (Layer 1-2), incremental updates
+#
+# Project-Level Strategies:
+#   project-readme: Project overview documentation
+#     - Read: All module API.md and README.md files
+#     - Generate: README.md (project root)
+#     - Use: After all module docs are generated
+#
+#   project-architecture: System design documentation
+#     - Read: All module docs + project README
+#     - Generate: ARCHITECTURE.md + EXAMPLES.md
+#     - Use: After project README is generated
+#
+#   http-api: HTTP API documentation
+#     - Read: API route files + existing docs
+#     - Generate: api/README.md
+#     - Use: For projects with HTTP APIs
+#
+# Output Structure:
+#   Module docs: .workflow/docs/{project_name}/{source_path}/API.md
+#   Module docs: .workflow/docs/{project_name}/{source_path}/README.md
+#   Project docs: .workflow/docs/{project_name}/README.md
+#   Project docs: .workflow/docs/{project_name}/ARCHITECTURE.md
+#   Project docs: .workflow/docs/{project_name}/EXAMPLES.md
+#   API docs: .workflow/docs/{project_name}/api/README.md
+#
+# Features:
+#   - Path mirroring: source structure → docs structure
+#   - Template-driven generation
+#   - Respects .gitignore patterns
+#   - Detects code vs navigation folders
+#   - Tool fallback support
+
+# Build exclusion filters from .gitignore
+build_exclusion_filters() {
+    local filters=""
+
+    # Common system/cache directories to exclude
+    local system_excludes=(
+        ".git" "__pycache__" "node_modules" ".venv" "venv" "env"
+        "dist" "build" ".cache" ".pytest_cache" ".mypy_cache"
+        "coverage" ".nyc_output" "logs" "tmp" "temp" ".workflow"
+    )
+
+    for exclude in "${system_excludes[@]}"; do
+        filters+=" -not -path '*/$exclude' -not -path '*/$exclude/*'"
+    done
+
+    # Find and parse .gitignore (current dir first, then git root)
+    local gitignore_file=""
+
+    # Check current directory first
+    if [ -f ".gitignore" ]; then
+        gitignore_file=".gitignore"
+    else
+        # Try to find git root and check for .gitignore there
+        local git_root=$(git rev-parse --show-toplevel 2>/dev/null)
+        if [ -n "$git_root" ] && [ -f "$git_root/.gitignore" ]; then
+            gitignore_file="$git_root/.gitignore"
+        fi
+    fi
+
+    # Parse .gitignore if found
+    if [ -n "$gitignore_file" ]; then
+        while IFS= read -r line; do
+            # Skip empty lines and comments
+            [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
+
+            # Remove trailing slash and whitespace
+            line=$(echo "$line" | sed 's|/$||' | xargs)
+
+            # Skip wildcards patterns (too complex for simple find)
+            [[ "$line" =~ \* ]] && continue
+
+            # Add to filters
+            filters+=" -not -path '*/$line' -not -path '*/$line/*'"
+        done < "$gitignore_file"
+    fi
+
+    echo "$filters"
+}
+
+# Detect folder type (code vs navigation)
+detect_folder_type() {
+    local target_path="$1"
+    local exclusion_filters="$2"
+
+    # Count code files (primary indicators)
+    local code_count=$(eval "find \"$target_path\" -maxdepth 1 -type f \\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' -o -name '*.py' -o -name '*.sh' -o -name '*.go' -o -name '*.rs' \\) $exclusion_filters 2>/dev/null" | wc -l)
+
+    if [ $code_count -gt 0 ]; then
+        echo "code"
+    else
+        echo "navigation"
+    fi
+}
+
+# Scan directory structure and generate structured information
+scan_directory_structure() {
+    local target_path="$1"
+    local strategy="$2"
+
+    if [ ! -d "$target_path" ]; then
+        echo "Directory not found: $target_path"
+        return 1
+    fi
+
+    local exclusion_filters=$(build_exclusion_filters)
+    local structure_info=""
+
+    # Get basic directory info
+    local dir_name=$(basename "$target_path")
+    local total_files=$(eval "find \"$target_path\" -type f $exclusion_filters 2>/dev/null" | wc -l)
+    local total_dirs=$(eval "find \"$target_path\" -type d $exclusion_filters 2>/dev/null" | wc -l)
+    local folder_type=$(detect_folder_type "$target_path" "$exclusion_filters")
+
+    structure_info+="Directory: $dir_name\n"
+    structure_info+="Total files: $total_files\n"
+    structure_info+="Total directories: $total_dirs\n"
+    structure_info+="Folder type: $folder_type\n\n"
+
+    if [ "$strategy" = "full" ]; then
+        # For full: show all subdirectories with file counts
+        structure_info+="Subdirectories with files:\n"
+        while IFS= read -r dir; do
+            if [ -n "$dir" ] && [ "$dir" != "$target_path" ]; then
+                local rel_path=${dir#$target_path/}
+                local file_count=$(eval "find \"$dir\" -maxdepth 1 -type f $exclusion_filters 2>/dev/null" | wc -l)
+                if [ $file_count -gt 0 ]; then
+                    local subdir_type=$(detect_folder_type "$dir" "$exclusion_filters")
+                    structure_info+="  - $rel_path/ ($file_count files, type: $subdir_type)\n"
+                fi
+            fi
+        done < <(eval "find \"$target_path\" -type d $exclusion_filters 2>/dev/null")
+    else
+        # For single: show direct children only
+        structure_info+="Direct subdirectories:\n"
+        while IFS= read -r dir; do
+            if [ -n "$dir" ]; then
+                local dir_name=$(basename "$dir")
+                local file_count=$(eval "find \"$dir\" -maxdepth 1 -type f $exclusion_filters 2>/dev/null" | wc -l)
+                local has_api=$([ -f "$dir/API.md" ] && echo " [has API.md]" || echo "")
+                local has_readme=$([ -f "$dir/README.md" ] && echo " [has README.md]" || echo "")
+                structure_info+="  - $dir_name/ ($file_count files)$has_api$has_readme\n"
+            fi
+        done < <(eval "find \"$target_path\" -maxdepth 1 -type d $exclusion_filters 2>/dev/null" | grep -v "^$target_path$")
+    fi
+
+    # Show main file types in current directory
+    structure_info+="\nCurrent directory files:\n"
+    local code_files=$(eval "find \"$target_path\" -maxdepth 1 -type f \\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' -o -name '*.py' -o -name '*.sh' -o -name '*.go' -o -name '*.rs' \\) $exclusion_filters 2>/dev/null" | wc -l)
+    local config_files=$(eval "find \"$target_path\" -maxdepth 1 -type f \\( -name '*.json' -o -name '*.yaml' -o -name '*.yml' -o -name '*.toml' \\) $exclusion_filters 2>/dev/null" | wc -l)
+    local doc_files=$(eval "find \"$target_path\" -maxdepth 1 -type f -name '*.md' $exclusion_filters 2>/dev/null" | wc -l)
+
+    structure_info+="  - Code files: $code_files\n"
+    structure_info+="  - Config files: $config_files\n"
+    structure_info+="  - Documentation: $doc_files\n"
+
+    printf "%b" "$structure_info"
+}
+
+# Calculate output path based on source path and project name
+calculate_output_path() {
+    local source_path="$1"
+    local project_name="$2"
+    local project_root="$3"
+
+    # Get absolute path of source (normalize to Unix-style path)
+    local abs_source=$(cd "$source_path" && pwd)
+
+    # Normalize project root to same format
+    local norm_project_root=$(cd "$project_root" && pwd)
+
+    # Calculate relative path from project root
+    local rel_path="${abs_source#$norm_project_root}"
+
+    # Remove leading slash if present
+    rel_path="${rel_path#/}"
+
+    # If source is project root, use project name directly
+    if [ "$abs_source" = "$norm_project_root" ] || [ -z "$rel_path" ]; then
+        echo "$norm_project_root/.workflow/docs/$project_name"
+    else
+        echo "$norm_project_root/.workflow/docs/$project_name/$rel_path"
+    fi
+}
+
+generate_module_docs() {
+    local strategy="$1"
+    local source_path="$2"
+    local project_name="$3"
+    local tool="${4:-gemini}"
+    local model="$5"
+
+    # Validate parameters
+    if [ -z "$strategy" ] || [ -z "$source_path" ] || [ -z "$project_name" ]; then
+        echo "❌ Error: Strategy, source path, and project name are required"
+        echo "Usage: generate_module_docs.sh <strategy> <source_path> <project_name> [tool] [model]"
+        echo "Module strategies: full, single"
+        echo "Project strategies: project-readme, project-architecture, http-api"
+        return 1
+    fi
+
+    # Validate strategy
+    local valid_strategies=("full" "single" "project-readme" "project-architecture" "http-api")
+    local strategy_valid=false
+    for valid_strategy in "${valid_strategies[@]}"; do
+        if [ "$strategy" = "$valid_strategy" ]; then
+            strategy_valid=true
+            break
+        fi
+    done
+
+    if [ "$strategy_valid" = false ]; then
+        echo "❌ Error: Invalid strategy '$strategy'"
+        echo "Valid module strategies: full, single"
+        echo "Valid project strategies: project-readme, project-architecture, http-api"
+        return 1
+    fi
+
+    if [ ! -d "$source_path" ]; then
+        echo "❌ Error: Source directory '$source_path' does not exist"
+        return 1
+    fi
+
+    # Set default models if not specified
+    if [ -z "$model" ]; then
+        case "$tool" in
+            gemini)
+                model="gemini-2.5-flash"
+                ;;
+            qwen)
+                model="coder-model"
+                ;;
+            codex)
+                model="gpt5-codex"
+                ;;
+            *)
+                model=""
+                ;;
+        esac
+    fi
+
+    # Build exclusion filters
+    local exclusion_filters=$(build_exclusion_filters)
+
+    # Get project root
+    local project_root=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+
+    # Determine if this is a project-level strategy
+    local is_project_level=false
+    if [[ "$strategy" =~ ^project- ]] || [ "$strategy" = "http-api" ]; then
+        is_project_level=true
+    fi
+
+    # Calculate output path
+    local output_path
+    if [ "$is_project_level" = true ]; then
+        # Project-level docs go to project root
+        if [ "$strategy" = "http-api" ]; then
+            output_path="$project_root/.workflow/docs/$project_name/api"
+        else
+            output_path="$project_root/.workflow/docs/$project_name"
+        fi
+    else
+        output_path=$(calculate_output_path "$source_path" "$project_name" "$project_root")
+    fi
+
+    # Create output directory
+    mkdir -p "$output_path"
+
+    # Detect folder type (only for module-level strategies)
+    local folder_type=""
+    if [ "$is_project_level" = false ]; then
+        folder_type=$(detect_folder_type "$source_path" "$exclusion_filters")
+    fi
+
+    # Load templates based on strategy
+    local api_template=""
+    local readme_template=""
+    local template_content=""
+
+    if [ "$is_project_level" = true ]; then
+        # Project-level templates
+        case "$strategy" in
+            project-readme)
+                local proj_readme_path="$HOME/.claude/workflows/cli-templates/prompts/documentation/project-readme.txt"
+                if [ -f "$proj_readme_path" ]; then
+                    template_content=$(cat "$proj_readme_path")
+                    echo "   📋 Loaded Project README template: $(wc -l < "$proj_readme_path") lines"
+                fi
+                ;;
+            project-architecture)
+                local arch_path="$HOME/.claude/workflows/cli-templates/prompts/documentation/project-architecture.txt"
+                local examples_path="$HOME/.claude/workflows/cli-templates/prompts/documentation/project-examples.txt"
+                if [ -f "$arch_path" ]; then
+                    template_content=$(cat "$arch_path")
+                    echo "   📋 Loaded Architecture template: $(wc -l < "$arch_path") lines"
+                fi
+                if [ -f "$examples_path" ]; then
+                    template_content="$template_content
+
+EXAMPLES TEMPLATE:
+$(cat "$examples_path")"
+                    echo "   📋 Loaded Examples template: $(wc -l < "$examples_path") lines"
+                fi
+                ;;
+            http-api)
+                local api_path="$HOME/.claude/workflows/cli-templates/prompts/documentation/api.txt"
+                if [ -f "$api_path" ]; then
+                    template_content=$(cat "$api_path")
+                    echo "   📋 Loaded HTTP API template: $(wc -l < "$api_path") lines"
+                fi
+                ;;
+        esac
+    else
+        # Module-level templates
+        local api_template_path="$HOME/.claude/workflows/cli-templates/prompts/documentation/api.txt"
+        local readme_template_path="$HOME/.claude/workflows/cli-templates/prompts/documentation/module-readme.txt"
+        local nav_template_path="$HOME/.claude/workflows/cli-templates/prompts/documentation/folder-navigation.txt"
+
+        if [ "$folder_type" = "code" ]; then
+            if [ -f "$api_template_path" ]; then
+                api_template=$(cat "$api_template_path")
+                echo "   📋 Loaded API template: $(wc -l < "$api_template_path") lines"
+            fi
+            if [ -f "$readme_template_path" ]; then
+                readme_template=$(cat "$readme_template_path")
+                echo "   📋 Loaded README template: $(wc -l < "$readme_template_path") lines"
+            fi
+        else
+            # Navigation folder uses navigation template
+            if [ -f "$nav_template_path" ]; then
+                readme_template=$(cat "$nav_template_path")
+                echo "   📋 Loaded Navigation template: $(wc -l < "$nav_template_path") lines"
+            fi
+        fi
+    fi
+
+    # Scan directory structure (only for module-level strategies)
+    local structure_info=""
+    if [ "$is_project_level" = false ]; then
+        echo "   🔍 Scanning directory structure..."
+        structure_info=$(scan_directory_structure "$source_path" "$strategy")
+    fi
+
+    # Prepare logging info
+    local module_name=$(basename "$source_path")
+
+    echo "⚡ Generating docs: $source_path → $output_path"
+    echo "   Strategy: $strategy | Tool: $tool | Model: $model | Type: $folder_type"
+    echo "   Output: $output_path"
+
+    # Build strategy-specific prompt
+    local final_prompt=""
+
+    # Project-level strategies
+    if [ "$strategy" = "project-readme" ]; then
+        final_prompt="PURPOSE: Generate comprehensive project overview documentation
+
+PROJECT: $project_name
+OUTPUT: Current directory (file will be moved to final location)
+
+Read: @.workflow/docs/$project_name/**/*.md
+
+Context: All module documentation files from the project
+
+Generate ONE documentation file in current directory:
+- README.md - Project root documentation
+
+Template:
+$template_content
+
+Instructions:
+- Create README.md in CURRENT DIRECTORY
+- Synthesize information from all module docs
+- Include project overview, getting started, and navigation
+- Create clear module navigation with links
+- Follow template structure exactly"
+
+    elif [ "$strategy" = "project-architecture" ]; then
+        final_prompt="PURPOSE: Generate system design and usage examples documentation
+
+PROJECT: $project_name
+OUTPUT: Current directory (files will be moved to final location)
+
+Read: @.workflow/docs/$project_name/**/*.md
+
+Context: All project documentation including module docs and project README
+
+Generate TWO documentation files in current directory:
+1. ARCHITECTURE.md - System architecture and design patterns
+2. EXAMPLES.md - End-to-end usage examples
+
+Template:
+$template_content
+
+Instructions:
+- Create both ARCHITECTURE.md and EXAMPLES.md in CURRENT DIRECTORY
+- Synthesize architectural patterns from module documentation
+- Document system structure, module relationships, and design decisions
+- Provide practical code examples and usage scenarios
+- Follow template structure for both files"
+
+    elif [ "$strategy" = "http-api" ]; then
+        final_prompt="PURPOSE: Generate HTTP API reference documentation
+
+PROJECT: $project_name
+OUTPUT: Current directory (file will be moved to final location)
+
+Read: @**/*.{ts,js,py,go,rs} @.workflow/docs/$project_name/**/*.md
+
+Context: API route files and existing documentation
+
+Generate ONE documentation file in current directory:
+- README.md - HTTP API documentation (in api/ subdirectory)
+
+Template:
+$template_content
+
+Instructions:
+- Create README.md in CURRENT DIRECTORY
+- Document all HTTP endpoints (routes, methods, parameters, responses)
+- Include authentication requirements and error codes
+- Provide request/response examples
+- Follow template structure (Part B: HTTP API documentation)"
+
+    # Module-level strategies
+    elif [ "$strategy" = "full" ]; then
+        # Full strategy: read all files, generate for each directory
+        if [ "$folder_type" = "code" ]; then
+            final_prompt="PURPOSE: Generate comprehensive API and module documentation
+
+Directory Structure Analysis:
+$structure_info
+
+SOURCE: $source_path
+OUTPUT: Current directory (files will be moved to final location)
+
+Read: @**/*
+
+Generate TWO documentation files in current directory:
+1. API.md - Code API documentation (functions, classes, interfaces)
+   Template:
+$api_template
+
+2. README.md - Module overview documentation
+   Template:
+$readme_template
+
+Instructions:
+- Generate both API.md and README.md in CURRENT DIRECTORY
+- If subdirectories contain code files, generate their docs too (recursive)
+- Work bottom-up: deepest directories first
+- Follow template structure exactly
+- Use structure analysis for context"
+        else
+            # Navigation folder - README only
+            final_prompt="PURPOSE: Generate navigation documentation for folder structure
+
+Directory Structure Analysis:
+$structure_info
+
+SOURCE: $source_path
+OUTPUT: Current directory (file will be moved to final location)
+
+Read: @**/*
+
+Generate ONE documentation file in current directory:
+- README.md - Navigation and folder overview
+
+Template:
+$readme_template
+
+Instructions:
+- Create README.md in CURRENT DIRECTORY
+- Focus on folder structure and navigation
+- Link to subdirectory documentation
+- Use structure analysis for context"
+        fi
+    else
+        # Single strategy: read current + child docs only
+        if [ "$folder_type" = "code" ]; then
+            final_prompt="PURPOSE: Generate API and module documentation for current directory
+
+Directory Structure Analysis:
+$structure_info
+
+SOURCE: $source_path
+OUTPUT: Current directory (files will be moved to final location)
+
+Read: @*/API.md @*/README.md @*.ts @*.tsx @*.js @*.jsx @*.py @*.sh @*.go @*.rs @*.md @*.json @*.yaml @*.yml
+
+Generate TWO documentation files in current directory:
+1. API.md - Code API documentation
+   Template:
+$api_template
+
+2. README.md - Module overview
+   Template:
+$readme_template
+
+Instructions:
+- Generate both API.md and README.md in CURRENT DIRECTORY
+- Reference child documentation, do not duplicate
+- Follow template structure
+- Use structure analysis for current directory context"
+        else
+            # Navigation folder - README only
+            final_prompt="PURPOSE: Generate navigation documentation
+
+Directory Structure Analysis:
+$structure_info
+
+SOURCE: $source_path
+OUTPUT: Current directory (file will be moved to final location)
+
+Read: @*/API.md @*/README.md @*.md
+
+Generate ONE documentation file in current directory:
+- README.md - Navigation and overview
+
+Template:
+$readme_template
+
+Instructions:
+- Create README.md in CURRENT DIRECTORY
+- Link to child documentation
+- Use structure analysis for navigation context"
+        fi
+    fi
+
+    # Execute documentation generation
+    local start_time=$(date +%s)
+    echo "   🔄 Starting documentation generation..."
+
+    if cd "$source_path" 2>/dev/null; then
+        local tool_result=0
+
+        # Store current output path for CLI context
+        export DOC_OUTPUT_PATH="$output_path"
+
+        # Record git HEAD before CLI execution (to detect unwanted auto-commits)
+        local git_head_before=""
+        if git rev-parse --git-dir >/dev/null 2>&1; then
+            git_head_before=$(git rev-parse HEAD 2>/dev/null)
+        fi
+
+        # Execute with selected tool
+        case "$tool" in
+            qwen)
+                if [ "$model" = "coder-model" ]; then
+                    qwen -p "$final_prompt" --yolo 2>&1
+                else
+                    qwen -p "$final_prompt" -m "$model" --yolo 2>&1
+                fi
+                tool_result=$?
+                ;;
+            codex)
+                codex --full-auto exec "$final_prompt" -m "$model" --skip-git-repo-check -s danger-full-access 2>&1
+                tool_result=$?
+                ;;
+            gemini)
+                gemini -p "$final_prompt" -m "$model" --yolo 2>&1
+                tool_result=$?
+                ;;
+            *)
+                echo "   ⚠️  Unknown tool: $tool, defaulting to gemini"
+                gemini -p "$final_prompt" -m "$model" --yolo 2>&1
+                tool_result=$?
+                ;;
+        esac
+
+        # Move generated files to output directory
+        local docs_created=0
+        local moved_files=""
+
+        if [ $tool_result -eq 0 ]; then
+            if [ "$is_project_level" = true ]; then
+                # Project-level documentation files
+                case "$strategy" in
+                    project-readme)
+                        if [ -f "README.md" ]; then
+                            mv "README.md" "$output_path/README.md" 2>/dev/null && {
+                                docs_created=$((docs_created + 1))
+                                moved_files+="README.md "
+                            }
+                        fi
+                        ;;
+                    project-architecture)
+                        if [ -f "ARCHITECTURE.md" ]; then
+                            mv "ARCHITECTURE.md" "$output_path/ARCHITECTURE.md" 2>/dev/null && {
+                                docs_created=$((docs_created + 1))
+                                moved_files+="ARCHITECTURE.md "
+                            }
+                        fi
+                        if [ -f "EXAMPLES.md" ]; then
+                            mv "EXAMPLES.md" "$output_path/EXAMPLES.md" 2>/dev/null && {
+                                docs_created=$((docs_created + 1))
+                                moved_files+="EXAMPLES.md "
+                            }
+                        fi
+                        ;;
+                    http-api)
+                        if [ -f "README.md" ]; then
+                            mv "README.md" "$output_path/README.md" 2>/dev/null && {
+                                docs_created=$((docs_created + 1))
+                                moved_files+="api/README.md "
+                            }
+                        fi
+                        ;;
+                esac
+            else
+                # Module-level documentation files
+                # Check and move API.md if it exists
+                if [ "$folder_type" = "code" ] && [ -f "API.md" ]; then
+                    mv "API.md" "$output_path/API.md" 2>/dev/null && {
+                        docs_created=$((docs_created + 1))
+                        moved_files+="API.md "
+                    }
+                fi
+
+                # Check and move README.md if it exists
+                if [ -f "README.md" ]; then
+                    mv "README.md" "$output_path/README.md" 2>/dev/null && {
+                        docs_created=$((docs_created + 1))
+                        moved_files+="README.md "
+                    }
+                fi
+            fi
+        fi
+
+        # Check if CLI tool auto-committed (and revert if needed)
+        if [ -n "$git_head_before" ]; then
+            local git_head_after=$(git rev-parse HEAD 2>/dev/null)
+            if [ "$git_head_before" != "$git_head_after" ]; then
+                echo "   ⚠️  Detected unwanted auto-commit by CLI tool, reverting..."
+                git reset --soft "$git_head_before" 2>/dev/null
+                echo "   ✅ Auto-commit reverted (files remain staged)"
+            fi
+        fi
+
+        if [ $docs_created -gt 0 ]; then
+            local end_time=$(date +%s)
+            local duration=$((end_time - start_time))
+            echo "   ✅ Generated $docs_created doc(s) in ${duration}s: $moved_files"
+            cd - > /dev/null
+            return 0
+        else
+            echo "   ❌ Documentation generation failed for $source_path"
+            cd - > /dev/null
+            return 1
+        fi
+    else
+        echo "   ❌ Cannot access directory: $source_path"
+        return 1
+    fi
+}
+
+# Execute function if script is run directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    # Show help if no arguments or help requested
+    if [ $# -eq 0 ] || [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
+        echo "Usage: generate_module_docs.sh <strategy> <source_path> <project_name> [tool] [model]"
+        echo ""
+        echo "Module-Level Strategies:"
+        echo "  full                   - Generate docs for all subdirectories with code"
+        echo "  single                 - Generate docs only for current directory"
+        echo ""
+        echo "Project-Level Strategies:"
+        echo "  project-readme         - Generate project root README.md"
+        echo "  project-architecture   - Generate ARCHITECTURE.md + EXAMPLES.md"
+        echo "  http-api               - Generate HTTP API documentation (api/README.md)"
+        echo ""
+        echo "Tools: gemini (default), qwen, codex"
+        echo "Models: Use tool defaults if not specified"
+        echo ""
+        echo "Module Examples:"
+        echo "  ./generate_module_docs.sh full ./src/auth myproject"
+        echo "  ./generate_module_docs.sh single ./components myproject gemini"
+        echo ""
+        echo "Project Examples:"
+        echo "  ./generate_module_docs.sh project-readme . myproject"
+        echo "  ./generate_module_docs.sh project-architecture . myproject qwen"
+        echo "  ./generate_module_docs.sh http-api . myproject"
+        exit 0
+    fi
+
+    generate_module_docs "$@"
+fi

.claude/scripts/get_modules_by_depth.sh

@@ -0,0 +1,166 @@
+#!/bin/bash
+# Get modules organized by directory depth (deepest first)
+# Usage: get_modules_by_depth.sh [format]
+#   format: list|grouped|json (default: list)
+
+# Parse .gitignore patterns and build exclusion filters
+build_exclusion_filters() {
+    local filters=""
+    
+    # Always exclude these system/cache directories and common web dev packages
+    local system_excludes=(
+        # Version control and IDE
+        ".git" ".gitignore" ".gitmodules" ".gitattributes"
+        ".svn" ".hg" ".bzr"
+        ".history" ".vscode" ".idea" ".vs" ".vscode-test"
+        ".sublime-text" ".atom"
+
+        # Python
+        "__pycache__" ".pytest_cache" ".mypy_cache" ".tox"
+        ".coverage" "htmlcov" ".nox" ".venv" "venv" "env"
+        ".egg-info" "*.egg-info" ".eggs" ".wheel"
+        "site-packages" ".python-version" ".pyc"
+
+        # Node.js/JavaScript
+        "node_modules" ".npm" ".yarn" ".pnpm" "yarn-error.log"
+        ".nyc_output" "coverage" ".next" ".nuxt"
+        ".cache" ".parcel-cache" ".vite" "dist" "build"
+        ".turbo" ".vercel" ".netlify"
+
+        # Package managers
+        ".pnpm-store" "pnpm-lock.yaml" "yarn.lock" "package-lock.json"
+        ".bundle" "vendor/bundle" "Gemfile.lock"
+        ".gradle" "gradle" "gradlew" "gradlew.bat"
+        ".mvn" "target" ".m2"
+
+        # Build/compile outputs
+        "dist" "build" "out" "output" "_site" "public"
+        ".output" ".generated" "generated" "gen"
+        "bin" "obj" "Debug" "Release"
+
+        # Testing
+        ".pytest_cache" ".coverage" "htmlcov" "test-results"
+        ".nyc_output" "junit.xml" "test_results"
+        "cypress/screenshots" "cypress/videos"
+        "playwright-report" ".playwright"
+
+        # Logs and temp files
+        "logs" "*.log" "log" "tmp" "temp" ".tmp" ".temp"
+        ".env" ".env.local" ".env.*.local"
+        ".DS_Store" "Thumbs.db" "*.tmp" "*.swp" "*.swo"
+
+        # Documentation build outputs
+        "_book" "_site" "docs/_build" "site" "gh-pages"
+        ".docusaurus" ".vuepress" ".gitbook"
+
+        # Database files
+        "*.sqlite" "*.sqlite3" "*.db" "data.db"
+
+        # OS and editor files
+        ".DS_Store" "Thumbs.db" "desktop.ini"
+        "*.stackdump" "*.core"
+
+        # Cloud and deployment
+        ".serverless" ".terraform" "terraform.tfstate"
+        ".aws" ".azure" ".gcp"
+
+        # Mobile development
+        ".gradle" "build" ".expo" ".metro"
+        "android/app/build" "ios/build" "DerivedData"
+
+        # Game development
+        "Library" "Temp" "ProjectSettings"
+        "Logs" "MemoryCaptures" "UserSettings"
+    )
+    
+    for exclude in "${system_excludes[@]}"; do
+        filters+=" -not -path '*/$exclude' -not -path '*/$exclude/*'"
+    done
+    
+    # Parse .gitignore if it exists
+    if [ -f ".gitignore" ]; then
+        while IFS= read -r line; do
+            # Skip empty lines and comments
+            [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
+            
+            # Remove trailing slash and whitespace
+            line=$(echo "$line" | sed 's|/$||' | xargs)
+            
+            # Add to filters
+            filters+=" -not -path '*/$line' -not -path '*/$line/*'"
+        done < .gitignore
+    fi
+    
+    echo "$filters"
+}
+
+get_modules_by_depth() {
+    local format="${1:-list}"
+    local exclusion_filters=$(build_exclusion_filters)
+    local max_depth=$(eval "find . -type d $exclusion_filters 2>/dev/null" | awk -F/ '{print NF-1}' | sort -n | tail -1)
+    
+    case "$format" in
+        "grouped")
+            echo "📊 Modules by depth (deepest first):"
+            for depth in $(seq $max_depth -1 0); do
+                local dirs=$(eval "find . -mindepth $depth -maxdepth $depth -type d $exclusion_filters 2>/dev/null" | \
+                           while read dir; do
+                               if [ $(find "$dir" -maxdepth 1 -type f 2>/dev/null | wc -l) -gt 0 ]; then
+                                   local claude_indicator=""
+                                   [ -f "$dir/CLAUDE.md" ] && claude_indicator=" [✓]"
+                                   echo "$dir$claude_indicator"
+                               fi
+                           done)
+                if [ -n "$dirs" ]; then
+                    echo "  📁 Depth $depth:"
+                    echo "$dirs" | sed 's/^/    - /'
+                fi
+            done
+            ;;
+            
+        "json")
+            echo "{"
+            echo "  \"max_depth\": $max_depth,"
+            echo "  \"modules\": {"
+            for depth in $(seq $max_depth -1 0); do
+                local dirs=$(eval "find . -mindepth $depth -maxdepth $depth -type d $exclusion_filters 2>/dev/null" | \
+                           while read dir; do
+                               if [ $(find "$dir" -maxdepth 1 -type f 2>/dev/null | wc -l) -gt 0 ]; then
+                                   local has_claude="false"
+                                   [ -f "$dir/CLAUDE.md" ] && has_claude="true"
+                                   echo "{\"path\":\"$dir\",\"has_claude\":$has_claude}"
+                               fi
+                           done | tr '\n' ',')
+                if [ -n "$dirs" ]; then
+                    dirs=${dirs%,}  # Remove trailing comma
+                    echo "    \"$depth\": [$dirs]"
+                    [ $depth -gt 0 ] && echo ","
+                fi
+            done
+            echo "  }"
+            echo "}"
+            ;;
+            
+        "list"|*)
+            # Simple list format (deepest first)
+            for depth in $(seq $max_depth -1 0); do
+                eval "find . -mindepth $depth -maxdepth $depth -type d $exclusion_filters 2>/dev/null" | \
+                while read dir; do
+                    if [ $(find "$dir" -maxdepth 1 -type f 2>/dev/null | wc -l) -gt 0 ]; then
+                        local file_count=$(find "$dir" -maxdepth 1 -type f 2>/dev/null | wc -l)
+                        local types=$(find "$dir" -maxdepth 1 -type f -name "*.*" 2>/dev/null | \
+                                    grep -E '\.[^/]*$' | sed 's/.*\.//' | sort -u | tr '\n' ',' | sed 's/,$//')
+                        local has_claude="no"
+                        [ -f "$dir/CLAUDE.md" ] && has_claude="yes"
+                        echo "depth:$depth|path:$dir|files:$file_count|types:[$types]|has_claude:$has_claude"
+                    fi
+                done
+            done
+            ;;
+    esac
+}
+
+# Execute function if script is run directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    get_modules_by_depth "$@"
+fi

.claude/scripts/ui-generate-preview.sh

@@ -0,0 +1,391 @@
+#!/bin/bash
+#
+# UI Generate Preview v2.0 - Template-Based Preview Generation
+# Purpose: Generate compare.html and index.html using template substitution
+# Template: ~/.claude/workflows/_template-compare-matrix.html
+#
+# Usage: ui-generate-preview.sh <prototypes_dir> [--template <path>]
+#
+
+set -e
+
+# Color output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Default template path
+TEMPLATE_PATH="$HOME/.claude/workflows/_template-compare-matrix.html"
+
+# Parse arguments
+prototypes_dir="${1:-.}"
+shift || true
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --template)
+            TEMPLATE_PATH="$2"
+            shift 2
+            ;;
+        *)
+            echo -e "${RED}Unknown option: $1${NC}"
+            exit 1
+            ;;
+    esac
+done
+
+if [[ ! -d "$prototypes_dir" ]]; then
+    echo -e "${RED}Error: Directory not found: $prototypes_dir${NC}"
+    exit 1
+fi
+
+cd "$prototypes_dir" || exit 1
+
+echo -e "${GREEN}📊 Auto-detecting matrix dimensions...${NC}"
+
+# Auto-detect styles, layouts, targets from file patterns
+# Pattern: {target}-style-{s}-layout-{l}.html
+styles=$(find . -maxdepth 1 -name "*-style-*-layout-*.html" | \
+         sed 's/.*-style-\([0-9]\+\)-.*/\1/' | sort -un)
+layouts=$(find . -maxdepth 1 -name "*-style-*-layout-*.html" | \
+          sed 's/.*-layout-\([0-9]\+\)\.html/\1/' | sort -un)
+targets=$(find . -maxdepth 1 -name "*-style-*-layout-*.html" | \
+          sed 's/\.\///; s/-style-.*//' | sort -u)
+
+S=$(echo "$styles" | wc -l)
+L=$(echo "$layouts" | wc -l)
+T=$(echo "$targets" | wc -l)
+
+echo -e "   Detected: ${GREEN}${S}${NC} styles × ${GREEN}${L}${NC} layouts × ${GREEN}${T}${NC} targets"
+
+if [[ $S -eq 0 ]] || [[ $L -eq 0 ]] || [[ $T -eq 0 ]]; then
+    echo -e "${RED}Error: No prototype files found matching pattern {target}-style-{s}-layout-{l}.html${NC}"
+    exit 1
+fi
+
+# ============================================================================
+# Generate compare.html from template
+# ============================================================================
+
+echo -e "${YELLOW}🎨 Generating compare.html from template...${NC}"
+
+if [[ ! -f "$TEMPLATE_PATH" ]]; then
+    echo -e "${RED}Error: Template not found: $TEMPLATE_PATH${NC}"
+    exit 1
+fi
+
+# Build pages/targets JSON array
+PAGES_JSON="["
+first=true
+for target in $targets; do
+    if [[ "$first" == true ]]; then
+        first=false
+    else
+        PAGES_JSON+=", "
+    fi
+    PAGES_JSON+="\"$target\""
+done
+PAGES_JSON+="]"
+
+# Generate metadata
+RUN_ID="run-$(date +%Y%m%d-%H%M%S)"
+SESSION_ID="standalone"
+TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u +"%Y-%m-%d")
+
+# Replace placeholders in template
+cat "$TEMPLATE_PATH" | \
+    sed "s|{{run_id}}|${RUN_ID}|g" | \
+    sed "s|{{session_id}}|${SESSION_ID}|g" | \
+    sed "s|{{timestamp}}|${TIMESTAMP}|g" | \
+    sed "s|{{style_variants}}|${S}|g" | \
+    sed "s|{{layout_variants}}|${L}|g" | \
+    sed "s|{{pages_json}}|${PAGES_JSON}|g" \
+    > compare.html
+
+echo -e "${GREEN}   ✓ Generated compare.html from template${NC}"
+
+# ============================================================================
+# Generate index.html
+# ============================================================================
+
+echo -e "${YELLOW}📋 Generating index.html...${NC}"
+
+cat > index.html << 'EOF'
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>UI Prototypes Index</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 40px 20px;
+            background: #f5f5f5;
+        }
+        h1 { margin-bottom: 10px; color: #333; }
+        .subtitle { color: #666; margin-bottom: 30px; }
+        .cta {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 8px;
+            margin-bottom: 30px;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        }
+        .cta h2 { margin-bottom: 10px; }
+        .cta a {
+            display: inline-block;
+            background: white;
+            color: #667eea;
+            padding: 10px 20px;
+            border-radius: 6px;
+            text-decoration: none;
+            font-weight: 600;
+            margin-top: 10px;
+        }
+        .cta a:hover { background: #f8f9fa; }
+        .style-section {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .style-section h2 {
+            color: #495057;
+            margin-bottom: 15px;
+            padding-bottom: 10px;
+            border-bottom: 2px solid #e9ecef;
+        }
+        .target-group {
+            margin-bottom: 20px;
+        }
+        .target-group h3 {
+            color: #6c757d;
+            font-size: 16px;
+            margin-bottom: 10px;
+        }
+        .link-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+            gap: 10px;
+        }
+        .prototype-link {
+            padding: 12px 16px;
+            background: #f8f9fa;
+            border: 1px solid #dee2e6;
+            border-radius: 6px;
+            text-decoration: none;
+            color: #495057;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            transition: all 0.2s;
+        }
+        .prototype-link:hover {
+            background: #e9ecef;
+            border-color: #667eea;
+            transform: translateX(2px);
+        }
+        .prototype-link .label { font-weight: 500; }
+        .prototype-link .icon { color: #667eea; }
+    </style>
+</head>
+<body>
+    <h1>🎨 UI Prototypes Index</h1>
+    <p class="subtitle">Generated __S__×__L__×__T__ = __TOTAL__ prototypes</p>
+
+    <div class="cta">
+        <h2>📊 Interactive Comparison</h2>
+        <p>View all styles and layouts side-by-side in an interactive matrix</p>
+        <a href="compare.html">Open Matrix View →</a>
+    </div>
+
+    <h2>📂 All Prototypes</h2>
+__CONTENT__
+</body>
+</html>
+EOF
+
+# Build content HTML
+CONTENT=""
+for style in $styles; do
+    CONTENT+="<div class='style-section'>"$'\n'
+    CONTENT+="<h2>Style ${style}</h2>"$'\n'
+
+    for target in $targets; do
+        target_capitalized="$(echo ${target:0:1} | tr '[:lower:]' '[:upper:]')${target:1}"
+        CONTENT+="<div class='target-group'>"$'\n'
+        CONTENT+="<h3>${target_capitalized}</h3>"$'\n'
+        CONTENT+="<div class='link-grid'>"$'\n'
+
+        for layout in $layouts; do
+            html_file="${target}-style-${style}-layout-${layout}.html"
+            if [[ -f "$html_file" ]]; then
+                CONTENT+="<a href='${html_file}' class='prototype-link' target='_blank'>"$'\n'
+                CONTENT+="<span class='label'>Layout ${layout}</span>"$'\n'
+                CONTENT+="<span class='icon'>↗</span>"$'\n'
+                CONTENT+="</a>"$'\n'
+            fi
+        done
+
+        CONTENT+="</div></div>"$'\n'
+    done
+
+    CONTENT+="</div>"$'\n'
+done
+
+# Calculate total
+TOTAL_PROTOTYPES=$((S * L * T))
+
+# Replace placeholders (using a temp file for complex replacement)
+{
+    echo "$CONTENT" > /tmp/content_tmp.txt
+    sed "s|__S__|${S}|g" index.html | \
+        sed "s|__L__|${L}|g" | \
+        sed "s|__T__|${T}|g" | \
+        sed "s|__TOTAL__|${TOTAL_PROTOTYPES}|g" | \
+        sed -e "/__CONTENT__/r /tmp/content_tmp.txt" -e "/__CONTENT__/d" > /tmp/index_tmp.html
+    mv /tmp/index_tmp.html index.html
+    rm -f /tmp/content_tmp.txt
+}
+
+echo -e "${GREEN}   ✓ Generated index.html${NC}"
+
+# ============================================================================
+# Generate PREVIEW.md
+# ============================================================================
+
+echo -e "${YELLOW}📝 Generating PREVIEW.md...${NC}"
+
+cat > PREVIEW.md << EOF
+# UI Prototypes Preview Guide
+
+Generated: $(date +"%Y-%m-%d %H:%M:%S")
+
+## 📊 Matrix Dimensions
+
+- **Styles**: ${S}
+- **Layouts**: ${L}
+- **Targets**: ${T}
+- **Total Prototypes**: $((S*L*T))
+
+## 🌐 How to View
+
+### Option 1: Interactive Matrix (Recommended)
+
+Open \`compare.html\` in your browser to see all prototypes in an interactive matrix view.
+
+**Features**:
+- Side-by-side comparison of all styles and layouts
+- Switch between targets using the dropdown
+- Adjust grid columns for better viewing
+- Direct links to full-page views
+- Selection system with export to JSON
+- Fullscreen mode for detailed inspection
+
+### Option 2: Simple Index
+
+Open \`index.html\` for a simple list of all prototypes with direct links.
+
+### Option 3: Direct File Access
+
+Each prototype can be opened directly:
+- Pattern: \`{target}-style-{s}-layout-{l}.html\`
+- Example: \`dashboard-style-1-layout-1.html\`
+
+## 📁 File Structure
+
+\`\`\`
+prototypes/
+├── compare.html           # Interactive matrix view
+├── index.html             # Simple navigation index
+├── PREVIEW.md             # This file
+EOF
+
+for style in $styles; do
+    for target in $targets; do
+        for layout in $layouts; do
+            echo "├── ${target}-style-${style}-layout-${layout}.html" >> PREVIEW.md
+            echo "├── ${target}-style-${style}-layout-${layout}.css" >> PREVIEW.md
+        done
+    done
+done
+
+cat >> PREVIEW.md << 'EOF2'
+```
+
+## 🎨 Style Variants
+
+EOF2
+
+for style in $styles; do
+    cat >> PREVIEW.md << EOF3
+### Style ${style}
+
+EOF3
+    style_guide="../style-extraction/style-${style}/style-guide.md"
+    if [[ -f "$style_guide" ]]; then
+        head -n 10 "$style_guide" | tail -n +2 >> PREVIEW.md 2>/dev/null || echo "Design philosophy and tokens" >> PREVIEW.md
+    else
+        echo "Design system ${style}" >> PREVIEW.md
+    fi
+    echo "" >> PREVIEW.md
+done
+
+cat >> PREVIEW.md << 'EOF4'
+
+## 🎯 Targets
+
+EOF4
+
+for target in $targets; do
+    target_capitalized="$(echo ${target:0:1} | tr '[:lower:]' '[:upper:]')${target:1}"
+    echo "- **${target_capitalized}**: ${L} layouts × ${S} styles = $((L*S)) variations" >> PREVIEW.md
+done
+
+cat >> PREVIEW.md << 'EOF5'
+
+## 💡 Tips
+
+1. **Comparison**: Use compare.html to see how different styles affect the same layout
+2. **Navigation**: Use index.html for quick access to specific prototypes
+3. **Selection**: Mark favorites in compare.html using star icons
+4. **Export**: Download selection JSON for implementation planning
+5. **Inspection**: Open browser DevTools to inspect HTML structure and CSS
+6. **Sharing**: All files are standalone - can be shared or deployed directly
+
+## 📝 Next Steps
+
+1. Review prototypes in compare.html
+2. Select preferred style × layout combinations
+3. Export selections as JSON
+4. Provide feedback for refinement
+5. Use selected designs for implementation
+
+---
+
+Generated by /workflow:ui-design:generate-v2 (Style-Centric Architecture)
+EOF5
+
+echo -e "${GREEN}   ✓ Generated PREVIEW.md${NC}"
+
+# ============================================================================
+# Completion Summary
+# ============================================================================
+
+echo ""
+echo -e "${GREEN}✅ Preview generation complete!${NC}"
+echo -e "   Files created: compare.html, index.html, PREVIEW.md"
+echo -e "   Matrix: ${S} styles × ${L} layouts × ${T} targets = $((S*L*T)) prototypes"
+echo ""
+echo -e "${YELLOW}🌐 Next Steps:${NC}"
+echo -e "   1. Open compare.html for interactive matrix view"
+echo -e "   2. Open index.html for simple navigation"
+echo -e "   3. Read PREVIEW.md for detailed usage guide"
+echo ""

.claude/scripts/ui-instantiate-prototypes.sh

@@ -0,0 +1,811 @@
+#!/bin/bash
+
+# UI Prototype Instantiation Script with Preview Generation (v3.0 - Auto-detect)
+# Purpose: Generate S × L × P final prototypes from templates + interactive preview files
+# Usage:
+#   Simple: ui-instantiate-prototypes.sh <prototypes_dir>
+#   Full:   ui-instantiate-prototypes.sh <base_path> <pages> <style_variants> <layout_variants> [options]
+
+# Use safer error handling
+set -o pipefail
+
+# ============================================================================
+# Helper Functions
+# ============================================================================
+
+log_info() {
+    echo "$1"
+}
+
+log_success() {
+    echo "✅ $1"
+}
+
+log_error() {
+    echo "❌ $1"
+}
+
+log_warning() {
+    echo "⚠️  $1"
+}
+
+# Auto-detect pages from templates directory
+auto_detect_pages() {
+    local templates_dir="$1/_templates"
+
+    if [ ! -d "$templates_dir" ]; then
+        log_error "Templates directory not found: $templates_dir"
+        return 1
+    fi
+
+    # Find unique page names from template files (e.g., login-layout-1.html -> login)
+    local pages=$(find "$templates_dir" -name "*-layout-*.html" -type f | \
+                  sed 's|.*/||' | \
+                  sed 's|-layout-[0-9]*\.html||' | \
+                  sort -u | \
+                  tr '\n' ',' | \
+                  sed 's/,$//')
+
+    echo "$pages"
+}
+
+# Auto-detect style variants count
+auto_detect_style_variants() {
+    local base_path="$1"
+    local style_dir="$base_path/../style-extraction"
+
+    if [ ! -d "$style_dir" ]; then
+        log_warning "Style consolidation directory not found: $style_dir"
+        echo "3"  # Default
+        return
+    fi
+
+    # Count style-* directories
+    local count=$(find "$style_dir" -maxdepth 1 -type d -name "style-*" | wc -l)
+
+    if [ "$count" -eq 0 ]; then
+        echo "3"  # Default
+    else
+        echo "$count"
+    fi
+}
+
+# Auto-detect layout variants count
+auto_detect_layout_variants() {
+    local templates_dir="$1/_templates"
+
+    if [ ! -d "$templates_dir" ]; then
+        echo "3"  # Default
+        return
+    fi
+
+    # Find the first page and count its layouts
+    local first_page=$(find "$templates_dir" -name "*-layout-1.html" -type f | head -1 | sed 's|.*/||' | sed 's|-layout-1\.html||')
+
+    if [ -z "$first_page" ]; then
+        echo "3"  # Default
+        return
+    fi
+
+    # Count layout files for this page
+    local count=$(find "$templates_dir" -name "${first_page}-layout-*.html" -type f | wc -l)
+
+    if [ "$count" -eq 0 ]; then
+        echo "3"  # Default
+    else
+        echo "$count"
+    fi
+}
+
+# ============================================================================
+# Parse Arguments
+# ============================================================================
+
+show_usage() {
+    cat <<'EOF'
+Usage:
+  Simple (auto-detect): ui-instantiate-prototypes.sh <prototypes_dir> [options]
+  Full:                 ui-instantiate-prototypes.sh <base_path> <pages> <style_variants> <layout_variants> [options]
+
+Simple Mode (Recommended):
+  prototypes_dir    Path to prototypes directory (auto-detects everything)
+
+Full Mode:
+  base_path         Base path to prototypes directory
+  pages             Comma-separated list of pages/components
+  style_variants    Number of style variants (1-5)
+  layout_variants   Number of layout variants (1-5)
+
+Options:
+  --run-id <id>         Run ID (default: auto-generated)
+  --session-id <id>     Session ID (default: standalone)
+  --mode <page|component>  Exploration mode (default: page)
+  --template <path>     Path to compare.html template (default: ~/.claude/workflows/_template-compare-matrix.html)
+  --no-preview          Skip preview file generation
+  --help                Show this help message
+
+Examples:
+  # Simple usage (auto-detect everything)
+  ui-instantiate-prototypes.sh .workflow/design-run-*/prototypes
+
+  # With options
+  ui-instantiate-prototypes.sh .workflow/design-run-*/prototypes --session-id WFS-auth
+
+  # Full manual mode
+  ui-instantiate-prototypes.sh .workflow/design-run-*/prototypes "login,dashboard" 3 3 --session-id WFS-auth
+EOF
+}
+
+# Default values
+BASE_PATH=""
+PAGES=""
+STYLE_VARIANTS=""
+LAYOUT_VARIANTS=""
+RUN_ID="run-$(date +%Y%m%d-%H%M%S)"
+SESSION_ID="standalone"
+MODE="page"
+TEMPLATE_PATH="$HOME/.claude/workflows/_template-compare-matrix.html"
+GENERATE_PREVIEW=true
+AUTO_DETECT=false
+
+# Parse arguments
+if [ $# -lt 1 ]; then
+    log_error "Missing required arguments"
+    show_usage
+    exit 1
+fi
+
+# Check if using simple mode (only 1 positional arg before options)
+if [ $# -eq 1 ] || [[ "$2" == --* ]]; then
+    # Simple mode - auto-detect
+    AUTO_DETECT=true
+    BASE_PATH="$1"
+    shift 1
+else
+    # Full mode - manual parameters
+    if [ $# -lt 4 ]; then
+        log_error "Full mode requires 4 positional arguments"
+        show_usage
+        exit 1
+    fi
+
+    BASE_PATH="$1"
+    PAGES="$2"
+    STYLE_VARIANTS="$3"
+    LAYOUT_VARIANTS="$4"
+    shift 4
+fi
+
+# Parse optional arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --run-id)
+            RUN_ID="$2"
+            shift 2
+            ;;
+        --session-id)
+            SESSION_ID="$2"
+            shift 2
+            ;;
+        --mode)
+            MODE="$2"
+            shift 2
+            ;;
+        --template)
+            TEMPLATE_PATH="$2"
+            shift 2
+            ;;
+        --no-preview)
+            GENERATE_PREVIEW=false
+            shift
+            ;;
+        --help)
+            show_usage
+            exit 0
+            ;;
+        *)
+            log_error "Unknown option: $1"
+            show_usage
+            exit 1
+            ;;
+    esac
+done
+
+# ============================================================================
+# Auto-detection (if enabled)
+# ============================================================================
+
+if [ "$AUTO_DETECT" = true ]; then
+    log_info "🔍 Auto-detecting configuration from directory..."
+
+    # Detect pages
+    PAGES=$(auto_detect_pages "$BASE_PATH")
+    if [ -z "$PAGES" ]; then
+        log_error "Could not auto-detect pages from templates"
+        exit 1
+    fi
+    log_info "   Pages: $PAGES"
+
+    # Detect style variants
+    STYLE_VARIANTS=$(auto_detect_style_variants "$BASE_PATH")
+    log_info "   Style variants: $STYLE_VARIANTS"
+
+    # Detect layout variants
+    LAYOUT_VARIANTS=$(auto_detect_layout_variants "$BASE_PATH")
+    log_info "   Layout variants: $LAYOUT_VARIANTS"
+
+    echo ""
+fi
+
+# ============================================================================
+# Validation
+# ============================================================================
+
+# Validate base path
+if [ ! -d "$BASE_PATH" ]; then
+    log_error "Base path not found: $BASE_PATH"
+    exit 1
+fi
+
+# Validate style and layout variants
+if [ "$STYLE_VARIANTS" -lt 1 ] || [ "$STYLE_VARIANTS" -gt 5 ]; then
+    log_error "Style variants must be between 1 and 5 (got: $STYLE_VARIANTS)"
+    exit 1
+fi
+
+if [ "$LAYOUT_VARIANTS" -lt 1 ] || [ "$LAYOUT_VARIANTS" -gt 5 ]; then
+    log_error "Layout variants must be between 1 and 5 (got: $LAYOUT_VARIANTS)"
+    exit 1
+fi
+
+# Validate STYLE_VARIANTS against actual style directories
+if [ "$STYLE_VARIANTS" -gt 0 ]; then
+    style_dir="$BASE_PATH/../style-extraction"
+
+    if [ ! -d "$style_dir" ]; then
+        log_error "Style consolidation directory not found: $style_dir"
+        log_info "Run /workflow:ui-design:consolidate first"
+        exit 1
+    fi
+
+    actual_styles=$(find "$style_dir" -maxdepth 1 -type d -name "style-*" 2>/dev/null | wc -l)
+
+    if [ "$actual_styles" -eq 0 ]; then
+        log_error "No style directories found in: $style_dir"
+        log_info "Run /workflow:ui-design:consolidate first to generate style design systems"
+        exit 1
+    fi
+
+    if [ "$STYLE_VARIANTS" -gt "$actual_styles" ]; then
+        log_warning "Requested $STYLE_VARIANTS style variants, but only found $actual_styles directories"
+        log_info "Available style directories:"
+        find "$style_dir" -maxdepth 1 -type d -name "style-*" 2>/dev/null | sed 's|.*/||' | sort
+        log_info "Auto-correcting to $actual_styles style variants"
+        STYLE_VARIANTS=$actual_styles
+    fi
+fi
+
+# Parse pages into array
+IFS=',' read -ra PAGE_ARRAY <<< "$PAGES"
+
+if [ ${#PAGE_ARRAY[@]} -eq 0 ]; then
+    log_error "No pages found"
+    exit 1
+fi
+
+# ============================================================================
+# Header Output
+# ============================================================================
+
+echo "========================================="
+echo "UI Prototype Instantiation & Preview"
+if [ "$AUTO_DETECT" = true ]; then
+    echo "(Auto-detected configuration)"
+fi
+echo "========================================="
+echo "Base Path: $BASE_PATH"
+echo "Mode: $MODE"
+echo "Pages/Components: $PAGES"
+echo "Style Variants: $STYLE_VARIANTS"
+echo "Layout Variants: $LAYOUT_VARIANTS"
+echo "Run ID: $RUN_ID"
+echo "Session ID: $SESSION_ID"
+echo "========================================="
+echo ""
+
+# Change to base path
+cd "$BASE_PATH" || exit 1
+
+# ============================================================================
+# Phase 1: Instantiate Prototypes
+# ============================================================================
+
+log_info "🚀 Phase 1: Instantiating prototypes from templates..."
+echo ""
+
+total_generated=0
+total_failed=0
+
+for page in "${PAGE_ARRAY[@]}"; do
+    # Trim whitespace
+    page=$(echo "$page" | xargs)
+
+    log_info "Processing page/component: $page"
+
+    for s in $(seq 1 "$STYLE_VARIANTS"); do
+        for l in $(seq 1 "$LAYOUT_VARIANTS"); do
+            # Define file paths
+            TEMPLATE_HTML="_templates/${page}-layout-${l}.html"
+            STRUCTURAL_CSS="_templates/${page}-layout-${l}.css"
+            TOKEN_CSS="../style-extraction/style-${s}/tokens.css"
+            OUTPUT_HTML="${page}-style-${s}-layout-${l}.html"
+
+            # Copy template and replace placeholders
+            if [ -f "$TEMPLATE_HTML" ]; then
+                cp "$TEMPLATE_HTML" "$OUTPUT_HTML" || {
+                    log_error "Failed to copy template: $TEMPLATE_HTML"
+                    ((total_failed++))
+                    continue
+                }
+
+                # Replace CSS placeholders (Windows-compatible sed syntax)
+                sed -i "s|{{STRUCTURAL_CSS}}|${STRUCTURAL_CSS}|g" "$OUTPUT_HTML" || true
+                sed -i "s|{{TOKEN_CSS}}|${TOKEN_CSS}|g" "$OUTPUT_HTML" || true
+
+                log_success "Created: $OUTPUT_HTML"
+                ((total_generated++))
+
+                # Create implementation notes (simplified)
+                NOTES_FILE="${page}-style-${s}-layout-${l}-notes.md"
+
+                # Generate notes with simple heredoc
+                cat > "$NOTES_FILE" <<NOTESEOF
+# Implementation Notes: ${page}-style-${s}-layout-${l}
+
+## Generation Details
+- **Template**: ${TEMPLATE_HTML}
+- **Structural CSS**: ${STRUCTURAL_CSS}
+- **Style Tokens**: ${TOKEN_CSS}
+- **Layout Strategy**: Layout ${l}
+- **Style Variant**: Style ${s}
+- **Mode**: ${MODE}
+
+## Template Reuse
+This prototype was generated from a shared layout template to ensure consistency
+across all style variants. The HTML structure is identical for all ${page}-layout-${l}
+prototypes, with only the design tokens (colors, fonts, spacing) varying.
+
+## Design System Reference
+Refer to \`../style-extraction/style-${s}/style-guide.md\` for:
+- Design philosophy
+- Token usage guidelines
+- Component patterns
+- Accessibility requirements
+
+## Customization
+To modify this prototype:
+1. Edit the layout template: \`${TEMPLATE_HTML}\` (affects all styles)
+2. Edit the structural CSS: \`${STRUCTURAL_CSS}\` (affects all styles)
+3. Edit design tokens: \`${TOKEN_CSS}\` (affects only this style variant)
+
+## Run Information
+- **Run ID**: ${RUN_ID}
+- **Session ID**: ${SESSION_ID}
+- **Generated**: $(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u +%Y-%m-%d)
+NOTESEOF
+
+            else
+                log_error "Template not found: $TEMPLATE_HTML"
+                ((total_failed++))
+            fi
+        done
+    done
+done
+
+echo ""
+log_success "Phase 1 complete: Generated ${total_generated} prototypes"
+if [ $total_failed -gt 0 ]; then
+    log_warning "Failed: ${total_failed} prototypes"
+fi
+echo ""
+
+# ============================================================================
+# Phase 2: Generate Preview Files (if enabled)
+# ============================================================================
+
+if [ "$GENERATE_PREVIEW" = false ]; then
+    log_info "⏭️  Skipping preview generation (--no-preview flag)"
+    exit 0
+fi
+
+log_info "🎨 Phase 2: Generating preview files..."
+echo ""
+
+# ============================================================================
+# 2a. Generate compare.html from template
+# ============================================================================
+
+if [ ! -f "$TEMPLATE_PATH" ]; then
+    log_warning "Template not found: $TEMPLATE_PATH"
+    log_info "   Skipping compare.html generation"
+else
+    log_info "📄 Generating compare.html from template..."
+
+    # Convert page array to JSON format
+    PAGES_JSON="["
+    for i in "${!PAGE_ARRAY[@]}"; do
+        page=$(echo "${PAGE_ARRAY[$i]}" | xargs)
+        PAGES_JSON+="\"$page\""
+        if [ $i -lt $((${#PAGE_ARRAY[@]} - 1)) ]; then
+            PAGES_JSON+=", "
+        fi
+    done
+    PAGES_JSON+="]"
+
+    TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u +%Y-%m-%d)
+
+    # Read template and replace placeholders
+    cat "$TEMPLATE_PATH" | \
+        sed "s|{{run_id}}|${RUN_ID}|g" | \
+        sed "s|{{session_id}}|${SESSION_ID}|g" | \
+        sed "s|{{timestamp}}|${TIMESTAMP}|g" | \
+        sed "s|{{style_variants}}|${STYLE_VARIANTS}|g" | \
+        sed "s|{{layout_variants}}|${LAYOUT_VARIANTS}|g" | \
+        sed "s|{{pages_json}}|${PAGES_JSON}|g" \
+        > compare.html
+
+    log_success "Generated: compare.html"
+fi
+
+# ============================================================================
+# 2b. Generate index.html
+# ============================================================================
+
+log_info "📄 Generating index.html..."
+
+# Calculate total prototypes
+TOTAL_PROTOTYPES=$((STYLE_VARIANTS * LAYOUT_VARIANTS * ${#PAGE_ARRAY[@]}))
+
+# Generate index.html with simple heredoc
+cat > index.html <<'INDEXEOF'
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>UI Prototypes - __MODE__ Mode - __RUN_ID__</title>
+  <style>
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      max-width: 900px;
+      margin: 2rem auto;
+      padding: 0 2rem;
+      background: #f9fafb;
+    }
+    .header {
+      background: white;
+      padding: 2rem;
+      border-radius: 0.75rem;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+      margin-bottom: 2rem;
+    }
+    h1 {
+      color: #2563eb;
+      margin-bottom: 0.5rem;
+      font-size: 2rem;
+    }
+    .meta {
+      color: #6b7280;
+      font-size: 0.875rem;
+      margin-top: 0.5rem;
+    }
+    .info {
+      background: #f3f4f6;
+      padding: 1.5rem;
+      border-radius: 0.5rem;
+      margin: 1.5rem 0;
+      border-left: 4px solid #2563eb;
+    }
+    .cta {
+      display: inline-block;
+      background: #2563eb;
+      color: white;
+      padding: 1rem 2rem;
+      border-radius: 0.5rem;
+      text-decoration: none;
+      font-weight: 600;
+      margin: 1rem 0;
+      transition: background 0.2s;
+    }
+    .cta:hover {
+      background: #1d4ed8;
+    }
+    .stats {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+      gap: 1rem;
+      margin: 1.5rem 0;
+    }
+    .stat {
+      background: white;
+      border: 1px solid #e5e7eb;
+      padding: 1.5rem;
+      border-radius: 0.5rem;
+      text-align: center;
+      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
+    }
+    .stat-value {
+      font-size: 2.5rem;
+      font-weight: bold;
+      color: #2563eb;
+      margin-bottom: 0.25rem;
+    }
+    .stat-label {
+      color: #6b7280;
+      font-size: 0.875rem;
+    }
+    .section {
+      background: white;
+      padding: 2rem;
+      border-radius: 0.75rem;
+      margin-bottom: 2rem;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    h2 {
+      color: #1f2937;
+      margin-bottom: 1rem;
+      font-size: 1.5rem;
+    }
+    ul {
+      line-height: 1.8;
+      color: #374151;
+    }
+    .pages-list {
+      list-style: none;
+      padding: 0;
+    }
+    .pages-list li {
+      background: #f9fafb;
+      padding: 0.75rem 1rem;
+      margin: 0.5rem 0;
+      border-radius: 0.375rem;
+      border-left: 3px solid #2563eb;
+    }
+    .badge {
+      display: inline-block;
+      background: #dbeafe;
+      color: #1e40af;
+      padding: 0.25rem 0.75rem;
+      border-radius: 0.25rem;
+      font-size: 0.75rem;
+      font-weight: 600;
+      margin-left: 0.5rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>🎨 UI Prototype __MODE__ Mode</h1>
+    <div class="meta">
+      <strong>Run ID:</strong> __RUN_ID__ |
+      <strong>Session:</strong> __SESSION_ID__ |
+      <strong>Generated:</strong> __TIMESTAMP__
+    </div>
+  </div>
+
+  <div class="info">
+    <p><strong>Matrix Configuration:</strong> __STYLE_VARIANTS__ styles × __LAYOUT_VARIANTS__ layouts × __PAGE_COUNT__ __MODE__s</p>
+    <p><strong>Total Prototypes:</strong> __TOTAL_PROTOTYPES__ interactive HTML files</p>
+  </div>
+
+  <a href="compare.html" class="cta">🔍 Open Interactive Matrix Comparison →</a>
+
+  <div class="stats">
+    <div class="stat">
+      <div class="stat-value">__STYLE_VARIANTS__</div>
+      <div class="stat-label">Style Variants</div>
+    </div>
+    <div class="stat">
+      <div class="stat-value">__LAYOUT_VARIANTS__</div>
+      <div class="stat-label">Layout Options</div>
+    </div>
+    <div class="stat">
+      <div class="stat-value">__PAGE_COUNT__</div>
+      <div class="stat-label">__MODE__s</div>
+    </div>
+    <div class="stat">
+      <div class="stat-value">__TOTAL_PROTOTYPES__</div>
+      <div class="stat-label">Total Prototypes</div>
+    </div>
+  </div>
+
+  <div class="section">
+    <h2>🌟 Features</h2>
+    <ul>
+      <li><strong>Interactive Matrix View:</strong> __STYLE_VARIANTS__×__LAYOUT_VARIANTS__ grid with synchronized scrolling</li>
+      <li><strong>Flexible Zoom:</strong> 25%, 50%, 75%, 100% viewport scaling</li>
+      <li><strong>Fullscreen Mode:</strong> Detailed view for individual prototypes</li>
+      <li><strong>Selection System:</strong> Mark favorites with export to JSON</li>
+      <li><strong>__MODE__ Switcher:</strong> Compare different __MODE__s side-by-side</li>
+      <li><strong>Persistent State:</strong> Selections saved in localStorage</li>
+    </ul>
+  </div>
+
+  <div class="section">
+    <h2>📄 Generated __MODE__s</h2>
+    <ul class="pages-list">
+__PAGES_LIST__
+    </ul>
+  </div>
+
+  <div class="section">
+    <h2>📚 Next Steps</h2>
+    <ol>
+      <li>Open <code>compare.html</code> to explore all variants in matrix view</li>
+      <li>Use zoom and sync scroll controls to compare details</li>
+      <li>Select your preferred style×layout combinations</li>
+      <li>Export selections as JSON for implementation planning</li>
+      <li>Review implementation notes in <code>*-notes.md</code> files</li>
+    </ol>
+  </div>
+</body>
+</html>
+INDEXEOF
+
+# Build pages list HTML
+PAGES_LIST_HTML=""
+for page in "${PAGE_ARRAY[@]}"; do
+    page=$(echo "$page" | xargs)
+    VARIANT_COUNT=$((STYLE_VARIANTS * LAYOUT_VARIANTS))
+    PAGES_LIST_HTML+="      <li>\n"
+    PAGES_LIST_HTML+="        <strong>${page}</strong>\n"
+    PAGES_LIST_HTML+="        <span class=\"badge\">${STYLE_VARIANTS}×${LAYOUT_VARIANTS} = ${VARIANT_COUNT} variants</span>\n"
+    PAGES_LIST_HTML+="      </li>\n"
+done
+
+# Replace all placeholders in index.html
+MODE_UPPER=$(echo "$MODE" | awk '{print toupper(substr($0,1,1)) tolower(substr($0,2))}')
+sed -i "s|__RUN_ID__|${RUN_ID}|g" index.html
+sed -i "s|__SESSION_ID__|${SESSION_ID}|g" index.html
+sed -i "s|__TIMESTAMP__|${TIMESTAMP}|g" index.html
+sed -i "s|__MODE__|${MODE_UPPER}|g" index.html
+sed -i "s|__STYLE_VARIANTS__|${STYLE_VARIANTS}|g" index.html
+sed -i "s|__LAYOUT_VARIANTS__|${LAYOUT_VARIANTS}|g" index.html
+sed -i "s|__PAGE_COUNT__|${#PAGE_ARRAY[@]}|g" index.html
+sed -i "s|__TOTAL_PROTOTYPES__|${TOTAL_PROTOTYPES}|g" index.html
+sed -i "s|__PAGES_LIST__|${PAGES_LIST_HTML}|g" index.html
+
+log_success "Generated: index.html"
+
+# ============================================================================
+# 2c. Generate PREVIEW.md
+# ============================================================================
+
+log_info "📄 Generating PREVIEW.md..."
+
+cat > PREVIEW.md <<PREVIEWEOF
+# UI Prototype Preview Guide
+
+## Quick Start
+1. Open \`index.html\` for overview and navigation
+2. Open \`compare.html\` for interactive matrix comparison
+3. Use browser developer tools to inspect responsive behavior
+
+## Configuration
+
+- **Exploration Mode:** ${MODE_UPPER}
+- **Run ID:** ${RUN_ID}
+- **Session ID:** ${SESSION_ID}
+- **Style Variants:** ${STYLE_VARIANTS}
+- **Layout Options:** ${LAYOUT_VARIANTS}
+- **${MODE_UPPER}s:** ${PAGES}
+- **Total Prototypes:** ${TOTAL_PROTOTYPES}
+- **Generated:** ${TIMESTAMP}
+
+## File Naming Convention
+
+\`\`\`
+{${MODE}}-style-{s}-layout-{l}.html
+\`\`\`
+
+**Example:** \`dashboard-style-1-layout-2.html\`
+- ${MODE_UPPER}: dashboard
+- Style: Design system 1
+- Layout: Layout variant 2
+
+## Interactive Features (compare.html)
+
+### Matrix View
+- **Grid Layout:** ${STYLE_VARIANTS}×${LAYOUT_VARIANTS} table with all prototypes visible
+- **Synchronized Scroll:** All iframes scroll together (toggle with button)
+- **Zoom Controls:** Adjust viewport scale (25%, 50%, 75%, 100%)
+- **${MODE_UPPER} Selector:** Switch between different ${MODE}s instantly
+
+### Prototype Actions
+- **⭐ Selection:** Click star icon to mark favorites
+- **⛶ Fullscreen:** View prototype in fullscreen overlay
+- **↗ New Tab:** Open prototype in dedicated browser tab
+
+### Selection Export
+1. Select preferred prototypes using star icons
+2. Click "Export Selection" button
+3. Downloads JSON file: \`selection-${RUN_ID}.json\`
+4. Use exported file for implementation planning
+
+## Design System References
+
+Each prototype references a specific style design system:
+PREVIEWEOF
+
+# Add style references
+for s in $(seq 1 "$STYLE_VARIANTS"); do
+    cat >> PREVIEW.md <<STYLEEOF
+
+### Style ${s}
+- **Tokens:** \`../style-extraction/style-${s}/design-tokens.json\`
+- **CSS Variables:** \`../style-extraction/style-${s}/tokens.css\`
+- **Style Guide:** \`../style-extraction/style-${s}/style-guide.md\`
+STYLEEOF
+done
+
+cat >> PREVIEW.md <<'FOOTEREOF'
+
+## Responsive Testing
+
+All prototypes are mobile-first responsive. Test at these breakpoints:
+
+- **Mobile:** 375px - 767px
+- **Tablet:** 768px - 1023px
+- **Desktop:** 1024px+
+
+Use browser DevTools responsive mode for testing.
+
+## Accessibility Features
+
+- Semantic HTML5 structure
+- ARIA attributes for screen readers
+- Keyboard navigation support
+- Proper heading hierarchy
+- Focus indicators
+
+## Next Steps
+
+1. **Review:** Open `compare.html` and explore all variants
+2. **Select:** Mark preferred prototypes using star icons
+3. **Export:** Download selection JSON for implementation
+4. **Implement:** Use `/workflow:ui-design:update` to integrate selected designs
+5. **Plan:** Run `/workflow:plan` to generate implementation tasks
+
+---
+
+**Generated by:** `ui-instantiate-prototypes.sh`
+**Version:** 3.0 (auto-detect mode)
+FOOTEREOF
+
+log_success "Generated: PREVIEW.md"
+
+# ============================================================================
+# Completion Summary
+# ============================================================================
+
+echo ""
+echo "========================================="
+echo "✅ Generation Complete!"
+echo "========================================="
+echo ""
+echo "📊 Summary:"
+echo "   Prototypes: ${total_generated} generated"
+if [ $total_failed -gt 0 ]; then
+    echo "   Failed: ${total_failed}"
+fi
+echo "   Preview Files: compare.html, index.html, PREVIEW.md"
+echo "   Matrix: ${STYLE_VARIANTS}×${LAYOUT_VARIANTS} (${#PAGE_ARRAY[@]} ${MODE}s)"
+echo "   Total Files: ${TOTAL_PROTOTYPES} prototypes + preview files"
+echo ""
+echo "🌐 Next Steps:"
+echo "   1. Open: ${BASE_PATH}/index.html"
+echo "   2. Explore: ${BASE_PATH}/compare.html"
+echo "   3. Review: ${BASE_PATH}/PREVIEW.md"
+echo ""
+echo "Performance: Template-based approach with ${STYLE_VARIANTS}× speedup"
+echo "========================================="

.claude/scripts/update_module_claude.sh

@@ -0,0 +1,333 @@
+#!/bin/bash
+# Update CLAUDE.md for modules with two strategies
+# Usage: update_module_claude.sh <strategy> <module_path> [tool] [model]
+#   strategy: single-layer|multi-layer
+#   module_path: Path to the module directory
+#   tool: gemini|qwen|codex (default: gemini)
+#   model: Model name (optional, uses tool defaults)
+#
+# Default Models:
+#   gemini: gemini-2.5-flash
+#   qwen: coder-model
+#   codex: gpt5-codex
+#
+# Strategies:
+#   single-layer: Upward aggregation
+#     - Read: Current directory code + child CLAUDE.md files
+#     - Generate: Single ./CLAUDE.md in current directory
+#     - Use: Large projects, incremental bottom-up updates
+#
+#   multi-layer: Downward distribution
+#     - Read: All files in current and subdirectories
+#     - Generate: CLAUDE.md for each directory containing files
+#     - Use: Small projects, full documentation generation
+#
+# Features:
+#   - Minimal prompts based on unified template
+#   - Respects .gitignore patterns
+#   - Path-focused processing (script only cares about paths)
+#   - Template-driven generation
+
+# Build exclusion filters from .gitignore
+build_exclusion_filters() {
+    local filters=""
+
+    # Common system/cache directories to exclude
+    local system_excludes=(
+        ".git" "__pycache__" "node_modules" ".venv" "venv" "env"
+        "dist" "build" ".cache" ".pytest_cache" ".mypy_cache"
+        "coverage" ".nyc_output" "logs" "tmp" "temp"
+    )
+
+    for exclude in "${system_excludes[@]}"; do
+        filters+=" -not -path '*/$exclude' -not -path '*/$exclude/*'"
+    done
+
+    # Find and parse .gitignore (current dir first, then git root)
+    local gitignore_file=""
+
+    # Check current directory first
+    if [ -f ".gitignore" ]; then
+        gitignore_file=".gitignore"
+    else
+        # Try to find git root and check for .gitignore there
+        local git_root=$(git rev-parse --show-toplevel 2>/dev/null)
+        if [ -n "$git_root" ] && [ -f "$git_root/.gitignore" ]; then
+            gitignore_file="$git_root/.gitignore"
+        fi
+    fi
+
+    # Parse .gitignore if found
+    if [ -n "$gitignore_file" ]; then
+        while IFS= read -r line; do
+            # Skip empty lines and comments
+            [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
+
+            # Remove trailing slash and whitespace
+            line=$(echo "$line" | sed 's|/$||' | xargs)
+
+            # Skip wildcards patterns (too complex for simple find)
+            [[ "$line" =~ \* ]] && continue
+
+            # Add to filters
+            filters+=" -not -path '*/$line' -not -path '*/$line/*'"
+        done < "$gitignore_file"
+    fi
+
+    echo "$filters"
+}
+
+# Scan directory structure and generate structured information
+scan_directory_structure() {
+    local target_path="$1"
+    local strategy="$2"
+
+    if [ ! -d "$target_path" ]; then
+        echo "Directory not found: $target_path"
+        return 1
+    fi
+
+    local exclusion_filters=$(build_exclusion_filters)
+    local structure_info=""
+
+    # Get basic directory info
+    local dir_name=$(basename "$target_path")
+    local total_files=$(eval "find \"$target_path\" -type f $exclusion_filters 2>/dev/null" | wc -l)
+    local total_dirs=$(eval "find \"$target_path\" -type d $exclusion_filters 2>/dev/null" | wc -l)
+
+    structure_info+="Directory: $dir_name\n"
+    structure_info+="Total files: $total_files\n"
+    structure_info+="Total directories: $total_dirs\n\n"
+
+    if [ "$strategy" = "multi-layer" ]; then
+        # For multi-layer: show all subdirectories with file counts
+        structure_info+="Subdirectories with files:\n"
+        while IFS= read -r dir; do
+            if [ -n "$dir" ] && [ "$dir" != "$target_path" ]; then
+                local rel_path=${dir#$target_path/}
+                local file_count=$(eval "find \"$dir\" -maxdepth 1 -type f $exclusion_filters 2>/dev/null" | wc -l)
+                if [ $file_count -gt 0 ]; then
+                    structure_info+="  - $rel_path/ ($file_count files)\n"
+                fi
+            fi
+        done < <(eval "find \"$target_path\" -type d $exclusion_filters 2>/dev/null")
+    else
+        # For single-layer: show direct children only
+        structure_info+="Direct subdirectories:\n"
+        while IFS= read -r dir; do
+            if [ -n "$dir" ]; then
+                local dir_name=$(basename "$dir")
+                local file_count=$(eval "find \"$dir\" -maxdepth 1 -type f $exclusion_filters 2>/dev/null" | wc -l)
+                local has_claude=$([ -f "$dir/CLAUDE.md" ] && echo " [has CLAUDE.md]" || echo "")
+                structure_info+="  - $dir_name/ ($file_count files)$has_claude\n"
+            fi
+        done < <(eval "find \"$target_path\" -maxdepth 1 -type d $exclusion_filters 2>/dev/null" | grep -v "^$target_path$")
+    fi
+
+    # Show main file types in current directory
+    structure_info+="\nCurrent directory files:\n"
+    local code_files=$(eval "find \"$target_path\" -maxdepth 1 -type f \\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' -o -name '*.py' -o -name '*.sh' \\) $exclusion_filters 2>/dev/null" | wc -l)
+    local config_files=$(eval "find \"$target_path\" -maxdepth 1 -type f \\( -name '*.json' -o -name '*.yaml' -o -name '*.yml' -o -name '*.toml' \\) $exclusion_filters 2>/dev/null" | wc -l)
+    local doc_files=$(eval "find \"$target_path\" -maxdepth 1 -type f -name '*.md' $exclusion_filters 2>/dev/null" | wc -l)
+
+    structure_info+="  - Code files: $code_files\n"
+    structure_info+="  - Config files: $config_files\n"
+    structure_info+="  - Documentation: $doc_files\n"
+
+    printf "%b" "$structure_info"
+}
+
+update_module_claude() {
+    local strategy="$1"
+    local module_path="$2"
+    local tool="${3:-gemini}"
+    local model="$4"
+
+    # Validate parameters
+    if [ -z "$strategy" ] || [ -z "$module_path" ]; then
+        echo "❌ Error: Strategy and module path are required"
+        echo "Usage: update_module_claude.sh <strategy> <module_path> [tool] [model]"
+        echo "Strategies: single-layer|multi-layer"
+        return 1
+    fi
+
+    # Validate strategy
+    if [ "$strategy" != "single-layer" ] && [ "$strategy" != "multi-layer" ]; then
+        echo "❌ Error: Invalid strategy '$strategy'"
+        echo "Valid strategies: single-layer, multi-layer"
+        return 1
+    fi
+
+    if [ ! -d "$module_path" ]; then
+        echo "❌ Error: Directory '$module_path' does not exist"
+        return 1
+    fi
+
+    # Set default models if not specified
+    if [ -z "$model" ]; then
+        case "$tool" in
+            gemini)
+                model="gemini-2.5-flash"
+                ;;
+            qwen)
+                model="coder-model"
+                ;;
+            codex)
+                model="gpt5-codex"
+                ;;
+            *)
+                model=""
+                ;;
+        esac
+    fi
+
+    # Build exclusion filters from .gitignore
+    local exclusion_filters=$(build_exclusion_filters)
+
+    # Check if directory has files (excluding gitignored paths)
+    local file_count=$(eval "find \"$module_path\" -maxdepth 1 -type f $exclusion_filters 2>/dev/null" | wc -l)
+    if [ $file_count -eq 0 ]; then
+        echo "⚠️  Skipping '$module_path' - no files found (after .gitignore filtering)"
+        return 0
+    fi
+
+    # Use unified template for all modules
+    local template_path="$HOME/.claude/workflows/cli-templates/prompts/memory/02-document-module-structure.txt"
+
+    # Read template content directly
+    local template_content=""
+    if [ -f "$template_path" ]; then
+        template_content=$(cat "$template_path")
+        echo "   📋 Loaded template: $(wc -l < "$template_path") lines"
+    else
+        echo "   ⚠️  Template not found: $template_path"
+        echo "   Using fallback template..."
+        template_content="Create comprehensive CLAUDE.md documentation following standard structure with Purpose, Structure, Components, Dependencies, Integration, and Implementation sections."
+    fi
+
+    # Scan directory structure first
+    echo "   🔍 Scanning directory structure..."
+    local structure_info=$(scan_directory_structure "$module_path" "$strategy")
+
+    # Prepare logging info
+    local module_name=$(basename "$module_path")
+
+    echo "⚡ Updating: $module_path"
+    echo "   Strategy: $strategy | Tool: $tool | Model: $model | Files: $file_count"
+    echo "   Template: $(basename "$template_path") ($(echo "$template_content" | wc -l) lines)"
+    echo "   Structure: Scanned $(echo "$structure_info" | wc -l) lines of structure info"
+
+    # Build minimal strategy-specific prompt with explicit paths and structure info
+    local final_prompt=""
+
+    if [ "$strategy" = "multi-layer" ]; then
+        # multi-layer strategy: read all, generate for each directory
+        final_prompt="Directory Structure Analysis:
+$structure_info
+
+Read: @**/*
+
+Generate CLAUDE.md files:
+- Primary: ./CLAUDE.md (current directory)
+- Additional: CLAUDE.md in each subdirectory containing files
+
+Template Guidelines:
+$template_content
+
+Instructions:
+- Work bottom-up: deepest directories first
+- Parent directories reference children
+- Each CLAUDE.md file must be in its respective directory
+- Follow the template guidelines above for consistent structure
+- Use the structure analysis to understand directory hierarchy"
+    else
+        # single-layer strategy: read current + child CLAUDE.md, generate current only
+        final_prompt="Directory Structure Analysis:
+$structure_info
+
+Read: @*/CLAUDE.md @*.ts @*.tsx @*.js @*.jsx @*.py @*.sh @*.md @*.json @*.yaml @*.yml
+
+Generate single file: ./CLAUDE.md
+
+Template Guidelines:
+$template_content
+
+Instructions:
+- Create exactly one CLAUDE.md file in the current directory
+- Reference child CLAUDE.md files, do not duplicate their content
+- Follow the template guidelines above for consistent structure
+- Use the structure analysis to understand the current directory context"
+    fi
+
+    # Execute update
+    local start_time=$(date +%s)
+    echo "   🔄 Starting update..."
+
+    if cd "$module_path" 2>/dev/null; then
+        local tool_result=0
+
+        # Execute with selected tool
+        # NOTE: Model parameter (-m) is placed AFTER the prompt
+        case "$tool" in
+            qwen)
+                if [ "$model" = "coder-model" ]; then
+                    # coder-model is default, -m is optional
+                    qwen -p "$final_prompt" --yolo 2>&1
+                else
+                    qwen -p "$final_prompt" -m "$model" --yolo 2>&1
+                fi
+                tool_result=$?
+                ;;
+            codex)
+                codex --full-auto exec "$final_prompt" -m "$model" --skip-git-repo-check -s danger-full-access 2>&1
+                tool_result=$?
+                ;;
+            gemini)
+                gemini -p "$final_prompt" -m "$model" --yolo 2>&1
+                tool_result=$?
+                ;;
+            *)
+                echo "   ⚠️  Unknown tool: $tool, defaulting to gemini"
+                gemini -p "$final_prompt" -m "$model" --yolo 2>&1
+                tool_result=$?
+                ;;
+        esac
+
+        if [ $tool_result -eq 0 ]; then
+            local end_time=$(date +%s)
+            local duration=$((end_time - start_time))
+            echo "   ✅ Completed in ${duration}s"
+            cd - > /dev/null
+            return 0
+        else
+            echo "   ❌ Update failed for $module_path"
+            cd - > /dev/null
+            return 1
+        fi
+    else
+        echo "   ❌ Cannot access directory: $module_path"
+        return 1
+    fi
+}
+
+# Execute function if script is run directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    # Show help if no arguments or help requested
+    if [ $# -eq 0 ] || [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
+        echo "Usage: update_module_claude.sh <strategy> <module_path> [tool] [model]"
+        echo ""
+        echo "Strategies:"
+        echo "  single-layer    - Read current dir code + child CLAUDE.md, generate ./CLAUDE.md"
+        echo "  multi-layer     - Read all files, generate CLAUDE.md for each directory"
+        echo ""
+        echo "Tools: gemini (default), qwen, codex"
+        echo "Models: Use tool defaults if not specified"
+        echo ""
+        echo "Examples:"
+        echo "  ./update_module_claude.sh single-layer ./src/auth"
+        echo "  ./update_module_claude.sh multi-layer ./components gemini gemini-2.5-flash"
+        exit 0
+    fi
+
+    update_module_claude "$@"
+fi

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

@@ -1,693 +0,0 @@
-# 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

@@ -1,584 +0,0 @@
-# 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

@@ -1,116 +0,0 @@
----
-name: ccw-help
-description: CCW command help system. Search, browse, recommend commands. Triggers "ccw-help", "ccw-issue".
-allowed-tools: Read, Grep, Glob, AskUserQuestion
-version: 7.0.0
----
-
-# CCW-Help Skill
-
-CCW 命令帮助系统，提供命令搜索、推荐、文档查看功能。
-
-## Trigger Conditions
-
-- 关键词: "ccw-help", "ccw-issue", "帮助", "命令", "怎么用"
-- 场景: 询问命令用法、搜索命令、请求下一步建议
-
-## Operation Modes
-
-### Mode 1: Command Search
-
-**Triggers**: "搜索命令", "find command", "search"
-
-**Process**:
-1. Query `command.json` commands array
-2. Filter by name, description, category
-3. Present top 3-5 relevant commands
-
-### Mode 2: Smart Recommendations
-
-**Triggers**: "下一步", "what's next", "推荐"
-
-**Process**:
-1. Query command's `flow.next_steps` in `command.json`
-2. Explain WHY each recommendation fits
-
-### Mode 3: Documentation
-
-**Triggers**: "怎么用", "how to use", "详情"
-
-**Process**:
-1. Locate command in `command.json`
-2. Read source file via `source` path
-3. Provide context-specific examples
-
-### Mode 4: Beginner Onboarding
-
-**Triggers**: "新手", "getting started", "常用命令"
-
-**Process**:
-1. Query `essential_commands` array
-2. 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
-
-## Data Source
-
-Single source of truth: **[command.json](command.json)**
-
-| Field | Purpose |
-|-------|---------|
-| `commands[]` | Flat command list with metadata |
-| `commands[].flow` | Relationships (next_steps, prerequisites) |
-| `commands[].essential` | Essential flag for onboarding |
-| `agents[]` | Agent directory |
-| `essential_commands[]` | Core commands list |
-
-### Source Path Format
-
-`source` 字段是相对路径（从 `skills/ccw-help/` 目录）：
-
-```json
-{
-  "name": "lite-plan",
-  "source": "../../../commands/workflow/lite-plan.md"
-}
-```
-
-## Slash Commands
-
-```bash
-/ccw-help                    # 通用帮助入口
-/ccw-help search <keyword>   # 搜索命令
-/ccw-help next <command>     # 获取下一步建议
-/ccw-issue                   # 问题报告
-```
-
-## Maintenance
-
-### Update Index
-
-```bash
-cd D:/Claude_dms3/.claude/skills/ccw-help
-python scripts/analyze_commands.py
-```
-
-脚本功能：扫描 commands/ 和 agents/ 目录，生成统一的 command.json
-
-## Statistics
-
-- **Commands**: 88+
-- **Agents**: 16
-- **Essential**: 10 核心命令
-
-## Core Principle
-
-**智能整合，非模板复制**
-
-- 理解用户具体情况
-- 整合多个来源信息
-- 定制示例和说明

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

@@ -1,511 +0,0 @@
-{
-  "_metadata": {
-    "version": "2.0.0",
-    "total_commands": 88,
-    "total_agents": 16,
-    "description": "Unified CCW-Help command index"
-  },
-
-  "essential_commands": [
-    "/workflow:lite-plan",
-    "/workflow:lite-fix",
-    "/workflow:plan",
-    "/workflow:execute",
-    "/workflow:session:start",
-    "/workflow:review-session-cycle",
-    "/memory:docs",
-    "/workflow:brainstorm:artifacts",
-    "/workflow:action-plan-verify",
-    "/version"
-  ],
-
-  "commands": [
-    {
-      "name": "lite-plan",
-      "command": "/workflow:lite-plan",
-      "description": "Lightweight interactive planning with in-memory plan, dispatches to lite-execute",
-      "arguments": "[-e|--explore] \"task\"|file.md",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "next_steps": ["/workflow:lite-execute"],
-        "alternatives": ["/workflow:plan"]
-      },
-      "source": "../../../commands/workflow/lite-plan.md"
-    },
-    {
-      "name": "lite-execute",
-      "command": "/workflow:lite-execute",
-      "description": "Execute based on in-memory plan or prompt",
-      "arguments": "[--in-memory] \"task\"|file-path",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "flow": {
-        "prerequisites": ["/workflow:lite-plan", "/workflow:lite-fix"]
-      },
-      "source": "../../../commands/workflow/lite-execute.md"
-    },
-    {
-      "name": "lite-fix",
-      "command": "/workflow:lite-fix",
-      "description": "Lightweight bug diagnosis and fix with optional hotfix mode",
-      "arguments": "[--hotfix] \"bug description\"",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "next_steps": ["/workflow:lite-execute"],
-        "alternatives": ["/workflow:lite-plan"]
-      },
-      "source": "../../../commands/workflow/lite-fix.md"
-    },
-    {
-      "name": "plan",
-      "command": "/workflow:plan",
-      "description": "5-phase planning with task JSON generation",
-      "arguments": "\"description\"|file.md",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "next_steps": ["/workflow:action-plan-verify", "/workflow:execute"],
-        "alternatives": ["/workflow:tdd-plan"]
-      },
-      "source": "../../../commands/workflow/plan.md"
-    },
-    {
-      "name": "execute",
-      "command": "/workflow:execute",
-      "description": "Coordinate agent execution with DAG parallel processing",
-      "arguments": "[--resume-session=\"session-id\"]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "prerequisites": ["/workflow:plan", "/workflow:tdd-plan"],
-        "next_steps": ["/workflow:review"]
-      },
-      "source": "../../../commands/workflow/execute.md"
-    },
-    {
-      "name": "action-plan-verify",
-      "command": "/workflow:action-plan-verify",
-      "description": "Cross-artifact consistency analysis",
-      "arguments": "[--session session-id]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "prerequisites": ["/workflow:plan"],
-        "next_steps": ["/workflow:execute"]
-      },
-      "source": "../../../commands/workflow/action-plan-verify.md"
-    },
-    {
-      "name": "init",
-      "command": "/workflow:init",
-      "description": "Initialize project-level state",
-      "arguments": "[--regenerate]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/init.md"
-    },
-    {
-      "name": "clean",
-      "command": "/workflow:clean",
-      "description": "Intelligent code cleanup with stale artifact discovery",
-      "arguments": "[--dry-run] [\"focus\"]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/clean.md"
-    },
-    {
-      "name": "debug",
-      "command": "/workflow:debug",
-      "description": "Hypothesis-driven debugging with NDJSON logging",
-      "arguments": "\"bug description\"",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/debug.md"
-    },
-    {
-      "name": "replan",
-      "command": "/workflow:replan",
-      "description": "Interactive workflow replanning",
-      "arguments": "[--session id] [task-id] \"requirements\"",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/replan.md"
-    },
-    {
-      "name": "session:start",
-      "command": "/workflow:session:start",
-      "description": "Start or discover workflow sessions",
-      "arguments": "[--type <workflow|review|tdd>] [--auto|--new]",
-      "category": "workflow",
-      "subcategory": "session",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "next_steps": ["/workflow:plan", "/workflow:execute"]
-      },
-      "source": "../../../commands/workflow/session/start.md"
-    },
-    {
-      "name": "session:list",
-      "command": "/workflow:session:list",
-      "description": "List all workflow sessions",
-      "arguments": "",
-      "category": "workflow",
-      "subcategory": "session",
-      "difficulty": "Beginner",
-      "source": "../../../commands/workflow/session/list.md"
-    },
-    {
-      "name": "session:resume",
-      "command": "/workflow:session:resume",
-      "description": "Resume paused workflow session",
-      "arguments": "",
-      "category": "workflow",
-      "subcategory": "session",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/session/resume.md"
-    },
-    {
-      "name": "session:complete",
-      "command": "/workflow:session:complete",
-      "description": "Mark session complete and archive",
-      "arguments": "",
-      "category": "workflow",
-      "subcategory": "session",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/session/complete.md"
-    },
-    {
-      "name": "brainstorm:auto-parallel",
-      "command": "/workflow:brainstorm:auto-parallel",
-      "description": "Parallel brainstorming with multi-role analysis",
-      "arguments": "\"topic\" [--count N]",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "difficulty": "Advanced",
-      "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
-    },
-    {
-      "name": "brainstorm:artifacts",
-      "command": "/workflow:brainstorm:artifacts",
-      "description": "Interactive clarification with guidance specification",
-      "arguments": "\"topic\" [--count N]",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "source": "../../../commands/workflow/brainstorm/artifacts.md"
-    },
-    {
-      "name": "brainstorm:synthesis",
-      "command": "/workflow:brainstorm:synthesis",
-      "description": "Refine role analyses through Q&A",
-      "arguments": "[--session session-id]",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "difficulty": "Advanced",
-      "source": "../../../commands/workflow/brainstorm/synthesis.md"
-    },
-    {
-      "name": "tdd-plan",
-      "command": "/workflow:tdd-plan",
-      "description": "TDD planning with Red-Green-Refactor cycles",
-      "arguments": "\"feature\"|file.md",
-      "category": "workflow",
-      "difficulty": "Advanced",
-      "flow": {
-        "next_steps": ["/workflow:execute", "/workflow:tdd-verify"],
-        "alternatives": ["/workflow:plan"]
-      },
-      "source": "../../../commands/workflow/tdd-plan.md"
-    },
-    {
-      "name": "tdd-verify",
-      "command": "/workflow:tdd-verify",
-      "description": "Verify TDD compliance with coverage analysis",
-      "arguments": "[session-id]",
-      "category": "workflow",
-      "difficulty": "Advanced",
-      "flow": {
-        "prerequisites": ["/workflow:execute"]
-      },
-      "source": "../../../commands/workflow/tdd-verify.md"
-    },
-    {
-      "name": "review",
-      "command": "/workflow:review",
-      "description": "Post-implementation review (security/architecture/quality)",
-      "arguments": "[--type=<type>] [session-id]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/review.md"
-    },
-    {
-      "name": "review-session-cycle",
-      "command": "/workflow:review-session-cycle",
-      "description": "Multi-dimensional code review across 7 dimensions",
-      "arguments": "[session-id] [--dimensions=...]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "prerequisites": ["/workflow:execute"],
-        "next_steps": ["/workflow:review-fix"]
-      },
-      "source": "../../../commands/workflow/review-session-cycle.md"
-    },
-    {
-      "name": "review-module-cycle",
-      "command": "/workflow:review-module-cycle",
-      "description": "Module-based multi-dimensional review",
-      "arguments": "<path-pattern> [--dimensions=...]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/review-module-cycle.md"
-    },
-    {
-      "name": "review-fix",
-      "command": "/workflow:review-fix",
-      "description": "Automated fixing of review findings",
-      "arguments": "<export-file|review-dir>",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "flow": {
-        "prerequisites": ["/workflow:review-session-cycle", "/workflow:review-module-cycle"]
-      },
-      "source": "../../../commands/workflow/review-fix.md"
-    },
-    {
-      "name": "test-gen",
-      "command": "/workflow:test-gen",
-      "description": "Generate test session from implementation",
-      "arguments": "source-session-id",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/test-gen.md"
-    },
-    {
-      "name": "test-fix-gen",
-      "command": "/workflow:test-fix-gen",
-      "description": "Create test-fix session with strategy",
-      "arguments": "session-id|\"description\"|file",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/test-fix-gen.md"
-    },
-    {
-      "name": "test-cycle-execute",
-      "command": "/workflow:test-cycle-execute",
-      "description": "Execute test-fix with iterative cycles",
-      "arguments": "[--resume-session=id] [--max-iterations=N]",
-      "category": "workflow",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/test-cycle-execute.md"
-    },
-    {
-      "name": "issue:new",
-      "command": "/issue:new",
-      "description": "Create issue from GitHub URL or text",
-      "arguments": "<url|text> [--priority 1-5]",
-      "category": "issue",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/issue/new.md"
-    },
-    {
-      "name": "issue:discover",
-      "command": "/issue:discover",
-      "description": "Discover issues from multiple perspectives",
-      "arguments": "<path> [--perspectives=...]",
-      "category": "issue",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/issue/discover.md"
-    },
-    {
-      "name": "issue:plan",
-      "command": "/issue:plan",
-      "description": "Batch plan issue resolution",
-      "arguments": "--all-pending|<ids>",
-      "category": "issue",
-      "difficulty": "Intermediate",
-      "flow": {
-        "next_steps": ["/issue:queue"]
-      },
-      "source": "../../../commands/issue/plan.md"
-    },
-    {
-      "name": "issue:queue",
-      "command": "/issue:queue",
-      "description": "Form execution queue from solutions",
-      "arguments": "[--rebuild]",
-      "category": "issue",
-      "difficulty": "Intermediate",
-      "flow": {
-        "prerequisites": ["/issue:plan"],
-        "next_steps": ["/issue:execute"]
-      },
-      "source": "../../../commands/issue/queue.md"
-    },
-    {
-      "name": "issue:execute",
-      "command": "/issue:execute",
-      "description": "Execute queue with DAG parallel",
-      "arguments": "[--worktree]",
-      "category": "issue",
-      "difficulty": "Intermediate",
-      "flow": {
-        "prerequisites": ["/issue:queue"]
-      },
-      "source": "../../../commands/issue/execute.md"
-    },
-    {
-      "name": "docs",
-      "command": "/memory:docs",
-      "description": "Plan documentation workflow",
-      "arguments": "[path] [--tool <tool>]",
-      "category": "memory",
-      "difficulty": "Intermediate",
-      "essential": true,
-      "flow": {
-        "next_steps": ["/workflow:execute"]
-      },
-      "source": "../../../commands/memory/docs.md"
-    },
-    {
-      "name": "update-related",
-      "command": "/memory:update-related",
-      "description": "Update docs for git-changed modules",
-      "arguments": "[--tool <tool>]",
-      "category": "memory",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/memory/update-related.md"
-    },
-    {
-      "name": "update-full",
-      "command": "/memory:update-full",
-      "description": "Update all CLAUDE.md files",
-      "arguments": "[--tool <tool>]",
-      "category": "memory",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/memory/update-full.md"
-    },
-    {
-      "name": "skill-memory",
-      "command": "/memory:skill-memory",
-      "description": "Generate SKILL.md with loading index",
-      "arguments": "[path] [--regenerate]",
-      "category": "memory",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/memory/skill-memory.md"
-    },
-    {
-      "name": "load-skill-memory",
-      "command": "/memory:load-skill-memory",
-      "description": "Activate SKILL package for task",
-      "arguments": "[skill_name] \"task intent\"",
-      "category": "memory",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/memory/load-skill-memory.md"
-    },
-    {
-      "name": "load",
-      "command": "/memory:load",
-      "description": "Load project context via CLI",
-      "arguments": "[--tool <tool>] \"context\"",
-      "category": "memory",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/memory/load.md"
-    },
-    {
-      "name": "compact",
-      "command": "/memory:compact",
-      "description": "Compact session memory for recovery",
-      "arguments": "[description]",
-      "category": "memory",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/memory/compact.md"
-    },
-    {
-      "name": "task:create",
-      "command": "/task:create",
-      "description": "Generate task JSON from description",
-      "arguments": "\"task title\"",
-      "category": "task",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/task/create.md"
-    },
-    {
-      "name": "task:execute",
-      "command": "/task:execute",
-      "description": "Execute task JSON with agent",
-      "arguments": "task-id",
-      "category": "task",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/task/execute.md"
-    },
-    {
-      "name": "task:breakdown",
-      "command": "/task:breakdown",
-      "description": "Decompose task into subtasks",
-      "arguments": "task-id",
-      "category": "task",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/task/breakdown.md"
-    },
-    {
-      "name": "task:replan",
-      "command": "/task:replan",
-      "description": "Update task with new requirements",
-      "arguments": "task-id [\"text\"|file]",
-      "category": "task",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/task/replan.md"
-    },
-    {
-      "name": "version",
-      "command": "/version",
-      "description": "Display version and check updates",
-      "arguments": "",
-      "category": "general",
-      "difficulty": "Beginner",
-      "essential": true,
-      "source": "../../../commands/version.md"
-    },
-    {
-      "name": "enhance-prompt",
-      "command": "/enhance-prompt",
-      "description": "Transform prompts with session memory",
-      "arguments": "user input",
-      "category": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/enhance-prompt.md"
-    }
-  ],
-
-  "agents": [
-    { "name": "action-planning-agent", "description": "Task planning and generation", "source": "../../../agents/action-planning-agent.md" },
-    { "name": "cli-execution-agent", "description": "CLI tool execution", "source": "../../../agents/cli-execution-agent.md" },
-    { "name": "cli-explore-agent", "description": "Codebase exploration", "source": "../../../agents/cli-explore-agent.md" },
-    { "name": "cli-lite-planning-agent", "description": "Lightweight planning", "source": "../../../agents/cli-lite-planning-agent.md" },
-    { "name": "cli-planning-agent", "description": "CLI-based planning", "source": "../../../agents/cli-planning-agent.md" },
-    { "name": "code-developer", "description": "Code implementation", "source": "../../../agents/code-developer.md" },
-    { "name": "conceptual-planning-agent", "description": "Conceptual analysis", "source": "../../../agents/conceptual-planning-agent.md" },
-    { "name": "context-search-agent", "description": "Context discovery", "source": "../../../agents/context-search-agent.md" },
-    { "name": "doc-generator", "description": "Documentation generation", "source": "../../../agents/doc-generator.md" },
-    { "name": "issue-plan-agent", "description": "Issue planning", "source": "../../../agents/issue-plan-agent.md" },
-    { "name": "issue-queue-agent", "description": "Issue queue formation", "source": "../../../agents/issue-queue-agent.md" },
-    { "name": "memory-bridge", "description": "Documentation coordination", "source": "../../../agents/memory-bridge.md" },
-    { "name": "test-context-search-agent", "description": "Test context collection", "source": "../../../agents/test-context-search-agent.md" },
-    { "name": "test-fix-agent", "description": "Test execution and fixing", "source": "../../../agents/test-fix-agent.md" },
-    { "name": "ui-design-agent", "description": "UI design and prototyping", "source": "../../../agents/ui-design-agent.md" },
-    { "name": "universal-executor", "description": "Universal task execution", "source": "../../../agents/universal-executor.md" }
-  ],
-
-  "categories": ["workflow", "issue", "memory", "task", "general", "cli"]
-}

.claude/skills/ccw/SKILL.md

@@ -1,352 +0,0 @@
----
-name: ccw
-description: Stateless workflow orchestrator. Auto-selects optimal workflow based on task intent. Triggers "ccw", "workflow".
-allowed-tools: Task(*), SlashCommand(*), AskUserQuestion(*), Read(*), Bash(*), Grep(*), TodoWrite(*)
----
-
-# CCW - Claude Code Workflow Orchestrator
-
-无状态工作流协调器，根据任务意图自动选择最优工作流。
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│  CCW Orchestrator (CLI-Enhanced + Requirement Analysis)         │
-├─────────────────────────────────────────────────────────────────┤
-│  Phase 1    │ Input Analysis (rule-based, fast path)            │
-│  Phase 1.5  │ CLI Classification (semantic, smart path)         │
-│  Phase 1.75 │ Requirement Clarification (clarity < 2)           │
-│  Phase 2    │ Chain Selection (intent → workflow)               │
-│  Phase 2.5  │ CLI Action Planning (high complexity)             │
-│  Phase 3    │ User Confirmation (optional)                      │
-│  Phase 4    │ TODO Tracking Setup                               │
-│  Phase 5    │ Execution Loop                                    │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Intent Classification
-
-### Priority Order
-
-| Priority | Intent | Patterns | Flow |
-|----------|--------|----------|------|
-| 1 | bugfix/hotfix | `urgent,production,critical` + bug | `bugfix.hotfix` |
-| 1 | bugfix | `fix,bug,error,crash,fail` | `bugfix.standard` |
-| 2 | issue batch | `issues,batch` + `fix,resolve` | `issue` |
-| 3 | exploration | `不确定,explore,研究,what if` | `full` |
-| 3 | multi-perspective | `多视角,权衡,比较方案,cross-verify` | `multi-cli-plan` |
-| 4 | quick-task | `快速,简单,small,quick` + feature | `lite-lite-lite` |
-| 5 | ui design | `ui,design,component,style` | `ui` |
-| 6 | tdd | `tdd,test-driven,先写测试` | `tdd` |
-| 7 | review | `review,审查,code review` | `review-fix` |
-| 8 | documentation | `文档,docs,readme` | `docs` |
-| 99 | feature | complexity-based | `rapid`/`coupled` |
-
-### Complexity Assessment
-
-```javascript
-function assessComplexity(text) {
-  let score = 0
-  if (/refactor|重构|migrate|迁移|architect|架构|system|系统/.test(text)) score += 2
-  if (/multiple|多个|across|跨|all|所有|entire|整个/.test(text)) score += 2
-  if (/integrate|集成|api|database|数据库/.test(text)) score += 1
-  if (/security|安全|performance|性能|scale|扩展/.test(text)) score += 1
-  return score >= 4 ? 'high' : score >= 2 ? 'medium' : 'low'
-}
-```
-
-| Complexity | Flow |
-|------------|------|
-| high | `coupled` (plan → verify → execute) |
-| medium/low | `rapid` (lite-plan → lite-execute) |
-
-### Dimension Extraction (WHAT/WHERE/WHY/HOW)
-
-从用户输入提取四个维度，用于需求澄清和工作流选择：
-
-| 维度 | 提取内容 | 示例模式 |
-|------|----------|----------|
-| **WHAT** | action + target | `创建/修复/重构/优化/分析` + 目标对象 |
-| **WHERE** | scope + paths | `file/module/system` + 文件路径 |
-| **WHY** | goal + motivation | `为了.../因为.../目的是...` |
-| **HOW** | constraints + preferences | `必须.../不要.../应该...` |
-
-**Clarity Score** (0-3):
-- +0.5: 有明确 action
-- +0.5: 有具体 target
-- +0.5: 有文件路径
-- +0.5: scope 不是 unknown
-- +0.5: 有明确 goal
-- +0.5: 有约束条件
-- -0.5: 包含不确定词 (`不知道/maybe/怎么`)
-
-### Requirement Clarification
-
-当 `clarity_score < 2` 时触发需求澄清：
-
-```javascript
-if (dimensions.clarity_score < 2) {
-  const questions = generateClarificationQuestions(dimensions)
-  // 生成问题：目标是什么? 范围是什么? 有什么约束?
-  AskUserQuestion({ questions })
-}
-```
-
-**澄清问题类型**:
-- 目标不明确 → "你想要对什么进行操作?"
-- 范围不明确 → "操作的范围是什么?"
-- 目的不明确 → "这个操作的主要目标是什么?"
-- 复杂操作 → "有什么特殊要求或限制?"
-
-## TODO Tracking Protocol
-
-### CRITICAL: Append-Only Rule
-
-CCW 创建的 Todo **必须附加到现有列表**，不能覆盖用户的其他 Todo。
-
-### Implementation
-
-```javascript
-// 1. 使用 CCW 前缀隔离工作流 todo
-const prefix = `CCW:${flowName}`
-
-// 2. 创建新 todo 时使用前缀格式
-TodoWrite({
-  todos: [
-    ...existingNonCCWTodos,  // 保留用户的 todo
-    { content: `${prefix}: [1/N] /command:step1`, status: "in_progress", activeForm: "..." },
-    { content: `${prefix}: [2/N] /command:step2`, status: "pending", activeForm: "..." }
-  ]
-})
-
-// 3. 更新状态时只修改匹配前缀的 todo
-```
-
-### Todo Format
-
-```
-CCW:{flow}: [{N}/{Total}] /command:name
-```
-
-### Visual Example
-
-```
-✓ CCW:rapid: [1/2] /workflow:lite-plan
-→ CCW:rapid: [2/2] /workflow:lite-execute
-  用户自己的 todo（保留不动）
-```
-
-### Status Management
-
-- 开始工作流：创建所有步骤 todo，第一步 `in_progress`
-- 完成步骤：当前步骤 `completed`，下一步 `in_progress`
-- 工作流结束：所有 CCW todo 标记 `completed`
-
-## Execution Flow
-
-```javascript
-// 1. Check explicit command
-if (input.startsWith('/workflow:') || input.startsWith('/issue:')) {
-  SlashCommand(input)
-  return
-}
-
-// 2. Classify intent
-const intent = classifyIntent(input)  // See command.json intent_rules
-
-// 3. Select flow
-const flow = selectFlow(intent)  // See command.json flows
-
-// 4. Create todos with CCW prefix
-createWorkflowTodos(flow)
-
-// 5. Dispatch first command
-SlashCommand(flow.steps[0].command, args: input)
-```
-
-## CLI Tool Integration
-
-CCW 在特定条件下自动注入 CLI 调用：
-
-| Condition | CLI Inject |
-|-----------|------------|
-| 大量代码上下文 (≥50k chars) | `gemini --mode analysis` |
-| 高复杂度任务 | `gemini --mode analysis` |
-| Bug 诊断 | `gemini --mode analysis` |
-| 多任务执行 (≥3 tasks) | `codex --mode write` |
-
-### CLI Enhancement Phases
-
-**Phase 1.5: CLI-Assisted Classification**
-
-当规则匹配不明确时，使用 CLI 辅助分类：
-
-| 触发条件 | 说明 |
-|----------|------|
-| matchCount < 2 | 多个意图模式匹配 |
-| complexity = high | 高复杂度任务 |
-| input > 100 chars | 长输入需要语义理解 |
-
-**Phase 2.5: CLI-Assisted Action Planning**
-
-高复杂度任务的工作流优化：
-
-| 触发条件 | 说明 |
-|----------|------|
-| complexity = high | 高复杂度任务 |
-| steps >= 3 | 多步骤工作流 |
-| input > 200 chars | 复杂需求描述 |
-
-CLI 可返回建议：`use_default` | `modify` (调整步骤) | `upgrade` (升级工作流)
-
-## Continuation Commands
-
-工作流执行中的用户控制命令：
-
-| 命令 | 作用 |
-|------|------|
-| `continue` | 继续执行下一步 |
-| `skip` | 跳过当前步骤 |
-| `abort` | 终止工作流 |
-| `/workflow:*` | 切换到指定命令 |
-| 自然语言 | 重新分析意图 |
-
-## Workflow Flow Details
-
-### Issue Workflow (两阶段生命周期)
-
-Issue 工作流设计为两阶段生命周期，支持在项目迭代过程中积累问题并集中解决。
-
-**Phase 1: Accumulation (积累阶段)**
-- 触发：任务完成后的 review、代码审查发现、测试失败
-- 活动：需求扩展、bug 分析、测试覆盖、安全审查
-- 命令：`/issue:discover`, `/issue:discover-by-prompt`, `/issue:new`
-
-**Phase 2: Batch Resolution (批量解决阶段)**
-- 触发：积累足够 issue 后的集中处理
-- 流程：plan → queue → execute
-- 命令：`/issue:plan --all-pending` → `/issue:queue` → `/issue:execute`
-
-```
-任务完成 → discover → 积累 issue → ... → plan all → queue → parallel execute
-    ↑                      ↓
-    └────── 迭代循环 ───────┘
-```
-
-### lite-lite-lite vs multi-cli-plan
-
-| 维度 | lite-lite-lite | multi-cli-plan |
-|------|---------------|----------------|
-| **产物** | 无文件 | IMPL_PLAN.md + plan.json + synthesis.json |
-| **状态** | 无状态 | 持久化 session |
-| **CLI选择** | 自动分析任务类型选择 | 配置驱动 |
-| **迭代** | 通过 AskUser | 多轮收敛 |
-| **执行** | 直接执行 | 通过 lite-execute |
-| **适用** | 快速修复、简单功能 | 复杂多步骤实现 |
-
-**选择指南**：
-- 任务清晰、改动范围小 → `lite-lite-lite`
-- 需要多视角分析、复杂架构 → `multi-cli-plan`
-
-### multi-cli-plan vs lite-plan
-
-| 维度 | multi-cli-plan | lite-plan |
-|------|---------------|-----------|
-| **上下文** | ACE 语义搜索 | 手动文件模式 |
-| **分析** | 多 CLI 交叉验证 | 单次规划 |
-| **迭代** | 多轮直到收敛 | 单轮 |
-| **置信度** | 高 (共识驱动) | 中 (单一视角) |
-| **适用** | 需要多视角的复杂任务 | 直接明确的实现 |
-
-**选择指南**：
-- 需求明确、路径清晰 → `lite-plan`
-- 需要权衡、多方案比较 → `multi-cli-plan`
-
-## Artifact Flow Protocol
-
-工作流产出的自动流转机制，支持不同格式产出间的意图提取和完成度判断。
-
-### 产出格式
-
-| 命令 | 产出位置 | 格式 | 关键字段 |
-|------|----------|------|----------|
-| `/workflow:lite-plan` | memory://plan | structured_plan | tasks, files, dependencies |
-| `/workflow:plan` | .workflow/{session}/IMPL_PLAN.md | markdown_plan | phases, tasks, risks |
-| `/workflow:execute` | execution_log.json | execution_report | completed_tasks, errors |
-| `/workflow:test-cycle-execute` | test_results.json | test_report | pass_rate, failures, coverage |
-| `/workflow:review-session-cycle` | review_report.md | review_report | findings, severity_counts |
-
-### 意图提取 (Intent Extraction)
-
-流转到下一步时，自动提取关键信息：
-
-```
-plan → execute:
-  提取: tasks (未完成), priority_order, files_to_modify, context_summary
-
-execute → test:
-  提取: modified_files, test_scope (推断), pending_verification
-
-test → fix:
-  条件: pass_rate < 0.95
-  提取: failures, error_messages, affected_files, suggested_fixes
-
-review → fix:
-  条件: critical > 0 OR high > 3
-  提取: findings (critical/high), fix_priority, affected_files
-```
-
-### 完成度判断
-
-**Test 完成度路由**:
-```
-pass_rate >= 0.95 AND coverage >= 0.80  → complete
-pass_rate >= 0.95 AND coverage < 0.80   → add_more_tests
-pass_rate >= 0.80                        → fix_failures_then_continue
-pass_rate < 0.80                         → major_fix_required
-```
-
-**Review 完成度路由**:
-```
-critical == 0 AND high <= 3  → complete_or_optional_fix
-critical > 0                  → mandatory_fix
-high > 3                      → recommended_fix
-```
-
-### 流转决策模式
-
-**plan_execute_test**:
-```
-plan → execute → test
-         ↓ (if test fail)
-    extract_failures → fix → test (max 3 iterations)
-         ↓ (if still fail)
-    manual_intervention
-```
-
-**iterative_improvement**:
-```
-execute → test → fix → test → ...
-    loop until: pass_rate >= 0.95 OR iterations >= 3
-```
-
-### 使用示例
-
-```javascript
-// 执行完成后，根据产出决定下一步
-const result = await execute(plan)
-
-// 提取意图流转到测试
-const testContext = extractIntent('execute_to_test', result)
-// testContext = { modified_files, test_scope, pending_verification }
-
-// 测试完成后，根据完成度决定路由
-const testResult = await test(testContext)
-const nextStep = evaluateCompletion('test', testResult)
-// nextStep = 'fix_failures_then_continue' if pass_rate = 0.85
-```
-
-## Reference
-
-- [command.json](command.json) - 命令元数据、Flow 定义、意图规则、Artifact Flow

.claude/skills/ccw/command.json

@@ -1,547 +0,0 @@
-{
-  "_metadata": {
-    "version": "2.0.0",
-    "description": "Unified CCW command index with capabilities, flows, and intent rules"
-  },
-
-  "capabilities": {
-    "explore": {
-      "description": "Codebase exploration and context gathering",
-      "commands": ["/workflow:init", "/workflow:tools:gather", "/memory:load"],
-      "agents": ["cli-explore-agent", "context-search-agent"]
-    },
-    "brainstorm": {
-      "description": "Multi-perspective analysis and ideation",
-      "commands": ["/workflow:brainstorm:auto-parallel", "/workflow:brainstorm:artifacts", "/workflow:brainstorm:synthesis"],
-      "roles": ["product-manager", "system-architect", "ux-expert", "data-architect", "api-designer"]
-    },
-    "plan": {
-      "description": "Task planning and decomposition",
-      "commands": ["/workflow:lite-plan", "/workflow:plan", "/workflow:tdd-plan", "/task:create", "/task:breakdown"],
-      "agents": ["cli-lite-planning-agent", "action-planning-agent"]
-    },
-    "verify": {
-      "description": "Plan and quality verification",
-      "commands": ["/workflow:action-plan-verify", "/workflow:tdd-verify"]
-    },
-    "execute": {
-      "description": "Task execution and implementation",
-      "commands": ["/workflow:lite-execute", "/workflow:execute", "/task:execute"],
-      "agents": ["code-developer", "cli-execution-agent", "universal-executor"]
-    },
-    "bugfix": {
-      "description": "Bug diagnosis and fixing",
-      "commands": ["/workflow:lite-fix"],
-      "agents": ["code-developer"]
-    },
-    "test": {
-      "description": "Test generation and execution",
-      "commands": ["/workflow:test-gen", "/workflow:test-fix-gen", "/workflow:test-cycle-execute"],
-      "agents": ["test-fix-agent"]
-    },
-    "review": {
-      "description": "Code review and quality analysis",
-      "commands": ["/workflow:review-session-cycle", "/workflow:review-module-cycle", "/workflow:review", "/workflow:review-fix"]
-    },
-    "issue": {
-      "description": "Issue lifecycle management - discover, accumulate, batch resolve",
-      "commands": ["/issue:new", "/issue:discover", "/issue:discover-by-prompt", "/issue:plan", "/issue:queue", "/issue:execute", "/issue:manage"],
-      "agents": ["issue-plan-agent", "issue-queue-agent", "cli-explore-agent"],
-      "lifecycle": {
-        "accumulation": {
-          "description": "任务完成后进行需求扩展、bug分析、测试发现",
-          "triggers": ["post-task review", "code review findings", "test failures"],
-          "commands": ["/issue:discover", "/issue:discover-by-prompt", "/issue:new"]
-        },
-        "batch_resolution": {
-          "description": "积累的issue集中规划和并行执行",
-          "flow": ["plan", "queue", "execute"],
-          "commands": ["/issue:plan --all-pending", "/issue:queue", "/issue:execute"]
-        }
-      }
-    },
-    "ui-design": {
-      "description": "UI design and prototyping",
-      "commands": ["/workflow:ui-design:explore-auto", "/workflow:ui-design:imitate-auto", "/workflow:ui-design:design-sync"],
-      "agents": ["ui-design-agent"]
-    },
-    "memory": {
-      "description": "Documentation and knowledge management",
-      "commands": ["/memory:docs", "/memory:update-related", "/memory:update-full", "/memory:skill-memory"],
-      "agents": ["doc-generator", "memory-bridge"]
-    }
-  },
-
-  "flows": {
-    "rapid": {
-      "name": "Rapid Iteration",
-      "description": "多模型协作分析 + 直接执行",
-      "complexity": ["low", "medium"],
-      "steps": [
-        { "command": "/workflow:lite-plan", "optional": false, "auto_continue": true },
-        { "command": "/workflow:lite-execute", "optional": false }
-      ],
-      "cli_hints": {
-        "explore_phase": { "tool": "gemini", "mode": "analysis", "trigger": "needs_exploration" },
-        "execution": { "tool": "codex", "mode": "write", "trigger": "complexity >= medium" }
-      },
-      "estimated_time": "15-45 min"
-    },
-    "full": {
-      "name": "Full Exploration",
-      "description": "头脑风暴 + 规划 + 执行",
-      "complexity": ["medium", "high"],
-      "steps": [
-        { "command": "/workflow:brainstorm:auto-parallel", "optional": false, "confirm_before": true },
-        { "command": "/workflow:plan", "optional": false },
-        { "command": "/workflow:action-plan-verify", "optional": true, "auto_continue": true },
-        { "command": "/workflow:execute", "optional": false }
-      ],
-      "cli_hints": {
-        "role_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true },
-        "execution": { "tool": "codex", "mode": "write", "trigger": "task_count >= 3" }
-      },
-      "estimated_time": "1-3 hours"
-    },
-    "coupled": {
-      "name": "Coupled Planning",
-      "description": "完整规划 + 验证 + 执行",
-      "complexity": ["high"],
-      "steps": [
-        { "command": "/workflow:plan", "optional": false },
-        { "command": "/workflow:action-plan-verify", "optional": false, "auto_continue": true },
-        { "command": "/workflow:execute", "optional": false },
-        { "command": "/workflow:review", "optional": true }
-      ],
-      "cli_hints": {
-        "pre_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
-        "execution": { "tool": "codex", "mode": "write", "trigger": "always" }
-      },
-      "estimated_time": "2-4 hours"
-    },
-    "bugfix": {
-      "name": "Bug Fix",
-      "description": "智能诊断 + 修复",
-      "complexity": ["low", "medium"],
-      "variants": {
-        "standard": [{ "command": "/workflow:lite-fix", "optional": false }],
-        "hotfix": [{ "command": "/workflow:lite-fix --hotfix", "optional": false }]
-      },
-      "cli_hints": {
-        "diagnosis": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
-        "fix": { "tool": "codex", "mode": "write", "trigger": "severity >= medium" }
-      },
-      "estimated_time": "10-30 min"
-    },
-    "issue": {
-      "name": "Issue Lifecycle",
-      "description": "发现积累 → 批量规划 → 队列优化 → 并行执行",
-      "complexity": ["medium", "high"],
-      "phases": {
-        "accumulation": {
-          "description": "项目迭代中持续发现和积累issue",
-          "commands": ["/issue:discover", "/issue:new"],
-          "trigger": "post-task, code-review, test-failure"
-        },
-        "resolution": {
-          "description": "集中规划和执行积累的issue",
-          "steps": [
-            { "command": "/issue:plan --all-pending", "optional": false },
-            { "command": "/issue:queue", "optional": false },
-            { "command": "/issue:execute", "optional": false }
-          ]
-        }
-      },
-      "cli_hints": {
-        "discovery": { "tool": "gemini", "mode": "analysis", "trigger": "perspective_analysis", "parallel": true },
-        "solution_generation": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true },
-        "batch_execution": { "tool": "codex", "mode": "write", "trigger": "always" }
-      },
-      "estimated_time": "1-4 hours"
-    },
-    "lite-lite-lite": {
-      "name": "Ultra-Lite Multi-CLI",
-      "description": "零文件 + 自动CLI选择 + 语义描述 + 直接执行",
-      "complexity": ["low", "medium"],
-      "steps": [
-        { "phase": "clarify", "description": "需求澄清 (AskUser if needed)" },
-        { "phase": "auto-select", "description": "任务分析 → 自动选择CLI组合" },
-        { "phase": "multi-cli", "description": "并行多CLI分析" },
-        { "phase": "decision", "description": "展示结果 → AskUser决策" },
-        { "phase": "execute", "description": "直接执行 (无中间文件)" }
-      ],
-      "vs_multi_cli_plan": {
-        "artifacts": "None vs IMPL_PLAN.md + plan.json + synthesis.json",
-        "session": "Stateless vs Persistent",
-        "cli_selection": "Auto-select based on task analysis vs Config-driven",
-        "iteration": "Via AskUser vs Via rounds/synthesis",
-        "execution": "Direct vs Via lite-execute",
-        "best_for": "Quick fixes, simple features vs Complex multi-step implementations"
-      },
-      "cli_hints": {
-        "analysis": { "tool": "auto", "mode": "analysis", "parallel": true },
-        "execution": { "tool": "auto", "mode": "write" }
-      },
-      "estimated_time": "10-30 min"
-    },
-    "multi-cli-plan": {
-      "name": "Multi-CLI Collaborative Planning",
-      "description": "ACE上下文 + 多CLI协作分析 + 迭代收敛 + 计划生成",
-      "complexity": ["medium", "high"],
-      "steps": [
-        { "command": "/workflow:multi-cli-plan", "optional": false, "phases": [
-          "context_gathering: ACE语义搜索",
-          "multi_cli_discussion: cli-discuss-agent多轮分析",
-          "present_options: 展示解决方案",
-          "user_decision: 用户选择",
-          "plan_generation: cli-lite-planning-agent生成计划"
-        ]},
-        { "command": "/workflow:lite-execute", "optional": false }
-      ],
-      "vs_lite_plan": {
-        "context": "ACE semantic search vs Manual file patterns",
-        "analysis": "Multi-CLI cross-verification vs Single-pass planning",
-        "iteration": "Multiple rounds until convergence vs Single round",
-        "confidence": "High (consensus-based) vs Medium (single perspective)",
-        "best_for": "Complex tasks needing multiple perspectives vs Straightforward implementations"
-      },
-      "agents": ["cli-discuss-agent", "cli-lite-planning-agent"],
-      "cli_hints": {
-        "discussion": { "tools": ["gemini", "codex", "claude"], "mode": "analysis", "parallel": true },
-        "planning": { "tool": "gemini", "mode": "analysis" }
-      },
-      "output": ".workflow/.multi-cli-plan/{session-id}/",
-      "estimated_time": "30-90 min"
-    },
-    "tdd": {
-      "name": "Test-Driven Development",
-      "description": "TDD规划 + 执行 + 验证",
-      "complexity": ["medium", "high"],
-      "steps": [
-        { "command": "/workflow:tdd-plan", "optional": false },
-        { "command": "/workflow:execute", "optional": false },
-        { "command": "/workflow:tdd-verify", "optional": false }
-      ],
-      "cli_hints": {
-        "test_strategy": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
-        "red_green_refactor": { "tool": "codex", "mode": "write", "trigger": "always" }
-      },
-      "estimated_time": "1-3 hours"
-    },
-    "ui": {
-      "name": "UI-First Development",
-      "description": "UI设计 + 规划 + 执行",
-      "complexity": ["medium", "high"],
-      "variants": {
-        "explore": [
-          { "command": "/workflow:ui-design:explore-auto", "optional": false },
-          { "command": "/workflow:ui-design:design-sync", "optional": false, "auto_continue": true },
-          { "command": "/workflow:plan", "optional": false },
-          { "command": "/workflow:execute", "optional": false }
-        ],
-        "imitate": [
-          { "command": "/workflow:ui-design:imitate-auto", "optional": false },
-          { "command": "/workflow:ui-design:design-sync", "optional": false, "auto_continue": true },
-          { "command": "/workflow:plan", "optional": false },
-          { "command": "/workflow:execute", "optional": false }
-        ]
-      },
-      "estimated_time": "2-4 hours"
-    },
-    "review-fix": {
-      "name": "Review and Fix",
-      "description": "多维审查 + 自动修复",
-      "complexity": ["medium"],
-      "steps": [
-        { "command": "/workflow:review-session-cycle", "optional": false },
-        { "command": "/workflow:review-fix", "optional": true }
-      ],
-      "cli_hints": {
-        "multi_dimension_review": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true },
-        "auto_fix": { "tool": "codex", "mode": "write", "trigger": "findings_count >= 3" }
-      },
-      "estimated_time": "30-90 min"
-    },
-    "docs": {
-      "name": "Documentation",
-      "description": "批量文档生成",
-      "complexity": ["low", "medium"],
-      "variants": {
-        "incremental": [{ "command": "/memory:update-related", "optional": false }],
-        "full": [
-          { "command": "/memory:docs", "optional": false },
-          { "command": "/workflow:execute", "optional": false }
-        ]
-      },
-      "estimated_time": "15-60 min"
-    }
-  },
-
-  "intent_rules": {
-    "bugfix": {
-      "priority": 1,
-      "variants": {
-        "hotfix": {
-          "patterns": ["hotfix", "urgent", "production", "critical", "emergency", "紧急", "生产环境", "线上"],
-          "flow": "bugfix.hotfix"
-        },
-        "standard": {
-          "patterns": ["fix", "bug", "error", "issue", "crash", "broken", "fail", "wrong", "修复", "错误", "崩溃"],
-          "flow": "bugfix.standard"
-        }
-      }
-    },
-    "issue_batch": {
-      "priority": 2,
-      "patterns": {
-        "batch": ["issues", "batch", "queue", "多个", "批量"],
-        "action": ["fix", "resolve", "处理", "解决"]
-      },
-      "require_both": true,
-      "flow": "issue"
-    },
-    "exploration": {
-      "priority": 3,
-      "patterns": ["不确定", "不知道", "explore", "研究", "分析一下", "怎么做", "what if", "探索"],
-      "flow": "full"
-    },
-    "ui_design": {
-      "priority": 4,
-      "patterns": ["ui", "界面", "design", "设计", "component", "组件", "style", "样式", "layout", "布局"],
-      "variants": {
-        "imitate": { "triggers": ["参考", "模仿", "像", "类似"], "flow": "ui.imitate" },
-        "explore": { "triggers": [], "flow": "ui.explore" }
-      }
-    },
-    "tdd": {
-      "priority": 5,
-      "patterns": ["tdd", "test-driven", "测试驱动", "先写测试", "test first"],
-      "flow": "tdd"
-    },
-    "review": {
-      "priority": 6,
-      "patterns": ["review", "审查", "检查代码", "code review", "质量检查"],
-      "flow": "review-fix"
-    },
-    "documentation": {
-      "priority": 7,
-      "patterns": ["文档", "documentation", "docs", "readme"],
-      "variants": {
-        "incremental": { "triggers": ["更新", "增量"], "flow": "docs.incremental" },
-        "full": { "triggers": ["全部", "完整"], "flow": "docs.full" }
-      }
-    },
-    "feature": {
-      "priority": 99,
-      "complexity_map": {
-        "high": "coupled",
-        "medium": "rapid",
-        "low": "rapid"
-      }
-    }
-  },
-
-  "complexity_indicators": {
-    "high": {
-      "threshold": 4,
-      "patterns": {
-        "architecture": { "keywords": ["refactor", "重构", "migrate", "迁移", "architect", "架构", "system", "系统"], "weight": 2 },
-        "multi_module": { "keywords": ["multiple", "多个", "across", "跨", "all", "所有", "entire", "整个"], "weight": 2 },
-        "integration": { "keywords": ["integrate", "集成", "api", "database", "数据库"], "weight": 1 },
-        "quality": { "keywords": ["security", "安全", "performance", "性能", "scale", "扩展"], "weight": 1 }
-      }
-    },
-    "medium": { "threshold": 2 },
-    "low": { "threshold": 0 }
-  },
-
-  "cli_tools": {
-    "gemini": {
-      "strengths": ["超长上下文", "深度分析", "架构理解", "执行流追踪"],
-      "triggers": ["分析", "理解", "设计", "架构", "诊断"],
-      "mode": "analysis"
-    },
-    "qwen": {
-      "strengths": ["代码模式识别", "多维度分析"],
-      "triggers": ["评估", "对比", "验证"],
-      "mode": "analysis"
-    },
-    "codex": {
-      "strengths": ["精确代码生成", "自主执行"],
-      "triggers": ["实现", "重构", "修复", "生成"],
-      "mode": "write"
-    }
-  },
-
-  "cli_injection_rules": {
-    "context_gathering": { "trigger": "file_read >= 50k OR module_count >= 5", "inject": "gemini --mode analysis" },
-    "pre_planning_analysis": { "trigger": "complexity === high", "inject": "gemini --mode analysis" },
-    "debug_diagnosis": { "trigger": "intent === bugfix AND root_cause_unclear", "inject": "gemini --mode analysis" },
-    "code_review": { "trigger": "step === review", "inject": "gemini --mode analysis" },
-    "implementation": { "trigger": "step === execute AND task_count >= 3", "inject": "codex --mode write" }
-  },
-
-  "artifact_flow": {
-    "_description": "定义工作流产出的格式、意图提取和流转规则",
-
-    "outputs": {
-      "/workflow:lite-plan": {
-        "artifact": "memory://plan",
-        "format": "structured_plan",
-        "fields": ["tasks", "files", "dependencies", "approach"]
-      },
-      "/workflow:plan": {
-        "artifact": ".workflow/{session}/IMPL_PLAN.md",
-        "format": "markdown_plan",
-        "fields": ["phases", "tasks", "dependencies", "risks", "test_strategy"]
-      },
-      "/workflow:multi-cli-plan": {
-        "artifact": ".workflow/.multi-cli-plan/{session}/",
-        "format": "multi_file",
-        "files": ["IMPL_PLAN.md", "plan.json", "synthesis.json"],
-        "fields": ["consensus", "divergences", "recommended_approach", "tasks"]
-      },
-      "/workflow:lite-execute": {
-        "artifact": "git_changes",
-        "format": "code_diff",
-        "fields": ["modified_files", "added_files", "deleted_files", "build_status"]
-      },
-      "/workflow:execute": {
-        "artifact": ".workflow/{session}/execution_log.json",
-        "format": "execution_report",
-        "fields": ["completed_tasks", "pending_tasks", "errors", "warnings"]
-      },
-      "/workflow:test-cycle-execute": {
-        "artifact": ".workflow/{session}/test_results.json",
-        "format": "test_report",
-        "fields": ["pass_rate", "failures", "coverage", "duration"]
-      },
-      "/workflow:review-session-cycle": {
-        "artifact": ".workflow/{session}/review_report.md",
-        "format": "review_report",
-        "fields": ["findings", "severity_counts", "recommendations"]
-      },
-      "/workflow:lite-fix": {
-        "artifact": "git_changes",
-        "format": "fix_report",
-        "fields": ["root_cause", "fix_applied", "files_modified", "verification_status"]
-      }
-    },
-
-    "intent_extraction": {
-      "plan_to_execute": {
-        "from": ["lite-plan", "plan", "multi-cli-plan"],
-        "to": ["lite-execute", "execute"],
-        "extract": {
-          "tasks": "$.tasks[] | filter(status != 'completed')",
-          "priority_order": "$.tasks | sort_by(priority)",
-          "files_to_modify": "$.tasks[].files | flatten | unique",
-          "dependencies": "$.dependencies",
-          "context_summary": "$.approach OR $.recommended_approach"
-        }
-      },
-      "execute_to_test": {
-        "from": ["lite-execute", "execute"],
-        "to": ["test-cycle-execute", "test-fix-gen"],
-        "extract": {
-          "modified_files": "$.modified_files",
-          "test_scope": "infer_from($.modified_files)",
-          "build_status": "$.build_status",
-          "pending_verification": "$.completed_tasks | needs_test"
-        }
-      },
-      "test_to_fix": {
-        "from": ["test-cycle-execute"],
-        "to": ["lite-fix", "review-fix"],
-        "condition": "$.pass_rate < 0.95",
-        "extract": {
-          "failures": "$.failures",
-          "error_messages": "$.failures[].message",
-          "affected_files": "$.failures[].file",
-          "suggested_fixes": "$.failures[].suggested_fix"
-        }
-      },
-      "review_to_fix": {
-        "from": ["review-session-cycle", "review-module-cycle"],
-        "to": ["review-fix"],
-        "condition": "$.severity_counts.critical > 0 OR $.severity_counts.high > 3",
-        "extract": {
-          "findings": "$.findings | filter(severity in ['critical', 'high'])",
-          "fix_priority": "$.findings | group_by(category) | sort_by(severity)",
-          "affected_files": "$.findings[].file | unique"
-        }
-      }
-    },
-
-    "completion_criteria": {
-      "plan": {
-        "required": ["has_tasks", "has_files"],
-        "optional": ["has_tests", "no_blocking_risks"],
-        "threshold": 0.8,
-        "routing": {
-          "complete": "proceed_to_execute",
-          "incomplete": "clarify_requirements"
-        }
-      },
-      "execute": {
-        "required": ["all_tasks_attempted", "no_critical_errors"],
-        "optional": ["build_passes", "lint_passes"],
-        "threshold": 1.0,
-        "routing": {
-          "complete": "proceed_to_test_or_review",
-          "partial": "continue_execution",
-          "failed": "diagnose_and_retry"
-        }
-      },
-      "test": {
-        "metrics": {
-          "pass_rate": { "target": 0.95, "minimum": 0.80 },
-          "coverage": { "target": 0.80, "minimum": 0.60 }
-        },
-        "routing": {
-          "pass_rate >= 0.95 AND coverage >= 0.80": "complete",
-          "pass_rate >= 0.95 AND coverage < 0.80": "add_more_tests",
-          "pass_rate >= 0.80": "fix_failures_then_continue",
-          "pass_rate < 0.80": "major_fix_required"
-        }
-      },
-      "review": {
-        "metrics": {
-          "critical_findings": { "target": 0, "maximum": 0 },
-          "high_findings": { "target": 0, "maximum": 3 }
-        },
-        "routing": {
-          "critical == 0 AND high <= 3": "complete_or_optional_fix",
-          "critical > 0": "mandatory_fix",
-          "high > 3": "recommended_fix"
-        }
-      }
-    },
-
-    "flow_decisions": {
-      "_description": "根据产出完成度决定下一步",
-      "patterns": {
-        "plan_execute_test": {
-          "sequence": ["plan", "execute", "test"],
-          "on_test_fail": {
-            "action": "extract_failures_and_fix",
-            "max_iterations": 3,
-            "fallback": "manual_intervention"
-          }
-        },
-        "plan_execute_review": {
-          "sequence": ["plan", "execute", "review"],
-          "on_review_issues": {
-            "action": "prioritize_and_fix",
-            "auto_fix_threshold": "severity < high"
-          }
-        },
-        "iterative_improvement": {
-          "sequence": ["execute", "test", "fix"],
-          "loop_until": "pass_rate >= 0.95 OR iterations >= 3",
-          "on_loop_exit": "report_status"
-        }
-      }
-    }
-  }
-}

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

@@ -0,0 +1,388 @@
+---
+name: command-guide
+description: Workflow command guide for Claude DMS3 (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 DMS3 workflow 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:
+   - Frame user's question precisely
+   - Specify required analysis depth
+   - Request structured comparison/synthesis
+   ```bash
+   gemini -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
+   " -m gemini-3-pro-preview-11-2025 --include-directories ~/.claude/skills/command-guide/reference
+   ```
+   Note: Use 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**: Claude DMS3 Team

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

@@ -0,0 +1,592 @@
+# 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

@@ -0,0 +1,410 @@
+# 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

@@ -0,0 +1,537 @@
+# 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

@@ -0,0 +1,242 @@
+# 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

@@ -0,0 +1,326 @@
+# 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