名称：超速驾驶描述：具有文件所有权划分的并行自动驾驶

超速驾驶技能

并行自动驾驶，通过生成多个工作器并分配非重叠文件集来实现最大速度。

概述

超速驾驶是自动驾驶的并行进化。它将您的任务分解为独立的可并行子任务，为每个工作器分配不重叠的文件集，并同时运行它们。

关键能力：

分解任务为并行安全组件
划分文件，具有独占所有权（无冲突）
生成最多20个并行工作器
协调进度通过TaskOutput
集成更改，顺序处理共享文件
验证完整系统完整性

**速度倍增：**对于适合的任务，比顺序自动驾驶快最多5倍。

使用方法

/oh-my-claudecode:ultrapilot <您的任务>
/oh-my-claudecode:up "构建一个全栈待办应用"
/oh-my-claudecode:ultrapilot 重构整个后端

魔术关键词

这些短语自动激活超速驾驶：

“ultrapilot”, “ultra pilot”
“并行构建”, “并行自动驾驶”
“集群构建”, “集群模式”
“快速并行”, “超快速”

何时使用

超速驾驶擅长：

多组件系统（前端 + 后端 + 数据库）
跨不同模块的独立功能添加
具有清晰模块边界的大型重构
并行测试文件生成
多服务架构

自动驾驶更适合：

单线程顺序任务
组件间重度依赖
需要持续集成检查的任务
单个模块中的小范围聚焦功能

架构

用户输入："构建一个全栈待办应用"
           |
           v
  [超速驾驶协调器]
           |
   分解 + 文件划分
           |
   +-------+-------+-------+-------+
   |       |       |       |       |
   v       v       v       v       v
[W-1]   [W-2]   [W-3]   [W-4]   [W-5]
后端   前端   数据库   API文档   测试
(src/  (src/   (src/    (docs/)  (tests/)
 api/)  ui/)    db/)
   |       |       |       |       |
   +---+---+---+---+---+---+---+---+
       |
       v
  [集成阶段]
  (共享文件：package.json, tsconfig.json等)
       |
       v
  [验证阶段]
  (完整系统测试)

阶段

阶段0：任务分析

**目标：**确定任务是否可并行

检查：

任务能否拆分为2+个独立子任务？
文件边界是否清晰？
依赖是否最小？

**输出：**执行/不执行决策（如果不适合，回退到自动驾驶）

阶段1：分解

**目标：**将任务分解为并行安全子任务

**代理：**架构师（Opus）

**方法：**AI驱动的任务分解

超速驾驶使用decomposer模块生成智能任务分解：

import {
  generateDecompositionPrompt,
  parseDecompositionResult,
  validateFileOwnership,
  extractSharedFiles
} from 'src/hooks/ultrapilot/decomposer';

// 1. 为架构师生成提示
const prompt = generateDecompositionPrompt(task, codebaseContext, {
  maxSubtasks: 5,
  preferredModel: 'sonnet'
});

// 2. 调用架构师代理
const response = await Task({
  subagent_type: 'oh-my-claudecode:architect',
  model: 'opus',
  prompt
});

// 3. 解析结构化结果
const result = parseDecompositionResult(response);

// 4. 验证无文件冲突
const { isValid, conflicts } = validateFileOwnership(result.subtasks);

// 5. 从子任务中提取共享文件
const finalResult = extractSharedFiles(result);

过程：

通过架构师代理分析任务需求
识别具有文件边界的独立组件
根据复杂性分配代理类型（executor-low/executor/executor-high）
映射子任务间的依赖（blockedBy）
生成并行执行组
识别共享文件（由协调器处理）

**输出：**结构化DecompositionResult：

