Faithful Task Executor

Faithful Task Executor - 任务规则忠实执行器

确保 AI 任务始终按初始要求执行，减少幻觉和偏差 - 让每个子任务都"记住"原始规则

核心特性

规则持久化:

• 初始要求写入规则文件，贯穿任务全生命周期
• 每个执行阶段强制读取并校验规则
• 禁止子代理添加不存在的要求或规则

并发任务编排:

• 多子代理并行执行时，规则文件自动传递给每个子代理
• 子任务启动前必须确认已读取并理解规则
• 支持任务依赖关系和并行度控制

执行一致性校验:

• 每个阶段输出前进行规则符合性检查
• 发现偏差立即纠正并记录
• 最终交付物必须通过规则校验

防幻觉机制:

• 规则明确禁止的行为列表
• 模糊要求澄清机制
• 输出内容溯源验证

激活条件

当用户提到以下关键词时激活：

• "执行这个任务"
• "处理这个工作"
• "完成以下要求"
• "按规则执行"
• "多步骤任务"
• "并发处理"
• "子代理协作"
• "减少执行偏差"
• "避免 AI 幻觉"
• "严格按规则来"

任务执行流程

Step 0: 规则提取与固化

目的: 从用户输入中提取明确规则，写入规则文件

# 规则提取步骤

1. **识别明确要求**
   - 列出用户明确提出的所有要求
   - 标注优先级（必须/应该/可以）
   - 识别禁止事项

2. **识别隐含约束**
   - 任务类型决定的默认约束
   - 领域最佳实践
   - 标注"隐含"标签

3. **生成规则文件**
   - 路径：`.task-rules/rules.md`
   - 格式：结构化 Markdown
   - 版本：初始版本 v1.0

4. **用户确认**
   - 展示提取的规则
   - 询问是否有遗漏或错误
   - 确认后锁定规则

规则文件模板:

# 任务规则说明书

## 任务概述
- **任务名称**: {任务名称}
- **任务类型**: {编码/文档/分析/设计/其他}
- **优先级**: {高/中/低}
- **创建时间**: {时间戳}

## 明确要求（必须遵守）

### 功能性要求
1. {要求 1}
2. {要求 2}
3. ...

### 非功能性要求
1. {性能要求}
2. {质量要求}
3. {格式要求}

### 禁止事项
- ❌ {禁止行为 1}
- ❌ {禁止行为 2}
- ❌ {禁止行为 3}

## 隐含约束（基于任务类型）

1. {隐含约束 1}
2. {隐含约束 2}

## 模糊澄清

以下要求需要进一步明确：
- ❓ {模糊要求 1} → 建议澄清问题：{问题}
- ❓ {模糊要求 2} → 建议澄清问题：{问题}

## 规则版本
- v1.0: 初始版本 ({时间})
- 任何规则变更必须经用户确认

## 规则确认
- [ ] 用户已确认规则完整准确
- [ ] 所有子代理已读取并理解规则

Step 1: 任务分解与规划

目的: 将复杂任务分解为可执行的子任务

# 任务分解步骤

1. **识别任务阶段**
   - 阶段 1: {阶段名称} - {目标}
   - 阶段 2: {阶段名称} - {目标}
   - ...

2. **识别子任务**
   - 子任务 1.1: {描述} - {依赖} - {预计耗时}
   - 子任务 1.2: {描述} - {依赖} - {预计耗时}
   - ...

3. **确定并发策略**
   - 可并行：子任务列表
   - 必须串行：子任务列表（标注原因）
   - 最大并行度：{数字}

4. **分配规则文件**
   - 每个子任务必须附带规则文件路径
   - 子代理启动前确认已读取规则

任务规划模板:

# 任务执行计划

## 任务概览
- **总任务**: {任务描述}
- **预计总耗时**: {时间}
- **最大并行度**: {数字}

## 阶段划分

### 阶段 1: {阶段名称}
- **目标**: {阶段目标}
- **子任务**:
  - [ ] 子任务 1.1: {描述}
    - 依赖：无
    - 预计：10 分钟
    - 规则文件：`.task-rules/rules.md`
  - [ ] 子任务 1.2: {描述}
    - 依赖：子任务 1.1
    - 预计：15 分钟
    - 规则文件：`.task-rules/rules.md`

### 阶段 2: {阶段名称}
...

## 并发策略
- **可并行组**: [子任务 1.1, 子任务 2.1, ...]
- **必须串行**: [子任务 1.2 → 子任务 2.2 → ...]
- **串行原因**: {数据依赖/资源冲突/规则要求}

## 规则传递
- 规则文件路径：`.task-rules/rules.md`
- 每个子代理启动前必须确认：
  - [ ] 已读取规则文件
  - [ ] 理解所有明确要求
  - [ ] 理解所有禁止事项
  - [ ] 承诺不添加额外规则

Step 2: 子代理执行（带规则校验）

目的: 子代理执行任务，确保遵循规则

子代理任务模板:

# 子代理任务：{子任务名称}

