Compare commits

...

10 Commits

Author SHA1 Message Date
cfdaily d98fae007f docs: §21 handler 注册后 E2E 验证报告
CI / lint (pull_request) Failing after 8s
CI / test (pull_request) Has been skipped
CI / notify-on-failure (pull_request) Successful in 3s
Mail/Toolchain 核心流程全部通过:
- Mail: inform auto-working → auto-done 
- Toolchain Issue 指派: webhook → Mail 
- Toolchain PR Review: webhook → Review 请求 → Review 结果 
- CI 失败重复 Mail 问题确认(org+repo webhook 双触发,已知)

Task review 路径待明天验证。
2026-06-11 08:08:20 +08:00
cfdaily 3c30a9b135 fix: task_handler SKILL_BASE_PATH 硬编码改为环境变量
与 bootstrap.py 保持一致,支持 MOZI_SKILL_PATH 环境变量覆盖。
默认值不变。
2026-06-11 08:08:20 +08:00
cfdaily 6bb0596e6d fix: dispatcher _legacy_on_complete 闭包内删除错误的重复 import
get_connection 已在文件顶部 L22 import(from src.blackboard.db),
闭包内 L258 错误地 from src.daemon.db import(模块不存在),
会触发 ImportError 被 try/except 吞掉导致 review verdict 逻辑不生效。

司马懿 review 发现。
2026-06-11 08:08:20 +08:00
cfdaily 25863634c2 fix: v3.0→HEAD review 修复 — handler 注册 + review verdict + skill 全文注入
基于庞统+司马懿背靠背 review,修复 6 个问题:

P0 致命:
- A1: _legacy_on_complete 补回 review verdict 处理(approved→done,非 approved→@mention assignee)
- A2: 添加 TaskTypeRegistry.register() 启动初始化(注册 Task/Mail/Toolchain handler)

P1 中等:
- B11-1: RoleSkillSection 从索引提示改为全文注入(对齐设计 §2.3 + BootstrapBuilder 行为)
- A8: retry prompt is_mail 硬编码改走 TaskTypeRegistry handler 判断

P2 低:
- _mail_* 4 个方法添加 DEPRECATED 注释
- ticker.py handler check_completion 代码块缩进对齐(28→24 空格)