{
  "subtasks": [
    {
      "id": "1",
      "description": "后端API路由",
      "files": ["src/api/routes.ts", "src/api/handlers.ts"],
      "blockedBy": [],
      "agentType": "executor",
      "model": "sonnet"
    },
    {
      "id": "2",
      "description": "前端组件",
      "files": ["src/ui/App.tsx", "src/ui/TodoList.tsx"],
      "blockedBy": [],
      "agentType": "executor",
      "model": "sonnet"
    },
    {
      "id": "3",
      "description": "连接前端到后端",
      "files": ["src/client/api.ts"],
      "blockedBy": ["1", "2"],
      "agentType": "executor-low",
      "model": "haiku"
    }
  ],
  "sharedFiles": [
    "package.json",
    "tsconfig.json",
    "README.md"
  ],
  "parallelGroups": [["1", "2"], ["3"]]
}

分解类型：

类型	描述	用例
`DecomposedTask`	具有id、文件、blockedBy、agentType、model的完整任务	智能工作器生成
`DecompositionResult`	具有子任务、sharedFiles、parallelGroups的完整结果	完整分解输出
`toSimpleSubtasks()`	转换为字符串数组以兼容旧版本	简单任务列表

阶段2：文件所有权划分

**目标：**为工作器分配独占文件集

规则：

独占所有权 - 没有文件在多个工作器集中
共享文件延迟处理 - 在集成中顺序处理
边界文件跟踪 - 跨边界导入的文件

数据结构： .omc/state/ultrapilot-ownership.json

{
  "sessionId": "ultrapilot-20260123-1234",
  "workers": {
    "worker-1": {
      "ownedFiles": ["src/api/routes.ts", "src/api/handlers.ts"],
      "ownedGlobs": ["src/api/**"],
      "boundaryImports": ["src/types.ts"]
    },
    "worker-2": {
      "ownedFiles": ["src/ui/App.tsx", "src/ui/TodoList.tsx"],
      "ownedGlobs": ["src/ui/**"],
      "boundaryImports": ["src/types.ts"]
    }
  },
  "sharedFiles": ["package.json", "tsconfig.json", "src/types.ts"],
  "conflictPolicy": "coordinator-handles"
}

阶段3：并行执行

**目标：**同时运行所有工作器

生成工作器：

// 伪代码
workers = [];
for (subtask in decomposition.subtasks) {
  workers.push(
    Task(
      subagent_type: "oh-my-claudecode:executor",
      model: "sonnet",
      prompt: `超速驾驶工作器 ${subtask.id}

您的独占文件所有权：${subtask.files}

任务：${subtask.description}

关键规则：
1. 只修改您所有权集中的文件
2. 如果需要修改共享文件，在输出中记录更改
3. 不要在所有权外创建新文件
4. 跟踪所有来自边界文件的导入

交付：代码更改 + 边界依赖列表`,
      run_in_background: true
    )
  );
}

监控：

轮询每个工作器的TaskOutput
跟踪完成状态
早期检测冲突
累积边界依赖

**最大工作器：**5（Claude Code限制）

阶段4：集成

**目标：**合并所有工作器更改并处理共享文件

过程：

收集输出 - 收集所有工作器交付物
检测冲突 - 检查意外重叠
处理共享文件 - 顺序更新package.json等
集成边界文件 - 合并类型定义、共享实用工具
解决导入 - 确保跨边界导入有效

**代理：**执行器（Sonnet）- 顺序处理

冲突解决：

如果工作器意外触及相同文件 → 手动合并
如果共享文件需要多次更改 → 顺序应用
如果边界文件更改 → 验证所有依赖工作器

阶段5：验证

**目标：**验证集成系统工作

检查（并行）：

构建 - 运行项目的构建命令
代码检查 - 运行项目的代码检查命令
类型检查 - 运行项目的类型检查命令
单元测试 - 所有测试通过
集成测试 - 跨组件测试

代理（并行）：

构建修复器（Sonnet）- 修复构建错误
架构师（Opus）- 功能完整性
安全审查员（Opus）- 跨组件漏洞

**重试策略：**最多3轮验证。如果失败持续，向用户提供详细错误报告。

状态管理

会话状态

位置： .omc/ultrapilot-state.json

{
  "sessionId": "ultrapilot-20260123-1234",
  "taskDescription": "构建一个全栈待办应用",
  "phase": "execution",
  "startTime": "2026-01-23T10:30:00Z",
  "decomposition": { /* 来自阶段1 */ },
  "workers": {
    "worker-1": {
      "status": "running",
      "taskId": "task-abc123",
      "startTime": "2026-01-23T10:31:00Z",
      "estimatedDuration": "5m"
    }
  },
  "conflicts": [],
  "validationAttempts": 0
}

