diff --git a/docs/README.md b/docs/README.md index bb04822..d76af7a 100644 --- a/docs/README.md +++ b/docs/README.md @@ -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:` 写进本体 `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/（暂缓，非当前重心） diff --git a/docs/todo/system-design/39-boss-agent-task-supervision.md b/docs/todo/system-design/39-boss-agent-task-supervision.md new file mode 100644 index 0000000..b1ccc99 --- /dev/null +++ b/docs/todo/system-design/39-boss-agent-task-supervision.md @@ -0,0 +1,182 @@ +# 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 行）。 diff --git a/docs/todo/system-design/40-agent-chat-streaming-interrupt.md b/docs/todo/system-design/40-agent-chat-streaming-interrupt.md new file mode 100644 index 0000000..b9572c3 --- /dev/null +++ b/docs/todo/system-design/40-agent-chat-streaming-interrupt.md @@ -0,0 +1,206 @@ +# 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。 + +本文档目前没有遗留的未决问题；进入实现阶段后如果冒出新的（比如风险②实测的具体数字要调整 +预算），回来更新这一节。 diff --git a/scripts/backfill-ceo-hire.js b/scripts/backfill-ceo-hire.js new file mode 100644 index 0000000..cfd91bc --- /dev/null +++ b/scripts/backfill-ceo-hire.js @@ -0,0 +1,58 @@ +#!/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(); diff --git a/server/index.js b/server/index.js index 28cbd47..14f81c3 100644 --- a/server/index.js +++ b/server/index.js @@ -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 上，那是进程内的）， // 于是重启后队里的任务会一直躺着 —— 界面上和「正在排队」一模一样，正是本批要消灭的症状。 diff --git a/server/routes/agent-chat.js b/server/routes/agent-chat.js index 7ea113e..d93b486 100644 --- a/server/routes/agent-chat.js +++ b/server/routes/agent-chat.js @@ -1502,13 +1502,18 @@ router.delete('/:agentId/conversations/:convId', (req, res) => { }); /** 停止当前正在生成的任务 */ -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('/:agentId/uploads/:convId/:filename', (req, res) => { // 同一 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('/:agentId/chat', async (req, res) => { 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('/:agentId/chat', async (req, res) => { 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 }); diff --git a/server/routes/company.js b/server/routes/company.js index 12ad0da..6e30632 100644 --- a/server/routes/company.js +++ b/server/routes/company.js @@ -8,10 +8,14 @@ const express = require('express'); 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('/create', async (req, res) => { 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('/:companyId/tasks', (req, res) => { 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); diff --git a/server/services/devloop/path-resolver.js b/server/services/devloop/path-resolver.js index 6bbec10..73636d1 100644 --- a/server/services/devloop/path-resolver.js +++ b/server/services/devloop/path-resolver.js @@ -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 = 'sandbox', 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 = 'sandbox', 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 = 'sandbox', 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 = 'sandbox', 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, diff --git a/server/services/graph-engine.js b/server/services/graph-engine.js index 83c0a3d..eb31e36 100644 --- a/server/services/graph-engine.js +++ b/server/services/graph-engine.js @@ -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', }); diff --git a/server/services/task-settle.js b/server/services/task-settle.js index ef2027b..e49f6ca 100644 --- a/server/services/task-settle.js +++ b/server/services/task-settle.js @@ -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，别再去比字符串相等。 diff --git a/server/services/work-graph-db.js b/server/services/work-graph-db.js index 5934a0d..21de6f5 100644 --- a/server/services/work-graph-db.js +++ b/server/services/work-graph-db.js @@ -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} 处理`); diff --git a/server/src/core/agent-session-lock.js b/server/src/core/agent-session-lock.js index e42d66c..adcbcc7 100644 --- a/server/src/core/agent-session-lock.js +++ b/server/src/core/agent-session-lock.js @@ -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 }; diff --git a/server/tests/devloop/path-resolver.test.js b/server/tests/devloop/path-resolver.test.js index 453e0b7..13d944f 100644 --- a/server/tests/devloop/path-resolver.test.js +++ b/server/tests/devloop/path-resolver.test.js @@ -162,6 +162,70 @@ describe('pathResolver', () => { }); }); + 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/); diff --git a/server/tests/unit/agent-chat-interrupt.test.js b/server/tests/unit/agent-chat-interrupt.test.js new file mode 100644 index 0000000..055dddd --- /dev/null +++ b/server/tests/unit/agent-chat-interrupt.test.js @@ -0,0 +1,118 @@ +/** + * 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; + }); +}); diff --git a/server/tests/unit/graph-engine-target-dir.test.js b/server/tests/unit/graph-engine-target-dir.test.js new file mode 100644 index 0000000..0baaa00 --- /dev/null +++ b/server/tests/unit/graph-engine-target-dir.test.js @@ -0,0 +1,140 @@ +/** + * 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); + }); +}); diff --git a/server/tests/unit/graph-engine.test.js b/server/tests/unit/graph-engine.test.js index 87603ce..160547e 100644 --- a/server/tests/unit/graph-engine.test.js +++ b/server/tests/unit/graph-engine.test.js @@ -752,6 +752,90 @@ describe('graph-engine', () => { }); // ────────────────────────────────────────────────────────────── + // 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）', () => { diff --git a/server/tests/unit/route-auth-gate.test.js b/server/tests/unit/route-auth-gate.test.js index 9e33c7a..67af657 100644 --- a/server/tests/unit/route-auth-gate.test.js +++ b/server/tests/unit/route-auth-gate.test.js @@ -44,8 +44,8 @@ describe('route-auth-gate（38 号文档 Phase 1）', () => { 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', () => { diff --git a/server/tests/unit/task-blocked-ceo-wake.test.js b/server/tests/unit/task-blocked-ceo-wake.test.js new file mode 100644 index 0000000..3eb3e97 --- /dev/null +++ b/server/tests/unit/task-blocked-ceo-wake.test.js @@ -0,0 +1,189 @@ +/** + * 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); + }); +}); diff --git a/server/tests/unit/task-entry-draft-mode.test.js b/server/tests/unit/task-entry-draft-mode.test.js new file mode 100644 index 0000000..7844220 --- /dev/null +++ b/server/tests/unit/task-entry-draft-mode.test.js @@ -0,0 +1,135 @@ +/** + * 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(); + }); +}); diff --git a/server/tests/unit/task-slots-parallel.test.js b/server/tests/unit/task-slots-parallel.test.js index 91853eb..a4fc3d6 100644 --- a/server/tests/unit/task-slots-parallel.test.js +++ b/server/tests/unit/task-slots-parallel.test.js @@ -587,6 +587,53 @@ describe('批 4 · 公司级执行位（max_parallel_tasks）', () => { }); // ──────────────────────────────────────────────────────────────── + // ⑤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 的存量库', () => { diff --git a/system/agents/ceo/heartbeat.md b/system/agents/ceo/heartbeat.md new file mode 100644 index 0000000..cc0a2fb --- /dev/null +++ b/system/agents/ceo/heartbeat.md @@ -0,0 +1,21 @@ +# 心跳任务 + +你收到的心跳消息会提"扫描全局 OKR 目标状态"——那是通用触发文案，对你不适用。 +你要看的是本公司的 **goal/task 板**（`tools.md` 里的读接口），不是 OKR。 + +## 每次心跳 + +- [ ] 查 `GET /tasks?status=blocked` 和 `?status=failed`，看有没有需要处理的 +- [ ] 查 `GET /goals?status=active`，扫一眼有没有明显该调整优先级的 +- [ ] 都正常就直接回复"心跳正常"，不要为了"用一下工具"而用工具 + +## 发现问题时 + +- 具体判断依据见 `tools.md` 的"什么时候该提新任务、什么时候该改优先级"一节 +- 新提的任务一律带 `draft:true`，判断确实清楚、值得马上跑再 `enqueue` +- 不确定的情况，把观察写进正文回复，不要瞎猜着动手改数据 + +## 不用管的 + +- 正在排队 / 正在跑但没超时的 task——那是调度器的活，不用你盯 +- 纯技术性的失败（比如基础设施抖动）——引擎自己有重试和熔断机制 diff --git a/system/agents/ceo/tools.md b/system/agents/ceo/tools.md new file mode 100644 index 0000000..8097d53 --- /dev/null +++ b/system/agents/ceo/tools.md @@ -0,0 +1,104 @@ +# CEO 工具箱 + +> 你的岗位是监督本公司的 goal/task 板（不是执行任务——`org-planner`/`org-coder`/`org-validator` +> 那条流水线干活，你只看板、判断、必要时提一条新任务或调一下优先级）。 +> +> 大部分心跳触发下，你**只需要读**：看一眼有没有 `blocked`/`failed` 太久的 task，正常就 +> 回复"心跳正常"，什么都不用调用。只有真发现问题时才用下面的写工具。 + +--- + +## 认证：每次调用都要带这个头 + +```bash +curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company//goals" \ + -H "x-internal-token: $LEMON_INTERNAL_TOKEN" +``` + +`LEMON_INTERNAL_TOKEN` 是你的进程环境变量里现成的（服务端 spawn 你的时候自动带上）， +不用去别处找、也不用自己生成。**忘了带这个头，所有请求都会 401**——先检查这个， +不要一看到 401 就怀疑接口路径写错了。 + +`` 换成你自己所在的公司 id（就是你运行时坐标里那个 cid）。 + +--- + +## 读：先看板子上有什么 + +### 看哪些 goal 在跑 +```bash +curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company//goals?status=active" \ + -H "x-internal-token: $LEMON_INTERNAL_TOKEN" +``` + +### 找卡住的 task（这是你心跳时主要要查的） +```bash +curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company//tasks?status=blocked" \ + -H "x-internal-token: $LEMON_INTERNAL_TOKEN" +curl -s "${LEMON_API_BASE:-http://localhost:3010/api}/company//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//goals/" \ + -H "x-internal-token: $LEMON_INTERNAL_TOKEN" +``` + +--- + +## 写：只在真正判断需要时才用 + +### 改一条 task 的优先级 +```bash +curl -s -X PATCH "${LEMON_API_BASE:-http://localhost:3010/api}/company//tasks/" \ + -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//tasks" \ + -H "x-internal-token: $LEMON_INTERNAL_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"goal_id":"","task":"<这条新任务要做什么，写清楚，别人要能看懂>","draft":true}' +``` +**必须带 `"draft":true`。** 不带的话这条任务会立刻入队执行——你的判断和 `task-planning` +拆分一样，都是一次"猜"，不该自己直接烧预算。落库后返回一个 `taskId`。 + +### 把你（或别人）提的草稿正式下达 +```bash +curl -s -X POST "${LEMON_API_BASE:-http://localhost:3010/api}/company//tasks//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`） | 会立刻烧预算，见上面的强调 | diff --git a/system/agents/zz-chat-interrupt/agent.md b/system/agents/zz-chat-interrupt/agent.md new file mode 100644 index 0000000..da566e4 --- /dev/null +++ b/system/agents/zz-chat-interrupt/agent.md @@ -0,0 +1 @@ +# 打断-排队单测用的常驻本体 diff --git a/system/agents/zz-chat-interrupt/config.json b/system/agents/zz-chat-interrupt/config.json new file mode 100644 index 0000000..6cc3644 --- /dev/null +++ b/system/agents/zz-chat-interrupt/config.json @@ -0,0 +1,6 @@ +{ + "id": "zz-chat-interrupt", + "type": "skill", + "name": "zz-chat-interrupt", + "status": "active" +} \ No newline at end of file diff --git a/system/agents/zz-chat-interrupt/identity.md b/system/agents/zz-chat-interrupt/identity.md new file mode 100644 index 0000000..a205872 --- /dev/null +++ b/system/agents/zz-chat-interrupt/identity.md @@ -0,0 +1 @@ +# zz-chat-interrupt diff --git a/vitest.config.js b/vitest.config.js index 7da9f66..5f9d9f0 100644 --- a/vitest.config.js +++ b/vitest.config.js @@ -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'], diff --git a/web/src/components/AppNav.vue b/web/src/components/AppNav.vue index 0a1b6b4..6d2ec90 100644 --- a/web/src/components/AppNav.vue +++ b/web/src/components/AppNav.vue @@ -61,8 +61,8 @@ ⚙️ SOP - - 🎯 OKR + + 🗂️ 任务看板 📁 Files diff --git a/web/src/composables/agentChatEvents.js b/web/src/composables/agentChatEvents.js new file mode 100644 index 0000000..dc51085 --- /dev/null +++ b/web/src/composables/agentChatEvents.js @@ -0,0 +1,131 @@ +/** + * 从 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; + } + }; +} diff --git a/web/src/composables/agentChatEvents.test.js b/web/src/composables/agentChatEvents.test.js new file mode 100644 index 0000000..9f99b99 --- /dev/null +++ b/web/src/composables/agentChatEvents.test.js @@ -0,0 +1,129 @@ +/** + * 回归测试：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(); + } + }); +}); diff --git a/web/src/router/index.js b/web/src/router/index.js index eb0a784..eb370ee 100644 --- a/web/src/router/index.js +++ b/web/src/router/index.js @@ -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, }, // 新增独立页面 { diff --git a/web/src/views/AgentChat.vue b/web/src/views/AgentChat.vue index 961cd63..dbc6074 100644 --- a/web/src/views/AgentChat.vue +++ b/web/src/views/AgentChat.vue @@ -128,24 +128,27 @@
-
-
{{ msg.role === 'user' ? '👤' : (agentInfo.emoji || '🏗️') }}
-
-
- {{ msg.role === 'user' ? '你' : agentInfo.name }} - {{ formatMsgTime(msg.timestamp) }} -
-
- -
-
- {{ att.type === 'image' ? '🖼️' : '📄' }} - {{ att.name }} - {{ formatFileSize(att.size) }} +
{{ agentInfo.emoji || '🏗️' }}
@@ -186,11 +189,17 @@ {{ f.name }} +{{ uploadedFiles.length - 3 }}
+ +
+ 上一条还在收尾… + +
- - + + +
Shift+Enter 换行 · {{ chatState.messages.length }} 条消息
@@ -360,6 +369,7 @@ import { useRoute, useRouter } from 'vue-router' 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 () => { .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 { diff --git a/web/src/views/CompanyDashboard.vue b/web/src/views/CompanyDashboard.vue index 9a8f983..18c3c61 100644 --- a/web/src/views/CompanyDashboard.vue +++ b/web/src/views/CompanyDashboard.vue @@ -43,6 +43,11 @@ + + @@ -355,103 +360,6 @@
- -
-
- -
-
- 🎯 OKR 目标 - {{ goals.length }} -
-
-
-
- {{ g.id }} - {{ okrStatusLabel(g.status) }} -
-
{{ g.title }}
-
-
- {{ Math.round(g.progress * 100) }}% -
-
- 👤 {{ g.owner }} - {{ g.doneCount || 0 }}/{{ g.totalCount || 0 }} -
-
-
暂无目标
-
-
- - -
-
-
- {{ selectedGoalDetail.id }} - {{ okrStatusLabel(selectedGoalDetail.status) }} - 👤 {{ selectedGoalDetail.owner }} -
-

{{ selectedGoalDetail.title }}

-

{{ selectedGoalDetail.description || '暂无详细描述' }}

-
-
- 目标总体进度 - {{ Math.round(selectedGoalProgress.progress * 100) }}% -
-
-
- 总: {{ selectedGoalProgress.total }} - ✅ {{ selectedGoalProgress.done }} - 🔄 {{ selectedGoalProgress.inProgress }} - ⏳ {{ selectedGoalProgress.pending }} -
-
-
-
-

OKR 拆解树

-
-
-
-
-
-
- {{ node.id }} - {{ okrLevelName(node.level) }} - {{ okrStatusLabel(node.status) }} -
-
{{ node.title }}
-
- 👤 {{ node.owner }} - {{ node.priority }} - 🔗 {{ node.taskId }} -
-
摘要: {{ node.summary }}
-
产出: {{ node.output }}
-
-
-
-
暂无 OKR 节点
-
-
-
-
-
-
🎯
-

OKR 目标看板

-

从左侧选择一个目标查看拆解树与进度

-
-
-
-
-
@@ -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 { diff --git a/web/src/views/OkrDashboard.vue b/web/src/views/OkrDashboard.vue deleted file mode 100644 index ac5dd47..0000000 --- a/web/src/views/OkrDashboard.vue +++ /dev/null @@ -1,352 +0,0 @@ - - - - - diff --git a/web/src/views/TaskBoard.vue b/web/src/views/TaskBoard.vue new file mode 100644 index 0000000..de7e3fd --- /dev/null +++ b/web/src/views/TaskBoard.vue @@ -0,0 +1,112 @@ + + + + + +