## 任务信息
- **子代理 ID**: {label}
- **任务描述**: {详细描述}
- **预计耗时**: {时间}
- **超时时间**: {时间}

## 规则确认（⚠️ 必须完成）

**在开始执行前，请确认**:

1. **已读取规则文件**
   - 路径：`.task-rules/rules.md`
   - 读取时间：{时间戳}
   - [ ] 确认已完整读取

2. **理解明确要求**
   - [ ] 功能性要求：{列出相关的要求}
   - [ ] 非功能性要求：{列出相关的要求}
   - [ ] 禁止事项：{列出相关的禁止项}

3. **承诺遵守规则**
   - [ ] 不添加规则中不存在的要求
   - [ ] 不忽略规则中的禁止事项
   - [ ] 如有模糊之处，先询问再执行

## 执行要求

1. **阶段性校验**
   - 每完成 25% 进度，回顾规则文件
   - 输出中间结果前，检查是否符合规则
   - 发现规则冲突，立即暂停并报告

2. **输出规范**
   - 输出内容必须可溯源到规则
   - 如添加额外内容，必须标注"超出规则范围"
   - 最终输出前进行规则符合性自检

3. **异常处理**
   - 遇到规则未覆盖的情况：暂停并询问
   - 发现规则内部矛盾：报告并等待澄清
   - 无法按要求执行：说明原因并提供替代方案

## 返回格式

```json
{
  "subtaskId": "{ID}",
  "status": "completed|partial|failed|blocked",
  "ruleCompliance": {
    "allRulesFollowed": true,
    "clarifications": [],
    "deviations": []
  },
  "output": {...},
  "artifacts": ["文件路径列表"]
}

---

### Step 3: 规则符合性校验

**目的**: 每个阶段输出前进行规则校验

**校验清单**:

```markdown
# 规则符合性校验清单

## 基本要求校验
- [ ] 所有明确要求已满足
- [ ] 所有禁止事项已避免
- [ ] 输出格式符合要求

## 防幻觉校验
- [ ] 所有陈述可溯源到输入或规则
- [ ] 未添加不存在的要求
- [ ] 未假设未提供的信息
- [ ] 模糊处理已标注

## 一致性校验
- [ ] 与前期输出无矛盾
- [ ] 术语使用一致
- [ ] 逻辑自洽

## 质量校验
- [ ] 输出完整无遗漏
- [ ] 无明显错误
- [ ] 符合领域最佳实践

## 校验结果
- **校验通过**: ✅ / ❌
- **发现问题**: {列表}
- **纠正措施**: {措施}
- **校验者**: {AI/用户}
- **校验时间**: {时间戳}

Step 4: 任务汇总与交付

目的: 汇总所有子任务结果，进行最终校验

# 任务汇总报告

## 任务概览
- **任务名称**: {名称}
- **开始时间**: {时间}
- **完成时间**: {时间}
- **总耗时**: {时间}

## 子任务完成情况

| 子任务 | 状态 | 耗时 | 规则符合性 |
|--------|------|------|------------|
| 1.1 | ✅ 完成 | 8 分钟 | ✅ 通过 |
| 1.2 | ✅ 完成 | 12 分钟 | ✅ 通过 |
| ... | ... | ... | ... |

## 规则符合性总结

### 已满足的要求
1. {要求 1} - {证据}
2. {要求 2} - {证据}
3. ...

### 未满足的要求（如有）
1. {要求} - {原因} - {替代方案}

### 禁止事项遵守情况
- ✅ 所有禁止事项均已避免

### 规则变更（如有）
- {时间}: {变更内容} - {用户确认：是/否}

## 交付物清单
1. {交付物 1} - {路径}
2. {交付物 2} - {路径}
3. ...

## 质量声明
- [ ] 所有输出已通过规则符合性校验
- [ ] 无 AI 幻觉内容
- [ ] 无额外添加的要求
- [ ] 所有假设已标注

## 用户确认
- [ ] 用户已验收交付物
- [ ] 用户对执行过程满意
- [ ] 任务正式关闭

防幻觉机制

1. 规则明确化

**要求**: "代码要高效"

❌ 模糊处理：自行判断什么是"高效"
✅ 正确处理：询问澄清
  - "高效"具体指什么？
  - 时间复杂度要求？
  - 空间复杂度要求？
  - 有无性能基准？

2. 禁止事项清单

**任务执行期间禁止**:

- ❌ 添加规则中未提及的功能
- ❌ 假设未提供的数据或信息
- ❌ 忽略明确的禁止事项
- ❌ 使用规则禁止的技术栈
- ❌ 超出任务范围的优化
- ❌ 未经验证的"最佳实践"

3. 输出溯源

**输出内容必须标注来源**:

- ✅ "根据规则第 3 条要求，..."
- ✅ "基于用户提供的数据，..."
- ✅ "假设 X（未验证），建议确认"
- ❌ "我认为应该..."（无依据）

4. 模糊澄清

**发现模糊要求时的处理流程**:

