refactor(task-decomposition): 46号文档 Phase 3 v2——CEO 直接派发，删掉认领机制

真实回归暴露"认领后没有触发源"的真问题，讨论后发现"认领"（pull，CAS 抢占）要解决的"多方竞争同一条任务"场景根本不存在——只有 CEO 一个人拍板要不要派、派给谁。CEO 心跳统一发现+直接派发（push）成本更低，还能顺带控制派发节奏，不需要认领。删除：claimSubtask/unclaimSubtask（work-graph-db.js）、POST /claim、 POST /unclaim（company.js）、CLAIMABLE_WORK_ROLES 白名单、 claimable/claimed 两个 status 值、claimed_at 列。改名：subtask_kind 的 'claimable_work' → 'decomposed_work' （materializeClaimableSubtasks → materializeDecomposedSubtasks）， "认领"这个词不再准确，物化出的行现在就是普通 draft task。新增： - triggerSubtaskPlanning 加递归防护（task.parent_task_id 非空直接跳过） ——设计 v2 时发现的真实漏洞：CEO 对子任务调 /enqueue 会默认 withSubtaskPlanning=true，不挡会对已经是"第几步"粒度的子任务再拆一层。 - createDecomposedWorkGraph：现造一张两节点轻量 work graph （impl=org-coder、validate=org-validator，agent_call 不是 subgraph），跳过公司完整 org graph 的 brd/prd/sdd 规划仪式——subtask-planning 已经把"怎么做"拆到这个粒度了，再走一遍纯属重复劳动。含一条没有真实验证过的假设（org-coder/org-validator 裸调用会不会读不到预期上下文），如实写在代码注释和文档里。 - enqueueTaskRun 按 subtask_kind 选图：decomposed_work 走轻量图，普通 task 行为不变（回归测试覆盖）。 - ceo/heartbeat.md、tools.md 补了巡检 decomposed_work 草稿 + 判断节奏 + 调用现成 /enqueue 的指令。测试：删除 task-pool-claim.test.js（随 v1 代码作废），新增 task-decomposition-dispatch.test.js（12 条），更新 task-decomposition-validator-gate.test.js 措辞。全量单测 1191 条， 1189 passed（唯二失败与本次改动无关），零残留 CLI 子进程。 Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01H85SS5hVC4u1PbVhjmrhH8