文件所有权地图

位置： .omc/state/ultrapilot-ownership.json

跟踪哪个工作器拥有哪个文件（见阶段2示例）。

进度跟踪

位置： .omc/ultrapilot/progress.json

{
  "totalWorkers": 5,
  "completedWorkers": 3,
  "activeWorkers": 2,
  "failedWorkers": 0,
  "estimatedTimeRemaining": "2m30s"
}

配置

可选设置在.claude/settings.json中：

{
  "omc": {
    "ultrapilot": {
      "maxWorkers": 5,
      "maxValidationRounds": 3,
      "conflictPolicy": "coordinator-handles",
      "fallbackToAutopilot": true,
      "parallelThreshold": 2,
      "pauseAfterDecomposition": false,
      "verboseProgress": true
    }
  }
}

设置解释：

maxWorkers - 最大并行工作器（5是Claude Code限制）
maxValidationRounds - 验证重试尝试
conflictPolicy - “coordinator-handles"或"abort-on-conflict”
fallbackToAutopilot - 如果任务不可并行，自动切换到自动驾驶
parallelThreshold - 使用超速驾驶的最小子任务数（否则回退）
pauseAfterDecomposition - 在执行前与用户确认
verboseProgress - 显示详细工作器进度

取消

/oh-my-claudecode:cancel

或说：“stop”, “cancel ultrapilot”, “abort”

行为：

所有活跃工作器优雅终止
部分进度保存到状态文件
会话可以恢复

恢复

如果超速驾驶被取消或工作器失败：

/oh-my-claudecode:ultrapilot resume

恢复逻辑：

仅重启失败工作器
重用已完成工作器输出
从最后阶段继续

示例

示例1：全栈应用

/oh-my-claudecode:ultrapilot 使用React前端、Express后端和PostgreSQL数据库构建待办应用

工作器：

前端（src/client/）
后端（src/server/）
数据库（src/db/）
测试（tests/）
文档（docs/）

共享文件： package.json, docker-compose.yml, README.md

**持续时间：**约15分钟（相对于约75分钟顺序）

示例2：多服务重构

/oh-my-claudecode:up 重构所有服务以使用依赖注入

工作器：

认证服务
用户服务
支付服务
通知服务

共享文件： src/types/services.ts, tsconfig.json

**持续时间：**约8分钟（相对于约32分钟顺序）

示例3：测试覆盖率

/oh-my-claudecode:ultrapilot 为所有未测试模块生成测试

工作器：

API测试
UI组件测试
数据库测试
实用工具测试
集成测试

共享文件： jest.config.js, test-utils.ts

**持续时间：**约10分钟（相对于约50分钟顺序）

最佳实践

清晰模块边界 - 适用于代码分离良好的情况
最小共享状态 - 减少集成复杂性
信任分解 - 架构师知道什么是并行安全的
监控进度 - 检查.omc/ultrapilot/progress.json
早期审查冲突 - 不要等到集成

文件所有权策略

所有权类型

独占所有权：

工作器具有独占写入访问权限
没有其他工作器可以触及这些文件
工作器可以在拥有的目录中创建新文件

共享文件：

没有工作器具有独占访问权限
在集成阶段顺序处理
包括：package.json, tsconfig.json, 配置文件, 根README

边界文件：

可以被所有工作器读取
写入访问由使用分析确定
通常：类型定义、共享实用工具、接口

所有权检测算法

对于代码库中的每个文件：
  如果文件在shared_patterns（package.json, *.config.js）：
    → sharedFiles

  否则如果文件被2+个子任务模块导入：
    → boundaryFiles
    → 分配给最相关的工作器或延迟到共享

  否则如果文件在子任务目录中：
    → 分配给子任务工作器

  否则：
    → sharedFiles（安全默认）

共享文件模式

自动分类为共享：

