Add unified command indices for CCW and CCW-Help with detailed capabilities, flows, and intent rules

- Introduced command.json for CCW-Help with 88 commands and 16 agents, covering essential workflows and memory management.
- Created command.json for CCW with comprehensive capabilities for exploration, planning, execution, bug fixing, testing, reviewing, and documentation.
- Defined complex flows for rapid iteration, full exploration, coupled planning, bug fixing, issue lifecycle management, and more.
- Implemented intent rules for bug fixing, issue batch processing, exploration, UI design, TDD, review, and documentation.
- Established CLI tools and injection rules to enhance command execution based on context and complexity.
This commit is contained in:
catlog22
2026-01-15 11:19:30 +08:00
parent f692834153
commit 95a7f05aa9
33 changed files with 3709 additions and 7263 deletions

View File

@@ -1,469 +1,352 @@
---
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(*)
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 Overview
## Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ CCW Orchestrator (Stateless + Requirement Analysis)
│ CCW Orchestrator (CLI-Enhanced + Requirement Analysis) │
├─────────────────────────────────────────────────────────────────┤
Input Analysis & Requirement Extraction
├─ Intent Classification (bugfix/feature/refactor/issue/...)
├─ Complexity Assessment (low/medium/high)
├─ Dimension Extraction (WHAT/WHERE/WHY/HOW)
├─ Clarity Scoring (0-3) with auto-clarification
└─ Constraint Extraction (time/scope/quality)
│ Workflow Selection (Decision Tree) │
│ ├─ 🐛 Bug? → lite-fix / lite-fix --hotfix │
│ ├─ ❓ Unclear? → clarify → brainstorm → plan → execute │
│ ├─ ⚡ Simple? → lite-plan → lite-execute │
│ ├─ 🔧 Complex? → plan → execute │
│ ├─ 📋 Issue? → discover → plan → queue → execute │
│ └─ 🎨 UI? → ui-design → plan → execute │
│ │
│ Execution Dispatch │
│ └─ SlashCommand("/workflow:xxx") or Task(agent) │
│ │
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
└─────────────────────────────────────────────────────────────────┘
```
## 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**: 发现 + 创建 + 规划 + 队列 + 批量执行
**Commands**:
- 完整链: `/issue:discover``/issue:new``/issue:plan``/issue:queue``/issue:execute`
- 快速链: `/issue:plan``/issue:queue``/issue:execute`
- 提示发现: `/issue:discover-by-prompt``/issue:plan``/issue:queue``/issue:execute`
**When to use**:
- 多个相关问题需要批量处理
- 长时间跨度的修复任务
- 需要优先级排序和冲突解决
- 安全审计、技术债务清理、GitHub Issues 批量导入
### 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' }
}
### 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
// 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'
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'
}
```
## Execution Flow
| Complexity | Flow |
|------------|------|
| high | `coupled` (plan → verify → execute) |
| medium/low | `rapid` (lite-plan → lite-execute) |
### Phase 1: Input Analysis
### 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
// Parse user input
const input = userInput.trim()
if (dimensions.clarity_score < 2) {
const questions = generateClarificationQuestions(dimensions)
// 生成问题:目标是什么? 范围是什么? 有什么约束?
AskUserQuestion({ questions })
}
```
// Check for explicit workflow request
**澄清问题类型**:
- 目标不明确 → "你想要对什么进行操作?"
- 范围不明确 → "操作的范围是什么?"
- 目的不明确 → "这个操作的主要目标是什么?"
- 复杂操作 → "有什么特殊要求或限制?"
## 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:')) {
// User explicitly requested a workflow, pass through
SlashCommand(input)
return
}
// Classify intent
const intent = classifyIntent(input)
// 2. Classify intent
const intent = classifyIntent(input) // See command.json intent_rules
console.log(`
## Intent Analysis
// 3. Select flow
const flow = selectFlow(intent) // See command.json flows
**Input**: ${input.substring(0, 100)}...
**Classification**: ${intent.type}
**Complexity**: ${intent.complexity || 'N/A'}
**Recommended Workflow**: ${intent.workflow}
`)
```
// 4. Create todos with CCW prefix
createWorkflowTodos(flow)
### 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
}
// 5. Dispatch first command
SlashCommand(flow.steps[0].command, args: input)
```
## CLI Tool Integration
CCW **隐式调用** CLI 工具以获得三大优势
CCW 在特定条件下自动注入 CLI 调用
### 1. Token 效率 (Context Efficiency)
| Condition | CLI Inject |
|-----------|------------|
| 大量代码上下文 (≥50k chars) | `gemini --mode analysis` |
| 高复杂度任务 | `gemini --mode analysis` |
| Bug 诊断 | `gemini --mode analysis` |
| 多任务执行 (≥3 tasks) | `codex --mode write` |
CLI 工具在单独进程中运行,可以处理大量代码上下文而不消耗主会话 token
### CLI Enhancement Phases
| 场景 | 触发条件 | 自动注入 |
|------|----------|----------|
| 大量代码上下文 | 文件读取 ≥ 50k 字符 | `gemini --mode analysis` |
| 多模块分析 | 涉及 ≥ 5 个模块 | `gemini --mode analysis` |
| 代码审查 | review 步骤 | `gemini --mode analysis` |
**Phase 1.5: CLI-Assisted Classification**
### 2. 多模型视角 (Multi-Model Perspectives)
当规则匹配不明确时,使用 CLI 辅助分类:
不同模型有不同优势CCW 根据任务类型自动选择:
| 触发条件 | 说明 |
|----------|------|
| matchCount < 2 | 多个意图模式匹配 |
| complexity = high | 高复杂度任务 |
| input > 100 chars | 长输入需要语义理解 |
| Tool | 核心优势 | 最佳场景 | 触发关键词 |
|------|----------|----------|------------|
| Gemini | 超长上下文、深度分析、架构理解、执行流追踪 | 代码库理解、架构评估、根因分析 | "分析", "理解", "设计", "架构", "诊断" |
| Qwen | 代码模式识别、多维度分析 | Gemini备选、第二视角验证 | "评估", "对比", "验证" |
| Codex | 精确代码生成、自主执行、数学推理 | 功能实现、重构、测试 | "实现", "重构", "修复", "生成", "测试" |
**Phase 2.5: CLI-Assisted Action Planning**
### 3. 增强能力 (Enhanced Capabilities)
高复杂度任务的工作流优化:
#### Debug 能力增强
```
触发条件: intent === 'bugfix' AND root_cause_unclear
自动注入: gemini --mode analysis (执行流追踪)
用途: 假设驱动调试、状态机错误诊断、并发问题排查
```
| 触发条件 | 说明 |
|----------|------|
| complexity = high | 高复杂度任务 |
| steps >= 3 | 多步骤工作流 |
| input > 200 chars | 复杂需求描述 |
#### 规划能力增强
```
触发条件: complexity === 'high' OR intent === 'exploration'
自动注入: gemini --mode analysis (架构分析)
用途: 复杂任务先用CLI分析获取多模型视角
```
CLI 可返回建议:`use_default` | `modify` (调整步骤) | `upgrade` (升级工作流)
### 隐式注入规则 (Implicit Injection Rules)
## Continuation Commands
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` | 执行下一步 |
| 命令 | 作用 |
|------|------|
| `continue` | 继续执行下一步 |
| `skip` | 跳过当前步骤 |
| `abort` | 止工作流 |
| `/workflow:*` | 执行指定命令 |
| `abort` | 止工作流 |
| `/workflow:*` | 切换到指定命令 |
| 自然语言 | 重新分析意图 |
## Reference Documents
## Workflow Flow Details
| 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) | 意图分类规范 |
| [specs/requirement-analysis.md](specs/requirement-analysis.md) | 需求分析规范 (NEW) |
| [specs/output-templates.md](specs/output-templates.md) | 输出格式模板 (NEW) |
| [WORKFLOW_DECISION_GUIDE.md](/WORKFLOW_DECISION_GUIDE.md) | 工作流决策指南 |
### Issue Workflow (两阶段生命周期)
## Examples
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`
### Example 1: Bug Fix
```
User: 用户登录失败,返回 401 错误
CCW: Intent=bugfix, Workflow=lite-fix
→ /workflow:lite-fix "用户登录失败,返回 401 错误"
任务完成 → discover → 积累 issue → ... → plan all → queue → parallel execute
↑ ↓
└────── 迭代循环 ───────┘
```
### Example 2: New Feature (Simple)
### 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)
流转到下一步时,自动提取关键信息:
```
User: 添加用户头像上传功能
CCW: Intent=feature, Complexity=low, Workflow=lite-plan→lite-execute
→ /workflow:lite-plan "添加用户头像上传功能"
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
```
### Example 3: Complex Refactoring
### 完成度判断
**Test 完成度路由**:
```
User: 重构整个认证模块,迁移到 OAuth2
CCW: Intent=feature, Complexity=high, Workflow=plan→verify→execute
→ /workflow:plan "重构整个认证模块,迁移到 OAuth2"
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
```
### Example 4: Exploration
**Review 完成度路由**:
```
User: 我想优化系统性能,但不知道从哪入手
CCW: Intent=exploration, Workflow=brainstorm→plan→execute
→ /workflow:brainstorm:auto-parallel "探索系统性能优化方向"
critical == 0 AND high <= 3 → complete_or_optional_fix
critical > 0 → mandatory_fix
high > 3 → recommended_fix
```
### Example 5: Multi-Model Collaboration
### 流转决策模式
**plan_execute_test**:
```
User: 用 gemini 分析现有架构,然后让 codex 实现优化
CCW: Detects tool preferences, executes in sequence
→ Gemini CLI (analysis) → Codex CLI (implementation)
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