宜博 / lemonboss

Commit e9a21412f9d7c90a7ca2bcccaaf7ef61c55b1085

Authored by yibo
2 parents 04db7717 22d93c88

Merge remote-tracking branch 'origin/main'

Inline Side-by-side
Showing 17 changed files with 956 additions and 69 deletions
bin/lemon.js
  View file @e9a2141
... ... @@ -195,6 +195,25 @@ async function run() {
195 195 });
196 196 } catch { /* best-effort，静默丢弃 */ }
197 197 }
  198 + // 43 号文档 Phase 3：itemized 任务列出它物化出的子任务（coder-validator 逐条验收前先拿列表）
  199 + else if (command === 'task subtasks') {
  200 + const { values } = parseArgs({ args: args.slice(2), options: {
  201 + companyId: { type: 'string' }, taskId: { type: 'string' }
  202 + }});
  203 + const res = await request('GET', `/company/${values.companyId}/tasks?parentTaskId=${encodeURIComponent(values.taskId)}`);
  204 + console.log(JSON.stringify(res.data, null, 2));
  205 + }
  206 + // 43 号文档 Phase 3：逐条上报一个子任务的验收结果（每判完一条验收项调一次）
  207 + else if (command === 'task subtask-result') {
  208 + const { values } = parseArgs({ args: args.slice(2), options: {
  209 + companyId: { type: 'string' }, taskId: { type: 'string' },
  210 + status: { type: 'string' }, summary: { type: 'string', default: '' }
  211 + }});
  212 + const res = await request('POST', `/company/${values.companyId}/tasks/${values.taskId}/subtask-result`, {
  213 + status: values.status, summary: values.summary
  214 + });
  215 + console.log(JSON.stringify(res.data, null, 2));
  216 + }