package.json, package-lock.json
tsconfig.json, *.config.js, *.config.ts
.eslintrc.*, .prettierrc.*
README.md, CONTRIBUTING.md, LICENSE
Docker文件：Dockerfile, docker-compose.yml
CI文件：.github/**, .gitlab-ci.yml

冲突处理

冲突类型

意外重叠：

两个工作器修改了同一文件
**解决：**协调器合并并需要人工确认

共享文件争用：

多个工作器需要更新package.json
**解决：**在集成阶段顺序应用

边界文件冲突：

多个工作器需要的类型定义
**解决：**第一个工作器创建，其他导入

冲突策略

coordinator-handles（默认）：

协调器尝试自动合并
如果复杂，回退到用户

abort-on-conflict：

任何冲突立即取消超速驾驶
用户审查冲突报告
可以在手动修复后恢复

故障排除

分解失败？

任务可能耦合太紧
自动触发回退到自动驾驶
查看.omc/ultrapilot/decomposition.json获取详情

工作器挂起？

检查工作器日志在.omc/logs/ultrapilot-worker-N.log
取消并重启该工作器
可能表示文件所有权问题

集成冲突？

查看.omc/ultrapilot-state.json冲突数组
检查共享文件是否意外修改
如果需要，调整所有权规则

验证循环？

跨组件集成问题
查看边界导入
可能需要带完整上下文的顺序重试

太慢？

检查工作器是否真正独立
查看分解质量
考虑自动驾驶是否更快（高度依赖）

与自动驾驶的区别

特性	自动驾驶	超速驾驶
执行	顺序	并行（最多5倍快）
最适合	单线程任务	多组件系统
复杂性	较低	较高
速度	标准	3-5倍快（适合任务）
文件冲突	无	所有权划分
回退	无	可以回退到自动驾驶
设置	即时	分解阶段（约1-2分钟）

**经验法则：**如果任务有3+个独立组件，使用超速驾驶。否则，使用自动驾驶。

高级：自定义分解

您可以提供自定义分解文件以跳过阶段1：

位置： .omc/ultrapilot/custom-decomposition.json

{
  "subtasks": [
    {
      "id": "worker-auth",
      "description": "添加OAuth2认证",
      "files": ["src/auth/**", "src/middleware/auth.ts"],
      "dependencies": ["src/types/user.ts"]
    },
    {
      "id": "worker-db",
      "description": "添加用户表和迁移",
      "files": ["src/db/migrations/**", "src/db/models/user.ts"],
      "dependencies": []
    }
  ],
  "sharedFiles": ["package.json", "src/types/user.ts"]
}

然后运行：

/oh-my-claudecode:ultrapilot --custom-decomposition

完成时状态清理

重要：完成时删除状态文件 - 不要只设置active: false

当所有工作器成功完成时：

# 删除超速驾驶状态文件
rm -f .omc/state/ultrapilot-state.json
rm -f .omc/state/ultrapilot-ownership.json

未来增强

计划v4.1：

动态工作器缩放（从2个开始，如果需要则生成更多）
预测冲突检测（集成前分析）
工作器到工作器通信（用于罕见依赖）
推测执行（乐观并行）
从集成阶段恢复（如果验证失败）

计划v4.2：

多机器分布（如果Claude Code支持）
实时进度仪表板
工作器性能分析
分解策略自动调整

名称：超速驾驶 描述：具有文件所有权划分的并行自动驾驶

超速驾驶技能

概述

使用方法

魔术关键词

何时使用

架构

阶段

阶段0：任务分析

阶段1：分解

阶段2：文件所有权划分

阶段3：并行执行

阶段4：集成

阶段5：验证

状态管理

会话状态

文件所有权地图

进度跟踪

配置

取消

恢复

示例

示例1：全栈应用

示例2：多服务重构

示例3：测试覆盖率

最佳实践

文件所有权策略

所有权类型

所有权检测算法

共享文件模式

冲突处理

冲突类型

冲突策略

故障排除

与自动驾驶的区别

高级：自定义分解

完成时状态清理

未来增强

名称：超速驾驶描述：具有文件所有权划分的并行自动驾驶