feat(skills): add CCW orchestrator and refactor command-guide to ccw-help

CCW Skill (new):
- Stateless workflow orchestrator with intent classification
- 6 workflow combinations: rapid, full, coupled, bugfix, issue, ui
- External configuration: intent-rules.json, workflow-chains.json
- Implicit CLI tool injection (Gemini/Qwen/Codex)
- TODO tracking integration for workflow progress

CCW-Help Skill (refactored from command-guide):
- Renamed command-guide → ccw-help
- Removed reference folder duplication
- Source paths now relative from index/ (../../../commands/...)
- Added all-agents.json index
- Simplified SKILL.md following CCW pattern

.claude/skills/ccw/SKILL.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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