测试:394 passed, 0 failed
Review reports: docs/design/review-v3-vs-head-{pangtong,simayi}.md
2026-06-11 08:08:20 +08:00
pangtong-fujunshi 09971b555a Merge pull request 'feat: Step 5 引擎接入 — dispatcher/spawner/ticker → handler 统一路由 + H1-H3/S3/D1/D2/D5 修复' (#26) from feat/step5-engine-integration into main
Deploy / ci (push) Failing after 7s
Deploy / deploy (push) Has been skipped
Deploy / notify-deploy-failure (push) Successful in 1s
2026-06-10 22:39:03 +08:00
cfdaily ce1b0902dd fix: S1 handler display_name + S2 import 移顶部 + W1 注释
CI / lint (pull_request) Failing after 7s
CI / test (pull_request) Has been skipped
CI / notify-on-failure (pull_request) Successful in 3s
- S1: vp_name 硬编码字典 → handler.display_name 属性
- S2: ticker/spawner 中 TaskTypeRegistry 局部 import → 移文件顶部
- W1: TaskHandler executor verify 失败不调 on_failure 加注释说明
2026-06-10 22:38:55 +08:00
cfdaily 8d72a1fa19 feat: Step 5 引擎接入 + H1-H3/S3 修复 + 审计 D1/D2/D5 修复
CI / lint (pull_request) Failing after 7s
CI / test (pull_request) Has been skipped
CI / notify-on-failure (pull_request) Successful in 3s
引擎接入(dispatcher/spawner/ticker → handler 统一路由):
- dispatcher: guardrail/on_checks_passed/on_complete → handler 查询
- spawner: _build_prompt/_build_api_section → handler.build_prompt
- ticker: 虚拟项目扫描/assignee/claimed/review/幻觉门控 → handler 判断

Handler 缺陷修复:
- H1: _mark_task_status 加 3 次重试(防 DB 锁)
- H2: review @mention 加 comment_type='review'
- H3: review 非 approved 保持 review 状态(不标 working)
- S3: 通知链接改 Gitea(PR/Issue/Commit)

审计修复:
- D1: pre_spawn 返回值未检查 → 加 if not 抛 RuntimeError
- D2: PromptContext 缺 from_agent/mail_type → 从 must_haves 解析
- D5: _check_reply 查错表 → 恢复查 tasks 表找 in_reply_to

旧方法保留未删(deprecated),确认稳定后再清理。
2026-06-10 22:33:03 +08:00
pangtong-fujunshi 2c970557c8 Merge pull request 'feat: Step 2-4 — Task/Mail/Toolchain Handlers + 11 PromptSections + BaseTaskHandler' (#25) from feat/task-type-handlers-step2-4 into main
Deploy / ci (push) Failing after 7s
Deploy / deploy (push) Has been skipped
Deploy / notify-deploy-failure (push) Successful in 1s
2026-06-10 21:47:03 +08:00
cfdaily 4a4e99f738 fix: S1-S3 review suggestions — type annotations unified, urllib replaces curl, rich notification content
CI / lint (pull_request) Failing after 6s
CI / test (pull_request) Has been skipped
CI / notify-on-failure (pull_request) Successful in 2s
2026-06-10 21:44:47 +08:00
cfdaily 1b0007f244 feat: Step 2-4 Task/Mail/Toolchain handlers + PromptSections + BaseTaskHandler
CI / lint (pull_request) Failing after 6s
CI / test (pull_request) Has been skipped
CI / notify-on-failure (pull_request) Successful in 0s
- base_task_handler.py: 基类统一4步流程(crash→verify→mark→notify)
- task_handler.py: 5 PromptSections + 三信号验证 + review流程
- mail_handler.py: 3 PromptSections + inform/request区分 + 基类统一流程
- toolchain_handler.py: 3 PromptSections + 模板引擎渲染 + Mail API通知
- 背靠背设计-编码一致性检查通过(4严重已修/6轻微保留)
2026-06-10 20:45:06 +08:00
13 changed files with 2686 additions and 142 deletions
+102
View File
@@ -0,0 +1,102 @@
# §21. Handler 注册后 E2E 验证
> 日期:2026-06-11
> 状态:已完成 ✅
> 目标:验证 Task 五层架构重构(Step 2-5+ review 修复后,Mail/Toolchain 路径端到端工作
## 前置条件
- Daemon 版本:commit 83694ad(含 handler 注册 + import 修复 + SKILL_BASE_PATH 修复)
- Handler 注册日志:
```
Registered task type handler: task (virtual_project=None)
Registered task type handler: mail (virtual_project=_mail)
Registered task type handler: toolchain (virtual_project=_toolchain)
```
- Gitea org webhook (ID=28):姜维启用,事件订阅含 issues/pull_request/pull_request_review 等 16 个事件
- 测试仓库:sanguo/sanguo_moziplus_v2
## 验证结果
### 一、Mail Handler(✅ 全部通过)
| # | 步骤 | 验证点 | 结果 | Mail ID |
|---|------|--------|------|---------|
| 1 | 发 inform 邮件给 zhangfei-dev | ticker 发现 `_mail` 虚拟项目 | ✅ `handler auto-working` | mail-1781106713261 |
| 2 | zhangfei-dev 回复 | handler verify (inform_auto) → done | ✅ `verify passed (inform_auto), marked done` | — |
| 3 | 回复邮件给 pangtong | handler auto-working + done | ✅ `verify passed (inform_auto), marked done` | mail-1781106736388 |
**关键验证**
- ✅ `virtual_projects()` 返回 `["_mail", "_toolchain"]`(注册前为空)
- ✅ handler `pre_spawn` (auto-working) 生效,不是旧的 `_mail_auto_working`
- ✅ guardrail 跳过 `_mail``is_handler_task=True`
- ✅ inform 类型自动标 donerequest 类型检查回复
### 二、Toolchain — Issue 指派(✅ 通过)
| # | 步骤 | 验证点 | 结果 | Mail ID |
|---|------|--------|------|---------|
| 1 | 创建 Issue #28assignee=zhangfei-dev | webhook 触发 + Mail 通知 | ✅ | mail-1781107087549 |
**Webhook 路径**Gitea → org webhook → `POST /webhook/gitea` → 签名验证 → `_handle_issues` → `_send_mail(zhangfei-dev, ...)`
**注意**Issue #27 创建时 webhook 未启用,未触发。Issue #28 创建时 webhook 已启用,正常触发。
### 三、Toolchain — PR Review(✅ 通过)
| # | 步骤 | 验证点 | 结果 | Mail ID |
|---|------|--------|------|---------|
| 1 | 创建 PR #30 | webhook 触发 + Review 请求 Mail | ✅ | mail-1781107538823 |
| 2 | simayi-challenger 提交 COMMENT review | Review 结果通知 PR 作者 | ✅ `Review 通过 ✓` | mail-1781107650433 |
**Webhook 路径**
- PR opened: Gitea → `_handle_pull_request` → `_send_mail(simayi-challenger, "Review 请求")`
- PR review: Gitea → `_handle_pull_request_review` → `_send_mail(pangtong-fujunshi, "Review 通过 ✓")`
### 四、CI 失败评论(⚠️ 触发但重复)
| # | 步骤 | 验证点 | 结果 | Mail ID |
|---|------|--------|------|---------|
| 1 | push 空 commit → CI lint 失败 | CI 失败通知 | ✅ 但收到 2 封重复 Mail | mail-1781107563991, mail-1781107560933 |
**已知问题**:和上次 E2E(§18)相同——org webhook + repo webhook 双触发。上次已加去重机制(delivery UUID + content sha256),但 CI 失败场景似乎仍触发 2 封。**非新问题,待姜维统一 org/repo webhook 后解决。**
### 五、负面测试(❌ 未执行)
| 步骤 | 说明 | 状态 |
|------|------|------|
| REQUEST_CHANGES review | review 驳回通知 PR 作者 | 未测(仲达提交的是 COMMENT 而非 REQUEST_CHANGES |
| 已关闭 Issue CI 评论 | closed issue 不触发 Mail | 未测 |
| 部署失败 Issue | 双收件人通知 | 未测 |
| 幂等测试 | 同 delivery ID 重发 | §18 已验证,未重测 |
## 阻塞/问题记录
### 已解决
| 问题 | 说明 |
|------|------|
| Org webhook 事件列表被 Gitea API 重置 | 姜维修复:PATCH webhook 只传 active:true 会重置 events,必须带完整事件列表 |
| PR Review 无法用 PR 作者 token 提交 | Gitea 不允许 self-review,请仲达用 simayi token 提交 |
### 遗留
| 问题 | 严重度 | 说明 |
|------|--------|------|
| CI 失败 Mail 重复 | 🟡 | org webhook + repo webhook 双触发,§18 已记录 |
| REQUEST_CHANGES 未验证 | 🟢 | 下次 E2E 补测 |
## 测试清理
- ✅ Issue #27、#28 已关闭
- ✅ PR #29、#30 已关闭
- ✅ 分支 `test/e2e-1781107119`、`test/e2e-pr-1781107530` 已删除
- ✅ 本地切回 main 分支
## 结论
**Handler 注册后 Mail 和 Toolchain 核心流程端到端验证通过。** 关键修复(handler 注册、review verdict、SKILL_BASE_PATH)均已生效。
下一步:
- Task review 路径 E2E(明天,需要普通任务 → executor → review → verdict → done
- CI 失败重复 Mail 根治(需姜维统一 org/repo webhook
+224
View File
@@ -0,0 +1,224 @@
# v3.0 vs HEAD 背靠背 Review — 庞统
**日期**: 2026-06-11
**范围**: v3.0 tag → HEAD6 commits, Step 2-5 Task 五层架构重构)
**对比**: `git diff v3.0..HEAD` + 安装目录代码验证
---
## Part A: v3.0 逻辑丢失检查
### 方法论
v3.0 → HEAD 的重构将 `_mail_*` 硬编码逻辑统一为 handler 架构(TaskTypeRegistry + BaseTaskHandler)。核心变更:
- dispatcher.py: `_mail_on_checks_passed` / `_mail_on_complete``_handler_on_checks_passed` / `_handler_on_complete`
- spawner.py: `_build_mail_prompt` → handler.build_prompt
- ticker.py: `_mail_check_reply` → handler.check_completion, `_mail` 硬编码 → `TaskTypeRegistry.virtual_projects()`
### 检查结果
| # | 文件 | v3.0 逻辑 | 当前状态 | 严重度 | 说明 |
|---|------|----------|---------|--------|------|
| 1 | dispatcher.py | `_legacy_on_complete` 中 review verdict 处理(approved→done, 非 approved→@mention assignee | **缺失** | 🔴 | 新版 `_legacy_on_complete``_is_review=True` 时只有 crash rollback**没有 verdict 判断逻辑**。review agent 完成后任务永远不会从 review→done。**仅影响非 handler 项目(_general**。handler 项目(_mail/_toolchain)的 review 由 TaskHandler.post_complete 正确处理 |
| 2 | dispatcher.py | `_mail_auto_working` / `_mail_auto_complete` / `_mail_revert_to_pending` 方法 | 保留但主流程不再调用 | 🟢 | 方法体仍存在(标记为 deprecated),主流程改走 handler.pre_spawn / handler.post_complete。正常的重构 |
| 3 | dispatcher.py | spawn 失败回退 `working→pending` | **逻辑改进** | 🟢 | v3.0 用 `_mail_revert_to_pending`(只处理 _mail),新版用通用 DB 操作处理所有 handler 项目 |
| 4 | spawner.py | `_build_mail_prompt` 精简模板 | **替换为 handler.build_prompt** | 🟢 | MailHandler 使用 PromptSection 组装,功能更完整 |
| 5 | spawner.py | `_build_api_section` 中 mail 直接 done | **替换为 handler.target_success_status** | 🟢 | 等价实现 |
| 6 | ticker.py | `_mail` 硬编码虚拟项目 | **替换为 TaskTypeRegistry.virtual_projects()** | 🟢 | 正常重构,可扩展 |
| 7 | ticker.py | `_mail_check_reply` 兜底(超时检查) | **替换为 handler.check_completion** | 🟢 | 等价实现,缩进正确 |
| 8 | ticker.py | `_dispatch_reviews` 跳过 `_mail` | **替换为 handler 检查** | 🟢 | 等价 |
### 🔴 严重问题 #1 详解
**位置**: `dispatcher.py` L250-260 `_legacy_on_complete`
**v3.0 逻辑**(已删除):
```python
if _is_review:
if _task_db and outcome in ("completed", "session_revived"):
# 读 verdict
if verdict == "approved":
_dispatcher._mark_task_status(_task_db, _task_id, "done")
else:
# @mention assignee + 保持 review
bb.add_comment(_task_id, "daemon", f"@{assignee} 审查结论: {verdict_str}")
```
**当前逻辑**:
```python
def _legacy_on_complete(aid, outcome):
if outcome in ROLLBACK_CURRENT_AGENT_OUTCOMES and _task_db:
_dispatcher._rollback_current_agent(_task_db, _task_id, aid)
if not _is_review: # ← review 时什么都不做
_dispatcher._task_auto_complete(_task_id, _task_db)
```
**影响**: `_dispatch_reviews` (ticker.py:1307) 对非 handler 项目会 dispatch review agent。review agent 完成后走 `_legacy_on_complete`,但 `_is_review=True` 时逻辑为空。任务永远停在 `review` 状态。
**修复方案**: 在 `_legacy_on_complete` 中补充 review verdict 处理逻辑,或让非 handler 项目也走 TaskHandler(注册 `_general` 到 TaskTypeRegistry)。
---
## Part B: 专题 01-13 设计编码一致性
### 专题 01: 四相循环(不参考实现,只检查设计遗漏)
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | §3.3 Spawn Prompt 框架(任务+约束+API+准则+完成标准) | ✅ BootstrapBuilder + PromptSection 实现 | ✅ | |
| 2 | §3.4 @mention 通知机制 | ✅ `_process_mentions` + `mention_queue` | ✅ | |
| 3 | §4 庞统 Review 机制(三问) | ✅ review agent + verdict 处理 | ✅ | |
**设计遗漏**: 无明显遗漏。
### 专题 02: Main Session + Delegation
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | 3.1 投递到 Main Session | ✅ `use_main_session=True` 参数 | ✅ | |
| 2 | 3.2 Delegationsubagent-delegation skill | ✅ 外部 skill,不在此代码库 | ✅ | |
| 3 | 3.3 续杯机制 | ✅ `use_main_session=True` + session 复用 | ✅ | |
| 4 | 4.1 投递消息格式 | ✅ dispatcher 构建 | ✅ | |
| 5 | 4.3 消息优先级与中断策略 | ❌ 无优先级队列 | ⚠️ | 设计描述了优先级但未实现,非关键 |
| 6 | 4.4 Subagent 背压控制 | ❌ 无显式背压 | ⚠️ | 靠 counter 间接控制 |
### 专题 03: Prompt 进化
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | 3.1 广播认领模板改写 | ✅ PromptSection 组装 | ✅ | |
| 2 | P4 群体智能(Boids | ✅ agent 自主决策 | ✅ | 设计原则,非具体代码 |
| 3 | P6 反静默降级 | ❌ 无 scope reduction detection 自动机制 | ⚠️ | 设计原则,未自动实现 |
| 4 | P7 经验闭环 | ❌ 无 IMPROVE 阶段自动触发 | ⚠️ | P4 级待实现 |
### 专题 04: 黑板协作模型
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | 3.1 assignee 降级为显示字段,路由走 @mention | 🟡 assignee 仍做直接路由 | ⚠️ | router.py L160-166 仍有 assignee 快速路径。设计说 Phase 1 双轨并行,当前停在 Phase 1。未迁移到 Phase 2 |
| 2 | 3.2 @mention 语义增强(mention_queue + comment_type | ✅ 已实现 | ✅ | |
| 3 | 3.3 多人协作模式(co_assignees | ❌ 无 co_assignees 字段 | ❌ | 数据库无此列 |
| 4 | 3.4 信息关联模型(output↔comment link | ❌ 无关联字段 | ❌ | outputs 表无 comment_id 列 |
| 5 | 3.5 层级查询 API | ✅ parent_task 支持 | ✅ | |
**总结**: 3.3 和 3.4 设计了但未实现。3.1 停在 Phase 1。
### 专题 05: 上下文四层架构
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | L0 铁律层 | ✅ 通过 workspace 文件注入 | ✅ | |
| 2 | L1 角色层 | ✅ SOUL.md / IDENTITY.md | ✅ | |
| 3 | L2 引擎注入层 | ✅ BootstrapBuilder | ✅ | |
| 4 | L3 被动参考层 | ❌ 无 _inject_wiki_knowledge | ❌ | wiki 知识注入未实现 |
### 专题 06: PM2 Crash 恢复
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | 4.1 总体流程(_startup_recover | ✅ ticker.py:1614 | ✅ | |
| 2 | 4.2 claimed 状态恢复 | ✅ | ✅ | |
| 3 | 4.2 working 状态恢复 | ✅ `_recover_working_task` | ✅ | |
| 4 | 4.2 review 状态恢复 | ✅ `_recover_review_task` | ✅ | |
| 5 | 设计提到 7 个恢复方法 | 🟡 只看到 2 个公开方法 | ⚠️ | 可能在内部逻辑中覆盖,需详细检查 |
### 专题 07: Spawner Acquire-First
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | Phase 0: Pre-acquire 修复 | ✅ L499-512 | ✅ | |
| 2 | Phase 1: Counter acquire | ✅ L516-521 | ✅ | |
| 3 | Phase 2: Session check | ✅ L523-568 | ✅ | |
| 4 | Phase 2.5: 假死修复 | ✅ L557-568 | ✅ | |
| 5 | O1: lock PID 死 + running 假死 | ✅ | ✅ | |
| 6 | O4: revive 清理 lock 文件 | ✅ | ✅ | |
### 专题 08: Classify Outcome 优化
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | A0-A17 判定树 | ✅ `_classify_outcome` 方法 | ✅ | |
| 2 | A9 api_error 特殊路径 | ✅ api_retry_count | ✅ | |
| 3 | A14-A17 可恢复 retry + cooldown 60s | ✅ cooldown_seconds + set_cooldown | ✅ | |
| 4 | Gateway Watchdog | ✅ 外部脚本 | ✅ | |
| 5 | Registry 逻辑删除 | ✅ | ✅ | |
### 专题 09: Rebuttal + Goal Gate
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | 2.1 Rebuttal 自动化(review 非 approved → @mention assignee | ✅ task_handler.py handle_review_complete + ticker.py _rebuttal_on_complete | ✅ | |
| 2 | 2.1 防止无限循环(max 2 轮) | ✅ RebuttalManager.MAX_ROUNDS | ✅ | |
| 3 | 2.2 目标一致性 Gate | ❌ 无 goal gate 自动检查 | ⚠️ | 设计为 Agent 端行为,非 Daemon 侧 |
| 4 | _task_on_complete 改动(design §2.1 代码改动) | 🟡 已移到 handler | ✅ | 重构后的等价位置 |
### 专题 10: T3 需求探索 + 黑板展示
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | A2: 需求探索过程写黑板 comments | ✅ 后端支持 comment_type | ✅ | |
| 2 | A3: TaskModal 实时刷新 | ✅ SSE comment_added/checkpoint_resolved | ✅ | |
| 3 | D1: 砍掉 AI 摘要 | ✅ 黑板直投前端 | ✅ | |
| 4 | D2: SSE 只做通知 | ✅ 前端按需拉数据 | ✅ | |
### 专题 11: 上下文四层重设计
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | L2 操作规范型 6 个 skill 全文注入 | ❌ BootstrapBuilder 只注入通用 prompt,无 skill 全文注入 | ❌ | 设计 §2.3 要求将 6 个操作规范型 skillblackboard-executor, code-review 等)全文注入 L2bootstrap.py 无此逻辑 |
| 2 | L3 _inject_wiki_knowledge | ❌ 完全未实现 | ❌ | |
| 3 | review_protocols/ 目录 | ❌ 目录不存在 | ❌ | |
| 4 | 2.3 提到的 handoff.schema.json | ❌ 不存在 | ❌ | |
**总结**: 专题 11 大部分 L2/L3 改造未实现。BootstrapBuilder 做了基础框架但缺少 skill 注入和知识注入。
### 专题 12: Pipeline 设计
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | §3 Pipeline 注册表(pipeline 字段) | ❌ 无 pipeline 数据结构 | ❌ | |
| 2 | §4 路由逻辑更新(task_type 路由) | ❌ router.py 无 task_type 路由 | ❌ | |
| 3 | §8 Pipeline 引擎 + PipelineRegistry | ❌ 不存在 | ❌ | |
| 4 | §8.2 状态流转校验 | ❌ 无 flow_rules | ❌ | |
| 5 | §9 实施路线标记为 "待实现" | — | — | 设计文档本身就标记为 TODO |
**总结**: Pipeline 整个设计未实施。设计文档 §9 自身标记为待实现。
### 专题 13: 工具链开发工作流(不参考实现,只检查设计遗漏)
| # | 设计描述 | 代码状态 | 一致性 | 说明 |
|---|---------|---------|--------|------|
| 1 | §16 工具链事件中枢 | ✅ toolchain_routes.py + toolchain_handler.py | ✅ | |
| 2 | Gitea webhook 处理 | ✅ 5 模板 + 去重 | ✅ | |
| 3 | CI 前缀 [CI] | ✅ | ✅ | |
| 4 | §5 CI/CD 管道设计 | 🟡 Gitea Actions 为主,非 Daemon 侧 | ✅ | |
**设计遗漏**: 无明显遗漏。
---
## 汇总
### 🔴 严重(需修复)
| # | 问题 | 影响 |
|---|------|------|
| A1 | `_legacy_on_complete` review verdict 处理丢失 | 非 handler 项目(_general)的 review agent 完成后任务永远停在 review 状态 |
### 🟡 中等(设计-代码不一致,可后续处理)
| # | 专题 | 设计描述 | 实际状态 |
|---|------|---------|---------|
| B4-1 | 04 黑板协作 | 3.1 assignee 降级 Phase 2 | 停在 Phase 1 |
| B4-3 | 04 黑板协作 | 3.3 co_assignees 多人协作 | 未实现 |
| B4-4 | 04 黑板协作 | 3.4 output↔comment 关联 | 未实现 |
| B5-4 | 05 上下文层 | L3 wiki 知识注入 | 未实现 |
| B11-1 | 11 上下文重设计 | L2 操作规范型 skill 全文注入 | 未实现 |
| B11-2 | 11 上下文重设计 | handoff.schema.json | 未实现 |
| B11-3 | 11 上下文重设计 | review_protocols/ 目录 | 未实现 |
| B12 | 12 Pipeline | 整个 Pipeline 引擎 | 未实现(设计自标 TODO) |
### 🟢 正常(重构等价或设计已标记待实现)
- _mail_* 方法 deprecated 但保留(平滑迁移)
- handler 架构统一替代硬编码(等价实现)
- 专题 01/02/03/06/07/08/09/10/13 无严重不一致
+707
View File
@@ -0,0 +1,707 @@
# v3.0 vs HEAD 背靠背 Review — 司马懿
> **日期**: 2026-06-10 (v2)
> **范围**: v3.0 tag → HEAD6 commits, +1584/-134 行, 9 个文件)
> **方法**: `git diff v3.0..HEAD` 逐文件逐行比对 + v3.0 源码 `git show v3.0:` 回溯验证
> **独立判断**: 不参考庞统 review,独立产出后比对
---
## 总览
v3.0 → HEAD 的核心改动是 **Step 2-5 五层架构重构**
| 层 | 新增/改动 | 说明 |
|---|---------|------|
| Protocol + Registry | `task_type_registry.py`(已有,未改) | `TaskTypeHandler` Protocol + `TaskTypeRegistry` |
| 基类 | `base_task_handler.py`(新增 +183 | `BaseTaskHandler` — crash/verify/mark/notify 统一流程 |
| Handler × 3 | `task_handler.py`+378)、`mail_handler.py`+210)、`toolchain_handler.py`+277 | 各自实现 `build_prompt` / `verify_completion` / `post_complete` |
| 引擎接入 | `dispatcher.py`-95/+58)、`spawner.py`+38)、`ticker.py`+31/-27 | `_mail_*` 硬编码 → `TaskTypeRegistry` 查表 |
| 设计文档 | `step5-impact-analysis.md`+324)、`step5-audit-report.md`(+74) | 影响分析 + 双重审计 |
**核心结论**:架构方向正确,但 **handler 注册初始化缺失导致所有 handler 路径为死代码**,实际运行仍走 `_legacy_on_complete` 旧路径。旧路径中 review verdict 处理被删除,造成 **非 handler 项目的 review 流程失效**
---
## Part A: v3.0 逻辑丢失检查
### 方法论
逐文件追踪 v3.0 中每个 `_mail` / `_task` / `project_id == "_mail"` 分支,验证 HEAD 中是否存在等价实现。分三层检查:
1. **功能等价**:新代码是否完整覆盖旧逻辑
2. **路径可达**:新代码是否会被实际执行(handler 注册?legacy fallback?)
3. **行为一致**:边界条件、异常处理是否等价
### 检查结果
#### A1 🔴 致命:dispatcher.py — review verdict 处理丢失
**v3.0 逻辑**`dispatcher.py` L253-308 `_task_on_complete`):
```python
if _is_review:
if _task_db and outcome in ("completed", "session_revived"):
# 读 verdict
review = conn.execute(
"SELECT verdict FROM reviews WHERE task_id=? ORDER BY created_at DESC LIMIT 1",
(_task_id,)).fetchone()
if review and review["verdict"] == "approved":
_dispatcher._mark_task_status(_task_db, _task_id, "done")
else:
# 非 approved → @mention assignee + 保持 review
bb.add_comment(_task_id, "daemon", f"@{assignee} 审查结论: {verdict_str}")
```
**HEAD 逻辑**`dispatcher.py` L246-258 `_legacy_on_complete`):
```python
def _legacy_on_complete(aid, outcome):
if outcome in ROLLBACK_CURRENT_AGENT_OUTCOMES and _task_db:
_dispatcher._rollback_current_agent(_task_db, _task_id, aid)
if not _is_review: # ← review 时整个 if 被跳过
_dispatcher._task_auto_complete(_task_id, _task_db)
```
**分析**
- `_legacy_on_complete``_is_review=True` 时**什么也不做**——无 verdict 读取、无 done 标记、无 @mention 通知
- `TaskHandler.handle_review_complete()` 方法有完整 verdict 处理,但 handler 未注册(见 A2),此代码不可达
- **影响**:所有非 handler 项目(`_general` 等)的 review agent 完成后,任务永远停在 `review` 状态
**补充**rebuttal 路径不受影响——`_rebuttal_on_complete``ticker.py` L756-790 独立定义,直接读 verdict 并处理,不经过 `_legacy_on_complete`
---
#### A2 🔴 致命:Handler 注册初始化缺失
**证据**
```bash
$ grep -rn "TaskTypeRegistry.register" src/
# 零结果
```
`TaskTypeRegistry.register()` 在整个代码库中**从未被调用**。`TaskHandler` / `MailHandler` / `ToolchainHandler` 类已定义但从未实例化和注册。
**后果链**
1. `TaskTypeRegistry.get_by_project()` 永远返回 `None`
2. 所有 `if handler:` 分支不进入 → 走 `else` / fallback 路径
3. `TaskTypeRegistry.virtual_projects()` 返回空列表 → `_mail` / `_toolchain` 不被 ticker 自动发现
**各路径受影响分析**
| 路径 | dispatcher | spawner | ticker | 实际走什么 |
|------|-----------|---------|--------|----------|
| Mail `_mail` | `handler=None``_legacy_on_complete` | `handler=None` → 旧 `_build_mail_prompt` | `virtual_projects()` 空 → **_mail 不被 tick** | 旧路径(无 handler),但 **ticker 不扫描 _mail** |
| Task `_general` | `handler=None``_legacy_on_complete` | `handler=None` → BootstrapBuilder | 不涉及 handler | 旧路径,但 review 处理被删(A1) |
| Toolchain `_toolchain` | N/A | N/A | `virtual_projects()` 空 → **_toolchain 不被 tick** | **完全不可达** |
**⚠️ A2 导致 ticker 不再扫描 `_mail` 虚拟项目**,这是 v3.0 有、HEAD 丢失的行为——v3.0 中 `_mail` 硬编码在 ticker L218-229HEAD 改为 `TaskTypeRegistry.virtual_projects()` 但注册为空。
**需要添加的初始化代码**(缺失):
```python
# 应在 server.py 或 bootstrap.py 的启动流程中
from src.daemon.task_handler import TaskHandler
from src.daemon.mail_handler import MailHandler
from src.daemon.toolchain_handler import ToolchainHandler
TaskTypeRegistry.register(TaskHandler())
TaskTypeRegistry.register(MailHandler())
TaskTypeRegistry.register(ToolchainHandler())
```
---
#### A3 🟡 中等:dispatcher.py — 旧 `_mail_*` 方法成为死代码
**v3.0**`_mail_auto_working` / `_mail_auto_complete` / `_mail_check_reply` / `_mail_revert_to_pending``dispatch()` 主流程调用。
**HEAD**:这些方法仍保留在 dispatcher.py 中(L628-860),但主流程已改走 handler 路径。由于 handler 未注册,主流程走 `_legacy_on_complete`(无 handler 分支),也不调用这些方法。
**结论**:方法体保留但无外部调用者,属于死代码。不影响当前运行(因为 `_legacy_on_complete` 有独立的 executor 逻辑),但增加维护混淆。
---
#### A4 🟢 低:dispatcher.py — spawn 失败回退等价
**v3.0**`self._mail_revert_to_pending(task.id, db_path)` — 调独立方法。
**HEAD**:内联代码(L309-327),`BEGIN IMMEDIATE` + 状态检查 + `UPDATE ... SET status='pending'`
**等价**:新版逻辑更通用(不限于 `_mail`,任何 handler 项目都可回退)。
---
#### A5 🟢 低:dispatcher.py — `_legacy_dispatch` 路径 handler 化
**v3.0**`is_mail_legacy = project_id.get("project_id") == "_mail"`
**HEAD**`handler_legacy = TaskTypeRegistry.get_by_project(project_id_legacy)`
**等价**`handler_legacy` 为 None 时跳过 pre_spawn,与 v3.0 中 `is_mail_legacy=False` 行为一致。`_legacy_dispatch` 本身仅在 `router=None` 时触发,当前配置不会进入。
---
#### A6 🟢 低:spawner.py — prompt 构建双路径
**v3.0**`if project_id == "_mail": return self._build_mail_prompt(...)` → 走 BootstrapBuilder。
**HEAD**`handler = TaskTypeRegistry.get_by_project(project_id)``if handler: return handler.build_prompt(ctx)` → else 走 BootstrapBuilder。
**分析**
- handler 未注册时,等价于 v3.0(走 BootstrapBuilder
- handler 注册后,Task/Mail/Toolchain 走新 PromptSection 路径
- **注意**:新旧路径的 Skill 注入策略不同——旧路径(BootstrapBuilder**全文注入** Skill,新路径(RoleSkillSection)只给**索引+引导语**。这可能导致 handler 注册后 Agent 行为变化
---
#### A7 🟢 低:spawner.py — `_build_api_section` success_status
**v3.0**`success_status = '"done"' if project_id == "_mail" else '"review"'`
**HEAD**`success_status = '"done"' if handler.target_success_status == "done" else '"review"'`
**等价**handler 未注册时走 else 分支 → `'"review"'`,与 v3.0 非 mail 项目一致。
---
#### A8 🟡 中等:spawner.py — retry prompt 仍用硬编码
**v3.0**`is_mail = project_id == "_mail"` → 用 `MAIL_RETRY_PROMPT` 模板。
**HEAD**:同样 `is_mail = project_id == "_mail"` 硬编码(L1128),未改走 handler。
**影响**:不影响功能(retry prompt 正确),但与设计文档 §6 不一致。属于 Step 5 未覆盖的遗留点。
---
#### A9 🟢 低:ticker.py — 虚拟项目扫描
**v3.0**:硬编码 `_mail` 扫描。
**HEAD**`TaskTypeRegistry.virtual_projects()` 循环。
**分析**:逻辑正确,但注册为空时 `_mail` 不被扫描(见 A2)。注册后自动发现 `_mail` + `_toolchain`,比 v3.0 更可扩展。
---
#### A10 🟢 低:ticker.py — assignee 清空条件
**v3.0**`if self._current_project_id == "_mail":` → 不清空 assignee。
**HEAD**`handler = TaskTypeRegistry.get_by_project(...); if handler:` → 不清空。
**等价**handler 未注册时,非 handler 项目正常清空 assignee。
---
#### A11 🟢 低:ticker.py — 跳过 claimed 状态
**v3.0**`if project_id == "_mail":` → 跳过 claimed,直接 working。
**HEAD**`handler = TaskTypeRegistry.get_by_project(project_id); if handler:` → 跳过。
**等价**
---
#### A12 🟢 低:ticker.py — review dispatch 跳过
**v3.0**`if project_id == "_mail": return []`
**HEAD**`handler = TaskTypeRegistry.get_by_project(project_id); if handler: return []`
**等价**
---
#### A13 🟢 低:ticker.py — 超时检查幻觉门控
**v3.0**
```python
if self._current_project_id == "_mail":
has_reply = self._mail_check_reply(task.id, db_path)
if has_reply:
... # mark done
```
**HEAD**
```python
handler = TaskTypeRegistry.get_by_project(self._current_project_id)
if handler and handler.check_completion(task.id, db_path):
... # mark done
```
**等价**`MailHandler.check_completion` 内部调 `_check_reply`,查询语义与 v3.0 的 `_mail_check_reply` 完全一致(`SELECT id FROM tasks WHERE id != ? AND must_haves LIKE ?`)。
**缩进问题**HEAD L1483 `if handler and handler.check_completion(...):` 后续 body 缩进 5 级(28 空格),与同级代码不一致。不影响运行,但增加维护混淆。
---
#### A14 🟢 低:ticker.py — startup recovery 虚拟项目列表
**v3.0**`for virtual_id in ("_general", "_mail"):`
**HEAD**`virtual_ids = ["_general"] + TaskTypeRegistry.virtual_projects()`
**等价**:注册为空时只有 `_general`,注册后自动包含 `_mail` + `_toolchain`
---
### Part A 汇总
| 严重度 | 数量 | 项目 |
|--------|------|------|
| 🔴 致命 | 2 | A1 review verdict 丢失, A2 handler 未注册 |
| 🟡 中等 | 2 | A3 死代码未清理, A8 retry prompt 硬编码 |
| 🟢 低 | 10 | A4~A7, A9~A14 |
**A1+A2 联合根因分析**
设计意图是 handler 注册后 review 走 `TaskHandler.post_complete``handle_review_complete`。但注册代码缺失导致:
1. 所有项目走 `_legacy_on_complete`(旧路径)
2. 旧路径中 review 处理被删除(信任 handler 会处理)
3. review agent 完成后无任何后续动作
**同时**ticker 不再扫描 `_mail` 虚拟项目(原来硬编码扫描),`_mail` 项目的 pending 任务无人处理。
---
## Part B: 13 个重点专题设计-编码一致性
逐专题检查设计文档描述与 HEAD 代码的一致性。标记:
- ✅ 一致
- ⚠️ 设计已标注未实施/Phase N(不算差异)
- ❌ 设计承诺但代码不一致
- 🟡 部分一致
---
### B1: 专题 01 四相循环
**设计文档**`01-four-phase-loop.md` — PRD Phase 1~4 完整实现方案
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B1-1 | §3.3 Spawn Prompt 框架(任务+约束+API+准则+完成标准) | BootstrapBuilder + PromptSection 实现 | ✅ |
| B1-2 | §3.4 @mention 通知机制 | `_process_mentions` + `mention_queue` | ✅ |
| B1-3 | §4 Review 机制(verdict → done/notify | `TaskHandler.handle_review_complete`handler 未注册)+ `_rebuttal_on_complete`ticker 独立) | ⚠️ handler 路径不可达,但 rebuttal 路径完整 |
---
### B2: 专题 02 Main Session + Delegation
**设计文档**`02-main-session-delegation.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B2-1 | §3.1 投递到 Main Session | `use_main_session=True` 参数 | ✅ |
| B2-2 | §3.3 续杯机制 | `use_main_session=True` + session 复用 | ✅ |
| B2-3 | §4.3 消息优先级与中断策略 | 无优先级队列 | ⚠️ 设计描述但未标注 Phase |
| B2-4 | §4.4 Subagent 背压控制 | 无显式背压,靠 counter 间接控制 | ⚠️ |
---
### B3: 专题 03 Prompt 进化
**设计文档**`03-prompt-evolution.md` — 从 SOP 到任务式指挥
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B3-1 | §3.1 广播认领模板改写 | PromptSection 组装(新路径)+ BootstrapBuilder(旧路径) | ✅ |
| B3-2 | P6 反静默降级 | 无 `scope-reduction-detection` 自动机制 | ⚠️ 设计原则,未强制实施 |
| B3-3 | P7 经验闭环 | 无 IMPROVE 阶段自动触发 | ⚠️ |
---
### B4: 专题 04 黑板协作模型
**设计文档**`04-blackboard-collaboration-model.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B4-1 | §3.1 assignee 降级为显示字段,路由走 @mention | `router.py` L160-166 仍有 assignee 快速路径 | ⚠️ 设计说 Phase 1 双轨并行,Phase 2 废弃。当前停在 Phase 1 |
| B4-2 | §3.2 @mention 语义增强 | `mention_queue` + `comment_type` 已实现 | ✅ |
| B4-3 | §3.3 多人协作 `co_assignees` | 数据库无此字段 | ⚠️ Phase 3 |
| B4-4 | §3.4 output↔comment 关联 | 无关联字段 | ⚠️ Phase 2 |
| B4-5 | §3.5 层级查询 API | `parent_task` 支持 | ✅ |
---
### B5: 专题 05 上下文四层架构
**设计文档**`05-context-layers.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B5-1 | L0 铁律层 | workspace 文件注入(SOUL.md/IDENTITY.md 等) | ✅ |
| B5-2 | L1 角色层 | SOUL.md / IDENTITY.md | ✅ |
| B5-3 | L2 引擎注入层 | BootstrapBuilder 实现 | ✅ |
| B5-4 | L3 被动参考层(wiki knowledge | 无 `_inject_wiki_knowledge` | ⚠️ 设计标注为 Phase 2 |
---
### B6: 专题 06 PM2 Crash 恢复
**设计文档**`06-pm2-crash-recovery.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B6-1 | §4.1 总体流程 `_startup_recover` | ticker.py L1614 有启动恢复 | ✅ |
| B6-2 | §4.2 claimed 状态恢复 | ✅ | ✅ |
| B6-3 | §4.2 working 状态恢复 `_recover_working_task` | ✅ | ✅ |
| B6-4 | §4.2 review 状态恢复 `_recover_review_task` | ✅ | ✅ |
---
### B7: 专题 07 Spawner Acquire-First
**设计文档**`07-spawner-acquire-first.md`#07.1 已实施, #07.2 已实施
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B7-1 | Phase 0 Pre-acquire 修复 | spawner.py L499-512 | ✅ |
| B7-2 | Phase 1 Counter acquire | spawner.py L516-521 | ✅ |
| B7-3 | Phase 2 Session check | spawner.py L523-568 | ✅ |
| B7-4 | Phase 2.5 假死修复 | spawner.py L557-568 | ✅ |
---
### B8: 专题 08 Classify Outcome 优化
**设计文档**`08-classify-outcome-optimization.md` — 已实施 ✅
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B8-1 | A0-A17 判定树 | `_classify_outcome` 方法 | ✅ |
| B8-2 | A9 api_error 特殊路径 | `api_retry_count` | ✅ |
| B8-3 | A14-A17 可恢复 retry + cooldown 60s | `cooldown_seconds` + `set_cooldown` | ✅ |
---
### B9: 专题 09 Rebuttal + Goal Gate
**设计文档**`09-rebuttal-and-goal-gate.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B9-1 | §2.1 Rebuttal 自动化(review 非 approved → @mention assignee | `review.py RebuttalManager` + `ticker.py _rebuttal_on_complete` | ✅ |
| B9-2 | §2.1 防止无限循环(max 2 轮) | `RebuttalManager.MAX_ROUNDS = 2` | ✅ |
| B9-3 | §2.2 目标一致性 Gate | 无自动 goal gate 检查 | ⚠️ 设计为 Agent 端行为,非 Daemon 侧 |
---
### B10: 专题 10 T3 需求探索 + 黑板展示
**设计文档**`10-t3-requirement-exploration-and-blackboard-display.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B10-1 | A2 需求探索过程写黑板 comments | 后端支持 `comment_type` | ✅ |
| B10-2 | A3 TaskModal 实时刷新 | SSE `comment_added` / `checkpoint_resolved` | ✅ |
| B10-3 | D1 砍掉 AI 摘要 | 黑板直投前端 | ✅ |
| B10-4 | D2 SSE 只做通知 | 前端按需拉数据 | ✅ |
---
### B11: 专题 11 上下文四层重设计
**设计文档**`11-context-layers-redesign.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B11-1 | §2.3 L2 操作规范型 6 个 Skill 全文注入 | `BootstrapBuilder``ROLE_SKILL_MAP` + `_read_skill` 全文注入 ✅;`task_handler.py RoleSkillSection` 只给索引+引导语 ⚠️ | 🟡 **双路径并存**,策略矛盾 |
| B11-2 | §2.3 `handoff.schema.json` | 不存在 | ⚠️ Phase 3 |
| B11-3 | §2.3 `review_protocols/` 目录 | 不存在,但 `review-quality` Skill 文件存在 | ⚠️ 设计文档 §三归属表已改归类为 L3 Skill |
| B11-4 | §6 Phase 3 Step 6-8 BootstrapBuilder 改造 | 已完成(ROLE_SKILL_MAP + _read_skill | ✅ |
| B11-5 | §2.3 token 预算 ~600 tokens | bootstrap.py 有 warn 但不截断 | 🟡 有告警无硬限制 |
**B11 关键发现**:新旧路径的 Skill 注入策略矛盾——
- 旧路径(BootstrapBuilder):**全文注入** Skill`_read_skill` 读文件全文)
- 新路径(RoleSkillSection):**只给索引**"请用 read 工具读取 SKILL.md"
- 设计文档 §2.3 要求 "A 类 Skill 全文注入"
- handler 注册后会从旧路径切换到新路径,导致 **Skill 从全文注入降级为索引提示**
这是一个 **隐性回归**:注册 handler 后 Agent 获取的操作规范信息量大幅减少。
---
### B12: 专题 12 Pipeline 设计
**设计文档**`12-pipeline-design.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B12-1 | §3 Pipeline 注册表 | 不存在 | ⚠️ 设计 §9 标注 Phase 2 |
| B12-2 | §4 路由逻辑 task_type | router.py 无 task_type 路由 | ⚪ |
| B12-3 | §8 PipelineRegistry | 不存在 | ⚪ |
| B12-4 | §10.1 task_type 默认值改 None | `blackboard_routes.py` 已为 Nonev3.0 已修) | ⚪ **已实施** |
| B12-5 | §10.2 广播计数器修正 | `_broadcast_tracker` + `BroadcastRound` 已实现 | ⚪ **已实施** |
**B12 结论**:Pipeline 主体未实施符合设计路线图(Phase 2),但 §10 Phase 1 的两个 bug fix 明确标注为"立做"却未执行。
---
### B13: 专题 13 工具链与开发工作流
**设计文档**`13-toolchain-and-dev-workflow.md`
| # | 设计要求 | 代码现状 | 判定 |
|---|---------|---------|------|
| B13-1 | §16 工具链事件中枢 | `toolchain_handler.py` + `toolchain_templates.py` | ✅ |
| B13-2 | Gitea webhook 处理 | 5 模板 + 去重 | ✅ |
| B13-3 | CI 前缀 `[CI]` | ✅ | ✅ |
---
### Part B 汇总
| 判定 | 数量 | 主要项目 |
|------|------|---------|
| ✅ 一致 | 21 | B1-1, B1-2, B2-1/2, B3-1, B4-2/5, B5-1/2/3, B6-1~4, B7-1~4, B8-1~3, B9-1/2, B10-1~4, B11-4, B13-1~3 |
| 🟡 部分一致 | 3 | B11-1 双路径策略矛盾, B11-5 token 预算无硬限制 |
| ⚠️ 设计标注未实施 | 10 | B1-3handler 不可达), B2-3/4, B3-2/3, B4-1/3/4, B5-4, B9-3, B11-2/3 |
| ❌ 设计承诺未交付 | 0 | — |
---
## Step 5 审计报告偏差项验证
`step5-audit-report.md` 列出 6 项偏差(D1-D6)。逐项验证 HEAD 代码:
| # | 审计描述 | HEAD 实际状态 | 判定 |
|---|---------|-------------|------|
| D1 | pre_spawn 返回值未检查 | **已修复**`if not _handler.pre_spawn(...): raise RuntimeError("handler_pre_spawn_failed")` | ✅ 已修 |
| D2 | PromptContext 缺少 from_agent/mail_type | **已修复**spawner L289-296 从 must_haves JSON 提取 | ✅ 已修 |
| D3 | inform outcome 白名单缺失 | 未修复。但影响极小——CRASH_OUTCOMES 由基类处理,剩余异常 outcome 罕见 | 🟢 可接受 |
| D4 | retry prompt 仍用 `is_mail` 硬编码 | **未修复**spawner L1128 仍硬编码 `is_mail = project_id == "_mail"` | 🟡 遗留 |
| D5 | _check_reply 语义差异 | **已修复**MailHandler._check_reply 用 `SELECT id FROM tasks WHERE id != ? AND must_haves LIKE ?`,与 v3.0 一致 | ✅ 已修 |
| D6 | 标 done 重试机制 | **已修复**`BaseTaskHandler._mark_task_status` 有 3 次重试 | ✅ 已修 |
**结论**D1/D2/D5/D6 已在后续 commit 修复,D3 可接受,D4 是遗留项。
---
## 与庞统 Review 的背靠背比对
| 维度 | 司马懿 | 庞统 | 差异分析 |
|------|--------|------|---------|
| **致命问题** | A1 review verdict 丢失 + A2 handler 未注册 | 仅 #1 review verdict 丢失 | **关键差异**:庞统未将 handler 未注册列为致命问题。庞统认为 `_legacy_on_complete` 仍可运行所以只关注 review 路径。但我认为 **ticker 不再扫描 `_mail`** 是 v3.0 有、HEAD 丢失的行为,这比 review 路径更严重——Mail 系统完全停止工作 |
| **_mail tick 丢失** | 明确指出 A2 导致 ticker 不扫描 `_mail` | 未提及 | 庞统漏检了 `virtual_projects()` 返回空时 `_mail` 不被 tick 的后果 |
| **Skill 注入降级** | B11-1 发现新旧路径策略矛盾 | 未提及 | 庞统未分析 handler 注册后 Skill 注入策略的变化 |
| **D1/D2/D5 修复状态** | 验证了审计报告的修复项 | 未验证 | 庞统的 review 早于修复 commit |
| **专题覆盖范围** | 13 个全覆盖 | 13 个全覆盖 | 一致 |
| **D4 retry 硬编码** | A8 独立发现 | B4 独立发现 | 独立确认 |
---
## 建议优先级
| 优先级 | 项目 | 说明 |
|--------|------|------|
| **P0** | A2 handler 注册初始化 | 添加 `TaskTypeRegistry.register()` 启动代码。**这是所有 handler 路径的前提** |
| **P0** | A1 review verdict 处理 | P0 修复后自然恢复(`TaskHandler.handle_review_complete` 生效)。**但如果不想立即注册 handler**,需先在 `_legacy_on_complete` 中恢复 review verdict 逻辑作为 interim fix |
| **P1** | B11-1 Skill 注入策略对齐 | 注册 handler 后 RoleSkillSection 只给索引——需确认这是有意降级还是遗漏。如果是遗漏,RoleSkillSection 应全文注入 |
| **P1** | A8 retry prompt handler 化 | spawner L1128 `is_mail` 硬编码改走 handler |
| **P2** | A3 死代码清理 | `_mail_auto_working` / `_mail_auto_complete` 等方法在 handler 注册后确认不再需要再删除 |
| ~~P2~~ | ~~B12-4/5~~ | ~~已验证 v3.0 tag 时已修复,不需要再改~~ |
| **P3** | ticker.py L1483 缩进对齐 | 风格问题 |
---
## Cross-Check:庞统 Review 逐项验证
对庞统 `review-v3-vs-head-pangtong.md` 的每个发现,独立验证:**是不是真问题?根因对不对?修复方案对不对?**
---
### Part A 逐项验证
#### 庞统 #1 🔴 review verdict 丢失
**庞统判定**:致命。"仅影响非 handler 项目(_general"。
**我的验证**
1. **是致命问题** ✅ —— `_legacy_on_complete``_is_review=True` 时确实什么都不做。
2. **"仅影响非 handler 项目" — 表述不准确**。实际情况更复杂:
- `_general` 项目确实受影响(走 `_legacy_on_complete`
-`_mail` / `_toolchain` 不受影响,**不是因为"handler 正确处理"**,而是因为它们**根本不走 review 流程**ticker 中 `_dispatch_reviews` 对 handler 项目 `return []`
- 庞统说"handler 项目(_mail/_toolchain)的 review 由 TaskHandler.post_complete 正确处理"——**这个说法有误导性**。TaskHandler 不是 `_mail`/`_toolchain` 的 handler,它们各自的 handlerMailHandler/ToolchainHandler)没有 `handle_review_complete` 方法。它们不走 review 是因为设计上就不走。
3. **庞统的修复方案有隐藏缺陷**。庞统说"让非 handler 项目也走 TaskHandler(注册 `_general` 到 TaskTypeRegistry"。但 `TaskTypeRegistry.get_by_project()` 匹配的是 `handler.virtual_project`,而 TaskHandler 的 `virtual_project = None`。所以:
- `get_by_project("_general")` → 遍历所有 handler,检查 `h.virtual_project == "_general"` → TaskHandler 的 `virtual_project``None`**不匹配** → 返回 `None`
- 即使注册了 TaskHandler`_general` 项目仍然走 `_legacy_on_complete`
- 庞统的修复方案需要**额外改 TaskHandler.virtual_project 或 registry 匹配逻辑**,但他没指出这一点
**结论**:问题是真的,严重度判定正确。但影响范围描述和修复方案都不完整。
---
#### 庞统 #2 🟢 旧 `_mail_*` 方法保留
**庞统判定**:正常重构,方法体保留标记为 deprecated。
**我的验证**
1. **方法体确实保留** ✅(dispatcher.py L628-860
2. **但"标记为 deprecated"不对**——代码中没有 `@deprecated` 装饰器或注释。这些方法就是安静地躺在那里,没有任何标记告诉维护者"别用了"
3. **我标 🟡 中等而非 🟢**的原因:无 deprecated 标记 + 主流程不再调用 = 未来维护者容易误用
**结论**:问题不大,但庞统多给了信息("标记为 deprecated")——代码中实际没有标记。
---
#### 庞统 #3 🟢 spawn 失败回退
**庞统判定**:逻辑改进。
**我的验证**:✅ 确认等价,新版更通用。
---
#### 庞统 #4-5 🟢 spawner prompt/api_section
**庞统判定**:等价实现。
**我的验证**:✅ 确认等价。
---
#### 庞统 #6 🟢 ticker `_mail` → `virtual_projects()`
**庞统判定**:正常重构,可扩展。
**我的验证****这是庞统最大的漏检**。
庞统只看了代码方向(硬编码 → 注册表),**没有检查注册表是否为空**。
实际运行时 `TaskTypeRegistry.virtual_projects()` 返回空列表 → `_mail` 不被 ticker 扫描。这是一个 **v3.0 有、HEAD 丢失的行为**——v3.0 中 `_mail` 硬编码在 ticker L218-229HEAD 中完全消失。
后果:所有 Mail 任务的 pending → claimed → working 流程中断,整个飞鸽传书系统停止工作。
这不是"正常重构",是**致命回归**。
---
#### 庞统 #7-8 🟢 ticker check_reply / dispatch_reviews
**庞统判定**:等价实现。
**我的验证**:✅ 确认等价。但 #7 说"缩进正确"——实际 ticker.py L1483 有缩进不一致(28 空格 vs 同级 24 空格),不影响运行但增加维护混淆。
---
### Part B 逐专题验证
#### 专题 01-03:无分歧
庞统的检查和我的结论一致。设计原则未强制实施属于正常。
---
#### 专题 04:庞统更严格
庞统把 B4-3co_assignees)和 B4-4output↔comment)标 ❌,我标 ⚪(Phase 2/3)。
庞统的判定更严格——"设计了但没实现就是不一致" vs 我的"设计自身标注了 Phase,未实施是预期的"。两种视角都有道理,**不算错误**。
---
#### 专题 05:判定标准差异
庞统把 B5-4(L3 wiki 知识注入)标 ❌。我标 ⚪(Phase 2)。
同专题 04,判定标准差异。
---
#### 专题 06:庞统更细致
庞统多了 B6-5"设计提到 7 个恢复方法只看到 2 个公开方法"——这是一个合理的疑问,我没有提出。
---
#### 专题 07-10:无分歧
---
#### 专题 11:庞统全标 ❌ 是错的
庞统 B11-1 说"BootstrapBuilder 只注入通用 prompt,无 skill 全文注入"。
**我验证了代码**
```python
# bootstrap.py L29
ROLE_SKILL_MAP = {
"executor": "blackboard-executor",
"reviewer": "blackboard-reviewer",
...
}
# bootstrap.py L68-72
skill_name = self.ROLE_SKILL_MAP.get(role)
if skill_name:
skill_content = self._read_skill(skill_name) # 读全文
if skill_content:
sections.append(skill_content)
```
**BootstrapBuilder 有 Skill 全文注入**。庞统说"无 skill 全文注入"与代码不符。他可能只看了 `task_handler.py` 的 RoleSkillSection(确实只给索引),没有看 `bootstrap.py` 的旧路径。
**实际情况**:双路径并存。旧路径(BootstrapBuilder)全文注入,新路径(RoleSkillSection)只给索引。handler 注册后从旧路径切换到新路径,Skill 信息量降级。这才是真正的问题。
---
#### 专题 12:我之前的 B12-4/5 判定有误
我在 Part B 中说"B12-4 task_type 默认值仍为 `\"coding\"`"和"B12-5 广播计数器 retry_count 不递增"是 Phase 1 承诺未交付。
**cross-check 时我重新验证了代码**
- **B12-4**`blackboard_routes.py` L138 已是 `body.get("task_type", None)`**默认值已经是 None**。v3.0 tag 中也是 None。设计文档 §10.1 的 bug fix 可能在 v3.0 之前就修了,或者设计文档基于旧版本写的。**不是问题**,我之前的判定有误。
- **B12-5**`ticker.py``_broadcast_tracker` + `BroadcastRound` + `round_number >= 3` 升级庞统的机制已实现。`mark_mention_retry``retry_count = retry_count + 1`。设计 §10.2 描述的问题已在 v3.0 或更早修复。**不是问题**,我之前的判定有误。
庞统对专题 12 的判定("设计文档 §9 自身标记为待实现")比我准确。
**修正我的报告**Part B 中 B12-4 和 B12-5 应从 ❌ 改为 ⚪(设计自标 Phase 2,主体未实施是预期的)。
---
#### 专题 13:无分歧
---
### 庞统未引用 Step 5 审计报告
庞统的 review 完全没引用 `step5-audit-report.md`v3.0..HEAD diff 中新增的文件)。这意味着 D1/D2/D5 的修复状态未经庞统验证。我逐项验证了 D1/D2/D5 **已修复**D4 **未修复**retry 硬编码),D3 **可接受**D6 **已修复**
---
### 庞统漏检的额外行为回归
handler 未注册还导致一个庞统完全没提到的问题:
**guardrail 回归**。v3.0 中 dispatcher L127-128
```python
is_mail = project_config.get("project_id") == "_mail" if project_config else False
if self.guardrails and not is_mail:
```
HEAD dispatcher L128-131
```python
handler = TaskTypeRegistry.get_by_project(project_config.get("project_id", "") ...)
is_handler_task = handler is not None
if self.guardrails and not is_handler_task:
```
handler 未注册 → `is_handler_task = False`**`_mail` 项目也要过 guardrail 检查了**。v3.0 中 `_mail` 是跳过 guardrail 的。这可能导致某些 Mail 任务被 guardrail 拦截。
---
### Cross-Check 总结
| 维度 | 庞统 review 质量 |
|------|-----------------|
| **致命问题发现** | 发现 A1 ✅,漏检 A2handler 注册 + ticker 不可达 + guardrail 回归)❌ |
| **根因分析** | A1 根因正确。修复方案不完整(没指出 TaskHandler.virtual_project=None 导致注册也匹配不到 `_general` |
| **Part B 专题覆盖** | 13/13 全覆盖 ✅ |
| **Part B 事实准确性** | B11 "无 skill 全文注入"与代码不符 ❌。B12 比我准确 ✅ |
| **Part B 多给信息** | #2 说"标记为 deprecated"但代码无标记 ⚠️ |
| **Part B 更严格处** | B04-3/4 标 ❌(合理),B06-5 恢复方法数量疑问(合理) |
| **审计报告验证** | 未引用,未验证 D1-D6 修复状态 |
| **遗漏的行为回归** | guardrail 对 `_mail` 的回归 |
**我的自我修正**:B12-4/5 判定有误,应改为 ⚪。v3.0 tag 时这两个问题已修复,设计文档描述的是更早期的问题。
---
*— 司马懿 仲达,质量总监 🗡️*
+74
View File
@@ -0,0 +1,74 @@
# Step 5 双重审计报告
## 摘要
- 设计一致性检查项: 8
- 特殊逻辑覆盖检查项: 22
- 一致/覆盖: 24
- **偏差/遗漏: 6(严重 3 / 轻微 3)**
---
## 偏差/遗漏清单
| # | 维度 | 设计要求 / 旧逻辑 | 代码实际 | 严重程度 | 建议 |
|---|------|-------------------|---------|---------|------|
| **D1** | B1.2 pre_spawn | 旧 `_mail_on_checks_passed`: `if not _mail_auto_working(): raise RuntimeError` — pre_spawn 失败时中止 spawn | 新 `_handler_on_checks_passed`: `_handler.pre_spawn(...)` 返回值未检查,`handler_marked_working = True` 无条件执行 | **严重** | 改为 `if not _handler.pre_spawn(...): raise RuntimeError("handler_pre_spawn_failed")` |
| **D2** | B3.1 PromptContext | 旧 `_build_mail_prompt` 从 must_haves JSON 解析 `from_agent``performative` 传入模板 | 新 `spawner._build_spawn_message` 构建 PromptContext 时缺少 `from_agent``mail_type`,均为空字符串 | **严重** | 从 `must_haves` JSON 提取 `from``performative` 填入 PromptContext |
| **D3** | B1.3 inform outcome 白名单 | 旧 `_mail_auto_complete`: inform 类型有 outcome 白名单 `{"completed", "claimed", "no_reply"}`,不在白名单的 outcome 跳过 auto-done | 新 `MailHandler.verify_completion`: inform 始终返回 True,不检查 outcome | **轻微** | CRASH_OUTCOMES 已被基类处理。剩余异常 outcomesession_revived/api_error/fallback_timeout)极少出现,且旧逻辑不标 done 只是等 ticker 重投,最终效果差异不大。但严格对齐需要加白名单检查 |
| **D4** | A. 设计 §6 retry 逻辑 | 设计文档要求 retry 逻辑中 `handler = TaskTypeRegistry.get_by_project(project_id); if handler: return handler.build_retry_prompt(...)` | spawner L1118-1130 重试 prompt 仍用 `is_mail = project_id == "_mail"` 硬编码 | **轻微** | 当前不影响运行(旧的 `_build_mail_prompt` 仍保留且可用),但与设计文档不一致 |
| **D5** | B1.5 _check_reply 语义差异 | 旧 `_mail_check_reply`: `SELECT id FROM tasks WHERE id != ? AND must_haves LIKE ?` — 检查是否有其他任务的 must_haves 包含当前 task_id(即 in_reply_to 匹配) | 新 `MailHandler._check_reply`: `SELECT COUNT(*) FROM comments WHERE task_id=? AND author != 'daemon' AND comment_type != 'system'` — 检查当前任务是否有非系统 comment | **严重** | 两个查询语义完全不同。旧逻辑检查的是 **mail 表的回复任务**(通过 must_haves 中 in_reply_to 关联),新逻辑检查的是 **当前任务的 comments**。这可能导致 request 类型邮件的幻觉门控行为不同 |
| **D6** | B1.3 标 done 重试机制 | 旧 `_mail_auto_complete`: 标 done 时外层有 `for attempt in range(3)` 循环 | 新 `BaseTaskHandler._mark_task_status`: H1 修复后已有 3 次重试 | **轻微** | ✅ 已修复,但注意旧代码标 done 和标 failed 是分开的重试循环,新代码统一走 `_mark_task_status`。行为等价 |
---
## 一致确认项
### A. 设计一致性
| # | 维度 | 检查点 | 结果 |
|---|------|--------|------|
| A1 | §6 dispatcher | classify_outcome 后调 handler.post_complete | ✅ on_complete 闭包替换为 handler.post_complete |
| A2 | §6 dispatcher | on_checks_passed → handler.pre_spawn | ✅ _handler_on_checks_passed 调用 handler.pre_spawn(但返回值未检查,见 D1) |
| A3 | §6 dispatcher | guardrail 跳过 → handler 判断 | ✅ `is_handler_task = handler is not None` |
| A4 | §6 spawner | _build_prompt → handler.build_prompt | ✅ handler 路径调用 handler.build_prompt(ctx) |
| A5 | §6 spawner | _build_api_section → handler 查询 | ✅ handler 存在时 success_status 从 handler.target_success_status 获取 |
| A6 | §6 ticker | 虚拟项目扫描 → registry.virtual_projects() | ✅ 循环 `TaskTypeRegistry.virtual_projects()` |
| A7 | §6 ticker | check_completion → handler.check_completion | ✅ 超时检查中调 `handler.check_completion(task.id, db_path)` |
| A8 | §6 兼容期 | 设计说"兼容期保留旧逻辑" | ✅ 无 handler 的项目走旧路径(legacy_on_complete |
### B. 特殊逻辑覆盖
| # | 维度 | 检查点 | 结果 |
|---|------|--------|------|
| B1 | 1.1 guardrail | handler 项目跳过,_general 等走 guardrail | ✅ |
| B2 | 1.2 _mail_auto_working | `BEGIN IMMEDIATE` + status 检查 + 标 working | ✅ `_auto_mark_working` 完全一致 |
| B3 | 1.3 request 无回复 → 标 failed + notify | ✅ MailHandler.on_failure 调 `_mark_task_status(failed)` + `notify_mail_failed` |
| B4 | 1.4 _mail_revert_to_pending | spawn 失败回退 working → pending | ✅ Exception handler 中有 `BEGIN IMMEDIATE` + 状态检查回退 |
| B5 | 1.6 Task review verdict 读取 | approved → done | ✅ handle_review_complete |
| B6 | 1.6 Task review 非 approved → @mention assignee + 保持 review | ✅ H3 修复后保持 review + INSERT comment with comment_type='review' |
| B7 | 1.6 Task executor 三信号验证 | output/comment/terminal status → review | ✅ verify_completion 完全一致 |
| B8 | 1.7 Legacy dispatch 路径 | handler 替代 is_mail_legacy | ✅ handler_legacy 查注册表 |
| B9 | 2.1 _transition_status assignee 清空 | handler 项目不清空 | ✅ |
| B10 | 2.2 跳过 claimed 状态 | handler 项目跳过 claimed 直接 working | ✅ |
| B11 | 2.3 _dispatch_reviews 跳过 | handler 项目不走 review | ✅ |
| B12 | 2.5 startup recovery | `_general` + virtual_projects() | ✅ 不会重复扫描 |
| B13 | 3.1 _build_api_section | handler 存在时正确获取 success_status | ✅ |
| B14 | B4.1 TaskHandler.post_complete | 区分 executor/review 流程 | ✅ 通过读 DB status 判断 |
| B15 | B4.2 MailHandler.post_complete | 基类统一流程 | ✅ |
| B16 | B4.3 ToolchainHandler.post_complete | 基类统一流程 | ✅ |
| B17 | B1.5 _check_reply 异常保守处理 | 旧: return True(保守)/ 新: return False | 见 D5 |
| B18 | CRASH_OUTCOMES 集合 | 与旧 ROLLBACK_CURRENT_AGENT_OUTCOMES 一致 | ✅ 完全一致 |
| B19 | B2.1 _toolchain ticker 扫描 | _toolchain 会被 ticker 扫描 | ✅ _toolchain 有 blackboard.db 时会被 tick_project 处理 |
| B20 | B2.3 handler 项目都跳过 claimed | _toolchain 也跳过 | ✅ 所有 handler 项目统一处理 |
---
## 修复优先级
| 优先级 | # | 修复内容 |
|--------|---|---------|
| **P0** | D1 | dispatcher _handler_on_checks_passed 检查 pre_spawn 返回值 |
| **P0** | D2 | spawner PromptContext 从 must_haves 提取 from_agent 和 mail_type |
| **P0** | D5 | MailHandler._check_reply 恢复旧查询语义(检查 must_haves 中的 in_reply_to |
| P1 | D3 | inform outcome 白名单(可选,影响极小) |
| P2 | D4 | retry prompt 用 handler 路径替代硬编码 |
+324
View File
@@ -0,0 +1,324 @@
# Step 5 引擎接入 — 影响分析与逐点对照
## 方法论
逐行审查 dispatcher.py / spawner.py / ticker.py 中所有 `is_mail` / `_mail` / `project_id == "_mail"` 分支,
对照 handler 实现,确认每个特殊处理的去向。
---
## 一、dispatcher.py985 行)
### 1.1 Guardrail 跳过(L127-129
```python
is_mail = project_config.get("project_id") == "_mail" if project_config else False
if self.guardrails and not is_mail:
violations = self.guardrails.check_task(task)
```
**特殊处理**Mail 不做 guardrail 检查。
**Handler 覆盖**:设计文档 D6 "skip_guardrail 从接口删除,guardrail 自己判断"。Step 5 改为:`if self.guardrails and handler is None`(无 handler 时走 guardrail),或者用 handler.virtual_project 判断。handler 存在时跳过 guardrail。
**改动**`is_mail``TaskTypeRegistry.get_by_project(project_id) is not None`
---
### 1.2 Mail on_checks_passedL194-213
```python
on_checks_passed = None
_mail_marked_working = False
if is_mail and db_path:
def _mail_on_checks_passed():
nonlocal _mail_marked_working
if not _disp._mail_auto_working(_task_id, _mail_db):
raise RuntimeError("mail_auto_working_failed")
_mail_marked_working = True
on_checks_passed = _mail_on_checks_passed
```
**特殊处理**Mail spawn 前通过 on_checks_passed 回调标 working,标记成功后才 spawnspawn 失败回退。
**Handler 覆盖**MailHandler.pre_spawn 调用 `_auto_mark_working`,和 `_mail_auto_working` 逻辑完全一致。
**改动**
- `on_checks_passed` 改为调用 `handler.pre_spawn(task_id, db_path)`
- `_mail_marked_working` 标记保留,用于 Exception 回退
---
### 1.3 Mail on_completeL224-238
```python
if is_mail:
def _mail_on_complete(aid, outcome):
_dispatcher._mail_auto_complete(_task_id, aid, _mail_db, _must_haves, outcome=outcome)
on_complete = _mail_on_complete
```
**特殊处理**Mail on_complete 调用 `_mail_auto_complete`(含 inform/request 分支、幻觉门控、重试 3 次、失败通知)。
**Handler 覆盖**MailHandler 使用基类 post_complete 统一流程(crash→verify→mark→notify)。但现有 `_mail_auto_complete` 有几个细节差异需要注意:
| 现有逻辑 | Handler 覆盖 | 差异 |
|---------|-------------|------|
| request 无回复 → 重试 3 次标 failed | on_failure 标 failed + notify | ⚠️ 缺少 3 次重试 |
| inform 只在特定 outcome 标 done | verify 始终返回 True → 基类标 done | ✅ 简化了,合理 |
| 标 done 重试 3 次 | _mark_task_status 单次 | ⚠️ 缺少重试 |
| notify_mail_failed | on_failure 中调用 notify_mail_failed | ✅ 一致 |
**⚠️ 关键发现**:现有代码标状态时有 **重试 3 次** 机制(防止 DB 锁),handler 的 `_mark_task_status` 只做一次。需要把重试逻辑补到 `_mark_task_status` 或在 handler 层加。
**改动**on_complete 改为调用 `handler.post_complete(task_id, agent_id, outcome, db_path)`
---
### 1.4 Task on_completeL241-310
```python
else:
def _task_on_complete(aid, outcome):
# #07.2: crash 回退
if outcome in ROLLBACK_CURRENT_AGENT_OUTCOMES and _task_db:
_dispatcher._rollback_current_agent(_task_db, _task_id, aid)
if _is_review:
if outcome in ("completed", "session_revived"):
# 读 verdict → approved 标 done / 非 approved @mention assignee
else:
logger.warning("review agent outcome=%s, NOT marking done", outcome)
else:
# executor: 三信号验证 → 标 review
_dispatcher._task_auto_complete(_task_id, _task_db)
```
**特殊处理清单**
1. **#07.2 crash 回退**executor 和 review 都回退 current_agent → assignee
2. **review 分支**outcome 必须是 "completed" 或 "session_revived" 才走 verdict 读取
3. **review verdict 读取**approved → done,非 approved → @mention assignee + 保持 review
4. **review @mention**:通过 Blackboard.add_commentcomment_type="review"
5. **executor 分支**:走 _task_auto_complete → 三信号验证 → review
**Handler 覆盖**
- crash 回退:✅ BaseTaskHandler.post_complete 第一步
- review verdict:⚠️ **TaskHandler.handle_review_complete 存在但未被 dispatcher 调用**。现有 dispatcher 直接在闭包里做了,不走 handler。
- @mention:⚠️ handler 用 `conn.execute("INSERT INTO comments")` 直接插入,dispatcher 用 `Blackboard.add_comment`(会做更多处理,如 comment_type="review"
- executor 三信号:✅ TaskHandler.verify_completion
**⚠️ 关键发现**
1. dispatcher 的 review @mention`bb.add_comment(..., comment_type="review")`handler 直接 INSERT 不带 comment_type。需要修复 handler。
2. dispatcher 对 review outcome 有白名单检查(只处理 "completed"/"session_revived"),handler 的 post_complete 没有 outcome 白名单——crash 已在基类处理,其他 outcome 都会走 verify。
3. dispatcher review 非 approved 时**保持 review 状态**handler 的 handle_review_complete 标回 working。这是**行为差异**。
**改动**:需要先修复 handler 的 review 分支,再替换 on_complete。
---
### 1.5 Mail spawn 失败回退(L355-358
```python
except Exception as e:
if _mail_marked_working:
self._mail_revert_to_pending(task.id, db_path)
```
**特殊处理**spawn 失败(subprocess 启动失败)回退 working → pending。
**Handler 覆盖**:❌ handler 没有这个。这是 dispatcher 级别的异常处理,和 handler 无关。但 toolchain 也需要类似逻辑。
**改动**:保留在 dispatcher 中,改为 `_mail_marked_working``handler_marked_working`
---
### 1.6 Legacy dispatchL584-660
```python
is_mail_legacy = project_config.get("project_id") == "_mail"
if is_mail_legacy:
if not self._mail_auto_working(task.id, db_path_legacy):
return error
```
**特殊处理**legacy 路径(router=None 时触发)也有 mail 特殊处理。
**Handler 覆盖**:同 1.2/1.3,用 handler 替代。
**改动**:同样用 handler.pre_spawn 和 handler.post_complete 替代。
---
### 1.7 现有 Mail 辅助方法(L658-870
`_mail_auto_working` / `_mail_revert_to_pending` / `_mail_auto_complete` / `_mail_check_reply`
**改动**:Step 5 不删这些方法(安全起见保留,标记 deprecated),只改调用方。确认稳定后再删。
---
## 二、spawner.py1704 行)
### 2.1 _build_prompt 中的 mail 分支(L282-284
```python
if project_id == "_mail":
return self._build_mail_prompt(task_id, title, description, must_haves, agent_id)
```
**特殊处理**Mail 用专用精简模板。
**Handler 覆盖**MailHandler.build_prompt 通过 PromptComposer 拼 3 个 section。
**改动**:查注册表 → handler.build_prompt(context)。需要构建 PromptContext 传入。
---
### 2.2 _build_api_sectionL321-325
```python
success_status = '"done"' if project_id == "_mail" else '"review"'
```
**特殊处理**Mail 的 success_status 是 done。
**Handler 覆盖**:已由 handler 的 PromptSection 处理(TaskApiSection hardcode reviewMailApiSection 不含 status 回写指令)。
**改动**:如果 handler 存在,跳过 _build_api_sectionhandler.build_prompt 已包含)。
---
### 2.3 classify_outcome 中的 handler 调用
spawner 在 classify_outcome 后调 on_complete(outcome)。on_complete 是 dispatcher 传入的闭包。
**改动**on_complete 闭包改为调用 handler.post_complete。spawner 本身不直接查注册表。
---
## 三、ticker.py1897 行)
### 3.1 虚拟项目扫描(L218-229
```python
mail_db = Path(self.registry.root) / "_mail" / "blackboard.db"
if mail_db.exists() and "_mail" not in active_projects:
pr = await self._tick_project("_mail", {...})
```
**特殊处理**_mail 硬编码扫描。
**Handler 覆盖**TaskTypeRegistry.virtual_projects() 返回 ["_toolchain", "_mail"]。
**改动**:循环 `TaskTypeRegistry.virtual_projects()` 替代硬编码。_toolchain 如果也需要 ticker 扫描就自动发现。但需确认 _toolchain 是否需要 ticker——当前 toolchain 任务创建和完成都在 toolchain_routes.py 中处理,可能不需要 ticker 扫描。
---
### 3.2 _transition_status 中 mail assignee 不清空(L953-960
```python
if new_status == "pending":
if self._current_project_id == "_mail":
# Mail 的 assignee 是收件人,永不清空
conn.execute("UPDATE tasks SET status=?, updated_at=? WHERE id=?", ...)
else:
conn.execute("UPDATE tasks SET status=?, assignee=NULL, ...", ...)
```
**特殊处理**Mail 重置到 pending 时不清空 assigneeassignee 是收件人)。
**Handler 覆盖**:❌ handler 不管 ticker 的状态转换逻辑。这是 ticker 内部逻辑。
**改动**:用 `TaskTypeRegistry.get_by_project(project_id)` 判断替代硬编码。
---
### 3.3 Mail 跳过 claimed 状态(L1029-1043
```python
if project_id == "_mail":
conn.execute("UPDATE tasks SET current_agent=? WHERE id=?", ...)
# 跳过 claimed,直接 working
```
**特殊处理**Mail 不走 claimed 中间态(已在 dispatcher 中标 working)。
**Handler 覆盖**handler.pre_spawn 的 _auto_mark_working 跳过了 claimed。
**改动**:用 handler 判断替代硬编码。
---
### 3.4 _dispatch_reviews 跳过 mailL1304
```python
if project_id == "_mail":
return []
```
**特殊处理**Mail 不走 review 流程。
**Handler 覆盖**MailHandler.target_success_status = "done",不走 review。但 ticker 的 _dispatch_reviews 是看项目级。
**改动**:用 handler 判断。
---
### 3.5 Mail 幻觉门控兜底(L1474-1492
```python
if self._current_project_id == "_mail":
has_reply = self._mail_check_reply(task.id, db_path)
if has_reply:
# working → done
```
**特殊处理**:Ticker 超时检查时,如果 mail 有回复,标 done 而非 failed。
**Handler 覆盖**:❌ handler 的 check_completion 只返回 bool,不做状态标记。
**改动**:调用 handler.check_completion 替代 _mail_check_reply。状态标记逻辑保留在 ticker 中。
---
### 3.6 _mail_check_replyL1555-1575
和 dispatcher 版本一致。
**改动**:用 handler.check_completion 替代。
---
### 3.7 虚拟项目 init + recovery 扫描(L1625-1643
```python
for virtual_id in ("_general", "_mail"):
...
# _mail 项目不清空 assignee
```
**改动**virtual_projects() + _general 硬编码。
---
## 四、Handler 缺陷(需在 Step 5 前修复)
| # | 缺陷 | 影响 | 修复方案 |
|---|------|------|---------|
| H1 | BaseTaskHandler._mark_task_status 无重试 | DB 锁时标状态失败,任务卡住 | 加 3 次重试(和 dispatcher 现有行为一致) |
| H2 | TaskHandler.handle_review_complete 中 @mention 不带 comment_type="review" | review comment 无类型标记 | INSERT 加 comment_type |
| H3 | dispatcher review 非 approved 保持 review 状态,handler 标 working | **行为差异** | handler 改为保持 review 状态(和 dispatcher 一致) |
| H4 | dispatcher review outcome 有白名单("completed"/"session_revived"),handler 无 | crash 之外的异常 outcome 也会走 verify | handler 的 post_complete 已在基类处理 crash,其余 outcome 走 verify 是合理的 |
**H3 最关键**——dispatcher review 非 approved 保持 review 状态(等 assignee 自己处理),handler 标 working 会触发 ticker 重新 dispatch executor,这不是预期行为。
## 五、改动策略
**不删旧代码,只改调用方**
1. dispatcher 中 is_mail → handler 判断,on_checks_passed/on_complete → handler.pre_spawn/post_complete
2. spawner 中 _build_prompt → handler.build_prompt
3. ticker 中虚拟项目扫描 → registry.virtual_projects()mail 特殊判断 → handler 判断
4. 旧方法(_mail_auto_working 等)标记 @deprecated 保留,不删
**先修 handler 缺陷(H1-H3),再改引擎**
+183
View File
@@ -0,0 +1,183 @@
"""base_task_handler.py — Task type handler 基类。
收敛合理的共性能力(crash rollback + verify + mark + notify),
子类只实现差异点。
"""
from __future__ import annotations
import logging
from dataclasses import dataclass
from pathlib import Path
from typing import Optional
from src.daemon.prompt_composer import PromptContext, PromptComposer, PromptSection
from src.blackboard.db import get_connection
logger = logging.getLogger("moziplus-v2.handler")
@dataclass
class VerifyResult:
"""验证结果"""
passed: bool
reason: str # "has_output" / "no_reply" / "no_signal" / ...
evidence: str # "output_count=1, comment_count=0"
can_retry: bool = True
retry_count: int = 0
class BaseTaskHandler:
"""所有 task type handler 的基类。
职责:L2 引擎注入层的业务逻辑——prompt 构建、完成验证、状态标记。
不管:进程生命周期、exit 分类、重试决策(这些归 spawner)。
"""
# crash 类 outcome(进程级异常,需要 rollback)
CRASH_OUTCOMES = frozenset({
"crashed", "compact_failed", "process_crash",
"session_stuck", "compact_hanging",
})
task_type: str = ""
virtual_project: Optional[str] = None
display_name: str = "" # 中文展示名(ticker 扫描日志用)
# === 子类必须实现 ===
def build_prompt(self, context: PromptContext) -> str:
"""构建 L2 prompt(通过 PromptComposer 拼 section)。子类实现。"""
raise NotImplementedError
def verify_completion(self, task_id: str, db_path: Path) -> VerifyResult:
"""验证任务完成质量。每个 handler 自己的验证逻辑。子类实现。"""
raise NotImplementedError
def target_success_status(self) -> str:
"""验证通过后的目标状态。task='review', mail/toolchain='done'"""
return "review"
def get_sections(self) -> list[PromptSection]:
"""返回此 handler 的 prompt section 列表。子类实现。"""
return []
# === 基类提供统一流程 ===
def pre_spawn(self, task_id: str, db_path: Path) -> bool:
"""spawn 前业务准备。默认 True。
mail/toolchain override 为 auto_working。"""
return True
def post_complete(self, task_id: str, agent_id: str,
outcome: str, db_path: Path) -> None:
"""spawn 完成后的业务处理。统一 4 步流程:
1. crash 处理 → rollback current_agent
2. verify → 验证产出
3. mark → 标目标状态
4. notify → 失败时 on_failure
"""
# 1. crash 处理(基类提供,所有 handler 继承)
if outcome in self.CRASH_OUTCOMES:
self._rollback_current_agent(db_path, task_id, agent_id)
return
# 2. verify
result = self.verify_completion(task_id, db_path)
# 3. mark
if result.passed:
self._mark_task_status(db_path, task_id, self.target_success_status())
logger.info("Task %s: verify passed (%s), marked %s",
task_id, result.reason, self.target_success_status())
else:
# 4. notify
self.on_failure(task_id, agent_id, db_path, result)
def on_failure(self, task_id: str, agent_id: str,
db_path: Path, verify: VerifyResult) -> None:
"""验证失败处理。默认:标 failed。子类可 override。"""
self._mark_task_status(db_path, task_id, "failed")
logger.info("Task %s: verify failed (%s), marked failed",
task_id, verify.reason)
def check_completion(self, task_id: str, db_path: Path) -> bool:
"""ticker 级别的完成检查。默认:False。"""
return False
# === 内部工具方法 ===
def _rollback_current_agent(self, db_path: Path, task_id: str, agent_id: str) -> None:
"""crash 后回退 current_agent → assignee,避免 exclude_current 卡死。
从 dispatcher._rollback_current_agent 迁移。"""
try:
conn = get_connection(db_path)
try:
conn.execute(
"UPDATE tasks SET current_agent = "
"(SELECT assignee FROM tasks WHERE id=?) "
"WHERE id=? AND current_agent=?",
(task_id, task_id, agent_id)
)
conn.commit()
finally:
conn.close()
logger.info("Task %s: rolled back current_agent from %s to assignee",
task_id, agent_id)
except Exception as e:
logger.warning("Task %s: failed to rollback current_agent: %s",
task_id, e)
def _mark_task_status(self, db_path: Path, task_id: str, status: str) -> None:
"""更新任务状态 + 写审计事件(带 3 次重试,防 SQLite DB 锁)。"""
for attempt in range(3):
try:
conn = get_connection(db_path)
try:
conn.execute("BEGIN IMMEDIATE")
old_row = conn.execute(
"SELECT status FROM tasks WHERE id=?", (task_id,)
).fetchone()
old_status = old_row["status"] if old_row else "unknown"
conn.execute(
"UPDATE tasks SET status=?, updated_at=datetime('now') WHERE id=?",
(status, task_id),
)
conn.execute(
"INSERT INTO events (task_id, agent, event_type, payload) "
"VALUES (?, 'handler', 'status_change', ?)",
(task_id,
f'{{"from": "{old_status}", "to": "{status}", '
f'"source": "{self.task_type}_handler"}}'),
)
conn.commit()
return
finally:
conn.close()
except Exception as e:
logger.warning("Handler: mark %s%s attempt %d failed: %s",
task_id, status, attempt + 1, e)
logger.error("Handler: mark %s%s all 3 attempts failed", task_id, status)
def _auto_mark_working(self, task_id: str, db_path: Path) -> bool:
"""pending → workingmail/toolchain 通用)。"""
try:
conn = get_connection(db_path)
try:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
"SELECT status FROM tasks WHERE id=?", (task_id,)).fetchone()
if not row or row["status"] not in ("pending", "claimed"):
logger.warning("Task %s: cannot mark working (status=%s)",
task_id, row["status"] if row else "not found")
return False
conn.execute(
"UPDATE tasks SET status='working', updated_at=datetime('now') "
"WHERE id=?", (task_id,))
conn.commit()
logger.info("Task %s: auto-marked working", task_id)
return True
finally:
conn.close()
except Exception as e:
logger.error("Task %s: failed to mark working: %s", task_id, e)
return False
+106 -94
View File
@@ -22,6 +22,7 @@ from src.blackboard.models import Task
from src.blackboard.db import get_connection
from src.daemon.spawner import AgentBusyError
from src.daemon.router import AgentRouter
from src.daemon.task_type_registry import TaskTypeRegistry
logger = logging.getLogger("moziplus-v2.dispatcher")
@@ -123,10 +124,11 @@ class Dispatcher:
"status": "dispatched"|"skipped"|"error"|"blocked", "reason": str}
"""
# 安全红线检查(调度前拦截)
# Mail 是 Agent 间通信,不做 guardrail 检查
is_mail = project_config.get(
"project_id") == "_mail" if project_config else False
if self.guardrails and not is_mail:
# handler 项目(_mail/_toolchain不做 guardrail 检查
handler = TaskTypeRegistry.get_by_project(
project_config.get("project_id", "") if project_config else "")
is_handler_task = handler is not None
if self.guardrails and not is_handler_task:
violations = self.guardrails.check_task(task)
critical = [
v for v in violations if v.action in (
@@ -190,27 +192,26 @@ class Dispatcher:
}
try:
# [v2.7.1] Mail: 标 working 移到 spawn_full_agent 内部(check 通过后、subprocess 前)
is_mail = project_config.get(
"project_id") == "_mail" if project_config else False
if is_mail:
db_path = Path(
project_config["db_path"]) if project_config and "db_path" in project_config else None
# [Step 5] Handler: pre_spawn + on_checks_passed 统一
project_id = project_config.get("project_id", "") if project_config else ""
handler = TaskTypeRegistry.get_by_project(project_id)
db_path = Path(
project_config["db_path"]) if project_config and "db_path" in project_config else None
# on_checks_passed: 所有检查通过后才标 working,检查失败不标
# on_checks_passed: handler 项目在 check 通过后调用 handler.pre_spawn
on_checks_passed = None
_mail_marked_working = False
if is_mail and db_path:
handler_marked_working = False
if handler and db_path:
_task_id = task.id
_mail_db = db_path
_disp = self
_handler_db = db_path
_handler = handler
def _mail_on_checks_passed():
nonlocal _mail_marked_working
if not _disp._mail_auto_working(_task_id, _mail_db):
raise RuntimeError("mail_auto_working_failed")
_mail_marked_working = True
on_checks_passed = _mail_on_checks_passed
def _handler_on_checks_passed():
nonlocal handler_marked_working
if not _handler.pre_spawn(_task_id, _handler_db):
raise RuntimeError("handler_pre_spawn_failed")
handler_marked_working = True
on_checks_passed = _handler_on_checks_passed
# 构建 spawn message
message = self._build_spawn_message(task, agent_id, project_config,
@@ -218,94 +219,84 @@ class Dispatcher:
"mode", ""),
spawn_type=action_type or "executor")
# v2.7.2: on_complete 只含业务逻辑,不含 counter.release
# counter.release 由 spawn_full_agent 内部的 wrapped_on_complete 保证
# [Step 5] Handler: on_complete 统一走 handler.post_complete
# 保留旧路径作为 fallback(无 handler 的项目)
on_complete = None
if is_mail:
if handler:
_task_id = task.id
_mail_db = db_path
_must_haves = task.must_haves or ""
_dispatcher = self
_handler_db = db_path
_handler = handler
def _mail_on_complete(aid, outcome):
# 幻觉门控:检查是否有回复,自动标 done/failed
def _handler_on_complete(aid, outcome):
try:
_dispatcher._mail_auto_complete(
_task_id, aid, _mail_db, _must_haves, outcome=outcome)
_handler.post_complete(
_task_id, aid, outcome, _handler_db)
except Exception as e:
logger.error(
"Mail %s: on_complete error: %s", _task_id, e)
on_complete = _mail_on_complete
"Handler %s: on_complete error: %s", _task_id, e)
on_complete = _handler_on_complete
else:
# #02: Task 路径也加 on_complete(幻觉门控
# 旧路径:无 handler 的项目(_general 等
_task_id = task.id
_task_db = Path(
project_config["db_path"]) if project_config and "db_path" in project_config else None
_task_db = db_path
_dispatcher = self
_is_review = action_type == "review"
# #07.2: executor/review 统一 crash 回退
ROLLBACK_CURRENT_AGENT_OUTCOMES = frozenset({
"crashed", "compact_failed", "process_crash",
"session_stuck", "compact_hanging",
})
def _task_on_complete(aid, outcome):
def _legacy_on_complete(aid, outcome):
try:
# #07.2: 统一 crash 回退——executor 和 review 都回退 current_agent
if outcome in ROLLBACK_CURRENT_AGENT_OUTCOMES and _task_db:
_dispatcher._rollback_current_agent(
_task_db, _task_id, aid)
if _is_review:
if _task_db and outcome in (
"completed", "session_revived"):
# #09: 读 verdict 决定后续动作
conn = get_connection(_task_db)
if _task_db and outcome in ("completed", "session_revived"):
from src.blackboard.blackboard import Blackboard
# get_connection 已在文件顶部 L22 import
rconn = get_connection(_task_db)
try:
review = conn.execute(
"SELECT verdict FROM reviews WHERE task_id=? ORDER BY created_at DESC LIMIT 1",
(_task_id,)
).fetchone()
review_row = rconn.execute(
"SELECT verdict, reviewer, comment FROM reviews "
"WHERE task_id=? ORDER BY created_at DESC LIMIT 1",
(_task_id,)).fetchone()
finally:
conn.close()
rconn.close()
if review and review["verdict"] == "approved":
if review_row and review_row["verdict"] == "approved":
_dispatcher._mark_task_status(
_task_db, _task_id, "done")
logger.info(
"Task %s: review approved, marking done", _task_id)
"Legacy %s: review approved, marked done", _task_id)
else:
# 非 approved → @mention 被审
# agentassignee,非 current_agent
verdict_str = review["verdict"] if review else "未知"
conn2 = get_connection(_task_db)
verdict_str = review_row["verdict"] if review_row else "未知"
tconn = get_connection(_task_db)
try:
task_row = conn2.execute(
"SELECT assignee FROM tasks WHERE id=?", (_task_id,)).fetchone()
t_row = tconn.execute(
"SELECT assignee FROM tasks WHERE id=?",
(_task_id,)).fetchone()
finally:
conn2.close()
if task_row and task_row["assignee"]:
from src.blackboard.blackboard import Blackboard
bb = Blackboard(_task_db)
bb.add_comment(_task_id, "daemon",
f"@{task_row['assignee']} 审查结论: {verdict_str},请查看详情并决定接受或反驳",
comment_type="review")
logger.info("Task %s: review verdict=%s, notified assignee=%s",
_task_id, verdict_str, task_row["assignee"] if task_row else "?")
# 不标 done,保持 review 状态
else:
logger.warning(
"Task %s: review agent %s (%s), NOT marking done", _task_id, aid, outcome)
tconn.close()
if t_row and t_row["assignee"]:
bb = Blackboard(str(_task_db))
bb.add_comment(
_task_id, "daemon",
f"@{t_row['assignee']} review 未通过 "
f"(verdict={verdict_str}): "
f"{review_row['comment'] if review_row else ''}",
comment_type="review")
logger.info(
"Legacy %s: review not approved (%s), "
"@mentioned assignee",
_task_id, verdict_str)
else:
# executor: 三信号验证 → 标 review
_dispatcher._task_auto_complete(
_task_id, _task_db)
_dispatcher._task_auto_complete(_task_id, _task_db)
except Exception as e:
logger.error(
"Task %s: on_complete error: %s", _task_id, e)
on_complete = _task_on_complete
"Legacy %s: on_complete error: %s", _task_id, e)
on_complete = _legacy_on_complete
session_id = await self.spawner.spawn_full_agent(
agent_id=agent_id,
@@ -354,8 +345,26 @@ class Dispatcher:
}
except Exception as e:
# on_checks_passed 已执行但 subprocess 失败 → 回退 working → pending
if _mail_marked_working:
self._mail_revert_to_pending(task.id, db_path)
if handler_marked_working and handler and db_path:
# handler 项目:回退到 pending
try:
conn = get_connection(db_path)
try:
conn.execute("BEGIN IMMEDIATE")
row = conn.execute(
"SELECT status FROM tasks WHERE id=?", (task.id,)).fetchone()
if row and row["status"] == "working":
conn.execute(
"UPDATE tasks SET status='pending', updated_at=datetime('now') WHERE id=?",
(task.id,))
conn.commit()
logger.info(
"Task %s: reverted working → pending (spawn failed)", task.id)
finally:
conn.close()
except Exception as revert_err:
logger.error(
"Task %s: failed to revert to pending: %s", task.id, revert_err)
self._record_routing(
task, decision, "error", str(e), _routing_db)
return {
@@ -580,17 +589,18 @@ class Dispatcher:
try:
# NOTE: _legacy_dispatch 仅在 router=None 时触发,当前配置不会进入。
# Mail 永远走 dispatch() 主路径(on_checks_passed 方案),不走此路径。
# 如果未来 legacy 路径被启用,需同步 on_checks_passed 逻辑。
is_mail_legacy = project_config.get(
"project_id") == "_mail" if project_config else False
if is_mail_legacy:
# [Step 5] handler 统一:用注册表查 handler
project_id_legacy = project_config.get("project_id", "") if project_config else ""
handler_legacy = TaskTypeRegistry.get_by_project(project_id_legacy)
if handler_legacy:
db_path_legacy = Path(
project_config["db_path"]) if project_config and "db_path" in project_config else None
if not db_path_legacy or not self._mail_auto_working(
task.id, db_path_legacy):
if db_path_legacy:
handler_legacy.pre_spawn(task.id, db_path_legacy)
else:
return {"level": level.value, "agent_id": agent_id,
"session_id": None, "status": "error",
"reason": "mail_auto_working_failed"}
"reason": "no db_path for handler"}
if hasattr(self.spawner,
'build_spawn_message') and project_config:
@@ -612,20 +622,18 @@ class Dispatcher:
# v2.7.2: on_complete 只含业务逻辑
on_complete_legacy = None
if is_mail_legacy:
if handler_legacy:
_t_id = task.id
_m_db = db_path_legacy
_m_mh = task.must_haves or ""
_disp = self
_h_db = db_path_legacy
_h = handler_legacy
def _mail_oc_legacy(aid, outcome):
def _handler_oc_legacy(aid, outcome):
try:
_disp._mail_auto_complete(
_t_id, aid, _m_db, _m_mh, outcome=outcome)
_h.post_complete(_t_id, aid, outcome, _h_db)
except Exception as e:
logger.error(
"Mail %s: legacy on_complete error: %s", _t_id, e)
on_complete_legacy = _mail_oc_legacy
"Handler %s: legacy on_complete error: %s", _t_id, e)
on_complete_legacy = _handler_oc_legacy
session_id = await self.spawner.spawn_full_agent(
agent_id=agent_id, message=message,
@@ -655,6 +663,7 @@ class Dispatcher:
# ── Mail 信封/载荷分离辅助方法 ──
# DEPRECATED: Step 5 handler 架构已替代此方法,保留仅供平滑过渡,确认稳定后删除。
def _mail_auto_working(self, task_id: str, db_path: Path) -> bool:
"""Mail 任务:系统自动标 workingspawn 前)
@@ -692,6 +701,7 @@ class Dispatcher:
logger.error("Mail %s: failed to mark working: %s", task_id, e)
return False
# DEPRECATED: Step 5 handler 架构已替代此方法,保留仅供平滑过渡,确认稳定后删除。
def _mail_revert_to_pending(self, task_id: str, db_path: Path) -> None:
"""Mail spawn 失败时回退 working → pending,避免永久死锁"""
try:
@@ -721,6 +731,7 @@ class Dispatcher:
task_id,
e)
# DEPRECATED: Step 5 handler 架构已替代此方法,保留仅供平滑过渡,确认稳定后删除。
def _mail_auto_complete(self, task_id: str, agent_id: str,
db_path: Path, must_haves: str, outcome=None) -> None:
"""Mail 任务:on_complete 后自动标 done/failed(含幻觉门控)"""
@@ -828,6 +839,7 @@ class Dispatcher:
except Exception as e:
logger.error("Mail %s: auto-complete error: %s", task_id, e)
# DEPRECATED: Step 5 handler 架构已替代此方法,保留仅供平滑过渡,确认稳定后删除。
def _mail_check_reply(self, original_task_id: str, db_path: Path) -> bool:
"""幻觉门控:检查是否有回复邮件(in_reply_to = original_task_id"""
try:
+210
View File
@@ -0,0 +1,210 @@
"""mail_handler.py — Mail 任务 handler。
处理 Agent 间通信(飞鸽传书),含 inform 和 request 两种类型。
"""
from __future__ import annotations
import json
import logging
from pathlib import Path
from typing import Dict, Optional
from src.daemon.base_task_handler import BaseTaskHandler, VerifyResult
from src.daemon.prompt_composer import PromptComposer, PromptContext
from src.blackboard.db import get_connection
logger = logging.getLogger("moziplus-v2.handler.mail")
class MailHandler(BaseTaskHandler):
"""Mail 任务 handler。"""
task_type = "mail"
virtual_project = "_mail"
display_name = "飞鸽传书"
def target_success_status(self) -> str:
return "done"
def pre_spawn(self, task_id: str, db_path: Path) -> bool:
"""auto_workingpending → working"""
return self._auto_mark_working(task_id, db_path)
def build_prompt(self, context: PromptContext) -> str:
"""通过 PromptComposer 拼装 3 个 section。"""
composer = PromptComposer()
composer.add_many(self.get_sections())
return composer.compose(context)
def get_sections(self) -> list:
return [MailContextSection(), MailApiSection(), MailConstraintsSection()]
def verify_completion(self, task_id: str, db_path: Path) -> VerifyResult:
"""Mail 完成验证:区分 inform/request。
- inform: 始终通过(通知已阅即 done,不需要检查产出)
- request: 检查是否已回复
"""
performative = self._parse_performative(task_id, db_path)
if performative == "inform":
return VerifyResult(True, "inform_auto", f"performative={performative}")
# request: 检查是否已回复
has_reply = self._check_reply(task_id, db_path)
if has_reply:
return VerifyResult(True, "has_reply", f"performative={performative}")
return VerifyResult(False, "no_reply", f"performative={performative}")
# post_complete 由基类 BaseTaskHandler 统一处理(crash→verify→mark→notify
# inform: verify 始终通过 → 基类 mark done ✅
# request 有回复: verify 通过 → 基类 mark done ✅
# request 无回复: verify 失败 → 基类调 on_failure ✅
def on_failure(self, task_id: str, agent_id: str,
db_path: Path, verify: VerifyResult) -> None:
"""request 验证失败 → 标 failed + 通知发件人"""
self._mark_task_status(db_path, task_id, "failed")
logger.info("Mail %s: request verify failed (%s), marked failed",
task_id, verify.reason)
# 通知发件人
try:
from src.daemon.mail_notify import notify_mail_failed
notify_mail_failed(db_path, task_id, "no_reply_found")
except Exception as e:
logger.warning("Mail %s: failed to send notification: %s", task_id, e)
# === 内部方法 ===
def _parse_performative(self, task_id: str, db_path: Path) -> str:
"""解析 mail 类型(inform/request"""
try:
conn = get_connection(db_path)
try:
row = conn.execute(
"SELECT must_haves FROM tasks WHERE id=?", (task_id,)
).fetchone()
if row and row["must_haves"]:
meta = json.loads(row["must_haves"])
return meta.get("performative", meta.get("type", "request"))
finally:
conn.close()
except Exception:
pass
return "request"
def _check_reply(self, task_id: str, db_path: Path) -> bool:
"""检查是否已回复(查 tasks 表找 in_reply_to 回复邮件)
从 dispatcher._mail_check_reply 迁移。
Mail 回复机制:创建新 taskmust_haves JSON 中包含 in_reply_to = original_task_id。
不能查 comments 表——回复邮件是独立的 task,不是 comment。
"""
try:
conn = get_connection(db_path)
try:
row = conn.execute(
"SELECT id FROM tasks WHERE id != ? AND must_haves LIKE ? LIMIT 1",
(task_id, f'%{task_id}%'),
).fetchone()
return row is not None
finally:
conn.close()
except Exception as e:
logger.error("Mail %s: check reply error: %s", task_id, e)
# 查询失败时保守处理:假设有回复(避免误标 failed)
return True
def check_completion(self, task_id: str, db_path: Path) -> bool:
"""ticker 级别的完成检查:检查是否已回复"""
return self._check_reply(task_id, db_path)
# ===================================================================
# Mail PromptSections
# ===================================================================
class MailContextSection:
"""邮件上下文段 — 发件人/收件人/主题/内容,区分 inform/request。"""
name: str = "mail_context"
priority: int = 10
def render(self, context: PromptContext) -> str:
if context.mail_type == "inform":
return self._render_inform(context)
return self._render_request(context)
def should_include(self, context: PromptContext) -> bool: # noqa: ARG002
return True
@staticmethod
def _render_inform(context: PromptContext) -> str:
return (
f"你收到一封飞鸽传书(纯通知)。\n\n"
f"发件者: {context.from_agent}\n"
f"主题: {context.title}\n"
f"内容: {context.description}\n\n"
f"已阅即可。如需回复,用 in_reply_to 回复发件者(不需要填 to)。\n"
f"⚠️ 不要执行任何状态转换命令。"
)
@staticmethod
def _render_request(context: PromptContext) -> str:
return (
f"你收到一封飞鸽传书,需要你处理并回复。\n\n"
f"发件者: {context.from_agent}\n"
f"主题: {context.title}\n"
f"内容: {context.description}\n\n"
f"### 如何回复发件者\n\n"
f'curl -s -X POST http://localhost:8083/api/mail \\\n'
f" -H 'Content-Type: application/json' \\\n"
f' -d \'{{"from": "{context.agent_id}", '
f'"in_reply_to": "{context.task_id}", '
f'"title": "回复: {context.title}", '
f'"text": "你的回复内容"}}\'\n\n'
f"⚠️ 不需要填 \"to\",系统自动回复给发件者。"
)
class MailApiSection:
"""Mail API 操作指令段。"""
name: str = "mail_api"
priority: int = 40
def render(self, context: PromptContext) -> str:
return (
f"### 如何给其他人发新邮件\n\n"
f'curl -s -X POST http://localhost:8083/api/mail \\\n'
f" -H 'Content-Type: application/json' \\\n"
f' -d \'{{"from": "{context.agent_id}", '
f'"to": "对方agent-id", '
f'"title": "标题", '
f'"text": "正文", '
f'"type": "inform"}}\'\n\n'
f"⚠️ to 必须是有效的 agent id\n"
f"⚠️ 纯通知用 type=inform,需要对方回复不填 type(默认 request)"
)
def should_include(self, context: PromptContext) -> bool:
return context.mail_type == "request"
class MailConstraintsSection:
"""Mail 硬约束段。"""
name: str = "mail_constraints"
priority: int = 50
def render(self, context: PromptContext) -> str: # noqa: ARG002
return (
"## 硬约束\n\n"
"1. ⚠️ 不要执行任何状态转换命令(标 working/done/review/failed 等),系统会自动处理。\n"
"2. ⚠️ 不能给自己发邮件\n"
"3. ⚠️ 发邮件时 to 必须是有效的 agent id\n"
"4. ⚠️ 纯通知用 type=inform,需要对方回复不填 type(默认 request)"
)
def should_include(self, context: PromptContext) -> bool: # noqa: ARG002
return True
+35 -8
View File
@@ -19,6 +19,8 @@ from src.blackboard.db import get_connection
logger = logging.getLogger("moziplus-v2.spawner")
from src.daemon.task_type_registry import TaskTypeRegistry
# ── Prompt 模板 ──
@@ -278,10 +280,29 @@ class AgentSpawner:
task_id, title, description, must_haves,
project_id, agent_id)
# mail 任务用精简模板
if project_id == "_mail":
return self._build_mail_prompt(
task_id, title, description, must_haves, agent_id)
# handler 路径:Task/Mail/Toolchain 用各自的 PromptSection 构建
handler = TaskTypeRegistry.get_by_project(project_id)
if handler:
from src.daemon.prompt_composer import PromptContext
# 从 must_haves 解析 mail 元数据(from / performative
from_agent = ""
mail_type = ""
try:
meta = json.loads(must_haves) if must_haves else {}
from_agent = meta.get("from", "")
mail_type = meta.get("performative", meta.get("type", ""))
except Exception:
pass
ctx = PromptContext(
task_id=task_id, title=title, description=description or "",
must_haves=must_haves or "", project_id=project_id,
agent_id=agent_id, role=spawn_type,
spawn_type=spawn_type,
from_agent=from_agent, mail_type=mail_type,
)
return handler.build_prompt(ctx)
# 旧路径保留:_general 等非 handler 项目
# 走 BootstrapBuilder 新路径
if self.bootstrap_builder and task is not None:
@@ -321,8 +342,13 @@ class AgentSpawner:
def _build_api_section(self, project_id: str, task_id: str,
agent_id: str) -> str:
"""构建 API 回写操作指令(BootstrapBuilder 模式下补充)"""
# mail 任务直接 done,不走 review
success_status = '"done"' if project_id == "_mail" else '"review"'
# handler 项目(_mail/_toolchain)的 success_status 由 PromptSection 处理
# 这里只处理无 handler 的项目(normal task
handler = TaskTypeRegistry.get_by_project(project_id)
if handler:
success_status = '"done"' if handler.target_success_status == "done" else '"review"'
else:
success_status = '"review"'
return f"""## 操作指令
### 状态回写
@@ -1099,9 +1125,10 @@ curl -X POST http://{api_host}:{api_port}/api/projects/{project_id}/tasks/{task_
# 构建续杯 message(Mail 用专用模板,Task 用标准模板)
task_info = self._get_task_info(db_path, task_id) or {}
project_id = task_info.get("project_id", "")
is_mail = project_id == "_mail"
handler = TaskTypeRegistry.get_by_project(project_id)
is_handler = handler is not None
if is_mail:
if is_handler:
must_haves = task_info.get("must_haves", "{}")
try:
meta = json.loads(must_haves) if must_haves else {}
+387
View File
@@ -0,0 +1,387 @@
"""task_handler.py — 黑板任务 handlertask_type='task')。
标准黑板任务三信号验证 review 状态
"""
from __future__ import annotations
import logging
import os
from pathlib import Path
from typing import Dict, List, Optional
from src.daemon.base_task_handler import BaseTaskHandler, VerifyResult
from src.daemon.prompt_composer import PromptComposer, PromptContext
from src.blackboard.db import get_connection
logger = logging.getLogger("moziplus-v2.handler")
TERMINAL_STATES = frozenset({"review", "done", "failed", "cancelled"})
# ---------------------------------------------------------------------------
# Role → Skill 映射(D8 决策:L2 只给索引+引导语,不注全文)
# ---------------------------------------------------------------------------
ROLE_SKILL_MAP: Dict[str, str] = {
"executor": "blackboard-executor",
"reviewer": "blackboard-reviewer",
"reviewer-simayi": "blackboard-reviewer-simayi",
"reviewer-pangtong": "blackboard-reviewer-pangtong",
"planner": "blackboard-planner",
"claim": "blackboard-claim",
}
SKILL_BASE_PATH = os.environ.get(
"MOZI_SKILL_PATH",
"/Users/chufeng/.sanguo_projects/sanguo_mozi/skills",
)
# ---------------------------------------------------------------------------
# PromptSection 实现
# ---------------------------------------------------------------------------
class TaskContextSection:
"""段 1:任务上下文(title / desc / must_haves / status)。"""
name: str = "task_context"
priority: int = 10
def render(self, context: PromptContext) -> str:
parts = ["## 任务上下文"]
if context.task_id:
parts.append(f"任务ID: {context.task_id}")
if context.title:
parts.append(f"标题: {context.title}")
if context.description:
parts.append(f"描述: {context.description}")
if context.must_haves:
parts.append(f"必须完成: {context.must_haves}")
if context.task and context.task.get("status"):
parts.append(f"当前状态: {context.task['status']}")
return "\n".join(parts)
def should_include(self, context: PromptContext) -> bool:
return bool(context.task_id or context.title)
class PriorOutputsSection:
"""段 2:前序产出摘要(depends_on 非空时注入)。"""
name: str = "prior_outputs"
priority: int = 20
def render(self, context: PromptContext) -> str:
outputs = context.depends_on_outputs or []
parts = ["## 前序产出"]
for out in outputs:
tid = out.get("task_id", "?")
summary = out.get("summary", "无摘要")
parts.append(f"- [{tid}] {summary}")
return "\n".join(parts)
def should_include(self, context: PromptContext) -> bool:
return bool(context.depends_on_outputs)
class RoleSkillSection:
"""段 3:角色 Skill 全文注入(对齐设计 §2.3 + BootstrapBuilder 行为)。"""
name: str = "role_skill"
priority: int = 30
def render(self, context: PromptContext) -> str:
skill_name = ROLE_SKILL_MAP.get(context.role, "")
lines = [
"## 角色操作规范",
f"你的角色:{context.role}",
]
if skill_name:
skill_path = os.path.join(SKILL_BASE_PATH, skill_name, "SKILL.md")
try:
with open(skill_path, encoding="utf-8") as f:
skill_content = f.read()
if skill_content:
lines.append(skill_content)
else:
lines.append(f"Skill 文件为空:{skill_name}")
except FileNotFoundError:
lines.append(f"Skill 文件不存在:{skill_name}")
else:
lines.append("无对应 Skill 文件,按通用规范执行。")
return "\n".join(lines)
def should_include(self, context: PromptContext) -> bool:
return True
class TaskApiSection:
"""段 4API 操作指令。"""
name: str = "task_api"
priority: int = 40
API_HOST = "localhost"
API_PORT = 8083
def render(self, context: PromptContext) -> str:
pid = context.project_id
tid = context.task_id
aid = context.agent_id
success_status = '"review"'
base = f"http://{self.API_HOST}:{self.API_PORT}/api/projects/{pid}/tasks/{tid}"
return (
"## 操作指令\n"
"### 状态回写\n"
f"开始工作:\n"
f'curl -X POST {base}/status \\\n'
f' -H "Content-Type: application/json" \\\n'
f' -d \'{{"status": "working", "agent": "{aid}"}}\'\n\n'
"### 写入产出\n"
f'curl -X POST {base}/outputs \\\n'
f' -H "Content-Type: application/json" \\\n'
f" -d '{{\"type\": \"text\", \"content\": \"<your output>\"}}'\n\n"
"### 完成后\n"
f"成功: status → {success_status} | 失败: status → \"failed\""
)
def should_include(self, context: PromptContext) -> bool:
return True
class TaskConstraintsSection:
"""段 5:硬约束。"""
name: str = "task_constraints"
priority: int = 50
def render(self, context: PromptContext) -> str:
constraints = ["## 硬约束"]
role = context.role
if role == "executor":
constraints.extend([
"- 完成后必须标 review",
"- 产出物不能为空(系统会验证)",
"- handoff comment ≥ 50 字符",
])
elif role.startswith("reviewer"):
constraints.extend([
"- 审查结果必须明确 pass/fail",
"- 评审意见须附证据(文件:行号)",
])
elif role == "planner":
constraints.extend([
"- 需求不清时提问,不要猜",
"- 子任务必须有明确的终态定义",
])
else:
constraints.append("- 按规范完成 assigned 任务")
return "\n".join(constraints)
def should_include(self, context: PromptContext) -> bool:
return True
class TaskHandler(BaseTaskHandler):
"""黑板标准任务 handler。
- verify: 三信号检查output / comment / terminal status
- 成功 review
- 失败 保持 working ticker 重试
- review 完成 读取 verdictapproved mark done
"""
task_type: str = "task"
virtual_project: Optional[str] = None
display_name = "黑板任务"
# === 子类实现 ===
def post_complete(self, task_id: str, agent_id: str,
outcome: str, db_path: Path) -> None:
"""Task on_complete:区分 executor 和 review。
executor: 基类统一流程crash verify mark review
review: handle_review_complete verdict done/keep review
"""
# crash 处理(所有类型共用)
if outcome in self.CRASH_OUTCOMES:
self._rollback_current_agent(db_path, task_id, agent_id)
return
# 检查当前任务状态:如果是 review 状态 → review 完成流程
try:
conn = get_connection(db_path)
try:
row = conn.execute(
"SELECT status FROM tasks WHERE id=?", (task_id,)
).fetchone()
task_status = row["status"] if row else "unknown"
finally:
conn.close()
except Exception:
task_status = "unknown"
if task_status == "review":
# review 完成流程:只处理正常 outcome
if outcome in ("completed", "session_revived"):
self.handle_review_complete(task_id, db_path)
else:
logger.warning(
"Task %s: review agent %s abnormal outcome=%s, keeping review",
task_id, agent_id, outcome)
else:
# executor 完成流程:基类统一 verify → mark
result = self.verify_completion(task_id, db_path)
if result.passed:
self._mark_task_status(db_path, task_id, self.target_success_status())
logger.info("Task %s: verify passed (%s), marked %s",
task_id, result.reason, self.target_success_status())
else:
logger.info(
"Task %s: verify not passed (%s), leaving working",
task_id, result.reason)
# NOTE: executor verify 不通过时不标 failed,留 working。
# 原因:Agent 可能还在产出中(幻觉门控的后续轮次),
# ticker 超时检查会兜底处理。不调 on_failure 避免误判。
def target_success_status(self) -> str:
"""task 类型验证通过后进 review。"""
return "review"
def verify_completion(self, task_id: str, db_path: Path) -> VerifyResult:
"""三信号验证:output / comment / terminal status。"""
try:
conn = get_connection(db_path)
try:
# 信号 1terminal status
row = conn.execute(
"SELECT status FROM tasks WHERE id=?", (task_id,)
).fetchone()
if not row:
return VerifyResult(False, "not_found", "task not found",
can_retry=False)
status = row["status"]
if status in TERMINAL_STATES:
return VerifyResult(
True, "terminal_status",
f"status={status}", can_retry=False
)
# 信号 2outputs
output_count = conn.execute(
"SELECT COUNT(*) as cnt FROM outputs WHERE task_id=?",
(task_id,)
).fetchone()["cnt"]
if output_count > 0:
return VerifyResult(
True, "has_output",
f"output_count={output_count}"
)
# 信号 3:非 system 且内容 >= 50 字的 comment
comment_count = conn.execute(
"SELECT COUNT(*) as cnt FROM comments "
"WHERE task_id=? AND author != 'system' "
"AND LENGTH(content) >= 50",
(task_id,)
).fetchone()["cnt"]
if comment_count > 0:
return VerifyResult(
True, "has_comment",
f"comment_count={comment_count}"
)
# 无信号
return VerifyResult(
False, "no_signal",
f"output=0, comment=0, status={status}"
)
finally:
conn.close()
except Exception as e:
logger.error("Task %s: verify error: %s", task_id, e)
return VerifyResult(False, "verify_error", str(e))
def pre_spawn(self, task_id: str, db_path: Path) -> bool:
"""task 类型不需要 pre_spawn 逻辑。"""
return True
def get_sections(self) -> list:
"""返回 5 个 PromptSection 实例。"""
return [
TaskContextSection(),
PriorOutputsSection(),
RoleSkillSection(),
TaskApiSection(),
TaskConstraintsSection(),
]
def build_prompt(self, context: PromptContext) -> str:
"""通过 PromptComposer 拼装 prompt sections。"""
composer = PromptComposer()
composer.add_many(self.get_sections())
return composer.compose(context)
def on_failure(self, task_id: str, agent_id: str,
db_path: Path, verify: VerifyResult) -> None:
"""验证失败:不标 failed,保持 working 让 ticker 重试。"""
logger.info(
"Task %s: verify failed (%s, evidence=%s), leaving working for ticker retry",
task_id, verify.reason, verify.evidence
)
# === Review 流程 ===
def handle_review_complete(self, task_id: str, db_path: Path) -> None:
"""Review 完成后处理:读取 verdict → approved 则 mark done
否则 @mention assignee via blackboard comment"""
try:
conn = get_connection(db_path)
try:
# 读取最新 review
review_row = conn.execute(
"SELECT verdict, reviewer, comment FROM reviews "
"WHERE task_id=? ORDER BY created_at DESC LIMIT 1",
(task_id,)
).fetchone()
if not review_row:
logger.warning("Task %s: no review found", task_id)
return
verdict = review_row["verdict"]
reviewer = review_row["reviewer"]
review_comment = review_row["comment"] or ""
# 获取 assignee
task_row = conn.execute(
"SELECT assignee FROM tasks WHERE id=?", (task_id,)
).fetchone()
if not task_row:
logger.warning("Task %s: task not found for review", task_id)
return
assignee = task_row["assignee"]
if verdict == "approved":
self._mark_task_status(db_path, task_id, "done")
logger.info("Task %s: review approved by %s, marked done",
task_id, reviewer)
else:
# 非 approved:通过 blackboard comment @mention assignee
# 保持 review 状态,让 assignee 自行决定下一步
conn.execute(
"INSERT INTO comments (task_id, author, content, comment_type) "
"VALUES (?, 'system', ?, 'review')",
(task_id,
f"@{assignee} review 未通过 (verdict={verdict}, "
f"reviewer={reviewer}): {review_comment}")
)
conn.commit()
logger.info(
"Task %s: review not approved (%s by %s), "
"@mentioned assignee %s, keeping review status",
task_id, verdict, reviewer, assignee
)
finally:
conn.close()
except Exception as e:
logger.error("Task %s: handle_review_complete error: %s", task_id, e)
+48 -40
View File
@@ -19,6 +19,8 @@ from typing import Any, Callable, Coroutine, Dict, List, Optional
from dataclasses import dataclass, field as dc_field
from src.daemon.task_type_registry import TaskTypeRegistry
from src.blackboard.operations import Blackboard
from src.blackboard.db import get_connection
from src.daemon.spawner import AgentBusyError
@@ -215,18 +217,21 @@ class Ticker:
logger.exception("Tick %d _general error", tick_num)
results["projects"]["_general"] = {"error": str(e)}
# 虚拟项目 _mail:飞鸽传书
mail_db = Path(self.registry.root) / "_mail" / "blackboard.db"
if mail_db.exists() and "_mail" not in active_projects:
try:
pr = await self._tick_project("_mail", {
"id": "_mail", "name": "飞鸽传书",
"status": "active", "source": "virtual",
})
results["projects"]["_mail"] = pr
except Exception as e:
logger.exception("Tick %d _mail error", tick_num)
results["projects"]["_mail"] = {"error": str(e)}
# 虚拟项目:从注册表自动发现 + _general 硬编码
for vp in TaskTypeRegistry.virtual_projects():
vp_db = Path(self.registry.root) / vp / "blackboard.db"
if vp_db.exists() and vp not in active_projects:
try:
vp_handler = TaskTypeRegistry.get_by_project(vp)
vp_name = vp_handler.display_name if vp_handler and vp_handler.display_name else vp
pr = await self._tick_project(vp, {
"id": vp, "name": vp_name,
"status": "active", "source": "virtual",
})
results["projects"][vp] = pr
except Exception as e:
logger.exception("Tick %d %s error", tick_num, vp)
results["projects"][vp] = {"error": str(e)}
logger.debug(
"Tick %d complete: %d projects",
@@ -948,9 +953,10 @@ Parent Task ID: {parent_task.id}
now = datetime.utcnow().isoformat()
# 重置到 pending 时清空 assignee(避免残留导致重复路由到同一 Agent)
# 但 Mail 的 assignee 是收件人,永不清空
# handler 虚拟项目(_mail 等)的 assignee 是收件人,永不清空
if new_status == "pending":
if self._current_project_id == "_mail":
handler = TaskTypeRegistry.get_by_project(self._current_project_id)
if handler:
conn.execute(
"UPDATE tasks SET status=?, updated_at=? WHERE id=?",
(new_status, now, task_id),
@@ -1025,15 +1031,16 @@ Parent Task ID: {parent_task.id}
"full", "escalate"):
conn = get_connection(db_path)
try:
# [v2.7.1] Mail 已在 dispatcher 中标 working,跳过 claimed
if project_id == "_mail":
# [Step 5] handler 项目已在 dispatcher 中标 working,跳过 claimed
handler = TaskTypeRegistry.get_by_project(project_id)
if handler:
conn.execute(
"UPDATE tasks SET current_agent=? WHERE id=?",
(result["agent_id"], task.id),
)
conn.commit()
dispatched.append(task.id)
logger.info("Dispatched %s to %s (session=%s, mail auto-working)",
logger.info("Dispatched %s to %s (session=%s, handler auto-working)",
task.id, result["agent_id"],
result.get("session_id"))
else:
@@ -1300,8 +1307,9 @@ Parent Task ID: {parent_task.id}
async def _dispatch_reviews(self, db_path: Path,
project_id: str) -> List[str]:
"""扫描 review 状态任务,检查是否有产出,调度审查 Agent"""
# mail 任务不走 review 流程,直接跳过
if project_id == "_mail":
# handler 项目(_mail/_toolchain不走 review 流程
handler = TaskTypeRegistry.get_by_project(project_id)
if handler:
return []
queries = Queries(db_path)
@@ -1470,25 +1478,24 @@ Parent Task ID: {parent_task.id}
elapsed = (now - start_time).total_seconds() / 60.0
if elapsed > timeout_minutes:
# [v2.7.1] Mail 幻觉门控兜底:有回复 + working → done
if self._current_project_id == "_mail":
has_reply = self._mail_check_reply(task.id, db_path)
if has_reply:
conn = get_connection(db_path)
try:
ok = self._transition_status(
conn, task.id, "done",
agent="daemon",
detail={"reason": "mail_auto_done_recheck",
"elapsed_minutes": round(elapsed, 1)},
)
if ok:
reclaimed.append(task.id)
logger.info("Mail %s: ticker recheck found reply, marked done (%.1fm)",
task.id, elapsed)
finally:
conn.close()
continue
# [Step 5] handler 幻觉门控兜底:check_completion 通过 + working → done
handler = TaskTypeRegistry.get_by_project(self._current_project_id)
if handler and handler.check_completion(task.id, db_path):
conn = get_connection(db_path)
try:
ok = self._transition_status(
conn, task.id, "done",
agent="daemon",
detail={"reason": "mail_auto_done_recheck",
"elapsed_minutes": round(elapsed, 1)},
)
if ok:
reclaimed.append(task.id)
logger.info("Mail %s: ticker recheck found reply, marked done (%.1fm)",
task.id, elapsed)
finally:
conn.close()
continue
conn = get_connection(db_path)
try:
@@ -1621,8 +1628,9 @@ Parent Task ID: {parent_task.id}
project_dirs[project_id] = self.registry.root / \
project_id / "blackboard.db"
# 虚拟项目
for virtual_id in ("_general", "_mail"):
# 虚拟项目_general + 注册表自动发现
virtual_ids = ["_general"] + TaskTypeRegistry.virtual_projects()
for virtual_id in virtual_ids:
virtual_db = Path(self.registry.root) / \
virtual_id / "blackboard.db"
if virtual_db.exists() and virtual_id not in project_dirs:
+277
View File
@@ -0,0 +1,277 @@
"""toolchain_handler.py — 工具链事件 handler。
处理 Gitea Webhook 事件CI 失败Review 请求Issue 指派等
"""
from __future__ import annotations
import json
import logging
import urllib.request
from pathlib import Path
from typing import Dict
from src.daemon.base_task_handler import BaseTaskHandler, VerifyResult
from src.daemon.prompt_composer import PromptComposer, PromptContext
from src.daemon.toolchain_templates import render_template, _TEMPLATE_MAP
from src.blackboard.db import get_connection
logger = logging.getLogger("moziplus-v2.handler.toolchain")
# ---------------------------------------------------------------------------
# Toolchain PromptSections
# ---------------------------------------------------------------------------
class ToolchainContextSection:
"""事件类型 + 事件详情(priority=10"""
name: str = "toolchain_context"
priority: int = 10
def render(self, context: PromptContext) -> str:
event_type = context.event_type
event_data: Dict = context.event_data or {}
if event_type in _TEMPLATE_MAP:
# 使用模板引擎渲染已知事件
variables = {k: str(v) for k, v in event_data.items()}
return render_template(event_type, variables)
# fallback:通用事件描述
lines = [f"## 工具链事件", f""]
lines.append(f"- **事件类型**: {event_type or '未知'}")
if event_data:
lines.append(f"- **事件详情**:")
for key, value in event_data.items():
lines.append(f" - {key}: {value}")
lines.append(f"")
return "\n".join(lines)
def should_include(self, context: PromptContext) -> bool:
return True
class ToolchainApiSection:
"""API 操作指令(priority=40),success_status=done"""
name: str = "toolchain_api"
priority: int = 40
API_HOST = "localhost:8083"
def render(self, context: PromptContext) -> str:
lines = [
"## API 操作指令",
"",
f"项目 ID: `{context.project_id}`",
f"任务 ID: `{context.task_id}`",
"",
"### 完成后必须更新任务状态",
"完成后务必通过以下命令将任务标记为 **done**:",
"```bash",
f'curl -s -X POST "http://{self.API_HOST}/api/projects/{context.project_id}/tasks/{context.task_id}/status" \\',
' -H "Content-Type: application/json" \\',
' -d \'{"status": "done"}\'',
"```",
"",
"### 提交产出",
"如有产出(如 review 结果、修复方案),提交到任务 outputs:",
"```bash",
f'curl -s -X POST "http://{self.API_HOST}/api/projects/{context.project_id}/tasks/{context.task_id}/outputs" \\',
' -H "Content-Type: application/json" \\',
' -d \'{"content": "<你的产出内容>", "type": "text"}\'',
"```",
"",
]
return "\n".join(lines)
def should_include(self, context: PromptContext) -> bool:
return True
class ToolchainConstraintsSection:
"""硬约束(priority=50"""
name: str = "toolchain_constraints"
priority: int = 50
def render(self, context: PromptContext) -> str:
lines = [
"## 硬约束",
"",
"1. **必须标 done**:处理完成后必须通过 API 将任务状态更新为 `done`,否则视为未完成",
"2. **产出不能为空**:必须提交有意义的产出(output 或 comment),不能只改状态",
"3. **单一职责**:只处理本次事件相关的操作,不要越界执行无关任务",
"4. **出错即报告**:如果无法处理(如权限不足、资源不存在),在 comment 中说明原因并标 done",
"5. **不要创建新任务**:工具链事件只处理当前事件,不衍生新任务",
"",
]
return "\n".join(lines)
def should_include(self, context: PromptContext) -> bool:
return True
# ---------------------------------------------------------------------------
# ToolchainHandler
# ---------------------------------------------------------------------------
class ToolchainHandler(BaseTaskHandler):
"""工具链事件 handler。"""
task_type = "toolchain"
virtual_project = "_toolchain"
display_name = "工具链事件"
def target_success_status(self) -> str:
return "done"
def pre_spawn(self, task_id: str, db_path: Path) -> bool:
"""auto_workingpending → working"""
return self._auto_mark_working(task_id, db_path)
def get_sections(self) -> list:
"""返回 3 个 Toolchain PromptSection 实例"""
return [
ToolchainContextSection(),
ToolchainApiSection(),
ToolchainConstraintsSection(),
]
def build_prompt(self, context: PromptContext) -> str:
"""通过 PromptComposer 拼装 sections 为最终 prompt"""
composer = PromptComposer()
composer.add_many(self.get_sections())
return composer.compose(context)
def verify_completion(self, task_id: str, db_path: Path) -> VerifyResult:
"""检查行动输出(output 或 comment 有实质内容)"""
try:
conn = get_connection(db_path)
try:
# 检查 output
output_count = conn.execute(
"SELECT COUNT(*) FROM outputs WHERE task_id=?", (task_id,)
).fetchone()[0]
if output_count > 0:
return VerifyResult(True, "has_output", f"output_count={output_count}")
# 检查 comment(非系统、有实质内容)
comment_count = conn.execute(
"SELECT COUNT(*) FROM comments WHERE task_id=? "
"AND author != 'system' AND LENGTH(content) >= 20",
(task_id,)
).fetchone()[0]
if comment_count > 0:
return VerifyResult(True, "has_comment", f"comment_count={comment_count}")
return VerifyResult(False, "no_action", "output=0, comment=0")
finally:
conn.close()
except Exception as e:
logger.error("Toolchain %s: verify error: %s", task_id, e)
return VerifyResult(False, "verify_error", str(e))
def on_failure(self, task_id: str, agent_id: str,
db_path: Path, verify: VerifyResult) -> None:
"""验证失败 → 标 failed + Mail API 通知主公"""
self._mark_task_status(db_path, task_id, "failed")
logger.info("Toolchain %s: verify failed (%s), marked failed", task_id, verify.reason)
# 从 db 读取事件上下文
event_type = ""
event_data: Dict = {}
try:
conn = get_connection(db_path)
row = conn.execute(
"SELECT must_haves FROM tasks WHERE id=?", (task_id,)
).fetchone()
if row and row["must_haves"]:
meta = json.loads(row["must_haves"])
event_type = meta.get("event_type", "")
raw = meta.get("event_data", "{}")
event_data = json.loads(raw) if isinstance(raw, str) else raw
conn.close()
except Exception:
pass
self._notify_via_mail_api(
task_id, verify.reason, verify.evidence,
event_type, event_data,
)
def _build_gitea_links(self, event_type: str, event_data: dict) -> str:
"""根据事件类型构建 Gitea 链接。"""
links = []
repo = event_data.get("repo", "")
base_url = "http://192.168.2.154:3000"
if "pr_number" in event_data:
links.append(f"PR: {base_url}/{repo}/pulls/{event_data['pr_number']}")
if "issue_number" in event_data:
links.append(f"Issue: {base_url}/{repo}/issues/{event_data['issue_number']}")
if "commit" in event_data:
links.append(f"Commit: {base_url}/{repo}/commit/{event_data['commit']}")
if "branch" in event_data and "commit" not in event_data:
links.append(f"分支: {event_data['branch']}")
return "\n".join(links) if links else "(无法提取链接,请检查黑板任务详情)"
def _notify_via_mail_api(
self,
task_id: str,
reason: str,
evidence: str,
event_type: str,
event_data: Dict,
) -> None:
"""通过 Mail API 发送丰富的失败通知给主公。"""
# 构建行动指引
action_hint = "请检查黑板任务并手动处理。"
et_lower = event_type.lower()
if "ci" in et_lower or "deploy" in et_lower:
action_hint = "建议创建任务派给 jiangwei-infra 检查 CI/部署问题。"
elif "review" in et_lower:
action_hint = "建议查看 PR review 状态,必要时通知相关开发者。"
elif "issue" in et_lower:
action_hint = "建议创建任务派给对应开发者处理 Issue。"
# 构建事件详情
event_details = ""
if event_data:
event_details = "\n".join(
f" - {k}: {v}" for k, v in event_data.items()
)
# 构建 Gitea 链接
gitea_links = self._build_gitea_links(event_type, event_data)
title = f"[toolchain-handler] 工具链事件处理失败: {task_id}"
text = (
f"任务 {task_id} 验证失败\n\n"
f"事件类型: {event_type or '未知'}\n"
f"事件详情:\n{event_details or ' (无)'}\n\n"
f"失败原因: {reason}\n"
f"证据: {evidence}\n\n"
f"{gitea_links}\n\n"
f"行动指引: {action_hint}"
)
payload = json.dumps({
"from": "daemon",
"to": "pangtong-fujunshi",
"title": title,
"text": text,
"type": "inform",
}, ensure_ascii=False).encode("utf-8")
try:
req = urllib.request.Request(
"http://localhost:8083/api/mail",
data=payload,
headers={"Content-Type": "application/json"},
)
urllib.request.urlopen(req, timeout=5)
logger.info("Toolchain %s: sent failure notification via Mail API", task_id)
except Exception as e:
logger.warning("Toolchain %s: failed to notify via Mail API: %s", task_id, e)
+9
View File
@@ -21,6 +21,10 @@ from fastapi.staticfiles import StaticFiles
from src.blackboard.registry import ProjectRegistry
from src.daemon.ticker import Ticker
from src.daemon.task_handler import TaskHandler
from src.daemon.mail_handler import MailHandler
from src.daemon.toolchain_handler import ToolchainHandler
from src.daemon.task_type_registry import TaskTypeRegistry
from src.daemon.spawner import AgentSpawner
from src.daemon.bootstrap import BootstrapBuilder
from src.daemon.dispatcher import Dispatcher
@@ -214,6 +218,11 @@ async def lifespan(app: FastAPI):
watch_interval=inbox_config.get("watch_interval", 1.0),
)
# [Step 5] 注册 TaskType handler(必须在 ticker 启动前)
TaskTypeRegistry.register(TaskHandler())
TaskTypeRegistry.register(MailHandler())
TaskTypeRegistry.register(ToolchainHandler())
ticker = Ticker(
registry=registry,
tick_interval=tick_interval,