Merge branch 'main' of gitlab-wuwei.hexpm.com:yibo/lemonboss

yibo
2 parents 46592361 4d23f506
Showing 34 changed files with 2227 additions and 721 deletions
docs/README.md
docs/todo/system-design/39-boss-agent-task-supervision.md
docs/todo/system-design/40-agent-chat-streaming-interrupt.md
scripts/backfill-ceo-hire.js
server/index.js
server/routes/agent-chat.js
server/routes/company.js
server/services/devloop/path-resolver.js
server/services/graph-engine.js
server/services/task-settle.js
server/services/work-graph-db.js
server/src/core/agent-session-lock.js
server/tests/devloop/path-resolver.test.js
server/tests/unit/agent-chat-interrupt.test.js
server/tests/unit/graph-engine-target-dir.test.js
server/tests/unit/graph-engine.test.js
server/tests/unit/route-auth-gate.test.js
server/tests/unit/task-blocked-ceo-wake.test.js
server/tests/unit/task-entry-draft-mode.test.js
server/tests/unit/task-slots-parallel.test.js
@@ -51,10 +51,12 @@ Graph Agent 架构重构（27 系列）。**已完成的阶段文档已移入 `d
 | [29-dream-design.md](./todo/system-design/29-dream-design.md) | **dream（经验汇流）**— ✅ 已实现。定时整理所有 agent 在所有公司的记忆，提炼后跨公司沉淀（不泄漏公司信息）。四条取舍已拍板并实现：去敏独立判定、四落点分层写入（经验/`SKILL.md`/`soul.md`/`agent.md`，受管区块+三道闸门）、每日定时（串行+空转保护）、引用真伪自动查、REST+控制台入口（`/api/dream/*`、`/dream`）。`innovator-evolver` 真 CLI 跑通一次。**仍缺的**：「结论对不对」只能人抽查；「套进 org/work graph 来跑」评估后用户选了不做（作用域不匹配，见文内 §5.7） |
 | [30-task-delegation-reliability-gaps.md](./todo/system-design/30-task-delegation-reliability-gaps.md) | **任务委派可靠性现状**— 📝 调研记录，非设计方案。DevLoop `runUnit`、Company 招聘装配、Graph 执行三条链路核对结论一致：都是「失败预算耗尽 → 停等人工」，没有「卡住了主动通知人」这一层；DevLoop 当前还默认走 mock，真实 CLI 成功率无实证数据。2026-08-23 追加真实实例并已修：`infra_flake` 原地重跑没有熔断线，真撞上过一次确定性死循环（节点把诊断结论误判成自己的执行结果，反复重跑却从不路由到诊断建议的目标节点）；已加 `infra_flake_count` 列 + 硬顶 3 次熔断，连续判 infra_flake 超过硬顶就改判 blocked 交给人工 |
 | [31-work-graph-fail-fallback-coverage.md](./todo/system-design/31-work-graph-fail-fallback-coverage.md) | work graph 兜底边覆盖不全 — ✅ 已完成（除入口节点外强制兜底边，`planner.json`/`executor-fanout.json` 补 6 条边），978/978 单测通过；2026-08-21 又用真实 LLM 起了一条新任务做端到端回归验证，`org-planner-sdd` 自判失败后自动打回 `org-planner-prd`（3 次，零人工介入），修复确认生效 |
+| [39-boss-agent-task-supervision.md](./todo/system-design/39-boss-agent-task-supervision.md) | 📝 **设计评估中，未实现**。评估用户提出的五阶段方案（雇 boss agent 监督 goal/task 看板、独立任务看板页、心跳挨个调度、org/work graph 产出的 bug/新任务回写看板、公司级目标代码目录）。结论：P2 看板已实现、P1/P3 心跳与 `ceo` 本体基础设施已有大半、P5 的 `linked-existing` 模式已在 `path-resolver.js` 完整实现只差公司级默认值，**真正从零开始的是 P4（回写闭环）**——当前没有任何 agent 工具能读写 goal/task 板。建议顺序倒过来先建 P4 地基 |
 | [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 人设文档的自我认知改写 |
 | [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（训练产物 → 雇佣本体转换）尚未开工 |
 | [35-validation-rigor-and-body-readiness-proposal.md](./todo/system-design/35-validation-rigor-and-body-readiness-proposal.md) | 📝 **复盘 + 改进方案，四条提案全部已实施**。承接 31/32/33/34 号的复盘结论：任务结果差主要是架构问题（完整性闸门 `missingBodyDefinition` 只在招聘时查、图执行侧完全没有第二道防线——新发现）+ 一个具体的招聘装配可靠性 bug，不是 agent 能力问题。提案 A：本体不完整时图执行前置判 `fail_reason=body_not_ready`，不扣预算。提案 D：`goal-contract.js` 的 `evidence_hint` 命中浏览器类关键词的维度必须有证据支撑，否则判不过。提案 C：新增 `scripts/visual-acceptance-check.mjs` 复用检查工具。提案 B：控制台「验收证据」小节展示每个维度有没有证据支撑 |
 | [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) 那类"装配没填充完"的真实样本，不是平台工具限制 |
+| [40-agent-chat-streaming-interrupt.md](./todo/system-design/40-agent-chat-streaming-interrupt.md) | 📝 **需求文档，讨论中，未实现**。回应"前端刷新不及时/没有打字机效果，要不要把 SSE 换成 WebSocket"——排查后结论是传输层不是瓶颈（对照 hermes-webui/hermes-agent/deepseek-harness 三个参考实现，全部走 SSE，不用 WebSocket）。真正的三个独立缺口：① 打字机不流畅（ACP chunk 粒度太粗，方案是前后端都做匀速切片/渲染缓冲）；② 执行中无法打断并接上新消息（现状"先 Stop 再发"两步，方案是深度 1 的打断-排队，顺带发现服务端对同 convId 并发缺闸门这个现存 bug）；③ 串台已在 `9b1c3f1` 修复但没有回归测试兜底 |
 | [33-needs-gate-role-filter-bug.md](./todo/system-design/33-needs-gate-role-filter-bug.md) | ✅ **已修复**。`executor.json`/`executor-fanout.json` 里 `produces:["log"]` 声明了一个 test/integration 类节点永远不会被索引到的 kind，导致 `org-coder-validator` 被 `missing_required_input` 反复误判 blocked；改成 `required:false`（对齐 `validator.json` 既有写法）。文档记录了一条**走过的弯路**（按 role 过滤 `inboundContracts` 会削弱 T-mt25ecbd 的产出闸门，已撤回），发现于 31 号文档的真实回归验证过程中，与兜底边问题无关 |
  
 ## todo/future/（暂缓，非当前重心）
+# 39. Boss Agent 任务看板监督 + 公司目标代码目录 — 需求评估与设计草案
+
+> **状态**：📝 设计评估中，未实现。本文档是对用户口述五阶段方案的落地可行性评估 + 修订后的设计草案，不是最终定案。
+> **日期**：2026-08-30
+> **背景**：承接对话讨论——goal/task 两级模型（[27-P3C](../../done/system-design/27-p3c-goal-task-model.md)）已落地，但推进它的是纯确定性代码（`task-scheduler.js` + `transitionRun` 钩子），没有任何 agent 在持续监督这块看板、处理异常、把执行中发现的新问题回写成新任务。用户提出五阶段方案补上这一层，并追加公司级目标代码目录需求。
+> **读者须知**：本文档大量引用现有代码路径核实"已有 vs 缺失"，结论以文内给出的具体函数/文件为准；这些引用会随代码演进过期，落地前请重新核实。
+
+---
+
+## 一、先说结论
+
+用户的五阶段里，**P2（任务看板）本质已完成，P1/P3 的基础设施已有大半，P4 是真正的新增核心，P5 的机制已经实现了 70%，只是没有暴露到公司层面。** 真正从零开始的工作量比五个"phase"暗示的要小得多，但顺序建议大改：**P4（回写闭环）应该提到最前面**，因为它才是这次讨论最初的诉求（"自己发现问题、自己重新规划"），P1/P3 的 boss agent 只有在 P4 的工具/数据通路建好之后才有事可做。
+
+| 用户的 phase | 名义工作量 | 实际现状 | 建议 |
+|---|---|---|---|
+| P1 雇佣通用 boss agent | 新建一个角色 + 训练 | 心跳基础设施、`ceo` 本体、Innovator 训练方法论**全部已有** | 复用 `ceo`，不新建角色；工作量收窄成"写 heartbeat.md + 工具" |
+| P2 任务看板独立页面 | 一个新系统 | goal/task 两级看板**已实现**（`GoalTaskPane.vue`），只是嵌在控制台里 | 降级成 UI 改造，非必须，可排最后 |
+| P3 心跳挨个决定下一个 task | 新的调度逻辑 | 挨个执行**已经是** `task-scheduler.js` 在做，且做得更好（事件驱动、零成本、已测试） | **不要重建调度**；心跳的职责收窄为"异常判断"，且应事件触发而非纯轮询 |
+| P4 bug/新任务回写看板 | 一条新闭环 | **不存在**——没有任何 agent 可读写 goal/task 板的工具，四分类失败归因（30 号文档）目前只导向"重试或人工介入"，不导向"开新任务" | **真正的核心工作，优先做** |
+| P5 公司目标代码目录 | 新能力 | DevLoop 的 `path-resolver.js` 已实现 `sandbox` / `linked-new` / `linked-existing` 三种模式，**`linked-existing`（接管已有目录）已经是完整实现**，只是没有公司级默认值，也没打通到 org/work graph（非 DevLoop）路径 | 补一个公司级默认配置 + 核实非 DevLoop 路径是否需要同样机制 |
+
+---
+
+## 二、逐 phase 现状核实
+
+### P1：每个公司雇佣 boss agent，system agent 层训练通用版本
+
+**已有的基础设施**（全部实地核实过）：
+
+1. **通用心跳机制**：`server/services/heartbeat-service.js`。状态落在 `system/agents/{aid}/{cid}/heartbeat.json`（公司态目录，不是共享本体——这条边界是踩过坑之后加的，见文件头注释），本体 `config.json.heartbeat` 只是只读默认建议间隔。`_triggerHeartbeat()` 按 `setInterval` 定时给 agent 发一条 `[SYSTEM HEARTBEAT]` 系统消息（走正常的 `/api/agent/{agentId}/chat`），要求 agent "**根据你的身份和 heartbeat.md 规则**……如果一切正常，无事发生，请直接回复『心跳正常』"，带 30 分钟会话互斥防重叠。**这套机制现成可用，不用重建。**
+   - ✅ **修正一处之前的误判**：原以为 prompt 里"扫描全局 OKR 目标状态和节点"那句硬编码需要改代码才能适配新 goal/task 模型。查了 `system/agents/` 下已有 **35 个**本体带 `heartbeat.md`（如 `org-innovator/heartbeat.md`），内容五花八门、完全跟 OKR 无关，说明触发消息里那句"扫描 OKR"从来就只是**默认示例文案**，各 agent 早就按自己 `heartbeat.md` 里写的规则各干各的。**结论：`heartbeat-service.js` 大概率零改动**，只需要新建 `system/agents/ceo/heartbeat.md`，写清楚"去查 goal/task 板、按 §四.9 的规则判断"，agent 读到自己的 `heartbeat.md` 就会照着做，不需要动服务端代码。落地时找一个现有 `heartbeat.md` 生效的真实案例复核一次这个推断，再动手写 `ceo` 的那份。
+2. **本体已存在**：`system/agents/ceo/`（`type: "cxo"`，"Chief Executive Officer"，`heartbeat.enabled: false` 默认关）。同时存在 `system/agents/master/`（`type: "master"`，**全局唯一**，`/api/master/chat`，负责建公司/招聘等跨公司操作）。两者定位不同：`master` 是平台层面的单例助手，`ceo` 才是"每个公司一个"的角色。
+3. **训练方法论已验证**：`36-prd-agent-methodology-training-feasibility.md` 已经用 Innovator（Hunt→Digest→Evolve）训练出过一个方法论型 agent（`prd-methodology-trial`），2 轮收敛、96/97 分，方法论对这类"判断型"角色确实管用。可以照搬这条路径训练 `ceo` 的监督方法论，而不是手写一份 prompt 拍脑袋。
+
+**结论**：不建议新建"boss"角色。**复用 `system/agents/ceo/`**——它的岗位定义（CEO）本来就该管"任务有没有卡住、要不要重新分解"，另起一个语义重叠的角色只会重犯这个仓库反复踩过的"名字歧义"坑（`27-naming-conventions.md` 通篇在防这个）。P1 的实际工作量是：① 给 `ceo` 补一份 `heartbeat.md`（监督规则）；② 给它挂上 P4 需要的工具（见下）；③ 默认 `heartbeat.enabled: true`（但见 P3 的成本讨论，建议先不无脑轮询）；④ 可选：用 Innovator 训练它的监督方法论。
+
+**缺口 A**：目前**没有任何 agent 工具能读写 `goals`/`tasks` 表或操作 graph run**（搜了 `server/src/tools/` 全目录，零命中）。`ceo` 就算被唤醒也无事可做——这是 P1 能不能生效的真正前提，见 P4。
+
+**缺口 B（新发现，之前漏了）：`ceo` 现在没有被雇进任何公司，`hire()` 也没有任何自动触发点会调它**。查了 `hire(companyId, roleName)`（`company-service.js:422`）——它只查本体目录 + `company_agents` 表，**不查 org graph**，机制上雇一个不在图里的角色完全没问题（数据模型层面，"雇了"和"进图"是两件独立的事）。但目前**没有任何代码路径会主动调 `hire(companyId, 'ceo')`**——它不在三份 org-graph-templates 里，也没有类似 `orggraph-planning` 那样的自动招聘钩子替它兜底。`37-org-graph-department-scoping.md` 里记录过一模一样的处境：`hr/` 本体"已经真实存在……只是从没被装进任何图……今天完全是编外人员"——`ceo` 现在是同款处境，**不是有先例可抄，是同一个坑还没人填**。P1 必须显式加一步：① 公司创建流程里（不管选哪个 org-graph-template）固定 `hire(companyId, 'ceo')` 一次；② 存量公司需要一次性回填脚本，遍历现有公司补雇。这条不做，前面说的"复用 ceo"就是一句空话——压根没有 `ceo` 实例在跑。
+
+---
+
+### P2：任务看板独立页面
+
+**已实现**（[27-P3C](../../done/system-design/27-p3c-goal-task-model.md)，✅ 2026-08-20）：`web/src/components/graph-console/GoalTaskPane.vue` + `goal-task-model.js`，挂在 `/:companyId/graph-console` 左栏。goal/task 两级状态、优先级排队位次、颜色语义全部已有，REST 是 `server/routes/company.js` 的 `GET/POST /api/company/:cid/goals` 系列。
+
+**用户要的"独立页面"** 目前是控制台的一个侧栏，不是路由级独立页面。这是纯 UI 改造，**不涉及数据模型或后端**，随时可做，风险最低。
+
+**"subtask" 层**：当前**没有独立的 subtask 表**，`task` 就是看板能管理的最细颗粒度。task 再往下是 `graph_runs`（work graph 节点，可能含嵌套子图），这层在中间的执行画布（`WorkGraphCanvas`）里看，不在左栏。
+
+> ⚠️ **不建议新增一张 subtask 表**去对应 work graph 节点。这个仓库已经因为"两套任务体系不统一"吃过至少两次苦头（P3C §十二"批 5"整章在处理这个债，`27-p3c-batch3-handover.md` 也记过一次事故）。如果要在看板上展示"这个 task 内部具体在跑哪几步"，应该是**只读地把该 task 当前 `current_run_id` 对应的 `graph_run_nodes` 渲染成一份"子步骤列表"**，复用现有表和现有执行画布的数据源，不新建写路径。
+
+#### P2 决定：与 OKR 页面的关系（已拍板，2026-08-30）
+
+排查发现现状比预期乱：**OKR 相关 UI 现在有两份几乎逐行相同的重复实现**——`web/src/views/OkrDashboard.vue`（路由 `/okr`，`requireAdmin`，零导航入口的孤儿页面）和 `CompanyDashboard.vue` 里挂着 "goals" 名字、实际渲染 "Goals (Full OKR Tree)" 的 tab——两者都是旧 OKR 树（`O-xxx`，owner + progress%），是"OKR 正名"（`27-naming-conventions.md` §六）前端没跟着改完的遗留物，前端两处都调 `/api/okr/*`，和 P3C 的新 goal/task 模型完全不是一回事。
+
+**已拍板**：**不合并**，OKR 这套前端 UI**直接废弃**，新任务看板**另起一个独立页面**。具体动作：
+
+1. **新增路由**：仿照 `GraphConsole` 已经立好的先例（`/:id/graph-console` 是独立路由，不挤在 `CompanyDetail` 的 `:tab(...)` 白名单里），新增 `/:id/task-board`（命名待定）→ 新建 `web/src/views/TaskBoard.vue`。**不要塞进 `:tab(...)` 正则**，理由与 `graph-console` 当年的注释一致：任务看板信息密度高，值得一个整页。
+2. **复用现有逻辑，不重写数据层**：`GoalTaskPane.vue` + `goal-task-model.js` 现在已经封装了 goal/task 的状态映射、排序、颜色语义（且有专门的单测 `goal-task-model.test.js` 兜底）。新页面应该是把这个组件从 `GraphConsole` 的侧栏布局里"拔出来"放大铺满整页，**不是重新实现一遍**。`GraphConsole` 侧栏可以保留一份精简版（点某个 task 仍需跳转去看它的执行图），也可以改成跳转链接指向新页面——两种都行，实现时再定。
+3. **废弃 OKR 前端**：删 `/okr` 路由 + `OkrDashboard.vue`；删 `CompanyDashboard.vue` 里那个挂着 "goals" 名字实为 OKR 树的 tab；路由 `:tab(...)` 白名单里的 `goals`/`okr` 两个值一并摘掉，避免留死链接。
+4. **导航入口**：新页面必须挂真实导航入口（`AppNav` 或公司详情页的显眼位置），不能重蹈 `/okr` 那种"孤儿页面"的覆辙。
+5. **鉴权**：`okr.js` 当年挂 `requireAdmin` 是因为它是孤儿页面、没做归属校验的权宜之计（`38-auth-multi-tenant-isolation.md`），**不是"任务看板天生该管理员专属"**。新路由要按 `company.js` 等其他公司级路由的标准做法，走 `canAccessCompany` 归属校验，不能照抄 `requireAdmin`。
+
+**范围之外、本次不动**（留作独立的后续决定，不在这次 P2 改造里顺手做）：`/api/okr/*` 后端路由、`okr` 相关 SQLite 表、`goals.okr_node_id` 这个可选外键字段——前端 UI 废弃不等于后端子系统也要一起拆，那是一次单独的、影响面更大的退役决定（牵涉数据迁移/存量数据处理），需要单独评估，这里先只处理前端。
+
+---
+
+### P3：心跳挨个决定下一个 task
+
+**这条按用户原话实现是在重建一个已经存在、已经测试、且更优的系统。** `task-scheduler.js` 的队列排序口径是 `priority → seq → created_at`（`ORDER BY priority, seq, created_at`），出队靠 `transitionRun` 这个唯一漏斗事件触发，不是轮询；v1 约束 `max_parallel_tasks`（`company.json`，缺省 1）决定"挨个"还是"并发几个"，`server/tests/unit/task-slots-parallel.test.js` 覆盖了 >1 的情况。这套机制零 LLM 成本、毫秒级触发、已经过多轮真实回归验证（`31-work-graph-fail-fallback-coverage.md` 的真实 LLM 端到端案例）。
+
+**成本账**：`heartbeat-service.js` 现在的实现是**每一次 tick 都真的发一次 LLM 调用**，只是 prompt 要求"没事就回复 `[心跳正常]`"——省不了那次调用的 token/延迟。如果 N 家公司、每家每 5 分钟一次心跳，24 小时就是 N×288 次 LLM 调用，绝大多数只会换回一句"心跳正常"。
+
+**修订建议**：boss agent 心跳**只负责调度器处理不了的判断题**，而且触发方式改成"事件优先、轮询兜底"，不是纯定时轮询：
+
+1. 判断题清单（调度器管不了、需要 LLM 判断的）：
+   - task 长时间 `blocked` 或 `failed`（预算耗尽/依赖死锁）——要不要重新分解、要不要升级给人类；
+   - 同一 goal 下多个 task 出现优先级冲突（业务变化导致原定顺序不再合理）——要不要调整 `priority`；
+   - `task-planning` 3 轮降级成单任务（P3C §四.9 的降级路径）——要不要人工介入重新审视这条 goal 的描述。
+2. **优先事件驱动**：在 `transitionRun`/`settleGoal` 这类既有钩子里，遇到上述判断题触发的状态变化（比如 task 转 `blocked`）时，**主动**唤醒 `ceo` 处理这一条，而不是让它等下一次心跳才发现。心跳退化成**低频兜底**（比如 30 分钟一次，只扫"有没有钩子漏掉的异常"），不是主决策路径——这与现有 `task-scheduler.js` 头部注释里"兜底扫描周期"的设计哲学完全一致，照抄这个模式即可。
+
+---
+
+### P4：org/work graph 产生的新 bug / 新 task 回写看板，形成闭环
+
+**这是五个 phase 里唯一真正从零开始、也是这次讨论最初诉求（"自己发现问题、自己重新规划"）真正要落地的地方。**
+
+**现有的失败归因机制**（`30-task-delegation-reliability-gaps.md`）：`BugTriager`/`validator-triager` 类节点已经在做四分类——`contract_mismatch` / `impl_bug` / `spec_ambiguous` / `infra_flake`——但**四条路径的终点目前都是"原地重试"或"预算耗尽后 blocked 等人工"**，没有一条走向"生成一条新 task/goal"。
+
+**需要新增的两个通路**：
+
+1. **确定性通路（不需要 agent 判断）**：把四分类里"显然该开新任务"的情形直接在 `routeFailure`（`graph-engine.js`）里接一条规则，而不是等 boss agent 心跳才处理——比如 `spec_ambiguous` 在 goal 级预算内重试超过阈值，直接生成一条 `status='draft'`、`created_by='system'`、挂在同一 `goal_id` 下的新 task，附上失败节点的诊断产物作为新 task 的 `description` 素材，人工/`ceo` 再审。这条不需要 LLM 判断"要不要开新任务"，只需要判断"开一条什么样的"——后者才是可选的 agent 介入点。
+2. **主观通路（需要 agent 判断，这是 P1 的 `ceo`/工具的用武之地）**：agent 在执行任务过程中发现的、**不在当前 task 描述范围内**的问题（比如 coder 顺手发现一个无关的历史 bug），需要一个**工具**让它"提一条新任务"而不是把不相关的修复硬塞进当前 task 的产物里。这是当前完全没有的能力。
+
+**必须先建的地基**——查完代码，发现比"包一层工具"更底层的东西还没有，得先排清楚三件事，顺序不能反：
+
+#### 地基 0（阻塞项）：`ceo` 现在物理上调不通这套 REST API
+
+`server/src/tools/tool-registry.js` 开头写得明明白白——**这是"Master Agent 工具注册中心"**，`[TOOL_CALL: xxx]` 这套 JSON 文本协议是 Master 专属的自定义解析层，`server/src/tools/devloop/` 下另有一套 DevLoop 专属的 tool-registry。`ceo` 这类普通 org node agent（走标准 Claude CLI 子进程）**两套都不属于**——它能用的只有 Claude CLI 原生的 Bash/curl，具体调用哪个接口靠 `tools.md` 里的**大白话 + curl 示例**（`task-planning/tools.md` 就是这个写法的范本）。所以"task-board-tools.js" 这个提法本身**不成立**——不需要新写一个 JS 工具模块，需要写的是一份 `system/agents/ceo/tools.md`（现在是空文件）。
+
+但更麻烦的是：`server/routes/company.js` 顶部 `router.use(requireAuth)`（14 行），**goals/tasks 全系列端点只认人类 JWT**，没有走 `agent-chat.js` 那样的 `requireAuthOrInternal`。也就是说，就算 `ceo` 的 `tools.md` 写得再clear，它发出的每一条 curl **现在都会静默 401**——这正是最近几个 commit（`d48425a` selfChat 自环漏带内部令牌、`9e58656` bin/lemon.js task report/dispatch 401）反复修的那一类坑，company.js 这次还没打这个补丁。**这是全部 P4 工作的前提阻塞项**，必须先给 goals/tasks 这组路由加上 `requireAuthOrInternal`（或者更收紧一点，只给这几条挂内部令牌白名单），agent 才有物理上调得通的可能。
+
+#### 地基 1：`POST /:companyId/tasks` 没有"草稿"模式，agent 提的任务会立刻烧预算
+
+现有 `POST /:companyId/tasks`（`company.js:2077`）建完 task 行**无条件紧接着调 `enqueueTaskRun` + `startNextIfSlotFree`**——语义是"下达即执行"，服务的是"人类/外部 agent 派工"这个存量场景（代码注释原话："存量调用方的心智是下达即执行"）。这条路径不适合 `ceo` 自主提的新任务：`task-planning` 拆出来的 task 尚且要先落 `draft`、人点"全部下达"才转 `queued`（P3C §四.9 的既定哲学——"一次 LLM 猜测直接烧 5 份预算"是要避免的事），`ceo` 一次判断失误直接把新任务怼进队列烧钱，风险比 task-planning 更高（task-planning 只在 goal 刚建时跑一次，`ceo` 是持续在线判断）。
+
+**需要的改动很小**：给 `POST /:companyId/tasks` 加一个 `draft: true`（或 `status: 'draft'`）入参，为真时只调 `wdb.createTask()` 落库，跳过 `enqueueTaskRun`/`markGoalDispatched`/`startNextIfSlotFree` 三步，返回 `status: 'draft'`。已有的 `POST /:companyId/tasks/:taskId/enqueue`（`company.js:2275`，`draft → queued`）原样复用，不用新建。默认行为（不传这个参数）完全不变，纯加法，不影响存量调用方。
+
+#### 地基 2：`ceo` 的 `tools.md` 写什么
+
+在地基 0/1 落地后，照抄 `task-planning/tools.md` 的写法（先说"大概率不需要工具"、给出何时才用、给出 curl 示例、专辟一节"你不该用的工具"防止越权）给 `ceo` 写一份，覆盖：
+
+- **读**：`GET /:cid/goals?status=active`（扫哪些 goal 在跑）、`GET /:cid/tasks?status=blocked` / `?status=failed`（找卡住的）、`GET /:cid/goals/:goalId`（看某 goal 下全部 task + run 摘要）
+- **写**：`PATCH /:cid/tasks/:taskId`（改 `priority`）、`POST /:cid/tasks`（带 `draft:true`，提新任务）、`POST /:cid/tasks/:taskId/enqueue`（把自己或别人提的草稿正式下达——这一步要不要也留给人类点，是个开放问题，见 §四）
+- **明确不该用**：`org-graph/replan`、招聘类端点（这些是 HR/`orggraph-planning` 的事，`ceo` 判断"缺角色"之后应该是发通知/提 task，不是自己动手改组织结构）
+
+#### 确定性通路（routeFailure 里那条规则）不走这套 REST
+
+30 号文档四分类里"显然该开新任务"的情形（比如 `spec_ambiguous` 重试超阈值），是 `graph-engine.js` 服务端内部代码，**直接调 `wdb.createTask()`**（同进程函数调用），不必经过 HTTP、不必带内部令牌，落库同样是 `draft`。这条通路和 `ceo` 的 agent 通路是并行的两条腿，共享同一个"落 draft、不自动下达"的规则，但触发方式不同（一个是引擎钩子里的确定性规则，一个是 agent 主观判断）。
+
+**先做地基 0（鉴权）→ 地基 1（draft 模式）→ 地基 2（`tools.md`），P1/P3 的 boss agent 才有事可干**——三步不做完，`ceo` 被心跳唤醒了也只能干瞪眼，或者干瞪眼都算好的，更可能是每次尝试都吃一个静默 401。
+
+---
+
+### P5：公司级目标代码目录（"接管已有工作目录"）
+
+**核实结论：这个能力在 DevLoop 层面已经完整实现，只是没有公司级默认值，也没有确认是否覆盖非 DevLoop 的执行路径。**
+
+`server/services/devloop/path-resolver.js` 的 `allocateProjectRoot()` 已支持三种模式（`server/routes/devloop.js` 建项目时传 `mode`/`target_path`）：
+
+| mode | 语义 | 现状 |
+|---|---|---|
+| `sandbox` | 自动分配到 `data/companies/{cid}/projects/{pid}/`（lemonboss 内部） | ✅ 已实现，默认值 |
+| `linked-new` | 用户指定一个**空/新建**的绝对路径作为项目根，登记进 `~/.devloop/linked-projects.json` | ✅ 已实现 |
+| `linked-existing` | 用户指定一个**已存在**的目录，接管为项目根 | ✅ **已实现，不是文件头注释说的"预留接口拒收"**——代码实测有完整校验：路径必须存在且是目录、不能已经是别的 DevLoop 项目（`project.json` 冲突检测）、若有 `.git` 必须 working tree 干净（防止 agent 的 `git add -A` 把用户脏改动卷进自动 commit）。文件头那句注释是过期文档，**建议顺手修正**。 |
+
+这正是用户要的"像 Claude Code 选工作目录一样接管一个已有目录"，**核心机制已经有**，且安全校验（黑名单敏感路径、git 干净树）已经比较完善。
+
+**org/work graph（非 DevLoop）路径已核实**，结论比预期更好也更麻烦，分开说：
+
+**好消息：不是两套系统**。`graph-engine.js` 有自己的 `ensureProjectRoot(ctx)`（3476 行），文件头注释写明"位置的分配**复用 DevLoop 的 `path-resolver.allocateProjectRoot`（sandbox 模式）**，不新造一套"——`allocateRunProjectRoot()`（3458 行）内部真的就是调 `require('./devloop/path-resolver').allocateProjectRoot({ company_id, mode: 'sandbox' })`。org-coder 类节点的交付物落点、`graph_files` 索引、`34号文档` 提到的"项目根"，指的都是这同一套机制，不是 `locator.taskDir`（那是 agent 自己的运行 cwd，`_applyRuntimeScope` 分配的，两者不是一回事——agent 在 `locator.taskDir` 里跑，但写产物是写去 `ctx.projectRoot`，这个区分在 `graph-engine.js` 3736 行的"越界写入"检测里能看到：写到项目根之外会被判越界）。**结论：P5 只需要改一处入口（`allocateRunProjectRoot`），不需要在 org graph 侧另建一套。**
+
+**坏消息：现在的分配粒度是"每个 root run 一份全新 sandbox"，不是"每个公司一份持久目录"**。`allocateRunProjectRoot()` 硬编码 `mode: 'sandbox'`，且**没有任何"复用已有项目根"的入参**——`ensureProjectRoot()` 的幂等只在**同一个 root run 内**成立（先读 `project-root.json` 再决定要不要新分配），跨 run（也就是跨 task）**永远分配一个新 `pid`**，哪怕是同一个公司、同一个 goal 下的两个 task，也会落进两个互不相干的空目录。这比"没法接管外部目录"更根本——现在**同一家公司自己的两个任务都不共享代码**，遑论接管一个外部已有仓库。
+
+**P5 真正要做的三件事**（比原先设想的"补个配置项"要深一层）：
+
+1. **公司级配置**：`company.json` 加 `target_dir`（绝对路径，可空）+ `target_mode`（`linked-new` / `linked-existing`，配了 `target_dir` 才有意义）。
+2. **改 `allocateRunProjectRoot(run)`**：读 `run.company_id` 对应的 `company.json.target_dir`。**配了就不再"每 run 分配新 pid"，而是所有该公司的 run 一律解析到同一个 `root_path`**（跳过 `path-resolver` 的 pid/registry 那一整套，直接返回固定路径，首次访问时按 `target_mode` 做一次 `linked-existing`/`linked-new` 的校验——现成的校验逻辑，`path-resolver.js` 261-310 行原样复用，只是只做一次，不是每个 run 各做一次）；没配 `target_dir` 就走现在的 `sandbox` 老路径，行为不变。
+3. **⚠️ 并发风险，必须在设计里显式处理**：一旦多个 task 共享同一个 `target_dir`，就与前面讨论过的"跨 task 并发"（`max_parallel_tasks > 1`）正面相撞——两个 coder agent 同时写同一个 git 仓库会冲突，`linked-existing` 现有的"进入时 working tree 必须干净"只是一次性校验，不是运行期互斥锁。**建议 v1 做法**：`company.json.target_dir` 非空时，该公司的 `max_parallel_tasks` 强制钉死为 1（在 `maxActiveRootRuns()` 里加一条：读到 `target_dir` 就忽略/覆盖用户配的 `max_parallel_tasks`），从根上排除并发写冲突，比引入 git worktree/分支合并那一整套复杂度便宜得多。`ponytail`: 这是刻意的简化，天花板是"一家公司同一时间只能有一个任务真正动代码"；真要多任务并发写同一个仓库，需要 git worktree + 完成时合并这一层，属于独立工作量，不在这次范围内。
+
+**建议**：P5 独立于 P1-P4 推进（数据面完全不相关），优先级可以更高——但工作量比最初评估要大一档，不是"公司级配置 + 一次核实"就完，是"公司级配置 + 改分配粒度 + 并发约束联动"三件套。
+
+---
+
+## 三、修订后的建议顺序
+
+用户原始顺序是 P1→P2→P3→P4，本文档建议倒过来做地基：
+
+```
+第一步：P4 地基 —— 建 task-board-tools（读写 goal/task 的 agent 工具）
+         + routeFailure 里接确定性的「四分类 → 自动开新 task」规则
+第二步：P1 收窄版 —— 给 ceo 配 heartbeat.md（监督规则，认新 goal/task 模型不是旧 OKR）
+         + 挂上第一步的工具
+第三步：P3 收窄版 —— 心跳只做异常判断，事件触发优先、轮询兜底、绝不重做调度
+第四步：P4 完整版 —— 把「主观判断要不要开新 task」的部分交给已经装好工具的 ceo
+第五步：P2（UI） —— 独立任务看板页面，随时可插入，风险最低
+并行轨：P5 —— 公司级默认 target dir 配置 + 核实 org graph 交付物落点是否需要同样机制
+```
+
+理由：P1/P3 的 boss agent 在 P4 地基建好之前没有可操作的对象；P2 是纯 UI，不卡任何人；P5 数据面独立，可以完全并行推进。
+
+---
+
+## 四、开放问题（已拍板，2026-08-30）
+
+1. ~~`ceo` 会不会和已有流水线角色冲突~~ **已核实排除**：`system/org-graph-templates/{dev,content,ops}.json` 三份模板全文搜索 `ceo`，零命中——`ceo` 现在没有出现在任何一张图里，是完全没被使用的孤儿本体。给它加监督职责没有冲突。
+2. **P4 确定性通路新开 task 的 `report_to`：继承原 goal 的 `report_to`**。`okr_node_id` 不用单独决定——它按 P3C §四.7 既定规则只挂在 `goals` 表，新 task 挂在同一个 `goal_id` 下自动沿用该 goal 的 OKR 归属，不存在"新开一份"的问题。
+3. **心跳成本策略：事件触发为主 + 低频兜底轮询**（不加"异常持续够久才唤醒"的抖动过滤，先简单落地）。主路径挂在 `transitionRun` 等既有钩子上，异常状态一出现就唤醒；另加一个量级在 30 分钟左右的低频轮询兜底，防钩子覆盖不到的漏网情况——直接照抄 `task-scheduler.js` 头部注释里"兜底扫描周期"那个既有设计哲学，不重新发明。
+4. **`ceo` 可以全权自主 `enqueue` 自己提的 draft task，不需要等人类点**——这是五个选项里最激进的一档，明确高于 `task-planning`（§四.9 定案：产出永远先落 draft，人点"全部下达"）的自主权限。**这个选择意味着安全网必须落在别处，不能靠"人工审核"这一层**：落地时要确保 `max_parallel_tasks`（防止一次性并发太多）、`DEFAULT_TASK_BUDGET`（防止单任务无限烧钱）、goal 级 `org-validator` 收敛验收（防止"完成"了但没真正达成）这几道既有闸门都乘上了 `ceo` 自主创建的 task，不能因为创建路径变了就绕开——这几道闸门本来就是数据层/调度器层强制的（不挂在"谁创建的"这个字段上），照理天然覆盖，但落地时要专门写一条回归测试钉死这一点。
+5. **P5 org graph 交付物落点调研：已做完**，结论见 §二 P5 小节——不是两套系统（复用同一个 `path-resolver`），但分配粒度是"每个 task 一份全新 sandbox"，同公司任务之间都不共享代码，比预想的工作量更大，且与"跨 task 并发"直接联动，需要一条并发约束兜底。
+6. **P4 确定性通路的实际挂载点：已实现并确认（2026-08-30）**。文档原先设想挂在 DevLoop 的四分类（`spec_ambiguous`/`contract_mismatch`）上——但那是 DevLoop 专属词汇，`graph-engine.js` 的 `routeFailure` 用的是另一套（`impl_bug`/`input_underspecified`/`skill_defect`/`infra_flake`），根本没有这两个取值。实现时改挂在 `handleBackwardEdge` 的双层硬顶熔断（单边 `loop_count>3` 或 run 级 `backward_count>5` → `force_terminated`）上——**任何**原因导致的反复回退不收敛都触发，不按 `fail_reason` 精筛。**已确认维持这个实现，不额外收窄**。副作用是良性的：`infra_flake` 走的是完全独立的原地重跑代码路径（不经过 `handleBackwardEdge`），结构上天然不会触发这条自动开新任务的规则，不需要专门加排除逻辑。落点函数：`graph-engine.js` 的 `maybeProposeReplanTask()`，挂在 `handleBackwardEdge` 熔断分支里（约 2131-2133 行）。
+# 40-agent-chat-streaming-interrupt. Agent Chat 打字机平滑 + 打断-排队 + 串台加固
+
+> **日期**: 2026-08-30
+> **状态**: 📝 需求文档，讨论中，尚未实现
+> **触发**: 用户反馈"前端刷新不及时、没有打字机效果"，怀疑要不要把传输层从 HTTP 换成 WebSocket
+> 来解决打字机效果、多 Agent/多聊天切换、执行中无法打断这几个问题。经排查现状代码 +
+> 对照 [hermes-webui](file:///Users/yibo/Documents/lemonAI/hermes-webui)、
+> [hermes-agent](file:///Users/yibo/Documents/lemonAI/hermes-agent)、
+> [deepseek-harness](file:///Users/yibo/Documents/lemonAI/deepseek-harness) 三个参考实现，
+> 结论是**传输层不是瓶颈，不需要引入 WebSocket**——三个参考项目全部走 SSE/HTTP 流式，
+> 没有一个用 WebSocket。真正的差距是另外三件独立的事，本文档逐一给方案。
+
+---
+
+## 起因
+
+现状排查发现：LemonBoss 的 Agent Chat **已经是 SSE 流式**，不是普通 HTTP 一问一答——
+`web/src/views/AgentChat.vue:941` 用 `fetch().body.getReader()` 逐行解析
+`event:`/`data:`，后端 `server/routes/agent-chat.js:2542`（`POST /:agentId/chat`）用
+`setupSSE(res)` 把 Claude CLI 子进程吐出的 ACP `agent_message_chunk` 事件实时转发给前端。
+多聊天"串台"（切换 Agent 时旧流写串到新 Agent 状态里）已经在 `9b1c3f1` 修复：每个 Agent
+一份独立的 `chatStates` reactive 状态 + `requestAgentId` 快照，事件处理函数（`handleEvent`,
+`AgentChat.vue:991`）全程用 `isCurrent()` 校验"这条流是不是还对应当前选中的 Agent"。
+
+对照 hermes-webui（`api/gateway_chat.py` 的 `_stream_writeback_is_current`）和
+deepseek-harness（`interruptByParent`：中止当前 turn → 新消息进 FIFO → 排队执行），
+确认这套"per-stream id + is-current 校验"就是业界通用解法，LemonBoss 已经用对了模式，
+不需要换传输层来重新解决一遍。
+
+真正剩下的三个独立问题：
+
+1. **打字机不流畅**——不是传输问题，是 ACP chunk 粒度太粗（Claude CLI 一次吐一大段，不是
+   逐字/逐 token），SSE 本身能把这段文本秒级送达前端，但前端拿到手就是一大坨，没有"逐字吐出"
+   的观感。
+2. **执行中无法打断并接上新消息**——现状是"先 Stop 再发"两步操作，且发送框在
+   `chatState.sending` 为真时整个被 `disabled`（`AgentChat.vue:192`），物理上打不了字。
+   deepseek-harness 有专门的打断-排队状态机，LemonBoss 没有。
+3. **串台已修，但没有回归测试兜底**——`9b1c3f1` 是一次性修复，`isCurrent()` 校验散落在
+   `handleEvent` 十几个分支里，没有测试盯着，将来改动容易在某个分支漏掉校验又退回去。
+
+---
+
+## 一、现状代码地图（后续设计都基于这份）
+
+| 组件 | 位置 | 现状行为 |
+|------|------|----------|
+| 前端发送/接收 | `AgentChat.vue:908-969`（`handleSend`） | `fetch()` 开流，`st.sending=true` 期间 textarea `disabled`（`:192`），流结束才 `sending=false` |
+| 前端事件分发 | `AgentChat.vue:991-1042`（`handleEvent`） | 按 `requestAgentId === agentId.value` 做 `isCurrent()` 校验，非当前 Agent 的流只落状态不刷 UI |
+| 后端 SSE 入口 | `agent-chat.js:2542`（`POST /:agentId/chat`） | 每次请求 `while(loopCount<10)` 循环喂 prompt 给 ACP 协议，`onUpdate` 把 `agent_message_chunk` 原样透传成一条 SSE `agent_output` 事件 |
+| 后端并发闸门 | `agent-chat.js:2552-2568`（`agentChatLocks`，键是 `agentId`） | 同一 Agent、**不同** convId 并发请求直接 `429` 拒绝；同一 Agent、**相同** convId 的并发请求**不会**被这段拒绝——第二个请求会直接覆盖锁往下跑，等于两个循环同时喂同一个 ACP 会话。目前靠前端 `disabled` 挡住，服务端没有闸门（见下文风险①） |
+| 停止端点 | `agent-chat.js:1505`（`POST /:agentId/chat/:convId/stop`） | 调用 `closeSession(key, reason)`（`agent-chat.js:840`），即 `entry.protocol.disconnect()` 杀掉常驻 CLI 子进程，是"硬中止"，不接排队 |
+| 锁释放 | `agent-chat.js:2880`（`finally` 块） | 请求 handler 退出时统一 `agentChatLocks.delete(agentId)` + `res.end()`；中止后原请求是否会立刻走到这里，取决于 `protocol.disconnect()` 是否让 handler 内部 `await` 的 ACP 调用抛错——**需要在实现阶段用真实 CLI 验证一次**（见风险②） |
+
+---
+
+## 二、方案一：打字机平滑（两端都做）
+
+**根因**：ACP `agent_message_chunk` 的粒度由 Claude CLI 决定，一次可能带几十到几百字符，
+SSE 转发是逐 chunk 转发（`agent-chat.js:2628` `sendSSE('agent_output', ...)`），前端收到
+就是这一整段直接拼进 `st.streamContent`，没有二次拆分，所以观感是"一坨一坨蹦出来"而不是
+打字机。
+
+### 2.1 后端：转发前按字符数切片
+
+在 `agent-chat.js:2624` 的 `onUpdate` 里，把 `update.content.text` 按固定步长（比如 8-12
+字符一片）拆成多条 `sendSSE('agent_output', ...)`，而不是一次性整段发送。这是唯一需要碰
+后端的点，改动局限在这一个回调函数内，不影响日志落盘（`logMessageChunk` 仍然整段写，只是
+发给前端的部分被拆片）。
+
+### 2.2 前端：渲染节流缓冲
+
+在 `handleEvent` 收到 `agent_output` 时（`AgentChat.vue:1015`），不直接把整段 `data.message`
+拼进 `st.streamContent`，改成推进一个逐字符渲染队列，用 `requestAnimationFrame` 或
+`setInterval` 按固定速率（比如 30-50 字符/秒）从队列取字符追加显示。这样即使后端某次真的
+一次性吐了一大段（比如网络抖动攒批），前端也能把它"抹平"成匀速的打字机效果，不依赖后端切片
+的粒度是否稳定。
+
+两端都做的原因：后端切片解决"数据到达的最小单位太粗"，前端缓冲解决"到达节奏不均匀"（网络
+延迟、CLI 输出突发）——只做一端在极端情况下（比如后端切了片但网络一次性把好几个 SSE 事件
+一起送到）还是会看起来一卡一卡。
+
+---
+
+## 三、方案二：打断-排队状态机
+
+### 3.1 交互设计
+
+保留现有 **Stop 按钮**（`AgentChat.vue:193`，⏹）不变——纯中止，点了就是杀会话，不接后续。
+
+新增：**执行中解锁输入框**，允许在 `chatState.sending === true` 时继续打字。此时发送按钮
+的语义从"发送"变成"**打断并发送**"，两个操作在视觉上要能一眼区分开——用户分不清点了哪个，
+后果是"以为消息接上了，其实这轮直接被丢掉"：
+
+- **Stop 按钮**（`AgentChat.vue:193`，⏹）：图标/文案不变，补一句 tooltip「仅停止，不发送
+  新消息」。
+- **发送按钮在 sending 态下**：换一个视觉上明显不同的图标/配色（暖色调，区别于平时发送用的
+  主色），tooltip 改为「发送并打断当前回复」。
+- **打断成功后**，在对话记录里插入一条不打断阅读的**分隔标记**（细线 + 小字，类似
+  "— 已打断上一条回复 —"），让用户回看聊天记录时能看懂"上一条为什么没说完"——这是
+  ChatGPT / Claude.ai 自己在"stop and continue"场景下的通用做法。
+
+点击"打断并发送"后的具体流程：
+
+1. 前端把发送按钮切到"打断中…"状态，锁住重复点击（防止手速快连点两次触发两轮打断）；
+2. 调用现有 `stop` 端点（复用 `agent-chat.js:1505`，不新增中止路由，但要改内部实现，见
+   3.1.1）；
+3. 根据 `stop` 返回的 `cleaned` 字段决定下一步（见 3.1.1），确认可以安全发送后，把这条新
+   消息按**正常发送流程**投出去，带**同一个 convId**，接续同一个对话历史，并在发送成功后
+   插入上面说的分隔标记。
+
+这本质是"打断并立即顶替"，但工程实现上做成一个**深度为 1 的排队**（先确认上一个 turn 真的
+已经退出，再发新的），不是前端拿到点击事件就立刻并发发第二个请求——原因见风险①：
+服务端目前对"同一 convId 并发"没有闸门，真并发会导致两个循环同时写同一个 ACP 会话。
+
+#### 3.1.1 `stop` 端点改造：后端确认清理完成，而不是前端猜时间
+
+现状 `stop` 端点（`agent-chat.js:1505-1512`）调用 `closeSession` 后立刻同步返回，不代表
+原来那个 `/chat` 请求的 handler 已经真正退出（风险②）。改造成：
+
+- `stop` 端点内部在调用 `closeSession` 之后，轮询等待 `agentChatLocks` 里对应 `agentId`
+  的锁被清掉（即原请求走到 `agent-chat.js:2880` 的 `finally`），**预算 3 秒**（`closeSession`
+  杀子进程本身是毫秒级，慢的是原请求 `await` 被异常唤醒到走完 `finally` 这段，3 秒是给日志
+  flush 这类边缘情况留的余量，正常路径应该用不到）。
+- 3 秒内确认清理完成 → 返回 `{ success: true, cleaned: true }`，前端立刻发新消息，用户基本
+  感觉不到延迟。
+- 3 秒仍未确认（极端情况） → 返回 `{ success: true, cleaned: false }`（尽力而为，不算失败），
+  前端**不自动强发**（会撞回风险①的并发洞），而是在输入框附近给一条不遮挡输入的提示
+  「上一条还在收尾…」+ 一个「强制发送」按钮，把"要不要冒这个小概率风险"的决定权交还给用户，
+  而不是系统默默赌一把。
+
+### 3.2 需要新增/改动的点
+
+| 位置 | 改动 |
+|------|------|
+| `AgentChat.vue:192` | textarea 的 `:disabled="chatState.sending"` 改成允许 sending 态下继续输入；`autoResize`/`handleKeydown` 不受影响 |
+| `AgentChat.vue:194` | 发送按钮增加"sending 态下点击 = 打断并发送"分支，UI 上给一个过渡态（如按钮文案/图标切换) |
+| `AgentChat.vue:handleSend`（`:908`） | 抽出"等待上一个 turn 收尾"的等待逻辑，供打断分支复用 |
+| `agent-chat.js:2552-2568`（`agentChatLocks`） | **补上同 convId 并发闸门**（风险①，见下）——无论是否做打断功能，这都是一个已经存在、只是暂时没被前端触发到的并发 bug，建议顺带修 |
+| `agent-chat.js:1505`（stop 端点） | 改成内部轮询确认清理完成再返回，加 `cleaned: true/false` 字段，见 3.1.1 |
+
+### 3.3 风险 / 需要在实现阶段验证的点
+
+1. **同 convId 并发无闸门（现存 bug，非本次引入）**：`agent-chat.js:2554` 的判断是
+   `existingLock.convId !== convId` 才拒绝，同 convId 的第二个请求会直接覆盖锁往下跑。
+   目前靠前端 `disabled` 属性挡住，从没被服务端真正堵过。一旦解锁输入框，这条路径变得
+   可达，必须先补服务端闸门，否则用户手速快一点就能让两个循环同时喂同一个 ACP 会话（未定义
+   行为，轻则消息乱序，重则 CLI 子进程状态损坏）。
+2. **中止后原请求是否会及时退出，还未验证**：`closeSession` 只是 `protocol.disconnect()`，
+   原来那个还挂着 `await` 的 `POST /chat` 请求 handler 会不会因此立刻抛错走到
+   `finally`（`:2880`）释放锁、结束响应，取决于 `ClaudeCliProtocol` 底层对子进程异常退出的
+   处理方式。**已拍板的应对方案见 3.1.1**（`stop` 端点内部轮询 + 3 秒预算 + `cleaned` 字段
+   + 前端超时兜底按钮）；实现阶段仍需要用一次真实 Claude CLI 会话验证「中止后原请求平均/最坏
+   多久会真正退出」，如果实测远超 3 秒（比如需要等底层网络超时），要回来调整这个预算数字，
+   而不是改设计本身。
+
+---
+
+## 四、方案三：串台加固（回归测试）
+
+`9b1c3f1` 的修复方式是在十几个 `handleEvent` 分支里散落地加 `if (isCurrent) ...`，容易在
+未来新增分支时漏掉。建议补一个**前端组件级测试**（而不是走完整 E2E），思路：
+
+- 模拟两个 Agent 的 `chatStates`，对 Agent A 发起一次"慢"流（用假的 SSE 事件序列，中间插
+  延时），在流还没结束时把 `agentId.value` 切到 Agent B；
+- 断言 Agent A 后续到达的事件（`thinking` / `agent_output` / `tool_call` 等每一种 SSE
+  事件类型都要覆盖到）只更新了 `chatStates.get('A')`，不影响当前显示（Agent B 的视图）；
+- 反向断言：切回 Agent A 时，之前"憋住"没刷 UI 的内容应该已经正确落在 `chatStates.get('A')`
+  里，切回来就能看到完整历史，不丢消息。
+
+这条测试的价值不是证明现在没 bug（`9b1c3f1` 已经手工验证过），而是**卡住以后的回归**——
+后续如果给 `handleEvent` 加新的 SSE 事件类型，忘了包 `isCurrent()` 判断，测试会红。
+
+---
+
+## 五、不做的事（明确排除）
+
+- **不引入 WebSocket**。三个参考项目和 LemonBoss 现状都证明 SSE 足够，问题不在传输层。
+  真要引入 WebSocket 的场景是"没有聊天窗口打开时也要收到 Agent 的后台推送"（比如心跳异常
+  主动弹通知），这是一个不同的需求，不属于本文档范围，需要的话应该另开文档讨论。
+- **不做"多条消息同时排队"的完整 FIFO**。deepseek-harness 那套是为多 Agent
+  parent-child 场景设计的，LemonBoss 这里是单用户单会话打断，深度 1（"打断当前的，接上
+  新的"）已经覆盖需求，做完整队列是过度设计。
+
+---
+
+## 六、实施顺序建议
+
+三个方案彼此独立，互不阻塞，建议顺序（从风险低/收益快到风险高）：
+
+1. **方案三**（串台回归测试）——纯新增测试，零风险，先把安全网铺好。
+2. **方案一**（打字机平滑）——只碰渲染逻辑和一个转发回调，不改并发/状态机，风险最低。
+3. **方案二**（打断-排队）——涉及并发闸门（风险①必须先修）和状态机改造，且风险②需要真实
+   CLI 验证，建议放最后，且实现前先用一次真实 Claude CLI 会话验证"中止后原请求多久会退出"。
+
+## 七、已拍板的设计决策
+
+以下两点原本是未决问题，已确认，写在这里避免以后重新讨论一遍：
+
+1. **超时策略**：由后端 `stop` 端点内部确认清理完成（轮询 `agentChatLocks`），预算 **3 秒**；
+   超时不代表失败，返回 `cleaned: false`，前端不自动强发，展示「上一条还在收尾…」+ 手动
+   「强制发送」按钮，风险由用户显式承担，不做静默重试。详见 3.1.1。
+2. **UI 区分**：Stop 按钮和"sending 态下的发送按钮"必须视觉上可区分（图标/配色 + 不同
+   tooltip），打断成功后在对话记录里插入一条分隔标记，便于事后回看。详见 3.1。
+
+本文档目前没有遗留的未决问题；进入实现阶段后如果冒出新的（比如风险②实测的具体数字要调整
+预算），回来更新这一节。
+#!/usr/bin/env node
+/**
+ * backfill-ceo-hire.js —— 存量公司补雇 ceo
+ *
+ * 依据: docs/todo/system-design/39-boss-agent-task-supervision.md §二 P1「缺口 B」
+ *
+ * `ceo` 不在任何 org-graph-template 里，也没有自动招聘钩子——POST /api/company/create
+ * 这次起改成新建公司时固定雇一次，但存量公司不会补跑那条创建流程，需要这个脚本单独补雇。
+ *
+ * 幂等: hire() 本身按 company_agents 表判重（见 company-service.js:429），已经雇过的公司
+ * 会拿到 status='already_exists'，跳过不算失败，可重复执行。
+ *
+ * 用法:
+ *   node scripts/backfill-ceo-hire.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DATA_DIR = path.resolve(__dirname, '../data/companies');
+
+function main() {
+  const { CompanyService } = require('../server/services/company-service');
+  const companyService = new CompanyService();
+
+  if (!fs.existsSync(DATA_DIR)) {
+    console.log('[backfill-ceo-hire] data/companies/ 不存在，无需处理');
+    return;
+  }
+
+  const dirs = fs.readdirSync(DATA_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  let hired = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const d of dirs) {
+    const fp = path.join(DATA_DIR, d.name, 'company.json');
+    if (!fs.existsSync(fp)) continue;
+
+    try {
+      const result = companyService.hire(d.name, 'ceo', {});
+      if (result.status === 'already_exists') {
+        skipped += 1;
+      } else {
+        console.log(`[backfill-ceo-hire] ${d.name} → ceo（${result.status}）`);
+        hired += 1;
+      }
+    } catch (e) {
+      console.error(`[backfill-ceo-hire] ${d.name} 雇 ceo 失败: ${e.message}`);
+      failed += 1;
+    }
+  }
+
+  console.log(`[backfill-ceo-hire] 完成：新雇 ${hired} 家，跳过（已雇过）${skipped} 家，失败 ${failed} 家`);
+  if (failed > 0) process.exitCode = 1;
+}
+
+main();
@@ -173,6 +173,13 @@ async function start() {
             } catch (err) {
                 console.error('[Startup] 僵尸 goal 扫描启动失败:', err.message);
             }
+            // 39 号文档 P3：ceo 低频兜底扫描（30 分钟一次），补事件驱动唤醒（settleRootRun 里
+            // 那条）漏掉的 blocked task。同 startZombieGoalSweeper 的形状，挂在同一处。
+            try {
+                taskSettle.startCeoSweeper();
+            } catch (err) {
+                console.error('[Startup] ceo 兜底扫描启动失败:', err.message);
+            }
             // 27-P3C 批 3：任务队列。进程重启会丢掉所有在途的 setImmediate 唤醒
             // （队列钩子挂在 graph-run-sse.transitionRun 上，那是进程内的），
             // 于是重启后队里的任务会一直躺着 —— 界面上和「正在排队」一模一样，正是本批要消灭的症状。
@@ -1502,13 +1502,18 @@ router.delete(&#39;/:agentId/conversations/:convId&#39;, (req, res) =&gt; {
 });
  
 /** 停止当前正在生成的任务 */