refactor(task-decomposition): 46号文档 Phase 3 v2——CEO 直接派发，删掉认领机制
真实回归暴露"认领后没有触发源"的真问题，讨论后发现"认领"（pull，CAS 抢占）要解决的"多方竞争同一条任务"场景根本不存在——只有 CEO 一个人拍板要不要派、派给谁。CEO 心跳统一发现+直接派发（push）成本更低，还能顺带控制派发节奏，不需要认领。删除：claimSubtask/unclaimSubtask（work-graph-db.js）、POST /claim、 POST /unclaim（company.js）、CLAIMABLE_WORK_ROLES 白名单、 claimable/claimed 两个 status 值、claimed_at 列。改名：subtask_kind 的 'claimable_work' → 'decomposed_work' （materializeClaimableSubtasks → materializeDecomposedSubtasks）， "认领"这个词不再准确，物化出的行现在就是普通 draft task。新增： - triggerSubtaskPlanning 加递归防护（task.parent_task_id 非空直接跳过） ——设计 v2 时发现的真实漏洞：CEO 对子任务调 /enqueue 会默认 withSubtaskPlanning=true，不挡会对已经是"第几步"粒度的子任务再拆一层。 - createDecomposedWorkGraph：现造一张两节点轻量 work graph （impl=org-coder、validate=org-validator，agent_call 不是 subgraph），跳过公司完整 org graph 的 brd/prd/sdd 规划仪式——subtask-planning 已经把"怎么做"拆到这个粒度了，再走一遍纯属重复劳动。含一条没有真实验证过的假设（org-coder/org-validator 裸调用会不会读不到预期上下文），如实写在代码注释和文档里。 - enqueueTaskRun 按 subtask_kind 选图：decomposed_work 走轻量图，普通 task 行为不变（回归测试覆盖）。 - ceo/heartbeat.md、tools.md 补了巡检 decomposed_work 草稿 + 判断节奏 + 调用现成 /enqueue 的指令。测试：删除 task-pool-claim.test.js（随 v1 代码作废），新增 task-decomposition-dispatch.test.js（12 条），更新 task-decomposition-validator-gate.test.js 措辞。全量单测 1191 条， 1189 passed（唯二失败与本次改动无关），零残留 CLI 子进程。 Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01H85SS5hVC4u1PbVhjmrhH8
yibo
1 parent 8651b84a
Showing 9 changed files with 420 additions and 516 deletions
server/routes/company.js
server/services/graph-engine.js
server/services/subtask-planning.js
server/services/work-graph-db.js
server/tests/unit/task-decomposition-dispatch.test.js
server/tests/unit/task-decomposition-validator-gate.test.js
server/tests/unit/task-pool-claim.test.js
system/agents/ceo/heartbeat.md
system/agents/ceo/tools.md
@@ -1026,9 +1026,8 @@ function taskView(t, progress = null, positions = null) {
     // 43 号文档：子任务树的父子指针 + 这条 task 走哪种验收模式（看板据此决定要不要画子任务）
     parentTaskId: t.parent_task_id || null,
     acceptanceMode: t.acceptance_mode || 'holistic',
-    // 46 号文档 Phase 3：两种子任务靠这个区分——'acceptance_item' | 'claimable_work' | null
+    // 46 号文档 Phase 3：两种子任务靠这个区分——'acceptance_item' | 'decomposed_work' | null
     subtaskKind: t.subtask_kind || null,
-    claimedAt: t.claimed_at || null,
     createdAt: t.created_at,
     queuedAt: t.queued_at,
     startedAt: t.started_at,
@@ -1112,9 +1111,20 @@ function isSlotRace(err) {
 function enqueueTaskRun({ companyId, taskRow, budget, withSubtaskPlanning = false }) {
   const wdb = require('../services/work-graph-db');
  
+  // 46 号文档 Phase 3（v2）：decomposed_work 子任务不走公司完整 org graph（那是给顶层 task
+  // 走 ceo→cto→org-planner→org-coder→org-validator 整套规划仪式的），现造一张最小的
+  // impl→validate work graph——`subtask-planning` 已经把"怎么做"拆到这一步的粒度了，
+  // 再走一遍 org-planner 的 brd/prd/sdd 纯属重复劳动。见 `createDecomposedWorkGraph` 的注释，
+  // 含一条没有真实验证过的假设（org-coder/org-validator 裸调用会不会读不到预期上下文）。
+  const isDecomposedSubtask = taskRow.subtask_kind === 'decomposed_work';
+  const graphKind = isDecomposedSubtask ? 'work' : 'org';
+  const graphId = isDecomposedSubtask
+    ? wdb.createDecomposedWorkGraph({ companyId, task: taskRow })
+    : companyId; // kind='org' 时 graph_id 就是 company_id
+
   const created = wdb.createRun({
-    graphKind: 'org',
-    graphId: companyId, // kind='org' 时 graph_id 就是 company_id
+    graphKind,
+    graphId,
     companyId,
     goalId: taskRow.goal_id,
     taskId: taskRow.id,
@@ -2112,7 +2122,7 @@ router.get(&#39;/:companyId/tasks&#39;, (req, res) =&gt; {
       goalId: req.query.goalId || req.query.goal_id || null,
       // 43 号文档：coder-validator 用它列出一个 itemized 任务物化出的全部子任务
       parentTaskId: req.query.parentTaskId || req.query.parent_task_id || null,
-      // 46 号文档 Phase 3：`?subtaskKind=claimable_work&status=claimable` = 当前可认领池
+      // 46 号文档 Phase 3：`?subtaskKind=decomposed_work&status=draft` = CEO 心跳巡检对象
       subtaskKind: req.query.subtaskKind || req.query.subtask_kind || null,
       includeArchived: req.query.includeArchived === '1' || req.query.includeArchived === 'true',
       limit: Number.isInteger(limit) ? limit : null,
@@ -2391,81 +2401,6 @@ router.post(&#39;/:companyId/tasks/:taskId/subtask-result&#39;, (req, res) =&gt; {
 });
  
 /**
- * 46 号文档 Phase 3：可认领子任务（`subtask_kind='claimable_work'`）先只对这个角色白名单开放。
- * 写死不做能力匹配——系统里没有任何结构化的角色能力字段（调研已确认），
- * `org-coder` 是当前唯一的通用"写代码"角色，且物化出的 steps 基本都是实现类工作。
- * 真需要扩展到多角色再加，不为假想的未来预先建模。
- */
-const CLAIMABLE_WORK_ROLES = ['org-coder'];
-
-/**
- * POST /api/company/:companyId/tasks/:taskId/claim — 46 号文档 Phase 3
- * body: { agentId }
- *
- * 认领一条可认领子任务。全仓库第一个真正的"认领（pull）"语义端点——并发保护见
- * `work-graph-db.claimSubtask`（CAS，`changes===0` 就是没抢到，返回 409 不是 500，
- * 这是预期会发生的正常竞争结果）。
- */
-router.post('/:companyId/tasks/:taskId/claim', (req, res) => {
-  try {
-    const wdb = require('../services/work-graph-db');
-    const task = requireTask(req, res);
-    if (!task) return;
-    if (task.subtask_kind !== 'claimable_work') {
-      return res.status(400).json({
-        error: `${task.id} 不是可认领子任务（subtask_kind !== 'claimable_work'）`,
-      });
-    }
-    const { agentId } = req.body || {};
-    if (!agentId) return res.status(400).json({ error: 'agentId 必填' });
-
-    const hired = listCompanyAgents(req.params.companyId)
-      .find((r) => r.system_agent_id === agentId || r.role_name === agentId);
-    if (!hired || !CLAIMABLE_WORK_ROLES.includes(hired.role_name)) {
-      return res.status(403).json({
-        error: `${agentId} 不在可认领角色白名单里（${CLAIMABLE_WORK_ROLES.join(', ')}）`,
-      });
-    }
-
-    const changed = wdb.claimSubtask(task.id, agentId);
-    if (!changed) {
-      return res.status(409).json({
-        error: `认领失败：${task.id} 已经不是可认领状态（被别人抢先认领，或状态已变化）`,
-      });
-    }
-    res.json({ ok: true, task: taskView(wdb.getTask(task.id)) });
-  } catch (err) {
-    console.error('[TaskEntry] Error:', err.message);
-    res.status(500).json({ error: err.message });
-  }
-});
-
-/**
- * POST /api/company/:companyId/tasks/:taskId/unclaim — 46 号文档 Phase 3
- * body: { agentId }：只有认领者本人能放弃（`work-graph-db.unclaimSubtask` 的 WHERE 挡着）。
- */
-router.post('/:companyId/tasks/:taskId/unclaim', (req, res) => {
-  try {
-    const wdb = require('../services/work-graph-db');
-    const task = requireTask(req, res);
-    if (!task) return;
-    const { agentId } = req.body || {};
-    if (!agentId) return res.status(400).json({ error: 'agentId 必填' });
-
-    const changed = wdb.unclaimSubtask(task.id, agentId);
-    if (!changed) {
-      return res.status(409).json({
-        error: `放弃失败：${task.id} 不是被 ${agentId} 认领的可认领子任务`,
-      });
-    }
-    res.json({ ok: true, task: taskView(wdb.getTask(task.id)) });
-  } catch (err) {
-    console.error('[TaskEntry] Error:', err.message);
-    res.status(500).json({ error: err.message });
-  }
-});
-
-/**
  * POST /api/company/:companyId/tasks/:taskId/enqueue — 单条入队（27-P3C §六.3）
  *
  * 与 `goals/:goalId/dispatch` 的差别只是粒度：那条把 goal 下所有 draft 一起推进队列，
@@ -1880,9 +1880,10 @@ function settleNode(runId, nodeRunId, outcome = {}) {
           if (dRole && dRole.systemAgentId === 'coder-validator' && run0.task_id) {
             // 46 号文档 Phase 3：这条闸门只该看 43 号文档的验收条目子任务——`AND subtask_kind =
             // 'acceptance_item'` 是必须的收窄，不是可选项。Phase 3 会往同一个 parent_task_id
-            // 底下物化第二种子任务（claimable_work，等着被认领执行，完成生命周期完全独立、
-            // 跟 coder-validator 的验收判定无关），不收窄这条查询会把它们也扫进来，天然不会
-            // 是 completed，直接把所有开了 subtask-planning 的 task 验收判定拖垮。
+            // 底下物化第二种子任务（decomposed_work，subtask-planning 拆出来等 CEO 派发执行的，
+            // 完成生命周期完全独立、跟 coder-validator 的验收判定无关），不收窄这条查询会把
+            // 它们也扫进来，天然不会是 completed，直接把所有开了 subtask-planning 的 task
+            // 验收判定拖垮。
             const subtasks = getDb()
               .prepare(`SELECT id, status FROM tasks WHERE parent_task_id = ? AND subtask_kind = 'acceptance_item'`)
               .all(run0.task_id);
@@ -2434,7 +2435,7 @@ function maybeMaterializeItemizedSubtasks({ runId, nodeRunId, run, nodeRun, def,
     if (!task || task.acceptance_mode !== 'itemized') return;
  
     // 46 号文档 Phase 3：只数 acceptance_item——同一个 task 现在可能同时挂着 subtask-planning
-    // 物化的 claimable_work 行，那批不该让这条幂等判据误判"已经物化过验收条目"而提前退出。
+    // 物化的 decomposed_work 行，那批不该让这条幂等判据误判"已经物化过验收条目"而提前退出。
     const already = getDb()
       .prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ? AND subtask_kind = 'acceptance_item'`)
       .get(task.id).n;
@@ -349,6 +349,14 @@ function normalizeSteps(raw) {
 async function triggerSubtaskPlanning({ run, task }) {
   try {
     if (!run || !task) return;
+    // 46 号文档 Phase 3：子任务不该被再拆一层——`materializeDecomposedSubtasks` 物化出的行
+    // 也会经过 enqueueTaskRun（CEO 派发时），如果不挡住，会对一条已经是"第几步怎么做"粒度的
+    // 子任务再跑一次 subtask-planning，浪费一次 LLM 调用还可能无限递归拆下去。
+    // 43 号文档的验收条目子任务同理（createTask 本身已经不许它们再声明 itemized）。
+    if (task.parent_task_id) {
+      console.log(`[SubtaskPlanning] task ${task.id} 本身就是子任务（parent_task_id=${task.parent_task_id}），跳过`);
+      return;
+    }
     const {
       steps, tokens, reasoningSource, experienceRefs, researchUsed,
     } = await planSubtasks({ companyId: run.company_id, task });
@@ -388,12 +396,12 @@ async function triggerSubtaskPlanning({ run, task }) {
       nodeRunId: null,
     });
  
-    // 46 号文档 Phase 3：把这批 steps 物化成可认领子任务。跟上面写 artifact/登记索引一样，
-    // 走同一个 try/catch——物化失败不该让 subtask-plan.json 已经写好的部分失效。
-    const materializedIds = wdb.materializeClaimableSubtasks({ task, steps });
+    // 46 号文档 Phase 3：把这批 steps 物化成 decomposed_work 子任务。跟上面写 artifact/登记
+    // 索引一样，走同一个 try/catch——物化失败不该让 subtask-plan.json 已经写好的部分失效。
+    const materializedIds = wdb.materializeDecomposedSubtasks({ task, steps });
  
     console.log(`[SubtaskPlanning] task ${task.id} 写入 ${steps.length} 条步骤分解（${tokens || 0} tokens），`
-      + `物化 ${materializedIds.length} 条可认领子任务`);
+      + `物化 ${materializedIds.length} 条待 CEO 派发的子任务`);
   } catch (err) {
     console.warn(`[SubtaskPlanning] task ${task && task.id} 触发失败（不影响入队）：${err.message}`);
   }
@@ -528,7 +528,6 @@ function getDb() {
       description    TEXT NOT NULL,             -- 落进 task-goal.json 的那句；下达后不可改
       status         TEXT NOT NULL DEFAULT 'draft',
                      -- draft | queued | running | completed | failed | blocked | cancelled
-                     --   | claimable | claimed（46 号文档 Phase 3，只对 subtask_kind='claimable_work' 有意义）
                      -- queued 现在就在取值域里，但排队逻辑（调度器 / run_status='queued'）另批实现：
                      -- 取值域是数据形状的一部分，先钉死它，免得批 3 再来改一次列注释
       execution_mode TEXT NOT NULL DEFAULT 'manual' CHECK (execution_mode IN ('manual','auto')),
@@ -562,13 +561,14 @@ function getDb() {
       parent_task_id TEXT REFERENCES tasks(id),
       -- 46 号文档 Phase 3：parent_task_id 非空的子任务分两种，靠这一列区分——
       --   'acceptance_item'  43 号文档：验收条目物化（coder-validator 逐条上报，见 settleSubtaskResult）
-      --   'claimable_work'   Phase 3：subtask-planning 步骤分解物化，等着被认领（见 claimSubtask）
+      --   'decomposed_work'  Phase 3：subtask-planning 步骤分解物化，等 CEO 心跳判断节奏后 enqueue
+      --                      （v1 设计过"认领"pull 语义，真实回归后改成 CEO 直接派发的 push 语义——
+      --                      认领需要的并发抢占场景不存在，CEO 一人拍板成本更低，历史决策见 46 号文档）
       -- NULL = 普通 task（不是子任务，或 parent_task_id 也是 NULL）。两套子任务共用同一张表
       -- （而不是各开一张），因为 tasks 表本来就是通用工作项容器，这一列只是给已经混杂的
       -- 两种东西正名；settleNode 的 SUBTASKS_INCOMPLETE 闸门靠它把两套完成判定分开
       -- （graph-engine.js，只认 'acceptance_item'，见该处注释；本段刻意不用反引号，见上）。
-      subtask_kind   TEXT CHECK (subtask_kind IN ('acceptance_item','claimable_work') OR subtask_kind IS NULL),
-      claimed_at     TEXT,                       -- 认领发生的时间；只对 claimable_work 有意义
+      subtask_kind   TEXT CHECK (subtask_kind IN ('acceptance_item','decomposed_work') OR subtask_kind IS NULL),
       created_at     TEXT NOT NULL,
       updated_at     TEXT NOT NULL,
       queued_at      TEXT,                       -- 入队时间；非空 = 描述已冻结（§四.4）
@@ -657,15 +657,12 @@ function getDb() {
   // 「no such column」，`getDb()` 起不来 = **所有存量库一启动就炸**。实测踩过。
   db.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(company_id, assignee_agent_id, created_at)`);
  
-  // ── 批 6：46 号文档 Phase 3，tasks 追加 subtask_kind / claimed_at ────────────
+  // ── 批 6：46 号文档 Phase 3，tasks 追加 subtask_kind ─────────────────────
   // 同批 5 的限制：ALTER TABLE ADD COLUMN 加不了 CHECK，存量库上 subtask_kind 的取值域
   // 只由 createTask 的应用层校验守，与新建库的 CHECK 不同源。
   if (!hasColumn(db, 'tasks', 'subtask_kind')) {
     db.exec(`ALTER TABLE tasks ADD COLUMN subtask_kind TEXT`);
   }
-  if (!hasColumn(db, 'tasks', 'claimed_at')) {
-    db.exec(`ALTER TABLE tasks ADD COLUMN claimed_at TEXT`);
-  }
  
   // R4-F1：graph_run_nodes 追加 remediation_note，可空，旧行 NULL = 「没有留给下一轮的话」。
   if (!hasColumn(db, 'graph_run_nodes', 'remediation_note')) {
@@ -1906,7 +1903,6 @@ function createTask({
   parentTaskId = null,
   acceptanceMode = 'holistic',
   subtaskKind = null,
-  status = 'draft',
 } = {}) {
   if (!goalId) throw new Error('createTask: goalId 必填');
   if (!title) throw new Error('createTask: title 必填');
@@ -1917,21 +1913,15 @@ function createTask({
   if (parentTaskId && acceptanceMode === 'itemized') {
     throw new Error('createTask: 子任务（有 parentTaskId）不允许再声明 itemized，不支持递归拆分');
   }
-  // 46 号文档 Phase 3：subtask_kind 只对子任务有意义，取值域应用层守（同上 acceptanceMode 那条注释）
-  if (subtaskKind !== null && !['acceptance_item', 'claimable_work'].includes(subtaskKind)) {
+  // 46 号文档 Phase 3：subtask_kind 只对子任务有意义，取值域应用层守（同上 acceptanceMode 那条注释）。
+  // 没有专属初始 status——decomposed_work 子任务就是普通 draft task，物化即走
+  // draft→（CEO 判断节奏后）enqueue 这条现成的路，不需要额外的状态。
+  if (subtaskKind !== null && !['acceptance_item', 'decomposed_work'].includes(subtaskKind)) {
     throw new Error(`createTask: subtaskKind 非法: ${subtaskKind}`);
   }
   if (subtaskKind && !parentTaskId) {
     throw new Error('createTask: subtaskKind 只对子任务（有 parentTaskId）有意义');
   }
-  // 初始状态只放开 'draft'（现状）和 'claimable'（Phase 3：claimable_work 物化即开放认领，
-  // 不需要走「先 draft 再手动下达」那一套——这批子任务从来就不打算过 task-scheduler）。
-  if (!['draft', 'claimable'].includes(status)) {
-    throw new Error(`createTask: status 只能是 'draft' 或 'claimable'（初始状态），收到: ${status}`);
-  }
-  if (status === 'claimable' && subtaskKind !== 'claimable_work') {
-    throw new Error(`createTask: status='claimable' 只对 subtaskKind='claimable_work' 有意义`);
-  }
  
   const db = getDb();
   const goal = getGoal(goalId);
@@ -1964,10 +1954,10 @@ function createTask({
     INSERT INTO tasks (id, goal_id, company_id, seq, title, description, status,
                        execution_mode, depends_on, priority, budget_json, report_to, created_by,
                        parent_task_id, acceptance_mode, subtask_kind, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, 'draft', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   const id = insertWithFreshId('tasks', genTaskId, (tid) => ins.run(
-    tid, goalId, String(cid), nextSeq, String(title), String(description), status,
+    tid, goalId, String(cid), nextSeq, String(title), String(description),
     executionMode, JSON.stringify(deps), priority, budget,
     // report_to 不落库就等于没有：请求作用域的闭包活不过一次排队（§四.7 禁令二）。
     // goal 上有就继承下来，别让每个调用方各记一遍。
@@ -2018,8 +2008,8 @@ function listCompanyTasks(companyId, {
     where.push('parent_task_id = @parentTaskId');
     params.parentTaskId = parentTaskId;
   }
-  // 46 号文档 Phase 3：`?subtaskKind=claimable_work&status=claimable` 就是"这家公司当前
-  // 可认领池"的查询——不需要专门的池子端点，复用这条通用列表接口加一个过滤参数。
+  // 46 号文档 Phase 3：`?subtaskKind=decomposed_work&status=draft` 就是 CEO 心跳巡检
+  // "有哪些子任务等我判断节奏"的查询——不需要专门的端点，复用这条通用列表接口加一个过滤参数。
   if (subtaskKind) {
     where.push('subtask_kind = @subtaskKind');
     params.subtaskKind = subtaskKind;
@@ -2058,10 +2048,7 @@ const TASK_PATCH_COLUMNS = {
  * `blocked` 在里面是「强制放行」那条自救路径的**全部依赖**：改完依赖 route 会立刻 tick 一次，
  * `requeueDerivedBlockedTask` 把它连同 blocked_reason 一起推回 queued。
  */
-// 'claimable' 是 46 号文档 Phase 3 加的：claimable_work 子任务物化后要能回填 depends_on
-// （steps[].depends_on_hint 转真实 task id，见 materializeClaimableSubtasks），这批子任务
-// 从来不过 task-scheduler，不存在"已经排队、依赖被别处消费过"的顾虑，放开无副作用。
-const DEPENDS_ON_EDITABLE_STATUS = ['draft', 'queued', 'blocked', 'claimable'];
+const DEPENDS_ON_EDITABLE_STATUS = ['draft', 'queued', 'blocked'];
  
 /** queued_at 非空后就不许再改的字段（§四.4）：它们都已经被 task-goal.json 或预算池消费过 */
 const TASK_FROZEN_FIELDS = ['description', 'executionMode', 'budgetJson'];
@@ -2188,54 +2175,12 @@ function settleSubtaskResult(taskId, status, summary = null) {
 }
  
 /**
- * 46 号文档 Phase 3：认领一条可认领子任务，claimable → claimed。
- *
- * 全仓库第一个真正的"认领（pull）"语义写入——`assignee_agent_id` 此前所有写入点
- * （`enqueueTaskRun`/`settleTaskFromRun` 的哨兵值兜底、`agent-chat.saveTaskMeta` 的
- * 派发）都是"派发（push）"：发起方单方面指定 `to`，从没有过"多方竞争同一条任务，
- * 谁先抢到算谁的"这种场景，所以也没有先例可抄，CAS 写法照抄 `claimQueuedTask`（同一份
- * "changes 数决定谁赢"判据）。
- *
- * 认领成功的同时把 `executor` 改成 `'agent'`——claimable_work 子任务生来就是要被某个
- * agent 自主完成的，只是物化时还没有认领对象；一旦认领，它就是一条普通的
- * `executor='agent'` 派单任务，后续走 `META_TO_TASK_STATUS` 那套既有生命周期
- * （`agent-chat.js` 的 `/task/report`），不需要 Phase 3 再发明一套执行触发逻辑。
- *
- * @returns {number} 1 = 认领成功；0 = 没抢到（已被认领 / 状态不对 / 不是可认领子任务）
- */
-function claimSubtask(taskId, agentId) {
-  if (!agentId) throw new Error('claimSubtask: agentId 必填');
-  const now = new Date().toISOString();
-  return getDb()
-    .prepare(`
-      UPDATE tasks
-         SET status = 'claimed', executor = 'agent', assignee_agent_id = @agentId,
-             claimed_at = @now, updated_at = @now
-       WHERE id = @id AND subtask_kind = 'claimable_work' AND status = 'claimable' AND archived_at IS NULL
-    `)
-    .run({ id: taskId, agentId, now }).changes;
-}
-
-/**
- * 放弃认领：claimed → claimable，对称的 CAS。**只有认领者本人能放弃**——
- * `assignee_agent_id = @agentId` 这道 WHERE 挡住"别人代为放弃"，避免抢别人手上的活。
- * @returns {number} 1 = 放弃成功；0 = 不是这个 agent 认领的 / 状态不对
- */
-function unclaimSubtask(taskId, agentId) {
-  if (!agentId) throw new Error('unclaimSubtask: agentId 必填');
-  const now = new Date().toISOString();
-  return getDb()
-    .prepare(`
-      UPDATE tasks
-         SET status = 'claimable', executor = 'graph', assignee_agent_id = NULL,
-             claimed_at = NULL, updated_at = @now
-       WHERE id = @id AND subtask_kind = 'claimable_work' AND status = 'claimed' AND assignee_agent_id = @agentId
-    `)
-    .run({ id: taskId, agentId, now }).changes;
-}
-
-/**
- * 46 号文档 Phase 3：把 `subtask-planning` 产出的 `steps[]` 物化成可认领子任务。
+ * 46 号文档 Phase 3（v2，2026-09-02 改版）：把 `subtask-planning` 产出的 `steps[]` 物化成
+ * decomposed_work 子任务。**v1 曾经设计成"认领"（pull，`claimable`/`claimed` 两个专属状态 +
+ * `claimSubtask`/`unclaimSubtask` 两个 CAS 函数），真实回归后拍板改掉**：认领要解决的是
+ * "多方竞争同一条任务"，但实际执行者只有 CEO 一个人拍板要不要派、派给谁，压根不存在竞争，
+ * CAS 是给不存在的问题找的解——现在直接砍掉，物化出的子任务就是普通 `draft` task，
+ * CEO 心跳判断节奏后调现成的 `/tasks/:taskId/enqueue`（旧 API，不用再发明新端点）。
  *
  * 两阶段建法：先把全部行建好拿到真实 task id，再回填 `depends_on`——`steps[].depends_on_hint`
  * 是这批 steps 内部的 1-based `seq` 引用，`subtask-planning.js` 的 `normalizeSteps` 只保证
@@ -2243,7 +2188,10 @@ function unclaimSubtask(taskId, agentId) {
  * 边建边填会在"前一步依赖后一步"这种前向引用上直接炸（`validateDependsOn` 要求依赖必须已存在）。
  * 先建后填就不用管顺序。
  *
- * 幂等：已经物化过 `claimable_work` 子任务的 task 直接跳过，不重复物化（同款判据见
+ * `executionMode: 'auto'`——CEO 一旦决定 enqueue 就该一路跑完，不需要停在入口等人工 `/next`
+ * （那是 `manual` 模式的语义，给"人下达"这个场景设计的，不适合"CEO 已经拍过板"这条路）。
+ *
+ * 幂等：已经物化过 `decomposed_work` 子任务的 task 直接跳过，不重复物化（同款判据见
  * `graph-engine.maybeMaterializeItemizedSubtasks` 的 `already` 检查——两处独立各写一份，
  * 因为分属两个模块，不值得为一次判空抽个共享工具函数）。
  *
@@ -2253,11 +2201,11 @@ function unclaimSubtask(taskId, agentId) {
  * @param {{task: object, steps: Array<{seq:number,title:string,why?:string,depends_on_hint?:number[]}>}} ctx
  * @returns {string[]} 物化出的 task id，按 steps 顺序；已物化过 / 无 steps 时返回 []
  */
-function materializeClaimableSubtasks({ task, steps }) {
+function materializeDecomposedSubtasks({ task, steps }) {
   if (!task || !Array.isArray(steps) || !steps.length) return [];
  
   const already = getDb()
-    .prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ? AND subtask_kind = 'claimable_work'`)
+    .prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ? AND subtask_kind = 'decomposed_work'`)
     .get(task.id).n;
   if (already > 0) return [];
  
@@ -2268,10 +2216,10 @@ function materializeClaimableSubtasks({ task, steps }) {
       companyId: task.company_id,
       title: String(step.title || '').slice(0, 200),
       description: step.why ? `${step.title}\n\n${step.why}` : String(step.title || ''),
+      executionMode: 'auto',
       createdBy: 'subtask-planning',
       parentTaskId: task.id,
-      subtaskKind: 'claimable_work',
-      status: 'claimable',
+      subtaskKind: 'decomposed_work',
     });
     seqToId.set(step.seq, row.id);
   }
@@ -2286,6 +2234,47 @@ function materializeClaimableSubtasks({ task, steps }) {
 }
  
 /**
+ * 46 号文档 Phase 3（v2）：给一条 `decomposed_work` 子任务现造一张最小的 work graph——
+ * `实现（org-coder）→ 验证（org-validator）`两个节点，`agent_call`（不是 `subgraph`），
+ * 跳过公司完整 org graph 那套 ceo→cto→org-planner→org-coder→org-validator 的规划仪式。
+ *
+ * 为什么跳得掉：`subtask-planning` 已经把"怎么做"拆到了这一步的粒度，`org-planner` 平时干的
+ * brd/prd/sdd 那一套是在回答"这件事怎么做"——对一条已经具体到"实现 add 子命令"的子任务，
+ * 再走一遍纯属重复劳动，Phase 0 真实测过一条完整 task 走完整 org graph 近 19 分钟，
+ * 子任务量级不该背这个成本。
+ *
+ * 没有声明任何 `needs`/`produces` 边契约（`declareEdgeContract` 一次都没调）——`agent_call`
+ * 节点没有声明 needs 就不会触发 `requiredInputsMissing`，没有声明 produces 就不会触发
+ * `unsatisfiedRequiredProduces`，这两道闸门天然对这张图是空的，不用额外放行。
+ *
+ * ⚠️ **这是一次没有真实验证过的假设，写在这里免得下一个人以为它是钉死的设计**：
+ * `org-coder`/`org-validator` 平时只在"公司完整 org graph 的 subgraph 节点"这个上下文里
+ * 被调用过，它们的 `agent.md`/`tools.md` 有没有隐含"前面一定有 brd/prd/sdd 产物"这种假设，
+ * 直接当 `agent_call` 裸调用会不会读不到预期上下文——没有实测过，需要真实回归验证。
+ * 用户的决定是"先跑轻量版看效果，不行再上完整 org graph"（46 号文档），这就是那次实验。
+ *
+ * @param {{companyId: string, task: object}} ctx task 是那条 decomposed_work 子任务本身
+ * @returns {string} 新建的 work graph id
+ */
+function createDecomposedWorkGraph({ companyId, task }) {
+  const g = createWorkGraph({
+    companyId,
+    plannedBy: 'subtask-dispatch',
+    goalId: task.goal_id,
+    taskId: task.id,
+    nodes: [
+      { nodeName: 'impl', systemAgentId: 'org-coder', nodeKind: 'agent_call' },
+      { nodeName: 'validate', systemAgentId: 'org-validator', nodeKind: 'agent_call' },
+    ],
+    edges: [{ from: 'impl', to: 'validate', condition: 'success' }],
+  });
+  if (!g.ok) {
+    throw new Error(`createDecomposedWorkGraph: 建图失败: ${JSON.stringify(g.errors)}`);
+  }
+  return g.id;
+}
+
+/**
  * 「上游已经不可能满足了」这个 blocked 的原因前缀（27-P3C §五.1.2）。
  *
  * 它同时是**判据**：只有 `blocked_reason` 以它开头的 blocked task 才是调度器**推导**出来的，
@@ -2919,10 +2908,9 @@ module.exports = {
   settleTaskFromRun,
   settleSubtaskResult,
   GRAPH_TAKEOVER_ASSIGNEE,
-  // 46 号文档 Phase 3：任务池认领
-  claimSubtask,
-  unclaimSubtask,
-  materializeClaimableSubtasks,
+  // 46 号文档 Phase 3（v2）：CEO 派发 decomposed_work 子任务
+  materializeDecomposedSubtasks,
+  createDecomposedWorkGraph,
   // 批 3 排队：三条都是条件更新，调用方靠 changes 判「是不是我做的」
   claimQueuedTask,
   blockQueuedTask,
+/**
+ * 46 号文档 Phase 3（v2，2026-09-02 改版）：CEO 派发 decomposed_work 子任务。
+ *
+ * v1 做的是"认领"（pull，CAS 抢占），真实回归后拍板改成"CEO 直接派发"（push，不存在
+ * 多方竞争，CAS 是在给不存在的问题找解）。这个文件替掉已删除的 task-pool-claim.test.js，
+ * 覆盖新设计的三层：
+ *   1. `materializeDecomposedSubtasks`（物化，depends_on 回填，幂等）
+ *   2. `createDecomposedWorkGraph`（现造的轻量 impl→validate 图，形状对不对）
+ *   3. 路由层 `enqueueTaskRun`——decomposed_work 走轻量 work graph，普通 task 走公司 org
+ *      graph 不受影响（回归），以及 `triggerSubtaskPlanning` 的递归防护（子任务不会被再拆一层）
+ */
+import {
+  describe, it, expect, beforeAll, afterAll,
+} from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const TEST_DB_PATH = '/tmp/test-task-decomp-dispatch.sqlite';
+const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
+const MODULES = ['../../services/graph-db', '../../services/work-graph-db'];
+
+function ensureAgent(wdb, id) {
+  const db = wdb.getDb();
+  const now = new Date().toISOString();
+  db.prepare(`INSERT OR IGNORE INTO system_agents
+      (id, name, scope, owner_company_id, legacy_path, status, created_at, updated_at)
+      VALUES (?, ?, 'public', NULL, ?, 'active', ?, ?)`)
+    .run(id, id, `system/agents/${id}`, now, now);
+}
+
+describe('46 号文档 Phase 3（v2）：DB 层', () => {
+  let wdb;
+
+  beforeAll(() => {
+    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
+    process.env.GRAPH_DB_PATH = TEST_DB_PATH;
+    for (const m of MODULES) delete require.cache[require.resolve(m)];
+    wdb = require('../../services/work-graph-db');
+    ensureAgent(wdb, 'org-coder');
+    ensureAgent(wdb, 'org-validator');
+  });
+
+  afterAll(() => {
+    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
+    delete process.env.GRAPH_DB_PATH;
+    for (const m of MODULES) delete require.cache[require.resolve(m)];
+  });
+
+  // ── createTask 校验（简化后：没有专属初始 status 了）─────────────────
+
+  it('subtaskKind 非法值直接拒', () => {
+    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
+    expect(() => wdb.createTask({
+      goalId: goal.id, title: 't', description: 'd', subtaskKind: 'not-a-real-kind',
+    })).toThrow(/subtaskKind 非法/);
+  });
+
+  it('subtaskKind 没有 parentTaskId 时直接拒', () => {
+    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
+    expect(() => wdb.createTask({
+      goalId: goal.id, title: 't', description: 'd', subtaskKind: 'decomposed_work',
+    })).toThrow(/只对子任务.*有意义/);
+  });
+
+  it('正常创建 decomposed_work 子任务：就是一条普通 draft task，只多了 subtask_kind 标签', () => {
+    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
+    const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
+    const child = wdb.createTask({
+      goalId: goal.id, title: 'c', description: 'd', parentTaskId: parent.id, subtaskKind: 'decomposed_work',
+    });
+    expect(child.subtask_kind).toBe('decomposed_work');
+    expect(child.status).toBe('draft'); // 没有专属状态了
+    expect(child.executor).toBe('graph'); // 默认值不变，走 enqueueTaskRun 一样能跑
+  });
+
+  // ── materializeDecomposedSubtasks ─────────────────────────────────
+
+  describe('materializeDecomposedSubtasks', () => {
+    function setupTask(companyId) {
+      const goal = wdb.createGoal({ companyId, title: 'g', description: 'd' });
+      return wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
+    }
+
+    it('按 steps 顺序物化，status=draft、executionMode=auto，depends_on 正确回填（含前向引用）', () => {
+      const task = setupTask('co-p3-2');
+      const steps = [
+        { seq: 1, title: '第一步', depends_on_hint: [3] }, // 前向引用：依赖还没建出来的第三步
+        { seq: 2, title: '第二步', depends_on_hint: [1] },
+        { seq: 3, title: '第三步', depends_on_hint: [] },
+      ];
+      const ids = wdb.materializeDecomposedSubtasks({ task, steps });
+      expect(ids).toHaveLength(3);
+
+      const rows = ids.map((id) => wdb.getTask(id));
+      expect(rows.every((r) => r.subtask_kind === 'decomposed_work')).toBe(true);
+      expect(rows.every((r) => r.status === 'draft')).toBe(true);
+      expect(rows.every((r) => r.execution_mode === 'auto')).toBe(true);
+      expect(rows[0].title).toBe('第一步');
+      expect(JSON.parse(rows[0].depends_on)).toEqual([ids[2]]); // 前向引用正确解析成第三步的真实 id
+      expect(JSON.parse(rows[1].depends_on)).toEqual([ids[0]]);
+      expect(JSON.parse(rows[2].depends_on)).toEqual([]);
+    });
+
+    it('depends_on_hint 指向不存在的 seq：丢那一条引用，不作废整批（宽松解析）', () => {
+      const task = setupTask('co-p3-3');
+      const steps = [{ seq: 1, title: '唯一一步', depends_on_hint: [99] }];
+      const ids = wdb.materializeDecomposedSubtasks({ task, steps });
+      expect(ids).toHaveLength(1);
+      expect(JSON.parse(wdb.getTask(ids[0]).depends_on)).toEqual([]);
+    });
+
+    it('幂等：同一个 task 物化第二次直接跳过，不重复建行', () => {
+      const task = setupTask('co-p3-4');
+      const steps = [{ seq: 1, title: '一步', depends_on_hint: [] }];
+      const first = wdb.materializeDecomposedSubtasks({ task, steps });
+      expect(first).toHaveLength(1);
+      const second = wdb.materializeDecomposedSubtasks({ task, steps });
+      expect(second).toEqual([]);
+
+      const rows = wdb.getDb()
+        .prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ? AND subtask_kind = 'decomposed_work'`)
+        .get(task.id);
+      expect(rows.n).toBe(1);
+    });
+
+    it('空 steps / 无 task 时返回 []，不报错', () => {
+      const task = setupTask('co-p3-5');
+      expect(wdb.materializeDecomposedSubtasks({ task, steps: [] })).toEqual([]);
+      expect(wdb.materializeDecomposedSubtasks({ task: null, steps: [{ seq: 1, title: 'x' }] })).toEqual([]);
+    });
+
+    it('与 43 号文档的 acceptance_item 共存互不干扰：各自幂等判据只看自己的 subtask_kind', () => {
+      const task = setupTask('co-p3-6');
+      wdb.createTask({
+        goalId: task.goal_id, title: 'a1', description: 'd', parentTaskId: task.id,
+        subtaskKind: 'acceptance_item',
+      });
+      const ids = wdb.materializeDecomposedSubtasks({
+        task, steps: [{ seq: 1, title: 'c1', depends_on_hint: [] }],
+      });
+      expect(ids).toHaveLength(1); // 没有被 acceptance_item 那条已存在的行挡住
+    });
+  });
+
+  // ── createDecomposedWorkGraph ──────────────────────────────────────
+
+  describe('createDecomposedWorkGraph', () => {
+    it('建出一张两节点的轻量图：impl(org-coder) → validate(org-validator)，都是 agent_call', () => {
+      const goal = wdb.createGoal({ companyId: 'co-p3-7', title: 'g', description: 'd' });
+      const task = wdb.createTask({ goalId: goal.id, title: 't', description: 'd' });
+      const graphId = wdb.createDecomposedWorkGraph({ companyId: 'co-p3-7', task });
+      expect(graphId).toBeTruthy();
+
+      const nodes = wdb.getDb()
+        .prepare(`SELECT node_name, system_agent_id, node_kind FROM work_graph_nodes WHERE work_graph_id = ? ORDER BY node_name`)
+        .all(graphId);
+      expect(nodes).toEqual([
+        { node_name: 'impl', system_agent_id: 'org-coder', node_kind: 'agent_call' },
+        { node_name: 'validate', system_agent_id: 'org-validator', node_kind: 'agent_call' },
+      ]);
+
+      const wg = wdb.getDb().prepare(`SELECT task_id, goal_id FROM work_graphs WHERE id = ?`).get(graphId);
+      expect(wg.task_id).toBe(task.id);
+      expect(wg.goal_id).toBe(goal.id);
+    });
+
+    it('这张图能被 createRun 直接拿去起一条 work run（机制打通，不真的执行）', () => {
+      const goal = wdb.createGoal({ companyId: 'co-p3-8', title: 'g', description: 'd' });
+      const task = wdb.createTask({ goalId: goal.id, title: 't', description: 'd' });
+      const graphId = wdb.createDecomposedWorkGraph({ companyId: 'co-p3-8', task });
+      const run = wdb.createRun({
+        graphKind: 'work', graphId, companyId: 'co-p3-8', goalId: goal.id, taskId: task.id,
+      });
+      expect(run.ok).not.toBe(false);
+      expect(wdb.getRun(run.id).graph_kind).toBe('work');
+      expect(wdb.getRun(run.id).graph_id).toBe(graphId);
+    });
+  });
+});
+
+describe('46 号文档 Phase 3（v2）：路由层 enqueueTaskRun 的图选择', () => {
+  const CID = 'route-p3v2-co';
+  let wdb;
+  let org;
+  let server;
+  let base;
+  let origCompanyGet;
+
+  async function call(method, url, body) {
+    const r = await fetch(base + url, {
+      method,
+      headers: { 'Content-Type': 'application/json' },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    return [r.status, await r.json()];
+  }
+
+  beforeAll(async () => {
+    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
+    process.env.GRAPH_DB_PATH = TEST_DB_PATH;
+    process.env.GRAPH_RUNS_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'p3v2-dispatch-routes-'));
+    const allModules = [
+      ...MODULES, '../../services/graph-service', '../../services/org-graph-service',
+      '../../services/subtask-planning', '../../routes/company',
+    ];
+    for (const m of allModules) {
+      try { delete require.cache[require.resolve(m)]; } catch {}
+    }
+    wdb = require('../../services/work-graph-db');
+    org = require('../../services/org-graph-service');
+    ensureAgent(wdb, 'org-planner');
+    ensureAgent(wdb, 'org-coder');
+    ensureAgent(wdb, 'org-validator');
+
+    const companyService = require('../../services/company-service');
+    origCompanyGet = companyService.CompanyService.prototype.get;
+    companyService.CompanyService.prototype.get = (companyId) =>
+      (companyId === CID ? { id: CID, name: CID, status: 'running' } : null);
+
+    // 起 /enqueue 前置门禁要求公司有 org graph——最小起一张（org-planner→org-coder→org-validator）
+    expect(org.writeGraph(CID, {
+      nodes: ['org-planner', 'org-coder', 'org-validator'],
+      edges: [{ from: 'org-planner', to: 'org-coder', condition: 'success' },
+        { from: 'org-coder', to: 'org-validator', condition: 'success' }],
+    }).ok).toBe(true);
+
+    // subtask-planning 的真实调用不走这个测试（VITEST 环境下 planSubtasks 自动短路，见该模块），
+    // 不用额外注入桩。
+
+    const express = require('express');
+    const app = express();
+    app.use(express.json());
+    app.use('/api/company', require('../../routes/company'));
+    await new Promise((resolve) => { server = app.listen(0, resolve); });
+    base = `http://127.0.0.1:${server.address().port}/api/company/${CID}`;
+  });
+
+  afterAll(() => {
+    if (server) server.close();
+    const companyService = require('../../services/company-service');
+    if (origCompanyGet) companyService.CompanyService.prototype.get = origCompanyGet;
+    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
+    try { fs.rmSync(process.env.GRAPH_RUNS_DIR, { recursive: true, force: true }); } catch {}
+    delete process.env.GRAPH_DB_PATH;
+    delete process.env.GRAPH_RUNS_DIR;
+    const allModules = [
+      ...MODULES, '../../services/graph-service', '../../services/org-graph-service',
+      '../../services/subtask-planning', '../../routes/company',
+    ];
+    for (const m of allModules) {
+      try { delete require.cache[require.resolve(m)]; } catch {}
+    }
+  });
+
+  it('普通顶层 task：enqueue 后走公司 org graph（graph_kind=org, graph_id=companyId）——回归，行为不变', async () => {
+    const goal = wdb.createGoal({ companyId: CID, title: 'g', description: 'd' });
+    const task = wdb.createTask({ goalId: goal.id, title: 't', description: 'd' });
+
+    const [status, body] = await call('POST', `/tasks/${task.id}/enqueue`);
+    expect(status).toBe(201);
+    const run = wdb.getRun(body.runId);
+    expect(run.graph_kind).toBe('org');
+    expect(run.graph_id).toBe(CID);
+  });
+
+  it('decomposed_work 子任务：enqueue 后走轻量 work graph（graph_kind=work，graph_id 不是 companyId）', async () => {
+    const goal = wdb.createGoal({ companyId: CID, title: 'g', description: 'd' });
+    const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
+    const child = wdb.createTask({
+      goalId: goal.id, title: 'c', description: 'd', parentTaskId: parent.id, subtaskKind: 'decomposed_work',
+    });
+
+    const [status, body] = await call('POST', `/tasks/${child.id}/enqueue`);
+    expect(status).toBe(201);
+    const run = wdb.getRun(body.runId);
+    expect(run.graph_kind).toBe('work');
+    expect(run.graph_id).not.toBe(CID);
+
+    const nodes = wdb.getDb()
+      .prepare(`SELECT node_name, system_agent_id FROM work_graph_nodes WHERE work_graph_id = ? ORDER BY node_name`)
+      .all(run.graph_id);
+    expect(nodes.map((n) => n.node_name)).toEqual(['impl', 'validate']);
+  });
+});
@@ -142,7 +142,7 @@ describe(&#39;43 号文档 Phase 3&#39;, () =&gt; {
     expect(out.node.status).toBe('success');
   });
  
-  it('46 号文档 Phase 3：同一个 task 下还挂着 claimable_work 子任务（未 completed）时，'
+  it('46 号文档 Phase 3：同一个 task 下还挂着 decomposed_work 子任务（未 completed）时，'
     + '不影响 acceptance_item 的验收判定——两套子任务完成判定互不干扰', async () => {
     const companyId = 'co-gate-6';
     const goal = wdb.createGoal({ companyId, title: 'g', description: 'd' });
@@ -151,11 +151,11 @@ describe(&#39;43 号文档 Phase 3&#39;, () =&gt; {
       goalId: goal.id, title: 'c1', description: 'd', parentTaskId: parent.id, subtaskKind: 'acceptance_item',
     });
     wdb.settleSubtaskResult(c1.id, 'completed'); // 验收条目全部完成
-    // claimable_work 子任务还停在 claimable，永远不会 completed（Phase 3 不碰执行）——
+    // decomposed_work 子任务还停在 draft，还没被 CEO enqueue、更不会 completed——
     // 如果闸门没收窄，这条会被当成"未完成的子任务"误伤，把上面本该通过的验收打成失败
     wdb.createTask({
-      goalId: goal.id, title: 'claim-me', description: 'd', parentTaskId: parent.id,
-      subtaskKind: 'claimable_work', status: 'claimable',
+      goalId: goal.id, title: 'todo-step', description: 'd', parentTaskId: parent.id,
+      subtaskKind: 'decomposed_work',
     });
  
     const out = await runValidator(companyId, parent.id);
-/**
- * 46 号文档 Phase 3：任务池认领机制。
- *
- * 三层各测各的：
- *   1. `createTask` 的 subtaskKind/status 校验（纯 DB 层参数校验）
- *   2. `materializeClaimableSubtasks`（steps[] → claimable_work 行，含 depends_on 回填）
- *   3. `claimSubtask`/`unclaimSubtask` 的 CAS（全仓库第一个"认领"语义的并发保护）
- *   4. 路由层 claim/unclaim 端点（角色白名单 + CAS 的 HTTP 翻译）
- *
- * DB 层沿用 `task-decomposition-validator-gate.test.js` 的隔离手法；路由层沿用
- * `company-goal-task-routes.test.js` 的「真起 express、没有 supertest 用 fetch 打」手法。
- */
-import {
-  describe, it, expect, beforeAll, afterAll,
-} from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-const TEST_DB_PATH = '/tmp/test-task-pool-claim.sqlite';
-const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
-const MODULES = ['../../services/graph-db', '../../services/work-graph-db'];
-
-describe('46 号文档 Phase 3：DB 层', () => {
-  let wdb;
-
-  beforeAll(() => {
-    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
-    process.env.GRAPH_DB_PATH = TEST_DB_PATH;
-    for (const m of MODULES) delete require.cache[require.resolve(m)];
-    wdb = require('../../services/work-graph-db');
-  });
-
-  afterAll(() => {
-    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
-    delete process.env.GRAPH_DB_PATH;
-    for (const m of MODULES) delete require.cache[require.resolve(m)];
-  });
-
-  // ── createTask 校验 ──────────────────────────────────────────────
-
-  it('subtaskKind 非法值直接拒', () => {
-    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
-    expect(() => wdb.createTask({
-      goalId: goal.id, title: 't', description: 'd', subtaskKind: 'not-a-real-kind',
-    })).toThrow(/subtaskKind 非法/);
-  });
-
-  it('subtaskKind 没有 parentTaskId 时直接拒（只对子任务有意义）', () => {
-    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
-    expect(() => wdb.createTask({
-      goalId: goal.id, title: 't', description: 'd', subtaskKind: 'claimable_work',
-    })).toThrow(/只对子任务.*有意义/);
-  });
-
-  it('status="claimable" 但 subtaskKind 不是 claimable_work 时直接拒', () => {
-    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
-    const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
-    expect(() => wdb.createTask({
-      goalId: goal.id, title: 'c', description: 'd', parentTaskId: parent.id,
-      subtaskKind: 'acceptance_item', status: 'claimable',
-    })).toThrow(/status='claimable' 只对/);
-  });
-
-  it('status 非 draft/claimable 直接拒', () => {
-    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
-    expect(() => wdb.createTask({
-      goalId: goal.id, title: 't', description: 'd', status: 'running',
-    })).toThrow(/status 只能是/);
-  });
-
-  it('正常创建 claimable_work 子任务：subtask_kind/status 落库正确', () => {
-    const goal = wdb.createGoal({ companyId: 'co-p3-1', title: 'g', description: 'd' });
-    const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
-    const child = wdb.createTask({
-      goalId: goal.id, title: 'c', description: 'd', parentTaskId: parent.id,
-      subtaskKind: 'claimable_work', status: 'claimable',
-    });
-    expect(child.subtask_kind).toBe('claimable_work');
-    expect(child.status).toBe('claimable');
-    expect(child.executor).toBe('graph'); // 默认值，认领时才会翻成 'agent'
-    expect(child.assignee_agent_id).toBeNull();
-  });
-
-  // ── materializeClaimableSubtasks ─────────────────────────────────
-
-  describe('materializeClaimableSubtasks', () => {
-    function setupTask(companyId) {
-      const goal = wdb.createGoal({ companyId, title: 'g', description: 'd' });
-      return wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
-    }
-
-    it('按 steps 顺序物化，depends_on 正确回填成真实 task id（含前向引用）', () => {
-      const task = setupTask('co-p3-2');
-      const steps = [
-        { seq: 1, title: '第一步', depends_on_hint: [3] }, // 前向引用：依赖还没建出来的第三步
-        { seq: 2, title: '第二步', depends_on_hint: [1] },
-        { seq: 3, title: '第三步', depends_on_hint: [] },
-      ];
-      const ids = wdb.materializeClaimableSubtasks({ task, steps });
-      expect(ids).toHaveLength(3);
-
-      const rows = ids.map((id) => wdb.getTask(id));
-      expect(rows.every((r) => r.subtask_kind === 'claimable_work')).toBe(true);
-      expect(rows.every((r) => r.status === 'claimable')).toBe(true);
-      expect(rows[0].title).toBe('第一步');
-      expect(JSON.parse(rows[0].depends_on)).toEqual([ids[2]]); // 前向引用也正确解析成第三步的真实 id
-      expect(JSON.parse(rows[1].depends_on)).toEqual([ids[0]]);
-      expect(JSON.parse(rows[2].depends_on)).toEqual([]);
-    });
-
-    it('depends_on_hint 指向不存在的 seq：丢那一条引用，不作废整批（宽松解析）', () => {
-      const task = setupTask('co-p3-3');
-      const steps = [{ seq: 1, title: '唯一一步', depends_on_hint: [99] }];
-      const ids = wdb.materializeClaimableSubtasks({ task, steps });
-      expect(ids).toHaveLength(1);
-      expect(JSON.parse(wdb.getTask(ids[0]).depends_on)).toEqual([]);
-    });
-
-    it('幂等：同一个 task 物化第二次直接跳过，不重复建行', () => {
-      const task = setupTask('co-p3-4');
-      const steps = [{ seq: 1, title: '一步', depends_on_hint: [] }];
-      const first = wdb.materializeClaimableSubtasks({ task, steps });
-      expect(first).toHaveLength(1);
-      const second = wdb.materializeClaimableSubtasks({ task, steps });
-      expect(second).toEqual([]);
-
-      const rows = wdb.getDb()
-        .prepare(`SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ? AND subtask_kind = 'claimable_work'`)
-        .get(task.id);
-      expect(rows.n).toBe(1);
-    });
-
-    it('空 steps / 无 task 时返回 []，不报错', () => {
-      const task = setupTask('co-p3-5');
-      expect(wdb.materializeClaimableSubtasks({ task, steps: [] })).toEqual([]);
-      expect(wdb.materializeClaimableSubtasks({ task: null, steps: [{ seq: 1, title: 'x' }] })).toEqual([]);
-    });
-
-    it('与 43 号文档的 acceptance_item 共存互不干扰：各自幂等判据只看自己的 subtask_kind', () => {
-      const task = setupTask('co-p3-6');
-      wdb.createTask({
-        goalId: task.goal_id, title: 'a1', description: 'd', parentTaskId: task.id,
-        subtaskKind: 'acceptance_item',
-      });
-      const ids = wdb.materializeClaimableSubtasks({
-        task, steps: [{ seq: 1, title: 'c1', depends_on_hint: [] }],
-      });
-      expect(ids).toHaveLength(1); // 没有被 acceptance_item 那条已存在的行挡住
-    });
-  });
-
-  // ── claimSubtask / unclaimSubtask CAS ────────────────────────────
-
-  describe('claimSubtask / unclaimSubtask', () => {
-    function makeClaimable(companyId) {
-      const goal = wdb.createGoal({ companyId, title: 'g', description: 'd' });
-      const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
-      return wdb.createTask({
-        goalId: goal.id, title: 'c', description: 'd', parentTaskId: parent.id,
-        subtaskKind: 'claimable_work', status: 'claimable',
-      });
-    }
-
-    it('认领成功：status/executor/assignee/claimed_at 全部正确落库', () => {
-      const t = makeClaimable('co-p3-7');
-      expect(wdb.claimSubtask(t.id, 'org-coder')).toBe(1);
-      const after = wdb.getTask(t.id);
-      expect(after.status).toBe('claimed');
-      expect(after.executor).toBe('agent');
-      expect(after.assignee_agent_id).toBe('org-coder');
-      expect(after.claimed_at).toBeTruthy();
-    });
-
-    it('并发认领同一条：只有一方成功（changes CAS）', () => {
-      const t = makeClaimable('co-p3-8');
-      const r1 = wdb.claimSubtask(t.id, 'org-coder');
-      const r2 = wdb.claimSubtask(t.id, 'org-coder'); // 模拟第二次竞争（同一行为不同调用）
-      expect([r1, r2].sort()).toEqual([0, 1]); // 一个 1 一个 0，不是两个都 1
-    });
-
-    it('非 claimable 状态（比如已经是 claimed）认领失败，changes=0', () => {
-      const t = makeClaimable('co-p3-9');
-      wdb.claimSubtask(t.id, 'org-coder');
-      expect(wdb.claimSubtask(t.id, 'someone-else')).toBe(0);
-      expect(wdb.getTask(t.id).assignee_agent_id).toBe('org-coder'); // 没被顶掉
-    });
-
-    it('不是 claimable_work 的行认领失败', () => {
-      const goal = wdb.createGoal({ companyId: 'co-p3-10', title: 'g', description: 'd' });
-      const t = wdb.createTask({ goalId: goal.id, title: 't', description: 'd' }); // 普通 task
-      expect(wdb.claimSubtask(t.id, 'org-coder')).toBe(0);
-    });
-
-    it('放弃认领：claimed → claimable，executor 退回 graph，assignee 清空', () => {
-      const t = makeClaimable('co-p3-11');
-      wdb.claimSubtask(t.id, 'org-coder');
-      expect(wdb.unclaimSubtask(t.id, 'org-coder')).toBe(1);
-      const after = wdb.getTask(t.id);
-      expect(after.status).toBe('claimable');
-      expect(after.executor).toBe('graph');
-      expect(after.assignee_agent_id).toBeNull();
-      expect(after.claimed_at).toBeNull();
-    });
-
-    it('放弃认领：不是认领者本人放弃失败', () => {
-      const t = makeClaimable('co-p3-12');
-      wdb.claimSubtask(t.id, 'org-coder');
-      expect(wdb.unclaimSubtask(t.id, 'someone-else')).toBe(0);
-      expect(wdb.getTask(t.id).status).toBe('claimed'); // 没被动
-    });
-  });
-});
-
-describe('46 号文档 Phase 3：路由层 claim/unclaim', () => {
-  const CID = 'route-p3-co';
-  let wdb;
-  let server;
-  let base;
-  let origCompanyGet;
-
-  function hireInto(companyId, agentId, roleName) {
-    const db = wdb.getDb();
-    const now = new Date().toISOString();
-    db.prepare(`INSERT OR IGNORE INTO system_agents
-        (id, name, scope, owner_company_id, legacy_path, status, created_at, updated_at)
-        VALUES (?, ?, 'public', NULL, ?, 'active', ?, ?)`)
-      .run(agentId, agentId, `system/agents/${agentId}`, now, now);
-    db.prepare(`INSERT OR IGNORE INTO company_agents (company_id, system_agent_id, role_name, status, hired_at)
-        VALUES (?, ?, ?, 'active', ?)`).run(companyId, agentId, roleName, now);
-  }
-
-  async function call(method, url, body) {
-    const r = await fetch(base + url, {
-      method,
-      headers: { 'Content-Type': 'application/json' },
-      body: body === undefined ? undefined : JSON.stringify(body),
-    });
-    return [r.status, await r.json()];
-  }
-
-  beforeAll(async () => {
-    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
-    process.env.GRAPH_DB_PATH = TEST_DB_PATH;
-    process.env.GRAPH_RUNS_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'p3-claim-routes-'));
-    for (const m of [...MODULES, '../../routes/company']) {
-      try { delete require.cache[require.resolve(m)]; } catch {}
-    }
-    wdb = require('../../services/work-graph-db');
-
-    const companyService = require('../../services/company-service');
-    origCompanyGet = companyService.CompanyService.prototype.get;
-    companyService.CompanyService.prototype.get = (companyId) =>
-      (companyId === CID ? { id: CID, name: CID, status: 'running' } : null);
-
-    hireInto(CID, 'org-coder', 'org-coder');
-    hireInto(CID, 'ceo', 'ceo'); // 用来验证"雇了但不在白名单"这条 403 分支
-
-    const express = require('express');
-    const app = express();
-    app.use(express.json());
-    app.use('/api/company', require('../../routes/company'));
-    await new Promise((resolve) => { server = app.listen(0, resolve); });
-    base = `http://127.0.0.1:${server.address().port}/api/company/${CID}`;
-  });
-
-  afterAll(() => {
-    if (server) server.close();
-    const companyService = require('../../services/company-service');
-    if (origCompanyGet) companyService.CompanyService.prototype.get = origCompanyGet;
-    for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch {} }
-    try { fs.rmSync(process.env.GRAPH_RUNS_DIR, { recursive: true, force: true }); } catch {}
-    delete process.env.GRAPH_DB_PATH;
-    delete process.env.GRAPH_RUNS_DIR;
-    for (const m of [...MODULES, '../../routes/company']) {
-      try { delete require.cache[require.resolve(m)]; } catch {}
-    }
-  });
-
-  function makeClaimable() {
-    const goal = wdb.createGoal({ companyId: CID, title: 'g', description: 'd' });
-    const parent = wdb.createTask({ goalId: goal.id, title: 'p', description: 'd' });
-    return wdb.createTask({
-      goalId: goal.id, title: 'c', description: 'd', parentTaskId: parent.id,
-      subtaskKind: 'claimable_work', status: 'claimable',
-    });
-  }
-
-  it('白名单角色认领成功', async () => {
-    const t = makeClaimable();
-    const [status, body] = await call('POST', `/tasks/${t.id}/claim`, { agentId: 'org-coder' });
-    expect(status).toBe(200);
-    expect(body.task.status).toBe('claimed');
-    expect(body.task.assigneeAgentId).toBe('org-coder');
-    expect(body.task.subtaskKind).toBe('claimable_work');
-  });
-
-  it('非白名单角色认领：403', async () => {
-    const t = makeClaimable();
-    const [status, body] = await call('POST', `/tasks/${t.id}/claim`, { agentId: 'ceo' });
-    expect(status).toBe(403);
-    expect(body.error).toMatch(/白名单/);
-  });
-
-  it('缺 agentId：400', async () => {
-    const t = makeClaimable();
-    const [status] = await call('POST', `/tasks/${t.id}/claim`, {});
-    expect(status).toBe(400);
-  });
-
-  it('不是可认领子任务（普通 task）：400', async () => {
-    const goal = wdb.createGoal({ companyId: CID, title: 'g', description: 'd' });
-    const t = wdb.createTask({ goalId: goal.id, title: 't', description: 'd' });
-    const [status] = await call('POST', `/tasks/${t.id}/claim`, { agentId: 'org-coder' });
-    expect(status).toBe(400);
-  });
-
-  it('已被认领的再认领：409', async () => {
-    const t = makeClaimable();
-    await call('POST', `/tasks/${t.id}/claim`, { agentId: 'org-coder' });
-    const [status] = await call('POST', `/tasks/${t.id}/claim`, { agentId: 'org-coder' });
-    expect(status).toBe(409);
-  });
-
-  it('认领后放弃：状态正确回退', async () => {
-    const t = makeClaimable();
-    await call('POST', `/tasks/${t.id}/claim`, { agentId: 'org-coder' });
-    const [status, body] = await call('POST', `/tasks/${t.id}/unclaim`, { agentId: 'org-coder' });
-    expect(status).toBe(200);
-    expect(body.task.status).toBe('claimable');
-    expect(body.task.assigneeAgentId).toBeNull();
-  });
-
-  it('不是认领者本人放弃：409', async () => {
-    const t = makeClaimable();
-    await call('POST', `/tasks/${t.id}/claim`, { agentId: 'org-coder' });
-    const [status] = await call('POST', `/tasks/${t.id}/unclaim`, { agentId: 'ceo' });
-    expect(status).toBe(409);
-  });
-});
@@ -7,8 +7,23 @@
  
 - [ ] 查 `GET /tasks?status=blocked` 和 `?status=failed`，看有没有需要处理的
 - [ ] 查 `GET /goals?status=active`，扫一眼有没有明显该调整优先级的
+- [ ] 查 `GET /tasks?subtaskKind=decomposed_work&status=draft`，看有没有等你派发的子任务
+      （46 号文档 Phase 3：`subtask-planning` 拆出来的步骤，落库就是普通 draft task，
+      不会自己跑起来，要你判断"现在放不放"）
 - [ ] 都正常就直接回复"心跳正常"，不要为了"用一下工具"而用工具
  
+## 子任务怎么派（decomposed_work）
+
+- 看到的每一条都已经是具体到"这一步做什么"的粒度（`subtask-planning` 已经拆过了），
+  不需要你再判断"这条该不该做"——**只需要判断节奏**：现在放，还是等前置步骤先跑完再放。
+- 想知道前置步骤是谁：任务详情里的 `dependsOn` 数组。不用你自己排队——`depends_on`
+  没完成的，`enqueue` 了也会被调度器自动拦成 `blocked`，一次性把一条 task 下所有
+  `draft` 的子任务全部 `enqueue` 是安全的，先后顺序、并发几个都是调度器的活，不是你的。
+- 派一条：`POST /tasks/<taskId>/enqueue`（跟你派自己提的草稿任务是同一个端点，同一条权限）。
+- 这批子任务会走一张**轻量图**（只有实现+验证两步，不是公司完整的组织架构那套），
+  成本比一条顶层 task 低很多，但目前还没有正式跑过真实验证——如果发现同一个 task 下的
+  子任务频繁失败或者结果质量不行，在回复里如实说，不要自己想办法绕过去。
+
 ## 发现问题时
  
 - 具体判断依据见 `tools.md` 的"什么时候该提新任务、什么时候该改优先级"一节
@@ -45,6 +45,14 @@ curl -s &quot;${LEMON_API_BASE:-http://localhost:3010/api}/company/&lt;companyId&gt;/goals/
   -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
 ```
  
+### 找等你派发的子任务（46 号文档 Phase 3）
+```bash
+curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/tasks?subtaskKind=decomposed_work&status=draft" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
+```
+每条都带 `parentTaskId`（它是哪条 task 拆出来的）和 `dependsOn`（同批里它依赖哪几条，
+数组里是别的子任务的 taskId，不是要你手动排序——只是给你看清楚"这条要等谁先完成"）。
+
 ---
  
 ## 写：只在真正判断需要时才用
@@ -76,6 +84,10 @@ curl -s -X POST &quot;${LEMON_API_BASE:-http://localhost:3010/api}/company/&lt;companyId
 必要的——`enqueue` 之后就会真的排队执行、真的烧预算。判断依据不够就先别 enqueue，
 留着草稿等人类看到也行。
  
+**`decomposed_work` 子任务走同一个端点**——`subtask-planning` 已经把内容拆好了，你不用再判断
+"清不清楚"，只判断节奏（现在放还是等）。同一条 task 下的子任务可以一次性全部 enqueue，
+`depends_on` 没完成的会被调度器自动拦住，不用你自己算顺序。
+
 ---
  
 ## 卡住的 run 节点：只能用这一个端点处理，不许自己动手