198 217 else if (command === 'pipeline create') {
199 218 const { values } = parseArgs({ args: args.slice(2), options: {
200 219 companyId: { type: 'string' }, file: { type: 'string' }
... ...
docs/README.md
  View file @e9a2141
... ... @@ -60,7 +60,8 @@ Graph Agent 架构重构（27 系列）。**已完成的阶段文档已移入 `d
60 60 | [37-org-graph-department-scoping.md](./todo/system-design/37-org-graph-department-scoping.md) | 📝 **设计讨论，调用点扫描已完成，尚未立项实现**。现状 org graph 按 `company_id` 单例（`27-P2` 标题原文即"公司级"），塞不下 HR/财务/市场这类跟"交付流水线"无关的公司常设职能——`system/agents/hr/`（"招·留·管·退"）本体已存在却从没被装进任何图，全靠 fire-and-forget chat 招聘、无图执行审计轨迹。提议把 org graph 作用域从 `company_id` 升级为 `(company_id, department_id)`，一家公司可装配多张部门图，每张仍保持人工固定/慢变/可审计。全仓库调用点扫描结论：改造面是最初估算的 4 倍——真正的单点真相在 `work-graph-db.js:readDefGraph` 的裸 SQL 不变式（不在服务层），还牵涉两个易混淆服务文件间必须字节级一致的重复唯一索引、独立的 `graph-seed-service.js` 对账子系统、`company-hire-org-layer.test.js` 专属测试、`orggraph-planning`/`task-planning` 两份 agent 人设文档的自我认知改写 |
61 61 | [36-prd-agent-methodology-training-feasibility.md](./todo/system-design/36-prd-agent-methodology-training-feasibility.md) | 📝 **调研 + 阶段一/二均已完成**。回应"落地页太单薄是不是该用 Innovator 先训练专业 agent、再用 Dream 持续迭代"——认同方向。**阶段一**：`graph-engine.js` 结算节点后把 `success`/`fail:<reason>` 写进本体 `memory.md`（此前只有人类对话路径会写，Dream 天天空转）。**阶段二**：新建独立试验节点 `prd-methodology-trial` 走真实 Hunt→Digest→Evolve，2 轮收敛（96/97 分，真实基线 50 分），三个真实历史项目反推验证方法论有效；过程中连带修复同一个 2026-08-16 改名批次遗留的 5 处 `innovator`→`org-innovator` 死链（后端两处硬编码、前端"重新训练"按钮、`/api/agent/list` 展示 id 来源的四个 `config.json`），以及 `AgentScaffold` 默认模板一处裸相对路径缺陷。结论：FDE 对方法论类角色确实管用，但收敛速度/验收严谨度依赖任务书显式写明的自纠正要求，非免人工黑盒。环节 3（训练产物 → 雇佣本体转换）尚未开工 |
62 62 | [34-validator-scored-without-real-deliverable.md](./todo/system-design/34-validator-scored-without-real-deliverable.md) | 📝 **调研记录，checklist 已查完**。最初以为 `org-coder-impl` 从未产出任何 HTML/CSS，后来发现真实网站其实存在于 `graph_files` 索引不覆盖的「项目根」目录（已顺手修：控制台「产物」面板现在会展示项目根）。追加查清 validator 有没有真的做浏览器级检查——中途自我订正一次：不是"没工具做不到"（`bash` 能走到仓库自带的 Playwright，另一条对照任务证明可行），是**没人教它这么做**；抽查另外两个项目根后发现**验证严谨度完全不稳定**（同类任务有的做了真实 Playwright 级验证、有的只做静态正则、有的没验证就被取消），根因很可能是新招聘的 `unit-tester` 本体撞上了 [32 号文档](./todo/system-design/32-hire-body-fill-reliability.md) 那类"装配没填充完"的真实样本，不是平台工具限制 |
63   -| [43-task-decomposition-granularity.md](./todo/system-design/43-task-decomposition-granularity.md) | 📝 **需求 + 方案定案 + 技术实现计划（5 个 Phase）已写完，尚未开工**。回应"org-planner 出 brd/prd/sdd 后，任务看板能不能展示成 task/sub-task 树，coder-validator 按清单逐条开发验收"。方案：goal→task 流水线自建父子机制、先只拆验收（开发仍整体完成）、`tasks.acceptance_mode` 由 task-planning 判断、子任务复用 `tasks.status` 既有状态语义、任一子任务 fail 父任务即 fail。**Phase 0-4** 逐条核实了代码形态：`createTask()`/`parent_task_id` 迁移模板、task-planning "硬规则 5"需要开例外让 LLM 多写一个字段、`org-planner` 产出的验收清单其实是 `acceptance.md` 不是 `acceptance.json`（且⚠️真实回归里从未被用上，落地前需先验证可靠性）、`coder-validator`（不是 org-validator，文档订正过一次）的 `checks[]` 目前没有任何服务端代码解析、看板树形渲染有 `FileNode.vue` 现成模板可抄。建议实施顺序 Phase 0→1→4→2→3 |
  63 +| [44-writes-artifacts-produces-gate-mismatch.md](./todo/system-design/44-writes-artifacts-produces-gate-mismatch.md) | 📝 **真实回归中发现的缺陷记录，未修复**。43 号文档 Phase 2 真实验证时撞见：`goal-benchmark`（`planner.json` 里标 `writesArtifacts:true`）按文档正确把产物写进 root run 共享 `artifacts/` 目录，但产出闸门 `unsatisfiedRequiredProduces`（`graph-engine.js:4430`）只查节点私有目录（`nodeArtifactDir`），`writesArtifacts` 这个字段全仓库零代码读取——这条契约在当前实现下**永远无法通过**，不是偶发。真实证据：`artifacts/goal-benchmark.json` 磁盘上确认存在，闸门仍判「没找到」，强制 fail 沿兜底边回退。很可能正是 snakegame-co 参考任务里 `goal-benchmark`/`planner-validator` 显示 `skipped` 的真实原因。已有的 R-19 `contract.json` 显式声明逃生口（41 号文档修的那个）`allowedRoots` 也够不到共享 `artifacts/` 目录，一并够不到。留了两条候选修法，未实现 |
  64 +| [43-task-decomposition-granularity.md](./todo/system-design/43-task-decomposition-granularity.md) | ✅ **Phase 0-4 全部已实现**（2026-08-31）。回应"org-planner 出 brd/prd/sdd 后，任务看板能不能展示成 task/sub-task 树，coder-validator 按清单逐条开发验收"。`tasks` 加 `acceptance_mode`/`parent_task_id`（后者复用既有列）；`task-planning` 判断要不要拆（硬规则 5 开例外让 LLM 写这一个字段）；org-planner 收尾把 `acceptance.md` 物化成子任务；`coder-validator` 新增 `task subtask-result` 工具逐条上报，`settleNode()` 新增闸门强制核对子任务全 `completed` 才认 success；看板加子任务展示。**落地时订正了一处原计划想岔的架构假设**：org-planner 在 org 层永远是 `subgraph` 节点（不是 agent_call），真跑数据显示它当前展开成的 `planner.json` 5 节点子图里，`goal-benchmark`/`planner-validator` 两节点常被 skip，`acceptance.md` 未必真的产出——钩子已改成扫子 run 全节点、找不到就优雅降级为 holistic，不阻塞主产出，但"子任务一定会长出来"这件事目前是尽力而为不是保证，见文档"实现记录"一节的遗留风险说明。全量单测 1120/1123 通过（3 个失败与本次改动无关，本次改动前即存在） |
64 65  
65 66 ## todo/future/（暂缓，非当前重心）
66 67  
... ...
docs/todo/system-design/43-task-decomposition-granularity.md
  View file @e9a2141
1 1 # 43 · Goal 分解粒度：规划产出该长成文件，还是长成 task/subtask 树
2 2  
3   -> **状态**: 📝 需求 + 现状调研，尚未设计、未实现
  3 +> **状态**: ✅ Phase 0-4 全部已实现（2026-08-31）。全量单测 1120/1123 通过（3 个失败与本次改动无关，改动前即存在）
4 4 > **日期**: 2026-08-31
5 5 > **触发场景**: snakegame-co 公司，goal `G-mtfh23mu-bd63`（"HTML 贪吃蛇游戏"），task `T-mtfh2kuf-7c31`。
6 6 > 该任务当天被 `missing_required_input` 死循环卡住（根因与修复见 [33 号文档](../../done/system-design/33-needs-gate-role-filter-bug.md) 的复发一例，
... ... @@ -136,3 +136,30 @@ org-planner 的 4 阶段 FSM（`system/agents/org-planner/tools.md:19-23`，`nod
136 136 Phase 4（看板渲染）提前到 Phase 2/3 之前：先用手工插入的测试数据验证树形展示对不对，把"看得见"和"能自动生成"两件事解耦，避免一次性大集成、出问题不知道是生成的问题还是展示的问题。
137 137  
138 138 Phase 2 排在 Phase 3 之前，且内部先做"acceptance.md 是否真的可靠"这次独立验证——这是唯一一个建在未经证实的既有产物之上的环节，值得单独花一次真跑确认，再决定要不要照原计划往下建。
  139 +
  140 +---
  141 +
  142 +## 实现记录（2026-08-31，Phase 0-4 全部完成）
  143 +
  144 +按 Phase 0→1→4→2→3 顺序实现，每个 Phase 落地时跑一次相关单测 + 全量回归，全程零静默失败。
  145 +以下记两处**跟原计划不一样的地方**——都是动手时发现原计划想岔了，不是简单照抄执行。
  146 +
  147 +### 落地清单
  148 +
  149 +| Phase | 改了什么 | 测试 |
  150 +|---|---|---|
  151 +| 0（schema） | `tasks` 加 `acceptance_mode` 列（`CHECK IN ('holistic','itemized')`，迁移套用 `parent_task_id` 当年的 `hasColumn`/`ALTER TABLE` 模板）；`createTask()` 加 `parentTaskId`/`acceptanceMode`，子任务禁止递归声明 `itemized`；`taskView()` 补上这两个字段的输出 | `task-acceptance-mode.test.js`（6 条） |
  152 +| 1（task-planning 判断） | `task-planning` 的 JSON schema 从 4 字段扩到 5 字段（`acceptance_mode` 可选），在硬规则 5 上明确开了一条例外（这个字段需要语义判断，不能像 mode/priority/budget 那样服务端注入默认值）；`agent.md` 加 Step 2bis + 例子；`buildTaskPlans()` 透传 | `company-goal-task-routes.test.js` 补 2 条断言 |
  153 +| 4（看板渲染） | `GoalTaskPane.vue` 按 `parentTaskId` 分层渲染（子任务只读、无操作菜单，因为它们没有独立 run）；新出现的 `TaskTable.vue`（同一天另一个 session 并发重写了 `TaskBoard.vue`）用一行"↳ 子任务·属于「…」"指回父任务，不强行画树——它是可排序表格，硬套树会打架 | 用假数据 harness 截图人工验证（渲染逻辑本身足够简单，没再加单测） |
  154 +| 2（org-planner 物化子任务） | **见下方"计划外的架构订正"** | `task-decomposition-materialize.test.js`（3 条，真的驱动了 org-planner 展开子图 + 子 run 收敛回传的完整路径） |
  155 +| 3（coder-validator 逐条上报） | 新增 `wdb.settleSubtaskResult()`（终态幂等条件更新，同 `settleTaskFromRun` 一个模子）；新路由 `POST /:companyId/tasks/:taskId/subtask-result`；`listCompanyTasks`/`GET /:companyId/tasks` 加 `parentTaskId` 过滤；`bin/lemon.js` 加 `task subtasks` / `task subtask-result` 两个子命令；`settleNode()` 新增闸门——`coder-validator` 判 success 前核一遍它验的 task 若有子任务，是否全部 `completed`，没全的话强制改判 fail（新 `ENGINE_FAIL_REASONS.SUBTASKS_INCOMPLETE`）；`coder-validator/agent.md` 加 Step 4bis | `task-decomposition-validator-gate.test.js`（6 条）；顺带修了 `graph-engine-fail-reason.test.js` 的取值域快照（六→七个引擎取值）和 `template-verdicts.test.js`（agent.md 里一句话的措辞会被误判成"教 agent 写一个引擎不认的 fail_reason"，改了措辞不改语义） |
  156 +
  157 +### 计划外的架构订正：org-planner 不是 agent_call，是 subgraph
  158 +
  159 +原计划假设 `system/agents/org-planner/` 是一个单体 agent，走 4 阶段 FSM 直接产出 `brd.md/prd.md/sdd.md/acceptance.md`，Phase 2 打算在它自己的 `settleNode()` 成功分支挂一个钩子。**这个假设是错的**——org 层节点在 `readDefGraph` 里全部被标记成 `nodeKind='subgraph'`（无一例外），真正核实 snakegame-co 那条参考任务的生产数据后发现，org-planner 当前总是靠 `workgraph-planning` 展开成 `planner.json` 那张 5 节点子图（`brd-planning → prd-planning → sdd-planning → goal-benchmark → planner-validator`），而**这条参考任务的 `goal-benchmark`/`planner-validator` 两个节点当时都是 `skipped`**——`acceptance.md`（连带 R-19-B 的 `acceptance.json` 契约）从未被真正产出过。这正是文档最初标记的"⚠️ 已知风险"，真跑数据把它坐实了。
  160 +
  161 +修法：钩子从"`org-planner` 这个 `agent_call` 节点自己成功时触发"改成"`org-planner` 这个 subgraph 节点（不管它是直接执行还是展开成子图）真正结算 success 时触发"——两种形态统一在同一个 `maybeMaterializeItemizedSubtasks()` 里判：agent_call 就在它自己的私有目录找 `acceptance.md`，subgraph 就去它的子 run 里**全节点扫**（不假设固定是哪个节点写的，因为 workgraph-planning 现场选模板，节点名不固定）。找不到就留一条 timeline note、按 `holistic` 收尾，**不阻塞、不拖累 org-planner 这一轮真正有价值的产出**——这与文档最初的"软失败"设计初衷一致，只是触发时机改对了。
  162 +
  163 +**遗留风险**（订正后依然成立，写实话）：`acceptance.md` 会不会被稳定产出，取决于 `workgraph-planning` 会不会给 org-planner 挑一张真正跑完 `goal-benchmark`/`planner-validator` 的图、以及那张图会不会真的产出这份文件——这两件事都不在本次改动范围内，`maybeMaterializeItemizedSubtasks()` 目前是**优雅降级**（找不到就跳过，不报错），不是**保证生效**。换句话说：`acceptance_mode='itemized'` 现在是"如果规划链路配合，就能自动长出子任务"，还没做到"一定会长出子任务"。
  164 +
  165 +**2026-08-31 真实回归验证坐实了这条风险**，而且找到了比"未必可靠"更具体的根因：见 [44 号文档](./44-writes-artifacts-produces-gate-mismatch.md)——`goal-benchmark` 按设计把产物写进 root run 共享 `artifacts/` 目录，但产出闸门只查节点私有目录，`writesArtifacts:true` 这个字段全仓库零代码读取，这条契约在当前实现下**结构性地**打不过，不是运气不好。这很可能正是本文档触发场景（snakegame-co）里 `goal-benchmark`/`planner-validator` 显示 `skipped` 的真实原因。44 号文档只记录诊断，未修复；修复它会提高 Phase 2 的实际命中率，但不在 43 号文档范围内，不在这里展开。
... ...
docs/todo/system-design/44-writes-artifacts-produces-gate-mismatch.md 0 → 100644
  View file @e9a2141
  1 +# 44 · `writesArtifacts` 节点的产出闸门永远打不过：写到共享区，闸门查的是私有目录
  2 +
  3 +> **状态**: 📝 真实回归中发现的缺陷记录，已诊断到根因，**未修复**（本文档只记录，不含实现）
  4 +> **日期**: 2026-08-31
  5 +> **发现场景**：[43 号文档](./43-task-decomposition-granularity.md) Phase 2 的真实端到端验证——新建 `task-decomp-verify-co` 公司，走一条真实 `itemized` 任务，org-planner 展开成 `system/work-graph-templates/planner.json` 那张 5 节点子图（真实 Claude CLI，非 mock）
  6 +> **与 43 号文档的关系**：**完全独立的缺陷**，跟 goal 分解粒度那件事没有任何关系，只是恰好在验证 43 号文档时撞见。43 号文档"实现记录"一节提到的"acceptance.md 未必可靠"，这份文档是那句话背后更具体、更确定的根因之一
  7 +
  8 +---
  9 +
  10 +## 一、现象
  11 +
  12 +真实回归任务里，`org-planner` 展开的 `planner.json` 子图跑到 `org-planner-benchmark`（本体 `goal-benchmark`，模板里标了 `"writesArtifacts": true`）这一步：
  13 +
  14 +- agent 自己的判决（`attempt-0.json`）写的是 `"verdict": "produced"`，`output.artifact` 指向 `artifacts/goal-benchmark.json`；
  15 +- 落到 `graph-engine.js` 的产出闸门（`unsatisfiedRequiredProduces`，`server/services/graph-engine.js:4430-4467`）却判定「节点声明会产出 `acceptance`，但产物目录里没找到对应文件」，把这次 `success` 强制改判 `fail`（`fail_reason: produces_missing`）；
  16 +- 沿 `planner.json` 的兜底回退边退回 `org-planner-sdd` 重跑，`loop_count 1/3`。
  17 +
  18 +时间线原文（`data/companies/task-decomp-verify-co/runs/run_edaf3ea3ed69/timeline.ndjson`）：
  19 +
  20 +```
  21 +18:24:17.177 node.output org-planner-benchmark → success
  22 +18:24:17.178 node.output 节点声明会产出 acceptance，但产物目录里没找到对应文件，按 fail 结算
  23 + payload: {"missing_kinds":["acceptance"],"degraded":"produces_missing"}
  24 +18:24:17.178 node.status org-planner-benchmark: running → fail (failReason: produces_missing)
  25 +18:24:17.179 loop.registered 回退备案 loop_count=1/3 · backward_count=1/5
  26 +18:24:17.179 node.status org-planner-benchmark: fail → pending（上游回退，本轮产出作废）
  27 +```
  28 +
  29 +**关键点**：agent 没有做错任何事——它确实把文件写出来了，就在它自己判决里写的那个路径：
  30 +
  31 +```bash
  32 +$ find data/companies/task-decomp-verify-co/runs/run_edaf3ea3ed69/artifacts -type f
  33 +data/companies/task-decomp-verify-co/runs/run_edaf3ea3ed69/artifacts/goal-benchmark.json # 真实存在，内容正常
  34 +```
  35 +
  36 +而闸门检查的是这个：
  37 +
  38 +```bash
  39 +$ ls data/companies/task-decomp-verify-co/runs/run_edaf3ea3ed69/nodes/rn_d5fb26f5eede/
  40 +attempt-0.json # 只有这一份，闸门要找的 acceptance 相关文件不在这
  41 +```
  42 +
  43 +两个不是同一个目录，而且**永远不会**是同一个目录——下面「根因」一节说明为什么。
  44 +
  45 +---
  46 +
  47 +## 二、根因：闸门只认节点私有目录，`writesArtifacts:true` 是纯文档、代码里没人读
  48 +
  49 +### 2.1 `goal-benchmark` 被明确指示写共享区，这是设计意图不是失误
  50 +
  51 +`system/agents/goal-benchmark/agent.md:13,43` 白纸黑字写着：
  52 +
  53 +> 产物写进 root run 的 `artifacts/` 共享区…… `runs/{rootRunId}/artifacts/`：共享产物区。你对它**有写权**（`writesArtifacts: true`），但只写自己那一段
  54 +
  55 +`goal-benchmark/tools.md:25`：`用文件写入工具写 $R/artifacts/goal-benchmark.json`。
  56 +
  57 +这是因为 `acceptance.json`（R-19-B 契约）是三个 org node 各写一段合成的（`benchmark`/`test_data`/`test_script`），天然是跨节点共享状态，只能落在 root run 级别的共享区，不可能落在某一个节点自己的私有目录里——落在私有目录里，别的节点根本读不到它那一段。
  58 +
  59 +### 2.2 但闸门只查节点私有目录
  60 +
  61 +`unsatisfiedRequiredProduces`（`server/services/graph-engine.js:4430-4467`）：
  62 +
  63 +```js
  64 +dir = nodeArtifactDir(run, nodeRun.id); // 4452 行：只算节点私有目录
  65 +if (!fs.existsSync(dir) || ...) return declared;
  66 +files = fs.readdirSync(dir)...
  67 +```
  68 +
  69 +`nodeArtifactDir(run, nodeRunId)` = `runRootDir(run)/nodes/{nodeRunId}`（`graph-engine.js:3680`），不包含 `runRootDir(run)/artifacts/`。所以只要 `goal-benchmark` **正确地**按文档写到共享区，它自己节点私有目录下除了 `attempt-N.json`（会被过滤掉，见 4458-4459 行）什么都不会有，`hasCandidates` 恒为 `false`，`acceptance` 这个 kind 恒被判定「缺」。
  70 +
  71 +**这条契约在当前实现下，无论 agent 表现多好都无法通过。**
  72 +
  73 +### 2.3 `writesArtifacts: true` 这个字段，全仓库零代码读取
  74 +
  75 +```bash
  76 +$ grep -rn "writesArtifacts" server/ system/ --include="*.js" --include="*.json"
  77 +system/work-graph-templates/planner.json:11: { ..., "writesArtifacts": true }
  78 +```
  79 +
  80 +唯一一处命中就是模板里声明它的那一行。**它是纯文档性质的元数据，从没被 `unsatisfiedRequiredProduces`、`indexNodeOutputs`（`graph-engine.js:4469` 起）或任何别的地方读取过。** 模板作者（`planner.json` 的注释）显然知道 `goal-benchmark` 的产出方式跟别的节点不一样，也确实标了这个字段——但从来没人把它接进产出闸门的判断逻辑里。
  81 +
  82 +### 2.4 已有的逃生口（R-19 产出索引的显式声明机制）够不到共享区
  83 +
  84 +`graph-engine.js` 已经有一条为**同一类**问题准备的机制——`readDeclaredProduces`（`graph-engine.js:4377-4406`）：节点可以在自己私有目录写一份 `contract.json`，里面显式声明 `produces: {kind: ["<绝对路径>"]}`，闸门会认这份声明而不是死磕目录扫描。这正是 [41 号文档](./41-graph-vs-fde-reliability-discussion.md) 提到的"R-19 产出索引不覆盖项目根，加 `contract.json` 的 `produces` 显式声明机制"那次修复的产物。
  85 +
  86 +但这条逃生口本身也够不到共享 `artifacts/` 目录——`inBounds()` 校验的 `allowedRoots` 只有 `[节点私有目录, 项目根]`（`graph-engine.js:4384`），不包含 `runRootDir(run)/artifacts/`。即使 `goal-benchmark` 主动在自己目录写一份 `contract.json` 声明 `produces.acceptance = ["/abs/path/to/artifacts/goal-benchmark.json"]`，这条声明也会因为路径不在 `allowedRoots` 里被判 `bad=true`，等于没声明。
  87 +
  88 +---
  89 +
  90 +## 三、影响面
  91 +
  92 +**任何一家公司只要 org-planner 走 `planner.json` 骨架（当前的常态，见 43 号文档 Phase 2 的真实数据核实），`org-planner-benchmark` 这一步几乎注定会撞这堵墙。** 每次撞墙都沿兜底回退边退回 `org-planner-sdd` 重来一轮（烧一次 sdd-planning 的真实调用 + 一次 goal-benchmark 的真实调用），直到 `loop_count` 撞到 `planner.json` 兜底边的硬顶（`LOOP_HARD_CAP_RUN` 相关，全树 `backward_count` 硬顶 5），最终大概率被强制判 `blocked` 或者 `planner-validator` 跟着一起被跳过。
  93 +
  94 +**这很可能正是本 session 全程调试的参考任务（snakegame-co，[43 号文档](./43-task-decomposition-granularity.md) 的触发场景）里 `goal-benchmark`/`planner-validator` 两个节点显示 `skipped` 的真实原因**——不是没跑到，是跑了、正确地写了产物，却被这道闸门反复判定「没写」，最终在某一轮被放弃跳过。
  95 +
  96 +连带后果：
  97 +
  98 +- `artifacts/acceptance.json`（R-19-B 契约，`benchmark`/`test_data`/`test_script` 三段合成）的 `benchmark` 段大概率永远拿不到真实内容——不是 `goal-benchmark` 没算出来，是它算出来的东西没能真正"通过"这一节点的成功判定，图会不断回退重算，直到耗尽回退预算放弃。
  99 +- 连带 43 号文档 Phase 2：`acceptance.md`（不同于此处的 `acceptance.json`，来源不同）不受这条闸门直接影响，但**同一个 `planner.json` 子图反复在这里回退熔断**，会拖慢/阻塞整条 org-planner 子图的收敛，间接影响 Phase 2 的"org-planner 真正判定 success"这一时机能不能正常到达。
  100 +
  101 +---
  102 +
  103 +## 四、建议修法（未实现，留给下一次专门处理）
  104 +
  105 +两个方向，第一个更小、更贴合现有 R-19 设计：
  106 +
  107 +1. **扩大 `readDeclaredProduces` 的 `allowedRoots`**（`graph-engine.js:4384`），把 `runRootDir(run)/artifacts/` 也纳入合法路径；同时让 `goal-benchmark`（以及未来任何 `writesArtifacts:true` 的节点）在写完共享产物后，**也**在自己节点私有目录写一份 `contract.json` 显式声明 `produces.acceptance` 指向那个共享区绝对路径。这样闸门检查的还是"显式声明 + 文件真实存在"，只是放宽了声明能指向的位置——跟 R-19 现有的设计哲学一致，改动面最小。
  108 +2. **让 `writesArtifacts: true` 这个字段真正被消费**：`unsatisfiedRequiredProduces` 读节点定义时，如果这个节点标了 `writesArtifacts: true`，改成同时扫 `runRootDir(run)/artifacts/` 目录（不要求 agent 额外写 `contract.json`）。改动面稍大（要把这个字段从模板一路传到 `def.nodes` 里，目前 `readDefGraph` 会不会保留这个字段未核实），但对 agent 侧零改动。
  109 +
  110 +两条路都没有实现，需要先确认哪条更契合现有 `def.nodes` 的数据流（`readDefGraph` 目前是否保留模板里的自定义字段），再动手；本文档只记录诊断结果，不展开设计。
... ...
server/routes/company.js
  View file @e9a2141
... ... @@ -1023,6 +1023,9 @@ function taskView(t, progress = null, positions = null) {
1023 1023 blockedReason: t.blocked_reason,
1024 1024 reportTo: t.report_to,
1025 1025 assigneeAgentId: t.assignee_agent_id || null,
  1026 + // 43 号文档：子任务树的父子指针 + 这条 task 走哪种验收模式（看板据此决定要不要画子任务）
  1027 + parentTaskId: t.parent_task_id || null,
  1028 + acceptanceMode: t.acceptance_mode || 'holistic',
1026 1029 createdAt: t.created_at,
1027 1030 queuedAt: t.queued_at,
1028 1031 startedAt: t.started_at,
... ... @@ -1409,10 +1412,19 @@ function buildTaskPlans(specs, { priority, budget, mode, seqBase = 0 } = {}) {
1409 1412 if (rawDeps !== undefined && rawDeps !== null && !Array.isArray(rawDeps)) {
1410 1413 return { error: `tasks[${i}].depends_on 必须是数组` };
1411 1414 }
  1415 + // 43 号文档：跟 mode/priority/budget 不同——这个字段**透传**、不继承 goal 级默认值。
  1416 + // 要不要按验收条目拆子任务是语义判断，task-planning 已经在 specs 里判过一次；
  1417 + // 没给就是没判断要拆，缺省 holistic（保守），不是「服务端注入默认值」那类字段。
  1418 + const rawAMode = s.acceptance_mode !== undefined ? s.acceptance_mode : s.acceptanceMode;
  1419 + const acceptanceMode = rawAMode == null ? 'holistic' : rawAMode;
  1420 + if (!['holistic', 'itemized'].includes(acceptanceMode)) {
  1421 + return { error: `tasks[${i}].acceptance_mode 只能是 'holistic' 或 'itemized'，收到: ${JSON.stringify(rawAMode)}` };
  1422 + }
1412 1423 plans.push({
1413 1424 seq: base + i + 1, // seq 显式给，别靠 MAX+1 —— depends_on 的 seq 引用要能对得上服务端分配的号
1414 1425 title: String(s.title || '').trim() || deriveTitle(d),
1415 1426 description: d,
  1427 + acceptanceMode,
1416 1428 // 优先级：task 自己的 mode > goal 级 mode（第三个候选）> 'manual'。
1417 1429 // 「继承 goal」这一层是批 2 加的，对显式传 tasks[] 的调用方是行为变化（此前恒 manual），
1418 1430 // 保留它是因为反过来更荒谬：用户在表单上把整个 goal 选成 auto，拆出来的 task 却全是
... ... @@ -1450,6 +1462,7 @@ function insertTasksForGoal(wdb, goal, plans, createdBy) {
1450 1462 priority: p.priority,
1451 1463 budgetJson: p.budget, // 建行时就存下来：草稿路径上请求体活不到 dispatch（缺陷 F3）
1452 1464 createdBy,
  1465 + acceptanceMode: p.acceptanceMode,
1453 1466 })
1454 1467 );
1455 1468 const bySeq = new Map(created.map((t) => [String(t.seq), t.id]));
... ... @@ -2065,6 +2078,8 @@ router.get(&#39;/:companyId/tasks&#39;, (req, res) =&gt; {
2065 2078 const tasks = wdb.listCompanyTasks(req.params.companyId, {
2066 2079 status: req.query.status || null,
2067 2080 goalId: req.query.goalId || req.query.goal_id || null,
  2081 + // 43 号文档：coder-validator 用它列出一个 itemized 任务物化出的全部子任务
  2082 + parentTaskId: req.query.parentTaskId || req.query.parent_task_id || null,
2068 2083 includeArchived: req.query.includeArchived === '1' || req.query.includeArchived === 'true',
2069 2084 limit: Number.isInteger(limit) ? limit : null,
2070 2085 });
... ... @@ -2308,6 +2323,40 @@ router.patch(&#39;/:companyId/tasks/:taskId&#39;, (req, res) =&gt; {
2308 2323 });
2309 2324  
2310 2325 /**
  2326 + * POST /api/company/:companyId/tasks/:taskId/subtask-result — 43 号文档 Phase 3
  2327 + * body: { status: 'completed' | 'failed', summary? }
  2328 + *
  2329 + * `coder-validator` 逐条验收 itemized 任务的验收条目时，每判完一条就调一次这个端点上报
  2330 + * 那一条子任务的结果——不是解析它写的 checks[]/verdict 自由文本 JSON（那份格式在几个
  2331 + * validator 之间只是约定俗成，从没被任何服务端代码强制校验过，见 graph-engine.js 的
  2332 + * unsatisfiedRequiredProduces 一带）。状态改变走真实工具调用，这是本仓库一贯的做法。
  2333 + *
  2334 + * 只接受**子任务**（`parent_task_id` 非空）：顶层 task 的终态由 run 收敛走
  2335 + * `settleTaskFromRun` 那条路，这个端点不是它的替代品。
  2336 + */
  2337 +router.post('/:companyId/tasks/:taskId/subtask-result', (req, res) => {
  2338 + try {
  2339 + const wdb = require('../services/work-graph-db');
  2340 + const task = requireTask(req, res);
  2341 + if (!task) return;
  2342 + if (!task.parent_task_id) {
  2343 + return res.status(400).json({
  2344 + error: `${task.id} 不是子任务（没有 parent_task_id）——这个端点只服务 43 号文档物化出来的子任务，顶层任务的终态由 run 收敛决定`,
  2345 + });
  2346 + }
  2347 + const { status, summary } = req.body || {};
  2348 + if (!['completed', 'failed'].includes(status)) {
  2349 + return res.status(400).json({ error: `status 只能是 'completed' 或 'failed'，收到: ${JSON.stringify(status)}` });
  2350 + }
  2351 + const changed = wdb.settleSubtaskResult(task.id, status, summary || null);
  2352 + res.json({ ok: true, changed: changed > 0, task: taskView(wdb.getTask(task.id)) });
  2353 + } catch (err) {
  2354 + console.error('[TaskEntry] Error:', err.message);
  2355 + res.status(500).json({ error: err.message });
  2356 + }
  2357 +});
  2358 +
  2359 +/**
2311 2360 * POST /api/company/:companyId/tasks/:taskId/enqueue — 单条入队（27-P3C §六.3）
2312 2361 *
2313 2362 * 与 `goals/:goalId/dispatch` 的差别只是粒度：那条把 goal 下所有 draft 一起推进队列，
... ...
server/services/graph-engine.js
  View file @e9a2141
... ... @@ -62,6 +62,8 @@ const {
62 62 // 39 号文档「确定性通路」：回退熔断收敛时顺手开一条 draft task，见 maybeProposeReplanTask
63 63 createTask,
64 64 getGoal,
  65 + // 43 号文档：settleNode 成功路径顺手物化 itemized 子任务，见 maybeMaterializeItemizedSubtasks
  66 + getTask,
65 67 } = require('./work-graph-db');
66 68  
67 69 /**
... ... @@ -221,6 +223,11 @@ const ENGINE_FAIL_REASONS = Object.freeze({
221 223 // 会静默拿一份没有角色指导的提示词去跑真实 CLI（真实样本见 34 号文档 §五）。
222 224 // 字符串与招聘路径的 'body_not_ready' 同名同义，不是两套判词。
223 225 BODY_NOT_READY: 'body_not_ready',
  226 + // 43 号文档 Phase 3：coder-validator 判自己 success，但它验的 task 是 itemized 且
  227 + // 子任务还没全部 completed——agent 自己写的 checks[]/verdict 没人解析（见下面
  228 + // maybeCheckSubtasksComplete 的注释），真正说了算的是 tasks.status，这里同样是
  229 + // 把一个此前只进提示词的软约束收成硬闸门，不是发明新语义。
  230 + SUBTASKS_INCOMPLETE: 'subtasks_incomplete',
224 231 });
225 232  
226 233 /** 归因/结构化产出文件名（agent.md「产出格式」：runs/{rootRunId}/nodes/{nodeRunId}/attempt-{n}.json） */
... ... @@ -1845,9 +1852,35 @@ function settleNode(runId, nodeRunId, outcome = {}) {
1845 1852 timelineNote({ runId, nodeRunId }, 'node.output',
1846 1853 `节点声明必需的上游产物 ${missingInputs.join(', ')} 在索引里查不到实例，按 fail 结算`,
1847 1854 { node_run_id: nodeRunId, missing_kinds: missingInputs, degraded: 'missing_required_input' });
  1855 + } else {
  1856 + // 43 号文档 Phase 3：coder-validator 判自己 success 之前，再核一遍它管的 task 是不是
  1857 + // itemized 且有子任务——有的话必须全部 completed 才认这次 success。coder-validator
  1858 + // 自己写的 checks[]/verdict 是没人解析的自由文本（同一段代码里 unsatisfiedRequiredProduces
  1859 + // 的教训：软产物必须收成硬闸门，不能只指望 agent 自觉），真正说了算的是 tasks.status，
  1860 + // 由 coder-validator 调 /subtask-result 端点逐条写（server/routes/company.js）。
  1861 + const dRole = def0.nodes.get(nodeRun0.def_node_id);
  1862 + if (dRole && dRole.systemAgentId === 'coder-validator' && run0.task_id) {
  1863 + const subtasks = getDb().prepare(`SELECT id, status FROM tasks WHERE parent_task_id = ?`).all(run0.task_id);
  1864 + const notDone = subtasks.filter((t) => t.status !== 'completed').map((t) => t.id);
  1865 + if (notDone.length) {
  1866 + to = 'fail';
  1867 + failReason = ENGINE_FAIL_REASONS.SUBTASKS_INCOMPLETE;
  1868 + timelineNote({ runId, nodeRunId }, 'node.output',
  1869 + `这条 task 是 itemized，还有 ${notDone.length}/${subtasks.length} 条子任务没有上报 completed（${notDone.join(', ')}），不认这次 success`,
  1870 + { node_run_id: nodeRunId, unresolved_subtasks: notDone, degraded: 'subtasks_incomplete' });
  1871 + }
  1872 + }
1848 1873 }
1849 1874 }
1850 1875 }
  1876 + // 43 号文档：故意放在 !isSubgraphNode 这道闸门**之外**——org-planner 在 org 层的节点
  1877 + // 类型是 subgraph（org 层节点全是 subgraph，见上面 isSubgraphNode 的注释），真正核实
  1878 + // 生产数据发现它当前总是靠 workgraph-planning 展开成 planner.json 那张 5 节点子图，
  1879 + // 不是直接一个 agent_call；acceptance.md（如果有）落在子 run 里，不在这个节点自己的
  1880 + // 私有目录（subgraph 节点的 output_ref 恒为 null）。两种形态都要认，见函数内部。
  1881 + if (to === 'success' && run0 && nodeRun0 && def0) {
  1882 + maybeMaterializeItemizedSubtasks({ runId, nodeRunId, run: run0, nodeRun: nodeRun0, def: def0, isSubgraphNode });
  1883 + }
1851 1884 }
1852 1885  
1853 1886 const changed = sse.transitionNode(runId, nodeRunId, 'running', to, {
... ... @@ -2207,6 +2240,109 @@ function maybeProposeReplanTask(runId, rootRunId, nodeRun, def, remediationNote)
2207 2240 }
2208 2241  
2209 2242 /**
  2243 + * 解析 org-planner 写的 acceptance.md（`| # | 验收项 | 判定方式 | pass 条件 |` 表格，
  2244 + * 见 `system/agents/org-planner/tools.md` §3 的模板）。只信表格形状，不信位置——
  2245 + * 列数不足 4、分隔行（`---`）、编号列不是纯数字的行一律跳过，不抛异常：格式不对
  2246 + * 就是「没有可用的验收条目」，交给调用方按空数组处理。
  2247 + */
  2248 +function parseAcceptanceMd(text) {
  2249 + const rows = [];
  2250 + for (const line of String(text || '').split('\n')) {
  2251 + const m = line.match(/^\s*\|(.*)\|\s*$/);
  2252 + if (!m) continue;
  2253 + const cells = m[1].split('|').map((c) => c.trim());
  2254 + if (cells.length < 4) continue;
  2255 + const [seqCell, item, method, passCondition] = cells;
  2256 + if (!/^\d+$/.test(seqCell) || !item) continue; // 表头 / 分隔行 / 编号写歪的行
  2257 + rows.push({ seq: Number(seqCell), item, method, passCondition });
  2258 + }
  2259 + return rows;
  2260 +}
  2261 +
  2262 +/**
  2263 + * 在一条 run 名下**全部**节点的私有目录里找 acceptance.md，返回第一份找到的绝对路径。
  2264 + *
  2265 + * 不假设固定节点名/固定模板：org-planner 到底展开成哪张 work graph（`planner.json` 的
  2266 + * 5 节点 fan-out，还是别的骨架）是 workgraph-planning 现场选的，谁写 acceptance.md
  2267 + * 因模板而异（43 号文档 Phase 2 核实真实生产数据后的结论），扫全部节点比认一个固定
  2268 + * 节点名更不容易随模板改动跟着碎。
  2269 + */
  2270 +function findAcceptanceMdFile(run) {
  2271 + try {
  2272 + const rows = getDb().prepare(`SELECT id FROM graph_run_nodes WHERE run_id = ?`).all(run.id);
  2273 + for (const r of rows) {
  2274 + const file = path.join(nodeArtifactDir(run, r.id), 'acceptance.md');
  2275 + if (fs.existsSync(file)) return file;
  2276 + }
  2277 + } catch { /* 目录读不出来就当没有，best-effort */ }
  2278 + return null;
  2279 +}
  2280 +
  2281 +/**
  2282 + * 43 号文档 Phase 2：`task.acceptance_mode='itemized'` 时，org-planner 这一轮真正判定
  2283 + * success 之后，把它（或它展开出的子图）写的 acceptance.md 逐行物化成子任务。
  2284 + *
  2285 + * org 层节点全是 `nodeKind='subgraph'`（见上面 isSubgraphNode 的注释），真实核实生产数据
  2286 + * 发现 org-planner 现在总是靠 workgraph-planning 展开成子图在跑，不是直接一个 agent_call——
  2287 + * 两种形态都要认：agent_call 就在它自己的私有目录找，subgraph 就去它的子 run 里全节点扫
  2288 + * （见 findAcceptanceMdFile）。
  2289 + *
  2290 + * 纯 best-effort：查不到 task / 不是 itemized / 文件不存在 / 解析不出条目，一律安静跳过
  2291 + * 并留一条 timeline note——**这一步失败绝不能把 org-planner 这一轮真正有价值的产出打成
  2292 + * fail**，物化子任务是「顺手做的」，不是节点判定的一部分（33 号文档的教训：把一个软产物
  2293 + * 当成硬闸门，会把整条链路拖进死循环）。
  2294 + *
  2295 + * 幂等：父任务名下已经有子任务就不再重复建——覆盖的是节点被 retry 后二次结算 success
  2296 + * 这种情况，不是想同步 acceptance.md 后续的编辑（那需要人工介入，不是这一步的职责）。
  2297 + */
  2298 +function maybeMaterializeItemizedSubtasks({ runId, nodeRunId, run, nodeRun, def, isSubgraphNode }) {
  2299 + try {
  2300 + const d = def && nodeRun && def.nodes.get(nodeRun.def_node_id);
  2301 + if (!d || d.systemAgentId !== 'org-planner') return;
  2302 + if (!run.task_id) return;
  2303 +
  2304 + const task = getTask(run.task_id);
  2305 + if (!task || task.acceptance_mode !== 'itemized') return;
  2306 +
  2307 + const already = getDb().prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ?`).get(task.id).n;
  2308 + if (already > 0) return;
  2309 +
  2310 + const searchRun = isSubgraphNode ? getRun(nodeRun.child_run_id) : run;
  2311 + const file = searchRun ? findAcceptanceMdFile(searchRun) : null;
  2312 + if (!file) {
  2313 + timelineNote({ runId, nodeRunId }, 'node.output',
  2314 + `task.acceptance_mode='itemized' 但没找到 acceptance.md，跳过子任务物化（仍按 holistic 收尾）`,
  2315 + { node_run_id: nodeRunId, task_id: task.id, degraded: 'acceptance_md_missing' });
  2316 + return;
  2317 + }
  2318 +
  2319 + const rows = parseAcceptanceMd(fs.readFileSync(file, 'utf-8'));
  2320 + if (!rows.length) {
  2321 + timelineNote({ runId, nodeRunId }, 'node.output',
  2322 + `acceptance.md 存在但解析不出任何验收条目（表格形状不对？），跳过子任务物化`,
  2323 + { node_run_id: nodeRunId, task_id: task.id, degraded: 'acceptance_md_unparseable' });
  2324 + return;
  2325 + }
  2326 +
  2327 + for (const row of rows) {
  2328 + createTask({
  2329 + goalId: task.goal_id,
  2330 + companyId: task.company_id,
  2331 + title: row.item.slice(0, 120),
  2332 + description: `判定方式：${row.method || '(未写明)'}\npass 条件：${row.passCondition || '(未写明)'}`,
  2333 + createdBy: 'org-planner',
  2334 + parentTaskId: task.id,
  2335 + });
  2336 + }
  2337 + timelineNote({ runId, nodeRunId }, 'node.output',
  2338 + `按 acceptance.md 物化了 ${rows.length} 条子任务`,
  2339 + { node_run_id: nodeRunId, task_id: task.id, subtask_count: rows.length });
  2340 + } catch (err) {
  2341 + console.error('[graph-engine] maybeMaterializeItemizedSubtasks 失败（不影响节点结算）：', err.message);
  2342 + }
  2343 +}
  2344 +
  2345 +/**
2210 2346 * 解析跨层地址 → 「该退到哪个子 run 的哪一行」（**纯查询，不改任何状态**）。
2211 2347 *
2212 2348 * 输入的地址来自失败节点行的 `fail_node_ref`（三值透传的第四值，见 normalizeNodeRef 那段）。
... ...
server/services/task-planning.js
  View file @e9a2141
... ... @@ -42,8 +42,14 @@ const PLAN_MAX_ROUNDS = 3;
42 42 */
43 43 const MAX_TASKS = 8;
44 44  
45   -/** 产出里允许出现的键。多余键一律按 schema 打回：那些字段要么服务端生成、要么人在界面上定 */
46   -const ALLOWED_KEYS = new Set(['seq', 'title', 'description', 'depends_on', 'dependsOn']);
  45 +/** 产出里允许出现的键。多余键一律按 schema 打回：那些字段要么服务端生成、要么人在界面上定
  46 + *
  47 + * 43 号文档：`acceptance_mode` 是这四个字段之外**唯一**的例外——要不要按验收条目拆子任务，
  48 + * 是一次语义判断（跟「要不要拆多个 task」用的是同一种判断力），没法像 mode/priority/budget
  49 + * 那样交给服务端按 goal 级默认值机械注入，所以必须让 agent 自己决定、自己写出来。
  50 + */
  51 +const ALLOWED_KEYS = new Set(['seq', 'title', 'description', 'depends_on', 'dependsOn', 'acceptance_mode', 'acceptanceMode']);
  52 +const ACCEPTANCE_MODES = new Set(['holistic', 'itemized']);
47 53  
48 54 // ────────────────────────────────────────────────────────────────
49 55 // 注入点（仿 graph-engine.setPlanWorkGraph）
... ... @@ -76,7 +82,7 @@ function planTasks(ctx) {
76 82 *
77 83 * @param {{companyId: string, goal: object}} ctx goal 是 goals 表的整行
78 84 * @returns {Promise<{specs: object[], tokens: number, rounds: number}>}
79   - * specs 形如 `[{seq, title, description, depends_on: [seq…]}]`，seq 恒为 1..N 连续
  85 + * specs 形如 `[{seq, title, description, depends_on: [seq…], acceptance_mode}]`，seq 恒为 1..N 连续
80 86 * @throws 轮次耗尽 / 调用本身炸了；两种情况都在 error 上挂了 `tokens`（已烧掉的那部分）
81 87 */
82 88 async function defaultPlanTasks(ctx) {
... ... @@ -203,14 +209,20 @@ function buildTaskPlanningPrompt(ctx, { round = 1, errors = null, lastOutput = &#39;
203 209 describeHiredRoles(ctx.companyId),
204 210 '',
205 211 '## 交回方式（引擎只读你回复里最后一个 ```json 代码块）',
206   - '顶层是**数组**，每个元素恰好四个字段：',
  212 + '顶层是**数组**，每个元素四个必填字段 + 一个可选字段：',
207 213 '```json',
208   - '[{"seq":1,"title":"…","description":"…","depends_on":[]}]',
  214 + '[{"seq":1,"title":"…","description":"…","depends_on":[],"acceptance_mode":"holistic"}]',
209 215 '```',
210 216 `- \`seq\`：1..N 连续整数、不重复、与数组顺序一致；条数上限 **${MAX_TASKS}**。`,
211 217 '- `depends_on`：只能写本次产出的 `seq` 数字（1-based）。**不许写 task id** —— id 由服务端'
212 218 + '在你交回之后才生成，你根本看不到；写字符串一定被打回。没有依赖就写 `[]`（不能省）。',
213   - '- 只输出这四个字段。`id` / `status` / `mode` / `budget` / `priority` / `agent` 一律不许出现。',
  219 + '- `acceptance_mode`（可选，缺省 `"holistic"`）：这条 task 的验收后续要不要按验收条目拆成'
  220 + + '子任务逐条判——判断轴跟 Step 2 判「要不要拆多个 task」是同一种（够不够独立成立、值不值得'
  221 + + '单独验收）。多数任务留空/写 `"holistic"` 即可；只有一件对外是单一交付物、但内部有多条'
  222 + + '可以各自独立验收的验收标准的任务，才写 `"itemized"`。不确定就留 `"holistic"`——错误地'
  223 + + '拆细比保守合并的代价更高。',
  224 + '- 只输出这五个字段（`acceptance_mode` 可以不写）。`id` / `status` / `mode` / `budget`'
  225 + + ' / `priority` / `agent` 一律不许出现。',
214 226 '- 每条 `description` 必须**自包含**：下游每条 task 起独立的 run，那个 run 只看得到自己'
215 227 + '这一条描述（它会成为该 run 的 task-goal.json），不许写「同上」「见 task 1」这类跨条引用。',
216 228 '- 拆分理由写在 JSON 代码块**前面**的正文里；代码块之后不要再写任何字。',
... ... @@ -370,7 +382,18 @@ function validatePlannedTasks(raw) {
370 382 }
371 383 const extra = Object.keys(item).filter((k) => !ALLOWED_KEYS.has(k));
372 384 if (extra.length) {
373   - errors.push({ rule: 'schema', detail: `${at} 有多余键 ${extra.join(' / ')}：只许 seq / title / description / depends_on` });
  385 + errors.push({ rule: 'schema', detail: `${at} 有多余键 ${extra.join(' / ')}：只许 seq / title / description / depends_on / acceptance_mode` });
  386 + }
  387 +
  388 + // 没写就是没判断要拆——缺省 holistic（保守，不引入新行为），不是错误
  389 + const rawMode = item.acceptance_mode !== undefined ? item.acceptance_mode : item.acceptanceMode;
  390 + let acceptanceMode = 'holistic';
  391 + if (rawMode !== undefined && rawMode !== null) {
  392 + if (!ACCEPTANCE_MODES.has(rawMode)) {
  393 + errors.push({ rule: 'schema', detail: `${at} 的 acceptance_mode 只能是 "holistic" 或 "itemized"，收到 ${JSON.stringify(rawMode)}` });
  394 + } else {
  395 + acceptanceMode = rawMode;
  396 + }
374 397 }
375 398  
376 399 const description = String(item.description == null ? '' : item.description).trim();
... ... @@ -406,6 +429,7 @@ function validatePlannedTasks(raw) {
406 429 title: String(item.title == null ? '' : item.title).trim(),
407 430 description,
408 431 depends_on: deps,
  432 + acceptance_mode: acceptanceMode,
409 433 });
410 434 });
411 435  
... ...
server/services/work-graph-db.js
  View file @e9a2141
... ... @@ -531,6 +531,10 @@ function getDb() {
531 531 -- queued 现在就在取值域里，但排队逻辑（调度器 / run_status='queued'）另批实现：
532 532 -- 取值域是数据形状的一部分，先钉死它，免得批 3 再来改一次列注释
533 533 execution_mode TEXT NOT NULL DEFAULT 'manual' CHECK (execution_mode IN ('manual','auto')),
  534 + -- 43 号文档：itemized 的 task 由 org-planner 收尾时按验收条目物化出子任务
  535 + -- （parent_task_id 指回这一行）；holistic 保持现状「一次性给总分」不物化任何东西。
  536 + -- 子任务本身恒为 holistic（不允许递归再拆一层），见 createTask 里的校验。
  537 + acceptance_mode TEXT NOT NULL DEFAULT 'holistic' CHECK (acceptance_mode IN ('holistic','itemized')),
534 538 depends_on TEXT NOT NULL DEFAULT '[]', -- JSON 数组，同 goal 内的 task id
535 539 budget_json TEXT,
536 540 current_run_id TEXT, -- 最近一次 root run（逻辑外键，见 §四.6）
... ... @@ -632,6 +636,11 @@ function getDb() {
632 636 if (!hasColumn(db, 'tasks', 'execution_conv_id')) {
633 637 db.exec(`ALTER TABLE tasks ADD COLUMN execution_conv_id TEXT`);
634 638 }
  639 + // 43 号文档：ADD COLUMN 加不了 CHECK（同上 executor 那条注释的 SQLite 限制），
  640 + // 存量库上 acceptance_mode 的取值域只由 createTask 的应用层校验守。
  641 + if (!hasColumn(db, 'tasks', 'acceptance_mode')) {
  642 + db.exec(`ALTER TABLE tasks ADD COLUMN acceptance_mode TEXT NOT NULL DEFAULT 'holistic'`);
  643 + }
635 644 // ⚠️ 这条索引**必须建在 ALTER 之后**，不能放进上面的建表块：
636 645 // 建表块整体先于迁移块执行，而存量库上 `CREATE TABLE IF NOT EXISTS tasks` 是 no-op ——
637 646 // 表还是批 4 的形态、没有 assignee_agent_id，那一句 CREATE INDEX 会直接抛
... ... @@ -1856,6 +1865,10 @@ function validateDependsOn(goalId, taskId, dependsOn) {
1856 1865 * **必须能在建行时就存下来**（缺陷 F3）：草稿路径（`POST /:cid/tasks` 撞 409 → 存草稿 →
1857 1866 * 之后 dispatch）上，请求体里的 budget 早就不在了。只有写侧没有读侧的列 = 用户填了、
1858 1867 * 接口回了 200、run 却拿着 DEFAULT_TASK_BUDGET 在跑，中途预算耗尽 blocked 且没人知道为什么。
  1868 + * @param {string|null} [p.parentTaskId] 43 号文档：子任务指回父任务。图流水线（`insertTasksForGoal`）
  1869 + * 建的顶层 task 恒为 null；只有 org-planner 收尾物化子任务时才传。
  1870 + * @param {string} [p.acceptanceMode='holistic'] 'holistic' | 'itemized'。子任务恒为 'holistic'
  1871 + * （不允许递归再拆一层）——传 `parentTaskId` 时若给了 'itemized' 会被拒。
1859 1872 * @returns {object} 刚插入的整行
1860 1873 */
1861 1874 function createTask({
... ... @@ -1870,14 +1883,25 @@ function createTask({
1870 1883 budgetJson = null,
1871 1884 reportTo = null,
1872 1885 createdBy = null,
  1886 + parentTaskId = null,
  1887 + acceptanceMode = 'holistic',
1873 1888 } = {}) {
1874 1889 if (!goalId) throw new Error('createTask: goalId 必填');
1875 1890 if (!title) throw new Error('createTask: title 必填');
1876 1891 if (!description) throw new Error('createTask: description 必填');
  1892 + if (!['holistic', 'itemized'].includes(acceptanceMode)) {
  1893 + throw new Error(`createTask: acceptanceMode 非法: ${acceptanceMode}`);
  1894 + }
  1895 + if (parentTaskId && acceptanceMode === 'itemized') {
  1896 + throw new Error('createTask: 子任务（有 parentTaskId）不允许再声明 itemized，不支持递归拆分');
  1897 + }
1877 1898  
1878 1899 const db = getDb();
1879 1900 const goal = getGoal(goalId);
1880 1901 if (!goal) throw new Error(`createTask: goal 不存在: ${goalId}`);
  1902 + if (parentTaskId && !getTask(parentTaskId)) {
  1903 + throw new Error(`createTask: parentTaskId 不存在: ${parentTaskId}`);
  1904 + }
1881 1905  
1882 1906 // company_id 这一列冗余存在的**唯一**理由是让调度器不必 JOIN；让调用方各传各的，
1883 1907 // 就等于给这份冗余留了一条能对不上的路。默认从 goal 抄，传了也以 goal 为准的那种「以防万一」
... ... @@ -1902,8 +1926,8 @@ function createTask({
1902 1926 const ins = db.prepare(`
1903 1927 INSERT INTO tasks (id, goal_id, company_id, seq, title, description, status,
1904 1928 execution_mode, depends_on, priority, budget_json, report_to, created_by,
1905   - created_at, updated_at)
1906   - VALUES (?, ?, ?, ?, ?, ?, 'draft', ?, ?, ?, ?, ?, ?, ?, ?)
  1929 + parent_task_id, acceptance_mode, created_at, updated_at)
  1930 + VALUES (?, ?, ?, ?, ?, ?, 'draft', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
1907 1931 `);
1908 1932 const id = insertWithFreshId('tasks', genTaskId, (tid) => ins.run(
1909 1933 tid, goalId, String(cid), nextSeq, String(title), String(description),
... ... @@ -1911,7 +1935,7 @@ function createTask({
1911 1935 // report_to 不落库就等于没有：请求作用域的闭包活不过一次排队（§四.7 禁令二）。
1912 1936 // goal 上有就继承下来，别让每个调用方各记一遍。
1913 1937 reportTo || goal.report_to || null,
1914   - createdBy, now, now
  1938 + createdBy, parentTaskId, acceptanceMode, now, now
1915 1939 ));
1916 1940 return getTask(id);
1917 1941 }
... ... @@ -1937,7 +1961,9 @@ function listGoalTasks(goalId, { includeArchived = false } = {}) {
1937 1961 * 这里再写一份就是第二个持有者 —— canDispatch 的取值域被前端复述了一遍、还多写一个值，
1938 1962 * 导致公司失败一次后再也下不了任务，就是这么来的。要位次找调度器要。
1939 1963 */
1940   -function listCompanyTasks(companyId, { status = null, goalId = null, includeArchived = false, limit = null } = {}) {
  1964 +function listCompanyTasks(companyId, {
  1965 + status = null, goalId = null, parentTaskId = null, includeArchived = false, limit = null,
  1966 +} = {}) {
1941 1967 const where = ['company_id = @companyId'];
1942 1968 const params = { companyId };
1943 1969 if (status) {
... ... @@ -1948,6 +1974,12 @@ function listCompanyTasks(companyId, { status = null, goalId = null, includeArch
1948 1974 where.push('goal_id = @goalId');
1949 1975 params.goalId = goalId;
1950 1976 }
  1977 + // 43 号文档 Phase 3：coder-validator 用它列出「这个 itemized 任务物化出了哪些子任务」，
  1978 + // 才知道要逐条上报哪几个 taskId
  1979 + if (parentTaskId) {
  1980 + where.push('parent_task_id = @parentTaskId');
  1981 + params.parentTaskId = parentTaskId;
  1982 + }
1951 1983 if (!includeArchived) where.push('archived_at IS NULL');
1952 1984 const lim = Number.isInteger(limit) && limit > 0 ? ` LIMIT ${limit}` : '';
1953 1985 return getDb()
... ... @@ -2084,6 +2116,31 @@ function settleTaskFromRun(taskId, runId, status) {
2084 2116 }
2085 2117  
2086 2118 /**
  2119 + * 43 号文档 Phase 3：coder-validator 逐条上报子任务验收结果的落库口。
  2120 + *
  2121 + * 与 `settleTaskFromRun` 同款条件更新（终态幂等闸门）：子任务可能因为 coder-validator
  2122 + * 被 retry 而重复上报，已经是终态的行不该被后一次调用覆盖。**只服务子任务**——
  2123 + * `parent_task_id IS NOT NULL` 这道 WHERE 挡住顶层 task（它的终态走 run 收敛那条路，
  2124 + * 不该被这个端点绕开）。
  2125 + *
  2126 + * @returns {number} 受影响行数；0 = 已经是终态 / 不是子任务，调用方据此判断这次上报有没有生效
  2127 + */
  2128 +function settleSubtaskResult(taskId, status, summary = null) {
  2129 + if (!['completed', 'failed'].includes(status)) {
  2130 + throw new Error(`settleSubtaskResult: status 只能是 'completed' 或 'failed'，收到: ${status}`);
  2131 + }
  2132 + const now = new Date().toISOString();
  2133 + return getDb()
  2134 + .prepare(`
  2135 + UPDATE tasks SET status = @status, summary = @summary, finished_at = @now, updated_at = @now
  2136 + WHERE id = @id
  2137 + AND parent_task_id IS NOT NULL
  2138 + AND status NOT IN (${TASK_TERMINAL_STATUS.map((s) => `'${s}'`).join(', ')})
  2139 + `)
  2140 + .run({ id: taskId, status, summary, now }).changes;
  2141 +}
  2142 +
  2143 +/**
2087 2144 * 「上游已经不可能满足了」这个 blocked 的原因前缀（27-P3C §五.1.2）。
2088 2145 *
2089 2146 * 它同时是**判据**：只有 `blocked_reason` 以它开头的 blocked task 才是调度器**推导**出来的，
... ... @@ -2715,6 +2772,7 @@ module.exports = {
2715 2772 taskProgress,
2716 2773 maxTaskSeq,
2717 2774 settleTaskFromRun,
  2775 + settleSubtaskResult,
2718 2776 GRAPH_TAKEOVER_ASSIGNEE,
2719 2777 // 批 3 排队：三条都是条件更新，调用方靠 changes 判「是不是我做的」
2720 2778 claimQueuedTask,
... ...
server/tests/unit/company-goal-task-routes.test.js
  View file @e9a2141
... ... @@ -400,7 +400,8 @@ describe(&#39;company goal/task routes（27-P3C §六）&#39;, () =&gt; {
400 400  
401 401 const ok = validatePlannedTasks([{ seq: 1, title: 'a', description: 'A', depends_on: [] }]);
402 402 expect(ok.ok).toBe(true);
403   - expect(ok.specs[0]).toEqual({ seq: 1, title: 'a', description: 'A', depends_on: [] });
  403 + // 43 号文档：acceptance_mode 没写就缺省 'holistic'
  404 + expect(ok.specs[0]).toEqual({ seq: 1, title: 'a', description: 'A', depends_on: [], acceptance_mode: 'holistic' });
404 405  
405 406 const rules = (raw) => validatePlannedTasks(raw).errors.map((e) => e.rule);
406 407 // seq 与数组顺序错位：错位后 depends_on 引的是另一条 task，而那条错误依赖完全合法，
... ... @@ -415,6 +416,9 @@ describe(&#39;company goal/task routes（27-P3C §六）&#39;, () =&gt; {
415 416 expect(rules(Array.from({ length: 9 }, (_, i) => ({ seq: i + 1, description: 'x', depends_on: [] }))))
416 417 .toContain('limit');
417 418 expect(rules([{ seq: 1, description: 'A', depends_on: [], mode: 'auto' }])).toContain('schema');
  419 + // 43 号文档：acceptance_mode 是允许出现的第五个键，itemized 合法、乱写值按 schema 打回
  420 + expect(validatePlannedTasks([{ seq: 1, description: 'A', depends_on: [], acceptance_mode: 'itemized' }]).ok).toBe(true);
  421 + expect(rules([{ seq: 1, description: 'A', depends_on: [], acceptance_mode: 'bogus' }])).toContain('schema');
418 422  
419 423 // 正向引用（第 1 条依赖第 2 条）不成环，是合法输入 —— 批 1 缺陷 4 就是被它咬的
420 424 expect(validatePlannedTasks([
... ...
server/tests/unit/graph-engine-fail-reason.test.js
  View file @e9a2141
... ... @@ -123,7 +123,7 @@ describe(&#39;引擎自判失败的 fail_reason 与失败上下文（W12 补完 / W9
123 123 // W12 补完 · 三类引擎自判失败都在 fail_reason 上留名
124 124 // ────────────────────────────────────────────────────────────────
125 125  
126   - it('取值域：六个引擎取值与 agent 的归因取值域**不重叠**（复用会劫持精确 fail 边的路由）', () => {
  126 + it('取值域：七个引擎取值与 agent 的归因取值域**不重叠**（复用会劫持精确 fail 边的路由）', () => {
127 127 const engineReasons = Object.values(engine.ENGINE_FAIL_REASONS);
128 128 expect(engineReasons).toEqual([
129 129 'node_error', 'boundary_escape', 'child_run_failed',
... ... @@ -131,6 +131,9 @@ describe(&#39;引擎自判失败的 fail_reason 与失败上下文（W12 补完 / W9
131 131 'missing_required_input', 'produces_missing',
132 132 // 35 号文档提案 A：本体完整性闸门（runClaimedNode 派发前检查）新增的取值
133 133 'body_not_ready',
  134 + // 43 号文档 Phase 3：coder-validator 判自己 success 但 itemized 任务的子任务没全部
  135 + // completed 时新增的取值（settleNode 的 success 判定里，与上面两个契约闸门同一处）
  136 + 'subtasks_incomplete',
134 137 ]);
135 138 // infra_flake 在 routeFailure 里有特判（原地重跑、不烧计数）。任何一个引擎取值撞上它
136 139 // 都会让确定性失败（如 Agent not found）原地重跑到预算耗尽。
... ...
server/tests/unit/task-acceptance-mode.test.js 0 → 100644
  View file @e9a2141
  1 +/**
  2 + * 43 号文档 Phase 0：`tasks.acceptance_mode` + `createTask({parentTaskId})` 的落库校验。
  3 + *
  4 + * 隔离：先设 GRAPH_DB_PATH 再 require（清 require.cache），仓库 data/graph.sqlite 全程不碰
  5 + * ——写法与 graph-edge-contracts.test.js 同源。
  6 + */
  7 +import { describe, it, expect, beforeAll, afterAll } from 'vitest';
  8 +import fs from 'fs';
  9 +
  10 +const TEST_DB_PATH = '/tmp/test-task-acceptance-mode.sqlite';
  11 +const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
  12 +
  13 +describe('43 号文档 Phase 0：acceptance_mode / parentTaskId', () => {
  14 + let wdb;
  15 +
  16 + beforeAll(() => {
  17 + for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
  18 + process.env.GRAPH_DB_PATH = TEST_DB_PATH;
  19 + delete require.cache[require.resolve('../../services/graph-db')];
  20 + delete require.cache[require.resolve('../../services/work-graph-db')];
  21 + wdb = require('../../services/work-graph-db');
  22 + });
  23 +
  24 + afterAll(() => {
  25 + for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
  26 + delete process.env.GRAPH_DB_PATH;
  27 + delete require.cache[require.resolve('../../services/graph-db')];
  28 + delete require.cache[require.resolve('../../services/work-graph-db')];
  29 + });
  30 +
  31 + function goalId() {
  32 + const g = wdb.createGoal({ companyId: 'co-amode', title: 'g', description: 'd' });
  33 + return g.id;
  34 + }
  35 +
  36 + it('缺省 acceptance_mode=holistic、parent_task_id=null（图流水线现状不变）', () => {
  37 + const t = wdb.createTask({ goalId: goalId(), title: 't', description: 'd' });
  38 + expect(t.acceptance_mode).toBe('holistic');
  39 + expect(t.parent_task_id).toBeNull();
  40 + });
  41 +
  42 + it('可以显式建一条 itemized 的顶层 task', () => {
  43 + const t = wdb.createTask({ goalId: goalId(), title: 't', description: 'd', acceptanceMode: 'itemized' });
  44 + expect(t.acceptance_mode).toBe('itemized');
  45 + });
  46 +
  47 + it('非法 acceptanceMode 直接拒', () => {
  48 + expect(() => wdb.createTask({ goalId: goalId(), title: 't', description: 'd', acceptanceMode: 'bogus' }))
  49 + .toThrow(/acceptanceMode 非法/);
  50 + });
  51 +
  52 + it('子任务：parentTaskId 指回父任务，acceptance_mode 恒 holistic', () => {
  53 + const gid = goalId();
  54 + const parent = wdb.createTask({ goalId: gid, title: 'parent', description: 'd', acceptanceMode: 'itemized' });
  55 + const child = wdb.createTask({ goalId: gid, title: 'child A.1', description: 'd', parentTaskId: parent.id });
  56 + expect(child.parent_task_id).toBe(parent.id);
  57 + expect(child.acceptance_mode).toBe('holistic');
  58 + });
  59 +
  60 + it('子任务不允许递归声明 itemized（不支持二级拆分）', () => {
  61 + const gid = goalId();
  62 + const parent = wdb.createTask({ goalId: gid, title: 'parent', description: 'd' });
  63 + expect(() => wdb.createTask({
  64 + goalId: gid, title: 'child', description: 'd', parentTaskId: parent.id, acceptanceMode: 'itemized',
  65 + })).toThrow(/不支持递归拆分/);
  66 + });
  67 +
  68 + it('parentTaskId 指向不存在的 task 直接拒，不静默建成孤儿行', () => {
  69 + expect(() => wdb.createTask({ goalId: goalId(), title: 't', description: 'd', parentTaskId: 'T-not-exist' }))
  70 + .toThrow(/parentTaskId 不存在/);
  71 + });
  72 +});
... ...
server/tests/unit/task-decomposition-materialize.test.js 0 → 100644
  View file @e9a2141
  1 +/**
  2 + * 43 号文档 Phase 2：org-planner 节点结算 success 后，把 acceptance.md 物化成子任务。
  3 + *
  4 + * org 层节点全是 subgraph（isSubgraphNode 恒真），真正的产出在 workgraph-planning 展开出的
  5 + * 子 run 里——所以这里跟 goal-task-acceptance.test.js 同源，用 `setPlanWorkGraph` 注入假
  6 + * 规划（返回一张手造的单节点 work graph），再用 `setAgentExecutor` 注入那个节点的假执行，
  7 + * 不真起 Claude CLI。
  8 + */
  9 +import { describe, it, expect, beforeAll, afterAll } from 'vitest';
  10 +import fs from 'fs';
  11 +import os from 'os';
  12 +import path from 'path';
  13 +
  14 +const TEST_DB_PATH = '/tmp/test-task-decomp-materialize.sqlite';
  15 +const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
  16 +const MODULES = [
  17 + '../../services/graph-db',
  18 + '../../services/graph-service',
  19 + '../../services/org-graph-service',
  20 + '../../services/work-graph-db',
  21 + '../../services/graph-run-sse',
  22 + '../../services/graph-engine',
  23 +];
  24 +
  25 +const ORG_NODES = ['org-planner', 'org-coder', 'org-validator'];
  26 +const ORG_EDGES = [
  27 + { from: 'org-planner', to: 'org-coder', condition: 'success' },
  28 + { from: 'org-coder', to: 'org-validator', condition: 'success' },
  29 +];
  30 +
  31 +const ACCEPTANCE_MD = `# 验收清单
  32 +
  33 +| # | 验收项 | 判定方式 | pass 条件 |
  34 +|---|--------|----------|-----------|
  35 +| 1 | 方向键控制移动 | 手动操作 | 蛇按方向键移动 |
  36 +| 2 | 吃到食物加分 | 手动操作 | 分数 +1 |
  37 +`;
  38 +
  39 +describe('43 号文档 Phase 2：acceptance.md → 子任务物化', () => {
  40 + let wdb;
  41 + let org;
  42 + let engine;
  43 + let runsDir;
  44 +
  45 + beforeAll(() => {
  46 + for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
  47 + process.env.GRAPH_DB_PATH = TEST_DB_PATH;
  48 + runsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'task-decomp-runs-'));
  49 + process.env.GRAPH_RUNS_DIR = runsDir;
  50 + for (const m of MODULES) delete require.cache[require.resolve(m)];
  51 + wdb = require('../../services/work-graph-db');
  52 + org = require('../../services/org-graph-service');
  53 + engine = require('../../services/graph-engine');
  54 + });
  55 +
  56 + afterAll(() => {
  57 + for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
  58 + delete process.env.GRAPH_DB_PATH;
  59 + try { fs.rmSync(runsDir, { recursive: true, force: true }); } catch {}
  60 + delete process.env.GRAPH_RUNS_DIR;
  61 + for (const m of MODULES) delete require.cache[require.resolve(m)];
  62 + });
  63 +
  64 + function ensureAgent(id) {
  65 + const db = wdb.getDb();
  66 + const now = new Date().toISOString();
  67 + db.prepare(`INSERT OR IGNORE INTO system_agents
  68 + (id, name, scope, owner_company_id, legacy_path, status, created_at, updated_at)
  69 + VALUES (?, ?, 'public', NULL, ?, 'active', ?, ?)`)
  70 + .run(id, id, `system/agents/${id}`, now, now);
  71 + }
  72 +
  73 + /** 建一家公司的 org 图 + 一条 task，起一条 org run，跑到 org-planner（含它展开的子图）结算为止 */
  74 + async function setupAndRunPlanner(companyId, { acceptanceMode = 'itemized', writeFile = true } = {}) {
  75 + expect(org.writeGraph(companyId, { nodes: ORG_NODES, edges: ORG_EDGES }).ok).toBe(true);
  76 + ensureAgent('planner-worker');
  77 +
  78 + const goal = wdb.createGoal({ companyId, title: 'g', description: '贪吃蛇游戏' });
  79 + const task = wdb.createTask({
  80 + goalId: goal.id, title: '实现贪吃蛇', description: 'd', acceptanceMode,
  81 + });
  82 +
  83 + const run = wdb.createRun({ graphKind: 'org', graphId: companyId, companyId, taskId: task.id });
  84 + engine.markRunReady(run.id);
  85 + engine.startRun(run.id, { mode: 'manual' });
  86 +
  87 + engine.setPlanWorkGraph(async () => {
  88 + const g = wdb.createWorkGraph({
  89 + companyId, nodes: [{ nodeName: 'planner-worker', systemAgentId: 'planner-worker' }], edges: [],
  90 + });
  91 + expect(g.errors || []).toEqual([]);
  92 + return { workGraphId: g.id };
  93 + });
  94 + let childRunId;
  95 + try {
  96 + const planned = await engine.nextStep(run.id); // org-planner：规划出子图，父节点转 running 等子 run
  97 + childRunId = planned.node && planned.node.childRunId;
  98 + } finally {
  99 + engine.setPlanWorkGraph(null);
  100 + }
  101 + expect(childRunId).toBeTruthy();
  102 +
  103 + engine.setAgentExecutor(async (ctx) => {
  104 + const dir = path.join(runsDir, ctx.run.root_run_id, 'nodes', ctx.nodeRunId);
  105 + fs.mkdirSync(dir, { recursive: true });
  106 + if (writeFile) fs.writeFileSync(path.join(dir, 'acceptance.md'), ACCEPTANCE_MD);
  107 + return { status: 'success', outputRef: dir };
  108 + });
  109 + try {
  110 + await engine.advanceOne(childRunId); // 子图里唯一的那个节点
  111 + } finally {
  112 + engine.setAgentExecutor(null);
  113 + }
  114 + return { task, run, childRunId };
  115 + }
  116 +
  117 + it('itemized + acceptance.md 存在 → org-planner 结算 success 后按表格行数物化子任务', async () => {
  118 + const { task, run } = await setupAndRunPlanner('co-materialize-1');
  119 + const plannerNode = wdb.getDb().prepare(`
  120 + SELECT status FROM graph_run_nodes WHERE run_id = ?
  121 + AND def_node_id = (SELECT id FROM org_graph_nodes WHERE company_id='co-materialize-1' AND role_name='org-planner')
  122 + `).get(run.id);
  123 + expect(plannerNode.status).toBe('success'); // 前提：子图真的收敛回了父节点
  124 +
  125 + const children = wdb.getDb()
  126 + .prepare(`SELECT * FROM tasks WHERE parent_task_id = ? ORDER BY created_at`)
  127 + .all(task.id);
  128 + expect(children).toHaveLength(2);
  129 + expect(children[0].title).toBe('方向键控制移动');
  130 + expect(children[0].acceptance_mode).toBe('holistic');
  131 + expect(children[0].description).toContain('手动操作');
  132 + expect(children[0].description).toContain('蛇按方向键移动');
  133 + expect(children[1].title).toBe('吃到食物加分');
  134 + });
  135 +
  136 + it('holistic 任务：org-planner 成功结算，不物化任何子任务', async () => {
  137 + const { task } = await setupAndRunPlanner('co-materialize-2', { acceptanceMode: 'holistic' });
  138 + const n = wdb.getDb().prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ?`).get(task.id).n;
  139 + expect(n).toBe(0);
  140 + });
  141 +
  142 + it('itemized 但 acceptance.md 不存在：org-planner 仍判 success，不物化子任务（软失败，不拖累主产出）', async () => {
  143 + const { task, run } = await setupAndRunPlanner('co-materialize-3', { writeFile: false });
  144 + const n = wdb.getDb().prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ?`).get(task.id).n;
  145 + expect(n).toBe(0);
  146 + const plannerNode = wdb.getDb().prepare(`
  147 + SELECT status FROM graph_run_nodes WHERE run_id = ?
  148 + AND def_node_id = (SELECT id FROM org_graph_nodes WHERE company_id='co-materialize-3' AND role_name='org-planner')
  149 + `).get(run.id);
  150 + expect(plannerNode.status).toBe('success'); // 找不到 acceptance.md 不该把这一步打成 fail
  151 + });
  152 +});
... ...
server/tests/unit/task-decomposition-validator-gate.test.js 0 → 100644
  View file @e9a2141
  1 +/**
  2 + * 43 号文档 Phase 3：coder-validator 判自己 success 之前，子任务必须全部 completed
  3 + * 才认；以及 settleSubtaskResult 这个落库口本身的条件更新/幂等/校验。
  4 + */
  5 +import { describe, it, expect, beforeAll, afterAll } from 'vitest';
  6 +import fs from 'fs';
  7 +import os from 'os';
  8 +import path from 'path';
  9 +
  10 +const TEST_DB_PATH = '/tmp/test-task-decomp-validator-gate.sqlite';
  11 +const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
  12 +const MODULES = [
  13 + '../../services/graph-db',
  14 + '../../services/graph-service',
  15 + '../../services/org-graph-service',
  16 + '../../services/work-graph-db',
  17 + '../../services/graph-run-sse',
  18 + '../../services/graph-engine',
  19 +];
  20 +
  21 +describe('43 号文档 Phase 3', () => {
  22 + let wdb;
  23 + let engine;
  24 + let runsDir;
  25 +
  26 + beforeAll(() => {
  27 + for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
  28 + process.env.GRAPH_DB_PATH = TEST_DB_PATH;
  29 + runsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'task-decomp-gate-runs-'));
  30 + process.env.GRAPH_RUNS_DIR = runsDir;
  31 + for (const m of MODULES) delete require.cache[require.resolve(m)];
  32 + wdb = require('../../services/work-graph-db');
  33 + engine = require('../../services/graph-engine');
  34 + });
  35 +
  36 + afterAll(() => {
  37 + for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
  38 + delete process.env.GRAPH_DB_PATH;
  39 + try { fs.rmSync(runsDir, { recursive: true, force: true }); } catch {}
  40 + delete process.env.GRAPH_RUNS_DIR;
  41 + for (const m of MODULES) delete require.cache[require.resolve(m)];
  42 + });
  43 +
  44 + function ensureAgent(id) {
  45 + const db = wdb.getDb();
  46 + const now = new Date().toISOString();
  47 + db.prepare(`INSERT OR IGNORE INTO system_agents
  48 + (id, name, scope, owner_company_id, legacy_path, status, created_at, updated_at)
  49 + VALUES (?, ?, 'public', NULL, ?, 'active', ?, ?)`)
  50 + .run(id, id, `system/agents/${id}`, now, now);
  51 + }
  52 +
  53 + // ── settleSubtaskResult 本身 ─────────────────────────────────────
  54 +
  55 + it('settleSubtaskResult：非法 status 直接拒', () => {
  56 + expect(() => wdb.settleSubtaskResult('T-whatever', 'running')).toThrow(/status 只能是/);
  57 + });
  58 +
  59 + it('settleSubtaskResult：不是子任务（parent_task_id 为空）不生效，changes=0', () => {
  60 + const goal = wdb.createGoal({ companyId: 'co-gate-1', title: 'g', description: 'd' });
  61 + const top = wdb.createTask({ goalId: goal.id, title: 't', description: 'd' });
  62 + const changed = wdb.settleSubtaskResult(top.id, 'completed');
  63 + expect(changed).toBe(0);
  64 + expect(wdb.getTask(top.id).status).toBe('draft'); // 没被动过
  65 + });
  66 +
  67 + it('settleSubtaskResult：正常上报 + 终态幂等（第二次不同结果上报不生效）', () => {
  68 + const goal = wdb.createGoal({ companyId: 'co-gate-2', title: 'g', description: 'd' });
  69 + const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd', acceptanceMode: 'itemized' });
  70 + const child = wdb.createTask({ goalId: goal.id, title: 'c', description: 'd', parentTaskId: parent.id });
  71 +
  72 + expect(wdb.settleSubtaskResult(child.id, 'completed', '通过')).toBe(1);
  73 + const after1 = wdb.getTask(child.id);
  74 + expect(after1.status).toBe('completed');
  75 + expect(after1.summary).toBe('通过');
  76 + expect(after1.finished_at).toBeTruthy();
  77 +
  78 + // 已经是终态，再上报 failed 不该覆盖——防的是 coder-validator 因 retry 重复上报
  79 + expect(wdb.settleSubtaskResult(child.id, 'failed', '改判')).toBe(0);
  80 + expect(wdb.getTask(child.id).status).toBe('completed');
  81 + });
  82 +
  83 + // ── 引擎侧的闸门：coder-validator 判 success 前核子任务 ─────────────
  84 +
  85 + async function runValidator(companyId, taskId) {
  86 + ensureAgent('coder-validator');
  87 + const g = wdb.createWorkGraph({
  88 + companyId,
  89 + taskId,
  90 + nodes: [{ nodeName: 'v', systemAgentId: 'coder-validator' }],
  91 + edges: [],
  92 + });
  93 + expect(g.errors || []).toEqual([]);
  94 + const run = wdb.createRun({ graphKind: 'work', graphId: g.id, companyId, taskId });
  95 + engine.markRunReady(run.id);
  96 + engine.startRun(run.id, { mode: 'manual' });
  97 + engine.setAgentExecutor(async () => ({ status: 'success' }));
  98 + let out;
  99 + try {
  100 + out = await engine.advanceOne(run.id);
  101 + } finally {
  102 + engine.setAgentExecutor(null);
  103 + }
  104 + return out;
  105 + }
  106 +
  107 + it('itemized 任务 + 子任务还没全部 completed → coder-validator 判自己 success 但被引擎打回 fail', async () => {
  108 + const companyId = 'co-gate-3';
  109 + const goal = wdb.createGoal({ companyId, title: 'g', description: 'd' });
  110 + const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd', acceptanceMode: 'itemized' });
  111 + const c1 = wdb.createTask({ goalId: goal.id, title: 'c1', description: 'd', parentTaskId: parent.id });
  112 + wdb.createTask({ goalId: goal.id, title: 'c2', description: 'd', parentTaskId: parent.id });
  113 + wdb.settleSubtaskResult(c1.id, 'completed'); // 只完成一半
  114 +
  115 + const out = await runValidator(companyId, parent.id);
  116 + // 单节点图没有兜底边可退，fail 之后引擎会继续把它收敛成 blocked（等人）——
  117 + // 这里要验的是「没被判 success」+「归因是 subtasks_incomplete」，不是具体停在哪个终态
  118 + expect(out.node.status).not.toBe('success');
  119 + expect(out.node.failReason).toBe('subtasks_incomplete');
  120 + });
  121 +
  122 + it('itemized 任务 + 子任务全部 completed → coder-validator 正常判 success', async () => {
  123 + const companyId = 'co-gate-4';
  124 + const goal = wdb.createGoal({ companyId, title: 'g', description: 'd' });
  125 + const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd', acceptanceMode: 'itemized' });
  126 + const c1 = wdb.createTask({ goalId: goal.id, title: 'c1', description: 'd', parentTaskId: parent.id });
  127 + const c2 = wdb.createTask({ goalId: goal.id, title: 'c2', description: 'd', parentTaskId: parent.id });
  128 + wdb.settleSubtaskResult(c1.id, 'completed');
  129 + wdb.settleSubtaskResult(c2.id, 'completed');
  130 +
  131 + const out = await runValidator(companyId, parent.id);
  132 + expect(out.node.status).toBe('success');
  133 + });
  134 +
  135 + it('holistic 任务（没有子任务）：闸门不生效，success 照常通过', async () => {
  136 + const companyId = 'co-gate-5';
  137 + const goal = wdb.createGoal({ companyId, title: 'g', description: 'd' });
  138 + const task = wdb.createTask({ goalId: goal.id, title: 't', description: 'd' }); // 缺省 holistic
  139 +
  140 + const out = await runValidator(companyId, task.id);
  141 + expect(out.node.status).toBe('success');
  142 + });
  143 +});
... ...
system/agents/coder-validator/agent.md
  View file @e9a2141
... ... @@ -68,6 +68,31 @@ node server/services/goal-contract.js run --target &lt;雿迤撉漱隞頝臬
68 68 **撠梢嚗** 瘥蝏嚗 / 銝 + 霂嚗挾 `辣:銵`嚗
69 69 憟漲憯唳葵閬笆摨閮ㄟ葵停閬嚗蜓瘚停銵
70 70  
  71 +### Step 4bis 繚 餈 task itemized 遙閬銝嚗43 ﹝嚗
  72 +
  73 +銝銝迤撉 task 瓷◤遙嚗itemized` 遙holistic` 瘝⊥
  74 +
  75 +```bash
  76 +node bin/lemon.js task subtasks --companyId <ID> --taskId <隞餃ID>
  77 +```
  78 +
  79 +餈征” = 餈 task `holistic`嚗歲餈甇伐 Step 4 acceptance_criteria 韏啜
  80 +
  81 +餈征”嚗**瘥摮遙停撖孵撉**嚗rg-planner 撠暹 acceptance.md
  82 + Step 2/3 瘜遛嚗摰**瘥摰撠曹銝甈**嚗
  83 +
  84 +```bash
  85 +node bin/lemon.js task subtask-result --companyId <ID> --taskId <摮遙ID> --status completed --summary "霂"
  86 +node bin/lemon.js task subtask-result --companyId <ID> --taskId <摮遙ID> --status failed --summary "辣:銵 + 銝"
  87 +```
  88 +
  89 + **餈甇乩兮鞎蝖祇**嚗雿銋銝 task 遙
  90 +銝****鈭 `completed` 銝瘝⊥鈭 `failed`嚗頧桀捏
  91 +`"verdict": "passed"` 餈隡◤撘**撘箏憭梯揖**嚗敶撘撌勗雿
  92 +雿餈遢銵券摰fail_reason` ‵撘”嚗澆摰
  93 +`attempt-N.json` `checks[]` 蝏犖恣霈⊥嚗**瘝⊥遙雿蝡臭誨圾**
  94 +迤霂港雿瓷銝餈隞日銝
  95 +
71 96 ### Step 5 繚 鈭批
72 97  
73 98 fail `remediation_note` 敹◆霈 coder 撘撌伐**`辣:銵` + 蛹 + 憟賭**
... ... @@ -170,6 +195,8 @@ fail `remediation_note` 敹◆霈 coder 撘撌伐**`辣:銵`
170 195 mock ◤瘚笆鞊 / 閬辣嚗
171 196 4. acceptance_criteria 餈鈭撠望銵
172 197 憟漲憯唳葵/秤閮
  198 +4bis. 餈 `task subtasks` 鈭遙銝瘥靚 `task subtask-result`
  199 + 銝嚗 attempt-N.json checks[] 撠曹誑銝箏
173 200 5. 瓷敢憿箸鈭銵誨捂鈭停瘝⊥洵鈭
174 201 6. fail_reason ‵ impl_bug / input_underspecified / infra_flake / null 銋
175 202 憛 infra_flake 餈漣摰 impl_bug嚗
... ...
system/agents/task-planning/agent.md
  View file @e9a2141
... ... @@ -3,11 +3,11 @@
3 3 ## ⚡ 硬约束（这 9 条排在最前面，因为它们是判「这一轮算不算数」的全部依据）
4 4  
5 5 1. **你的产出是一个 JSON 数组，不是别的任何东西。** 形状固定：
6   - `[{ "seq": 1, "title": "…", "description": "…", "depends_on": [] }]`
  6 + `[{ "seq": 1, "title": "…", "description": "…", "depends_on": [], "acceptance_mode": "holistic" }]`
7 7 2. **`depends_on` 里只能出现本次产出的 `seq` 数字**（1-based）。**不许写 task id** —— id 由服务端在你交回之后才生成，你根本看不到。写字符串 id 一定被打回。
8 8 3. **`seq` 必须是 1..N 连续整数、不重复、按你数组的顺序排。** 别跳号，别从 0 开始。
9 9 4. **条数上限 8。** 超过 8 条，说明你在拆步骤而不是拆任务（见「Step 2」）。
10   -5. **只输出这四个字段。** 不许产出 `id` / `taskId` / `status` / `mode` / `budget` / `priority` / `agent` / `assignee` —— 这些要么由服务端生成，要么由人在界面上定，你写了会被当成脏字段打回。
  10 +5. **只输出这五个字段，其中 `acceptance_mode` 可以不写（缺省 `"holistic"`）。** 不许产出 `id` / `taskId` / `status` / `mode` / `budget` / `priority` / `agent` / `assignee` —— 这些要么由服务端生成，要么由人在界面上定，你写了会被当成脏字段打回。`acceptance_mode` 是唯一的例外：它需要你的语义判断，服务端给不出默认值以外的答案，见「Step 2bis」。
11 11 6. **JSON 代码块必须是你回复的最后一段。** 拆分理由写在它**前面**的正文里。代码块之后不要再写任何字。
12 12 7. **一条也算合法产出。** goal 本身就是一件事时，输出**恰好 1 条** `seq:1 / depends_on:[]`。这不是失败，是正确答案（见「Step 2」的不拆信号）。
13 13 8. **不许发明需求。** goal 描述里没有的东西，一个字都不许出现在你的 task 里。拆分是**切分**，不是扩写、不是补全、不是「顺便建议」。
... ... @@ -89,6 +89,19 @@
89 89  
90 90 ---
91 91  
  92 +## Step 2bis · 这条 task 的验收要不要拆成子任务逐条判（`acceptance_mode`）
  93 +
  94 +这是**这条 task 内部**的判断，跟 Step 2「要不要拆成多条 task」是同一个轴（够不够独立成立、值不值得单独验收），只是尺度缩小了一级——Step 2 判的是「这个 goal 该拆成几条 task」，这里判的是「这一条 task 的验收标准该不该拆成几条子任务」。
  95 +
  96 +- **`"holistic"`（缺省，不确定就选它）**：这条 task 是一个不可再分的交付物，验收时一次性给总分。绝大多数 task 都是这个。
  97 +- **`"itemized"`**：这条 task 对外是**单一交付物**（不满足 Step 2 拆多条 task 的条件），但它的验收标准天然由**多条互相独立、可以各自单独判定通过与否**的条目组成——拿掉其中一条，剩下的验收条目仍然各自成立。org-planner 收尾时会把这些验收条目物化成子任务，挂在看板上，coder-validator 会逐条判而不是给总分。
  98 +
  99 +例子：「实现一个贪吃蛇小游戏」是一个交付物（不该按 Step 2 拆成「方向控制」「计分」「碰撞」「重开」四条 task——那是同一个交付物的四个功能点，不是四个可以分开验收的交付物），但它的验收标准（方向键控制、吃到食物加分、碰撞结束游戏、可以重新开始）彼此独立、可以逐条判定——这种情况写 `"itemized"`。反例：「产出可跑通的后端服务」这条 task 的验收标准可能也有好几条（能启动、接口能上传、接口能下载、错误有正确返回码），但如果这些条目本身互相依赖、拆开单独判没有意义（比如"能上传"离开"能启动"根本无法验证），就该留 `"holistic"`。
  100 +
  101 +**判断错的代价是不对称的**：错误地写 `"itemized"`（验收标准其实互相依赖）会让后续验收拆出没法独立成立的子任务，比漏写、保守选 `"holistic"` 的代价更高。拿不准就留 `"holistic"`。
  102 +
  103 +---
  104 +
92 105 ## Step 3 · 定依赖
93 106  
94 107 `depends_on` 只写**真的拿不到前一条的产物就开不了工**的那种依赖。
... ... @@ -100,7 +113,7 @@
100 113  
101 114 ---
102 115  
103   -## Step 4 · 自查（六条，逐条对着你写好的 JSON 过一遍再交）
  116 +## Step 4 · 自查（七条，逐条对着你写好的 JSON 过一遍再交）
104 117  
105 118 | # | 检查 | 不过怎么办 |
106 119 |---|---|---|
... ... @@ -108,8 +121,9 @@
108 121 | 2 | `depends_on` 每个元素都是 1..N 里的整数、不等于自己、无环 | 删掉引用不到的 |
109 122 | 3 | N ≤ 8 | 回 Step 2 合并 |
110 123 | 4 | 每条 `description` 单独读得懂、写清了「做完什么算达成」 | 补全背景，别写跨条引用 |
111   -| 5 | 四个字段之外没有多余键；`depends_on` 是数组（哪怕是空的 `[]`）也必须在 | 删掉多余键，补上 `[]` |
  124 +| 5 | 五个字段之外没有多余键；`depends_on` 是数组（哪怕是空的 `[]`）也必须在 | 删掉多余键，补上 `[]` |
112 125 | 6 | N 条加起来正好覆盖 goal，没漏、**也没多发明** | 漏了补一条；多了删掉 |
  126 +| 7 | 写了 `"itemized"` 的每一条，验收标准确实由几条互相独立的条目组成，不是硬凑的 | 拿不准就改回 `"holistic"`（省略也一样） |
113 127  
114 128 ---
115 129  
... ... @@ -142,6 +156,18 @@
142 156 ]
143 157 ```
144 158  
  159 +`acceptance_mode` 不写就是 `"holistic"`，上面三条都省了。只有验收标准天然拆成几条互相独立条目的单一交付物才需要显式写 `"itemized"`（见 Step 2bis 的贪吃蛇例子）：
  160 +
  161 +```json
  162 +[{
  163 + "seq": 1,
  164 + "title": "实现可在浏览器直接玩的贪吃蛇游戏",
  165 + "description": "用 HTML/CSS/JS 实现一个完整的贪吃蛇小游戏。达成判据：方向键控制移动、吃到食物加分、撞墙或撞自己游戏结束、可以重新开始。",
  166 + "depends_on": [],
  167 + "acceptance_mode": "itemized"
  168 +}]
  169 +```
  170 +
145 171 最小合法产出（goal 本身就是一件事时，**这是正确答案，不是偷懒**）：
146 172  
147 173 ```json
... ...
web/src/components/graph-console/GoalTaskPane.vue
  View file @e9a2141
... ... @@ -76,58 +76,70 @@
76 76 </p>
77 77  
78 78 <ul class="tasks">
79   - <li
80   - v-for="t in g.tasks || []"
81   - :key="t.taskId"
82   - class="task"
83   - :class="{ on: t.taskId === selectedTaskId, blocked: t.status === 'blocked' }"
84   - @click="$emit('select', { goalId: g.goalId, taskId: t.taskId })"
85   - >
86   - <span class="dot" :class="{ pulse: taskStyle(t.status).pulse }" :style="dotStyle(taskStyle(t.status))" />
87   - <div class="t-body">
88   - <div class="t-title">
89   - <span
90   - v-if="(t.dependsOn || []).length"
91   - class="dep"
92   - :title="dependsLabel(t, g.tasks || [])"
93   - >⇢</span>{{ t.title || t.taskId }}
  79 + <template v-for="t in topLevel(g.tasks)" :key="t.taskId">
  80 + <li
  81 + class="task"
  82 + :class="{ on: t.taskId === selectedTaskId, blocked: t.status === 'blocked' }"
  83 + @click="$emit('select', { goalId: g.goalId, taskId: t.taskId })"
  84 + >
  85 + <span class="dot" :class="{ pulse: taskStyle(t.status).pulse }" :style="dotStyle(taskStyle(t.status))" />
  86 + <div class="t-body">
  87 + <div class="t-title">
  88 + <span
  89 + v-if="(t.dependsOn || []).length"
  90 + class="dep"
  91 + :title="dependsLabel(t, g.tasks || [])"
  92 + >⇢</span>{{ t.title || t.taskId }}
  93 + </div>
  94 + <div class="t-sub">
  95 + <!-- 排队中的行把状态标签换成位次：「排队中」谁都看得出来，「前面还有几个」才是
  96 + 用户点完下达之后真正在问的问题。位次是服务端算的，前端不排（见 queueBadge） -->
  97 + <span
  98 + v-if="queueBadge(t)"
  99 + class="st queue"
  100 + :style="{ color: taskStyle(t.status).color }"
  101 + :title="queueBadge(t).title"
  102 + >{{ queueBadge(t).text }}</span>
  103 + <span v-else class="st" :style="{ color: taskStyle(t.status).color }">{{ taskStyle(t.status).label }}</span>
  104 + <span v-if="taskSubtitle(t, now)"> · {{ taskSubtitle(t, now) }}</span>
  105 + </div>
  106 + <!-- blocked 的原因单独一行并标红：它是**要人动手**的状态，混在灰色第二排里等于没说 -->
  107 + <div v-if="blockedLabel(t, g.tasks || [])" class="t-blocked" :title="t.blockedReason">
  108 + ⚠ {{ blockedLabel(t, g.tasks || []) }}
  109 + </div>
94 110 </div>
95   - <div class="t-sub">
96   - <!-- 排队中的行把状态标签换成位次：「排队中」谁都看得出来，「前面还有几个」才是
97   - 用户点完下达之后真正在问的问题。位次是服务端算的，前端不排（见 queueBadge） -->
98   - <span
99   - v-if="queueBadge(t)"
100   - class="st queue"
101   - :style="{ color: taskStyle(t.status).color }"
102   - :title="queueBadge(t).title"
103   - >{{ queueBadge(t).text }}</span>
104   - <span v-else class="st" :style="{ color: taskStyle(t.status).color }">{{ taskStyle(t.status).label }}</span>
105   - <span v-if="taskSubtitle(t, now)"> · {{ taskSubtitle(t, now) }}</span>
106   - </div>
107   - <!-- blocked 的原因单独一行并标红：它是**要人动手**的状态，混在灰色第二排里等于没说 -->
108   - <div v-if="blockedLabel(t, g.tasks || [])" class="t-blocked" :title="t.blockedReason">
109   - ⚠ {{ blockedLabel(t, g.tasks || []) }}
110   - </div>
111   - </div>
112   - <button
113   - v-if="taskActions(t).length"
114   - class="more t-more"
115   - title="更多"
116   - @click.stop="menu = menu === t.taskId ? '' : t.taskId"
117   - >⋯</button>
118   -
119   - <!-- 每条 task 的操作菜单。做不成的（重跑）置灰并说明，不给能点却必然 4xx 的入口 -->
120   - <div v-if="menu === t.taskId" class="menu t-menu" @click.stop>
121 111 <button
122   - v-for="a in taskActions(t)"
123   - :key="a.key"
124   - :class="{ danger: a.danger }"
125   - :disabled="busy || a.disabled"
126   - :title="a.title"
127   - @click="runTaskAction(g, t, a)"
128   - >{{ a.label }}</button>
129   - </div>
130   - </li>
  112 + v-if="taskActions(t).length"
  113 + class="more t-more"
  114 + title="更多"
  115 + @click.stop="menu = menu === t.taskId ? '' : t.taskId"
  116 + >⋯</button>
  117 +
  118 + <!-- 每条 task 的操作菜单。做不成的（重跑）置灰并说明，不给能点却必然 4xx 的入口 -->
  119 + <div v-if="menu === t.taskId" class="menu t-menu" @click.stop>
  120 + <button
  121 + v-for="a in taskActions(t)"
  122 + :key="a.key"
  123 + :class="{ danger: a.danger }"
  124 + :disabled="busy || a.disabled"
  125 + :title="a.title"
  126 + @click="runTaskAction(g, t, a)"
  127 + >{{ a.label }}</button>
  128 + </div>
  129 + </li>
  130 +
  131 + <!-- 43 号文档：itemized 任务按验收条目物化出的子任务，只读展示——没有独立的 run，
  132 + 不接操作菜单/选中态，状态由 coder-validator 逐条上报（tasks.status 那套枚举）。
  133 + 子任务不会再递归拆一层（createTask 校验过），所以这里只用一层 <ul>，不需要
  134 + FileNode.vue 那种自递归组件。 -->
  135 + <ul v-if="childrenOf(g.tasks, t.taskId).length" class="subtasks">
  136 + <li v-for="st in childrenOf(g.tasks, t.taskId)" :key="st.taskId" class="subtask">
  137 + <span class="dot sm" :class="{ pulse: taskStyle(st.status).pulse }" :style="dotStyle(taskStyle(st.status))" />
  138 + <span class="st-title">{{ st.title || st.taskId }}</span>
  139 + <span class="st-status" :style="{ color: taskStyle(st.status).color }">{{ taskStyle(st.status).label }}</span>
  140 + </li>
  141 + </ul>
  142 + </template>
131 143 </ul>
132 144  
133 145 <p v-if="g.status !== 'planning' && !(g.tasks || []).length" class="tip small">这个目标下还没有任务。</p>
... ... @@ -173,6 +185,14 @@ let clock = null;
173 185 onMounted(() => { clock = setInterval(() => { now.value = Date.now(); }, 30000); });
174 186 onBeforeUnmount(() => clearInterval(clock));
175 187  
  188 +/** 43 号文档：g.tasks 是摊平的（父任务 + 子任务同一个数组），这里按 parentTaskId 分两层 */
  189 +function topLevel(tasks) {
  190 + return (tasks || []).filter((t) => !t.parentTaskId);
  191 +}
  192 +function childrenOf(tasks, parentTaskId) {
  193 + return (tasks || []).filter((t) => t.parentTaskId === parentTaskId);
  194 +}
  195 +
176 196 function toggle(goalId) {
177 197 const next = new Set(collapsed.value);
178 198 if (next.has(goalId)) next.delete(goalId); else next.add(goalId);
... ... @@ -378,6 +398,12 @@ function onDispatched(d) {
378 398 .dot.pulse { animation: pulse 1.6s ease-in-out infinite; }
379 399 @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: .35; } }
380 400  
  401 +.subtasks { list-style: none; margin: 0 0 2px; padding: 0 0 0 27px; }
  402 +.subtask { display: flex; align-items: center; gap: 5px; padding: 2px 6px; font-size: 11px; }
  403 +.subtask .dot.sm { margin-top: 0; width: 6px; height: 6px; }
  404 +.st-title { min-width: 0; flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: #555; }
  405 +.st-status { font-size: 10px; font-weight: 600; white-space: nowrap; }
  406 +
381 407 .t-body { min-width: 0; flex: 1; }
382 408 .t-title {
383 409 font-size: 12px; line-height: 1.4; color: #1a1a1a;
... ...
web/src/components/task-board/TaskTable.vue
  View file @e9a2141
... ... @@ -50,6 +50,9 @@
50 50 <span v-if="queueBadge(t)" class="qb" :title="queueBadge(t).title">{{ queueBadge(t).text }}</span>
51 51 </td>
52 52 <td class="c-desc">
  53 + <!-- 43 号文档：子任务是按验收条目物化出来的只读行，没有独立的 run，
  54 + 表格本身是平铺+可排序的，不适合画树——用一行小字指回父任务就够了 -->
  55 + <div v-if="t.parentTaskId" class="parent-line">↳ 子任务 · 属于「{{ parentTitle(t) }}」</div>
53 56 <div class="title">{{ t.title || '（无标题）' }}</div>
54 57 <div v-if="t.description" class="desc" :title="t.description">{{ t.description }}</div>
55 58 <div v-if="t.status === 'blocked'" class="blocked-line">{{ blockedLabel(t, siblingsOf(t)) || '挂起' }}</div>
... ... @@ -95,6 +98,12 @@ function siblingsOf(t) {
95 98 return (g && g.tasks) || [];
96 99 }
97 100  
  101 +/** 43 号文档：子任务行指回父任务标题——父任务恒在同一个 goal 下，查兄弟列表就够了 */
  102 +function parentTitle(t) {
  103 + const parent = siblingsOf(t).find((x) => x.taskId === t.parentTaskId);
  104 + return (parent && (parent.title || parent.taskId)) || t.parentTaskId;
  105 +}
  106 +
98 107 function dotStyle(s) {
99 108 return s.hollow ? { background: 'transparent', borderColor: s.color } : { background: s.color, borderColor: s.color };
100 109 }
... ... @@ -208,6 +217,7 @@ tbody td { padding: 8px 10px; border-bottom: 1px solid #f4f4f6; vertical-align:
208 217 .title { font-weight: 600; color: #1a1a1a; }
209 218 .desc { margin-top: 2px; color: #888; font-size: 11px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
210 219 .blocked-line { margin-top: 2px; color: #d33; font-size: 11px; }
  220 +.parent-line { color: #8a5cd6; font-size: 10px; margin-bottom: 2px; }
211 221 .c-goal, .c-assignee { color: #555; white-space: nowrap; }
212 222 .c-priority { white-space: nowrap; }
213 223 .c-time { white-space: nowrap; color: #666; }
... ...