-router.post('/:agentId/chat/:convId/stop', (req, res) => {
+// 40 号文档方案二（3.1.1）：中止后不能立刻同步返回——原来那个 /chat 请求的 handler
+// 是否已经走到 finally（释放 agentChatLocks、res.end()）还不确定，"打断并发送"要用这个
+// 信号判断能不能安全发第二条。这里轮询等最多 3 秒，超时不算失败，只是 cleaned:false，
+// 交给前端决定要不要"强制发送"。
+router.post('/:agentId/chat/:convId/stop', async (req, res) => {
   const { agentId, convId } = req.params;
   const key = `${agentId}:${convId}`;
-  if (closeSession(key, '用户手动中断')) {
-    return res.json({ success: true, message: 'Agent 已中断' });
+  if (!closeSession(key, '用户手动中断')) {
+    return res.json({ success: false, message: '未找到运行中的 Agent 进程' });
   }
-  res.json({ success: false, message: '未找到运行中的 Agent 进程' });
+  const cleaned = await waitForLockRelease(agentId);
+  res.json({ success: true, message: 'Agent 已中断', cleaned });
 });
  
 /** 读取 bootstrap file */
@@ -2537,7 +2542,17 @@ router.get(&#39;/:agentId/uploads/:convId/:filename&#39;, (req, res) =&gt; {
 // 同一 convId 的多轮对话不受限制（ACP 进程复用）
 // 32 号文档方案 B：这把锁挪到了共享模块 agent-session-lock.js，company.js 的招聘装配
 // 重试逻辑也要用同一把——两条路径各自维护一份的话，各自都以为自己没有并发。
-const { agentChatLocks, AGENT_LOCK_TIMEOUT } = require('../src/core/agent-session-lock');
+const { agentChatLocks, AGENT_LOCK_TIMEOUT, waitForLockRelease } = require('../src/core/agent-session-lock');
+
+// 40 号文档方案一：Claude CLI 一次 agent_message_chunk 可能带几十到几百字符，SSE 原样
+// 转发就是"一坨一坨蹦出来"，没有打字机效果。这里按固定步长切成小片再各发一条 SSE 事件——
+// 只影响推给前端的粒度，`logMessageChunk` 落盘的仍是整段，不受影响。
+const TYPEWRITER_CHUNK_SIZE = 10;
+function sliceForTypewriter(text, size = TYPEWRITER_CHUNK_SIZE) {
+  const pieces = [];
+  for (let i = 0; i < text.length; i += size) pieces.push(text.slice(i, i + size));
+  return pieces;
+}
  
 router.post('/:agentId/chat', async (req, res) => {
   const { message, conversationId: reqConvId } = req.body;
@@ -2549,16 +2564,21 @@ router.post(&#39;/:agentId/chat&#39;, async (req, res) =&gt; {
  
   const convId = reqConvId || `conv-${Date.now().toString(36)}`;
  
-  // 🔒 并发互斥检查：同一 Agent 不同 convId 的并发请求被拒绝
+  // 🔒 并发互斥检查：同一 Agent 的并发请求被拒绝——无论 convId 是否相同。
+  // 40 号文档风险①：这里原来只挡"不同 convId"，同一 convId 的第二个请求会直接
+  // 覆盖锁往下跑，等于两个循环同时喂同一个 ACP 会话（未定义行为）。此前一直靠前端
+  // textarea 的 disabled 属性挡住，从没被服务端真正堵过；"打断并发送"要解锁输入框，
+  // 这条路径就变得可达了，必须在这里把闸门补上。
   const existingLock = agentChatLocks.get(agentId);
-  if (existingLock && existingLock.convId !== convId) {
+  if (existingLock) {
     const elapsed = Date.now() - existingLock.startedAt;
     if (elapsed < AGENT_LOCK_TIMEOUT) {
       console.log(`[AgentChat] 🔒 拒绝 ${agentId} 并发请求 — 已有活跃会话 ${existingLock.convId} (${(elapsed / 1000).toFixed(0)}s)`);
       return res.status(429).json({
         error: `Agent ${agentId} 正在执行另一个会话 (${existingLock.convId})，请等待完成`,
         activeConvId: existingLock.convId,
-        elapsedMs: elapsed
+        elapsedMs: elapsed,
+        sameConversation: existingLock.convId === convId,
       });
     }
     // 超时释放
@@ -2625,7 +2645,9 @@ router.post(&#39;/:agentId/chat&#39;, async (req, res) =&gt; {
           console.log(`[SSE-DEBUG] 📤 agent_output (${update.content.text.length} chars)`);
           fullOutput += update.content.text;
           logMessageChunk(agentId, convId, update.content.text);
-          sendSSE('agent_output', { agent: agentId, message: update.content.text });
+          for (const piece of sliceForTypewriter(update.content.text)) {
+            sendSSE('agent_output', { agent: agentId, message: piece });
+          }
         } else if (update?.sessionUpdate === 'agent_thought_chunk' && update.content?.text) {
           logMessageChunk(agentId, convId, update.content.text);
           sendSSE('thinking', { message: update.content.text });
@@ -8,10 +8,14 @@ const express = require(&#39;express&#39;);
 const path = require('path');
 const fs = require('fs');
 const router = express.Router();
-const { requireAuth, INTERNAL_TOKEN, INTERNAL_TOKEN_HEADER } = require('../middleware/jwt-auth');
+const { requireAuth, requireAuthOrInternal, INTERNAL_TOKEN, INTERNAL_TOKEN_HEADER } = require('../middleware/jwt-auth');
  
 // 38 号文档 Phase 1：全站要求登录。
-router.use(requireAuth);
+// 39 号文档：goals/tasks 系列端点要给 agent（如 ceo 的心跳监督循环）用 curl 直接调，
+// agent 子进程没有用户 cookie，改用 requireAuthOrInternal（放行带对 INTERNAL_TOKEN 的自环
+// 调用，其余情况仍退回 requireAuth）——与 agent-chat.js 同一个模式，理由也相同：
+// 这个内部令牌只在本机进程树内有效，不落盘、不外泄，安全模型早已被 agent-chat.js 验证过。
+router.use(requireAuthOrInternal);
  
 const { CompanyService, listCompanyAgents, buildAgentDefinitionBrief, canAccessCompany } = require('../services/company-service');
 const { ScheduleService } = require('../services/schedule-service');
@@ -32,6 +36,14 @@ const scheduleService = new ScheduleService();
 // 404 而不是 403：不告诉调用方"这个 id 存在、只是不是你的"，直接当不存在处理。
 router.param('companyId', (req, res, next, companyId) => {
   const company = companyService.get(companyId);
+  // 39 号文档：内部自环调用（agent 用 INTERNAL_TOKEN 发起，比如 ceo 心跳查看/操作
+  // goal/task 板）没有"当前登录用户"这个概念，不能对它做归属校验——与
+  // agent-chat.js 的 :agentId param 中间件是同一处理方式（req.user.internal 直接放行）。
+  if (req.user?.internal) {
+    if (!company) return res.status(404).json({ error: `公司 ${companyId} 不存在` });
+    req.company = company;
+    return next();
+  }
   if (!canAccessCompany(company, req.user)) {
     return res.status(404).json({ error: `公司 ${companyId} 不存在` });
   }
@@ -146,6 +158,15 @@ router.post(&#39;/create&#39;, async (req, res) =&gt; {
       console.error('[Create] orggraph-planning 自动招聘失败（不影响公司创建）:', e.message);
     }
  
+    // 39 号文档 P1：固定雇一个 ceo，负责监督 goal/task 板（不进任何 org graph，
+    // 与 org-graph-template 选哪张无关，所以独立于上面那段的 bootstrap.status）。
+    // 同样遵守「任何失败都不能影响公司创建」的降级约定。
+    try {
+      companyService.hire(id, 'ceo', {});
+    } catch (e) {
+      console.error('[Create] ceo 自动招聘失败（不影响公司创建）:', e.message);
+    }
+
     res.json({ success: true, company, message: '公司已创建，正在由 orggraph-planning 自动规划组织结构（异步进行中）。' });
   } catch (err) {
     res.status(400).json({ error: err.message });
@@ -2146,6 +2167,22 @@ router.post(&#39;/:companyId/tasks&#39;, (req, res) =&gt; {
       throw err;
     }
  
+    // 39 号文档地基 1：draft:true 时只落库，不入队、不下达。服务的是 agent（如 ceo）
+    // 自主提的新任务——task-planning 拆出来的 task 尚且要先落 draft 等人点「全部下达」
+    // 才转 queued（P3C §四.9），agent 在线判断的风险不该比一次性拆分低。
+    // 落库后走既有 `POST /:companyId/tasks/:taskId/enqueue` 正式下达，不新建端点。
+    if (body.draft === true) {
+      return res.status(201).json({
+        success: true,
+        status: 'draft',
+        taskId: taskRow.id,
+        goalId: goal.id,
+        companyId,
+        task: description,
+        hint: `草稿已创建，未入队。调用 POST /api/company/${companyId}/tasks/${taskRow.id}/enqueue 正式下达。`,
+      });
+    }
+
     const launched = enqueueTaskRun({ companyId, taskRow, budget: body.budget || DEFAULT_TASK_BUDGET });
  
     markGoalDispatched(goal);
@@ -7,8 +7,10 @@
  *
  * 支持三种 mode（见 arch-project-root.html §②）：
  *   - sandbox       : 自动生成 root_path = `{dataDir}/companies/{cid}/projects/{pid}/`
- *   - linked-new    : 用户指定 root_path（绝对路径），注册到 ~/.devloop/linked-projects.json
- *   - linked-existing : v2，本文件预留接口但 register 阶段拒收
+ *   - linked-new    : 用户指定一个空/新建的 root_path（绝对路径），注册到 ~/.devloop/linked-projects.json
+ *   - linked-existing : 用户指定一个已存在的目录，接管为项目根，同样注册到 ~/.devloop/linked-projects.json
+ *                       （已实现，校验见 validateLinkedTarget：路径存在且是目录、未挂载过 DevLoop 项目、
+ *                       有 .git 则 working tree 必须干净）
  *
  * 详尽规格：docs/prd/newfunction/_spec/arch-project-root.md
  */
@@ -209,31 +211,28 @@ function isSensitivePath(abs) {
 }
  
 /**
- * 在文件系统上分配一个 root_path，但不写任何业务文件。
- * 仅 mkdir + 校验路径合法。
- * 业务文件（project.json / .gitignore / git init）由 LoopController.createProject 完成。
+ * `linked-new` / `linked-existing` 共用的校验逻辑，**不碰 registry / cache / pid**。
+ * 抽出来是因为 39 号文档的公司级 `target_dir` 机制也要用同一套校验（敏感路径黑名单、
+ * git 干净树……），但它是「一个公司固定一个目录，不进 DevLoop 的 pid 注册表」，
+ * 语义和 `allocateProjectRoot` 的 linked-* 分支（一对多、按 pid 登记）不同，不能直接复用
+ * 那个函数——于是只抽这一半（纯校验 + 解析 root_path），registry 写入留在调用方各自决定。
  *
- * @returns { pid, root_path, mode }
+ * @returns {string} 校验通过后的绝对 root_path
+ * @throws 校验失败：错误 message/code 与原 `allocateProjectRoot` 内联版本逐字一致，
+ *         不要在这里改措辞——外部可能已经在依赖具体的 error.code（如 DIRTY_WORKTREE）。
  */
-function allocateProjectRoot({ company_id, mode = 'sandbox', target_path }) {
-  if (!company_id) throw new Error('company_id required');
-
-  const pid = generatePid();
+function validateLinkedTarget(target_path, mode) {
+  if (!target_path) throw new Error(`target_path required for ${mode}`);
+  if (!path.isAbsolute(target_path)) {
+    throw new Error('target_path must be absolute');
+  }
+  if (isSensitivePath(target_path)) {
+    const e = new Error(`sensitive_path: ${target_path} is in blacklist`);
+    e.code = 'SENSITIVE_PATH';
+    throw e;
+  }
  
-  let root_path;
-  if (mode === 'sandbox') {
-    root_path = path.join(DATA_DIR, 'companies', company_id, 'projects', pid);
-    fs.mkdirSync(root_path, { recursive: true });
-  } else if (mode === 'linked-new') {
-    if (!target_path) throw new Error('target_path required for linked-new');
-    if (!path.isAbsolute(target_path)) {
-      throw new Error('target_path must be absolute');
-    }
-    if (isSensitivePath(target_path)) {
-      const e = new Error(`sensitive_path: ${target_path} is in blacklist`);
-      e.code = 'SENSITIVE_PATH';
-      throw e;
-    }
+  if (mode === 'linked-new') {
     // 父目录必须存在
     const parent = path.dirname(target_path);
     if (!fs.existsSync(parent)) {
@@ -248,26 +247,10 @@ function allocateProjectRoot({ company_id, mode = &#39;sandbox&#39;, target_path }) {
     } else {
       fs.mkdirSync(target_path, { recursive: false });
     }
-    root_path = path.resolve(target_path);
-    // 注册到 linked-projects
-    const reg = loadLinkedRegistry();
-    reg[pid] = {
-      root_path,
-      mode: 'linked-new',
-      company_id,
-      registered_at: new Date().toISOString(),
-    };
-    saveLinkedRegistry(reg);
-  } else if (mode === 'linked-existing') {
-    if (!target_path) throw new Error('target_path required for linked-existing');
-    if (!path.isAbsolute(target_path)) {
-      throw new Error('target_path must be absolute');
-    }
-    if (isSensitivePath(target_path)) {
-      const e = new Error(`sensitive_path: ${target_path} is in blacklist`);
-      e.code = 'SENSITIVE_PATH';
-      throw e;
-    }
+    return path.resolve(target_path);
+  }
+
+  if (mode === 'linked-existing') {
     if (!fs.existsSync(target_path)) {
       throw new Error(`target_path does not exist: ${target_path} (use linked-new for empty/new dir)`);
     }
@@ -279,7 +262,7 @@ function allocateProjectRoot({ company_id, mode = &#39;sandbox&#39;, target_path }) {
     if (fs.existsSync(path.join(target_path, 'project.json'))) {
       throw new Error(`target_path already contains a DevLoop project.json: ${target_path}`);
     }
-    // 已有 .git → 必须 working tree 干净（避免后续 Agent 的 git add -A 把用户脏改动扫进 DevLoop commit）
+    // 已有 .git → 必须 working tree 干净（避免后续 Agent 的 git add -A 把用户脏改动扫进自动 commit）
     if (fs.existsSync(path.join(target_path, '.git'))) {
       const { execFileSync } = require('child_process');
       let porcelain;
@@ -299,11 +282,35 @@ function allocateProjectRoot({ company_id, mode = &#39;sandbox&#39;, target_path }) {
         throw err;
       }
     }
-    root_path = path.resolve(target_path);
+    return path.resolve(target_path);
+  }
+
+  throw new Error(`unknown mode: ${mode}`);
+}
+
+/**
+ * 在文件系统上分配一个 root_path，但不写任何业务文件。
+ * 仅 mkdir + 校验路径合法。
+ * 业务文件（project.json / .gitignore / git init）由 LoopController.createProject 完成。
+ *
+ * @returns { pid, root_path, mode }
+ */
+function allocateProjectRoot({ company_id, mode = 'sandbox', target_path }) {
+  if (!company_id) throw new Error('company_id required');
+
+  const pid = generatePid();
+
+  let root_path;
+  if (mode === 'sandbox') {
+    root_path = path.join(DATA_DIR, 'companies', company_id, 'projects', pid);
+    fs.mkdirSync(root_path, { recursive: true });
+  } else if (mode === 'linked-new' || mode === 'linked-existing') {
+    root_path = validateLinkedTarget(target_path, mode);
+    // 注册到 linked-projects
     const reg = loadLinkedRegistry();
     reg[pid] = {
       root_path,
-      mode: 'linked-existing',
+      mode,
       company_id,
       registered_at: new Date().toISOString(),
     };
@@ -319,6 +326,25 @@ function allocateProjectRoot({ company_id, mode = &#39;sandbox&#39;, target_path }) {
   return { pid, root_path, mode };
 }
  
+/**
+ * 39 号文档「公司级目标代码目录」专用：校验并解析一个**固定**目录，
+ * 不生成 pid、不写 `~/.devloop/linked-projects.json`、不进 DevLoop 的项目列表。
+ * 语义是「这家公司所有 run 永远落这一个目录」，跟 DevLoop 「一对多、每个项目一个 pid」
+ * 的项目模型是两回事，故意不复用那套注册表——见 `validateLinkedTarget` 头部注释。
+ *
+ * 每次调用都会重新校验（包括 git 干净树检查），不缓存结果：目标目录的状态可能在
+ * 两次调用之间被人手动改过（比如两次任务之间用户自己提交了一次），下次分配前应该
+ * 重新确认一次，而不是信任上一次的结论。
+ *
+ * @returns {string} 校验通过后的绝对 root_path
+ */
+function resolveFixedTarget({ target_path, mode }) {
+  if (mode !== 'linked-new' && mode !== 'linked-existing') {
+    throw new Error(`unknown mode: ${mode} (must be linked-new | linked-existing)`);
+  }
+  return validateLinkedTarget(target_path, mode);
+}
+
 function unregisterLinkedProject(pid) {
   const reg = loadLinkedRegistry();
   if (reg[pid]) {
@@ -427,6 +453,8 @@ module.exports = {
   resolveMemoryDir,
   resolveCompanyDir,
   allocateProjectRoot,
+  resolveFixedTarget,
+  validateLinkedTarget,
   unregisterLinkedProject,
   listProjects,
   patchProjectMeta,
@@ -59,6 +59,9 @@ const {
   recordFile,
   // 27-P4 T4/T5：advanceBatch 批量拾取宽度的缺省值
   DEFAULT_MAX_CONCURRENCY,
+  // 39 号文档「确定性通路」：回退熔断收敛时顺手开一条 draft task，见 maybeProposeReplanTask
+  createTask,
+  getGoal,
 } = require('./work-graph-db');
  
 /**
@@ -2125,6 +2128,9 @@ function handleBackwardEdge(runId, def, nodeRun, edge, out, remediationNote = nu
       verdict: 'force_terminated', cap: out.loop.cap,
     }, { ref: edge.id });
     blockNode(runId, nodeRun.id, remediationNote);
+    // 39 号文档「确定性通路」：熔断收敛之后顺手把这个卡点回写成 goal/task 板上一条 draft
+    // task，不等 ceo 心跳才发现。best-effort，绝不能反过来影响上面已经做完的熔断收敛。
+    maybeProposeReplanTask(runId, rootRunId, nodeRun, def, remediationNote);
     return true;
   }
  
@@ -2155,6 +2161,52 @@ function handleBackwardEdge(runId, def, nodeRun, edge, out, remediationNote = nu
 }
  
 /**
+ * 39 号文档「确定性通路」：run 树级/单边回退熔断（force_terminated）收敛时，顺手在同一个
+ * goal 下开一条 draft task，把卡住的诊断信息交回 goal/task 板，而不是只留一个 blocked
+ * 节点等人翻控制台才发现。
+ *
+ * 只在根 run 触发一次（`runId === rootRunId`）：嵌套子图自己的回退熔断会先在子层
+ * blockNode，结论再沿子 run 边界冒泡成父层（org）节点的失败——冒泡到根时同一次「卡住」
+ * 只应该开一条 task，不是每层各开一条。
+ *
+ * 落库时机是 `draft`，不自动 enqueue（与 §四.9 task-planning 同一条哲学：这是一次
+ * 「猜」，不该自动花钱）；`report_to` 继承原 goal 的 `report_to`（§四.2 已拍板）。
+ *
+ * 纯 best-effort：任何一步查不到/写不进都吞掉，不能让「顺手开个 task」反过来打断
+ * 熔断收敛本身——熔断收敛是安全关键路径，这个不是。
+ */
+function maybeProposeReplanTask(runId, rootRunId, nodeRun, def, remediationNote) {
+  if (runId !== rootRunId) return;
+  try {
+    const db = getDb();
+    const task = db.prepare(`SELECT * FROM tasks WHERE current_run_id = ?`).get(rootRunId);
+    if (!task) return; // 这条 run 树当前不是任何 task 的 current_run_id（例如已被重跑顶替），不开
+    const goal = getGoal(task.goal_id);
+    if (!goal) return;
+
+    const d = def.nodes.get(nodeRun.def_node_id) || {};
+    const nodeName = d.name || nodeRun.def_node_id;
+    const reason = remediationNote || `节点 ${nodeName} 反复回退撞了熔断硬顶，未能收敛`;
+
+    createTask({
+      goalId: goal.id,
+      companyId: goal.company_id,
+      title: `[待重新规划] ${(task.title || task.description || goal.title || '').slice(0, 160)}`,
+      description: `任务 ${task.id}（${task.title || task.description || ''}）执行时在节点 `
+        + `${nodeName} 反复回退未能收敛，已停止自动重试。\n\n诊断：${reason}\n\n`
+        + `此任务由系统自动生成（草稿），需要人工或 ceo 审阅后决定：调整原任务描述重新下达，还是关闭。`,
+      executionMode: 'manual',
+      priority: goal.priority || 'P1',
+      reportTo: goal.report_to || null,
+      createdBy: 'system',
+    });
+  } catch (err) {
+    // best-effort：吞掉。上一步的熔断收敛（blockNode）已经做完，这里出错不影响主路径。
+    console.error('[graph-engine] maybeProposeReplanTask 失败（不影响熔断收敛）：', err.message);
+  }
+}
+
+/**
  * 解析跨层地址 → 「该退到哪个子 run 的哪一行」（**纯查询，不改任何状态**）。
  *
  * 输入的地址来自失败节点行的 `fail_node_ref`（三值透传的第四值，见 normalizeNodeRef 那段）。
@@ -3449,11 +3501,42 @@ function readProjectRootRecord(run) {
 }
  
 /**
+ * 39 号文档「公司级目标代码目录」：读 `company.json.target_dir`/`target_mode`。
+ *
+ * 走 `companyRootDir` 而不是 `company-service.get`——理由与 `work-graph-db.maxActiveRootRuns`
+ * 头部注释一致（那边的判据是这个仓库唯一持有者，这里只是同一份配置的第二个读者，
+ * 字段名必须逐字对齐，不能另起 camelCase）：`companyRootDir` 认 GRAPH_RUNS_DIR 测试覆盖，
+ * `company-service.get` 不认，用后者会导致设了 GRAPH_RUNS_DIR 的单测读到真仓库的
+ * `data/companies/`，撞上同名公司就读到真配置。
+ *
+ * 读不到 / 格式不对一律当没配（回落 sandbox），不抛错——目标目录是可选加成，
+ * 不能因为它读取失败就让整个项目根分配跟着炸。
+ */
+function readCompanyTargetConfig(companyId) {
+  if (!companyId) return null;
+  try {
+    const fp = path.join(companyRootDir(companyId), 'company.json');
+    if (!fs.existsSync(fp)) return null;
+    const cfg = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+    if (!cfg.target_dir || typeof cfg.target_dir !== 'string') return null;
+    const target_mode = cfg.target_mode === 'linked-new' ? 'linked-new' : 'linked-existing';
+    return { target_dir: cfg.target_dir, target_mode };
+  } catch {
+    return null;
+  }
+}
+
+/**
  * 真正在盘上开一个目录。
  *
  * GRAPH_RUNS_DIR 覆盖时项目根跟着走（`{RUNS_ROOT}/{rootRunId}/project`），理由与本文件
  * 顶部 RUNS_ROOT 那段注释完全一样：run 的产物被重定向到临时目录，项目根却还落在仓库
  * `data/companies/` 的话，测试每跑一次就往仓库里堆一个空项目目录。两处必须同源。
+ *
+ * 配了 `company.json.target_dir` 时，该公司**所有** run 解析到同一个固定 root_path，
+ * 不再走 sandbox 那套「每 run 一个新 pid」——39 号文档 P5：公司级目标代码目录。
+ * 校验失败（比如 git 树不干净）直接抛出，不静默降级回 sandbox：配错了必须看得见，
+ * 不能让 agent 写到一个跟用户预期不一样的空目录里却毫无察觉。
  */
 function allocateRunProjectRoot(run) {
   const runsRoot = runsRootOverride();
@@ -3462,6 +3545,13 @@ function allocateRunProjectRoot(run) {
     fs.mkdirSync(root_path, { recursive: true });
     return { pid: `p-run-${run.root_run_id}`, root_path, mode: 'runs-dir-override' };
   }
+  const targetCfg = readCompanyTargetConfig(run.company_id);
+  if (targetCfg) {
+    const root_path = require('./devloop/path-resolver').resolveFixedTarget({
+      target_path: targetCfg.target_dir, mode: targetCfg.target_mode,
+    });
+    return { pid: 'company-target', root_path, mode: targetCfg.target_mode };
+  }
   return require('./devloop/path-resolver').allocateProjectRoot({
     company_id: run.company_id, mode: 'sandbox',
   });
@@ -192,6 +192,12 @@ function settleRootRun(run, to) {
   if (taskStatus === 'blocked') {
     const why = describeRunBlock(run.id);
     if (why) wdb.noteTaskBlockedReason(run.task_id, run.id, why);
+
+    // 39 号文档 P3：blocked **不是**终态（下面 settleGoalIfAllTasksDone 也不会碰它），
+    // goal 因此不会收敛、`reportGoalOutcome` 那条唤醒 report_to 的路径也不会触发——
+    // 卡住的任务本来会一直静默躺着，直到有人自己点进控制台才发现（30 号文档点过名的
+    // 那个空白）。这里主动叫醒 ceo，不等它下一次心跳。best-effort，失败只打日志。
+    wakeCeo(run.company_id, why);
   }
  
   const task = wdb.getTask(run.task_id);
@@ -199,6 +205,39 @@ function settleRootRun(run, to) {
 }
  
 /**
+ * 39 号文档 P3：唤醒本公司的 ceo（事件驱动的主路径）。
+ * 与 company.js 的 triggerOrgGraphPlanning / 本文件 reportGoalOutcome 里唤醒 report_to
+ * 同一个模式：公司限定地址（`{companyId}:ceo`，本体只有一份，公司态按公司分）+
+ * INTERNAL_TOKEN 自环调用。发射后不等结果——这条不是收敛链路的一部分，晚几秒钟被
+ * ceo 看到不影响正确性，不值得为它拖慢 settleRootRun 的返回。
+ */
+function wakeCeo(companyId, reason) {
+  if (!companyId) return;
+  try {
+    const PORT = require('../config').port || 3010;
+    const { INTERNAL_TOKEN, INTERNAL_TOKEN_HEADER } = require('../middleware/jwt-auth');
+    const namespacedId = `${companyId}:ceo`;
+    fetch(`http://127.0.0.1:${PORT}/api/agent/${encodeURIComponent(namespacedId)}/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', [INTERNAL_TOKEN_HEADER]: INTERNAL_TOKEN },
+      body: JSON.stringify({
+        message: `[SYSTEM] 有一条 task 刚转入 blocked 状态：${reason || '（无详情）'}\n`
+          + `请查看 tools.md 里的读接口确认情况，判断是否需要提一条新任务或调整优先级。`,
+        conversationId: `ceo-wake-${companyId}-${Date.now().toString(36)}`,
+        isHeartbeat: true,
+      }),
+    })
+      .then((res) => {
+        if (!res.ok) console.error(`[CeoWake] 唤醒 ${namespacedId} 失败: HTTP ${res.status}`);
+      })
+      .catch((e) => console.error(`[CeoWake] 唤醒 ${namespacedId} 失败(网络): ${e.message}`));
+  } catch (e) {
+    // best-effort：唤醒失败不能影响调用方（settleRootRun）已经做完的状态回写。
+    console.error('[CeoWake] 唤醒 ceo 异常（不影响状态回写）:', e.message);
+  }
+}
+
+/**
  * goal 级收敛：这个 goal 的 task 是不是都到终态了？是则定判词并做**一次**对外汇报。
  *
  * 状态口径：
@@ -642,6 +681,50 @@ function stopZombieGoalSweeper() {
   zombieSweepTimer = null;
 }
  
+/**
+ * 39 号文档 P3：ceo 低频兜底扫描。`settleRootRun` 里的事件驱动唤醒（task 转 blocked 那一刻）
+ * 是主路径，这里只补漏——进程重启、fetch 失败、或本来就没接住那次转换。量级放到 30 分钟，
+ * 不是主决策路径，照抄 `task-scheduler.js` 头部注释里"兜底扫描周期"那个设计哲学。
+ * 按 company_id 分组只叫醒一次，不逐条 task 叫（否则一家公司卡 5 条 task 就是 5 次心跳）。
+ */
+const CEO_SWEEP_INTERVAL_MS = Number(process.env.CEO_SWEEP_INTERVAL_MS) || 30 * 60 * 1000;
+let ceoSweepTimer = null;
+
+function sweepBlockedTasksForCeo() {
+  try {
+    const wdb = require('./work-graph-db');
+    const rows = wdb.getDb()
+      .prepare(`
+        SELECT company_id, COUNT(*) AS cnt, GROUP_CONCAT(id) AS ids
+          FROM tasks
+         WHERE archived_at IS NULL AND status = 'blocked'
+      GROUP BY company_id
+      `)
+      .all();
+    for (const r of rows) {
+      wakeCeo(r.company_id, `兜底扫描：本公司当前有 ${r.cnt} 条 blocked task（${r.ids}），`
+        + `事件驱动那条唤醒可能漏了，请查看。`);
+    }
+    return rows;
+  } catch (err) {
+    console.error(`[CeoWake] sweepBlockedTasksForCeo 异常: ${err.message}`);
+    return [];
+  }
+}
+
+/** 启动周期性 ceo 兜底扫描（unref，不拖着进程不退出）。幂等：重复调用只返回已有的计时器 */
+function startCeoSweeper(intervalMs = CEO_SWEEP_INTERVAL_MS) {
+  if (ceoSweepTimer) return ceoSweepTimer;
+  ceoSweepTimer = setInterval(sweepBlockedTasksForCeo, intervalMs);
+  if (typeof ceoSweepTimer.unref === 'function') ceoSweepTimer.unref();
+  return ceoSweepTimer;
+}
+
+function stopCeoSweeper() {
+  if (ceoSweepTimer) clearInterval(ceoSweepTimer);
+  ceoSweepTimer = null;
+}
+
 module.exports = {
   settleRootRun,
   settleGoalIfAllTasksDone,
@@ -649,6 +732,10 @@ module.exports = {
   sweepStuckActiveGoals,
   startZombieGoalSweeper,
   stopZombieGoalSweeper,
+  wakeCeo,
+  sweepBlockedTasksForCeo,
+  startCeoSweeper,
+  stopCeoSweeper,
   RUN_TO_TASK_STATUS,
   // 占位值不再是常量而是「前缀 + 唯一 token」，所以对外给的是前缀和判定函数：
   // 任何地方想认出「这条还没有结论」，都必须走 isPendingVerdict，别再去比字符串相等。
@@ -102,17 +102,34 @@ function warnMaxParallelOnce(companyId, raw, why) {
 function maxActiveRootRuns(companyId) {
   if (!companyId) return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
   let raw;
+  let targetDir;
   try {
     const { companyRootDir } = require('./company-paths');
     const fp = require('path').join(companyRootDir(companyId), 'company.json');
     const fs = require('fs');
     if (!fs.existsSync(fp)) return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
-    raw = JSON.parse(fs.readFileSync(fp, 'utf-8')).max_parallel_tasks;
+    const cfg = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+    raw = cfg.max_parallel_tasks;
+    targetDir = cfg.target_dir;
   } catch (err) {
     // company.json 坏了不该让一次出队变成 500：回落缺省，但必须留声
     warnMaxParallelOnce(companyId, null, `读取失败（${err.message}），按 ${DEFAULT_MAX_ACTIVE_ROOT_RUNS} 处理`);
     return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
   }
+  // 39 号文档 P5：配了公司级目标代码目录（多个 run 共享同一份真实工作区）时，
+  // 强制把并行度钉死为 1，不管 max_parallel_tasks 配的是什么——`linked-existing`/
+  // `linked-new` 那道「进入时 working tree 干净」的校验只在分配那一刻查一次，
+  // 不是运行期互斥锁，两个 coder agent 同时写同一个 git 仓库会真的冲突。
+  // ponytail: 天花板是「配了 target_dir 的公司同一时间只能有一个任务真正动代码」；
+  // 真要多任务并发写同一仓库，需要 git worktree + 完成时合并那一层，是独立工作量。
+  if (typeof targetDir === 'string' && targetDir) {
+    const key = `${companyId}:target_dir`;
+    if (!warnedMaxParallel.has(key)) {
+      warnedMaxParallel.add(key);
+      console.warn(`[work-graph-db] company ${companyId} 配了 target_dir=${JSON.stringify(targetDir)}，并行度强制钉为 1（忽略 max_parallel_tasks=${JSON.stringify(raw)}）`);
+    }
+    return 1;
+  }
   if (raw === undefined || raw === null) return DEFAULT_MAX_ACTIVE_ROOT_RUNS;
   if (!Number.isInteger(raw) || raw < 1) {
     warnMaxParallelOnce(companyId, raw, `不是 ≥1 的整数，按 ${DEFAULT_MAX_ACTIVE_ROOT_RUNS} 处理`);
@@ -14,4 +14,21 @@
 const agentChatLocks = new Map(); // agentId → { convId, startedAt }
 const AGENT_LOCK_TIMEOUT = 30 * 60 * 1000; // 30 分钟安全阀，与原实现一致
  
-module.exports = { agentChatLocks, AGENT_LOCK_TIMEOUT };
+/**
+ * 40 号文档「打断-排队」用：中止一个 turn 之后，轮询等这把锁真正被清掉
+ * （即原请求的 handler 走到 finally），而不是前端凭感觉睡一个固定时长。
+ * 查不到锁本身也算"已清空"——用于 stop 端点在锁已经因为别的原因释放时仍能返回 cleaned:true。
+ */
+function waitForLockRelease(agentId, budgetMs = 3000, pollMs = 100) {
+  return new Promise((resolve) => {
+    const deadline = Date.now() + budgetMs;
+    const check = () => {
+      if (!agentChatLocks.has(agentId)) return resolve(true);
+      if (Date.now() >= deadline) return resolve(false);
+      setTimeout(check, pollMs);
+    };
+    check();
+  });
+}
+
+module.exports = { agentChatLocks, AGENT_LOCK_TIMEOUT, waitForLockRelease };
@@ -162,6 +162,70 @@ describe(&#39;pathResolver&#39;, () =&gt; {
     });
   });
  
+  describe('resolveFixedTarget（39 号文档：公司级目标代码目录，不进 registry）', () => {
+    it('linked-existing：校验通过时返回 root_path，不写 linked-projects registry', () => {
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'devloop-fixed-le-'));
+      fs.writeFileSync(path.join(dir, 'README.md'), '# user');
+      const before = fs.existsSync(pathResolver.LINKED_REGISTRY)
+        ? fs.readFileSync(pathResolver.LINKED_REGISTRY, 'utf8') : null;
+      const root = pathResolver.resolveFixedTarget({ target_path: dir, mode: 'linked-existing' });
+      expect(root).toBe(dir);
+      const after = fs.existsSync(pathResolver.LINKED_REGISTRY)
+        ? fs.readFileSync(pathResolver.LINKED_REGISTRY, 'utf8') : null;
+      expect(after).toBe(before); // registry 文件内容没变——没有 pid 被登记进去
+      expect(pathResolver.findProjectByPath(dir)).toBe(null); // 也没有进内存 cache
+    });
+
+    it('linked-existing：git 树不干净照样拒绝（复用同一套校验，报同一个 error.code）', () => {
+      const { execFileSync } = require('child_process');
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'devloop-fixed-dirty-'));
+      execFileSync('git', ['init', '-q', '-b', 'main'], { cwd: dir });
+      execFileSync('git', ['config', 'user.email', 't@l'], { cwd: dir });
+      execFileSync('git', ['config', 'user.name', 't'], { cwd: dir });
+      fs.writeFileSync(path.join(dir, 'a.txt'), 'one');
+      execFileSync('git', ['add', '-A'], { cwd: dir });
+      execFileSync('git', ['commit', '-q', '-m', 'init'], { cwd: dir });
+      fs.writeFileSync(path.join(dir, 'b.txt'), 'untracked');
+      let caught = null;
+      try {
+        pathResolver.resolveFixedTarget({ target_path: dir, mode: 'linked-existing' });
+      } catch (e) { caught = e; }
+      expect(caught).not.toBe(null);
+      expect(caught.message).toMatch(/uncommitted changes/);
+      expect(caught.code).toBe('DIRTY_WORKTREE');
+    });
+
+    it('linked-existing：路径不存在时报错，不静默创建/降级', () => {
+      const fake = path.join(os.tmpdir(), 'devloop-fixed-le-nope');
+      fs.rmSync(fake, { recursive: true, force: true });
+      expect(() =>
+        pathResolver.resolveFixedTarget({ target_path: fake, mode: 'linked-existing' })
+      ).toThrow(/does not exist/);
+      expect(fs.existsSync(fake)).toBe(false); // 没有被顺手 mkdir 出来
+    });
+
+    it('linked-new：空目录直接接受，同样不进 registry', () => {
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'devloop-fixed-new-'));
+      fs.rmSync(dir, { recursive: true, force: true }); // 留空壳测试「不存在则新建」
+      const root = pathResolver.resolveFixedTarget({ target_path: dir, mode: 'linked-new' });
+      expect(root).toBe(dir);
+      expect(fs.existsSync(dir)).toBe(true);
+      expect(pathResolver.findProjectByPath(dir)).toBe(null);
+    });
+
+    it('拒绝未知 mode', () => {
+      expect(() =>
+        pathResolver.resolveFixedTarget({ target_path: '/tmp/x', mode: 'sandbox' })
+      ).toThrow(/unknown mode/);
+    });
+
+    it('敏感路径黑名单同样生效', () => {
+      expect(() =>
+        pathResolver.resolveFixedTarget({ target_path: '/etc/whatever', mode: 'linked-existing' })
+      ).toThrow(/sensitive_path/);
+    });
+  });
+
   describe('resolveProjectRoot + 派生路径', () => {
     it('throws on unknown pid', () => {
       expect(() => pathResolver.resolveProjectRoot('p-nonexistent')).toThrow(/Unknown project/);
+/**
+ * 40 号文档方案二的两条后端回归：
+ *
+ * 1. 风险①：同一 agentId + 同一 convId 的并发请求过去完全没有闸门（`agentChatLocks` 的判断
+ *    只挡"不同 convId"），一直靠前端 textarea 的 disabled 属性挡住。"打断并发送"要解锁输入框，
+ *    这条路径就变得可达——两个循环同时喂同一个 ACP 会话是未定义行为。
+ * 2. `stop` 端点现在要等锁真正释放（或 3 秒预算到期）才返回，`cleaned` 字段供前端判断
+ *    能不能安全发第二条。
+ */
+process.env.LEMONBOSS_CLAUDE_MODE = 'mock';
+process.env.AGENT_SESSION_IDLE_MS = '60000';
+
+import { describe, it, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import express from 'express';
+import { createRequire } from 'node:module';
+
+const require_ = createRequire(import.meta.url);
+const ROOT = path.resolve(__dirname, '../../..');
+const AGENT = 'zz-chat-interrupt';
+const BODY = path.join(ROOT, 'system', 'agents', AGENT);
+
+function clearRuntimeState() {
+  for (const d of ['conversations', '_global', 'memory']) {
+    fs.rmSync(path.join(BODY, d), { recursive: true, force: true });
+  }
+}
+
+describe('agent-chat · 打断-排队（40 号文档）', () => {
+  let base, srv;
+
+  beforeAll(async () => {
+    clearRuntimeState();
+    fs.mkdirSync(BODY, { recursive: true });
+    fs.writeFileSync(path.join(BODY, 'config.json'), JSON.stringify({ id: AGENT, type: 'skill', name: AGENT, status: 'active' }, null, 2));
+    fs.writeFileSync(path.join(BODY, 'identity.md'), `# ${AGENT}\n`);
+    fs.writeFileSync(path.join(BODY, 'agent.md'), '# 打断-排队单测用的常驻本体\n');
+
+    const app = express();
+    app.use(express.json());
+    app.use('/api/agent', require_('../../routes/agent-chat'));
+    await new Promise((r) => { srv = app.listen(0, '127.0.0.1', () => { base = `http://127.0.0.1:${srv.address().port}`; r(); }); });
+  });
+
+  afterAll(async () => {
+    if (srv) await new Promise((r) => srv.close(r));
+    clearRuntimeState();
+  });
+
+  afterEach(() => vi.restoreAllMocks());
+
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+  it('同一 convId 的第二个请求在第一个还没跑完时会被 429 拒绝，不会两个循环同时跑', async () => {
+    const conv = 'race-same-conv';
+    const { ClaudeCliProtocol } = require_('@mas/acp-core');
+    const original = ClaudeCliProtocol.prototype.sendPrompt;
+    // 拖住第一个请求，制造一个真实的并发窗口
+    vi.spyOn(ClaudeCliProtocol.prototype, 'sendPrompt').mockImplementation(function (...args) {
+      return sleep(300).then(() => original.apply(this, args));
+    });
+
+    const first = fetch(`${base}/api/agent/${AGENT}/chat`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: 'first', conversationId: conv }),
+    });
+    await sleep(50); // 确保 first 已经进了 handler、拿到了锁
+    const second = await fetch(`${base}/api/agent/${AGENT}/chat`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: 'second', conversationId: conv }),
+    });
+
+    expect(second.status).toBe(429);
+    const body = await second.json();
+    expect(body.sameConversation).toBe(true);
+
+    const firstRes = await first;
+    await firstRes.text(); // 读完流，等 finally 跑完
+  });
+
+  it('stop 之后：锁在预算内释放，返回 cleaned:true', async () => {
+    const conv = 'stop-cleaned';
+    const chatDone = fetch(`${base}/api/agent/${AGENT}/chat`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: 'ping', conversationId: conv }),
+    }).then(r => r.text());
+
+    await sleep(50); // 等它先跑起来、拿到锁
+    const stopRes = await fetch(`${base}/api/agent/${AGENT}/chat/${conv}/stop`, { method: 'POST' });
+    const stopBody = await stopRes.json();
+    expect(stopBody.success).toBe(true);
+    expect(stopBody.cleaned).toBe(true);
+
+    await chatDone;
+  });
+
+  it('stop 之后立刻发同一个 convId 的新消息不会被 429 拒绝（cleaned 确认过锁已释放）', async () => {
+    const conv = 'stop-then-resend';
+    const chatDone = fetch(`${base}/api/agent/${AGENT}/chat`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: 'ping', conversationId: conv }),
+    }).then(r => r.text());
+
+    await sleep(50);
+    const stopRes = await fetch(`${base}/api/agent/${AGENT}/chat/${conv}/stop`, { method: 'POST' });
+    const { cleaned } = await stopRes.json();
+    expect(cleaned).toBe(true);
+
+    const resendRes = await fetch(`${base}/api/agent/${AGENT}/chat`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: 'resend', conversationId: conv }),
+    });
+    expect(resendRes.status).toBe(200);
+    await resendRes.text();
+    await chatDone;
+  });
+});
+/**
+ * Unit Tests — graph-engine 的公司级目标代码目录（39 号文档 P5）
+ *
+ * 验的是 `ensureProjectRoot` 在配了 `company.json.target_dir` 时的行为：
+ *   T1 没配 target_dir：走老的 sandbox 路径，行为不变（零回归）
+ *   T2 配了 target_dir：两个不同 root_run_id 的 run（同一公司）解析到同一个 root_path
+ *   T3 target_dir 校验失败（git 树不干净）：ensureProjectRoot 优雅降级成 null + timeline 记录，
+ *      不静默 fallback 回 sandbox
+ *   T4 GRAPH_RUNS_DIR 测试覆盖优先级高于 target_dir（不能让业务配置绕过测试隔离）
+ *
+ * `ensureProjectRoot` 本身不碰 SQLite（只读写文件系统），所以不需要像
+ * graph-boundary.test.js 那样做 GRAPH_DB_PATH 隔离；但会真的往 `data/companies/` 写
+ * 东西（company.json 走 companyRootDir，不认测试注入，除非设 GRAPH_RUNS_DIR——T1-T3
+ * 就是要验「不设 GRAPH_RUNS_DIR 时的生产行为」，所以只能用真路径 + 用后即删，
+ * 手法同 path-resolver.test.js 的 sandbox 用例）。
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const engine = require('../../services/graph-engine');
+const { companyRootDir } = require('../../services/company-paths');
+
+describe('graph-engine 公司级目标代码目录（target_dir）', () => {
+  const cleanups = [];
+
+  afterEach(() => {
+    delete process.env.GRAPH_RUNS_DIR;
+    while (cleanups.length) {
+      const p = cleanups.pop();
+      try { fs.rmSync(p, { recursive: true, force: true }); } catch { /* best-effort */ }
+    }
+  });
+
+  function writeCompany(companyId, patch) {
+    const dir = companyRootDir(companyId);
+    fs.mkdirSync(dir, { recursive: true });
+    cleanups.push(dir);
+    fs.writeFileSync(path.join(dir, 'company.json'), JSON.stringify({ id: companyId, name: companyId, ...patch }));
+    return dir;
+  }
+
+  function fakeRun(companyId, rootRunId) {
+    return { root_run_id: rootRunId, company_id: companyId };
+  }
+
+  it('T1 没配 target_dir：走 sandbox，行为跟改动前一样', () => {
+    const cid = 'tdcfg-t1';
+    writeCompany(cid, {});
+    const run = fakeRun(cid, 'r-t1');
+    const rec = engine.ensureProjectRoot({ run });
+    expect(rec).not.toBe(null);
+    expect(rec.mode).toBe('sandbox');
+    expect(rec.root_path).toContain(path.join('data', 'companies', cid, 'projects'));
+    expect(fs.existsSync(rec.root_path)).toBe(true);
+    cleanups.push(path.join(companyRootDir(cid), '..', 'runs')); // 无害；下面按 run 目录精确清
+    cleanups.push(path.dirname(path.dirname(rec.root_path))); // projects/ 目录
+    cleanups.push(path.join(companyRootDir(cid), 'runs', run.root_run_id));
+  });
+
+  it('T2 配了 target_dir：同一公司两个不同 run 解析到同一个 root_path，且不产生 pid 目录', () => {
+    const cid = 'tdcfg-t2';
+    const target = fs.mkdtempSync(path.join(os.tmpdir(), 'graph-engine-target-'));
+    cleanups.push(target);
+    fs.writeFileSync(path.join(target, 'README.md'), '# existing repo, no .git');
+    writeCompany(cid, { target_dir: target, target_mode: 'linked-existing' });
+
+    const runA = fakeRun(cid, 'r-t2-a');
+    const runB = fakeRun(cid, 'r-t2-b');
+    cleanups.push(path.join(companyRootDir(cid), 'runs', runA.root_run_id));
+    cleanups.push(path.join(companyRootDir(cid), 'runs', runB.root_run_id));
+
+    const recA = engine.ensureProjectRoot({ run: runA });
+    const recB = engine.ensureProjectRoot({ run: runB });
+
+    expect(recA).not.toBe(null);
+    expect(recB).not.toBe(null);
+    expect(recA.root_path).toBe(target);
+    expect(recB.root_path).toBe(target);
+    expect(recA.mode).toBe('linked-existing');
+    // 没有新的 sandbox pid 目录被造出来
+    const projectsDir = path.join(companyRootDir(cid), 'projects');
+    expect(fs.existsSync(projectsDir)).toBe(false);
+  });
+
+  it('T2b target_mode 缺省时按 linked-existing 处理（目标目录本来就该已经存在）', () => {
+    const cid = 'tdcfg-t2b';
+    const target = fs.mkdtempSync(path.join(os.tmpdir(), 'graph-engine-target-'));
+    cleanups.push(target);
+    writeCompany(cid, { target_dir: target }); // 不传 target_mode
+
+    const run = fakeRun(cid, 'r-t2b');
+    cleanups.push(path.join(companyRootDir(cid), 'runs', run.root_run_id));
+
+    const rec = engine.ensureProjectRoot({ run });
+    expect(rec.root_path).toBe(target);
+    expect(rec.mode).toBe('linked-existing');
+  });
+
+  it('T3 target_dir 校验失败（git 树不干净）：不静默降级回 sandbox，返回 null', () => {
+    const { execFileSync } = require('child_process');
+    const cid = 'tdcfg-t3';
+    const target = fs.mkdtempSync(path.join(os.tmpdir(), 'graph-engine-target-dirty-'));
+    cleanups.push(target);
+    execFileSync('git', ['init', '-q', '-b', 'main'], { cwd: target });
+    execFileSync('git', ['config', 'user.email', 't@l'], { cwd: target });
+    execFileSync('git', ['config', 'user.name', 't'], { cwd: target });
+    fs.writeFileSync(path.join(target, 'a.txt'), 'one');
+    execFileSync('git', ['add', '-A'], { cwd: target });
+    execFileSync('git', ['commit', '-q', '-m', 'init'], { cwd: target });
+    fs.writeFileSync(path.join(target, 'b.txt'), 'untracked, dirty tree');
+
+    writeCompany(cid, { target_dir: target, target_mode: 'linked-existing' });
+    const run = fakeRun(cid, 'r-t3');
+    cleanups.push(path.join(companyRootDir(cid), 'runs', run.root_run_id));
+
+    const rec = engine.ensureProjectRoot({ run });
+    expect(rec).toBe(null); // 优雅失败，不是编一个假 sandbox 路径
+
+    const projectsDir = path.join(companyRootDir(cid), 'projects');
+    expect(fs.existsSync(projectsDir)).toBe(false); // 确认真的没有偷偷退化成 sandbox
+  });
+
+  it('T4 GRAPH_RUNS_DIR 测试覆盖优先级高于 target_dir（测试隔离不能被业务配置绕过）', () => {
+    const cid = 'tdcfg-t4';
+    const target = fs.mkdtempSync(path.join(os.tmpdir(), 'graph-engine-target-override-'));
+    cleanups.push(target);
+    writeCompany(cid, { target_dir: target, target_mode: 'linked-existing' });
+
+    const runsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'graph-engine-runs-override-'));
+    cleanups.push(runsDir);
+    process.env.GRAPH_RUNS_DIR = runsDir;
+
+    const run = fakeRun(cid, 'r-t4');
+    const rec = engine.ensureProjectRoot({ run });
+    expect(rec.mode).toBe('runs-dir-override');
+    expect(rec.root_path).toBe(path.join(runsDir, run.root_run_id, 'project'));
+    expect(rec.root_path).not.toBe(target);
+  });
+});
@@ -752,6 +752,90 @@ describe(&#39;graph-engine&#39;, () =&gt; {
   });
  
   // ──────────────────────────────────────────────────────────────
+  // 39 号文档 P4「确定性通路」：回退熔断收敛时顺手开一条 draft task
+  // ──────────────────────────────────────────────────────────────
+  describe('回退熔断 · 确定性通路自动开新 task（39 号文档 §二 P4）', () => {
+    it('单边硬顶 force_terminated 时，会在同一个 goal 下新开一条 draft task，report_to 继承自 goal', async () => {
+      const companyId = nextCompany();
+      const goal = wdb.createGoal({
+        companyId,
+        title: '测试 goal',
+        description: '测试 goal 的描述',
+        priority: 'P2',
+        createdBy: 'human',
+        reportTo: 'some-upstream-agent',
+      });
+      const task = wdb.createTask({
+        goalId: goal.id,
+        companyId,
+        title: '测试 task',
+        description: '测试 task 的描述',
+        executionMode: 'auto',
+        priority: 'P2',
+        createdBy: 'human',
+      });
+
+      const { runId } = buildWorkRun({
+        companyId,
+        nodes: ['impl', 'check'],
+        edges: [
+          { from: 'impl', to: 'check' },
+          { from: 'check', to: 'impl', condition: 'fail', edgeKind: 'backward' },
+        ],
+        mode: 'auto',
+      });
+      // 让这条 run 看起来是「这条 task 当前的 run」——只有 runId === rootRunId 且
+      // current_run_id 指回它，maybeProposeReplanTask 才会触发（避免嵌套子图重复开）。
+      wdb.updateTask(task.id, { currentRunId: runId });
+
+      fakeExecutor({
+        impl: { status: 'success' },
+        check: { status: 'fail', remediationNote: '反复修不好' },
+      });
+
+      await engine.startRun(runId, { mode: 'auto' }).driver;
+
+      // 熔断收敛本身不受影响（既有断言的等价物）
+      expect(wdb.getRun(runId).run_status).toBe('blocked');
+
+      const tasksInGoal = wdb.listCompanyTasks(companyId, { goalId: goal.id, includeArchived: true });
+      expect(tasksInGoal).toHaveLength(2);
+      const created = tasksInGoal.find((t) => t.id !== task.id);
+      expect(created).toBeTruthy();
+      expect(created.status).toBe('draft');
+      expect(created.created_by).toBe('system');
+      // report_to 继承自 goal（39 号文档 §四.2 已拍板），不是继承自触发它的 task
+      expect(created.report_to).toBe('some-upstream-agent');
+      expect(created.description).toContain('反复修不好');
+    });
+
+    it('嵌套子图自己的回退熔断（runId !== rootRunId）不会新开 task——只在根 run 触发一次', async () => {
+      // buildWorkRun 建出的是顶层 run，rootRunId 本来就等于自己；这里改用
+      // 「run 不是任何 task 的 current_run_id」这条更好触发的早退路径验证同一条防重复保证：
+      // 没有匹配的 task 行，maybeProposeReplanTask 必须安静地什么都不做，不能抛错。
+      const companyId = nextCompany();
+      const { runId } = buildWorkRun({
+        companyId,
+        nodes: ['impl', 'check'],
+        edges: [
+          { from: 'impl', to: 'check' },
+          { from: 'check', to: 'impl', condition: 'fail', edgeKind: 'backward' },
+        ],
+        mode: 'auto',
+      });
+      fakeExecutor({
+        impl: { status: 'success' },
+        check: { status: 'fail', remediationNote: '再修一遍' },
+      });
+
+      await expect(engine.startRun(runId, { mode: 'auto' }).driver).resolves.not.toThrow();
+      expect(wdb.getRun(runId).run_status).toBe('blocked');
+      // 没有任何 task 挂这条 run，不应该凭空生出一条 task 来（company 下 tasks 表应仍为空）
+      expect(wdb.listCompanyTasks(companyId, {})).toHaveLength(0);
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────
   // §六 验收 9b：多边不架空熔断（R-16 发现的 3×N 漏洞）
   // ──────────────────────────────────────────────────────────────
   describe('回退熔断 · 多边不架空（§六 验收 9b / R-16）', () => {
@@ -44,8 +44,8 @@ describe(&#39;route-auth-gate（38 号文档 Phase 1）&#39;, () =&gt; {
     delete process.env.FORCE_REAL_AUTH;
   });
  
-  it('company.js 挂了 requireAuth', () => {
-    expectGated(require('../../routes/company.js'), requireAuth, 'company.js');
+  it('company.js 挂了 requireAuthOrInternal（39 号文档：goals/tasks 系列端点要给 agent 用 curl 直接调，比如 ceo 的心跳监督循环，不是普通 requireAuth）', () => {
+    expectGated(require('../../routes/company.js'), requireAuthOrInternal, 'company.js');
   });
  
   it('tasks.js 挂了 requireAuth', () => {
+/**
+ * Unit Tests — task 转 blocked 时主动唤醒 ceo（39 号文档 §二 P3，事件驱动主路径）
+ *
+ * 背景：blocked 不是终态，`settleGoalIfAllTasksDone` 不会碰它，goal 因此不会收敛，
+ * `reportGoalOutcome` 那条唤醒 report_to 的路径也不会触发——卡住的任务本来会一直静默
+ * 躺着，直到有人自己点进控制台才发现（30 号文档点过名的空白）。`settleRootRun` 现在
+ * 会在 blocked 回写之后顺手唤醒本公司的 ceo。
+ *
+ * 只验唤醒这一跳的逻辑（URL / header / body 形状），不验 agent-chat 真的收到消息之后
+ * 会做什么——那是 ceo 自己 tools.md / heartbeat.md 的行为，不在引擎测试射程内。
+ *
+ * 隔离手法与 task-blocked-reason.test.js 一致。
+ */
+import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
+import fs from 'fs';
+
+describe('task 转 blocked 唤醒 ceo（39 号文档 P3）', () => {
+  let wdb;
+  let settle;
+  const TEST_DB_PATH = '/tmp/test-blocked-ceo-wake.sqlite';
+  const files = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
+
+  beforeAll(() => {
+    for (const f of files) { try { fs.unlinkSync(f); } catch { /* 没有就算了 */ } }
+    process.env.GRAPH_DB_PATH = TEST_DB_PATH;
+    for (const m of [
+      '../../services/graph-db',
+      '../../services/org-graph-service',
+      '../../services/work-graph-db',
+      '../../services/graph-run-sse',
+      '../../services/task-settle',
+    ]) {
+      delete require.cache[require.resolve(m)];
+    }
+    wdb = require('../../services/work-graph-db');
+    settle = require('../../services/task-settle');
+  });
+
+  afterAll(() => {
+    for (const f of files) { try { fs.unlinkSync(f); } catch { /* 同上 */ } }
+    delete process.env.GRAPH_DB_PATH;
+  });
+
+  beforeEach(() => {
+    const db = wdb.getDb();
+    db.pragma('foreign_keys = OFF');
+    db.exec(`
+      DELETE FROM graph_run_nodes;
+      DELETE FROM graph_runs;
+      DELETE FROM tasks;
+      DELETE FROM goals;
+      DELETE FROM work_graph_edges;
+      DELETE FROM work_graph_nodes;
+      DELETE FROM work_graphs;
+      DELETE FROM system_agents;
+    `);
+    db.pragma('foreign_keys = ON');
+  });
+
+  let seq = 0;
+
+  /** 与 task-blocked-reason.test.js 的 scene() 同构：造出「一条 root run 正卡在某节点」 */
+  function scene() {
+    const companyId = `ceowake-co-${++seq}`;
+    const now = new Date().toISOString();
+    const db = wdb.getDb();
+    db.prepare(`
+      INSERT OR IGNORE INTO system_agents
+        (id, name, scope, owner_company_id, legacy_path, status, created_at, updated_at)
+      VALUES ('sdd-planning', 'sdd-planning', 'public', NULL, 'system/agents/sdd-planning', 'active', ?, ?)
+    `).run(now, now);
+
+    const graph = wdb.createWorkGraph({ companyId, nodes: ['sdd-planning'], edges: [] });
+    const goal = wdb.createGoal({ companyId, title: '做一个官网', description: '测试用' });
+    const task = wdb.createTask({
+      goalId: goal.id, companyId, title: '做一个官网', description: '测试用', executionMode: 'manual',
+    });
+    const run = wdb.createRun({
+      graphKind: 'work', graphId: graph.id, companyId, goalId: goal.id, taskId: task.id,
+      executionMode: 'manual', runStatus: 'running',
+    });
+    wdb.syncRunNodesToDef(run.id);
+    wdb.updateTask(task.id, { status: 'running', currentRunId: run.id, startedAt: now });
+
+    const nodeRow = db.prepare(`SELECT id FROM graph_run_nodes WHERE run_id = ?`).get(run.id);
+    db.prepare(`UPDATE graph_run_nodes SET status = 'blocked', fail_reason = 'boundary_escape', updated_at = ? WHERE id = ?`)
+      .run(now, nodeRow.id);
+
+    return { companyId, taskId: task.id, run: wdb.getRun(run.id) };
+  }
+
+  it('blocked 回写时会 fetch 唤醒 `{companyId}:ceo`，带上正确的内部令牌头', async () => {
+    const { companyId, run } = scene();
+    const { INTERNAL_TOKEN, INTERNAL_TOKEN_HEADER } = require('../../middleware/jwt-auth');
+
+    const calls = [];
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn((url, opts) => {
+      calls.push({ url, opts });
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    try {
+      settle.settleRootRun(run, 'blocked');
+      // wakeCeo 是发射后不等结果，让微任务队列跑一轮再断言
+      await new Promise((r) => setImmediate(r));
+    } finally {
+      global.fetch = originalFetch;
+    }
+
+    expect(calls).toHaveLength(1);
+    const [{ url, opts }] = calls;
+    expect(url).toContain(`/api/agent/${companyId}%3Aceo/chat`);
+    expect(opts.method).toBe('POST');
+    expect(opts.headers[INTERNAL_TOKEN_HEADER]).toBe(INTERNAL_TOKEN);
+    const body = JSON.parse(opts.body);
+    expect(body.message).toContain('blocked');
+    expect(body.isHeartbeat).toBe(true);
+  });
+
+  it('completed 回写不会唤醒 ceo（只有 blocked 才需要主动叫人）', async () => {
+    const { run } = scene();
+    const calls = [];
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn((url, opts) => { calls.push({ url, opts }); return Promise.resolve({ ok: true }); });
+
+    try {
+      // 先把节点状态改成 success，让 settleTaskFromRun 认成 completed
+      const db = wdb.getDb();
+      db.prepare(`UPDATE graph_run_nodes SET status = 'success', fail_reason = NULL WHERE run_id = ?`).run(run.id);
+      settle.settleRootRun(run, 'completed');
+      await new Promise((r) => setImmediate(r));
+    } finally {
+      global.fetch = originalFetch;
+    }
+
+    expect(calls).toHaveLength(0);
+  });
+
+  it('fetch 唤醒失败（网络异常）不影响 settleRootRun 的返回值 —— best-effort，不能拖垮主路径', () => {
+    const { run } = scene();
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn(() => Promise.reject(new Error('网络挂了')));
+
+    let result;
+    try {
+      result = settle.settleRootRun(run, 'blocked');
+    } finally {
+      global.fetch = originalFetch;
+    }
+
+    expect(result).toEqual({ task: 'blocked', goal: null });
+  });
+
+  it('低频兜底扫描 sweepBlockedTasksForCeo：按公司分组只唤醒一次，不逐条 task 叫', async () => {
+    const a = scene();
+    const b = scene();
+    // 同一家公司再卡一条 —— a.companyId 应该只被唤醒一次，不是两次
+    const db = wdb.getDb();
+    const now = new Date().toISOString();
+    const graph2 = wdb.createWorkGraph({ companyId: a.companyId, nodes: ['sdd-planning'], edges: [] });
+    const goal2 = wdb.createGoal({ companyId: a.companyId, title: '第二条', description: '测试用' });
+    const task2 = wdb.createTask({
+      goalId: goal2.id, companyId: a.companyId, title: '第二条', description: '测试用', executionMode: 'manual',
+    });
+    wdb.updateTask(task2.id, { status: 'blocked' });
+    // scene() 已经把 a/b 的 task 结算成 blocked（settleRootRun 还没跑，这里直接跑一次让状态落到位）
+    settle.settleRootRun(a.run, 'blocked');
+    settle.settleRootRun(b.run, 'blocked');
+
+    const calls = [];
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn((url) => { calls.push(url); return Promise.resolve({ ok: true }); });
+
+    try {
+      const rows = settle.sweepBlockedTasksForCeo();
+      await new Promise((r) => setImmediate(r));
+      const companiesSwept = rows.map((r) => r.company_id).sort();
+      expect(companiesSwept).toEqual([a.companyId, b.companyId].sort());
+      const aRow = rows.find((r) => r.company_id === a.companyId);
+      expect(aRow.cnt).toBe(2); // a 公司这次有 2 条 blocked task，但下面只应该 fetch 一次
+    } finally {
+      global.fetch = originalFetch;
+    }
+
+    const aCalls = calls.filter((u) => u.includes(`${a.companyId}%3Aceo`));
+    expect(aCalls).toHaveLength(1);
+  });
+});
+/**
+ * task-entry-draft-mode.test.js —— POST /:companyId/tasks 的 draft:true 分支（39 号文档地基 1）
+ *
+ * 现有 `POST /:companyId/tasks` 建完任务无条件立刻入队执行（"下达即执行"）。
+ * `draft:true` 时只应该落库，不应该 enqueue/start——服务的是 agent（如 ceo）自主提的新任务，
+ * 不该像 task-planning 一样先经过 draft 就自动花预算。
+ *
+ * 隔离手法与 graph-engine.test.js / company-goal-task-routes.test.js 一致：先设
+ * GRAPH_DB_PATH / GRAPH_RUNS_DIR 再 require，真实的 data/graph.sqlite、data/companies/ 全程不被碰。
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TEST_DB_PATH = '/tmp/test-task-entry-draft-mode.sqlite';
+const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
+const MODULES = [
+  '../../services/graph-db',
+  '../../services/work-graph-db',
+  '../../services/org-graph-service',
+  '../../services/graph-run-sse',
+  '../../routes/company',
+];
+
+const CID = 'draft-mode-test-co';
+
+let wdb;
+let orgSvc;
+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()];
+}
+
+function ensureAgents(ids) {
+  const db = wdb.getDb();
+  const now = new Date().toISOString();
+  const ins = 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', ?, ?)
+  `);
+  for (const id of new Set(ids)) ins.run(id, id, `system/agents/${id}`, now, now);
+}
+
+describe('POST /:companyId/tasks draft 模式（39 号文档地基 1）', () => {
+  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(), 'draft-mode-runs-'));
+    for (const m of MODULES) delete require.cache[require.resolve(m)];
+
+    wdb = require('../../services/work-graph-db');
+    orgSvc = require('../../services/org-graph-service');
+
+    const { CompanyService } = require('../../services/company-service');
+    origCompanyGet = CompanyService.prototype.get;
+    CompanyService.prototype.get = (companyId) =>
+      (companyId === CID ? { id: CID, name: CID, status: 'running' } : null);
+
+    // 一张最小 org graph：POST /tasks 建行前会先查「公司有没有 org graph」，没有直接 409，
+    // 这一步不是本文件要测的东西，先把它铺好。
+    ensureAgents(['org-planner', 'org-coder', 'org-validator']);
+    expect(
+      orgSvc.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);
+
+    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();
+    if (origCompanyGet) require('../../services/company-service').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 { /* ignore */ }
+    delete process.env.GRAPH_DB_PATH;
+    delete process.env.GRAPH_RUNS_DIR;
+    for (const m of MODULES) delete require.cache[require.resolve(m)];
+  });
+
+  it('draft:true → 201 + status draft，不落 runId，task 不入队（current_run_id 仍为空）', async () => {
+    const [status, body] = await call('POST', '/tasks', {
+      task: '（草稿）先别执行的一条任务',
+      draft: true,
+      created_by: 'ceo',
+    });
+
+    expect(status).toBe(201);
+    expect(body.status).toBe('draft');
+    expect(body.runId).toBeUndefined();
+    expect(body.taskId).toBeTruthy();
+    expect(body.hint).toContain(`/tasks/${body.taskId}/enqueue`);
+
+    const row = wdb.getTask(body.taskId);
+    expect(row.status).toBe('draft');
+    expect(row.current_run_id).toBeFalsy();
+    expect(row.created_by).toBe('ceo');
+  });
+
+  it('draft:true 建出的任务，之后走既有 /enqueue 端点能正常下达（不是死路）', async () => {
+    const [, created] = await call('POST', '/tasks', { task: '（草稿）待下达', draft: true });
+    const [status, body] = await call('POST', `/tasks/${created.taskId}/enqueue`);
+    expect(status).toBe(201);
+    expect(['queued', 'running'].includes(body.status)).toBe(true);
+
+    const row = wdb.getTask(created.taskId);
+    expect(['queued', 'running'].includes(row.status)).toBe(true);
+  });
+
+  it('默认行为不变：不传 draft 时仍然立刻入队/起跑（存量调用方不受影响）', async () => {
+    const [status, body] = await call('POST', '/tasks', { task: '正常下达一条任务' });
+    expect(status).toBe(201);
+    expect(body.status).not.toBe('draft');
+    expect(body.runId).toBeTruthy();
+  });
+});
@@ -587,6 +587,53 @@ describe(&#39;批 4 · 公司级执行位（max_parallel_tasks）&#39;, () =&gt; {
   });
  
   // ────────────────────────────────────────────────────────────────
+  // ⑤bis 39 号文档 P5：配了 target_dir 强制并行度=1，不管 max_parallel_tasks 说什么
+  // ────────────────────────────────────────────────────────────────
+  describe('⑤bis 公司级目标代码目录：target_dir 存在时并行度钉死为 1', () => {
+    /** 同一家公司同时配 target_dir 和一个 >1 的 max_parallel_tasks */
+    function setTargetDir(companyId, targetDir, maxParallel) {
+      const { companyRootDir } = require('../../services/company-paths');
+      const dir = companyRootDir(companyId);
+      fs.mkdirSync(dir, { recursive: true });
+      const cfg = { id: companyId, name: companyId, target_dir: targetDir };
+      if (maxParallel !== undefined) cfg.max_parallel_tasks = maxParallel;
+      fs.writeFileSync(path.join(dir, 'company.json'), JSON.stringify(cfg));
+      return companyId;
+    }
+
+    it('target_dir 非空 + max_parallel_tasks=5 → 仍然返回 1', () => {
+      const cid = setTargetDir(nextCompany(), '/tmp/some-shared-repo', 5);
+      expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+    });
+
+    it('没配 target_dir 时 max_parallel_tasks 照常生效（回归：这条改动不该动到没配的公司）', () => {
+      const cid = setMaxParallel(nextCompany(), 3);
+      expect(wdb.maxActiveRootRuns(cid)).toBe(3);
+    });
+
+    it('target_dir 留声一次（不静默），且是可读的一次性日志，不刷屏', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        const cid = setTargetDir(nextCompany(), '/tmp/shared-repo-log-test', 9);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+        expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(String(warn.mock.calls[0][0])).toContain('target_dir');
+      } finally {
+        warn.mockRestore();
+      }
+    });
+
+    it('运行期把 target_dir 清空后，恢复读 max_parallel_tasks（调用时读盘，不是缓存快照）', () => {
+      const cid = setTargetDir(nextCompany(), '/tmp/shared-repo-toggle', 4);
+      expect(wdb.maxActiveRootRuns(cid)).toBe(1);
+      setMaxParallel(cid, 4); // 覆写掉 target_dir
+      expect(wdb.maxActiveRootRuns(cid)).toBe(4);
+    });
+  });
+
+  // ────────────────────────────────────────────────────────────────
   // ⑥ DROP 迁移：存量库（带旧索引）启动一次就没了
   // ────────────────────────────────────────────────────────────────
   describe('⑥ 迁移：带 idx_graph_runs_one_active_root 的存量库', () => {
+# 心跳任务
+
+你收到的心跳消息会提"扫描全局 OKR 目标状态"——那是通用触发文案，对你不适用。
+你要看的是本公司的 **goal/task 板**（`tools.md` 里的读接口），不是 OKR。
+
+## 每次心跳
+
+- [ ] 查 `GET /tasks?status=blocked` 和 `?status=failed`，看有没有需要处理的
+- [ ] 查 `GET /goals?status=active`，扫一眼有没有明显该调整优先级的
+- [ ] 都正常就直接回复"心跳正常"，不要为了"用一下工具"而用工具
+
+## 发现问题时
+
+- 具体判断依据见 `tools.md` 的"什么时候该提新任务、什么时候该改优先级"一节
+- 新提的任务一律带 `draft:true`，判断确实清楚、值得马上跑再 `enqueue`
+- 不确定的情况，把观察写进正文回复，不要瞎猜着动手改数据
+
+## 不用管的
+
+- 正在排队 / 正在跑但没超时的 task——那是调度器的活，不用你盯
+- 纯技术性的失败（比如基础设施抖动）——引擎自己有重试和熔断机制
+# CEO 工具箱
+
+> 你的岗位是监督本公司的 goal/task 板（不是执行任务——`org-planner`/`org-coder`/`org-validator`
+> 那条流水线干活，你只看板、判断、必要时提一条新任务或调一下优先级）。
+>
+> 大部分心跳触发下，你**只需要读**：看一眼有没有 `blocked`/`failed` 太久的 task，正常就
+> 回复"心跳正常"，什么都不用调用。只有真发现问题时才用下面的写工具。
+
+---
+
+## 认证：每次调用都要带这个头
+
+```bash
+curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/goals" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
+```
+
+`LEMON_INTERNAL_TOKEN` 是你的进程环境变量里现成的（服务端 spawn 你的时候自动带上），
+不用去别处找、也不用自己生成。**忘了带这个头，所有请求都会 401**——先检查这个，
+不要一看到 401 就怀疑接口路径写错了。
+
+`<companyId>` 换成你自己所在的公司 id（就是你运行时坐标里那个 cid）。
+
+---
+
+## 读：先看板子上有什么
+
+### 看哪些 goal 在跑
+```bash
+curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/goals?status=active" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
+```
+
+### 找卡住的 task（这是你心跳时主要要查的）
+```bash
+curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/tasks?status=blocked" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
+curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/tasks?status=failed" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
+```
+
+### 看某个 goal 下全部 task + 每条 task 的当前 run 摘要
+```bash
+curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/goals/<goalId>" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
+```
+
+---
+
+## 写：只在真正判断需要时才用
+
+### 改一条 task 的优先级
+```bash
+curl -s -X PATCH "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/tasks/<taskId>" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"priority":"P0"}'
+```
+
+### 提一条新任务（草稿，不会立刻执行）
+```bash
+curl -s -X POST "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/tasks" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"goal_id":"<goalId>","task":"<这条新任务要做什么，写清楚，别人要能看懂>","draft":true}'
+```
+**必须带 `"draft":true`。** 不带的话这条任务会立刻入队执行——你的判断和 `task-planning`
+拆分一样，都是一次"猜"，不该自己直接烧预算。落库后返回一个 `taskId`。
+
+### 把你（或别人）提的草稿正式下达
+```bash
+curl -s -X POST "${LEMON_API_BASE:-http://localhost:3010/api}/company/<companyId>/tasks/<taskId>/enqueue" \
+  -H "x-internal-token: $LEMON_INTERNAL_TOKEN"
+```
+你被授权可以自主调这一步（不需要等人类点），但前提是你已经确认过这条草稿的描述是清楚、
+必要的——`enqueue` 之后就会真的排队执行、真的烧预算。判断依据不够就先别 enqueue，
+留着草稿等人类看到也行。
+
+---
+
+## 什么时候该提新任务、什么时候该改优先级
+
+- **一条 task 长时间 `blocked` 或 `failed`**（预算耗尽 / 依赖死锁 / 反复回退熔断）：看它的
+  `blocked_reason` 或诊断信息，判断是「原任务描述本身有问题，需要重新拆」还是「暂时的技术
+  问题，等修复」。前者提一条新任务说明清楚问题、把原 task 的教训写进 description；
+  后者不用你管，等基础设施问题解决会自动恢复。
+  （注意：某些"卡住已回退熔断"的情形系统会**自动**先开一条草稿任务——你去看板前可能已经
+  有一条 `created_by: 'system'` 的草稿在等你审了，先看有没有再决定要不要自己再开一条。）
+- **同一 goal 下多个 task 优先级冲突**（业务变化导致原定顺序不再合理）：改 `priority`，
+  不需要新建任务。
+- **`task-planning` 降级成单任务**（goal 描述里能看出"自动拆分失败，已按单任务下达"的
+  标注）：这种情况不要自己再拆一次——把情况记下来，正文回复里说明，等人类看一眼原始
+  goal 描述是不是本身就有歧义。
+
+---
+
+## 你不该用的工具
+
+| 工具 / 动作 | 为什么不该 |
+|---|---|
+| `POST /:companyId/org-graph/replan` | 改组织结构是 `orggraph-planning` 的事，不是你的判断范围 |
+| 任何招聘 / 解雇端点 | 公司缺角色是 HR 与 `orggraph-planning` 的活，你发现"缺人"应该提一条 task 说明缺口，不是自己动手改编制 |
+| 直接改 `graph_runs` / `graph_run_nodes`（没有这类端点，但如果你找到裸 SQL 或内部函数也一样不许碰） | 执行状态由引擎维护，你只通过 goals/tasks 这层 REST 接口操作 |
+| `POST /:companyId/tasks`（不带 `draft:true`） | 会立刻烧预算，见上面的强调 |
+# 打断-排队单测用的常驻本体
+{
+  "id": "zz-chat-interrupt",
+  "type": "skill",
+  "name": "zz-chat-interrupt",
+  "status": "active"
+}
 \ No newline at end of file
+# zz-chat-interrupt
@@ -4,7 +4,7 @@ export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    include: ['src/**/*.test.js', 'server/src/tests/**/*.test.js', 'server/tests/**/*.test.js', 'packages/**/*.test.js'],
+    include: ['src/**/*.test.js', 'server/src/tests/**/*.test.js', 'server/tests/**/*.test.js', 'packages/**/*.test.js', 'web/src/**/*.test.js'],
     coverage: {
       provider: 'v8',
       reporter: ['text', 'html'],
@@ -61,8 +61,8 @@
         <a :href="`/${currentCompany.id}/pipelines`" target="_blank" class="nav-link" :class="{ active: $route.params.tab === 'pipelines' || $route.params.tab === 'sop' }">
           ⚙️ SOP
         </a>
-        <a :href="`/${currentCompany.id}/goals`" target="_blank" class="nav-link" :class="{ active: $route.params.tab === 'goals' || $route.params.tab === 'okr' }">
-          🎯 OKR
+        <a :href="`/${currentCompany.id}/task-board`" target="_blank" class="nav-link" :class="{ active: $route.path.endsWith('/task-board') }">
+          🗂️ 任务看板
         </a>
         <a :href="`/${currentCompany.id}/files`" target="_blank" class="nav-link" :class="{ active: $route.params.tab === 'files' }">
           📁 Files
+/**
+ * 从 AgentChat.vue 抽出来的两块纯逻辑：
+ *
+ * 1. `createAgentChatEventHandler` —— SSE 事件分发器。只认 requestAgentId 是否等于
+ *    调用时刻"当前选中的 agent"，据此决定要不要触碰全局态（路由/对话列表/DOM 滚动）；
+ *    传入的 `st`（每个 agent 一份的状态）永远无条件更新，不受这个判断影响——这样切走
+ *    了不会打断/污染，切回来能看到完整的后台进度（9b1c3f1 修的就是这条不变式）。
+ *    抽成不依赖组件实例的纯函数，是为了能在不挂载整个 Vue 组件的前提下对它做回归测试
+ *    （40 号文档方案三）。
+ *
+ * 2. `createTypewriterQueue` / `flushTypewriter` —— 打字机渲染缓冲（40 号文档方案一）。
+ *    后端已经把大段文本切成小片再发 SSE，这里再加一层匀速吐出，抹平网络到达节奏不均匀
+ *    （突发多个 SSE 事件挤在一起）的情况。
+ */
+
+const TYPEWRITER_TICK_MS = 20;
+const TYPEWRITER_CHARS_PER_TICK = 2;
+
+/** 把新到的文本接到 st 的打字机队列尾部，并确保有一个定时器在匀速吐出 */
+export function createTypewriterQueue({ tickMs = TYPEWRITER_TICK_MS, charsPerTick = TYPEWRITER_CHARS_PER_TICK } = {}) {
+  return function pushChunk(st, text) {
+    if (!text) return;
+    st._typeQueue = (st._typeQueue || '') + text;
+    if (st._typeTimer) return; // 已经在吐了，接上队尾即可
+    st._typeTimer = setInterval(() => {
+      if (!st._typeQueue) {
+        clearInterval(st._typeTimer);
+        st._typeTimer = null;
+        return;
+      }
+      st.streamContent += st._typeQueue.slice(0, charsPerTick);
+      st._typeQueue = st._typeQueue.slice(charsPerTick);
+    }, tickMs);
+  };
+}
+
+/** 立刻把队列里剩下的字符吐光，用在"这轮已经结束/被打断，不用再演匀速"的时刻 */
+export function flushTypewriter(st) {
+  if (st._typeTimer) {
+    clearInterval(st._typeTimer);
+    st._typeTimer = null;
+  }
+  if (st._typeQueue) {
+    st.streamContent += st._typeQueue;
+    st._typeQueue = '';
+  }
+}
+
+/**
+ * @param {() => string} getCurrentAgentId 读取"用户当前选中的 agent id"
+ * @param {(requestAgentId: string, data: object, st: object) => void} onNewConversation
+ *   仅在 isCurrent 时调用：处理路由跳转 + 对话列表插入这类全局副作用
+ * @param {() => void} scrollToBottom
+ * @param {() => void} scrollAcpLog
+ * @param {() => void} scrollSubLogs
+ * @param {(st: object, text: string) => void} [pushChunk] 打字机队列的入队函数，默认新建一个
+ */
+export function createAgentChatEventHandler({
+  getCurrentAgentId,
+  onNewConversation,
+  scrollToBottom,
+  scrollAcpLog,
+  scrollSubLogs,
+  pushChunk = createTypewriterQueue(),
+}) {
+  return function handleEvent(st, requestAgentId, type, data) {
+    const isCurrent = getCurrentAgentId() === requestAgentId;
+    switch (type) {
+      case 'session':
+        if (data.conversationId && !st.activeConvId) {
+          st.activeConvId = data.conversationId;
+          if (isCurrent) onNewConversation(requestAgentId, data, st);
+        }
+        break;
+      case 'thinking':
+        if (data.message && !data.message.startsWith('🏗️')) {
+          st.thinkingContent += data.message;
+          if (isCurrent) scrollToBottom();
+        } else {
+          st.thinkingText = data.message || '思考中...';
+        }
+        break;
+      case 'agent_output':
+        st.streaming = true;
+        pushChunk(st, data.message || '');
+        if (isCurrent) scrollToBottom();
+        break;
+      case 'tool_call':
+        st.thinkingText = data.message || `🔧 ${data.tool}`;
+        st.acpLog.push({ type: 'tool', icon: '🔧', text: `${data.tool}`, ts: Date.now() });
+        if (isCurrent) scrollAcpLog();
+        break;
+      case 'tool_input':
+        st.acpLog.push({ type: 'input', icon: '📥', text: data.input?.slice(0, 300) || '', ts: Date.now() });
+        if (isCurrent) scrollAcpLog();
+        break;
+      case 'tool_result':
+        st.acpLog.push({ type: 'result', icon: '📤', text: data.result?.slice(0, 300) || '', ts: Date.now() });
+        if (isCurrent) scrollAcpLog();
+        break;
+      case 'session_cost':
+        st.acpLog.push({ type: 'cost', icon: '💰', text: `$${data.cost?.toFixed(4)} (${((data.duration || 0) / 1000).toFixed(1)}s)`, ts: Date.now() });
+        break;
+      case 'acp_raw':
+        if (data.method && !data.method.includes('content_block_delta') && !data.method.includes('message_start')) {
+          st.acpLog.push({ type: 'raw', icon: '⚡', text: data.method, ts: Date.now() });
+          if (isCurrent) scrollAcpLog();
+        }
+        break;
+      case 'sub_agent':
+        if (!st.subAgents[data.callId]) st.subAgents[data.callId] = { agent: data.agent, status: 'running', content: '', collapsed: false };
+        if (data.event === 'chunk' && data.chunk) {
+          st.subAgents[data.callId].content += data.chunk;
+          if (isCurrent) scrollSubLogs();
+        } else if (data.event === 'done') st.subAgents[data.callId].status = data.status;
+        else if (data.event === 'start') st.subAgents[data.callId].status = 'running';
+        if (isCurrent) scrollToBottom();
+        break;
+      case 'error':
+        st.messages.push({ role: 'assistant', content: `❌ ${data.message}`, timestamp: new Date().toISOString() });
+        st.acpLog.push({ type: 'error', icon: '🚨', text: data.message, ts: Date.now() });
+        st.thinkingText = '';
+        st.thinkingContent = '';
+        if (isCurrent) {
+          scrollToBottom();
+          scrollAcpLog();
+        }
+        break;
+    }
+  };
+}
+/**
+ * 回归测试：9b1c3f1 修的"多聊天串台"不变式（40 号文档方案三）。
+ *
+ * 不变式：handleEvent 收到的每一条事件都要无条件写进它自己的 st（每个 agent 一份），
+ * 但只有在事件所属的 requestAgentId 仍等于"用户当前选中的 agent"时，才允许触碰
+ * 全局副作用（路由跳转 / 对话列表 / DOM 滚动）。这条测试不需要挂载整个 Vue 组件——
+ * handleEvent 已经被抽成不依赖组件实例的纯函数（agentChatEvents.js），直接喂事件、
+ * 断言 st 内容和副作用回调的调用次数即可。
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { createAgentChatEventHandler, createTypewriterQueue, flushTypewriter } from './agentChatEvents.js';
+
+function makeState() {
+  return {
+    messages: [], activeConvId: null,
+    sending: false, streaming: false, streamContent: '',
+    subAgents: {}, subLogList: [], acpLog: [],
+    thinkingText: '', thinkingContent: '', showThinking: true,
+  };
+}
+
+describe('agentChatEvents · 串台加固', () => {
+  it('切走之后，旧 agent 的事件继续更新它自己的 st，但不再触发全局副作用', () => {
+    let current = 'agent-A';
+    const scrollToBottom = vi.fn();
+    const scrollAcpLog = vi.fn();
+    const onNewConversation = vi.fn();
+    const handleEvent = createAgentChatEventHandler({
+      getCurrentAgentId: () => current,
+      onNewConversation,
+      scrollToBottom,
+      scrollAcpLog,
+      scrollSubLogs: vi.fn(),
+      pushChunk: (st, text) => { st.streamContent += text; }, // 跳过打字机定时器，测同步内容
+    });
+
+    const stA = makeState();
+    handleEvent(stA, 'agent-A', 'session', { conversationId: 'conv-A' });
+    handleEvent(stA, 'agent-A', 'agent_output', { message: '你好' });
+    expect(scrollToBottom).toHaveBeenCalledTimes(1); // 只有 agent_output 会调 scrollToBottom
+    expect(onNewConversation).toHaveBeenCalledTimes(1); // session 走的是 onNewConversation
+
+    // 用户切到另一个 agent
+    current = 'agent-B';
+    scrollToBottom.mockClear();
+    scrollAcpLog.mockClear();
+
+    handleEvent(stA, 'agent-A', 'agent_output', { message: '，世界' });
+    handleEvent(stA, 'agent-A', 'tool_call', { tool: 'bash' });
+
+    // st 照常被写：内容没丢
+    expect(stA.streamContent).toBe('你好，世界');
+    expect(stA.acpLog).toHaveLength(1);
+    // 但不再是当前 agent，全局副作用一次都不该触发
+    expect(scrollToBottom).not.toHaveBeenCalled();
+    expect(scrollAcpLog).not.toHaveBeenCalled();
+
+    // 切回来之后，新事件恢复触发副作用，且历史内容完好
+    current = 'agent-A';
+    handleEvent(stA, 'agent-A', 'tool_call', { tool: 'grep' });
+    expect(scrollAcpLog).toHaveBeenCalledTimes(1);
+    expect(stA.acpLog).toHaveLength(2);
+  });
+
+  it('两个 agent 同时在跑，事件不会互相串台到对方的 st 里', () => {
+    let current = 'agent-A';
+    const handleEvent = createAgentChatEventHandler({
+      getCurrentAgentId: () => current,
+      onNewConversation: vi.fn(),
+      scrollToBottom: vi.fn(),
+      scrollAcpLog: vi.fn(),
+      scrollSubLogs: vi.fn(),
+      pushChunk: (st, text) => { st.streamContent += text; },
+    });
+
+    const stA = makeState();
+    const stB = makeState();
+    // 交替喂 A、B 两条流的事件，模拟后台并发
+    handleEvent(stA, 'agent-A', 'agent_output', { message: 'A1' });
+    handleEvent(stB, 'agent-B', 'agent_output', { message: 'B1' });
+    current = 'agent-B'; // 用户切到 B
+    handleEvent(stA, 'agent-A', 'agent_output', { message: 'A2' });
+    handleEvent(stB, 'agent-B', 'agent_output', { message: 'B2' });
+
+    expect(stA.streamContent).toBe('A1A2');
+    expect(stB.streamContent).toBe('B1B2');
+  });
+});
+
+describe('agentChatEvents · 打字机渲染缓冲', () => {
+  it('文本按固定节奏匀速吐出，而不是一次性整段落地', () => {
+    vi.useFakeTimers();
+    try {
+      const st = makeState();
+      const pushChunk = createTypewriterQueue({ tickMs: 10, charsPerTick: 2 });
+      pushChunk(st, 'abcdef');
+
+      expect(st.streamContent).toBe(''); // 入队即刻不落地，等定时器吐
+      vi.advanceTimersByTime(10);
+      expect(st.streamContent).toBe('ab');
+      vi.advanceTimersByTime(10);
+      expect(st.streamContent).toBe('abcd');
+      vi.advanceTimersByTime(10);
+      expect(st.streamContent).toBe('abcdef');
+      vi.advanceTimersByTime(10); // 队列空了，定时器该自己停
+      expect(st._typeTimer).toBeNull();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('flushTypewriter 立刻吐光剩余队列（打断/结束时用）', () => {
+    vi.useFakeTimers();
+    try {
+      const st = makeState();
+      const pushChunk = createTypewriterQueue({ tickMs: 10, charsPerTick: 1 });
+      pushChunk(st, 'hello');
+      vi.advanceTimersByTime(10); // 只吐了 1 个字符
+      expect(st.streamContent).toBe('h');
+
+      flushTypewriter(st);
+      expect(st.streamContent).toBe('hello');
+      expect(st._typeTimer).toBeNull();
+      expect(st._typeQueue).toBe('');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
@@ -36,7 +36,10 @@ const routes = [
     component: () => import('@/views/CompanyDashboard.vue'),
   },
   {
-    path: '/:id/:tab(overview|agents|pipelines|goals|sop|okr|team|files|messages|skills|jobs|workspace)',
+    // 39 号文档 §二 P2：'goals'/'okr' 两个 tab 值已摘掉 —— 前者是 OKR 树的历史命名残留
+    // （真正的 goal/task 看板走下面 'task-board' 独立路由，不挤在这条 :tab 正则里），
+    // 后者是随 /okr 一起废弃的孤儿页面。
+    path: '/:id/:tab(overview|agents|pipelines|sop|team|files|messages|skills|jobs|workspace)',
     name: 'CompanyDetail',
     component: () => import('@/views/CompanyDashboard.vue'),
     props: true
@@ -50,9 +53,11 @@ const routes = [
     props: true,
   },
   {
-    path: '/okr',
-    name: 'OkrDashboard',
-    component: () => import('@/views/OkrDashboard.vue'),
+    // 39 号文档 §二 P2：goal/task 两级看板独立页，同样不挤进 :tab 正则（信息密度高，值得一整页）。
+    path: '/:id/task-board',
+    name: 'TaskBoard',
+    component: () => import('@/views/TaskBoard.vue'),
+    props: true,
   },
   // 新增独立页面
   {
@@ -128,24 +128,27 @@
             </div>
           </div>
           <div v-else ref="messageListRef" class="message-list">
-            <div v-for="(msg, idx) in chatState.messages" :key="idx" class="msg-row" :class="`msg-${msg.role}`">
-              <div class="msg-avatar" :class="`avatar-${msg.role}`">{{ msg.role === 'user' ? '👤' : (agentInfo.emoji || '🏗️') }}</div>
-              <div class="msg-body">
-                <div class="msg-header">
-                  <span class="msg-role">{{ msg.role === 'user' ? '你' : agentInfo.name }}</span>
-                  <span class="msg-time">{{ formatMsgTime(msg.timestamp) }}</span>
-                </div>
-                <div class="msg-content" v-html="renderMarkdown(msg.content)"></div>
-                <!-- Attachment cards -->
-                <div v-if="msg.attachments && msg.attachments.length" class="msg-attachments">
-                  <div v-for="att in msg.attachments" :key="att.name" class="msg-attachment-card">
-                    <span class="att-icon">{{ att.type === 'image' ? '🖼️' : '📄' }}</span>
-                    <span class="att-name">{{ att.name }}</span>
-                    <span class="att-size">{{ formatFileSize(att.size) }}</span>
+            <template v-for="(msg, idx) in chatState.messages" :key="idx">
+              <div v-if="msg.role === 'divider'" class="msg-divider"><span>{{ msg.content }}</span></div>
+              <div v-else class="msg-row" :class="`msg-${msg.role}`">
+                <div class="msg-avatar" :class="`avatar-${msg.role}`">{{ msg.role === 'user' ? '👤' : (agentInfo.emoji || '🏗️') }}</div>
+                <div class="msg-body">
+                  <div class="msg-header">
+                    <span class="msg-role">{{ msg.role === 'user' ? '你' : agentInfo.name }}</span>
+                    <span class="msg-time">{{ formatMsgTime(msg.timestamp) }}</span>
+                  </div>
+                  <div class="msg-content" v-html="renderMarkdown(msg.content)"></div>
+                  <!-- Attachment cards -->
+                  <div v-if="msg.attachments && msg.attachments.length" class="msg-attachments">
+                    <div v-for="att in msg.attachments" :key="att.name" class="msg-attachment-card">
+                      <span class="att-icon">{{ att.type === 'image' ? '🖼️' : '📄' }}</span>
+                      <span class="att-name">{{ att.name }}</span>
+                      <span class="att-size">{{ formatFileSize(att.size) }}</span>
+                    </div>
                   </div>
                 </div>
               </div>
-            </div>
+            </template>
             <div v-if="chatState.streaming" class="msg-row msg-assistant streaming">
               <div class="msg-avatar avatar-assistant">{{ agentInfo.emoji || '🏗️' }}</div>
               <div class="msg-body">
@@ -186,11 +189,17 @@
               <span v-for="f in uploadedFiles.slice(0, 3)" :key="f.name" class="uploaded-file-tag">{{ f.name }}</span>
               <span v-if="uploadedFiles.length > 3" class="uploaded-file-tag more">+{{ uploadedFiles.length - 3 }}</span>
             </div>
+            <!-- sending 态下 stop 迟迟没确认清理完成时的兜底提示（40 号文档方案二） -->
+            <div v-if="chatState.pendingForceSend" class="force-send-bar">
+              <span>上一条还在收尾…</span>
+              <button class="force-send-btn" @click="handleForceSend">强制发送</button>
+            </div>
             <div class="input-box" :class="{ focused: inputFocused }">
               <button class="attach-btn" @click="triggerFileInput" title="上传文件">📎</button>
               <input type="file" ref="fileInputRef" multiple style="display:none" @change="handleFileSelect" />
-              <textarea ref="inputRef" v-model="inputText" :disabled="chatState.sending" :placeholder="chatState.sending ? '等待回复中...' : '跟 ' + agentInfo.name + ' 对话...'" class="msg-textarea" rows="1" @keydown="handleKeydown" @focus="inputFocused = true" @blur="inputFocused = false" @input="autoResize" @paste="handlePaste"></textarea>
-              <button v-if="chatState.sending" class="send-btn stop-btn" @click="handleStop">⏹</button>
+              <textarea ref="inputRef" v-model="inputText" :placeholder="chatState.sending ? '输入新消息可打断当前回复...' : '跟 ' + agentInfo.name + ' 对话...'" class="msg-textarea" rows="1" @keydown="handleKeydown" @focus="inputFocused = true" @blur="inputFocused = false" @input="autoResize" @paste="handlePaste"></textarea>
+              <button v-if="chatState.sending" class="send-btn stop-btn" title="仅停止，不发送新消息" @click="handleStop">⏹</button>
+              <button v-if="chatState.sending" class="send-btn interrupt-btn" :class="{ ready: inputText.trim() || pendingFiles.length }" :disabled="(!inputText.trim() && !pendingFiles.length) || chatState.interrupting" title="发送并打断当前回复" @click="handleInterruptAndSend">⤴</button>
               <button v-else class="send-btn" :class="{ ready: (inputText.trim() || pendingFiles.length) && !chatState.sending }" :disabled="!inputText.trim() && !pendingFiles.length" @click="handleSend">➤</button>
             </div>
             <div class="input-hint">Shift+Enter 换行 · {{ chatState.messages.length }} 条消息<template v-if="pendingFiles.length"> · {{ pendingFiles.length }} 个待上传文件</template><template v-if="uploadedFiles.length"> · 📎 {{ uploadedFiles.length }} 个附件</template></div>
@@ -360,6 +369,7 @@ import { useRoute, useRouter } from &#39;vue-router&#39;
 import AppNav from '@/components/AppNav.vue'
 import FileNode from '@/components/FileNode.vue'
 import { marked } from 'marked'
+import { createAgentChatEventHandler, flushTypewriter } from '@/composables/agentChatEvents.js'
  
 const route = useRoute()
 const router = useRouter()
@@ -463,6 +473,7 @@ function ensureChatState(id) {
       sending: false, streaming: false, streamContent: '',
       subAgents: {}, subLogList: [], acpLog: [],
       thinkingText: '🏗️ 启动中...', thinkingContent: '', showThinking: true,
+      interrupting: false, pendingForceSend: false,
     })
   }
   return chatStates.get(id)
@@ -958,6 +969,7 @@ async function handleSend() {
         }
       }
     }
+    flushTypewriter(st) // 流已经读完，剩下排队的字符没必要再演匀速，直接吐光再拼进消息
     if (st.streamContent) {
       st.messages.push({ role: 'assistant', content: st.streamContent, timestamp: new Date().toISOString() })
     }
@@ -981,70 +993,86 @@ async function handleStop() {
   const st = chatState.value
   if (!st.activeConvId) return
   try { await fetch(`/api/agent/${agentId.value}/chat/${st.activeConvId}/stop`, { method: 'POST' }) } catch(e) { console.error('Stop error:', e) }
+  flushTypewriter(st)
   st.sending = false; st.streaming = false
   st.messages.push({ role: 'assistant', content: `*[已终止]*`, timestamp: new Date().toISOString() })
   scrollToBottom()
 }
  
+// 40 号文档方案二：执行中把已生成的部分内容 + 一条分隔标记落进历史，再当作一轮全新对话
+// 重置 sending 相关状态——不依赖"旧的 fetch 循环自己发现流已结束"这件事的时序，
+// 保证接下来立刻调用 handleSend() 是安全的（旧循环之后自己走到 finally 时，
+// st.streamContent 已经是空的，不会重复 push）。
+function finalizeInterruptedTurn(st) {
+  flushTypewriter(st)
+  if (st.streamContent) {
+    st.messages.push({ role: 'assistant', content: st.streamContent, timestamp: new Date().toISOString() })
+  }
+  st.messages.push({ role: 'divider', content: '已打断上一条回复', timestamp: new Date().toISOString() })
+  st.sending = false; st.streaming = false; st.streamContent = ''; st.thinkingContent = ''
+}
+
+// sending 态下点发送 = "打断并发送"：先中止当前 turn，服务端确认清理完成（cleaned）后
+// 再把这条新消息接上；服务端 3 秒还没确认的话不自动强发（避免撞上同 convId 并发的坑），
+// 交给用户自己点"强制发送"。
+async function handleInterruptAndSend() {
+  const st = chatState.value
+  if (!inputText.value.trim() && pendingFiles.value.length === 0) return
+  if (!st.activeConvId) return handleSend()
+
+  st.interrupting = true
+  let cleaned = false
+  try {
+    const r = await fetch(`/api/agent/${agentId.value}/chat/${st.activeConvId}/stop`, { method: 'POST' })
+    const data = await r.json().catch(() => ({}))
+    cleaned = !!data.cleaned
+  } catch (e) {
+    console.error('Interrupt error:', e)
+  }
+  st.interrupting = false
+
+  if (!cleaned) { st.pendingForceSend = true; return }
+  finalizeInterruptedTurn(st)
+  await handleSend()
+}
+
+function handleForceSend() {
+  const st = chatState.value
+  st.pendingForceSend = false
+  finalizeInterruptedTurn(st)
+  handleSend()
+}
+
 // st/requestAgentId 是 handleSend 传下来的快照；只有 requestAgentId 仍是当前选中 agent 时
 // 才动 DOM(滚动)/URL/全局对话列表——避免把某个后台 agent 的进度"带"到当前正看的页面上。
-function handleEvent(st, requestAgentId, type, data) {
-  const isCurrent = agentId.value === requestAgentId
-  switch (type) {
-    case 'session':
-      if (data.conversationId && !st.activeConvId) {
-        st.activeConvId = data.conversationId
-        if (isCurrent) {
-          if (route.params.id) {
-            router.replace({ params: { id: route.params.id, agentId: requestAgentId, convId: data.conversationId } })
-          } else {
-            router.replace({ params: { agentId: requestAgentId, convId: data.conversationId } })
-          }
-          const existsInList = conversations.value.some(c => (c.conversationId || c.id) === data.conversationId)
-          if (!existsInList) {
-            conversations.value.unshift({ conversationId: data.conversationId, title: st.messages.find(m => m.role === 'user')?.content?.slice(0, 50) || '新对话', updatedAt: new Date().toISOString(), messageCount: 1, status: 'running' })
-          }
-        }
-      }
-      break
-    case 'thinking':
-      if (data.message && !data.message.startsWith('🏗️')) { st.thinkingContent += data.message; if (isCurrent) scrollToBottom() }
-      else { st.thinkingText = data.message || '思考中...' }
-      break
-    case 'agent_output':
-      st.streaming = true; st.streamContent += (data.message || ''); if (isCurrent) scrollToBottom(); break
-    case 'tool_call':
-      st.thinkingText = data.message || `🔧 ${data.tool}`
-      st.acpLog.push({ type: 'tool', icon: '🔧', text: `${data.tool}`, ts: Date.now() }); if (isCurrent) scrollAcpLog(); break
-    case 'tool_input':
-      st.acpLog.push({ type: 'input', icon: '📥', text: data.input?.slice(0, 300) || '', ts: Date.now() }); if (isCurrent) scrollAcpLog(); break
-    case 'tool_result':
-      st.acpLog.push({ type: 'result', icon: '📤', text: data.result?.slice(0, 300) || '', ts: Date.now() }); if (isCurrent) scrollAcpLog(); break
-    case 'session_cost':
-      st.acpLog.push({ type: 'cost', icon: '💰', text: `$${data.cost?.toFixed(4)} (${((data.duration||0)/1000).toFixed(1)}s)`, ts: Date.now() }); break
-    case 'acp_raw':
-      if (data.method && !data.method.includes('content_block_delta') && !data.method.includes('message_start')) {
-        st.acpLog.push({ type: 'raw', icon: '⚡', text: data.method, ts: Date.now() }); if (isCurrent) scrollAcpLog()
-      }
-      break
-    case 'sub_agent':
-      if (!st.subAgents[data.callId]) st.subAgents[data.callId] = { agent: data.agent, status: 'running', content: '', collapsed: false }
-      if (data.event === 'chunk' && data.chunk) {
-        st.subAgents[data.callId].content += data.chunk
-        if (isCurrent) setTimeout(() => { document.querySelectorAll('.sub-log-content').forEach(el => el.scrollTop = el.scrollHeight) }, 50)
-      } else if (data.event === 'done') st.subAgents[data.callId].status = data.status
-      else if (data.event === 'start') st.subAgents[data.callId].status = 'running'
-      if (isCurrent) scrollToBottom(); break
-    case 'error':
-      st.messages.push({ role: 'assistant', content: `❌ ${data.message}`, timestamp: new Date().toISOString() })
-      st.acpLog.push({ type: 'error', icon: '🚨', text: data.message, ts: Date.now() })
-      st.thinkingText = ''; st.thinkingContent = ''
-      if (isCurrent) { scrollToBottom(); scrollAcpLog() }
-      break
+// 分发逻辑本体已抽到 composables/agentChatEvents.js（40 号文档方案三，便于单独做回归测试）。
+function scrollSubLogs() {
+  setTimeout(() => { document.querySelectorAll('.sub-log-content').forEach(el => el.scrollTop = el.scrollHeight) }, 50)
+}
+const handleEvent = createAgentChatEventHandler({
+  getCurrentAgentId: () => agentId.value,
+  scrollToBottom,
+  scrollAcpLog,
+  scrollSubLogs,
+  onNewConversation(requestAgentId, data, st) {
+    if (route.params.id) {
+      router.replace({ params: { id: route.params.id, agentId: requestAgentId, convId: data.conversationId } })
+    } else {
+      router.replace({ params: { agentId: requestAgentId, convId: data.conversationId } })
+    }
+    const existsInList = conversations.value.some(c => (c.conversationId || c.id) === data.conversationId)
+    if (!existsInList) {
+      conversations.value.unshift({ conversationId: data.conversationId, title: st.messages.find(m => m.role === 'user')?.content?.slice(0, 50) || '新对话', updatedAt: new Date().toISOString(), messageCount: 1, status: 'running' })
+    }
+  },
+})
+
+function handleKeydown(e) {
+  if (e.key === 'Enter' && !e.shiftKey && !e.isComposing) {
+    e.preventDefault()
+    chatState.value.sending ? handleInterruptAndSend() : handleSend()
   }
 }
-
-function handleKeydown(e) { if (e.key === 'Enter' && !e.shiftKey && !e.isComposing) { e.preventDefault(); handleSend() } }
 function scrollAcpLog() { nextTick(() => { const el = document.querySelector('.acp-log-stream'); if (el) el.scrollTop = el.scrollHeight }) }
 function autoResize() { const el = inputRef.value; if (!el) return; el.style.height = 'auto'; el.style.height = Math.min(el.scrollHeight, 160) + 'px' }
 function scrollToBottom() { nextTick(() => { if (messageListRef.value) messageListRef.value.scrollTop = messageListRef.value.scrollHeight }) }
@@ -1305,6 +1333,14 @@ onMounted(async () =&gt; {
 .send-btn.ready { background: linear-gradient(135deg,var(--accent),var(--accent-light)); color: #fff; box-shadow: 0 3px 10px rgba(16,185,129,0.3); }
 .send-btn.ready:hover { transform: scale(1.05); }
 .input-hint { margin-top: 2px; font-size: 9px; color: var(--text-faint); text-align: center; }
+/* sending 态下：Stop（纯中止）与 interrupt-btn（打断并发送）视觉上要能一眼区分开 */
+.interrupt-btn.ready { background: linear-gradient(135deg,#f59e0b,#fbbf24); color: #fff; box-shadow: 0 3px 10px rgba(245,158,11,0.35); }
+.interrupt-btn.ready:hover { transform: scale(1.05); }
+.force-send-bar { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 6px; padding: 6px 10px; font-size: 11px; color: var(--text-muted); background: var(--accent-bg); border: 1px solid var(--border-active); border-radius: 7px; }
+.force-send-btn { border: none; border-radius: 6px; padding: 4px 10px; font-size: 11px; cursor: pointer; background: #f59e0b; color: #fff; }
+.force-send-btn:hover { opacity: 0.9; }
+.msg-divider { display: flex; align-items: center; gap: 8px; margin: 10px 0; font-size: 10px; color: var(--text-faint); }
+.msg-divider::before, .msg-divider::after { content: ''; flex: 1; height: 1px; background: var(--border-primary); }
  
 /* ═══ 第4列: ACP / 预览 ═══ */
 .acp-panel {
@@ -43,6 +43,11 @@
           <button class="btn-templates" @click="goToGraphConsole" style="border: none; background: transparent;">
             🕸️ 执行控制台
           </button>
+          <!-- 39 号文档 §二 P2：goal/task 看板独立页入口，同一处放法（不挤进 :tab 白名单，
+               按 goToGraphConsole 的先例给一个跳转按钮）。 -->
+          <button class="btn-templates" @click="goToTaskBoard" style="border: none; background: transparent;">
+            🗂️ 任务看板
+          </button>
           <button class="btn-templates" @click="showTemplates = !showTemplates" style="border: none; background: transparent;">
             📦 模板库 ({{ templates.length }})
           </button>
@@ -355,103 +360,6 @@
         </div>
       </div>
  
-      <!-- Tab: Goals (Full OKR Tree) -->
-      <div v-if="activeTab === 'goals'" class="tab-content">
-        <div class="okr-layout">
-          <!-- Left: Goal List -->
-          <div class="okr-sidebar">
-            <div class="okr-sidebar-header">
-              <span>🎯 OKR 目标</span>
-              <span class="okr-count" v-if="goals.length">{{ goals.length }}</span>
-            </div>
-            <div class="okr-goal-list">
-              <div
-                v-for="g in goals" :key="g.id"
-                class="okr-goal-card" :class="{ active: selectedGoalId === g.id }"
-                @click="selectGoalDetail(g.id)"
-              >
-                <div class="okr-goal-top">
-                  <span class="okr-gid">{{ g.id }}</span>
-                  <span class="okr-gstatus" :class="g.status">{{ okrStatusLabel(g.status) }}</span>
-                </div>
-                <div class="okr-gtitle">{{ g.title }}</div>
-                <div class="okr-gprogress">
-                  <div class="okr-pbar"><div class="okr-pfill" :style="{ width: (g.progress * 100) + '%' }"></div></div>
-                  <span class="okr-ppct">{{ Math.round(g.progress * 100) }}%</span>
-                </div>
-                <div class="okr-gmeta">
-                  <span>👤 {{ g.owner }}</span>
-                  <span>{{ g.doneCount || 0 }}/{{ g.totalCount || 0 }}</span>
-                </div>
-              </div>
-              <div v-if="goals.length === 0" class="empty-mini">暂无目标</div>
-            </div>
-          </div>
-
-          <!-- Right: Goal Detail + Node Tree -->
-          <div class="okr-detail" v-if="selectedGoalDetail">
-            <div class="okr-hero">
-              <div class="okr-hero-row">
-                <span class="okr-hero-id">{{ selectedGoalDetail.id }}</span>
-                <span class="okr-hero-status" :class="selectedGoalDetail.status">{{ okrStatusLabel(selectedGoalDetail.status) }}</span>
-                <span class="okr-hero-owner">👤 {{ selectedGoalDetail.owner }}</span>
-              </div>
-              <h2 class="okr-hero-title">{{ selectedGoalDetail.title }}</h2>
-              <p class="okr-hero-desc">{{ selectedGoalDetail.description || '暂无详细描述' }}</p>
-              <div class="okr-hero-progress" v-if="selectedGoalProgress">
-                <div class="okr-hp-top">
-                  <span>目标总体进度</span>
-                  <span class="okr-hp-pct">{{ Math.round(selectedGoalProgress.progress * 100) }}%</span>
-                </div>
-                <div class="okr-hp-bar"><div class="okr-hp-fill" :style="{ width: (selectedGoalProgress.progress * 100) + '%' }"></div></div>
-                <div class="okr-hp-stats">
-                  <span>总: {{ selectedGoalProgress.total }}</span>
-                  <span class="stat-d">✅ {{ selectedGoalProgress.done }}</span>
-                  <span class="stat-p">🔄 {{ selectedGoalProgress.inProgress }}</span>
-                  <span class="stat-w">⏳ {{ selectedGoalProgress.pending }}</span>
-                </div>
-              </div>
-            </div>
-            <div class="okr-tree-area">
-              <h3 class="okr-tree-title">OKR 拆解树</h3>
-              <div class="okr-tree">
-                <div
-                  v-for="node in okrSortedNodes" :key="node.id"
-                  class="okr-tnode"
-                >
-                  <div class="okr-tnode-line">
-                    <div class="okr-tnode-indent" :style="{ width: (node.level - 2) * 24 + 'px' }"></div>
-                    <div class="okr-tnode-card" :class="[node.status, 'okr-lv-' + node.level]">
-                      <div class="okr-tnode-hdr">
-                        <span class="okr-nid">{{ node.id }}</span>
-                        <span class="okr-ntype">{{ okrLevelName(node.level) }}</span>
-                        <span class="okr-nstatus" :class="node.status">{{ okrStatusLabel(node.status) }}</span>
-                      </div>
-                      <div class="okr-ntitle">{{ node.title }}</div>
-                      <div class="okr-nfooter">
-                        <span class="okr-nowner" v-if="node.owner">👤 {{ node.owner }}</span>
-                        <span class="okr-nprio" v-if="node.priority" :class="node.priority">{{ node.priority }}</span>
-                        <span class="okr-ntask" v-if="node.taskId">🔗 {{ node.taskId }}</span>
-                      </div>
-                      <div class="okr-nsummary" v-if="node.summary"><strong>摘要:</strong> {{ node.summary }}</div>
-                      <div class="okr-nsummary" v-if="node.output"><strong>产出:</strong> {{ node.output }}</div>
-                    </div>
-                  </div>
-                </div>
-                <div v-if="okrSortedNodes.length === 0" class="empty-mini">暂无 OKR 节点</div>
-              </div>
-            </div>
-          </div>
-          <div class="okr-detail okr-empty" v-else>
-            <div class="empty-state-large">
-              <div style="font-size:48px; margin-bottom:16px; opacity:0.8">🎯</div>
-              <h3>OKR 目标看板</h3>
-              <p>从左侧选择一个目标查看拆解树与进度</p>
-            </div>
-          </div>
-        </div>
-      </div>
-
       <!-- Tab: Files -->
       <div v-if="activeTab === 'files'" class="tab-content">
         <div class="files-layout">
@@ -852,10 +760,6 @@ const companyAgents = ref([])
 const pipelines = ref([])
 const pipelineRuns = ref([])
 const selectedPipeline = ref(null)
-const goals = ref([])
-const selectedGoalId = ref(null)
-const selectedGoalDetail = ref(null)
-const selectedGoalProgress = ref(null)
 const templates = ref([])
 const activeTab = ref('overview')
 const showTemplates = ref(false)
@@ -1039,7 +943,6 @@ async function loadCompanyData(id, tab) {
     if (activeTab.value === 'overview') await loadCompanyStatus(id)
     if (activeTab.value === 'agents') { await loadCompanyAgents(id); await loadOrgGraph(id) }
     if (activeTab.value === 'pipelines') await loadPipelines(id)
-    if (activeTab.value === 'goals') await loadGoals(id)
     if (activeTab.value === 'files') await loadCompanyFiles(id)
     if (activeTab.value === 'messages') await loadMessages(id)
     if (activeTab.value === 'skills') await loadSkillsList(id)
@@ -1064,6 +967,11 @@ function goToGraphConsole() {
   router.push(`/${selectedCompany.value.id}/graph-console`)
 }
  
+function goToTaskBoard() {
+  if (!selectedCompany.value) return
+  router.push(`/${selectedCompany.value.id}/task-board`)
+}
+
 watch(() => route?.params, async (params) => {
   if (!params) return
   if (route.name === 'CompanyDetail' && params.id) {
@@ -1216,54 +1124,6 @@ async function retryPipelineRun(runId) {
   } catch (e) { alert(`❌ 重试失败: ${e.message}`) }
 }
  
-async function loadGoals(id) {
-  try {
-    const { data } = await axios.get(`/api/company/${id}/okr`)
-    goals.value = data
-    // Auto-select first goal
-    if (data.length > 0 && !selectedGoalId.value) {
-      selectGoalDetail(data[0].id)
-    }
-  } catch (e) { console.error(e) }
-}
-
-async function selectGoalDetail(goalId) {
-  if (!selectedCompany.value) return
-  selectedGoalId.value = goalId
-  try {
-    const [goalRes, progRes] = await Promise.all([
-      axios.get(`/api/company/${selectedCompany.value.id}/okr/${goalId}`),
-      axios.get(`/api/company/${selectedCompany.value.id}/okr/${goalId}/progress`)
-    ])
-    selectedGoalDetail.value = goalRes.data
-    selectedGoalProgress.value = progRes.data
-  } catch (e) { console.error(e) }
-}
-
-function okrStatusLabel(status) {
-  const map = { active: '运转中', in_progress: '进行中', pending: '待开始', done: '已完成', failed: '失败', blocked: '已阻塞' }
-  return map[status] || status
-}
-
-function okrLevelName(level) {
-  const names = ['Goal', 'Objective', 'Key Result', 'Sub-Task', 'Micro-Task']
-  return names[Math.min(level - 1, 4)]
-}
-
-const okrSortedNodes = computed(() => {
-  if (!selectedGoalDetail.value?.nodes) return []
-  const nodes = selectedGoalDetail.value.nodes
-  const keys = Object.keys(nodes).sort((a, b) => {
-    const partsA = a.replace('G-','').split('.').map(Number)
-    const partsB = b.replace('G-','').split('.').map(Number)
-    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-      if ((partsA[i] || 0) !== (partsB[i] || 0)) return (partsA[i] || 0) - (partsB[i] || 0)
-    }
-    return 0
-  })
-  return keys.map(id => ({ id, ...nodes[id], level: id.split('.').length }))
-})
-
 async function loadCompanyStatus(id) {
   try {
     const { data } = await axios.get(`/api/company/${id}/status`)
@@ -1848,84 +1708,6 @@ function closeDropdown() {
 .run-meta { display: flex; gap: 16px; font-size: 12px; color: var(--text-muted); }
 .run-actions { margin-top: 8px; }
  
-/* ═══ OKR Full Layout ═══ */
-.okr-layout { display: flex; height: calc(100vh - 140px); overflow: hidden; }
-.okr-sidebar { width: 280px; min-width: 260px; border-right: 1px solid var(--border-primary); background: var(--bg-overlay); display: flex; flex-direction: column; }
-.okr-sidebar-header { padding: 12px 16px; font-size: 13px; font-weight: 700; color: var(--text-secondary); border-bottom: 1px solid var(--border-primary); display: flex; align-items: center; justify-content: space-between; background: var(--bg-secondary); }
-.okr-count { background: var(--bg-surface-active); color: var(--accent); padding: 2px 8px; border-radius: 12px; font-size: 11px; }
-.okr-goal-list { flex: 1; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px; }
-.okr-goal-card { padding: 12px 14px; border-radius: 10px; cursor: pointer; background: var(--bg-surface); border: 1px solid var(--border-primary); transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1); }
-.okr-goal-card:hover { transform: translateY(-2px); border-color: var(--accent-light); box-shadow: 0 4px 12px rgba(16,185,129,0.08); }
-.okr-goal-card.active { background: var(--accent-bg); border-color: var(--border-active); box-shadow: 0 0 0 1px var(--accent) inset; }
-.okr-goal-top { display: flex; justify-content: space-between; margin-bottom: 6px; }
-.okr-gid { font-size: 11px; font-family: 'JetBrains Mono', monospace; font-weight: 600; color: var(--text-tertiary); }
-.okr-gstatus { font-size: 10px; font-weight: 600; padding: 2px 6px; border-radius: 4px; }
-.okr-gstatus.active { background: rgba(59,130,246,0.15); color: #60a5fa; }
-.okr-gstatus.done { background: rgba(16,185,129,0.15); color: #34d399; }
-.okr-gtitle { font-size: 13px; font-weight: 600; margin-bottom: 10px; color: var(--text-primary); line-height: 1.4; }
-.okr-gprogress { display: flex; align-items: center; gap: 8px; margin-bottom: 8px; }
-.okr-pbar { flex: 1; height: 6px; background: var(--bg-input-focus); border-radius: 3px; overflow: hidden; }
-.okr-pfill { height: 100%; background: linear-gradient(90deg, var(--accent), var(--accent-light)); border-radius: 3px; transition: width 0.5s ease; }
-.okr-ppct { font-size: 11px; font-weight: 600; color: var(--text-secondary); width: 32px; text-align: right; }
-.okr-gmeta { display: flex; justify-content: space-between; font-size: 10px; color: var(--text-faint); }
-
-/* OKR Detail Panel */
-.okr-detail { flex: 1; overflow-y: auto; background: var(--bg-primary); display: flex; flex-direction: column; }
-.okr-detail.okr-empty { align-items: center; justify-content: center; background: var(--bg-overlay); }
-.okr-detail.okr-empty h3 { font-size: 20px; font-weight: 600; margin-bottom: 8px; color: var(--text-secondary); }
-.okr-detail.okr-empty p { color: var(--text-muted); font-size: 13px; }
-
-.okr-hero { padding: 30px 40px; border-bottom: 1px solid var(--border-primary); background: linear-gradient(180deg, var(--accent-bg) 0%, transparent 100%); }
-.okr-hero-row { display: flex; align-items: center; gap: 12px; margin-bottom: 12px; }
-.okr-hero-id { font-size: 14px; font-family: 'JetBrains Mono', monospace; font-weight: 700; color: var(--accent-light); }
-.okr-hero-status { font-size: 12px; font-weight: 600; padding: 3px 8px; border-radius: 6px; }
-.okr-hero-status.active { background: rgba(59,130,246,0.2); color: #60a5fa; border: 1px solid rgba(59,130,246,0.3); }
-.okr-hero-status.done { background: rgba(16,185,129,0.2); color: #34d399; border: 1px solid rgba(16,185,129,0.3); }
-.okr-hero-owner { font-size: 12px; font-weight: 500; color: var(--text-secondary); margin-left: auto; background: var(--bg-surface); padding: 4px 10px; border-radius: 12px; border: 1px solid var(--border-primary); }
-.okr-hero-title { font-size: 26px; font-weight: 800; margin: 0 0 10px; letter-spacing: -0.5px; }
-.okr-hero-desc { font-size: 14px; color: var(--text-tertiary); line-height: 1.6; max-width: 800px; margin: 0; }
-
-.okr-hero-progress { margin-top: 24px; max-width: 600px; background: var(--bg-surface); padding: 16px 20px; border-radius: 12px; border: 1px solid var(--border-primary); }
-.okr-hp-top { display: flex; justify-content: space-between; align-items: flex-end; margin-bottom: 10px; font-size: 13px; font-weight: 600; color: var(--text-secondary); }
-.okr-hp-pct { font-size: 24px; font-weight: 800; color: var(--accent-light); line-height: 1; }
-.okr-hp-bar { height: 8px; background: var(--bg-input-focus); border-radius: 4px; overflow: hidden; margin-bottom: 12px; }
-.okr-hp-fill { height: 100%; background: linear-gradient(90deg, #10b981, #34d399); border-radius: 4px; transition: width 0.8s cubic-bezier(0.16, 1, 0.3, 1); }
-.okr-hp-stats { display: flex; gap: 16px; font-size: 11px; font-weight: 500; color: var(--text-tertiary); }
-.okr-hp-stats .stat-d { color: #34d399; }
-.okr-hp-stats .stat-p { color: #60a5fa; }
-.okr-hp-stats .stat-w { color: var(--text-muted); }
-
-/* OKR Tree */
-.okr-tree-area { padding: 30px 40px; max-width: 1000px; }
-.okr-tree-title { font-size: 18px; font-weight: 600; margin: 0 0 20px; color: var(--text-primary); }
-.okr-tree { display: flex; flex-direction: column; gap: 6px; }
-.okr-tnode-line { display: flex; width: 100%; }
-.okr-tnode-indent { position: relative; }
-.okr-tnode-indent::before { content: ''; position: absolute; top: -16px; bottom: 50%; left: -14px; width: 14px; border-left: 1.5px solid var(--border-active); border-bottom: 1.5px solid var(--border-active); border-bottom-left-radius: 6px; z-index: 1; opacity: 0.3; }
-.okr-tnode-card { flex: 1; background: var(--bg-surface); border: 1px solid var(--border-primary); border-radius: 8px; padding: 12px 16px; transition: all 0.2s; }
-.okr-tnode-card:hover { border-color: rgba(255,255,255,0.1); background: var(--bg-surface-hover); }
-.okr-tnode-card.okr-lv-2 { background: rgba(59,130,246,0.03); border-color: rgba(59,130,246,0.1); }
-.okr-tnode-card.okr-lv-3 { background: rgba(16,185,129,0.03); border-color: rgba(16,185,129,0.1); }
-.okr-tnode-hdr { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
-.okr-nid { font-family: 'JetBrains Mono', monospace; font-size: 11px; font-weight: 700; color: var(--text-tertiary); }
-.okr-ntype { font-size: 9px; font-weight: 600; padding: 2px 6px; border-radius: 10px; background: rgba(255,255,255,0.05); color: var(--text-muted); text-transform: uppercase; letter-spacing: 0.5px; }
-.okr-nstatus { font-size: 10px; font-weight: 600; padding: 2px 6px; border-radius: 4px; border: 1px solid transparent; }
-.okr-nstatus.done { background: rgba(16,185,129,0.1); color: #34d399; border-color: rgba(16,185,129,0.2); }
-.okr-nstatus.in_progress { background: rgba(59,130,246,0.1); color: #60a5fa; border-color: rgba(59,130,246,0.2); animation: okr-pulse 2s infinite; }
-.okr-nstatus.pending { background: rgba(255,255,255,0.05); color: var(--text-muted); border-color: var(--border-primary); }
-@keyframes okr-pulse { 0% { box-shadow: 0 0 0 0 rgba(96,165,250,0.2); } 70% { box-shadow: 0 0 0 4px rgba(96,165,250,0); } 100% { box-shadow: 0 0 0 0 rgba(96,165,250,0); } }
-.okr-ntitle { font-size: 14px; font-weight: 600; color: var(--text-primary); margin-bottom: 8px; line-height: 1.4; }
-.okr-nfooter { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; margin-bottom: 4px; }
-.okr-nowner { font-size: 11px; font-weight: 500; color: var(--accent-light); display: flex; align-items: center; gap: 4px; background: var(--accent-bg); padding: 2px 8px; border-radius: 10px; }
-.okr-nprio { font-size: 10px; font-weight: 700; font-family: 'JetBrains Mono', monospace; }
-.okr-nprio.P0 { color: #ef4444; }
-.okr-nprio.P1 { color: #f59e0b; }
-.okr-nprio.P2 { color: var(--text-muted); }
-.okr-ntask { font-size: 10px; font-family: 'JetBrains Mono', monospace; color: var(--blue-text); background: rgba(59,130,246,0.1); padding: 2px 6px; border-radius: 4px; }
-.okr-nsummary { margin-top: 8px; padding-top: 8px; border-top: 1px dashed var(--border-primary); font-size: 11px; color: var(--text-tertiary); line-height: 1.5; }
-.okr-nsummary strong { color: var(--text-secondary); }
-
-.empty-state-large { text-align: center; color: var(--text-muted); }
  
 /* ═══ Modal ═══ */
 .modal-overlay {
-<template>
-  <div class="okr-dashboard-page">
-    <AppNav />
-    <div class="okr-layout">
-      <!-- 第1列: Goal 列表 -->
-      <aside class="goal-sidebar">
-        <div class="col-header">
-          <span>🎯 OKR 目标</span>
-          <span class="count-badge" v-if="goals.length">{{ goals.length }}</span>
-        </div>
-        <div class="goal-list">
-          <div
-            v-for="g in goals" :key="g.id"
-            class="goal-card" :class="{ active: selectedGoalId === g.id }"
-            @click="selectGoal(g.id)"
-          >
-            <div class="goal-card-header">
-              <span class="goal-id">{{ g.id }}</span>
-              <span class="goal-status" :class="g.status">{{ getDisplayStatus(g.status) }}</span>
-            </div>
-            <div class="goal-title" :title="g.title">{{ g.title }}</div>
-            <div class="goal-progress-wrap">
-              <div class="progress-bar"><div class="progress-fill" :style="{ width: (g.progress * 100) + '%' }"></div></div>
-              <span class="progress-text">{{ Math.round(g.progress * 100) }}%</span>
-            </div>
-            <div class="goal-meta">
-              <span class="goal-owner">👤 {{ g.owner }}</span>
-              <span class="goal-counts">节点: {{ g.doneCount || 0 }}/{{ g.totalCount || 0 }}</span>
-            </div>
-          </div>
-          <div v-if="goals.length === 0" class="empty-state">当前没有目标</div>
-        </div>
-      </aside>
-
-      <!-- 第2列: Goal 详情与节点树 -->
-      <section class="goal-detail-panel" v-if="selectedGoal">
-        <div class="goal-hero">
-          <div class="hero-top">
-            <span class="hero-id">{{ selectedGoal.id }}</span>
-            <span class="hero-status" :class="selectedGoal.status">{{ getDisplayStatus(selectedGoal.status) }}</span>
-            <span class="hero-owner">👤 负责人: {{ selectedGoal.owner }}</span>
-          </div>
-          <h1 class="hero-title">{{ selectedGoal.title }}</h1>
-          <p class="hero-desc">{{ selectedGoal.description || '暂无详细描述...' }}</p>
-          <div class="hero-progress-large" v-if="selectedGoalProgress">
-            <div class="large-progress-top">
-              <span class="large-progress-label">目标总体进度</span>
-              <span class="large-progress-value">{{ Math.round(selectedGoalProgress.progress * 100) }}%</span>
-            </div>
-            <div class="large-progress-bar">
-              <div class="large-progress-fill" :style="{ width: (selectedGoalProgress.progress * 100) + '%' }"></div>
-            </div>
-            <div class="large-progress-stats">
-              <span>总叶子节点: {{ selectedGoalProgress.total }}</span>
-              <span class="stat-done">已完成: {{ selectedGoalProgress.done }}</span>
-              <span class="stat-inprogress">进行中: {{ selectedGoalProgress.inProgress }}</span>
-              <span class="stat-pending">待开始: {{ selectedGoalProgress.pending }}</span>
-            </div>
-          </div>
-        </div>
-
-        <div class="nodes-area">
-          <div class="nodes-header">
-            <h3>OKR 拆解树配置</h3>
-          </div>
-          <div class="tree-container">
-            <div
-              v-for="node in sortedNodes" :key="node.id"
-              class="tree-node"
-              :class="'level-' + node.level"
-            >
-              <div class="node-line">
-                <div class="node-prefix" :style="{ width: (node.level - 2) * 24 + 'px' }"></div>
-                <div class="node-card" :class="[node.status, 'level-style-' + node.level]">
-                  <div class="node-header">
-                    <span class="node-id">{{ node.id }}</span>
-                    <span class="node-type-badge">{{ getLevelName(node.level) }}</span>
-                    <span class="node-status" :class="node.status">{{ getDisplayStatus(node.status) }}</span>
-                  </div>
-                  <div class="node-title">{{ node.title }}</div>
-                  <div class="node-footer">
-                    <span class="node-owner" v-if="node.owner">👤 {{ node.owner }}</span>
-                    <span class="node-priority" v-if="node.priority" :class="node.priority">{{ node.priority }}</span>
-                    <span class="node-task" v-if="node.taskId">🔗 {{ node.taskId }}</span>
-                  </div>
-                  <div class="node-summary" v-if="node.summary">
-                    <strong>摘要:</strong> {{ node.summary }}
-                  </div>
-                  <div class="node-summary" v-if="node.output">
-                    <strong>产出:</strong> {{ node.output }}
-                  </div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </section>
-      
-      <section class="goal-detail-panel empty-panel" v-else>
-        <div class="empty-state-large">
-          <div class="empty-icon">🎯</div>
-          <h2>OKR 目标看板</h2>
-          <p>请从左侧列表选择一个目标查看详细拆解树与进度</p>
-        </div>
-      </section>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref, computed, onMounted } from 'vue'
-import AppNav from '@/components/AppNav.vue'
-
-const goals = ref([])
-const selectedGoalId = ref(null)
-const selectedGoal = ref(null)
-const selectedGoalProgress = ref(null)
-
-const statusMap = {
-  'active': '运转中',
-  'in_progress': '进行中',
-  'pending': '待开始',
-  'done': '已完成',
-  'failed': '失败',
-  'blocked': '已阻塞'
-}
-
-function getDisplayStatus(status) {
-  return statusMap[status] || status
-}
-
-function getLevelName(level) {
-  const names = ['Goal', 'Objective', 'Key Result', 'Sub-Task', 'Micro-Task'];
-  return names[Math.min(level - 1, 4)];
-}
-
-async function loadGoals() {
-  try {
-    const res = await fetch('/api/okr')
-    if (res.ok) {
-      goals.value = await res.json()
-      // 默认选中第一个
-      if (goals.value.length > 0 && !selectedGoalId.value) {
-        selectGoal(goals.value[0].id)
-      }
-    }
-  } catch (err) {
-    console.error('Failed to load goals:', err)
-  }
-}
-
-async function selectGoal(id) {
-  selectedGoalId.value = id
-  try {
-    const [goalRes, progRes] = await Promise.all([
-      fetch(`/api/okr/${id}`),
-      fetch(`/api/okr/${id}/progress`)
-    ])
-    if (goalRes.ok) selectedGoal.value = await goalRes.json()
-    if (progRes.ok) selectedGoalProgress.value = await progRes.json()
-  } catch (err) {
-    console.error('Failed to load goal detail:', err)
-  }
-}
-
-// 将扁平的nodes转为按树结构排序的列表，便于直接循环渲染并计算缩进
-const sortedNodes = computed(() => {
-  if (!selectedGoal.value || !selectedGoal.value.nodes) return []
-  const nodes = selectedGoal.value.nodes
-  
-  // 给定一个父节点，递归获取所有后代，按ID自然排序确保层级
-  const result = []
-  const keys = Object.keys(nodes).sort((a, b) => {
-    // 采用自然排序法，如 G-1.2 排在 G-1.10 前面
-    const partsA = a.replace('G-','').split('.').map(Number)
-    const partsB = b.replace('G-','').split('.').map(Number)
-    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-      const numA = partsA[i] || 0
-      const numB = partsB[i] || 0
-      if (numA !== numB) return numA - numB
-    }
-    return 0
-  })
-
-  for (const id of keys) {
-    result.push({
-      id,
-      ...nodes[id],
-      level: id.split('.').length
-    })
-  }
-  return result
-})
-
-onMounted(() => {
-  loadGoals()
-  // 简单轮询刷新进度
-  setInterval(() => {
-    if (selectedGoalId.value) {
-      selectGoal(selectedGoalId.value)
-    } else {
-      loadGoals()
-    }
-  }, 10000)
-})
-</script>
-
-<style scoped>
-.okr-dashboard-page {
-  height: 100vh; display: flex; flex-direction: column;
-  background: var(--bg-primary);
-  color: var(--text-primary); font-family: 'Inter', -apple-system, sans-serif;
-}
-.okr-layout { flex: 1; display: flex; overflow: hidden; }
-
-.col-header {
-  padding: 12px 16px; font-size: 13px; font-weight: 700; color: var(--text-secondary);
-  border-bottom: 1px solid var(--border-primary);
-  display: flex; align-items: center; justify-content: space-between;
-  background: var(--bg-secondary);
-}
-.count-badge {
-  background: var(--bg-surface-active); color: var(--accent);
-  padding: 2px 8px; border-radius: 12px; font-size: 11px;
-}
-
-/* ═══ Left Sidebar: Goals ═══ */
-.goal-sidebar {
-  width: 280px; min-width: 260px; border-right: 1px solid var(--border-primary);
-  background: var(--bg-overlay); display: flex; flex-direction: column;
-}
-.goal-list { flex: 1; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px; }
-.goal-card {
-  padding: 12px 14px; border-radius: 10px; cursor: pointer;
-  background: var(--bg-surface); border: 1px solid var(--border-primary);
-  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
-}
-.goal-card:hover { transform: translateY(-2px); border-color: var(--accent-light); box-shadow: 0 4px 12px rgba(16,185,129,0.08); }
-.goal-card.active {
-  background: var(--accent-bg); border-color: var(--border-active);
-  box-shadow: 0 0 0 1px var(--accent) inset;
-}
-
-.goal-card-header { display: flex; justify-content: space-between; margin-bottom: 6px; }
-.goal-id { font-size: 11px; font-family: 'JetBrains Mono', monospace; font-weight: 600; color: var(--text-tertiary); }
-.goal-status { font-size: 10px; font-weight: 600; padding: 2px 6px; border-radius: 4px; }
-.goal-status.active { background: rgba(59,130,246,0.15); color: #60a5fa; }
-.goal-status.done { background: rgba(16,185,129,0.15); color: #34d399; }
-
-.goal-title { font-size: 13px; font-weight: 600; margin-bottom: 10px; color: var(--text-primary); line-height: 1.4; }
-
-.goal-progress-wrap { display: flex; align-items: center; gap: 8px; margin-bottom: 8px; }
-.progress-bar { flex: 1; height: 6px; background: var(--bg-input-focus); border-radius: 3px; overflow: hidden; }
-.progress-fill { height: 100%; background: linear-gradient(90deg, var(--accent), var(--accent-light)); border-radius: 3px; transition: width 0.5s ease; }
-.progress-text { font-size: 11px; font-weight: 600; color: var(--text-secondary); width: 32px; text-align: right; }
-
-.goal-meta { display: flex; justify-content: space-between; font-size: 10px; color: var(--text-faint); }
-
-.empty-state { text-align: center; padding: 40px 20px; color: var(--text-faint); font-size: 12px; }
-
-/* ═══ Right Panel: Details ═══ */
-.goal-detail-panel {
-  flex: 1; overflow-y: auto; background: var(--bg-primary);
-  display: flex; flex-direction: column;
-}
-.goal-detail-panel.empty-panel { align-items: center; justify-content: center; background: var(--bg-overlay); }
-
-.empty-state-large { text-align: center; color: var(--text-muted); }
-.empty-icon { font-size: 48px; margin-bottom: 16px; opacity: 0.8; }
-.empty-state-large h2 { font-size: 20px; font-weight: 600; margin-bottom: 8px; color: var(--text-secondary); }
-
-.goal-hero {
-  padding: 30px 40px; border-bottom: 1px solid var(--border-primary);
-  background: linear-gradient(180deg, var(--accent-bg) 0%, transparent 100%);
-}
-.hero-top { display: flex; align-items: center; gap: 12px; margin-bottom: 12px; }
-.hero-id { font-size: 14px; font-family: 'JetBrains Mono', monospace; font-weight: 700; color: var(--accent-light); }
-.hero-status { font-size: 12px; font-weight: 600; padding: 3px 8px; border-radius: 6px; }
-.hero-status.active { background: rgba(59,130,246,0.2); color: #60a5fa; border: 1px solid rgba(59,130,246,0.3); }
-.hero-status.done { background: rgba(16,185,129,0.2); color: #34d399; border: 1px solid rgba(16,185,129,0.3); }
-
-.hero-owner { font-size: 12px; font-weight: 500; color: var(--text-secondary); margin-left: auto; background: var(--bg-surface); padding: 4px 10px; border-radius: 12px; border: 1px solid var(--border-primary); }
-.hero-title { font-size: 28px; font-weight: 800; margin: 0 0 12px; letter-spacing: -0.5px; }
-.hero-desc { font-size: 14px; color: var(--text-tertiary); line-height: 1.6; max-width: 800px; margin: 0; }
-
-.hero-progress-large { margin-top: 24px; max-width: 600px; background: var(--bg-surface); padding: 16px 20px; border-radius: 12px; border: 1px solid var(--border-primary); }
-.large-progress-top { display: flex; justify-content: space-between; align-items: flex-end; margin-bottom: 10px; }
-.large-progress-label { font-size: 13px; font-weight: 600; color: var(--text-secondary); }
-.large-progress-value { font-size: 24px; font-weight: 800; color: var(--accent-light); line-height: 1; }
-.large-progress-bar { height: 8px; background: var(--bg-input-focus); border-radius: 4px; overflow: hidden; margin-bottom: 12px; }
-.large-progress-fill { height: 100%; background: linear-gradient(90deg, #10b981, #34d399); border-radius: 4px; transition: width 0.8s cubic-bezier(0.16, 1, 0.3, 1); }
-.large-progress-stats { display: flex; gap: 16px; font-size: 11px; font-weight: 500; color: var(--text-tertiary); }
-.stat-done { color: #34d399; }
-.stat-inprogress { color: #60a5fa; }
-.stat-pending { color: var(--text-muted); }
-
-/* ═══ Nodes Tree ═══ */
-.nodes-area { padding: 30px 40px; max-width: 1000px; }
-.nodes-header h3 { font-size: 18px; font-weight: 600; margin: 0 0 20px; color: var(--text-primary); }
-
-.tree-container { display: flex; flex-direction: column; gap: 6px; }
-.tree-node { display: flex; flex-direction: column; }
-.node-line { display: flex; width: 100%; }
-.node-prefix { position: relative; }
-/* 连线占位 */
-.node-prefix::before {
-  content: ''; position: absolute; top: -16px; bottom: 50%; left: -14px;
-  width: 14px; border-left: 1.5px solid var(--border-active); border-bottom: 1.5px solid var(--border-active);
-  border-bottom-left-radius: 6px; z-index: 1; opacity: 0.3;
-}
-
-.node-card {
-  flex: 1; background: var(--bg-surface); border: 1px solid var(--border-primary);
-  border-radius: 8px; padding: 12px 16px; position: relative;
-  transition: all 0.2s;
-}
-.node-card:hover { border-color: rgba(255,255,255,0.1); background: var(--bg-surface-hover); }
-
-/* Level Styles */
-.node-card.level-style-2 { background: rgba(59,130,246,0.03); border-color: rgba(59,130,246,0.1); }
-.node-card.level-style-3 { background: rgba(16,185,129,0.03); border-color: rgba(16,185,129,0.1); }
-.node-card.level-style-4 { background: var(--bg-surface); }
-
-.node-header { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
-.node-id { font-family: 'JetBrains Mono', monospace; font-size: 11px; font-weight: 700; color: var(--text-tertiary); }
-.node-type-badge { font-size: 9px; font-weight: 600; padding: 2px 6px; border-radius: 10px; background: rgba(255,255,255,0.05); color: var(--text-muted); text-transform: uppercase; letter-spacing: 0.5px; }
-
-.node-status { font-size: 10px; font-weight: 600; padding: 2px 6px; border-radius: 4px; border: 1px solid transparent; }
-.node-status.done { background: rgba(16,185,129,0.1); color: #34d399; border-color: rgba(16,185,129,0.2); }
-.node-status.in_progress { background: rgba(59,130,246,0.1); color: #60a5fa; border-color: rgba(59,130,246,0.2); animation: pulse-light 2s infinite; }
-.node-status.pending { background: rgba(255,255,255,0.05); color: var(--text-muted); border-color: var(--border-primary); }
-
-@keyframes pulse-light {
-  0% { box-shadow: 0 0 0 0 rgba(96,165,250,0.2); }
-  70% { box-shadow: 0 0 0 4px rgba(96,165,250,0); }
-  100% { box-shadow: 0 0 0 0 rgba(96,165,250,0); }
-}
-
-.node-title { font-size: 14px; font-weight: 600; color: var(--text-primary); margin-bottom: 8px; line-height: 1.4; }
-
-.node-footer { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; margin-bottom: 6px; }
-.node-owner { font-size: 11px; font-weight: 500; color: var(--accent-light); display: flex; align-items: center; gap: 4px; background: var(--accent-bg); padding: 2px 8px; border-radius: 10px; }
-.node-priority { font-size: 10px; font-weight: 700; font-family: 'JetBrains Mono', monospace; }
-.node-priority.P0 { color: #ef4444; }
-.node-priority.P1 { color: #f59e0b; }
-.node-priority.P2 { color: var(--text-muted); }
-.node-task { font-size: 10px; font-family: 'JetBrains Mono', monospace; color: var(--blue-text); background: rgba(59,130,246,0.1); padding: 2px 6px; border-radius: 4px; }
-
-.node-summary { margin-top: 8px; padding-top: 8px; border-top: 1px dashed var(--border-primary); font-size: 11px; color: var(--text-tertiary); line-height: 1.5; }
-.node-summary strong { color: var(--text-secondary); }
-
-</style>
+<!--
+  任务看板 —— goal/task 两级模型的独立页面（39 号文档 §二 P2）。
+
+  在此之前 goal/task 只能在 GraphConsole 左栏的窄侧栏里看，这里把同一份组件
+  （GoalTaskPane + goal-task-model.js）铺满整页，数据层原样不动，不重写。
+
+  点一条 task 不在本页画执行图（那是 GraphConsole 的活），而是跳过去 ——
+  `/:id/graph-console?goal=...&task=...` 是 GraphConsole 已经支持的选中态复原路径
+  （见该文件 onMounted 里 `route.query.goal` / `route.query.task` 那两行），不新开一条协议。
+-->
+<template>
+  <div class="board">
+    <header class="top">
+      <div class="who">
+        <router-link :to="`/${companyId}/overview`" class="back">←</router-link>
+        <b>{{ company?.name || companyId }}</b>
+        <span class="sep">任务看板</span>
+      </div>
+      <router-link :to="`/${companyId}/graph-console`" class="to-console">🕸️ 执行控制台</router-link>
+    </header>
+
+    <div class="body">
+      <GoalTaskPane
+        :company-id="companyId"
+        :goals="goals"
+        :loading="goalsLoading"
+        :selected-task-id="selectedTaskId"
+        :selected-goal-id="selectedGoalId"
+        :slots="slots"
+        @select="goToDetail"
+        @refresh="loadGoals"
+      />
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed, onMounted, onBeforeUnmount } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import GoalTaskPane from '@/components/graph-console/GoalTaskPane.vue';
+
+const route = useRoute();
+const router = useRouter();
+const props = defineProps({ id: { type: String, default: '' } });
+const companyId = computed(() => props.id || route.params.id);
+
+const company = ref(null);
+const goals = ref([]);
+const goalsLoading = ref(false);
+const slots = ref(null);
+const selectedGoalId = ref('');
+const selectedTaskId = ref('');
+
+let treePoll = null;
+
+onMounted(async () => {
+  selectedGoalId.value = String(route.query.goal || '');
+  selectedTaskId.value = String(route.query.task || '');
+  await Promise.all([loadCompany(), loadGoals()]);
+  // 与 GraphConsole 同款兜底：没有公司级 SSE 通道，靠轮询看到别处发生的状态变化
+  treePoll = setInterval(() => { loadGoals(); }, 20000);
+});
+onBeforeUnmount(() => clearInterval(treePoll));
+
+async function loadCompany() {
+  try {
+    const r = await fetch(`/api/company/${companyId.value}`);
+    if (r.ok) company.value = await r.json();
+  } catch { /* 页头名字掉了不影响功能 */ }
+}
+
+async function loadGoals() {
+  goalsLoading.value = true;
+  try {
+    const r = await fetch(`/api/company/${companyId.value}/goals?withTasks=1`);
+    if (!r.ok) return;
+    const j = await r.json();
+    goals.value = j.goals || [];
+    slots.value = j.slots || null;
+  } catch { /* 轮询失败保留上一份树 */ } finally {
+    goalsLoading.value = false;
+  }
+}
+
+/** 点一条 task：跳到执行控制台看它的图，选中态通过 query 带过去 */
+function goToDetail({ goalId, taskId }) {
+  selectedGoalId.value = goalId || '';
+  selectedTaskId.value = taskId || '';
+  if (!taskId) return;
+  router.push({ path: `/${companyId.value}/graph-console`, query: { goal: goalId || '', task: taskId } });
+}
+</script>
+
+<style scoped>
+.board { display: flex; flex-direction: column; height: 100vh; background: #fff; color: #1a1a1a; }
+
+.top {
+  display: flex; align-items: center; justify-content: space-between;
+  padding: 10px 16px; border-bottom: 1px solid #eee; flex: 0 0 auto;
+}
+.who { display: flex; align-items: center; gap: 8px; font-size: 13px; }
+.back { text-decoration: none; color: #666; font-size: 16px; }
+.sep { color: #999; }
+.to-console { text-decoration: none; color: #2b6cb0; font-size: 12px; font-weight: 600; }
+.to-console:hover { text-decoration: underline; }
+
+.body { flex: 1 1 auto; overflow-y: auto; padding: 16px 24px; max-width: 900px; width: 100%; margin: 0 auto; box-sizing: border-box; }
+
+@media (max-width: 700px) {
+  .body { padding: 12px; }
+}
+</style>