1. 识别模糊点
2. 提出具体澄清问题
3. 等待用户确认
4. 将澄清结果写入规则文件
5. 继续执行

示例:
- 模糊要求："界面要美观"
- 澄清问题：
  - 有无设计风格参考？
  - 有无颜色偏好？
  - 有无布局要求？

并发任务编排

子代理分片策略

# 并发配置
concurrency:
  max_parallel: 5              # 最大并行子代理数
  rule_propagation: true       # 规则自动传递
  pre_execution_check: true    # 执行前规则确认
  
# 任务分配
task_allocation:
  strategy: "round_robin"      # 或 "load_balanced"
  rule_attachment: "mandatory" # 规则必须附带
  
# 一致性保障
consistency:
  periodic_rule_review: true   # 定期规则回顾
  cross_validation: true       # 子任务间交叉校验
  conflict_detection: true     # 冲突检测

规则传递机制

**子代理启动流程**:

1. 创建子代理会话
2. 传递规则文件路径
3. 子代理读取规则文件
4. 子代理确认理解规则
5. 开始执行任务

**确认模板**:

子代理 {label} 规则确认:

• 已读取规则文件：.task-rules/rules.md
• 理解所有明确要求
• 理解所有禁止事项
• 承诺不添加额外规则
• 发现模糊将先询问

确认时间：{时间戳}

使用示例

示例 1: 代码生成任务

用户：执行代码生成任务

要求:
1. 生成一个用户登录 API（Node.js + Express）
2. 使用 JWT 认证
3. 密码必须加密存储
4. 不要使用第三方登录
5. 代码要有注释

AI: 收到！启动 Faithful Task Executor 流程：

Step 0: 规则提取与固化
✅ 已生成规则文件：.task-rules/rules.md

## 明确要求
1. 生成用户登录 API
2. 技术栈：Node.js + Express
3. 认证方式：JWT
4. 密码存储：加密（bcrypt/argon2）
5. 代码注释：必须
6. 禁止事项：不使用第三方登录

请确认规则是否完整准确？(y/n)

用户：y

AI: 规则已锁定，开始执行...

Step 1: 任务分解
- 子任务 1: 项目结构搭建
- 子任务 2: 用户模型定义
- 子任务 3: 登录 API 实现
- 子任务 4: JWT 中间件配置
- 子任务 5: 密码加密工具

Step 2: 子代理执行（每个子代理已确认规则）
...

Step 3: 规则符合性校验
✅ 所有要求已满足
✅ 无第三方登录代码
✅ 密码已加密
✅ 代码有注释

Step 4: 任务交付
✅ 完成！交付物：
- src/controllers/authController.js
- src/middleware/jwtMiddleware.js
- src/utils/passwordUtil.js
- README.md

示例 2: 文档编写任务

用户：编写产品文档

要求:
1. 文档要简洁明了
2. 不要超过 2000 字
3. 包含使用示例
4. 不要使用技术术语
5. 面向非技术用户

AI: 收到！启动 Faithful Task Executor 流程：

Step 0: 规则提取
...

规则确认:
- 字数限制：≤2000 字
- 语言风格：简洁明了，无技术术语
- 必须内容：使用示例
- 目标读者：非技术用户
- 禁止：技术术语、冗长解释

用户：确认

AI: 开始执行...

Step 3: 规则符合性校验
- 字数检查：1850 字 ✅
- 技术术语检查：0 个 ✅
- 使用示例：包含 3 个 ✅
- 语言风格：简洁 ✅

✅ 完成！

示例 3: 多子代理并发任务

用户：分析这个项目的代码质量

要求:
1. 分析所有 Java 文件
2. 检查代码规范
3. 检查潜在 bug
4. 不要修改代码
5. 生成报告

AI: 收到！启动 Faithful Task Executor 流程：

Step 0: 规则固化
...

Step 1: 任务分解（并发策略）
- 子代理 1: 分析 src/main/java/com/api/ (15 文件)
- 子代理 2: 分析 src/main/java/com/service/ (20 文件)
- 子代理 3: 分析 src/main/java/com/domain/ (18 文件)
- 子代理 4: 汇总报告

每个子代理已确认规则：
- ✅ 只读分析，不修改代码
- ✅ 检查代码规范
- ✅ 检查潜在 bug
- ✅ 生成报告

Step 2: 并发执行（4 个子代理并行）
...

Step 4: 汇总交付
✅ 完成！生成代码质量报告 (45KB)

配置项

在 TOOLS.md 中添加：

### Faithful Task Executor - 任务规则忠实执行器

- 规则文件路径：`.task-rules/rules.md`
- 执行前规则确认：强制
- 阶段性规则回顾：每 25% 进度
- 模糊澄清机制：启用
- 输出溯源要求：强制
- 子代理规则传递：自动
- 并发最大并行：5 子代理
- 规则变更流程：用户确认

相关文件

• 规则文件模板：templates/rules-template.md
• 任务计划模板：templates/task-plan-template.md
• 校验清单模板：templates/checklist-template.md
• 子代理任务模板：templates/subagent-task-template.md

版本