Compare commits

...

No commits in common. "master" and "v0.3.1" have entirely different histories.

108 changed files with 6466 additions and 18281 deletions

7
.gitignore vendored
View File

@ -1,8 +1 @@
.scratch/
.research/
node_modules/
*.log
.stats.html
review_results.json
# 生图实验残留,不进版本历史;要留下的预览图放 docs/
dsh-image-gen/

View File

@ -1,264 +0,0 @@
# Changelog
> 版本号以 `package.json` 为准(当前 0.14.0)。更早的 0.6.x 条目沿用旧编号,保留作历史。
## 0.14.0 — 入口生命周期、项目识别、项目隔离与会话订阅
- **入口注册按服务生命周期**:betterSidebar / 原生 sidebarRightTabs 通过 `ctx.inject` 监听,服务晚到或重挂时先清理旧注册再重建,两条路径互斥不重复;原生降级补齐 `guide` 胶囊,第一次进入不再找不到「朝堂」。
- **项目识别不再猜首项目**:当前工作区由 `sessions.list` 的 `mainView` 保留会话与 `workspaces.list` 的会话归属公开推导;`uiWorkspace.currentWorkspaceId` / `selection` 不再是依赖。没有明确项目时只显示项目清单和选择引导,bootstrap 也不再默认返回第一个项目。
- **项目隔离**:所有部门操作继续显式携带 projectId;切换项目会丢弃旧项目迟到响应,避免 A 的席位/任务显示到 B。
- **会话订阅**:follow 地址改为 `{kind:'session', sessionId}`,支持 `{kind:'subagent', parentSessionId, childSessionId, mode}`;同一会话只保留一条流,订阅失败会把对应绑定标成 unavailable(缺少 follow 能力的宿主除外)。
- **移除退役预设**:部门会话不再硬编码 `sansheng-liubu` 预设;显式预设先经宿主 `agentPresets.list()` 校验,不存在时返回明确错误。
- **清理旧安装自检**:`workbench-install.mjs` 只打印迁移说明,不再改 profile;`workbench-preflight.mjs` 改为严格只读、只检查主包入口与 16 条路由,不再要求独立 workbench 包。
## 0.13.2 — 修面板接管主区时与官方入口重复声明槽位
0.13.1 修好 betterSidebar 后,干净档案实测继续往下走又撞到第二个启动失败:面板接管 `main.conversation` 时在 children 里声明 `conversation.header`,而官方会话入口已经声明了同一个槽,宿主的槽注册表拒绝重复声明、同步抛错,面板再次激活失败。改为先按原样注册、被拒时退回不带 children 的注册(槽由官方入口声明、仍然存在,组件里的 renderSlot 照常渲染)。
## 0.13.1 — 修面板在缺 betterSidebar 的宿主上把整个启动页打崩
干净档案实测发现:面板的 `betterSidebarOf` 里有一处未经防护的 `ctx.betterSidebar` 直读——该服务不在面板的 inject 声明里,宿主没有它时 Cordis 直接抛错,面板激活失败并把整个 web 启动打到「Failed to load plugins」页(白屏)。这与面板自己「服务探测缺了也要照常加载」的设计意图相悖。改为只走带 try/catch 的 `readService` 探测:缺服务时按原有降级路径走(警告 + 仍注册 pane 槽),有服务时行为不变。
## 0.13.0 — 朝堂面板并回主包:商店里只剩一条
应需求把面板包 `dsh-sansheng-liubu-workbench`(0.2.0)并回主包 `dsh-sansheng-liubu-mode`,单独安装时不再装两条:
- 根包新增 `dsh.client`(平台与 inject 沿用面板原来的三项)与 exports `./client`,指向 `workbench/panel/lib/client.js`;面板客户端的模块注册 id、CSS id 与 DOM 标记同步改为主包名。
- 面板子包退役:其 package.json 去掉 `dsh` 声明并标 private,不再作为独立 bundle 被组合;`workbench/panel/` 目录保留为面板客户端的源码/产物所在。
- 根包去掉 `private: true`(为发布到自有 Gitea npm 源做准备;git 安装不受影响)。
- 商店索引同步去掉「三省六部 · 朝堂面板」一条,描述改回单条安装。QQ-dsh 捆绑包仍按旧结构 vendored,后续再跟进。
## 0.12.1 — 宿主冲突审计与加固
对现行工作台做了一次完整的宿主接触面审计(patch 槽位、路由、UI 槽位、服务注册、会话 API、文件与定时器),结论:没有 M-02/M-03 式的硬冲突(不占 settings.trigger、不停用宿主设置页、不改搜索提供方、不注册任何服务/工具/命令,路由只用自有前缀)。审计中发现并修掉一处隐患:
- **极简入口防重复启动**:`index.js` 增加全局单例护栏(Symbol.for 注册 + 引用计数)。插件被重复应用时(如 profile 里还留着旧预设段、按会话重复挂载)不再另起一份宿主,避免两份宿主重复注册路由、双写同一本账本;引用全部释放后才真正停掉宿主。
- 根 `cordis.patch.yml` 的注释更新为退役后的现状(此前还指向已删除的 preset.patch.yml)。
审计备忘(不改代码):工作台面板默认接管 `main.conversation` 槽位(priority -1,原生内容透传,有 localStorage 逃生开关);与全局记忆插件(Mnemosyne 系)无名称/文件冲突,但对方的全局注入会叠加到部门会话上,属预期内的软性相互影响。
## 0.12.0 — 第三层记忆:每个部门一份自己的长期记忆
应需求给 0.10.0 的两层记忆补上第三层(设计文档同步升为 v2):
- **新增部门记忆**:`memory/departments/<roleId>.md`,一个席位一份,跟着部门跨项目走;roleId 按十席名单校验,非法 ID 明确报错。
- **召回**:派发摘录变为三段,顺序为部门记忆(主责部门自己那份,上限 2000 字)→ 项目记忆(3000 字)→ 长期记忆(2000 字)。只注入主责部门自己的经验本,别的部门读不到。
- **记账**:新成果落账后,部门记忆里同步记一行「在项目「<项目名>」汇报成果(任务「<标题>」):<摘要>」,带上项目出处;幂等重复汇报不重复记。
- **接口**:`memory/get|put|append` 的 scope 新增 `department`(需带 roleId),路由数量不变(仍 16 条)。
- 新增 5 项测试,全量 175 项通过。
## 0.11.0 — 退役老预设线,只留工作台
按现行方案(`docs/v0.1-实施方案.md`:十席独立会话、身份由项目+席位绑定注入)执行退役。旧方案的 Team/子 agent 模型整体移除:
- **删除**:`preset.patch.yml`、朝堂侧栏 `panel/`(含其客户端与测试)、`scripts/mode.mjs`、`scripts/preview.mjs`、`locale/`、`test/policy.test.js`。
- **根 `index.js` 重写为极简入口**:只在应用根上启动工作台宿主(`createWorkbenchHost`),卸载时停掉;不注册预设、不读 Team 成员身份、不注入角色提示词、不做工具守卫、不提供 /dept-model 命令。
- **随老线退役的能力**:基于成员身份的角色判定、丞相组队流程、工具守卫(含未分类工具拦截)、预设内按部门改模型。工作台的账本、席位绑定、派工对账与分层记忆不受影响——它们本来就走独立会话模型。
- **包名保持 `dsh-sansheng-liubu-mode` 不变**,仅为让既有 bundle 登记继续有效;它不再提供任何模式。升级时请删掉 profile `cordis.patch.yml` 里旧的上朝预设段。
- 单测随之减少:删除的 policy/panel 测试共 55 项,余下全部为工作台测试。
## 0.10.0 — 三省六部有记忆了:长期记忆 + 项目记忆
- 新增分层记忆(设计见 `docs/记忆设计.md`,思路借鉴 DS Bot 的分层记忆,落在原生账本之外):长期记忆一份(跨项目,记用户偏好与长期经验),项目记忆一项目一份(记这个项目发生过什么、结论是什么),都是侧车目录 `memory/` 下的 Markdown 文件,用户可以直接打开看、打开改。
- 隔离按本项目的规矩:项目记忆只认项目 ID、项目之间互不可见,不学 DS Bot 上游「主 Bot 可读全部记忆」的弱隔离。
- 派发时自动注入:dispatchTask 把项目记忆(上限 3000 字)与长期记忆(上限 2000 字)的摘录并进上下文包的 excerpts,部门开工前就能看到;记忆读失败不拦派发。
- 成果自动记账:新成果汇报落账后,往项目记忆追加一行(哪个部门、做了什么),重复汇报不重复记;写失败不影响成果本身。
- 新增三条路由(共 16 条):POST /memory/get、/memory/put、/memory/append;服务层未启用记忆时明确报 INVALID_STATE,不假装。
- 测试新增 6 项(记忆存储、隔离与上限、服务 API、派发注入、自动记账去重),全量 226 项通过;preflight 路由数同步为 16。
## 0.9.2 — 模型设置这次真的会落到部门身上
- 面板原来从 `ctx.remote.commands` 取指令接口,新宿主把服务挂成 `remote.commands`(要写进 inject,用 `ctx.get` 取),所以一直报「没有直接执行指令的接口」;现在按官方挂法取,并在 inject 里声明 `remote.session` / `remote.subagents` / `remote.commands`。
- 宿主返回的是 `{ ok, value: { commandId, result } }`,面板现在先解包再判断 `result.kind`,同步兼容旧的裸返回。
- 保存失败时也会把 busy 放掉:以前宿主一拒绝,两个下拉框就永久变灰点不动。
- 测试 55 项(新增「指令接口挂在 `ctx.get` 上也能静默执行」)。
## 0.9.1 — 三省与六部之间真的空开了
- 上一版只加了三省、六部**组内**卡片的间距;「三省」整组到「六部」整组之间还是贴着的。
- 这次给六部这块加 `margin-top: 16px`,任何侧栏宽度下都留出空隙,不再靠那条细连接线撑门面。
## 0.9.0 — 你也可以直接给部门派活,模型不再绕丞相
- 席位详情里新增「直接派活」:写清要办的事,点「派给礼部」,消息直接进该部门自己的会话——丞相收不到、也不参与。丞相照旧可以自己派活,两条路互不干扰。
- 派活走宿主 `subagents.prompt`(`{ requestId, parentSessionId, childSessionId, mode: "continuable", delivery: "queue" }`),每次带独立 requestId;宿主拒绝时把原因原样显示。
- 改模型不再借丞相的会话:先在部门自己的会话里执行 `/dept-model`,那个会话冷着就退到任一已登记会话——指令只写全局路由表,依然不产生对话消息、不唤醒模型。
- 测试新增 4 项(派活投递、非子会话报错、模型优先用部门会话、失败回退且不发消息),全量 54 项通过。
## 0.8.0 — 换完即存,不再惊动智能体
- 模型和推理等级改成**选完就保存**,去掉「保存模型设置」按钮;脚注直接显示「自动保存 · 当前:…」。
- 保存改走宿主 `commands/execute` 直接执行 `/dept-model`:不投递提示词、不在对话里留消息、不触发模型轮次,丞相不会因此进入大段推理。
- 宿主没有这个接口或指令尚未加载时,只在前端报错(「宿主没有执行这条指令」),不会退化成一条普通消息发给智能体。
- 测试新增两项:确认改模型时**不**调用 `session.prompt`、以及缺接口时的报错;全量 50 项通过。
## 0.7.2 — 三省与六部之间松一点
- 三省(`.sl-grid-3`)与六部(`.sl-grid-6`)的卡片间距从 8–10px 统一到 12px,三个容器断点(含 ≤620px 的两列布局)一起调,窄侧栏下也不再挤在一起。
## 0.7.1 — 十个席位都有模型设置,没召见的也能先选好
- 面板「模型设置」原来只在 `seat.present` 时渲染,没召见的部门连入口都没有。现在绑定的是席位本身:未召见的部门也能选模型,保存时同样下发 `/dept-model <角色> <provider> <model> [推理等级]`,并注明「召见后生效」。
- 未召见的席位读清单时不再传会话 id:直接读全局清单,当前值取面板里固定过的那条;保存后脚注写「该部门还没召见;保存后在召见时生效」。
- 顺带修掉一个由缺席席位暴露的 bug:`activeSeat` 在 `activeChildId` 为空时会撞上「没有会话 id 的缺席席位」(`undefined === undefined`),把标题写成「正在与吏部对话」。现在只有存在子会话时才去找席位。
- 预览脚本新增 `--absent=<角色,...>`,可以直接截「未召见的部门」这一态;演示数据补上全局清单的 `default` 字段,缺席席位才有默认可选模型。
- 测试新增「还没召见的部门也能先选好模型,保存走 /dept-model」;`node --test` 49 项全过。
## 0.7.0 — 每个部门可以单独固定模型
- 部门是子会话(`origin: "subagent"`),宿主的 `session.selectModel` 对它们一律拒绝(`session/agent-busy`,建议走 subagent delivery),所以「在这里选好就生效」原来根本做不到。现在面板改为下发 `/dept-model <部门> <provider> <model> [推理等级]` 指令,由模式插件按角色把模型写进运行时路由表并落盘 `routes.json`,`agent/request` 钩子在下一轮开工时生效。
- 模式插件新增 `parseDeptModelCommand` / `describeDeptRoutes` / `readStoredRoutes` / `writeStoredRoutes`:支持 set、`list`、`clear [部门]`,未知部门与参数不足各自给出可读原因;路由文件按 `DSH_HOME`(缺省 `~/.dsh`)下的 `sansheng-liubu/routes.json` 读写,读不到就当没固定过。
- 面板「模型设置」对部门显示「按部门固定」,选好保存即固定,脚注显示「该部门固定使用此模型」;每个部门的固定值用 `localStorage` 记在面板侧(`sansheng-liubu.route.<角色>`),用于显示当前模型。
- 预览脚本新增 `--seat=<角色>`,可以直接截某个部门的详情;演示数据补了 `localStorage` 与部门子会话地址,工部示例固定为 DeepSeek V4。
- 测试:客户端新增「改模型改由丞相会话下发 /dept-model」「固定路由从面板记录读出来当当前模型」两项;策略侧新增指令解析与路由文件往返用例。`node --test` 48 项全过。
## 0.6.0 — 模型选择真的能用了
- 部门设置里的模型清单原来靠 `modelDirectories.directoryFor(sessionId)` 取该会话的目录,而这个方法只认「本页登记过的会话」,于是每个还没在面板里打开过的部门都读不到模型。现在清单改从宿主的全局目录 `modelDirectories.catalog` 读(`catalog.load()` 一份,所有部门共用),不再依赖会话登记。
- 保存模型改成真正的 RPC:有 `ModelDirectory` 时走 `directory.select(...)`,没有时直接 `remote.session.selectModel({ sessionId, provider, model, reasoningEffort })`。**没在本页打开过的部门也能改模型**,保存后立即生效。
- 「当前模型」读不到该部门自己的选择时,退回全局默认并标明「跟随默认」,不再冒充成别人的选择;界面脚注会说明「该部门会话未在本页打开,选好保存后直接生效」。
- 错误分级:服务缺失 →「当前宿主没有全局模型清单(modelDirectories.catalog)」;清单读取失败 →「读取模型清单失败:<原文>」;6 秒超时 →「读取模型清单超时(显示已知缓存)」;宿主拒绝保存 → 「<code>:<message>」。
- 测试从 4 项模型用例重写为 6 项:服务缺失、清单来自全局且不依赖登记、未登记时保存走 RPC、宿主拒绝原文、清单读取失败保留缓存、正常路径;`node --test` 客户端 35 项全过。
## 0.5.7 — 模型目录读不到时说清是哪一步断了
- 部门设置里的「当前宿主未提供模型目录」不再是一句万能提示。原来 `modelDirectoryOf` 把三种情况都吞成 `undefined`:取不到 `modelDirectories` 服务、`directoryFor` 方法不存在、`directoryFor(sessionId)` 抛异常。现在分别返回 `{ service: false }`、`{ error }`、`{ directory }`。
- 宿主的 `ModelDirectoryResolver.directoryFor` 在该会话没登记时抛 `ui-model-selection: session "<id>" resolved no scope / no binding`。这种情况不再报「宿主未提供模型目录」,而是**借另一个已登记会话的目录把全局模型清单列出来**:列表照常可选看,`current` 留空不冒充别人的选择,保存按钮禁用并写明「进入该部门会话后才能改模型」。其它异常(服务崩溃、超时、快照读取失败)原样带出原文,同时用 `[三省六部]` 前缀在控制台留下会话 id 与原始错误。
- 新增 `sessionsOtherThan`(最近活跃会话 → 任意已登记会话)做兜底;`loadCatalog` 的投影收敛成一个 `project()`,成功/超时/兜底三条路径共用,`unresolved` 随结果返回给界面。
- 新增 4 项测试:服务缺失、会话未登记时兜底且不冒充当前选择(含 `selectModel` 拒绝)、其它异常原样带出、正常路径。`node --test` 43 项、`node --check`、`git diff --check`、`check-install` 全过。
## 0.5.6 — 左栏那一行改名「上朝」并置顶
- 按用户要求把左侧栏导航行的标签从「三省六部」改成「上朝」,`order` 从 10 改为 −100,排在「插件」以外所有插件行之前(`插件` 恒列首行,是宿主写死的)。
- 只改呈现,不动行为:点击仍然是停靠右侧栏的 `main` 重定向桩。
- 39 项测试(含新增的「标签是上朝、order 为负」断言)、`node --check`、`git diff --check`、`check-install` 全过。
## 0.5.5 — 左栏只留一处入口
- 撤掉 0.5.3 的左侧栏底部入口(`sidebar.footer.action`)与它的 `SanshengRailAction` 组件、8 条 `.sl-rail-*` 样式(`.sl-rail-mark` 保留,重定向桩还在用)。0.5.4 之后左栏同时有导航行和底部一行,是同一功能的两个入口,按用户要求收敛成一个。
- 左栏现在只有「插件 / 定时任务 / 任务看板 / MCP 连接器」那一列里的「三省六部」一行;会话头部的「三省」开关仍是另一处入口(两处都只做停靠,不是两套面板)。
- 删掉 2 条只服务于底部入口的测试,槽位断言回到五个;39 项测试、`node --check`、`git diff --check`、`check-install` 全过。
## 0.5.4 — 入口搬进左侧栏导航列
- 用户要的不是底部那一条,而是「插件 / 定时任务 / 任务看板 / MCP 连接器」那一列;那一列只认 `sidebar.panellist`,于是注册一行导航:`id: sansheng-liubu`、`order: 10`、`label: 三省六部`,图标是插件画的 18px 细线「三」字样标(`SanshengNavGlyph`,激活时线宽 1.6)。
- 那一列的点击行为由宿主写死为 `selectPanel(id)`,一定要 `main` 槽,所以同时注册 `main`(`key: sansheng-liubu`)作为**重定向桩**:`SanshengDockRedirect` 挂载后立刻调 `dockToSidebarTab(host)`,停靠右侧栏、清掉旧提示、`selectPanel(null)` 退回原会话;没有会话时只在页面中央写明原因(`.sl-dock-stub`)。它不渲染朝堂、不承载聊天,这是对 0.5.0「两个槽一律不注册」的收敛式修订。
- 底部入口(`sidebar.footer.action`)保留:两处入口等价,共用同一条提示存储。
- 新增 2 条测试:导航行与 `main` 桩的注册(含 `label()` 与 `key`)、`dockToSidebarTab` 成功/失败两条路径(失败时不得 `selectPanel`)。另修了断言写法:`h("svg", props, [children])` 在测试替身里是单层嵌套,要先 `.flat()`。
- 41 项测试、`node --check`、`git diff --check`、`check-install` 全部通过。
## 0.5.3 — 左侧栏也有三省六部入口
- 在左侧栏底部(`sidebar.footer.action`,`id: sansheng-liubu:rail`)加了一个常驻入口:只做「把朝堂停靠到当前会话的右侧栏」,与会话头开关共用同一条提示存储,不切整页面板、不新增聊天存储。
- 折叠侧栏时只剩「三省」字标;展开时补上「三省六部 / 收起朝堂」文字,失败原因显示在文字下方(`role="status"`,最多两行,完整文本在 `title` 里),字标转红作为折叠状态下的可见信号。
- 不再用 `sidebar.panellist`:那个槽的点击会走 `selectPanel` 去要 `main` 槽,而 0.5.0 起不再注册 `main`,点进去只会得到空面板。
- 修掉会话头开关的一个连带问题:失败时原来会回退到 `host.togglePanel()`,同样指向不存在的整页面板;现在只写提示。
- 新增 3 条测试:左栏入口的注册与两种宽度下的渲染、无会话时的可见原因、以及「失败时不得 `selectPanel` 到无 `main` 槽的面板」。
- 39 项测试、`node --check`、`git diff --check`、`check-install` 全部通过。
## 0.5.2 — 断点跟随侧栏容器,窄栏不再挤压状态说明
- 响应式断点从浏览器视口改为面板容器:`.sl-root` 声明 `container-type:inline-size;container-name:slpanel`,11 处 `@media (max-width: …)` 全部换成 `@container slpanel (max-width: …)`。真实宿主窗口最大化时侧栏仍只有 371px,旧的视口断点一个都不会触发,等于窄栏样式从来没生效过。
- 删掉 `.sl-compact .sl-grid-3,.sl-compact .sl-grid-6` 的强制两列:它优先级高于容器断点,会把单列规则压死。现在列数完全由容器宽度决定。
- 单列阈值落在 330px 容器宽(约 348px 侧栏):360px 及以上保持两列,320px 降为单列。
- 部门配置里的「最近活动」独占一行、最多两行后省略,不再和状态文字挤在同一行被裁断;`panel/lib/client.js:891` 的 `shortText(…, 46)` 保持不变。
- `scripts/preview.mjs` 新增 `--viewport=<像素>`:窗口可比侧栏宽,用来复现「大窗口 + 窄侧栏」的真实宿主形态;新增 371px、320px 两张入库预览图。
- 新增两条回归测试:禁止视口 `@media` 断点且必须保留容器断点;`.sl-detail-status small` 必须独占一行且不得 `white-space:nowrap`。
- 36 项测试、`node --check`、`git diff --check`、`check-install` 全部通过。
## 0.5.1 — 清掉侧栏化残留,会话头开关不再静默
- 删除侧栏化后不再渲染的旧样式:独立聊天栏、整页面板壳、`sl-left-nav`、`sl-task-jump` 等 46 个类共约 117 行规则;CSS 由 374 行收到 257 行。
- 删除无调用点的 `SanshengPinRow`、`DockButton`,以及已经没有外部消费方的 `SidebarIcon` 导出;`panel/lib/client.js` 由 1890 行收到 1758 行。
- 会话头部开关在拿不到会话、或宿主没有右侧栏服务时,把失败原因直接显示在开关旁(`role="status"`,完整文本放在 `title`),不再静默回退成整页面板。
- 新增两条回归测试:开关失败提示的渲染与清除;`className` 里出现的每个 `sl-*` 类都必须有对应 CSS 规则,防止样式与组件再次脱节。
- 去掉 `sl-side-pane`、`sl-control-model`、`sl-control-effort` 三个「有类名、无规则」的幽灵类名。
- 34 项测试、`node --check`、`git diff --check`、`check-install` 全部通过。
## 0.5.0 — 收进右侧栏,聊天回归 DSH 原生
- 移除整页「三省六部」面板、丞相主对话摘要卡和第二套聊天入口;聊天统一使用 DSH 原生输入框与消息流。
- 朝堂编制与任务流转收进会话右侧栏:顶部「朝堂 / 任务」页签、四张统计卡、组织图与选中部门配置在同一侧栏内滚动。
- 在原生输入框输入 `@` 选择部门后进入其子会话;右侧栏自动选中对应部门,返回丞相时恢复丞相选中。
- 移除 `main`、`sidebar.panellist` 和 `sidebar.panellist.actions` 注册,只在会话头部与右侧栏注入入口,不再占用工作区主视图。
- 侧栏顶部改为紧凑状态行:协作状态、`输入 @ 选择部门` 提示与子会话返回按钮;统计卡可点击切换朝堂/任务。
- 移除 Agent 预设编辑与重复「下旨」输入;部门设置只保留固定职责、模型/推理等级和会话入口。
- 策略插件与面板版本推进到 0.5.0;侧栏结构、槽位注册、@ 导航和自动选中均有回归测试。
## 0.4.2 — 原生 @ 部门成员
- 在 DSH 原生会话输入框注册 `@` 来源,候选为已建立的九个子 Agent 会话;主对话仍使用宿主原有输入框,不新增第二套聊天。
- 选择 `@中书省`、`@工部` 等部门后进入该成员的现有子会话,随后直接在原生输入框发送任务;不会把消息静默转发或改写接收人。
- 进入子会话时右侧朝堂图自动选中对应部门,部门配置同步切换;返回丞相主会话时恢复选中丞相,不再出现“人在工部、面板还选着丞相”的错位。
- 面板主对话区提示改为「输入 @ 可直接找部门成员」;未设官、没有会话的部门不出现在候选中。
- 新增 @ 候选与会话导航回归测试;32 项策略和客户端测试通过。
## 0.4.1 — 重设计朝堂面板
- 按 DSH 原生主题变量重构面板:品牌与朝班状态头、丞相主对话卡、独立任务流转区、右侧统计与部门配置。
- 部门改为边界清楚的实体卡片:蓝灰描边、字徽、名称与中文状态;选中态使用蓝边、浅蓝底和勾选标记。
- 朝堂图固定为「丞相 → 三省 → 六部」:丞相连接三省,尚书省连接整个六部分组;六部两排三列,明确同属一级。
- 左侧增加「主对话 / 任务流转」切换;点击「在办任务」统计卡或对话区入口,可直接切到任务流转。
- 点击「在朝成员」统计卡进入全宽朝堂编制:收起左栏与统计,组织图和部门配置铺满面板;顶栏或地图头部均可返回协作台。
- 设置区移除 Agent 预设输入与重复的「下旨」文本框,只保留固定职责、模型/推理等级和「与某部对话」。
- 新增子 Agent 会话入口:选中部门后直接打开其 DSH 子会话;顶部可返回丞相主会话,不再另造聊天存储。
- 统计保持两列两行;右侧栏、窄屏和紧凑侧栏分别减少列数,卡片状态行不再塞入任务计数。
- 修复空闲状态显示为英文 `idle` 的问题;深色与明亮模式共用结构,颜色均由 DSH 主题变量派生。
- 策略插件与面板版本推进到 0.4.1;当时 31 项策略和客户端测试通过。
## 0.4.0 — 补齐六部
- 角色由七席扩为十席:丞相 + 三省 + 吏、户、礼、兵、刑、工六部;新增 `COURT_ROLES` 作为唯一编制来源。
- 新增 `libu`(吏部)、`hubu`(户部)、`xingbu`(刑部)角色提示词;`libu` 由「礼部」改为「吏部」,礼部改用 `lipu`,避免与吏部拼音重名。
- 按职责重划写入边界:吏部/户部只有 write、edit;礼部、刑部另有命令行;兵部另含远程与 MCP 通道;工部独有 Image-gen 生图。
- 尚书省提示词改为按吏户礼兵刑工分工、只召集真正用到的部门;丞相提示词同步十席组织。
- 面板朝堂图改为「丞相 → 三省 → 六部」三排结构,六部同排直隶尚书省;座位计数与测试同步到十席。
- 版本推进:策略插件 0.4.0,面板 0.4.0。
## 0.3.7 — 上朝改为手动启用
- 包自带的 `cordis.patch.yml` 改为空层(`[]`):装包不再往模式选择器里注册「上朝」,也不再能成为新会话的默认模式。
- 新增 `preset.patch.yml`:想上朝时把它的 `- insert:` 段合并进 profile 的 `cordis.patch.yml`,重启后才会出现该选项。
- 新增 `scripts/mode.mjs`(`npm run mode -- on|off|status`):带标记地写入/撤回那段 insert,可逆且幂等,不会替你选中模式。
- `scripts/check-install.mjs` 改为校验「装包不等于开模式」:包内 patch 必须不含预设行,`preset.patch.yml` 必须能复现同一 preset id,并报告当前是否已启用。
- README 补「启用方式」与 Git 回滚,删除已失效的 backup 目录回滚说明。
## 0.6.2 — 默认进入丞相
- 将尚未加入 Agent Team 的新会话主 Agent 直接映射为丞相(Lead)。
- 使用“上朝”模式后可立即与丞相对话,不再需要手动切换默认 Agent。
- 已加入团队的中书、门下、尚书、工部、礼部和兵部角色映射保持不变。
## 0.6.1 — 交由 dsh-image-gen 执行
- 上朝不再重复注册 `generate_image`,避免与 `dsh-image-gen` 工具冲突。
- 工部获准使用 Image-gen 的 `generate_image`、`generate_images` 和 `edit_image`。
- Provider、凭据、模型、计费与图片保存全部交由 Image-gen 管理。
- 上朝仅保留角色职责、任务准奏和工具权限边界。
## 0.6.0 — 普通百炼生图
- 工部恢复 `generate_image`,使用普通百炼 `/images/generations` 接口。
- 通过 DSH 凭据服务读取 `BAILIAN_API_KEY`,源码不保存密钥。
- 默认 dry-run,真实调用必须显式 `live=true`。
- 固定三模型白名单,无其他图片渠道 fallback。
- 保留其他图片生成和编辑工具的拒绝策略。
## 0.5.1 — 移除上朝生图能力
- 删除 `generate_image` 工具注册、请求构造、参数矩阵、付费开关及网络调用实现。
- 删除 `sansheng-liubu:imagegen` 提示词块和相关可选能力探测。
- 工部恢复为识图、OCR、截图与视觉分析,不提供生图或图片编辑。
- 策略明确拒绝所有图片生成和编辑工具。
- 保留工具审核开放制、执行部门文件工具、管理型工具审批与审计逻辑。
- 删除生图使用文档;mode id 和 preset id 保持不变。
## 0.5.0 — 工具审核开放、六部配笔与千问生图
### 变更范围
- 将管理型工具的一刀切禁令改为审发分离:丞相可调用并记录审计日志;部门须持门下省准奏记录;兵部负责装配、发放、回收、登记和销账,只发不批。
- 兵部、礼部、工部获得 `read`、`write`、`edit`、`bash`、`grep`、`glob` 等执行工具;中书、门下、尚书维持只读工具集。
- 该版本曾向工部加入可选生图能力,已在 0.5.1 移除。
### 历史缺陷防复发
- `sansheng-liubu:role` 使用共享安装引用计数保护,不重复注册。
- 未引入 `sanshengLiubuGeneration` preset service;模式沿用 agent 原生 scope。
- preset 只保留 `sansheng-liubu-policy` 单一引用,未接入 v2、v3 或 v031 陈旧链。

61
CONTRACT.md Normal file
View File

@ -0,0 +1,61 @@
# 三省六部 v0.1 内部接口契约
本文件约束 Web 工作台、dsh-go 原生面板与宿主服务之间的数据形状。三端共用 `src/shared/roles.js` 与 `src/shared/schema.js`。
## 十席
- `SEAT_IDS` 顺序:lead, zhongshu, shangshu, menxia, libu, hubu, lipu, bingbu, xingbu, gongbu。
- `SEATS[id]` = `{ id, label(两字), duty(短摘要), responsibility(职责全文) }`。
- `SEAT_GROUPS` = `{ lead:[lead], sansheng:[zhongshu,shangshu,menxia], liubu:[libu,hubu,lipu,bingbu,xingbu,gongbu] }`(工作台布局用)。
## 宿主 HTTP:POST `/api/sansheng`
请求体 `{ endpoint: string, payload?: object }`;成功回 `{ ok:true, value }`,失败回 `{ ok:false, error:{ code, message } }`(HTTP 200)。
| endpoint | payload | value |
|---|---|---|
| `list` | — | `{ projects:[{ id, name, status, revision }] }` |
| `project` | `{ projectId }` | 项目视图(见下) |
| `open` | `{ workspaceId, name?, path? }` | 项目视图;不存在则按 workspaceId 建项目记录(不创建会话) |
| `enable` | `{ projectId }` | 项目视图;严格创建/恢复十席会话 |
| `configure` | `{ projectId, seatId, model:({provider,model,reasoningEffort?}|null), instructions? }` | `{ seat }` |
| `models` | — | `{ providers:[{ provider, models:[{ model, reasoningEffort?:[...] }] }], default:({provider,model}|null), failures:[...] }` |
错误码:`sansheng/invalid`、`sansheng/not-found`、`sansheng/conflict`、`sansheng/unbound`(席尚未绑定会话)、`sansheng/model-invalid`、`sansheng/state-corrupt`。
## 项目视图
```jsonc
{
"revision": 0,
"project": {
"id": "ws-1", "name": "项目名", "workspaceId": "ws-1", "path": "D:/x", "status": "pending|provisioning|ready|error",
"seats": [
{ "id":"lead","label":"丞相","duty":"...","responsibility":"...","status":"pending|creating|bound|failed|missing","sessionId":null,"model":null,"instructions":"","error":null }
],
"groups": { "lead":["lead"], "sansheng":[...], "liubu":[...] }
}
}
```
## 会话/模型规则(两端 UI 必须遵守)
- 每席一个独立 root Session;切换角色 = 导航到该席 `sessionId`,不新建、不重建聊天引擎。
- 模型未选择显示“请选择模型”;选择后显示具体名称。界面不提供“跟随宿主模型”选项。
- “启用”只建立十个会话,不自动运行模型。
- 角色补充说明:Web 可编辑;原生面板只读(原生无自由文本控件)。
## Web 工作台(`src/client/`)
纯视图模型函数 `buildWorkbenchView(view, ui)` 必须可由 node 直接 import 测试(不依赖 React/DOM):
- `view` = 项目视图;`ui` = `{ selectedSeatId, models, draft }`。
- 返回:`{ projectTitle, ready, seats:[{id,name,duty,statusLabel,selected}], groups, selected:{ id,name,responsibility,duty,modelValue,modelLabel,instructions,modelOptions } }`。
- `seats` 必须正好十项且 name 两字;未选模型时 `modelLabel==='请选择模型'` 且 `modelValue===''`;`modelOptions` 不得含 value==='inherit' 的项。
React 接线用 `React.createElement`(不用 JSX,便于 esbuild 直接打包)。入口 `export const inject=[...]` + `export function apply(ctx)`。
## dsh-go 原生面板(`src/native/`)
纯视图树函数 `buildPanelView(input)` 必须可由 node 直接 import 测试:
- `input` = `{ project, selectedSeatId, models }`。
- 返回原生 view 节点(`{ type:'stack'|'row'|'text'|'list'|'callout'|'button'|'accordion'... }`)。
- 硬约束:节点数 ≤120、深度 ≤8、单个 options/列表 ≤8 项、无自由文本输入控件;十席按 lead/sansheng/liubu 分组呈现。

View File

@ -1,55 +1,22 @@
# 三省六部工作台
# 三省六部(dsh-sansheng)· 第一版
给 DeepSeek Harness(DSH)用的多角色工作台:丞相、三省、六部共十席,
每一席都是一个**独立会话**(不是谁的子 agent),身份由程序按
「项目 + 席位」的绑定注入,项目之间互不串扰。
在 DSH 里为每个项目提供固定的十席角色(丞相、中书、门下、尚书、吏部、户部、礼部、兵部、刑部、工部),
每席绑定一个独立的原生命 root Session,模型与补充说明按项目独立保存。中间复用宿主原生会话,不替换聊天引擎。
## 它怎么运转
当前进度(对应 `docs/v1-plan.md` §7 实施顺序):
- **账本**:项目、任务、派工、成果都记在一本账本里
(`~/.dsh/sansheng-liubu/workbench.json`),聊天原文不复制,
留在各席位自己的会话里。
- **派工**:在工作台里选项目、选席位、写任务单,程序把材料直接
投递到那个席位的会话;投递以请求号防重复,结果回来自动对账。
- **模型**:每个席位可以单独选模型,存在账本与会话绑定里,
不借别的会话、不靠猜。
- **记忆**:三层 Markdown 记忆,派工时自动带上相关片段——
部门记忆(每个部门一份、跨项目,`memory/departments/<部门>.md`)、
项目记忆(按项目隔离,`memory/projects/<项目>.md`)与长期记忆
(跨项目,`memory/long-term.md`),都是纯文本,可以直接打开改。
设计说明见 `docs/记忆设计.md`。
- ✅ 第 2 步:项目内身份与十席会话绑定(宿主服务 + 严格创建/恢复/失败重试/跨项目隔离,`npm test` 用 fake ctx 验证)。
- ✅ 第 3 步:Web 入口与右侧工作台(已在隔离测试 DSH 真机验证:入口、十席工作台、真实建十个会话、重启幂等)。
- 🟡 第 4 步:dsh-go 原生面板(源代码就位,触摸/返回/会话跳转需真机核验)。
- ⬜ 第 5 步:双项目联调后打包发布。
## 安装与启用
**本包尚未安装到任何 DSH profile,也未改动用户的日常 DSH 配置。**
本包只发布一条:`dsh-sansheng-liubu-mode`。朝堂面板已并回主包,**不要**
再单独安装 `dsh-sansheng-liubu-workbench`;旧脚本 `workbench-install.mjs`
现在只打印迁移说明,不会再改任何 profile 文件。
## 目录
```sh
node scripts/workbench-preflight.mjs # 严格只读自检:入口、bundle 语法、路由、账本可写
```
安装、修复与迁移是独立授权操作;自检不会创建、覆盖或迁移用户文件。
改完安装后要**彻底退出并重启 DSH** 才生效。
## 验证
```sh
npm test # 工作台全量单测
node scripts/workbench-preflight.mjs # 装配与安装状态预检
```
真机验收矩阵在 `docs/v0.1-验收记录.md`,标「待真机」的条目
只能在装了 DSH 的机器上验。
## 0.11.0 退役说明
老预设线已整体退役:不再有「上朝」模式、基于 Team 成员身份的
政策插件(工具守卫、按部门改模型)、朝堂侧栏与组建朝班流程。
根目录 `index.js` 现在只负责在应用根上启动工作台宿主。
升级注意:如果你的 DSH 配置文件 `cordis.patch.yml` 里还留着
以前写入的上朝预设段,请把它删掉再重启;如果 profile 里还登记了
`dsh-sansheng-liubu-workbench`,也一并移除(面板已并回本包)。本包的包名
保持 `dsh-sansheng-liubu-mode` 不变,只是为了既有 bundle 登记继续有效,
它不再提供任何模式。
- `index.js` — 宿主插件入口(`name` / `inject` / `apply`)。
- `src/shared/` — 十席定义与项目状态 schema(前后端共用)。
- `src/host/` — 项目状态存储、严格会话创建/恢复、模型配置(不写 profile)、提示词 section、HTTP `api/sansheng`。
- `src/client/` — Web 工作台(纯视图模型 + React 接线 + 传输层)。
- `src/native/` — dsh-go 原生面板(纯视图树构造 + bridge 接线)。
- `test/` — fake ctx 单元/集成测试。

180
TODO.md
View File

@ -1,180 +0,0 @@
# 三省六部开发 TODO
更新日期:2026-11-10(模型推荐段于 2026-11-12 实时更新)
当前阶段:角色与面板规划。以下勾选框表示实施是否完成,不表示方案是否确认。除特别注明外均为用户已确认、待实施;创建本文件不代表授权安装技能或修改运行配置。已有实验代码也不代表下面的新方案已实现。
> 2026-11-10:老预设线已退役(0.11.0)——「上朝」模式、Team 政策插件与朝堂侧栏全部移除,仓库只保留工作台一套(十席独立会话)。下文涉及预设/老面板的条目均为历史规划记录,不再执行。
## v0.1 与首次提交
- [ ] 先完成 TODO 规划,再进入 v0.1 实现;当前继续规划,不提前实施。
- [ ] v0.1 实现完成并通过相应验证后,再创建首次 Git 提交。规划阶段和 v0.1 未完成前不提前提交;此前的 Git 初始化不等于首次提交。
## v1.0 优先级与后续 DS Bot 适配(2026-11-07 用户确认;2026-11-10 已否决)
**结论(2026-11-10):不基于 DS Bot 构建,本节的适配计划作废。** 已实测冲突(feat/dsbot 分支):ds-bot 子包与自有侧边栏同装时,`settings.trigger` 槽位重复登记抛错、整个插件被标 failed(ds-bot/PATCHES.md M-03);其上游补丁还会禁用 DSH 原生设置页(M-02);且侧边栏按原生 Team 会话模型工作,与 Bot 会话模型不匹配。三省六部只走原生路线(预设 + 工作台)完成自身 v1.0;DS Bot 仅作参考阅读,不 fork、不迁移运行时。
当前优先顺序:先完成三省六部 v1.0 并验证可用。本节以下条目保留为历史规划,不再执行。
- [ ] 优先完成三省六部自身 v1.0:修复“开新朝堂”阻断问题,验证创建会话、组建成员、下旨、按需派工、结果回传与审核交付的完整链路。
- [ ] v1.0 对齐本文已确认的角色与流程要求:六部职责、用户授权、审发分离、依赖调度、角色模型可配置与权限边界;统一代码版本、README、CHANGELOG 与 TODO 的实际状态。
- [ ] v1.0 验收包含真实 DSH 宿主集成验证与关键失败路径;不能仅凭语法检查、安装检查或 Mock 单测通过宣称可用。
- 已否决(2026-11-10):「v1.0 完成后评估并适配 DS Bot」作废;长期 Bot、主 Bot/群聊管理、分阶段 Goal、分层记忆等机制仅作参考阅读。
- [ ] 适配前核对 DS Bot 的实际接口、宿主版本兼容性、数据与会话隔离、许可证及维护状态,固定验证版本;文档所述能力不等于已经在本机验证。
- [ ] 优先评估配置、角色模板、Skill 或薄插件的复用方式;是否采用其运行时、是否需要 fork,待验证后决定,不把此前助手提出的迁移建议当作用户已确认方案。
- [ ] 适配保留三省六部的用户授权、拟案/审议/调度分工、按需召集与定向修改机制;当前不因借鉴 DS Bot 而替换现有实现或扩大 v1.0 范围。
参考项目:https://github.com/Fei2411/DS-Bot
中文说明:https://github.com/Fei2411/DS-Bot/blob/main/README.zh.md
## 模型推荐方向:仅供选型参考,未确定默认配置
以下角色与模型的搭配均为推荐候选,不代表用户已确认绑定;具体默认模型须后续选定。用户明确偏好尽量不用 Claude。
- [ ] 尽量不用 Claude,不列入默认模型,也不因困难自动切换到 Claude。(2026-11-12 注:全球编程/Agent 榜首仍是 Claude Opus 5.5 / Fable 5.2,按此偏好未列入下表。)
- [ ] 图像理解与图像生成分别配置:礼部模型需能读取截图、图表与页面;需要生成或编辑图片时另用相应工具。
- [ ] 各角色模型保持可手动切换,技能绑定角色而非模型;不把下表推荐当作已定配置。
### 2026-11-12 实时更新:十席推荐(依据 2026-11-05~11 的 SuperCLUE、SWE-bench、Terminal-Bench、ProgramBench、FrontierMath、LMArena 等公开榜单)
通道标记:●=现有通道(DeepSeek 官方 API 按量付费,或 WorkBuddy/Magpie 订阅池,具体版本以 Magpie 实际刷出的模型列表为准);○=需另开通道(OpenAI / Google API,用户目前未接)。Gemini 4 Carbon 虽居多榜第一,但仅向受 vet 的安全从业者开放、无公开 model id,不列入推荐。
| 席位 | 主推 | 备选 | 推理档 | 依据 |
|---|---|---|---|---|
| 丞相 lead | DeepSeek V4.1 Flash (1017) ● | Kimi K3.1 Pro ● | 中 | 快、便宜、1M 上下文,SuperCLUE 国内第二;重要汇报临时切 V4 Pro |
| 中书 zhongshu | GPT-6 Astra ○ | Kimi K3.1 Pro ● | 高 | GPQA 96.0 / HLE 54.8 / ARC-AGI-2 95.0 推理天花板,沿用原 GPT 方向 |
| 尚书 shangshu | Kimi K3.1 Pro ● | Qwen3.8-Max ● | 中高 | 多任务拆解与长程 Agent;ProgramBench 第一、Terminal-Bench 65.7。备选改国产替代(2026-11-12 用户改定,原 GPT-6 Astra):Qwen3.8-Max 擅长复杂 Agent 与长程任务、企业级调度配套,与主推 Kimi 不同家族,可互为故障转移 |
| 门下 menxia | Gemini 4 Argon ○ | Kimi K3.1 Pro ● | 高 | 幻觉控制 83.19 全球断层、事实性第一;与中书/尚书不同家族保独立性;备选 Kimi 为国内幻觉控制第一(原定方向) |
| 吏部 libu | DeepSeek V4.1 Flash (1017) ● | GLM-5.3 ● | 中 | 改 Flash(2026-11-12 用户改定):编制与技能配置多为调研加结构化文案,Flash 够快够用;复杂选型评估切备选 GLM-5.3 |
| 户部 hubu | DeepSeek V4.1 Flash (1017) ● | DeepSeek V4 Pro ● | 高 | 改 Flash:数理与代码计算靠写脚本复算,Flash 便宜量大(FrontierMath 开放权重最强一档);硬核统计与证明切备选 V4 Pro。备选原 GPT-6.1 Sol,按「备选列全国产」替换 |
| 礼部 lipu | Gemini 3.8 Flash ○ | MiMo-V2.6-Flash ● | 中 | 视觉 Arena 第一(1411)、写作性价比之选、1M;备选 MiMo 全模态 MIT 开源、极便宜。未改 DS Flash:礼部必须读截图、图表与页面,DS Flash 主线是文本模型(Vision 变体接入未核实),视觉是硬需求 |
| 兵部 bingbu | DeepSeek V4.1 Flash (1017) ● | Kimi K3.1 Pro ● | 中高 | 改 Flash:调试靠流程技能加代码能力,DeepSWE 77.0 够打,部署脚本属常规活;长程终端任务切备选 Kimi(Terminal-Bench 65.7) |
| 刑部 xingbu | DeepSeek V4.1 Flash (1017) ● | Kimi K3.1 Pro ● | 高 | 本就是 Flash:DeepSWE 77.0 反超 Kimi 与 Opus。备选原 GPT-6.1 Sol,按「备选列全国产」换 Kimi——不同家族、国内幻觉控制第一,复核视角独立 |
| 工部 gongbu | GLM-5.3 ● | DeepSeek V4 Pro ● | 高 | SWE-bench 独立实测 95.4(非 Claude 阵营最高一档)、1M 无损上下文读整仓、重构稳;备选 DeepSeek 算法/后端强。未改 Flash:工部产出是生产代码,换 Flash 会明显降档,保留 GLM-5.3 |
2026-11-12 用户两条改定:①备选列(第三列)全部换国产替代,不留国外备选;②六部执行席能用 DeepSeek Flash 的改 Flash——吏、户、兵、刑四部已改,礼部(视觉硬需求)、工部(生产代码质量)保留原主推。Flash 走 DeepSeek 官方 API 按量付费,不占 WorkBuddy 单模型约 45 次/5 小时的 429 窗口;丞相与三省决策席仍分散在 Flash / GPT / Kimi / Gemini 上。
翰林(后续席位):原定「默认 Flash、重要总结切 Pro」不变,具体化为默认 DeepSeek V4.1 Flash,重要总结切 Kimi K3.1 Pro 或 Gemini 4 Argon。
## 面板与基础接口
- [ ] 从左侧导航打开三省六部页面;主对话在左、成员图在右,复用已安装 better-sidebar 的文件树,不另造文件树。
- [ ] 成员图采用卡片和连线:顶部丞相;中层左中书省、中尚书省、右门下省;吏、户、礼、兵、刑、工六部直属尚书省。
- [ ] 支持成员选择高亮、编辑、折叠;点击部门即可切换其对话并下旨。
- [ ] 图下配置所选成员的 Agent 预设、API、联动模型及推理等级;区分成员运行状态与任务状态。
- [ ] 实施前核实 better-sidebar 扩展接口、DSH 会话导航、直接投递、预设/模型切换及生效时点。
- [ ] 核实成员创建与调度权限;DSH 仅 Lead 可创建团队成员等宿主限制不能靠角色提示词绕过。
## 已确认的整体流程
- [ ] 与丞相沟通后,经用户同意才执行;“仅规划”的限制持续有效。
- [ ] 无方案或方案不明确:中书拟案 → 门下审议(默认一次)→ 用户提出修改意见并确认 → 尚书派工执行。门下准奏不替代用户授权。
- [ ] 首次交付:所需六部执行并自行检查 → 尚书组织完整成品 → 门下统一审核成品 → 交付用户;不逐部门送审。
- [ ] 审核问题只交对应部门修正,不扩大到无关部分。
- [ ] 交付附可编辑源文件位置与“部分 → 主责部门”清单,用户直接点击部门修改,不经丞相查找和转述。
- [ ] 交付后定向修改:用户 → 指定部门 → 只改指定部分 → 直接交回;默认不重新合成、不自动复审、不启动完整版本发布。
- [ ] 局部修改默认更新同一工作文件,进行必要局部检查;版本历史与回退统一使用 Git,不再创建 backup 目录、时间戳备份或多份“最终版”。保留并发冲突保护,PDF 等导出物只做必要重导出。
- [ ] 项目源码、角色配置、技能和规划文档通过 Git 提交记录有意义的变更;按需使用分支或 worktree 隔离并行工作,不为每次小修改建立完整发布流程。历史备份在核对并保全独有内容后再清理,不直接丢弃。
- [ ] 局部修改后标注未重新审核,不阻止交付;用户明确要求时才重新整合或复审。扩大修改范围须先获用户同意。
## 丞相:已确认,待实施
- [ ] 参考 Edict 太子职责,负责接旨分流、转达、三省协调与简短回报。
- [ ] 按语义判断任务,不按字数;普通问答不强制建任务,补充指令关联原任务。
- [ ] 用户指定部门时由程序直接投递原话、附件与范围,不额外调用模型转述;未指定、关键歧义或冲突时才由模型介入。
- [ ] 不擅自改派或扩大授权;成员原始回复即时可见,仅重要交接、阻塞、需用户决定及完成时汇总。
- [ ] API、模型独立配置;暂不内置中书省规划技能。
## 中书省:已确认,待实施
- [ ] 沿用 Edict 公开中书令角色基线,负责方案,不直接执行制作任务。
- [ ] 角色绑定 brainstorming 与 writing-plans 的适用内容,切换 API/模型后保留技能。
- [ ] 明确需求直接形成可执行计划;仅关键不明时澄清,不自动进入实施。
- [ ] 落地前核对上游版本、许可证与 DSH 适配。Edict 演示配置中的 planning 仅有作者本机路径,未取得其技能正文,不宣称已复用。
## 门下省:已确认,待实施
- [ ] 审查方案的可行性、完整性、风险、资源与授权边界;覆盖代码、办公套件、论文及跨文件一致性。
- [ ] 输出审查对象与版本、检查范围、证据、问题位置/影响/建议、未核实项,以及准奏/封驳/待核实结论;不越权修改,修复交执行部门。
- [ ] 按需适配 Builder Check、Code Reviewer 模板与 verification-before-completion 的证据规则;不把模板误称独立技能,不再嵌套派一个审查代理。
- [ ] 核实 Office/Univer 的读取、重算、渲染与 PDF 检查能力;覆盖 Word 结构排版、Excel 数据公式、PPT 图文版式、PDF 导出完整性及跨文件一致性。产生文件的检查优先副本或隔离环境。
- [ ] 核实 qqsci、nature-academic-search、nature-figure、nature-data、nature-response;按学科和期刊适配,覆盖文献创新性、证据结论、方法对照复现、统计、图文补充材料、引用及投稿修回。
- [ ] 无原始数据不声称真实性已验证,无文献核查不声称创新性已验证。
### 审核循环
- [ ] 审核循环上限可配置,默认 1 次;支持保存默认值及单任务覆盖。
- [ ] 一次循环定义为审核当前对象并输出结论;返工后再次审核才计下一次。计划审议和成品审核分别计数。
- [ ] 提前通过立即结束,不为用满次数重复审核;次数用尽不强制准奏。
- [ ] 默认一次后可在原授权内修正,但不自动复审;交付注明审核后修正情况及未解决事项。
- [ ] 上限大于一次时,在剩余次数内重点复核修改及影响;用尽后由用户决定是否追加审核。
## 尚书省:已确认,待实施
### 职责与技能
- [ ] 接收用户批准的方案,负责执行拆分、调度、阻塞协调、首次成品合成与交付;不重复中书规划,不承担门下审查。
- [ ] 专业制作及合成操作按需交执行部门;尚书负责组织完整产出。交付后的局部修改默认不介入。
- [ ] 绑定轻量“执行调度与交付”技能,切换 API/模型后保留;API、模型与推理等级由用户独立设置。
- [ ] Adopt-part:提取 dispatching-parallel-agents 的独立任务判断、聚焦派工及交接方法。
- [ ] Adopt-part:提取 subagent-driven-development 的 batching、preflight 与进度恢复方法;不引入逐任务审核、自动升级模型或上游返工循环。
- [ ] executing-plans 不作为尚书主技能,其自行逐项执行的定位更接近执行部门。
- [ ] 落地前固定上游提交、保留 MIT 版权和许可声明,完成维护与安全核查。部分主技能正文曾截断,采用前补读所需完整内容与引用。
### 任务依赖与并行调度
- [ ] 只调用需要的部门;一个部门能完成的工作不为凑齐六部拆分,同类小任务合并派工。
- [ ] 无相互依赖且写入范围不冲突的任务并行。
- [ ] 需要前项数据、文件或接口结果的任务串行,满足交接条件才启动。
- [ ] 可拆分任务的独立部分提前开展,依赖部分等待;条件满足即启动后续,不等待所有并行任务一起完成。
- [ ] 同一文件存在写入冲突且无可靠隔离合并机制时安排先后;某个部门阻塞只影响依赖该部门的分支。
- [ ] 派工记录:负责人、任务目标、必要材料、前置任务与交接条件、可提前开展部分、允许修改范围、产出位置、完成标准。
- [ ] 使用状态和完成事件推进,避免循环询问进展;保存任务实际结果、负责人和产出,防止重复派发。
- [ ] 维护“部分 → 主责部门”映射,首次交付附成品、源文件、审核计数、审核后修正及未解决事项。
- [ ] 技能负责判断分工依赖;程序检查授权、就绪条件、审核计数、防重复派发与文件冲突。不得把任务说明写完当作已派发或已执行。
## 六部:技能选型已确认,骨架已落地(0.4.0)
各部门采用主要技能入口加按需加载,技能绑定角色,更换 API/模型后保留。以下是选型确认,不代表安装或实测完成;具体工具权限和交接接口实施前核实。
已落地(0.4.0):角色编制扩为十席,六部角色、提示词、写入边界与面板朝堂图已接通;十席与职责断言纳入 `npm test`。以下技能选型条目仍在推进中。
- [x] 角色骨架:`COURT_ROLES` 十席、六部提示词、按职责划分的写入边界、面板三排朝堂图。
- [ ] 吏部负责 Agent 与技能维护:部分采用 Anthropic skill-creator 的技能设计与评估方法,复用 windows-codex-skill-install 的安装发现检查。仅新增或实质改进技能时进行评测,不因普通配置修改启动多代理基准测试,不擅自更换模型或扩权。
- [ ] 户部负责数据与计算:复用 univer-sheet/office-xlsx、office-recalculate,科学绘图按需使用 nature-figure。依据实际数据选择统计方法,不把表格操作等同统计验证,不补造数据。
- [ ] 礼部负责内容与呈现:按任务选用 qqsci、qqwrite、qqppt 及 Word/Slide 能力。保留 PPT 分流和叙事方法,默认采用可编辑文本、图表、形状;整页图片式演示须用户明确接受,实施前核实实际依赖,不把技能旧环境记录当现状。
- [ ] 兵部负责环境运行:部分采用 systematic-debugging 的错误读取、复现、变化检查、假设与最小验证;具体部署按平台适配,部署发布须在授权内。
- [ ] 刑部负责按需专项测试:采用 systematic-debugging 的复现定位及 TDD 的有效测试设计方法,输出问题与证据;不是每项任务必经审批,不重复门下成品审议,不另设无限返工循环。
- [ ] 工部负责开发实现:选型使用 search-first,关键行为与缺陷修复采用适配的 TDD,故障按需加载 systematic-debugging;不把删除已有实现重来、每个低影响改动强制全流程等上游规则原样引入。
- [ ] 六部共享技能不等于重复执行:各部完成必要自检,刑部按风险承担独立专项验证,门下核对已有证据,仅证据不足或变更影响时补查。
- [ ] v0.1 优先复用已有办公、论文和绘图技能,适配排错、测试及技能维护方法,不另引入完整多 Agent 开发框架;统一由尚书调度。
- [ ] 安装前补读所采用技能及引用、固定上游提交、核对许可证和脚本依赖并验证可用性。本轮 systematic-debugging/TDD 主文已完整读取;skill-creator 与部分本地技能只核对相关片段,办公能力尚未逐项实测。
候选来源:
- https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md
- https://github.com/obra/superpowers/blob/main/skills/systematic-debugging/SKILL.md
- https://github.com/obra/superpowers/blob/main/skills/test-driven-development/SKILL.md
## 参考来源
本轮技能选型核对日期:2026-11-07。以下是候选和改编依据,链接到可变分支,实施时须固定提交。
- Edict 尚书角色:https://github.com/cft0808/edict/blob/main/agents/shangshu/SOUL.md
- 并行调度:https://github.com/obra/superpowers/blob/main/skills/dispatching-parallel-agents/SKILL.md
- 子代理开发:https://github.com/obra/superpowers/blob/main/skills/subagent-driven-development/SKILL.md
- 同类任务合并:https://github.com/obra/superpowers/blob/main/skills/subagent-driven-development/references/batching.md
- 执行前依赖检查:https://github.com/obra/superpowers/blob/main/skills/subagent-driven-development/references/preflight.md
- 自行执行计划(不作尚书主技能):https://github.com/obra/superpowers/blob/main/skills/executing-plans/SKILL.md
- Superpowers 许可证:https://github.com/obra/superpowers/blob/main/LICENSE
## 后续规划:翰林助理(私人助理席位)
2026-11-10 定下方向,仅规划、未排期,等真机调试与 v1.0 验收走完再议。
- 定位:取意唐翰林学士「天子私人」——编制外的一个私人助理席位,只对用户本人负责,不进十席、不走中书→门下→尚书的正式流程。
- 形态:一个长期跟随用户的独立会话(与现行独立会话方案一致)。
- 职责:备顾问(先查先答)、起草文书、贴身事务(提醒/日程/零碎跟进);可选:各部门成果呈报前的预审。
- 边界:不派工(派工仍由用户经工作台进行)、不审批(审议归门下)。
- 记忆:以长期记忆(用户偏好)为主;助理自身经验的存放方式(独立一份助理记忆,或借用部门记忆层)实施时再定。
- 模型策略(2026-11-10 定):默认 Flash——陪聊高频、长会话滚雪球,速度与成本优先,且陪聊质量主要靠长期记忆与人设稳定;重要总结(长材料、部门成果预审)临时切 Pro,席位可单独选模型,翰林应在碰到这类材料时主动提醒用户切换。

View File

@ -1,197 +0,0 @@
# 三省六部 v1.0 工作台修复方案
日期:2026-11-07
审查基线:`master` / `dd62068`,代码版本 `0.3.1`。
文档性质:实施建议与验收方案;不代表代码已修复或宿主集成已验证。
## 1. 目标与范围
将三省六部做成一个可直接工作的工作台:用户在同一页面完成下达任务、确认方案、查看部门执行、打开交付文件和定向修改。底层继续使用 DSH 会话与 Agent Teams,但由程序管理绑定与生命周期,不要求用户反复手动新建聊天、切换预设或组建朝班。
优先完成三省六部自身 v1.0,再评估 DS Bot 适配。当前不迁移运行时、不 fork DS Bot、不重写 DSH,也不为工作台重新实现已有文件树或通用聊天编辑器。
保留已确认原则:
- 丞相负责分流与协调,中书负责规划,门下负责审议与验收,尚书负责执行调度,六部按专业执行。
- 门下准奏不等于用户授权;执行必须在用户批准范围内。
- 只启动需要的部门,不为凑六部拆任务。
- 用户指定部门时直接投递原话、附件与修改范围。
- 首次交付统一审核;交付后的定向修改默认不重走完整流程。
- 模型由用户配置,技能绑定角色;不硬编码禁止某个模型家族。
## 2. 当前完成情况与阻断原因
已有基础:插件入口、预设、角色提示词、面板入口、部分会话导航与投递、模型路由、工具 guard、任务依赖准入检查。现有 22 个单元测试通过,但没有覆盖开新朝堂的完整路径。
| 问题 | 证据位置 | 影响与处理方向 |
|---|---|---|
| 未定义的投递函数 | `panel/lib/client.js:1074` | `sendPrompt` 不是当前作用域变量,创建会话后触发 `ReferenceError`;提取共用投递函数,所有入口调用同一实现 |
| 依靠新 ID 猜测创建结果 | `panel/lib/client.js:1048–1060` | 可能重复创建或误认并发会话;核实宿主契约,以返回标识或关联事件精确绑定 |
| 错误被吞掉或显示成功 | `panel/lib/client.js:1050,1066–1074` | 用户无法确定是否送达;统一结构化错误与界面状态 |
| 成员创建职责冲突 | `index.js:81`、`panel/lib/client.js:1084` | 尚书不能创建 teammate;尚书提出需求,由 Lead 执行创建 |
| 模型选择被覆盖 | `index.js:215–220` | 界面选择与实际请求不一致;统一配置来源与生效规则 |
| 权限覆盖不完整 | `index.js:132–154` | 未枚举工具默认放行,任务准入不等于授权;建立与宿主配合的权限检查 |
| 角色与文档不一致 | `index.js:54–60`、`TODO.md` | 实现只有工礼兵,未补齐六部;按已确认职责对齐 |
| 版本口径不一致 | `package.json`、`CHANGELOG.md`、`TODO.md` | 无法凭文档判断交付状态;发布时依据实际验证统一 |
以上是源码和已有复现支持的发现。DSH `startSession` 的准确契约尚未核实,不能假定它一定返回 session ID,也不能先编造接口再开发。
## 3. 工作台交互
建议布局:
```text
顶部:项目 / 当前任务 / 总体状态 / 设置
左侧:复用现有文件树 + 任务入口 + 交付入口
中间:所选部门对话、方案与授权卡片、任务输入
右侧:丞相—三省—六部组织图 + 所选角色配置
底部:当前阶段、等待对象、阻塞原因、最近产出
```
工作台打开时应立即展示结构。部门卡片常驻,执行成员按需建立;尚未启动的部门显示“未启动”,不能冒充在线成员。没有任务时显示可用的输入区,不以“组建朝班成功”作为页面可用的前提。
用户点击部门后,在工作台中显示对应对话。若宿主不提供可嵌入对话组件,先验证可用扩展点,再确定替代呈现;不得以自动跳转普通聊天页冒充完成工作台验收。
## 4. 实施阶段
### 阶段 A:核实宿主接口并确定实现边界
先核实以下能力的真实签名、返回值、异步错误和版本兼容性:
1. 工作区定位、会话创建、预设应用、会话读取及订阅。
2. 指定会话投递文本与附件、接收回执、运行中消息的处理语义。
3. 工作台内嵌对话或复用聊天组件的扩展点。
4. Lead 创建成员、成员身份、任务依赖与完成事件。
5. 角色模型/推理等级切换及实际生效时点。
6. better-sidebar 文件树复用及页面注册接口。
7. 宿主权限与人工审批凭证、共享任务元数据能否保存所需字段。
产出一份接口核对表,逐项标注“已验证 / 不支持 / 待验证”。若会话创建只能触发 UI 草稿而不真正建档,应采用宿主支持的服务路径或扩展点,不再使用轮询猜测弥补契约差异。
完成标准:可通过最小实验准确创建并识别一个指定工作区和预设的会话,获得明确的投递结果;确认中间对话区的可实现方式。
### 阶段 B:修复会话连接与错误处理(最高优先级)
- 将投递逻辑提取为有明确作用域的共用函数,供普通下旨、组建指令及工作台调用;不依赖不确定的 `this` 绑定。
- 用明确的创建结果或请求关联事件绑定会话;禁止选取“任意新出现的会话”。
- 对同一创建动作实行 single-flight,运行中禁用重复提交;超时进入“结果待确认”,先对账,不自动再次创建。
- 不吞同步异常、Promise rejection 或投递失败。统一返回 `ok`、`stage`、`sessionId`(已知时)、`errorCode`、用户可读说明和允许的恢复动作。
- 会话创建成功但投递失败时保留绑定,只允许向该会话重试投递;不能返回完整成功,也不自动删除用户会话。
- 消息重试需核对宿主是否支持幂等标识或送达查询。结果不明时提示用户确认,不能盲目重复投递。
- 将普通 `lastAction` 变量改为可订阅状态,及时显示创建、投递、失败和恢复进度。
- 所有按钮路径具备错误捕获和清理逻辑;卸载页面时清理订阅与计时器。
完成标准:单击只产生一个目标会话;并发创建其他会话不误投;投递失败不显示成功;恢复操作不重复建会话。
### 阶段 C:建立工作台状态与持久绑定
建议拆分职责,不直接在大型客户端 bundle 内堆叠新逻辑:
- 宿主适配层:封装经验证的 DSH API。
- 工作台状态层:维护绑定、选择、加载状态和错误。
- 流程层:管理授权、依赖与交接。
- 展示层:组织图、对话、任务、配置和产出视图。
具体文件拆分应先确认现有源码与构建来源;如果客户端是构建产物,修改源文件并重新构建,避免源文件和 bundle 各维护一套逻辑。
建议数据模型:
| 对象 | 必需信息 |
|---|---|
| 工作台绑定 | schemaVersion、workspaceId、工作台实例 ID、Lead sessionId、role→member/session 映射 |
| 任务 | 原始请求、目标部门、计划版本、负责人、依赖、允许范围、状态、产出引用 |
| 授权记录 | 用户动作来源、批准的计划版本与范围、时间、失效/撤销状态 |
| 审核记录 | 计划或成品、对象版本、结论、证据、次数、未解决问题 |
| 交付记录 | 文件引用、可编辑源文件、主责部门、验证状态 |
通过宿主允许的存储服务持久化。以 workspaceId 与工作台实例标识隔离,不用“最新会话”自动覆盖已有绑定。模型输出、角色消息或任务标题不能伪造用户授权。
刷新后核验会话是否仍存在、工作区是否匹配。会话缺失时显示可恢复状态,保留记录;重新绑定应明确展示对象,不能静默绑定其他会话。
成员可用性和任务状态分别展示:成员 inactive 不代表任务完成;任务完成必须有结果记录。
完成标准:刷新、切换项目、重启后恢复正确绑定;同一页面完成部门切换、投递、查看任务与打开产出。
### 阶段 D:统一角色、模型和流程
角色补齐为丞相、三省、吏户礼兵刑工六部。各角色职责以当前 TODO 已确认内容为准,角色 ID 必须唯一,避免吏部与礼部拼音重名。角色元数据集中定义,界面、提示词和策略共用。
创建与派工职责:尚书提出依赖、分工和成员需求;Lead 创建需要的成员;执行部门领取就绪任务。普通问答不强制创建全套任务链。
模型配置:统一用户选择、持久配置和请求路由的来源;明确角色覆盖与默认继承关系。删除与已确认选型冲突的硬编码限制。显示实际 provider/model/推理等级;不可用时报告错误或提供选择,不静默更换模型。
首次交付流程:
```text
接收需求 → 中书拟案 → 门下审议 → 用户确认
→ 尚书按依赖派工 → 所需部门执行与自检
→ 尚书组织完整产出 → 门下审核 → 交付
```
程序应验证:
- 用户确认绑定具体计划版本和范围;计划扩大或实质变化后需重新确认。
- 调度须同时满足用户授权、前置任务完成、负责人及写入范围有效。
- 独立任务可以并行,冲突写入按顺序执行或采用已验证的隔离机制。
- 防止同一任务因重复事件被多次派发;失败只阻塞依赖分支。
- 计划审议与成品审核分别计数,默认各一次;不得自行无限返工。
- 审核后的修正与未复审状态如实记录,不能修正后自动标为审核通过。
- 用户指定部门的局部修改直接投递,默认不重新拟案、合成和发布;扩大范围才重新请求确认。
完成标准:分别跑通单部门任务、并行任务、串行依赖与定向修改,能够说明每次推进依据的授权和完成证据。
### 阶段 E:补齐权限执行与交付
- 明确哪些限制由宿主沙箱、审批系统承担,哪些由插件承担;插件不能绕过宿主权限。
- 按工具能力与副作用检查准入,不把“未在黑名单中”视为只读安全。
- 未知或未分类工具先阻止本次执行并说明所需授权,避免无声放行。
- 文件写入检查真实目标与允许范围;路径归一化和链接处理交给可信文件服务,不能只用字符串前缀判断。
- 命令行与远程执行不能仅凭存在 writeScopes 就视为安全;受宿主沙箱和权限档位约束。无法证明范围约束时不得声称已实现强隔离。
- 用户审批凭证由可信宿主或界面操作产生,不接受模型自行填写的 `humanSigned` 作为真实签字。
- 检查现有 `approval`、`writeScopes` 等字段与宿主任务 schema 的兼容性;不支持时使用经过验证的插件存储映射,不能往宿主塞未支持字段。
- 首次交付附文件、可编辑源文件、主责部门、审核结果、修正情况及未完成项。
完成标准:只读角色写入、未授权执行、越界写入和未知副作用工具不能绕过检查;正常获授权任务能够完成。
### 阶段 F:v1.0 验收与发布
测试分三层:纯逻辑单测、宿主适配集成测试、当前 DSH GUI 人工可见的端到端验收。现有 22 个测试保留,不以数量代替行为覆盖。
| 场景 | 必须看到的结果 |
|---|---|
| 首次打开工作台 | 页面结构可用,可输入任务,未启动部门状态明确 |
| 创建慢、失败、重复点击 | 不重复创建,阶段及恢复动作准确 |
| 同时创建其他会话 | 不误认、不误投、不污染其他对话 |
| 创建成功但消息失败 | 显示部分完成状态,保留准确会话绑定 |
| 刷新或重启 | 恢复原工作台任务与会话;缺失对象明确提示 |
| 用户未确认计划 | 不进入执行 |
| 改模型及推理等级 | 下一次实际请求使用所选配置 |
| 多部门并行和依赖 | 只启动就绪任务,写入冲突受控,无重复派发 |
| 审核不通过或执行失败 | 留下证据,按规则修正或报告阻塞,不假报成功 |
| 打开交付和定向修改 | 可打开源文件并直接联系主责部门,不强制全流程重跑 |
按影响面重建 Web 产物,并在当前实际 DSH GUI 中刷新验证;不能另起一个服务后声称原 GUI 已更新。宿主插件代码变化若需重启,应明确重启后再验证。
通过后统一 package、面板版本、README、CHANGELOG 和 TODO。保留真实恢复历史,将旧规划标明历史状态,不编造过去版本的验收记录。按独立变更使用 Git 记录与回退,不创建时间戳备份。
## 5. 推荐拆分与实施次序
1. **连接层修复**:接口核对、确定性绑定、投递函数、错误状态、回归测试。
2. **工作台基础**:状态存储、刷新恢复、同页对话与部门选择、文件和任务入口。
3. **角色与配置**:补齐六部、集中角色定义、按需创建、模型配置实际生效。
4. **流程与权限**:可信用户授权、依赖与防重、审核次数、权限及范围检查。
5. **交付与验收**:产出映射、定向修改、完整宿主验收、文档与 v1.0 版本对齐。
第 1 项应先独立完成并验证。之后界面与角色配置可在边界明确时并行;涉及同一客户端文件、共享状态结构或接口的改动必须先约定再合并。每一项完成都应提供可复核结果,不先改版本号再补实现。
## 6. DS Bot 后续事项
v1.0 完成后再评估 DS Bot 的长期 Bot、群聊派活、阶段 Goal、分层记忆、独立模型与审批机制。先核对接口、版本、许可证、迁移和维护成本,再决定配置复用、薄插件适配或其他方式。
本方案不承诺 DS Bot 可直接承载现有三省六部,也不把公开文档能力等同本机兼容验证。
参考:https://github.com/Fei2411/DS-Bot/blob/main/README.zh.md
## 7. v1.0 最终完成标准
用户始终留在三省六部工作台中,能完成“下任务 → 确认方案 → 按需执行 → 查看产出 → 指定部门修改”;会话不串线、消息不误投、失败不假报、模型配置真实生效、授权边界可验证、刷新后可恢复,并有当前宿主上的验证证据。

1884
client.js Normal file

File diff suppressed because it is too large Load Diff

View File

@ -1,12 +1,4 @@
# 三省六部工作台 · 宿主包补丁层
#
# 一行 insert 把宿主入口(index.js)挂进应用:账本、HTTP 接口、会话
# 装配与三层记忆都在 workbench/host 里。0.11.0–0.12.1 期间本文件是
# 空层([]),以为 bundle 加载会自动带起宿主入口——实际不会:没有
# insert 行,宿主插件根本不被应用,从商店单独安装时工作台后端不
# 启动(接口 404)。0.12.2 起补上这一行,与其它插件包同一装法。
# 老预设线(上朝模式/朝堂侧栏)仍保持退役,本层不恢复任何预设。
# 三省六部:挂到 DSH 宿主的三省六部工作台插件。
- insert:
- id: dsh-sansheng-liubu-mode
name: 'dsh-sansheng-liubu-mode'
config: {}
- id: sansheng
name: 'dsh-sansheng-liubu'

View File

@ -1,171 +0,0 @@
# 三省六部面板设计方案
日期:2026-11-08
状态:已落地到 0.5.1 面板;实现位于 `panel/lib/client.js`。
## 1. 目标与范围
让每个部门拥有明确、易识别、可点击的卡片边界,贴合 DSH 原生主题。朝堂编制与任务流转统一收进会话右侧栏,聊天复用 DSH 原生输入框和消息流,不再维护整页面板或第二套对话摘要。本轮不新增聊天引擎,不修改角色策略、权限或调度机制。
用户要求:每轮设计调整附一张新生成的预览图。版本历史使用 Git,不建立时间戳备份或多个最终版。
## 2. 预览依据
0.5.6 的预览图由 `scripts/preview.mjs` 生成:脚本用 vm 加载**真实的** `panel/lib/client.js`,用会重渲染的 hooks 替身跑真实组件树,把结果序列化成 HTML,再用 headless Chrome 截图。因此它是真实 CSS + 真实 DOM 的渲染结果,不是生成式模拟图。
440px 明亮主题:
![右侧栏 440px 明亮主题](preview/panel-sidebar-440-light.png)
371px(当前宿主实测的侧栏宽度;最近活动独占一行):
![右侧栏 371px](preview/panel-sidebar-371-light.png)
360px 窄栏(检查不裁切):
![右侧栏 360px 窄栏](preview/panel-sidebar-360-light.png)
320px 极窄栏(三省与六部降为单列):
![右侧栏 320px 单列](preview/panel-sidebar-320-light.png)
440px 深色主题:
![右侧栏 440px 深色主题](preview/panel-sidebar-440-dark.png)
任务页:
![任务页](preview/panel-sidebar-tasks-440.png)
左侧栏导航行的观感(展开/折叠/激活态,以及 main 重定向桩的两种文案):
![左侧栏导航行](preview/panel-nav-entry.png)
重新生成的方式写在 `docs/panel-handoff.md` 顶部。截图只覆盖组件在给定容器宽度下的表现,**不覆盖**宿主槽位宽度、滚动容器与真实主题变量注入;最终验收仍需在 DSH Host 中截图确认。统计数字 10 / 3 / 4 是测试替身给的示例数据,不得硬编码为真实数据。
## 3. 面板结构
面板只存在于会话右侧栏。从上到下:状态行 → 朝堂/任务页签 → 统计区 → 丞相 → 三省 → 六部分组 → 当前部门配置。
入口有两个,行为完全等价,都只做「把朝堂停靠到当前会话的右侧栏」:**会话头部的「三省」开关**,和**左侧栏导航列里的一行「上朝」**(`sidebar.panellist`,`order: -100` 置顶,细线「三」字样标;折叠侧栏时只剩图标)。左栏只保留这一处入口——0.5.5 撤掉了曾经并存的底部入口,避免同一功能出现两行。点导航行时宿主会要 `main` 槽,那里放的是重定向桩:停靠右侧栏后立刻退回原会话,没有会话时就地写明原因,不渲染面板内容、也不提供第二套聊天。
- 状态行:协作状态、`输入 @ 选择部门` 提示;在子会话中显示“返回丞相”。
- 页签:朝堂与任务二选一;点击统计卡也可切换,切换不改变当前选中的部门。
- 统计区:在朝成员、运行中、在办任务、已完成,右侧栏固定两列两行。
- 丞相:居中单卡,连接中书省、尚书省、门下省。
- 三省:从左到右为中书省、尚书省、门下省。
- 六部:放入带“六部 · 尚书省调度”标题的浅底色容器,仅由尚书省连接到整个组。
- 六部第一排:吏部、户部、礼部;第二排:兵部、刑部、工部。
- 两排只是视觉换行,不能用连线暗示吏部管理兵部、户部管理刑部等关系。
- 配置区:显示所选部门名称、固定职责、模型、推理等级、保存设置按钮与“与该部门对话”入口。移除重复指令输入框及“Agent 预设”输入与应用按钮;消息在对应原生会话发送,部门角色由系统配置。
十席清单:丞相、中书省、尚书省、门下省、吏部、户部、礼部、兵部、刑部、工部。
## 4. 部门卡片规范
| 项目 | 规划值或行为 |
| --- | --- |
| 底色 | 独立实色表面,与工作区背景明确分离 |
| 常态边框 | 1px 清晰蓝灰实线;不得仅靠阴影区分 |
| 圆角 | 10–12px |
| 内边距 | 10–12px |
| 卡片间距 | 10–12px |
| 建议最小宽度 | 104px;不足时减少列数 |
| 建议最小高度 | 80–88px,由内容撑高,不裁切 |
| 字徽 | 28–32px 淡蓝底字徽,准确使用丞/中/尚/门/吏/户/礼/兵/刑/工 |
| 名称 | 13–14px,中等至粗体,完整可读 |
| 状态 | 11–12px,状态点与文字并存 |
| 点击范围 | 整张卡片,不只部门名称 |
名称和状态是卡片主要信息。长模型名、最近消息和配置细节集中到下方详情区,避免卡片成为密集文本块。尺寸是实现起点,应在真实侧栏宽度下验证。
## 5. 状态与交互
- 常态:白色或主题表面底色、清晰边框、轻微阴影。
- 悬停:边框略加深,底色轻微变化,不改变卡片尺寸。
- 选中:蓝色描边、浅蓝底、右上角勾选标记;通过内描边或等宽边框避免布局跳动。
- 键盘焦点:独立可见焦点环;使用原生按钮语义和选中状态属性。
- 运行中:绿色状态点 + “运行中”;待命:中性状态点 + “待命”。
- 失败:红色状态点 + “失败”,不把整卡大面积涂红。
- 未设官:虚线边框 + “未设官”;可查看职责,但不能对不存在的会话发送指令。
- 右侧栏提供「朝堂 / 任务」页签;点击「在朝成员」或「在办任务」统计卡分别切到对应页,切换不丢失当前选择。
- 聊天不在侧栏内重复实现;主会话与部门子会话都使用 DSH 原生消息流和输入框。
- 点击卡片只切换配置对象;“与该部门对话”负责跳转,避免误触导航。
- 发送期间按钮显示进度并防止重复提交;错误在当前配置区域说明。
## 6. 主题与层次
复用 DSH 的背景、表面、文字、边框和强调色变量。蓝色回退为 #4D6BFE;明亮模式的视觉参考为浅灰工作区、白色卡片和浅蓝选中底色。
深色模式保持同一结构,使用宿主深色表面与边框;不得保留刺眼白卡。状态同时使用文字和颜色,正文对比度以至少 4.5:1 为目标,可交互边界与焦点以至少 3:1 为目标。连接线比部门卡片边框更弱,但仍可辨认。
六部分组底色比工作区略深或略偏蓝,组内每个部门仍保持独立边框。配置区使用独立卡片,“与该部门对话”为主要入口,“保存模型设置”为次要按钮;消息发送按钮只存在于对应会话输入区。
## 7. 空间与响应式
按面板实际容器宽度适配,不能只依赖整个浏览器窗口宽度。
- 实现方式:`.sl-root` 声明 `container-type:inline-size;container-name:slpanel`,所有断点写成 `@container slpanel (max-width: …)`;`panel/lib/client.js` 里不得再出现视口 `@media (max-width: …)` 断点,`panel/test/client.test.js` 有回归测试守着这条。
- 1180px / 980px:整页与双栏形态的切换;侧栏形态下这两档不会生效。
- 620px 及以下:统计两列两行;三省与六部降为两列,卡片保持 104px 以上的可读宽度。
- 330px 及以下:三省与六部降为单列;组织层级用分组标题表达,不再强行绘制横线。
- 极窄宽度:使用单列卡片和分组标签,隐藏无法准确表达关系的树形横线,保留组织语义。
- 统计卡建议每张高64–72px,避免占据过多首屏空间。
- 采用自然纵向滚动,不固定过小高度导致文字截断;表单窄屏改为上下排列。
- 部门配置里的「最近活动」独占一行,最多两行后省略;不得与状态文字排在同一行互相挤压。
- 不直接按1024px生成图等比缩小;在320、360、371、400、440、480px容器中检查实际可读性。
## 8. 数据与实现边界
继续使用现有成员和任务投影生成统计,运行状态与任务状态分别计算。选择部门后配置区同步切换,复用已有会话导航、模型和指令发送逻辑。底层预设与部门角色配置保留,由系统管理;移除面向普通用户的手动预设切换入口,不因此删除底层角色初始化。
后续授权实现后,主要修改 panel/lib/client.js 中的卡片、组织分组和样式;必要的纯布局逻辑可放入 panel/lib/model.js。行为变化才补对应回归测试,不以字符串断言代替视觉验证。此方案不要求引入新的UI库,也不要求修改后端权限。
## 9. 部门设置与子 Agent 对话
本节取代上一轮设置卡中“发送任务”输入框的设计。用户指出给丞相下任务本来就在主会话,真正需要明确的是如何与子 Agent 对话。右侧栏里对应的是底部的「正在丞相主会话 / 与某部对话」按钮,见第 2 节的真实渲染图。
### 对话路径
- 给丞相下任务:在丞相主会话的原生输入框发送。
- 与部门聊天:选中部门卡片 → 点击“与工部对话”等具体入口 → 打开该成员现有的可继续子会话。
- 快捷入口:在 DSH 原生输入框输入 `@` → 选择已设官部门 → 直接进入该部门子会话,在同一个原生输入框继续输入并发送。候选只包含已有会话的部门;选择动作本身就是导航,不把当前会话中的普通文字静默改投给其他 Agent。
- 选中同步:进入某部门子会话时,右侧朝堂图自动选中该部门并切换配置区;返回丞相主会话时恢复选中丞相。切换只跟随实际会话,不按普通文本猜测接收人。
- 子会话显示历史消息、当前接收部门和原生消息输入框,支持继续追问与补充;不另造一套聊天存储或发送机制。
- 顶部提供“返回丞相主会话”,明确父子关系。原有“打开会话”入口改用具体接收方文案,降低歧义。
- 点击卡片仅选择部门;真正进入会话必须通过明确入口,避免误触跳转。
- 未设官或没有可继续会话时,入口不可用并解释原因;不能静默创建重复成员或将消息转发给其他角色。
- 子会话消息与主会话分别保存。不要暗示私聊内容会自动同步给丞相;如后续需要汇报功能,应单独规划明确的转发动作。
- 直接对话不改变部门权限、分工与审批边界。
### 设置卡
1. 身份:字徽、部门名称、职责摘要;固定职责应由实际角色绑定支持。
2. 模型:模型下拉、模型支持的推理等级、单一“保存模型设置”按钮;未修改时禁用,成功或失败有明确反馈。同名模型才补充友好的提供商名称。
3. 对话入口:“与工部对话”或“返回丞相主会话”。已处于该成员会话时显示“正在对话”,避免重复导航。
移除设置卡里的“下旨给丞相”、任务输入框、“下旨”或“发送任务”按钮;移除 Agent 预设输入、应用按钮和加载提示。内部标识可放入默认折叠的只读高级信息。底层预设仍由系统管理,旧会话角色不匹配时明确提示,不静默改写。
宽屏模型与推理等级并排,窄栏上下排列。预览图中的模型与推理等级只是示意,真实选项严格由模型能力目录决定。图中遗漏的统计区、卡片字徽和状态仍以其他章节为准,本图重点表示对话位置。
专项验收:设置区无重复消息输入框;子会话能查看历史并继续发送;实际接收方与会话标题一致;返回主会话不丢失历史;未设官入口正确禁用;不自动同步私聊或绕过既有权限。
## 10. 后续实施顺序
1. 建立卡片表面、边框、间距与状态样式。
2. 整理丞相、三省、六部分组与连接线。
3. 压缩统计区,梳理部门配置区。
4. 验证宿主明亮/深色主题和真实窄栏宽度。
5. 运行现有回归测试,检查会话跳转、模型选择和发送指令。
6. 获取真实界面截图,与设计图比对后再宣告视觉验收。
## 11. 验收标准
- 十席完整、无重复,吏部和礼部文字正确。
- 未选中的部门也有清晰边框,不能看起来只是浮动文字。
- 选中、运行、失败、未设官和键盘焦点可以区分。
- 六部全部属于尚书省,不产生错误的上下级连线。
- 统计使用实时投影,图片中的示例数字不会进入逻辑。
- 窄栏没有横向溢出,名称与状态不被裁切。
- 明亮与深色均可读,配置功能与会话入口保持可用。
- 真实界面视觉检查和必要回归测试都通过;生成模拟图不能替代实际截图验收。

View File

@ -1,239 +0,0 @@
# 三省六部面板:换环境开发交接方案
日期:2026-11-08
当前版本:`0.5.6`
状态:侧栏化改造、残留清理、容器断点与左侧栏入口均已实现并通过 39 项本地测试;尚未在真实 DSH Host 里做最终视觉验收。
![右侧栏 440px 明亮主题](preview/panel-sidebar-440-light.png)
> 这张图由 `scripts/preview.mjs` 渲染真实组件树 + 真实 CSS,再用 headless Chrome 截图(440 CSS px × 2 DPR),不是 DSH Host 的运行截图,也不是 AI 生图。同一脚本还产出宿主实测宽度 371px、窄栏 360px、极窄单列 320px、深色主题与任务页:
![371px 实测侧栏宽度](preview/panel-sidebar-371-light.png)
![360px 窄栏](preview/panel-sidebar-360-light.png)
![320px 单列](preview/panel-sidebar-320-light.png)
![440px 深色主题](preview/panel-sidebar-440-dark.png)
![任务页](preview/panel-sidebar-tasks-440.png)
左侧栏导航行(静态标记 + 真实 CSS,不是宿主截图):
![左侧栏入口](preview/panel-rail-entry.png)
重新生成(需要放开沙箱,Chrome 无头模式要建 mojo 命名管道):
```bash
node scripts/preview.mjs --width=440 --view=court --theme=light --name=panel-sidebar-440-light --out=docs/preview
node scripts/preview.mjs --width=371 --view=court --theme=light --name=panel-sidebar-371-light --out=docs/preview
node scripts/preview.mjs --width=360 --view=court --theme=light --name=panel-sidebar-360-light --out=docs/preview
node scripts/preview.mjs --width=320 --view=court --theme=light --name=panel-sidebar-320-light --out=docs/preview
node scripts/preview.mjs --width=440 --view=court --theme=dark --name=panel-sidebar-440-dark --out=docs/preview
node scripts/preview.mjs --width=440 --view=tasks --theme=light --name=panel-sidebar-tasks-440 --out=docs/preview
```
复现「大窗口 + 窄侧栏」(真实宿主形态):加 `--viewport=1200 --width=371`,页面按 1200px 窗口渲染、侧栏仍为 371px。
只想要中间 HTML、不调 Chrome 时加 `--html-only`。最终验收仍然必须在真实会话右侧栏里完成。
## 1. 一句话目标
不要再维护一套整页面板或第二套聊天界面。聊天全部使用 DSH 原生输入框;三省六部的朝堂编制、任务流转和部门配置只停留在会话右侧栏,并通过 `@` 直接进入部门子会话。
## 2. 已经完成的部分
- 十席角色:丞相、中书省、尚书省、门下省、吏部、户部、礼部、兵部、刑部、工部。
- 朝堂图为「丞相 → 三省 → 六部」,六部两排三列,同属尚书省调度。
- 部门为实体卡片:字徽、边框、状态点和中文状态;选中态有蓝边、浅底和勾选标记。
- 插件注册会话头部入口、左侧栏导航行(`sidebar.panellist`)、`main` 重定向桩与右侧栏页签;`sidebar.panellist.actions` 仍不注册。
- 右侧栏包含「朝堂 / 任务」页签、2×2 统计卡、朝堂图、部门配置和任务列表。
- DSH 原生输入框注册 `@` 来源,列出已有会话的部门;选中后进入该部门子会话。
- 进入部门子会话时自动选中对应部门;返回丞相主会话时恢复选中丞相。
- 移除 Agent 预设编辑、重复的「下旨」输入框和独立聊天摘要。
- 复用 DSH 主题变量,支持明亮、深色与窄侧栏布局。
- 0.5.6 左栏那一行改名「上朝」(`label: () => "上朝"`),`order` 从 10 改成 −100,排在「插件」之外的所有插件行之前(置顶)。
- 0.5.5 撤掉了 0.5.3 的左侧栏底部入口(`sidebar.footer.action`):用户看到左栏里同时出现导航行和底部一行,明确要求只保留导航列那一行。左栏入口从两个收敛成一个。
- 0.5.4 把入口放进左侧栏导航列(`插件 / 定时任务 / 任务看板 / MCP 连接器` 那一列):注册 `sidebar.panellist` 一行(细线「三」字样标 + 标签),点击后走宿主的 `selectPanel(id)`。
- 因为那一列的点击一定要 `main` 槽,所以同时注册 `main`(`key: PANEL_ID`)作为**重定向桩**:进去立刻把朝堂停靠到当前会话右侧栏并 `selectPanel(null)` 退回原会话;没有会话时只在页面中央写明原因。它不渲染面板、不承载聊天。
- ~~0.5.3 在左侧栏底部加了一个常驻入口~~:0.5.5 已撤掉,见上条。
- 0.5.3 去掉了会话头开关失败时对 `host.togglePanel()` 的回退:0.5.0 起没有 `main` 槽,那个调用只会把主区域切到一个不存在的面板上。
- 0.5.2 把响应式断点从浏览器视口改到面板容器:`.sl-root` 声明 `container-type:inline-size;container-name:slpanel`,11 处 `@media (max-width: …)` 全部改为 `@container slpanel (max-width: …)`。真实宿主窗口最大化时侧栏仍只有 371px,原来的视口断点一个都不会触发。
- 部门配置里的「最近活动」独占一行(最多两行后省略),不再和状态文字挤在同一行被裁断;单列阈值落在 330px 容器宽(360px 及以上仍两列)。
- `scripts/preview.mjs` 新增 `--viewport`,可以渲染「大窗口 + 窄侧栏」的真实宿主形态。
- 0.5.1 清掉侧栏化残留:46 个不再渲染的 `sl-*` 类、无调用点的 `SanshengPinRow`/`DockButton`/`SidebarIcon`,以及三个无规则的幽灵类名。
- 会话头部开关在拿不到会话时把原因显示在开关旁,不再静默回退;CSS 与组件的一致性由测试兜住。
- 版本更新到 `0.5.6`;`CHANGELOG.md`、`panel/README.md`、`docs/panel-design.md` 已同步。
## 3. 当前验证结果
在 `C:\Users\qyh15\三省六部` 执行:
```powershell
$node = 'C:\Users\qyh15\AppData\Local\Programs\DeepSeek Harness\DeepSeek Harness.exe'
$env:ELECTRON_RUN_AS_NODE = '1'
& $node --check panel/lib/client.js
& $node --test --test-isolation=none test/policy.test.js panel/test/client.test.js
& $node scripts/check-install.mjs
```
结果:
- 语法检查通过。
- **39 项测试全部通过**。
- `scripts/check-install.mjs` 通过:panel 以 link 方式安装,client bundle 已注册。
- `modeEnabled: false` 只表示「上朝」模式尚未启用,不表示面板不可用。
- 清理前后做了像素级 A/B:用同一份 `scripts/preview.mjs`、同一组参数,分别渲染 0.5.0 快照(`.scratch/preview-baseline/client.snapshot.js`)与 0.5.1 的 `panel/lib/client.js`,五组(440/400/360 明亮、440 任务页、440 深色)截图的 sha256 **逐字节相同**,证明删掉的 CSS 与组件确实不在渲染路径上。
- 体积变化:内联 CSS 40,963 → 28,346 字符(−30.8%),HTML 52,261 → 39,596 字节(−24.2%)。
尚未完成:真实 DSH Host 的视觉截图验收。当前只有 Chromium 对真实组件树的渲染图。
## 4. 代码地图
| 文件 | 作用 | 当前注意点 |
| --- | --- | --- |
| `panel/lib/client.js` | 前端全部实现:CSS、React 组件、DSH 槽位、@ 来源、宿主适配 | 约 1890 行,单文件自包含 bundle;修改后必须跑 `--check` |
| `panel/lib/model.js` | 十席定义、布局、状态、模型切换等纯逻辑 | 与 client 内自包含常量需要同步 |
| `panel/index.js` | 策略侧 formation/decree 提示词 | 与前端职责保持一致 |
| `index.js` | Agent Preset 策略、角色工具权限 | 不得随意放宽写入/命令权限 |
| `panel/test/client.test.js` | 面板结构与行为测试 | 使用最小 React 替身,`useState` 不自动更新 |
| `test/policy.test.js` | 策略与权限测试 | 与客户端测试合计 39 项 |
| `scripts/check-install.mjs` | 安装一致性检查 | 已改为校验右侧栏注册、拒绝旧的 main/panellist |
| `scripts/preview.mjs` | 零依赖预览生成器:vm 加载真实 bundle → 渲染真实组件树 → HTML → headless Chrome 截图 | 需放开沙箱跑 Chrome;`--html-only` 只出 HTML |
| `docs/panel-design.md` | 设计依据与验收标准 | 已更新到侧栏结构 |
| `CHANGELOG.md` | 版本变更 | 顶部已切到 `0.5.x` 线 |
### 前端关键位置
- `SanshengPanel`:右侧栏主组件,状态含 `sidebarView`、`selectedRole`、`activeChildId`。
- `SeatCard`:部门实体卡片。
- `courtStats`:四张统计卡的数据投影。
- `seatMentionOptions` / `createSeatMentionSource` / `registerSeatMentions`:原生 `@` 来源。
- `childRoleOf`:由子会话 id 反查部门角色,用于自动选中。
- `openSeatConversation` / `returnToLead`:进入部门会话与返回丞相。
- `apply`:注册五个原生槽位:
- `conversation.session.header.actions`(会话头开关)
- `sidebar.panellist`(左侧栏导航列的一行,标签「上朝」、`order: -100` 置顶;图标是插件提供的细线「三」字样标)
- `main`(只作重定向桩:停靠右侧栏后退回原会话,不渲染面板)
- `sidebar.right.pane.tab`
- `sidebar.right.pane.tab.title`
- `dockToSidebarTab(host)`:导航行点击后的实际动作(成功清提示并 `selectPanel(null)`,失败只写提示),导出在 `__test` 里供测试直接驱动。
## 5. 不可破坏的决策
1. **不恢复整页面板**。左栏只保留**一个**入口——导航列那一行;不要再加底部入口、页脚按钮或第二处重复入口(0.5.5 就是撤掉这类重复)。`sidebar.panellist` 只用于「左侧栏导航列的一行」,`main` 只用于「点进去立刻退回会话」的重定向桩:两者都不得渲染朝堂内容、不得承载聊天、不得出现第二套输入框。用户 0.5.4 明确要求入口出现在导航列,这是对 0.5.0「两个槽一律不注册」的收敛式修订——范围限定在「纯跳转」,不是把整页面板请回来。
2. **不造第二套聊天存储**。消息只在 DSH 原生会话里发送与保存。
3. **不静默改投消息**。普通 `@` 文本不能自动把当前会话消息转发给别的 Agent;进入哪个会话,消息就发给谁。
4. **@ 只列已有会话的部门**。未设官、无子会话的部门不能伪造入口。
5. **权限不因界面变化而放宽**。这只是客户端面板调整,不修改 `index.js` 的工具边界。
6. **版本历史只用 Git**。不要创建 `backup/`、时间戳副本或“最终版”目录。
## 6. 换环境后的推进顺序
### 第 1 步:带走代码,而不是复制一堆副本
当前工作树有未提交改动。换环境前先在原环境提交一次,或生成 Git bundle:
```powershell
cd C:\Users\qyh15\三省六部
git add -A
git commit -m "feat(panel): move court into sidebar and use native chat mentions"
```
如果目标环境不能直接访问原磁盘:
```powershell
git bundle create sansheng-liubu-0.5.0.bundle --all
```
到新环境:
```powershell
git clone sansheng-liubu-0.5.0.bundle 三省六部
```
不要手工拷贝整个工作区,也不要把 `node_modules`、`.chrome-preview` 或临时 HTML 带过去。
### 第 2 步:确认宿主与安装方式
新环境先确认:
- DSH 版本支持 `sidebar.right.pane.tab` 与 `inputTriggers.registerSource`。
- profile 的 `dsh.profile.bundles` 含 `dsh-sansheng-liubu-panel`。
- panel 以 `link:` 或可编辑的开发方式安装,避免每次改代码都重新打包。
- 如需「上朝」模式,再执行 `node scripts/mode.mjs on`;面板本身不需要先开模式。
### 第 3 步:真实宿主验收
重启 **DSH Host**,不是只刷新浏览器。然后:
1. 打开一个会话,确认右侧栏出现「三省六部」页签。
2. 检查「朝堂 / 任务」切换;点击「在朝成员」「在办任务」统计卡。
3. 在原生输入框输入 `@`,确认只出现已有会话的部门。
4. 选择 `@工部`,确认进入工部子会话,右侧栏自动选中工部。
5. 在工部会话发送一句话,确认消息进入工部而不是丞相会话。
6. 点击「返回丞相」,确认回到父会话且选中恢复丞相。
7. 在 360、400、440、480px 侧栏宽度下检查:无横向滚动、卡片名称和状态不被裁切。
8. 切换 DSH 明亮/深色主题,确认没有刺眼白卡或不可读状态。
### 第 4 步:处理剩余技术债
这些不阻塞功能,但建议在下一个环境完成:
- ~~删除已不再渲染的旧 CSS~~:0.5.1 已删除 46 个死类、约 117 行规则(CSS 374 → 257 行)。
- ~~删除未引用的 `SanshengPinRow`、`DockButton` 包装~~:两者与 `SidebarIcon` 导出均已删除(确认外部无消费方)。
- ~~检查会话头部开关在“当前没有会话”时的反馈~~:0.5.1 已把失败原因显示在开关旁(`role="status"`),并有回归测试。
- 视真实宿主表现,决定是否保留 `remote.agentPresets` 注入;高级信息仍读取只读预设,不要贸然删除底层能力。
- 为真实右侧栏补一张宿主截图,替换/补充 `panel-preview-sidebar.png` 作为验收证据。
## 7. 可直接粘贴给新环境 Agent 的交接提示
```text
你在 C:\Users\qyh15\三省六部 继续一个 DSH Web 客户端插件项目(dsh-sansheng-liubu-panel,当前 0.5.6)。
用户目标:三省六部面板只存在于会话右侧栏;聊天必须复用 DSH 原生输入框;在原生输入框用 @ 选择部门后进入该部门子会话,并自动选中右侧对应部门;不要再恢复整页面板或第二套聊天。
先读:
- docs/panel-handoff.md
- docs/panel-design.md
- panel/lib/client.js 中 SanshengPanel、createSeatMentionSource、apply
- panel/test/client.test.js
- scripts/check-install.mjs
当前状态:侧栏化、残留清理、容器断点与左侧栏入口(含导航行)都已实现,39 项测试通过,check-install 通过,工作树可能尚未提交。不要创建备份目录。
请先:
1. 运行现有测试和 check-install,确认基线;
2. 在真实 DSH Host 重启后验收右侧栏、@ 导航、自动选中、返回丞相;
3. 修复真实宿主暴露的问题,并补回归测试;
4. ~~清理不再渲染的旧 CSS/组件~~(0.5.1 已完成,后续只需保持);
5. 更新 CHANGELOG、README 和设计文档,保持 0.5.x;
6. 用 Git 提交,不要建时间戳副本。
硬约束:
- 不注册 sidebar.panellist.actions;main 与 sidebar.panellist 只允许作「导航行 + 重定向桩」;
- 不新增聊天存储,不静默把消息转发给其他 Agent;
- @ 候选只含已有会话的部门;
- 不改变 index.js 的角色工具权限边界;
- 每个设计调整附一张新的实际预览图。
```
## 8. 验收标准
- [ ] 右侧栏可打开,朝堂与任务可切换。
- [ ] 十席完整,六部同属尚书省,无错误上下级连线。
- [ ] 部门卡片在窄栏仍清晰,名称与状态不裁切。
- [ ] `@` 只列已有会话的部门,选择后进入正确子会话。
- [ ] 进入子会话自动选中对应部门,返回后恢复丞相。
- [ ] 原生输入框发送的消息不会误投给其他 Agent。
- [ ] 明亮/深色主题都可读,焦点与选中状态可见。
- [ ] 39 项测试、`node --check`、`git diff --check`、`check-install` 全部通过。
- [ ] 有真实 DSH Host 截图作为最终视觉证据。
## 9. 已知风险
- 静态预览能按任意容器宽度渲染,但**不能**证明宿主实际给出的侧栏宽度、滚动容器和槽位渲染完全一致;必须实机验收。宿主实测侧栏宽度为 371px,已作为预览图之一(`panel-sidebar-371-light.png`)。
- 断点已改为容器查询,但容器是 `.sl-root`:若宿主把面板塞进更窄的固定宽外壳,实际生效宽度以内层容器为准。修改布局时先用 `--viewport=1200 --width=371` 复现真实形态,不要只看预览页宽度。
- `better-sidebar` 与宿主自带 `sidebarRight` 两条注册路径都要验证;只测其中一条不够。
- 测试用的最小 React 替身不会执行真实点击,交互问题需要宿主手测或补更真实的组件测试。
- 若新环境 DSH 版本没有 `inputTriggers`,`@` 入口应静默不可用,但其余侧栏功能不能因此崩溃。

Binary file not shown.

Before

Width:  |  Height:  |  Size: 76 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 30 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 174 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 160 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 165 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 162 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 170 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 81 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 44 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 90 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 34 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 67 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 51 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 50 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 48 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 107 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 106 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 97 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 93 KiB

View File

@ -1,77 +0,0 @@
# 三省六部工作台 v0.1 · 使用说明
装好并重启 DSH 之后,右侧多一栏「三省六部」。它是**贴着当前项目**的一本工作台账:谁在办、办到哪、交了什么,都在这里。中间仍然是原生聊天,没有第二个输入框。
## 1. 先接通,再派工
十席(丞相 / 中书 / 尚书 / 门下 / 吏户礼兵刑工)一开始都是「未接通」——只是编制,还没有会话。
1. **朝堂**页点卡片右下角的「接通」。宿主会给这一席建一个独立会话,并把卡片状态变成「空闲」。
2. 卡片本身是可点的:点已接通的卡片,中央区会切到那一席的会话。
3. 接通后,这一席才收得到派工。
「接通」做的事:建会话(或复用已有会话)→ 把会话号写进账本绑定 → 打开它。换绑不自动发生,需要显式重接,避免把两个部门串到同一个会话上。
## 2. 派一条任务
**任务**页 → 「新建」→ 填标题、目标、主责部门 → 「存为草稿」。
草稿不会自己跑,因为服务端不允许把任务直接塞进一个还没接通的部门。接下来:
- 部门已接通:在任务行上点 **「派工」**,任务会被投递到那一席的会话里,卡片变「正在运行」。
- 部门没接通:先回朝堂接通,再回来点「派工」。
- 派错了或不想跑了:点 **「取消」**。取消只改台账状态,不会删除已经发生的对话。
同一条任务重复点「派工」不会派出两份——幂等键按任务号生成,第二次会返回第一次那条记录。
## 3. 部门怎么回话
部门在自己的会话里干活,完成后回一段带前缀的契约行(宿主解析,不需要你手抄):
```
【三省六部】{"action":"reportTaskResult","taskId":"…","report":{"summary":"…","checks":[…],"artifactRefs":[…]}}
```
收到并校验通过后,任务变「已完成」,成果进「成果」页。判定是三件事都要成立:**运行结束、报告合格、成果核验通过**。缺一件就停在「需人处理」,等你说下一步。
## 4. 成果与修订
**成果**页每行是一份交付物:
- 灰色「· 位置未核验」:只登记了路径,还没确认文件在不在。
- 红色虚线「· 文件已失效」:登记过,但磁盘上找不到了。记录还在,可以重新登记,或让主责部门补一份。
- 「第 N 版 · 修订自上一版」:这是某份成果的修订版,原始版本仍然可查。
点开一行 → 「找主责部门修改」→ 写清楚要改什么 → 「存为草稿」或「直接派工」。这会**只**给原主责部门开一条修订任务,不重跑三省。
## 5. 模型
部门模型由根插件按角色覆写,走的是 `/dept-model` 命令,不在右栏里改(右栏只显示当前生效的模型):
```
/dept-model 工部 magpie workbuddy/deepseek-v4.1-flash 高
/dept-model list
/dept-model clear 工部
```
右栏卡片上的模型行就是它当前会用的那个;显示「跟随宿主」表示没有单独设。
## 6. 栏宽与键盘
- 拖分隔条,或在分隔条上按方向键(±16px,Shift ±64px,Home/End 到两端),宽度记在 `localStorage['sansheng.workbench.railWidth']`,范围 340–600。
- 卡片是 `role="button"`,Tab 可到,Enter / 空格打开会话。
## 7. 项目隔离
每个项目一本账:席位绑定、部门配置、任务、成果、事件都按项目分桶。切项目会重新取一次 `bootstrap`,看不到别的项目的东西。同一个目录被登记成两个项目会明确报冲突(要共用请显式传 `allowSharedRoot`)。
## 8. 出问题怎么办
| 现象 | 处理 |
| --- | --- |
| 中央区白屏或样式崩了 | 控制台执行 `localStorage['sansheng.workbench.main']='off'`,刷新。接管被整个跳过,原生聊天照旧 |
| 右栏不出现 | `node scripts/workbench-preflight.mjs` 看 5 项自检;再确认重启是**彻底退出**而不是关窗口 |
| 派工后一直「已备好」 | 宿主没接上会话层:重启获取一次;右栏会提示「已记入台账,但暂时没有真的发出」 |
| 完全不想用了 | 从 profile 移除 `dsh-sansheng-liubu-mode` 后重启(独立 workbench 包已退役) |
账本在 `%USERPROFILE%\.dsh\sansheng-liubu\workbench.json`。它是唯一事实来源,删掉等于清空工作台;Git 回退代码不会回退它。

View File

@ -1,376 +0,0 @@
# 三省六部独立工作台 v0.1 实施方案
日期:2026-11-09
用途:交给执行者的实施与验收依据。当前只完成方案编写,未实现、安装或迁移。
版本含义:v0.1 是新架构的首个里程碑,不代表把现有 0.9.2 软件包直接降级为 0.1.0。
## 1. 执行摘要与约束优先级
要交付的是 DSH 内的独立工作台:左侧直接使用 better-workspace-group 现有项目树,中间显示所选部门的真实会话,右侧显示可调宽的部门树、模型配置以及任务与工作成果。每个项目的每个部门有独立 session;程序定向传递必要上下文,模型承担专业判断。多个项目可以同时运行,配置、会话、结果和停止操作互不串线。
用户已经确定的硬要求:
1. 独立主页面,不依附于某个普通聊天或丞相 Team;不要求 spawn_teammate 才能找到部门。
2. 复用现有项目树,不新建项目列表,不恢复顶部项目标签。分组不是项目。
3. 项目隔离从首版实现,服务侧检查归属,不能只过滤前端列表。
4. 右侧树状方块:丞相顶端居中;下一排中书、尚书、门下;尚书连接六部这一同级分组。六部两排展示,不能画成上下级。
5. 每个部门独立改模型,修改只影响当前项目当前部门;运行中的请求保持原配置。
6. 中央聊天优先保留空间,右栏可拖动、收起、恢复;白蓝浅色、跟随宿主的深色模式,紧凑字体。
7. 工作成果由 Agent 产生,用户在聊天中提供材料;成果区没有要求用户上传交付物的流程。
8. 使用 Git 管理版本。不创建 backup、时间戳副本或“最终版2”代替版本历史。
本文的字段、模块名和开发顺序是实施设计,不是已存在的 DSH API。与宿主真实接口有冲突时,先写明证据和适配方案;不得把虚构调用当成已验证能力。需求冲突按“用户最新指示 → 本文首版范围与已确认视觉要求 → 总体规划 → 历史资料”处理。
相关资料: [总体规划](../V1.0-工作台修复方案.md)、[视觉要求与预览](panel-design.md)、[待办](../TODO.md)、[交接入口](panel-handoff.md)。旧 Team/侧栏规则不具有新架构约束力。
## 2. v0.1 范围与完成定义
本方案建议:开发中先以丞相、工部两席跑通闭环,最终 v0.1 扩展到全部十席的独立会话与相同基础能力。两席闭环不能冒充十席完成。其余部门未接通时明确标注“尚未接通”,不能显示待命或可执行。
### 2.1 必须交付
| 能力 | 首版要求 |
|---|---|
| 页面入口 | “上朝”进入独立工作台,同页聊天,无需父会话 |
| 项目入口 | 真实接入现有项目树选择和稳定工作区 ID |
| 十席 | 丞相、三省、六部均可按需创建独立会话、直聊、恢复历史 |
| 配置 | 每席保存明确 provider/model/受支持 effort;实际运行可核对 |
| 基础交接 | 创建任务单、定向发送上下文与材料、回执、执行结果、回传 |
| 用户直聊 | 只发当前部门;切换部门保留各自草稿 |
| 成果 | 文件引用、主责部门、来源任务、真实检查、局部修改入口 |
| 运行控制 | 会话串行投递,跨项目可并行,取消准确指向运行 |
| 可靠性 | 幂等、失败/未知状态、刷新恢复、宿主重启后的对账 |
| 隔离 | 会话、配置、材料、记忆、权限、任务及文件边界验证 |
| 视觉 | 已确认三栏、调宽、居中、浅深色、手机抽屉、键盘可用 |
| 验收 | 单元/集成测试及真实 DSH GUI 双项目端到端证据 |
### 2.2 后续版本再做
完整自动化的“中书规划 → 门下审议 → 尚书派工 → 六部执行 → 成品审核”引擎、多层任务 DAG、自动重规划、无限层级子任务、自建技能市场、跨项目共享、自动迁移旧 Team、自动压缩换 session、成本统计仪表盘和进度百分比均不属于 v0.1。
首版可以由用户或丞相选择需要的部门,以单任务、单主责执行和结果回传构成闭环;不同部门的独立任务可并行,但同目录写冲突必须协调。不要为了自动化朝廷流程阻塞基础聊天和项目隔离。不要把十席常驻展示理解为进入页面就启动十次模型请求。
### 2.3 两条必须演示的业务路径
路径 A:用户在项目 A 找丞相提出明确工程任务 → 丞相通过受控交接操作提交工部任务单 → 程序创建/定位工部独立会话并发送必要材料 → 工部执行和检查 → 结构化报告登记结果与源文件 → 丞相收到定向结果并汇报。此时项目 B 同时运行独立任务,配置和消息保持隔离。
路径 B:用户在成果区点击“找主责部门修改” → 工部会话得到用户指定修改、成果版本及来源任务 → 修改原工作文件 → 新增修订记录和检查结果。无需重新启动整套三省流程。普通问答不强制生成任务。
## 3. 第一阶段必须核实的宿主能力
执行者先只读核实实际安装版本和源码;当前仓库中的调用痕迹只是调查线索。不得凭接口名字假设权限、返回值、完成语义或跨项目安全性。
建立 [宿主能力记录](host-capabilities.md)(实施时创建),每项填写:宿主/插件版本、源码路径与行号、调用签名、返回值、错误语义、最小验证、结论、需改动的仓库。状态只能是“已验证 / 需要扩展 / 未确认 / 不支持”。
| 项目 | 要取得的证据 | 阻塞条件 |
|---|---|---|
| 主页面扩展 | 可注册独立页面、导航、卸载行为 | 只能渲染旧聊天 sidebar |
| 项目树 | 插件真实标识、稳定 workspace ID、选择事件、初始选择、重命名/移动/删除行为 | 只能读取 DOM 文本或依赖名称猜测 |
| 内嵌聊天 | 组件生命周期、传入 session ID、原生历史/附件/输入/审批能力 | 只能跳去外部聊天页 |
| 独立 session | 创建参数、准确 ID、工作目录、角色配置、创建幂等/可查询性 | 只能扫描“最新会话”猜 ID |
| 消息投递 | 指定 session、文本、附件、消息 ID、接收回执 | 只能把文本塞进当前输入框 |
| 运行关联 | hostRunId 与消息/dispatch 的关联、终态、取消、重启查询 | 只有通用 idle 状态且无可追溯终态 |
| 模型目录 | provider/model ID、effort 枚举、可用状态、实际请求配置 | 只能改全局默认或无法核对生效 |
| 配置/工具权限 | 会话独立配置、技能绑定、宿主审批和写入边界 | 角色提示词承担实际权限控制 |
| 材料/记忆 | 附件授权引用、检索范围、全局记忆注入的开关与作用域 | 无法阻止其他项目材料自动进入 |
| 存储 | 宿主允许的位置、原子更新/事务、版本、事件恢复 | 仅浏览器 localStorage 保存任务账 |
| 主题/构建 | 宿主主题令牌、真实客户端构建和加载方式 | 改源码但当前 GUI 未加载 |
项目树可能只提供 workspaceId,没有另一个 projectId。此时在插件中生成稳定 projectId,并与 hostWorkspaceId 建唯一绑定;不要强迫宿主增加同义标识。若宿主原生 ID 足够稳定,也可使用该 ID 作为内部项目键,须记录决定。绝不能用目录名、树行号或显示名称作主键。
若缺少核心能力,交付最小宿主扩展提案和可复现证据。先完成不依赖该能力的纯逻辑、测试和视图工作;明确阻塞集成部分,不以假数据宣布完成。若需要修改本仓库外的宿主或第三方插件,说明具体仓库与变更边界,由该处适用权限控制;不要直接改安装包内的 app.asar 当成可维护实现。
DS Bot 仅为页面组织参考。当前没有核实其真实上游地址、版本或许可证。需要借用代码时先核实并记录授权;不为寻找参考引入第二套会话运行时。
## 4. 分层与复用策略
建议分为四层:工作台 UI → 项目服务/任务服务 → 会话及宿主适配层 → DSH 原生能力。任务调度必须在可持续运行的服务侧,关闭页面不会停止派发和结果处理。UI 订阅投影,不承担唯一调度者职责。
| 模块(建议名称) | 职责 |
|---|---|
| WorkspaceAdapter | 承接现有树选择、稳定 ID、生命周期 |
| SessionAdapter | 创建/查询 session、投递、运行查询/取消、原生聊天接入 |
| ModelAdapter | 目录、参数校验、明确配置快照与实际生效核对 |
| ProjectService | 项目和部门绑定、归属校验、并发版本更新 |
| ContextBuilder | 按任务构建最小上下文包、校验材料及版本 |
| DispatchService | 持久队列、幂等、单会话串行、公平并发 |
| ResultService | 校验报告、关联运行、成果登记和回传 |
| Reconciler | 启动对账、断线恢复、未知状态核查 |
| WorkbenchView | 三栏、树、会话容器、任务与成果、设置 |
这些是内部职责边界,不要求为了形式拆成十个软件包。先用本仓库技术栈,优先已有依赖;新增依赖需说明必要性。
现有[策略入口](../index.js)可参考角色职责,但必须拆除以 membership 决定身份的默认逻辑,否则所有独立会话可能都变成丞相。[旧客户端](../panel/lib/client.js)可参考主题、模型选择与注册方式,但不复用父会话/Team 投影作为状态源。[旧桥接入口](../panel/index.js)中的组建提示词不能作为新会话创建流程。[纯逻辑模块](../panel/lib/model.js)的角色定义需核对后复用。
先看 git status/diff,保护执行者开始前已有改动。不要整文件覆盖未理解的用户修改,不自动迁移旧 session。旧功能如需保留,用明确模式边界区分;新工作台不能误执行旧 Team 注入。
## 5. 身份与数据模型
以下是逻辑字段建议,不指定数据库产品。聊天正文继续由 DSH 保存;插件仅存业务账、引用和必要交接快照。所有服务入口必须从可信宿主上下文确定调用身份,再验证传入 ID;模型填写的 projectId 不能成为授权依据。
### 5.1 角色标识
| roleId | 中文 | 首版职责 |
|---|---|---|
| lead | 丞相 | 接需求、分流、协调、汇报 |
| zhongshu | 中书省 | 调查、澄清、规划 |
| shangshu | 尚书省 | 分工建议、组织交付 |
| menxia | 门下省 | 审议与整体审核 |
| libu | 吏部 | 角色和技能配置建议 |
| hubu | 户部 | 数据、表格、计算 |
| lipu | 礼部 | 文档、内容、呈现 |
| bingbu | 兵部 | 环境、调试、部署 |
| xingbu | 刑部 | 测试与风险检查 |
| gongbu | 工部 | 代码实现与工程产出 |
核对现有标识后建立显式兼容映射,尤其吏部与礼部不可混用。修改中文显示名不改变 roleId。吏部的职责不赋予它绕过用户授权修改权限或其他项目设置的权力。
### 5.2 核心记录
| 实体 | 必要字段 |
|---|---|
| Project | id、hostWorkspaceId、displayNameCache、canonicalRoot、status、schemaVersion、revision、timestamps |
| DepartmentBinding | projectId、roleId、currentSessionId(nullable)、bindingGeneration、historySessionRefs、creationRequestId、revision |
| DepartmentConfig | projectId、roleId、providerId、modelId、reasoningEffort(nullable)、rolePromptVersion、skillRefs、permissionRef、configRevision |
| Task | id、projectId、title、objective、acceptance、ownerRoleId、sourceRoleId、originMessageRef、scope、status、activeAttemptId、revision |
| Dispatch | id、projectId、taskId、attemptId、sourceSessionId、targetSessionId、bindingGeneration、contextPacketId、idempotencyKey、status、hostMessageId、timestamps |
| Attempt | id、projectId、taskId、dispatchId、sessionId、hostRunId、effectiveConfigSnapshot、state、error、startedAt、endedAt |
| ContextPacket | id、projectId、taskId、version、相关原始消息引用及必要摘录、objective、constraints、authorizationRefs、materialRefs、scope、expectedOutputs、returnTarget |
| Result | id、projectId、taskId、attemptId、reportVersion、summary、artifactRefs、checks、remainingItems、blockedReason、sourceMessageRef |
| Artifact | id、projectId、taskId、ownerRoleId、fileRef、displayName、mediaType、versionOrHash、verification、sourceResultId |
| AuthorizationRef | id、projectId、sourceHumanEvent、scope、planVersion、hostApprovalRef、status |
| Outbox/EventInbox | eventId/idempotencyKey、projectId、相关实体、处理状态、序号/游标、时间戳 |
授权记录只引用真实人类授权或宿主批准;摘要不能凭空制造批准。模型产生的“用户已同意”只是一段待核实文本。
约束:
- (projectId, roleId) 当前绑定唯一;非空 currentSessionId 不得绑定到多个项目或部门。
- task、dispatch、attempt、result、artifact 的 projectId 必须一致,跨项目引用拒绝。
- targetSessionId 在派发时固定并保存 bindingGeneration;换绑不能把旧消息自动送进新会话。
- 主键使用稳定随机 ID;名称/路径作为属性。目录解析后的规范路径用于冲突检查,不作唯一身份。
- 任务与 outbox 在同一事务内持久化;没有事务能力时实现可恢复日志并验证崩溃窗口。
- 配置用 revision/CAS 防止多个标签页互相覆盖,不能单靠浏览器锁。
- 凭据由宿主管理,只存凭据引用;不得把 token 写进上下文、任务账或日志。
### 5.3 页面本地状态
selectedRole、panelWidth、panelCollapsed 等可按“宿主用户/实例 + projectId”保存到本地。草稿还需 roleId 和 session/bindingGeneration;切换项目不能覆盖另一部门草稿。只作为 UI 恢复数据,不能取代持久任务账。宿主已有草稿管理时优先复用,不保存第二份相互竞争的草稿。
## 6. 会话创建、配置与模型切换
1. 项目首次进入时创建项目业务记录和十席配置初值,不自动发模型请求。
2. 首次明确开始聊天或收到授权派工时,按需创建该部门 session。
3. 服务获取 projectId+roleId 创建锁,读取已有绑定;已有可用会话直接使用。
4. 带 creationRequestId 调用经验证的宿主创建能力,保存准确返回 ID 和绑定。超时先查证,不能直接再建。
5. 若创建成功但绑定保存失败,保留恢复记录,按 requestId 查回并补绑定。宿主若无对应查询,显示“创建结果待核实”,要求明确恢复,不扫描最新会话猜归属。
6. 独立会话的角色身份由可信 projectId+roleId 绑定注入,不能依赖 Team membership 或让模型自报角色。
7. session 被删除或不可访问时标记 unavailable,保留旧引用。提供显式新建接续会话,必要摘要与材料经过选择后传入,旧历史不删除。
新项目初始化时把宿主默认配置解析成明确值快照;以后全局默认变化不追改已初始化项目。所有模型选项来自真实目录,不写死预览中的模型或 effort。
保存模型设置只更新该部门 desired configRevision。一次运行在真正开始前固定 effectiveConfigSnapshot;已经开始的运行不变,等待队列尚未开始的运行使用最新合法配置,并记录版本。UI 分别显示“本次运行使用”和“下次运行使用”,不混用。
切模型不清历史、不改角色、技能或权限。新模型不支持旧 effort 时,表单要求选有效值或默认值,不透传非法枚举。目录失效/额度不足时明确失败,不静默回退其他模型。若宿主只能通过换 session 改模型,必须先形成适配设计并解决历史延续,不能偷偷丢弃会话来满足表面切换。
首版技能/权限可以使用明确的角色初值与只读展示,暂不做复杂编辑器;但实际配置和边界必须可核实。不能把首版未做技能编辑解释为允许跨项目共享可变全局预设。
## 7. 上下文交接协议与真实完成条件
### 7.1 内部操作契约
以下是拟实现的业务操作,不是现成工具名:
- dispatchTask:提交目标部门、目标、完成标准、必要材料、授权依据和返回对象。调用上下文确定源项目/源部门。
- reportTaskResult:提交 taskId/attemptId、结论、文件引用、检查、未完成项或阻塞。服务验证调用者与当前执行尝试匹配。
- requestTaskInput:明确缺失信息及影响范围,进入待用户补充,不广播所有部门。
- syncDecision:用户明确同步私聊中的某个决定到指定任务/丞相,仅发送选定内容。
可以通过宿主扩展工具暴露,也可以使用经验证的结构化宿主通道。禁止靠解析任意聊天中的“已完成”三个字更新任务;禁止让浏览器定时读取最后一条消息来假装回执协议。
默认丞相可在用户已授权范围向目标部门派发任务;部门可以提交结果和请求补充。首版不允许执行部门自主递归派发,避免环路。若用户直接要求尚书派工,可通过同一权限校验契约,权限由可信角色规则决定。
### 7.2 上下文包内容
每次交接包含:任务标识与版本、目标及完成标准、相关用户原话的引用和必要摘录、已确认约束、授权来源、允许读写范围、材料版本、需要输出什么、返回给谁。不是复制整段丞相会话。
材料引用必须在目标项目下解析。共享同一项目文件可传宿主可读取的文件引用,不重复上传;宿主附件 ID 需要验证目标 session 可访问。文件找不到/权限失效时阻塞并列出缺失项。不得把另一项目的绝对路径放进消息就视为已授权共享。
上下文预算由目标模型能力和任务决定,预留输出余量;优先保留目标、硬约束、完成标准和必要证据。材料太大时提供索引及可按需读取的引用,显示裁剪情况。若模型窗口信息不可得,使用明确的保守配置,不能虚构 token 精确值。附件、检索正文和文件内容属于材料,不得覆盖系统职责或赋予授权。
### 7.3 结果与回传
报告必须包含结果摘要、成果引用、真实检查及未完成项。代码/文档任务需可编辑源文件;纯分析任务允许没有文件,但应有可追溯结果内容,不强制伪造附件。
“宿主运行正常结束”和“业务任务完成”分开判断:收到可信结构化报告,且其对应宿主运行正常结束、成果引用有效、必要条件满足,才标记 completed。报告先到时保存候选结果等待终态;运行先结束但没有有效报告时标记 needs_attention,提供补报/核实,不显示已完成。自检通过不等于独立审核通过;首版未经过门下审核时应直说未审核。
结果登记和回传通知写入可靠 outbox。向来源会话回传的文本是一条关联原任务的结果消息,仅包含必要摘要和引用。来源会话忙时排队。回传触发汇报可以是新的模型回合,但不得再次触发相同派工;结果消息需有类型和去重键。汇报失败不撤销已完成的执行任务,显示“成果已完成,汇报待处理”。
### 7.4 局部修改
成果入口带 taskId/artifactId/当前版本进入主责会话,等待用户发送具体修改指令,不在点击时自动执行。修改用关联原任务的新修订任务或新 attempt,保留旧结果引用及变更范围;历史记录不能被覆盖成仿佛第一次就产出修订版。写文件前核对当前版本,检测到用户已修改时先合并理解,不用旧快照盲目覆盖。
## 8. 状态机、队列和恢复
### 8.1 分开维护状态
| 对象 | 建议状态 | 关键规则 |
|---|---|---|
| Department | uninitialized / idle / queued / running / unavailable | 表示会话运行情况,不代表任务结论 |
| Task | draft / queued / running / waiting_input / needs_attention / completed / failed / cancelled | 未解决项不得自动完成 |
| Dispatch | prepared / sending / accepted / unknown / rejected | 发出不等于接收;超时可能 unknown |
| Attempt | queued / running / succeeded / failed / cancel_requested / cancelled / unknown | 取消请求不等于已取消 |
draft 校验通过且授权有效后可入队;accepted 等待实际运行开始;收到运行关联后进入 running。waiting_input 仅恢复原任务所需输入,不能顺便扩大范围。failed/取消任务重试创建新 attempt,不覆盖历史。unknown 必须先对账,不能自动当失败重试。
每个 session 同时只有一个活动执行,用户直聊与系统派工经统一协调。若原生聊天绕过插件队列,适配层必须接入宿主原生队列或共享忙碌检查/原子调度;两套各自独立的“串行队列”不能防竞态。运行中补充消息仅在宿主确有 steer 能力时提供,否则明确排队下一轮,不猜测语义。
跨项目队列独立,受共享并发额度约束时公平调度,展示排队原因。A 等待输入不得长期占住可释放的全局执行槽。项目切换、面板收起、浏览器关闭只影响 UI,不发送停止请求。
### 8.2 故障处理要求
| 场景 | 必须行为 |
|---|---|
| 重复点击派工 | 相同幂等键返回同一 dispatch,不能两次执行 |
| 发送超时但可能已接收 | 标记 unknown,按请求/消息 ID 查询,查不清就待核实 |
| 重复完成事件 | 以 eventId/attemptId 去重,只登记一次结果和回传 |
| 乱序事件 | 使用宿主序列或校验当前状态;终态不被迟到 running 覆盖 |
| 页面切到 B,A 返回 | 更新 A 的数据投影,不写 B 的聊天/成果 |
| 配置并发保存 | CAS 冲突后读回,提示并重应用,不静默覆盖 |
| 绑定替换后旧运行结束 | 结果归旧 attempt,不能误标新会话已完成 |
| 点停止 | 指向该 project/task/hostRunId;等待宿主取消回执 |
| 取消和成功竞争 | 以宿主真实终态和事件证据定结果,不丢成功文件 |
| 用户刷新 | 重新读取业务账并订阅/补拉事件,不重新派工 |
| 宿主重启 | 获取调度所有权,查询非终态尝试,补结果/回执,再恢复安全队列 |
| 两个浏览器窗口 | 服务端锁/租约防止重复消费;UI 不是调度主节点 |
| 模型不可用 | 保留任务及错误,配置修复后显式重试 |
| 文件已删除 | 成果标记不可用,保留来源,不显示可打开成功 |
不要承诺外部副作用 exactly-once。宿主若不支持投递幂等,只能做到本地去重与未知状态保守核对;不可判定的窗口应留给明确恢复操作。
## 9. 项目、文件、记忆与授权隔离
所有读写服务校验“调用者可访问项目 + 目标资源属于该项目 + 操作被授权”。伪造 projectId、sessionId、taskId、artifactId、hostRunId 均应拒绝。订阅流、缓存及草稿也必须带项目键,不能使用单个全局 activeSession 变量处理回调。
文件边界需要真实规范化路径,处理 Windows 大小写、相对路径、父目录与 junction/符号链接。不要假设 workspace-write 自动阻止链接逃逸。使用宿主经验证的文件访问策略;若无法保证,明确限制受支持布局并阻止不安全的自动写入。
首版默认独立项目目录。检测到两个项目相同或重叠可写目录、指向同一实际目标的链接时,提示冲突并阻止声称独立的并行写任务;优先要求使用分离目录/独立 worktree。若增加显式串行共享模式,必须明确它不提供完全文件隔离,并按解析后的资源范围加锁。相同项目不同部门也需声明写范围,重叠写任务串行;只读任务可并行。
宿主可能默认注入全局记忆或检索其他工作区。执行者必须核对并限制部门 session 的项目记忆来源;不能只在 ContextBuilder 过滤材料却保留另一条全局自动注入路径。无法隔离的可选记忆功能先关闭并记录限制。用户偏好类全局信息与其他项目业务内容区分,不能借“全局记忆”名义带入项目机密。
外部服务、端口、终端和环境变量不是 session 天然隔离资源。工具工作目录固定在目标项目,运行参数不能跟 UI 当前选择漂移。部署/发布/发消息等操作服从用户明确授权及宿主审批;跨 session 交接不得把普通文字当成宿主批准凭据。原授权覆盖的常规操作持续执行,不为每次派工重复要求用户确认。
## 10. 页面与交互施工规范
视觉依据为[已确认设计](panel-design.md),浅色[概念图](../dsh-image-gen/image-5eef6f14.png)和深色[概念图](../dsh-image-gen/image-ef9e9758.png)仅表达布局与配色。无需再设计一套页面;生成图字体、宽度和虚构模型不是像素规范。
### 10.1 布局
- 左:复用现有项目树及其宽度管理。其缺失时提示安装/接入问题,不悄悄生成替代树。
- 中:紧凑项目/部门标题、真实原生会话和输入框。标题及输入提示明确当前接收部门。
- 右:同一区域“部门 / 任务与成果”页签。默认展示部门树,模型设置在右区展开或受控浮层,避免增加第四列。
- 树使用稳定三列对齐布局:丞相跨三列居中;中书/尚书/门下各一列;尚书下接六部组,六部按吏/户/礼、兵/刑/工两行排列。
- 连线根据布局自适应,六部连接到同一分组,不画成吏部下辖兵部。树结构是职责展示,不是 session 父子关系。
初始尺寸建议作为调试起点:右栏约 400 CSS px,允许约 340–600 px;中央聊天尽量不少于 560 px。最终取宿主现有密度及真实可用区域校准,不按屏幕物理像素直接换算。中央与右栏不足以容纳最小尺寸时切抽屉/折叠,禁止负宽度或缩小全部文字硬塞。右栏上限同时受剩余容器宽度约束。
分隔条支持拖动、键盘方向键、可见焦点及恢复默认;使用合适 separator 语义并说明当前宽度。按项目记宽度/折叠,手机使用独立布局。缩小后仅限制当前渲染值,避免覆盖用户大屏偏好。
### 10.2 方块与模型设置
卡片主体打开会话;模型按钮只打开设置,阻止事件冒泡且有独立焦点。十席都需模型入口。卡片状态来源真实业务投影,没有运行过显示“未开始”,不是“运行中”。模型长名截断可查看全名,provider 不用猜。
保存时显示“仅当前项目的此部门生效”。运行中同时显示当前模型与待生效模型。错误应有具体原因和恢复入口,不静默重置下拉框。模型目录空时禁用保存并解释。
### 10.3 任务与成果
任务列表显示主责部门、状态、更新时间;详情展示目标、交接材料、尝试、失败原因、检查和成果。不要显示无来源完成百分比。成果显示源文件、主责部门、检查状态、打开和局部修改操作。上传入口只属于聊天材料输入。
“同步决定”必须显示接收任务/部门和将同步的内容;普通私聊不会自动广播。系统回传是有来源的任务消息,与用户原话分开标识。
### 10.4 主题、手机和空状态
尽量复用宿主语义颜色令牌。浅色白/浅蓝灰/蓝强调;深色深蓝灰/灰白文字/柔和蓝强调。覆盖输入框、下拉、弹层、连线、滚动条、焦点、禁用、错误、选中。状态不仅依靠颜色。
手机通过现有项目树入口和右侧部门抽屉切换,中央对话优先;模型设置、任务详情可全宽展示。不能把桌面树整体等比缩到难以点击。选择部门后关闭抽屉并回到该部门对话。主题切换和开关抽屉不能重建 session 或清空草稿。
必须覆盖:未选项目、插件缺失、未初始化、创建中、绑定失效、模型不可用、排队、投递未知、等待输入、任务失败、没有成果。错误文字说明发生在哪个项目/部门,不要求用户猜测。
每次改变已确认布局都附新预览供核对;实施阶段优先使用真实宿主截图。沿用现有视觉要求不需要为了交方案重复生成概念图。
## 11. 分阶段执行清单与出口
| 阶段 | 工作 | 交付与进入下一阶段条件 |
|---|---|---|
| P0 基线 | 读当前代码、Git 改动、宿主接口与项目插件 | 能力记录及阻塞表;不把推测记成支持 |
| P1 数据基础 | 项目绑定、十席角色、配置、持久化、归属校验 | 双项目配置隔离、唯一约束、事务恢复测试通过 |
| P2 两席闭环 | 丞相/工部独立 session、结构化交接、运行/结果关联 | 不开 Team 完成真实任务及回传,未知投递不重复 |
| P3 十席接入 | 同一机制扩展其他八席、角色提示与权限核对 | 十席直聊/模型配置真实可用,不自动全员启动 |
| P4 工作台 | 项目树、原生聊天、右侧树、设置、任务成果、调宽主题手机 | 同页可用,布局符合确认图和文字要求 |
| P5 恢复隔离 | 取消、重复/乱序、重启、共享目录、记忆和附件 | 双项目并发及故障矩阵通过 |
| P6 验收交付 | 当前 GUI 实测、构建、文档、版本与已知问题 | 提交证据、测试命令、限制及回退说明 |
UI 静态布局可与 P1–P3 并行,但真实集成依赖已验证接口。自动化任务链留到后续,不借 P3 扩展首版范围。每阶段用小 Git 提交保留可检查差异;提交只包含本任务变更。提交和发布是两件事,不自动推送、发布或重装宿主。
如多人实施:数据/调度、宿主适配、UI、验收可分工;明确文件写范围和契约负责人,接口变动先同步。不要同时修改整个旧客户端再靠最后合并猜结果。
## 12. 验收矩阵
下面每项需要记录实际结果与证据。“已写代码”不等于通过。Mock 测试只能证明插件逻辑,不能证明宿主接入。
| ID | 操作 | 预期 |
|---|---|---|
| A01 | 无普通聊天时打开上朝 | 独立页面可进入,不要求 Team |
| A02 | 从现有树切 A/B,重命名/移动项目 | 使用稳定绑定;名称变化不换 session |
| A03 | 点击分组节点 | 不创建项目或十席会话 |
| A04 | 双击首次启动同部门 | 唯一 session 或明确待核实,不重复创建 |
| A05 | 十席分别发送短消息 | 输入接收方、历史、实际 session 一致 |
| A06 | A 工部改模型,B 工部用另一模型 | 配置与实际请求分别正确,全局默认不变 |
| A07 | 运行中切模型 | 本次保持原模型,下一次使用新配置 |
| A08 | 模型不支持旧 effort/目录失效 | 校验错误可见,无静默替换 |
| A09 | 丞相带文件交接工部 | 材料可读、引用可追溯、不复制无关历史 |
| A10 | 正常完成任务 | 有效报告+运行终态+成果核验后完成,回传一次 |
| A11 | 仅变 idle 或输出“已完成” | 不据此标记业务完成 |
| A12 | 重复投递/重复完成/乱序事件 | 不重复执行、不重复成果、不倒退终态 |
| A13 | 发送已接收但回执超时 | unknown 对账,不自动重发 |
| A14 | 用户直聊与派工同时到达 | 同 session 串行,忙碌行为明确 |
| A15 | A/B 同时运行,停止 A | B 继续;停止准确对应 A run |
| A16 | A 运行时切到 B,A 迟到回调 | A 结果只归 A,不改变 B 当前输入 |
| A17 | 刷新、关闭重开、重启宿主 | 绑定/配置/任务恢复,无重复派工 |
| A18 | 伪造其他项目 session/task/artifact/run ID | 服务侧拒绝并返回可辨错误 |
| A19 | B 尝试检索 A 材料/记忆 | 不自动进入 B 上下文 |
| A20 | 相同目录/父子目录/junction 指同一目标 | 冲突被识别并处理,不宣称完全隔离 |
| A21 | 两窗口同时改设置/消费队列 | CAS 和服务调度防覆盖、防重复 |
| A22 | 主责部门局部修改成果 | 保留来源/版本,仅改要求部分,无全链重跑 |
| A23 | 用户删除 session 或成果文件 | 显示失效,保留历史与明确恢复入口 |
| A24 | 2560×1440 浅/深色、拖动右栏 | 聊天优先、丞相居中、三省/六部连线正确 |
| A25 | 缩窄及约 390 CSS px 手机宽度 | 抽屉可用,无横向挤压,模型和任务可操作 |
| A26 | 切主题/项目/部门并恢复 | 草稿、绑定和配置保留,各归所属 |
| A27 | 键盘选卡片、模型按钮、分隔条、弹层 | 焦点明确、行为独立、关闭后焦点合理恢复 |
| A28 | 原生聊天审批、附件、流式回复 | 在工作台同页可用,不因嵌入绕过审批 |
测试层级:纯逻辑测状态转换/归属/幂等/上下文过滤;服务集成测事务/队列/恢复和宿主适配契约;真实宿主测 UI、实际模型、双项目、附件及权限。已有测试中有效的通用行为保留,侧栏专属与 Team 前提断言按新设计重写,不为绿色结果删除全部旧测试。
日志仅记录必要的 projectId/roleId/taskId/attemptId/dispatchId/sessionId/hostRunId、事件类型、耗时及错误码;错误中避免完整私聊、材料正文或凭据。每个失败应能从任务详情定位到关联记录。
## 13. 构建、安装与最终交付
执行者需先核实实际宿主加载的是哪个包/构建产物。当前 GUI 是 DSH 提供的页面;启动另一台开发服务器不能证明当前 GUI 已更新。若涉及客户端插件 HMR,只有同一实现 checkout 的相关 watcher 正在构建时才能承诺自动更新;其他修改按真实构建方式构建、刷新并验证。
不要修改源文件后直接报告“页面已更新”。交付说明列出宿主版本、插件版本、实际 URL、构建命令、产物路径、刷新/重启要求,以及在当前页面取得的截图。宿主扩展未安装时,明确哪些能力仍未验证。
软件包版本与新架构里程碑分开处理:先核对根包、面板包、策略常量及安装记录的现有差异,使用适合现有发布链的下一版本;未经决定不要把 0.9.2 降级到 0.1.0。文档可继续叫“新架构 v0.1”。
执行者最终提交:
1. 源码与明确 Git 提交/差异,列清保留的原有未提交改动。
2. 宿主能力记录:已验证接口、需要的宿主/插件扩展和版本。
3. 数据结构/迁移说明、内部契约、角色和权限配置说明。
4. 测试命令、结果、A01–A28 验收记录;未通过项不得写完成。
5. 真实浅色、深色、调宽、手机和双项目运行证据。
6. 用户使用说明:首次开始、切部门、改模型、派工、成果修改、未知状态恢复。
7. 已知限制与回退方法。Git 回退代码不自动回退业务数据;采用兼容 schema 或显式迁移策略,回退不删除 DSH 历史会话。
## 14. 可直接交给执行者的任务说明
> 请按本方案实现三省六部独立工作台新架构 v0.1。先检查 Git 现有改动及真实 DSH/项目树接口,输出能力证据,再按 P0–P6 推进。最终十席均须具有独立会话与项目内模型配置;先以丞相和工部验证真实交接闭环。左侧复用 better-workspace-group,中间嵌入真实会话,右侧做已确认部门树、模型设置、任务与工作成果;支持调宽、白蓝浅色和宿主深色、手机抽屉。项目 A/B 必须可同时运行且配置、上下文、任务、结果和取消严格隔离。程序负责可靠投递、回执、结构化结果和重启恢复,不用 Team 父子关系重建旧方案,不另建聊天数据库,不猜宿主 API。复杂自动审批/DAG 留到后续。接口缺失先提交最小适配证据和明确阻塞,不用假数据冒充集成完成。保护已有改动,使用 Git,不建备份副本。按照验收矩阵提供真实证据,未验证内容如实标注;涉及额外仓库写入、安装或发布时遵守对应授权边界。

View File

@ -1,679 +0,0 @@
# v0.1 宿主能力核实记录(P0 交付物)
> 本文是《[v0.1 实施方案](v0.1-实施方案.md)》§3「能力核实」的实做记录。原则:**只写读过的代码**,没有代码依据的一律标「未核实」,并写明是「需要动态验证」还是「代码里没有」。
>
> 阅读本文前请先知道一件事:**本轮核实只做到「类型层」**。没有任何一条结论来自在真实 DSH 里跑一遍(见 §0.3)。
---
## 0. 核实环境与方法
### 0.1 版本
| 项 | 值 |
| --- | --- |
| DSH 宿主包版本 | **0.2.0-rc.1**(`node_modules/@deepseek-ai/*` 全员 0.2.0-rc.1) |
| 类型定义来源 | `C:\Users\qyh15\Documents\dsh-workspaces-goups-new\dsh-workspace-groups\node_modules\@deepseek-ai\` |
| 本插件版本 | `dsh-sansheng-liubu-mode` **0.9.2**(`package.json`),面板子包 `dsh-sansheng-liubu-panel` 0.9.2 |
| 旧客户端参考 | [panel/lib/client.js](../panel/lib/client.js)(2107 行,仓库内唯一在真实宿主里跑过的客户端代码) |
| 宿主 Web GUI | `http://127.0.0.1:8457` |
| 系统 | Windows |
### 0.2 方法
1. 通读 `docs/v0.1-实施方案.md` 全文,抽出 §3 要求核实的 12 项与 §4/§6/§8 的接口需求。
2. 逐包读 `.d.ts`(签名)与 `lib/types/commands.js`、`agent.js` 等实现文件(语义),记录**文件路径 + 行号**。
3. 对照旧插件已跑通的调用点,标注哪些是「运行时已跑过」。
4. 读不到的包(如 `@deepseek-ai/dsh-client-ui-layout`)明确写「未核实」,不做推测性补全。
### 0.3 验证档位的定义(本文全篇使用)
| 档位 | 含义 |
| --- | --- |
| **类型层已核实** | 有 `.d.ts` 或实现源码为据,签名与语义可引用行号。(**允许据此写代码**) |
| **运行时已跑过** | 旧插件在真实宿主里实际调用过并通过(有代码调用点为据;本轮多数只能间接证明)。 |
| **未验证** | 分两种:**需动态验证**(类型存在,但行为/边界要靠实测确认);**代码里没有**(读遍本机宿主包找不到该能力)。 |
### 0.4 本轮**没有**做的事(重要)
- **没有**在真实宿主里做 P0 最小验证(§3 要求的「最小验证」全部待做)。
- **没有**运行任何 Host 侧 RPC,也没有在浏览器里打开插槽快照。
- 旧插件的 `panel/test/client.test.js` 本轮用仓库自带 node 跑过一遍:44 项全过(`node --test --test-isolation=none panel/test/client.test.js`)——但这是**对 mock 上下文**的单测,**不构成宿主兼容性证据**。
- 结论:**当前所有能力最多只能给到「类型层已核实」**。§12 验收矩阵里的真实宿主证据仍需按 §0.5 的核对清单去取。
### 0.5 拿到「运行时已跑过」的最小动作(P0 收尾 TODO)
| 目标 | 具体动作 |
| --- | --- |
| 槽归属 | 浏览器控制台执行 `ctx.slots.snapshot()`(`SlotRegistry.snapshot`,registry.d.ts:180),导出 `main` / `main.conversation` / `sidebar.workspaces` 三个节点的 `occupants`(谁注册、priority) |
| 会话创建幂等 | 对同一 `sessionId` 连调两次 `sessionController.create({sessionId, cwd})`,第二次应返回同一 id 且不新建;再换 cwd 调一次,应抛 `session/conflict` |
| prompt 幂等 | 同一 `requestId` 连发两次,第二次应立即 `{accepted:true}` 且日志里只有一条 `user/message` |
| cancel 真语义 | 发一条长任务 → `cancel()` → 观察 `running` 何时变 false、inbox 里排队的消息是否仍在 |
| 归档拒绝 | 会话 running 时 `archiveSession` 应抛 `workspace/session-active` |
| 断线重连 | 拔网/重启宿主,观察客户端 follow 流是否自愈、`sessionListMetadata` 是否重建 |
---
## 1. 速查总表
| # | 能力 | 档位 | 一句话结论 |
| --- | --- | --- | --- |
| 1 | 会话创建(显式 sessionId 幂等 adopt) | 类型层已核实 | 只有显式给 `sessionId` 才有幂等语义;cwd/preset 冲突抛错,不会静默合并 |
| 2 | 投递 prompt(requestId / queue / steer) | 类型层已核实 | `requestId` 幂等真实存在;`mode` 语义明确;客户端 `prompt()` 默认不带 requestId,必须自己传 |
| 3 | 取消 | 类型层已核实 | 同步返回、只对 attached agent 有效、保留 inbox;`accepted:true` ≠ 已取消 |
| 4 | 模型目录与选择 | 类型层已核实 | `modelCatalog` 有;`selectModel` **会连带改全局默认**,必须插件侧覆写 |
| 5 | 会话列表与投影 | 类型层已核实 | list 不用 resume agent;投影键名固定三个 |
| 6 | follow 事件流 | 类型层已核实 | 快照 + 无缺口事件帧;断线重连由客户端 session 层负责(细节未验证) |
| 7 | Workspace 列表与视图 | 类型层已核实 | `WorkspaceView` 有 canonical path + sessionIds;host id 不复用 |
| 8 | 项目树槽位归属 | 类型层已核实(归属)/ 未验证(实际占位) | `sidebar.workspaces` 是 single/root,由 ui-workspace 声明、workspace-groups 插件以 priority -1 shadow |
| 9 | 中央主区槽位归属 | **未核实** | `main` 槽的 SlotMap 声明在 `dsh-client-ui-layout`,本机没有该包 |
| 10 | `'conversation.content'` 工厂可复用性 | 类型层已核实 | 是 SlotFactory,可被再次实例化;但嵌套实例的 scope/绑定行为未验证 |
| 11 | slot register / registerFactory / renderFactorySlot | 类型层已核实(语义)/ 未验证(冲突抛错实测) | priority 最低者胜;同 cell 同 priority 注册**抛错**;`root` 槽禁止注册 |
| 12 | 插件 client 注入声明 | 类型层已核实 | 两种 inject 并存且含义不同:`package.json dsh.client.inject` 填包名,`exports.inject` 填服务短名 |
---
## 2. 会话与投递能力
### 2.1 会话创建(含显式 sessionId 幂等 adopt)
**签名(Host 侧)**
```ts
// node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/index.d.ts:93
create(request: SessionCreateRequest): Promise<SessionCreateValue>;
```
```ts
// lib/types/types.d.ts:279-289
interface SessionCreateRequest {
workspaceId?: WorkspaceId;
cwd?: string;
sessionId?: SessionId;
agentPreset?: string;
}
interface SessionCreateValue {
sessionId: SessionId;
agentPreset?: string;
}
```
**实现语义**(`lib/types/commands.js`)
| 行为 | 证据 |
| --- | --- |
| `workspaceId` 与 `cwd` 同时给 → 抛 `gateway/bad-request`("session.create accepts workspaceId or cwd, not both") | commands.js:107-110 |
| 未给 `sessionId` 时由宿主随机生成:`request.sessionId ?? brandString(\`session-${randomUUID()}\`)` | commands.js:111 |
| 给 `workspaceId` 但查不到 → 抛 `workspace/not-found` | commands.js:113-120 |
| 解析 cwd:`workspace?.path ?? request.cwd ?? defaultCwd`,并在调用前 `mkdir(cwd, {recursive:true})` | commands.js:121-124;agent.js:475 |
| **只有显式传了 `sessionId` 才做 adopt 校验**:`ensureSession(sessionId, cwd, request.sessionId !== undefined, agentPreset)` | commands.js:124 |
| adopt 校验:cwd 不同 → `ApiSessionCwdConflict` → `session/conflict`;preset 不同 → `ApiSessionPresetConflict` → `agent-preset/conflict` | agent.js:470-474 |
| adopt 命中(同 cwd 同 preset)→ 直接返回同一个 sessionId,不新建 | agent.js:454-512 |
| session 建成后 `workspace.attachSession(sessionId)`,失败抛 `session/workspace-attach-failed`——**此时 session 已创建**,调用方必须能对账 | commands.js:129-136 |
| JSDoc 原文:"Create or idempotently adopt one ordinary Session" | index.d.ts:88-93 |
**我们的用法**:`ProjectService` 用 `projectId + roleId` 生成或查出稳定 `sessionId`(形如 `session-sansheng-<projectHash>-<roleId>`),带 `cwd = workspace.path` 与 `agentPreset` 调 `create`。同一请求重放是安全的(幂等 adopt);cwd/preset 不一致时报错,由 Reconciler 处理而不是自动重建。
**档位**:**类型层已核实**。幂等仅来自「显式 sessionId + cwd/preset 一致」,`creationRequestId` **不参与** create 的幂等(`SessionCreateRequest` 里没有这个字段,types.d.ts:279-284)。
**未验证**:真实宿主上第二次同参 create 是否真的返回同 id(需动态验证)。
**客户端等价物**(`ctx.sessions`,浏览器侧)
```ts
// lib/types/client/contract/sessions.d.ts:80-84
create(opts?: { workspaceId?: WorkspaceId; cwd?: string; sessionId?: SessionId }): Promise<SessionId>;
```
```ts
// lib/types/client/contract/sessions.d.ts:54-63
class SessionCreateError extends Error {
rpcError: RemoteFailure;
requestedSessionId?: SessionId;
name = 'SessionCreateError';
}
```
`requestedSessionId` 让「创建失败但宿主可能已经建了」变成可对账状态——这正是实施方案 §6.5 要的「按 requestId 查回」的现有替代物。**档位:类型层已核实;未验证(需动态验证宿主是否真的回填该字段)**。
---
### 2.2 投递 prompt(requestId、mode queue/steer)
**签名(Host 侧)**
```ts
// lib/types/index.d.ts:163
prompt(request: SessionPromptRequest, signal: AbortSignal): Promise<SessionPromptValue>;
```
```ts
// lib/types/types.d.ts:319-331
interface SessionPromptRequest {
requestId: SessionRequestId;
sessionId: SessionId;
mode: 'queue' | 'steer';
content: readonly PromptContentPart[];
clientTimeZone?: string;
}
type PromptContentPart =
| { type: 'text'; text: string }
| { type: 'image'; mediaType: string; data: string; name?: string }
| { type: 'file'; receiptId: string };
interface SessionPromptValue { accepted: true }
// :78-89, :329-331
```
**requestId 幂等是真的**(`lib/types/commands.js:290-352`):
- `if (hasPromptRequest(agent, request.requestId)) return { accepted: true }`(:301-302)——**重复投递直接吞掉,不报错**。
- `hasPromptRequest` 扫 `inbox.nextTurn` / `inbox.nextStep`,以及 `session.snapshotEvents()` 里 `user/message` 的 `source.rpcId`(:547-561)。这意味着**跨重启也幂等**(历史事件里留了 rpcId)。
- 空内容 → `gateway/bad-request`;`clientTimeZone` 非法 → `session/invalid-time-zone`。
- `mode === 'steer'` 走 `agent.steer(message)`,否则 `agent.followup(message)`(:327-330)。
- 其它异常统一折叠为 `session/agent-busy { reason }`(:347)——**错误码粒度很粗,不能靠它区分具体原因**。
**客户端签名(浏览器侧)**
```ts
// lib/types/client/contract/session.d.ts:82-84
prompt(content: PromptContentPart[], mode: 'queue' | 'steer', signal?: AbortSignal, requestId?: SessionRequestId)
: Promise<RemoteResult<{ accepted: true }>>;
```
注意 **`requestId` 是第 4 个可选参数**——旧插件 `panel/lib/client.js:1148-1165` 的 `deliverPrompt` 只传了前两个参数,**没有 requestId**,所以旧插件路径不具备幂等性。v0.1 必须显式传。
**`RemoteResult` 的形状**(`@deepseek-ai/dsh-typert-protocol/lib/types/types.d.ts:67-73`):
```ts
type RemoteResult<T> = { ok: true; value: T } | { ok: false; error: RemoteFailure };
```
**我们的用法**:`DispatchService` 每条派工生成一个 `requestId`(与 `dispatchId` 一一对应并落库),投递失败重试用同一个 `requestId`。`mode` 首版固定 `'queue'`;`'steer'` 只在确认宿主行为后启用。
**档位**:**类型层已核实**(Host 幂等)/**运行时已跑过**(旧插件确实用 `binding.session.prompt([...], "queue")` 成功投递,未带 requestId)。
**未验证**:客户端第 4 参数 `requestId` 是否被正确透传到 Host(需动态验证)。
**客户端补充**:`beginSubmission(input): SubmissionHandle`(session.d.ts:73)返回 `{ requestId, abandon() }`,是官方的「先登记 echo 再发」路径;`SubmissionHandle.requestId` 的类型注释明确「pass it to prompt」。
---
### 2.3 取消
```ts
// lib/types/index.d.ts:181 (注意:同步返回,不是 Promise)
cancel(request: SessionCancelRequest): SessionCancelValue;
// lib/types/types.d.ts:353-359
interface SessionCancelRequest { sessionId: SessionId }
interface SessionCancelValue { accepted: true }
```
实现(`lib/types/commands.js:468-478`):
- **只对已 attach 的 live agent 生效**,否则抛 `session/not-found`("session ... not found (not attached)")。
- 调用 `agent.cancel({ kind: 'user' }, { keepInbox: true })`——**保留 inbox**,排队消息不会被清掉。
- JSDoc(index.d.ts:177-181):"Cancel one active Agent turn **without dropping its pending inbox** ... acknowledgement that cancellation was **requested**"。
客户端等价物:`ISession.cancel(): Promise<RemoteResult<{accepted:true}>>`(session.d.ts:108-110)。JSDoc 补一句关键语义:**"Pending queued work remains and resumes in FIFO order after the Host reaches cancellation quiescence"**——即取消后排队任务会**继续跑**。
**我们的用法**:`Attempt` 状态机保留 `cancel_requested` 与 `cancelled` 两个态(正好对应实施方案 §8);`cancel()` 返回只推进到 `cancel_requested`,终态必须靠 `follow` 事件或 `running` 投影落到 false 才能确认。
**档位**:**类型层已核实**。**未验证**:真实宿主上从 `cancel()` 到 `running=false` 的时延与事件序列(需动态验证)。
---
## 3. 模型能力
### 3.1 模型目录
```ts
// lib/types/index.d.ts:109
modelCatalog(): Promise<ModelCatalog>;
// lib/types/types.d.ts:141-147
interface ModelCatalog {
default: ModelSelection;
routableProviders: readonly string[];
groups: readonly ModelProviderGroup[];
failures: readonly ModelCatalogFailure[];
}
interface ModelCatalogModel { // :110-127
id: string; name: string; description?: string;
reasoning?: { efforts: readonly { id: string; name: string; description?: string }[]; defaultEffort?: string };
}
interface ModelProviderGroup { id: string; name: string; models: readonly ModelCatalogModel[] } // :129-133
interface ModelCatalogFailure { id: string; name: string; message: string } // :135-139
```
**要点**:
- `reasoning.efforts` 是**每个模型自己的枚举**,`defaultEffort` 可能不存在 → 实施方案 §6「不支持旧 effort 不透传非法枚举」有直接依据。
- `failures` 是**隔离的 provider 失败**,不是整体失败——UI 应当「部分可用」而不是一有 failure 就整页报错。
- Host JSDoc:"Describe every currently routable model"(index.d.ts:105-109)。
- **客户端侧没有 `modelCatalog`**:`ISessions` / `ISession`(client/contract/*.d.ts)里搜不到该名字。旧插件只能走 `ctx.modelDirectories`(一个非本仓库的第三方服务)或 `ctx.remote.session.selectModel`。→ **v0.1 的模型目录必须从 Host 侧取**。
**档位**:**类型层已核实**(Host 签名与形状)。**未验证**:真实宿主返回的 efforts 枚举内容(需动态验证)。
### 3.2 模型选择
```ts
// lib/types/index.d.ts:99
selectModel(request: SessionSelectModelRequest): Promise<SessionSelectModelValue>;
// lib/types/types.d.ts:91-95, :291-297
interface ModelSelection { provider: string; model: string; reasoningEffort?: string }
interface SessionSelectModelRequest extends ModelSelection { sessionId: SessionId }
interface SessionSelectModelValue { selected: ModelSelection }
```
实现(`lib/types/commands.js:145-175`):
1. 先 `resolveAgent`(**会 resume 会话**);
2. 模型不在目录里 → 抛 `session/model-unavailable { provider, model }`;
3. `llm.resolveCallConfig` 归一化(这让返回的 `selected` 可能与请求不同,例如补默认 effort);
4. `agents.selectForNextRequest(selected)`;
5. **后台** `agentDefaultModel.saveSelection(selected)` —— **会把这个选择写成全局默认**,失败只 warn。
JSDoc(index.d.ts:94-99):"Select one Session-local model after explicitly resuming the Session; **save the default in the background**"。
> **这是 v0.1 最容易踩的坑**:`selectModel` 不是「只改这个会话」,它顺带改全局默认。所以「本项目本部门固定模型」必须由插件在**每次派发前**显式 `selectModel` 覆写,并自己持久化 desired 配置;不能指望宿主记住。
相关投影:
```ts
// lib/types/types.d.ts:104-109
interface ModelSelectionProjection { lastUsed: ModelSelection | null; next: ModelSelection | null }
```
投影键名固定三个(`lib/types/types.d.ts:11-27`):`sessionListMetadata`、`imageLimits`、`modelSelection`。这正是实施方案 §6「UI 分别显示『本次运行使用』和『下次运行使用』」的现成数据源(`lastUsed` / `next`)。
**档位**:**类型层已核实**。
**运行时已跑过(间接)**:旧插件 `panel/lib/client.js:1534-1560` 走 `remote.session.selectModel({sessionId, provider, model, reasoningEffort?})` 返回 `{ok, error:{code,message}}`,说明该 RPC 在真实宿主里存在且可调。
---
## 4. 会话列表、投影与事件流
### 4.1 列表
```ts
// lib/types/index.d.ts:80
list(_request: SessionListRequest, signal: AbortSignal): Promise<SessionListValue>;
// lib/types/types.d.ts:159-170
interface SessionSummary {
agentAvailable: boolean; sessionId: SessionId; updatedAt: number; running: boolean; blank: boolean;
parentSessionId?: SessionId; origin?: 'subagent'; cwd?: string; projections?: SessionProjectionHints;
}
```
- Host JSDoc:**"without resuming an Agent ... ordered by activity"**(index.d.ts:75-80)——列会话不会把 agent 拉起来,可放心高频调用。
- `SessionProjectionHints { kind: 'cached'|'sequenced'; asOfSeq; values }`(:51-64):**行内投影是可能过期的 partial 视图**,不能当权威值。
客户端:`SessionListState { ids; byId; phase; projectionsBySession }`(client/service.d.ts:43-52),旧插件就是读 `sessions.list.getSnapshot()` 的 `{ids, byId}`(client.js:635-760、1813)。
**档位**:**类型层已核实**+**运行时已跑过**(旧插件读列表快照驱动面板)。
### 4.2 投影
```ts
// lib/types/index.d.ts:203
projections(request: SessionProjectionsRequest, signal: AbortSignal): Promise<SessionProjectionsValue>;
```
JSDoc:"Read all registered projections **without activating an Agent** ... **null when the Session does not exist**"(index.d.ts:198-203)。
客户端:`ISessions.refreshProjections(sessionId): Promise<void>`(sessions.d.ts:92 附近)与 `ISession.projections.faceOf(key): ObservableSnapshot<unknown>`(session.d.ts:55)。
> `faceOf(key: string)` 的参数是**裸 string**,不是联合类型——拼错键名不会有编译错误,只会拿到 `undefined` 快照。v0.1 应把这几个键名收敛成常量。
**档位**:**类型层已核实**。**未验证**:真实宿主上 cold session 的 projections 是否真返回 null vs 空对象(需动态验证)。
### 4.3 follow 事件流
```ts
// lib/types/index.d.ts:196
follow(request: SessionFollowRequest, signal: AbortSignal): AsyncIterable<SessionFollowFrame>;
// lib/types/types.d.ts:459-463, :516-527
interface SessionFollowRequest extends Pick<SessionPageRequest, 'maxMessages' | 'turnWindow'> {
address: SessionAddress; assistantStream?: true;
}
type SessionFollowFrame =
| { type: 'snapshot'; header: SessionWireHeader; cursor: number; records; hasMore: boolean;
projections: SessionProjectionBaseline; assistantStream?: ... }
| { type: 'event'; event: SessionWireEvent }
| { type: 'assistant-stream'; frame: ... };
```
Host JSDoc(index.d.ts:190-196):"complete opening snapshot followed by **gap-free durable event frames** and optional cursorless assistant-stream frames"。
- 首帧必然是 `snapshot`(带 `cursor` 与 `projections` 基线),后续是 `event`;**assistant-stream 帧是无游标的**(不可作为状态依据)。
- `SessionAddress` 支持子会话:`{kind:'subagent'; parentSessionId; childSessionId; mode:'one-shot'|'continuable'|'unknown'}`(:386-394)。v0.1 十席走**普通会话**(`{kind:'session'}`),不用 subagent 地址,这是与旧方案的关键区别。
**断线重连**(未验证的主要部分):客户端 session 层是"reconnecting"设计——
- `lib/types/client/index.d.ts:35`:"Install Client Session state and its **reconnecting** control stream";
- `sessions/manager.d.ts:258-263` `handleConnected()`:"Repair one re-established Host-event generation with queryable baselines ... Opened Session follow streams resume independently through API Gateway";
- `transport.d.ts` 有 `carrierFailed?: (error: RemoteStreamCarrierError) => void` 钩子(可重试断流)与 `failed`(终态失败)。
**档位**:**类型层已核实**(帧结构与"gap-free"承诺)。
**未验证**:断线后事件是否真的零丢失、重连窗口多长、`cursor` 从哪一层续(**需动态验证**——这是 P0 必测项之一,直接决定 `Reconciler` 要不要做全量对账)。
---
## 5. Workspace 能力
```ts
// node_modules/@deepseek-ai/dsh-api-workspace-controller/lib/types/types.d.ts:13-25
interface WorkspaceView {
workspaceId: WorkspaceId;
path: string; // canonical
title: string;
sessionIds: readonly SessionId[];
createdAt: string;
updatedAt: string;
}
// lib/types/client/model.d.ts:9-18
interface WorkspaceSnapshot {
items: readonly WorkspaceView[];
archivedSessionIds: ...; pinnedSessionIds: ...;
state: 'idle' | 'loading' | 'error';
phase: 'pending' | 'ready';
error: RemoteFailure | null;
}
```
Host 方法(`lib/types/index.d.ts`):`create(request)` :42("Create or **idempotently resolve** one Workspace over an existing directory")、`initializeDefault(signal)` :51、`rename` :57、`delete` :63("Remove one Workspace **registration** while retaining files and Sessions")、`insertBefore` :69、`insertSessionBefore` :75、`archiveSession(request)` :81、`unarchiveSession` :87、`pinSession` :93、`unpinSession` :99、`follow(signal)` :105。
客户端:`ctx.workspaces: IWorkspaces`(`lib/types/client/index.d.ts:16-20`),`list: WorkspaceSource`(`getSnapshot()` / `subscribe()`),`archiveSession(sessionId, options?: { stopActivity?: boolean })`(client/service.d.ts:80-82)。
**关键限制**:
| 限制 | 证据 |
| --- | --- |
| **有运行中工作时拒绝归档**,抛 `workspace/session-active { sessionId, activity }`,除非 `stopActivity: true` | types.d.ts:36-44;commands.js:120-127 |
| 归档**不能当 stop 用**:`stopActivity: true` 才会顺带停 | 同上 |
| workspace id **永不复用**(延迟数据不会复活已删行) | client/model.d.ts:55 |
| `delete` 只删注册,**不删文件、不删会话** | index.d.ts:63 |
**我们的用法**:`WorkspaceAdapter` 只做「读 → 投影」,**不让插件去创建/删除 workspace**(那是 workspace-groups 插件的领地,见 §6.1)。项目 `projectId` 由插件生成并绑定 `hostWorkspaceId`;宿主 workspace 的 `path` 作 canonical 键,**绝不用目录名/树行号/显示名做主键**(实施方案 §3 要求)。
**档位**:**类型层已核实**。**未验证**:归档被拒时 `activity` 数组的具体内容(需动态验证)。
---
## 6. 槽位(Slot)能力
### 6.1 项目树槽位归属:`sidebar.workspaces`
```ts
// node_modules/@deepseek-ai/dsh-client-ui-sidebar/lib/types/client/contract/slots.d.ts:57-61
'sidebar.workspaces': { kind: 'single'; scope: 'root'; owner: SidebarSectionOwnerProps };
// :54-55 JSDoc: "Declared by this package's 'sidebar' entry (declaring is claiming);
// ui-workspace registers the browser."
```
- 该槽是 **single / root**,`owner` 为 `SidebarSectionOwnerProps { wide: boolean; expandSidebar: () => void }`(:113-118)。
- ui-sidebar 声明它(声明即占用),ui-workspace 往里注册 `WorkspaceBrowser`(整个浏览区域,见 ui-workspace `contract/slots.d.ts` 头部注释 1-40 行)。
- **workspace-groups 插件(better 工作组)以 `priority: -1` shadow 官方浏览器**——旧仓库文档 `DEVELOPMENT.md`(dsh-workspace-groups)第 17 行原文:"客户端入口:向 `sidebar.workspaces` 槽注册(priority -1,shadow 官方浏览器)"。
**结论**:v0.1 左栏**不需要、也不应该**再往 `sidebar.workspaces` 注册;直接复用 workspace-groups 已占据的那棵树。若将来要改树的行内容,正确入口是它声明的子槽(`sidebar.workspaces.session.menu.item`、`sidebar.workspaces.session.row.action`、`sidebar.session.row.leading/hover`,见 ui-workspace `contract/slots.d.ts:122-191`),这些是 **list** 槽,additive、按 `order` 插队。
**档位**:归属 = **类型层已核实**;「priority -1 真的胜出」= **运行时已跑过**(workspace-groups 是在跑的插件,其 DEVELOPMENT.md 明示该策略)但**本机未实测**其 occupancy。
**未核实**:workspace-groups 当前版本的 priority 是否仍为 -1(该仓库 0.1.2 后可能改过)——需看它 `src/client/index.ts` 或 `ctx.slots.snapshot()`。
### 6.2 中央主区槽位归属:`main` / `main.conversation`
**`main.conversation`**(已核实):
```ts
// node_modules/@deepseek-ai/dsh-client-ui-conversation/lib/types/client/contract/slots.d.ts:122-125
'main.conversation': { kind: 'single'; scope: 'session-maybe' };
// JSDoc: "Conversation shell beneath its root-scoped main-panel entry"
```
**`main`**(**未核实**):
- 该槽的 `SlotMap` 声明来自 `MainPanelId`(`@deepseek-ai/dsh-client-ui-layout/client`,被 ui-sidebar 在 `contract/slots.d.ts:14` 引用)。
- **本机没有 `@deepseek-ai/dsh-client-ui-layout` 包**(两份 `node_modules` 与全盘 `find` 均未命中)→ **无法读到 `main` 的 SlotMap 声明、kind、owner 类型**。
- 间接证据:`SidebarPanelMetadata { id: MainPanelId; order: number; label: string }`,JSDoc "List id and **matching main panel key**"(ui-sidebar slots.d.ts:101-108)→ `sidebar.panellist` 的 list `id` 就是 `main` 槽的 keyed `key`。旧插件正是这样用的(`panel/lib/client.js:2023-2027`,`key: PANEL_ID`)。
- 旧插件还依赖一个**未在类型里出现**的 `layout` 服务:`ctx.get("layout")` 回退 `ctx.layout`,再调 `selectPanel(panelId | null)`(client.js:1100-1108、1411-1415)。**这是运行时探测出来的**,没有 `.d.ts` 依据,v0.1 不应把它当公共 API。
**档位**:`main.conversation` = **类型层已核实**;`main` = **未核实(代码里没有:本机缺包)**。
**未验证**:`main` 是否 keyed、key 空间是否等于 MainPanelId、`selectPanel(null)` 回默认面板的行为(**需动态验证**)。
### 6.3 `'conversation.content'` 工厂可复用性
```ts
// ui-conversation contract/slots.d.ts:282-326
declare module '...ui-slots' {
interface SlotFactoryMap {
'conversation.content': {
scope: 'session-maybe';
props: ConversationContentInputProps;
children: {
'conversation.session': { kind: 'single'; scope: 'session' };
'conversation.composer': { kind: 'chain'; scope: 'session' };
'conversation.composer.bar': { kind: 'single'; scope: 'session-maybe' };
'conversation.input.dock': { kind: 'list'; scope: 'session' };
'conversation.hero.brand.mark': { kind: 'single'; scope: 'root' };
'conversation.hero.workspace': { kind: 'single'; scope: 'root' };
'conversation.hero.agentPreset': { kind: 'single'; scope: 'session-maybe' };
};
inject: ConversationInjected;
locale: 'conversation';
slots: { views: { scope: 'session' }; widthControls: { scope: 'root'; props: ... } };
};
}
}
// :509-513
interface ConversationContentInputProps { variant: 'main' | 'embedded'; phase: 'settling' | 'hero' | 'active'; hero: boolean }
```
JSDoc(:281):"**Reusable Conversation content instantiated by presentation hosts**"。
**含义**:这是 **SlotFactory**(不是普通 slot)——`registerFactory` 注册的是**定义**,`renderFactorySlot(name, props, options)` 实例化**occurrence**,每次 occurrence 独立(`store` 若为 factory 则每 occurrence 一份,见 ui-slots index.d.ts:505 附近注释)。
**可复用性结论**:
- ✅ **能**:任何拿到 `renderFactorySlot` 的组件都可以 `props.renderFactorySlot('conversation.content', { variant: 'embedded', phase: 'active', hero: false }, { fallback })` 渲染一份"真·原生对话"。
- ⚠️ **但**:`scope: 'session-maybe'` 说明它需要会话上下文。**在哪个 scope 下实例化、是否会自动获得 `SessionProvider`、与本项目 `sessionId` 如何对齐——本机类型只能证明这套 API 存在,不能证明"在右栏里嵌一个别的项目的会话"能工作**。→ **未验证(需动态验证)**。
- 实施方案 §4/§7 要求的「中间显示所选部门的真实会话」最稳的走法仍是:**让真会话占据 `main.conversation`**(宿主本来就这么渲染),插件只做「切换哪个 sessionId 被选中」,而不是自己再造一个 conversation。
**档位**:**类型层已核实**(声明完整可引用);**未验证**(嵌到非主区位置的可行性)。
### 6.4 slot register / registerFactory / renderFactorySlot 语义
```ts
// node_modules/@deepseek-ai/dsh-client-ui-slots/lib/types/index.d.ts
type SlotKind = 'single' | 'list' | 'keyed' | 'chain'; // :83
type SlotScope = 'root' | 'session-maybe' | 'session'; // :85
type SlotComponent<P> = (props: P) => ReactNode; // :343
```
**`register`**(两个重载,`SlotCore.register` @ :789-804;`SlotRegistry.register` 复用同一签名 @ registry.d.ts:85):
| 语义 | 证据 |
| --- | --- |
| 返回**幂等 disposer**;disposer 会**递归折叠**它声明的子槽 | :777-788 |
| 注册未声明的 slot → 抛错 | :789-804 及 load-time 校验段 |
| 同一 declarer 重复声明同一 child key → 抛错 | 同上 |
| 同一 store handle 跨不同 scope 挂载 → 抛错 | 同上 |
| keyed 缺 `key` / list 缺 `id` / chain 缺 `select` → 各自抛错 | 同上 |
| **shadowing**:同 cell(single=整槽、keyed=同 key、list=同 id)按 `priority` **升序**共存,最低者渲染;ties 保留注册顺序 | :769-776 |
| **在已占用 cell 的同 priority 再注册 → 抛错并点名 occupant** | :769-776;`KindOptions` 注释复述 "same key/id/cell + same priority throws" @ :560-584 |
| 声明了 `children` 就必须消费 `renderSlot`(或仅 chain 时 `renderSlotChain`),否则**编译期**报 `'children declared but the component consumes no renderSlot'` | `RendersCheck` :591-596 |
**`registerFactory`**:
```ts
// ui-slots index.d.ts:532-534
interface RegisterFactory {
<F>(options: RegisterFactoryOptions<F>, component: SlotComponent<FactoryComponentPropsOf<F>>): () => void;
}
// RegisterFactoryOptions @ :522-526
{ name: F; scope: FactoryDefOf<F>['scope'] } & children? & store? & inject? & locale? & slots?
```
有**类型级**碰撞检查:`FactoryCollisionCheck`(inject/input/local props 重叠 → 编译失败,:508-513)、`FactoryChildrenCheck`(子槽定义必须与 SlotMap 相符,:514-521)。
**`renderFactorySlot`**:
```ts
// ui-slots index.d.ts:395-404
type RenderFactorySlot = <F>(name: F, props: FactoryInputPropsOf<F>, options?: {
slots?: Partial<{ [N in local]: FactoryLocalComponent<F, N> }>;
fallback?: ReactNode;
}) => ReactNode;
interface PropsRenderFactories { renderFactorySlot: RenderFactorySlot }
```
"**每个 renderer 创建的组件都拿到 `renderFactorySlot`**"(原注释:Factory rendering capability supplied to **every** renderer-created Component)→ 插件组件里直接 `props.renderFactorySlot(...)` 即可,无需自己 import 任何东西。
相关但**禁止**的:`SlotRegistry.renderSlot(key, owner)` **运行时强制 `key === 'root'`**(registry.d.ts:150-158)。除 root 之外,任何槽都只能通过组件 props 的 `renderSlot` 渲染。
**`root` 槽禁止注册**——原注释(registry.d.ts:16-38)值得整段引用:
> "**DO NOT register here.** This is a single slot, so a second entry does not sit beside the frame — it shadows it, and a dynamically registered entry is assigned a lower priority than the shipped one, which makes it the winner: **the page would render your component alone, with every seat the frame declares gone.** For a surface of your own that floats over the whole app, register into `shell.overlay` instead (a list slot: additive, and click-through until your entry opts into pointer events)."
root 被 ui-layout 的 `AppFrame` 占据,AppFrame 在其内部声明 `sidebar` / `conversation` / `details` / `shell.overlay` 四个座位。
**`ctx.slots.inject(key, cb)`**(registry.d.ts:96-111)是**不依赖 apply 顺序**的正确姿势:槽已声明则同步跑 cb,否则等声明方 register 提交后跑;折叠时 dispose,再声明会重跑。旧插件全部用它(client.js:2006-2072),**这是对的,v0.1 继续用**。
**档位**:语义 = **类型层已核实**(文档注释极详细,逐条有行号)。
**运行时已跑过**:`register` + `inject` 组合(旧插件 5 处注册在真实宿主可用)。
**未验证**:priority 冲突抛错的**实测**表现(类型注释明说会抛,但没跑过);`registerFactory` 在本仓库跑过(旧插件没用到 factory)。
---
## 7. 插件客户端装载与注入
### 7.1 两种 inject,别混
| 声明位置 | 内容 | 语义 | 证据 |
| --- | --- | --- | --- |
| `package.json` → `dsh.client.inject` | **包名**(`@deepseek-ai/...`) | **informational**:只影响加载/预取顺序,**从不决定 apply 顺序** | ui-workspace `client/index.d.ts:24-31` 注释原文:"activation order ... is NOT constrained: `dsh.client.inject` edges are **informational (loading/prefetch metadata, never apply sequencing)**" |
| 客户端模块 → `exports.inject` | **cordis 服务短名**(`slots` / `sessions` / `uiWorkspace`…) | **强制**:apply 前这些服务必须就绪,缺了插件会被 **park**(不激活) | 旧插件 client.js:2073;client.js:1990 注释:"better-sidebar 是可选的,没装时不要写进 inject,否则插件会被 park" |
官方包的写法可对照(`package.json` 的 `dsh` 块):
```jsonc
// node_modules/@deepseek-ai/dsh-client-ui-workspace/package.json
"dsh": { "client": { "inject": ["@deepseek-ai/dsh-api-remotes", "@deepseek-ai/dsh-api-session-controller", ...], "platform": "web" } }
// node_modules/@deepseek-ai/dsh-client-ui-renderer/package.json
"dsh": { "client": { "platform": "web", "immediately": true } }
// node_modules/@deepseek-ai/dsh-api-session-controller/package.json
"dsh": { "client": { "external": ["@deepseek-ai/dsh-api-gateway/client"], "inject": [...], "platform": "web" } }
```
### 7.2 仓库现状
| 文件 | 现状 | 结论 |
| --- | --- | --- |
| `C:\Users\qyh15\三省六部\package.json` | `dsh` 块只有 `manifestVersion: 1` 与 `bundle.patch`,**没有 `client`** | 根包是「模式策略层」,不带客户端 |
| [panel/package.json](../panel/package.json) | **有** `dsh.client = { platform: "web", inject: [...] }`,含 `@deepseek-ai/dsh-client-ui-model-selection` 等 6 个包名 | 客户端在 panel 子包里 |
| [panel/cordis.patch.yml](../panel/cordis.patch.yml) | `insert: [{ id: sansheng-agent-panel, name: dsh-sansheng-liubu-panel }]` | 把 panel 作为一个 bundle 插进 cordis |
| [panel/lib/client.js](../panel/lib/client.js):2073 | `exports.inject = ["slots","sessions","uiWorkspace","uiConversation","modelDirectories","remote","remote.agentPresets","remote.session","remote.subagents","remote.commands","sidebarRightTabs","sidebarRight"]` | 短名服务列表 |
### 7.3 客户端 bundle 的加载契约
```js
// panel/lib/client.js:1-6
window.__ModuleLoader__.load({
id: "dsh-sansheng-liubu-panel",
factory: (require) => { /* ... */ return module.exports },
});
```
- `require` 只对**共享模块表**里的模块生效;表外的 `@deepseek-ai/*` 必须内联。
- 共享表(官方式)见 `C:\Users\qyh15\Documents\dsh-workspaces-goups-new\dsh-workspace-groups\tsdown.config.ts:48-64`:`react`、`react/jsx-runtime`、`react-dom`、`react-dom/client`、`@deepseek-ai/cordis`、`@deepseek-ai/dsh-client-ui-slots`、`@deepseek-ai/dsh-client-ui-primitives`、`@deepseek-ai/dsh-client-store`(旧名 `dsh-client-runtime/client` 兼容)。
- 该仓库的纯净门约束(`DEVELOPMENT.md` §4.1):"任何其它 `@deepseek-ai/*` 值导入都会让构建失败"。**类型导入(`import type`)会被擦除,不受限**。
**档位**:装载契约 = **运行时已跑过**(旧插件 bundle 在真实宿主加载成功);`dsh.client.inject` 是 informational = **类型层已核实**(官方包注释原文)。
**未验证**:`immediately` 字段对自己插件的影响(代码里只有 renderer 用,**需动态验证**)。
---
## 8. 已知限制与未验证点
### 8.1 明确不能用 / 不要做
| # | 限制 | 依据 |
| --- | --- | --- |
| L1 | **`root` 槽不能注册**:会 shadow AppFrame,导致整页只剩你的组件 | registry.d.ts:16-38 原文 |
| L2 | 除 `root` 外**不能用 `slots.renderSlot(key)`** 渲染,运行时强制 `key === 'root'` | registry.d.ts:150-158 |
| L3 | **同 cell 同 priority 注册会抛错**(single/同 key/同 id 均算),并点名 occupant | ui-slots :769-776 |
| L4 | `main` 槽的声明读不到(本机无 `dsh-client-ui-layout`),**不能假设**它 keyed 或 key 空间 | §6.2 |
| L5 | `selectModel` **会改全局默认** | commands.js:145-175 |
| L6 | `cancel` **不取消排队消息**,取消后 FIFO 继续 | commands.js:468-478;session.d.ts:104-110 |
| L7 | 有活动时 `archiveSession` 拒绝(`workspace/session-active`),`stopActivity:true` 才停 | types.d.ts:36-44 |
| L8 | `delete` workspace **不删会话、不删文件** | index.d.ts:63 |
| L9 | `projections.faceOf(key)` 的 key 是裸 string,拼错不报错 | session.d.ts:55 |
| L10 | 把可选插件(如 better-sidebar)写进 `exports.inject` 会让插件被 **park** | client.js:1990 注释 |
| L11 | 客户端 `prompt()` 的 `requestId` 是第 4 个可选参数,**不传就没有幂等**(旧插件就没传) | session.d.ts:82-84;client.js:1148-1165 |
### 8.2 未验证点(分级)
| # | 项 | 类型 | 要做什么 |
| --- | --- | --- | --- |
| U1 | `main` 槽 kind/owner/keyed 语义 | **代码里没有**(缺包) | 装 `dsh-client-ui-layout` 或读其源码;运行时 `ctx.slots.snapshot('main')` |
| U2 | 三处 slot 的**实际占位者**(谁 priority 多少) | 需动态验证 | `ctx.slots.snapshot()` 导出 |
| U3 | workspace-groups 当前是否仍 priority -1 shadow `sidebar.workspaces` | 需动态验证 | 看其 `src/client/index.ts` 或快照 |
| U4 | 显式 `sessionId` 二次 create 真返回同 id | 需动态验证 | 连调两次比对 |
| U5 | 客户端 `prompt` 第 4 参 requestId 是否透传到 Host | 需动态验证 | 同 requestId 发两次看事件数 |
| U6 | `cancel()` → `running=false` 的时延与事件序列 | 需动态验证 | 长任务实测 |
| U7 | **宿主重启后客户端重建**:插槽是否重新注册、apply 是否重跑、浏览器本地状态(旧插件用 localStorage)是否还在 | 需动态验证(**v0.1 关键**) | 重启 DSH,看插件是否 park、绑定是否丢 |
| U8 | **follow 事件流断线重连**:是否零丢失、cursor 续点在哪层 | 需动态验证(**v0.1 关键**) | 断网/重启期间制造事件,重连后核对 |
| U9 | `'conversation.content'` 在非主区位置实例化是否可用 | 需动态验证 | 先做个最小 occurrence |
| U10 | `SessionCreateError.requestedSessionId` 是否真被回填 | 需动态验证 | 制造一次创建失败 |
| U11 | `modelCatalog` 的 efforts 枚举实际内容、`failures` 触发条件 | 需动态验证 | 打真实宿主 |
| U12 | 归档被拒时 `activity` 数组的成员结构 | 需动态验证 | 运行中归档一次 |
| U13 | 两窗口同会话并发投递的行为(租约/互斥) | 需动态验证(实施方案 §8 故障矩阵要求) | 两窗口同时派工 |
| U14 | `dsh.client.immediately` 对本插件的影响 | 需动态验证 | 加字段对比加载时机 |
### 8.3 与实施方案 §3 十二项的对账
| §3 项 | 本文对应 | 当前档位 |
| --- | --- | --- |
| 主页面扩展 | §6.2、§6.4 | 部分未核实(`main` 缺包) |
| 项目树 | §6.1 | 归属已核实,优先级待验证 |
| 内嵌聊天 | §6.3 | 类型层已核实,嵌入可用性未验证 |
| 独立 session | §2.1 | 类型层已核实 |
| 消息投递 | §2.2 | 类型层已核实 |
| 运行关联(hostRunId、终态、取消、重启查询) | §2.2、§2.3、§4.3 | 取消与终态语义已核实;**重启查询未核实** |
| 模型目录 | §3.1、§3.2 | 类型层已核实(Host 侧) |
| 配置/工具权限 | — | **本文未覆盖**(属 index.js 宿主策略层,需另开一节核实 `evaluateToolPolicy` 的宿主约束) |
| 材料/记忆 | — | **本文未覆盖**(未查记忆注入路径) |
| 存储(原子/事务/版本/事件恢复) | — | **本文未覆盖**(§4.1 提到 Host 用 `folded prefix`,插件侧存储方案尚未定) |
| 主题/构建 | §7.3(构建) | 构建契约已核实;主题未核实 |
---
## 9. 对 v0.1 实现的影响
1. **会话创建一律显式传 `sessionId`,别靠 `startSession` + 轮询。** `create({sessionId, cwd, agentPreset})` 天然幂等 adopt,冲突会明确报 `session/conflict` / `agent-preset/conflict`;而旧插件的 `uiWorkspace.startSession()` + `waitNew(15×200ms)`(client.js:1646-1680)是靠"轮询列表找新 id"猜归属,正是实施方案 §6.5 明令禁止的做法。`sessionId` 由 `projectId + roleId` 稳定派生,落库后永不变。
2. **调度必须放 Host 侧,浏览器只订阅。** 依据有二:`sessionController`、`workspaceController` 都是 Host 服务(`TypertRemoteService`,index.d.ts:17-19/20-23),Host 侧能直接 `create`/`prompt`/`follow`/`control`,不需要浏览器在场;而客户端离开页面时 `SessionReference.release()` 会拆掉本地 scope(sessions.d.ts:22-30)。→ `DispatchService`/`Reconciler` 写在 `index.js`(Host apply)里,插件 client 只做 `WorkbenchView`。
3. **幂等键用 `requestId`(Host 侧真幂等),不要自造去重表。** `hasPromptRequest` 会扫 inbox 与历史 `user/message` 的 `rpcId`,**跨重启**仍然生效(commands.js:301-302、547-561)。本项目只需要保证「同一个 dispatch 重试时复用同一个 requestId」。注意走客户端 `binding.session.prompt(...)` 时必须补第 4 参,否则等于没有幂等。
4. **模型配置是"每次派发前覆写",不是"设一次就记住"。** `selectModel` 会后台 `saveSelection` 改全局默认。所以:读 `modelCatalog()` 校验 desired → 每次派发前显式 `selectModel` → 用返回值 `selected` 记成 `effectiveConfigSnapshot`(可能被归一化)→ 失败就明确报错,**不静默换模型**(对应实施方案 §6 三条要求)。UI 的"本次/下次"直接用 `modelSelection` 投影的 `lastUsed` / `next`。
5. **`cancel` 只能到 `cancel_requested`;`inbox` 不会被清。** 要真停,得先 `cancel` 再把排队项逐条 `updateQueue(itemId, {kind:'remove'})`(`QueueAction`,types.d.ts:149-157);而 `updateQueue` 在 `target === 'next-turn'` 且 agent 仍 `running` 时支持 steer,否则抛 `session/steer-unavailable`(commands.js:435-436)。Attempt 状态机的 `cancel_requested → cancelled` 必须由 follow 事件确认,不能凭 `accepted:true`。
6. **左栏不要再注册 `sidebar.workspaces`。** 它是 single/root,已由 ui-workspace 声明、workspace-groups 占据。需要行内动作时只往 `sidebar.workspaces.session.menu.item` / `sidebar.workspaces.session.row.action` 这类 **list** 槽插(additive、按 order),这样不会和别人的 priority 撞(同 cell 同 priority 会抛错)。
7. **中间对话让真会话占 `main.conversation`,不要自己造 conversation。** `'conversation.content'` 是工厂、确实可复用,但 `scope: 'session-maybe'` 的绑定行为本机无法核实。最稳的是沿用旧插件的做法:`ctx.uiWorkspace.openSession(sessionId)` 让原生会话占据主区(client.js:1441-1460),插件只决定"选中哪个 session";需要额外信息就在 `conversation.session.header.actions`(list,旧插件已用 order 40)等已有座位上加,而不是覆盖整块。
8. **P0 收尾必须补 §0.5 那六项动态验证,尤其是 U7(宿主重启)与 U8(断线重连)。** 实施方案 §8 的「重启对账」「重复事件」「两窗口租约」全都依赖这两个行为;如果实测发现 follow 不能零丢失,`Reconciler` 就必须从"增量补偿"升级为"定期全量对账 + 状态机兜底",这会显著改变 §4 的分层预算。在此之前,任何"已通过"的结论都应写成"类型层已核实"。
---
## 附:本文引用的文件清单
| 简称 | 绝对路径 |
| --- | --- |
| ui-slots | `...\@deepseek-ai\dsh-client-ui-slots\lib\types\index.d.ts` |
| ui-renderer | `...\@deepseek-ai\dsh-client-ui-renderer\lib\types\client\registry.d.ts` / `client\index.d.ts` |
| ui-conversation | `...\@deepseek-ai\dsh-client-ui-conversation\lib\types\client\contract\slots.d.ts` |
| ui-sidebar | `...\@deepseek-ai\dsh-client-ui-sidebar\lib\types\client\contract\slots.d.ts` |
| ui-workspace | `...\@deepseek-ai\dsh-client-ui-workspace\lib\types\client\contract\slots.d.ts` / `navigation.d.ts` / `index.d.ts` |
| session-controller | `...\@deepseek-ai\dsh-api-session-controller\lib\types\index.d.ts` / `types.d.ts` / `commands.js` / `agent.js` / `client\contract\*.d.ts` |
| workspace-controller | `...\@deepseek-ai\dsh-api-workspace-controller\lib\types\index.d.ts` / `types.d.ts` / `client\model.d.ts` / `client\service.d.ts` |
| typert-protocol | `...\.pnpm\@deepseek-ai+dsh-typert-pro_ced96565a0ecf302a2ee4e627ca2288b\node_modules\@deepseek-ai\dsh-typert-protocol\lib\types\types.d.ts`、`remote-error.d.ts` |
其中 `...` = `C:\Users\qyh15\Documents\dsh-workspaces-goups-new\dsh-workspace-groups\node_modules\@deepseek-ai`。

View File

@ -1,222 +0,0 @@
# 三省六部工作台 · 新架构 v0.1 · 接线与契约
本文记录 v0.1 已经落地的部分:**数据层、Host 服务层、HTTP 接口、宿主接线**。
它回答三个问题:装了什么、界面能用哪些接口、哪些地方还没验证。实施方案本身见
`docs/v0.1-实施方案.md`,宿主能力的原始取证见 `docs/v0.1-宿主能力记录.md`。
> 版本口径:包版本仍是 0.9.2,**不降级**;"v0.1" 指新架构的第一版,不是包版本号。
## 1. 分层与文件
```
DSH 宿主
└─ index.js 政策插件(prompt / 工具策略 / 模型路由)+ 工作台挂载
└─ workbench/host/… Host 服务:账本、派发、对账、HTTP
└─ workbench/core/… 纯逻辑:ID、编制、状态机、账本、任务判定
workbench/panel/… 浏览器端(右栏部门树 + 任务/成果)
```
### workbench/core —— 纯逻辑,零依赖,可单独测
| 文件 | 行数 | 职责 | 关键导出 |
| --- | --- | --- | --- |
| `workbench/core/ids.mjs` | 81 | 稳定随机 ID、前缀与归属校验 | `newId` / `createIdFactory` / `isIdOf` / `ID_PREFIXES` |
| `workbench/core/roles.mjs` | 192 | 十席编制、布局分组、派发许可 | `ROLE_IDS` / `ROLES` / `layoutGroups` / `canDispatch` / `initialSeats` |
| `workbench/core/states.mjs` | 138 | 四套状态机(部门/任务/派发/尝试) | `STATE_MACHINES` / `canTransition` / `isTerminal` / `assertTransition` |
| `workbench/core/store.mjs` | 1012 | 账本:单写者、事务提交、CAS、引用完整性 | `WorkbenchStore` / `defaultStorePath` / `StoreError` |
| `workbench/core/tasks.mjs` | 436 | 任务状态推进与完成判定 | `createTask` / `beginAttempt` / `decide` / `evaluateCompletion` |
**账本约束(store 强制,不靠调用方自觉)**
- 一个账本文件只有一个写者;`mutate()` 内所有变更同事务提交,失败整批回滚。
- `(projectId, roleId)` 绑定唯一;同一个 `sessionId` 不能同时绑两个部门/项目
(`SESSION_CONFLICT`,带 `heldBy:{projectId,roleId}`);换绑必须显式
`allowReplace`,且 `bindingGeneration` 每次换绑 +1。
- 跨项目引用一律拒绝(`CROSS_PROJECT`);实体的 `projectId` 不可改。
- 配置写入走 CAS:`saveConfig(projectId, roleId, desired, expectedRevision)`,
期望版本不符返回冲突,避免两个标签页互相覆盖。
- 事件日志是**只读游标**:按 `seq` 追加,`listPendingEvents` 过滤未投递未处理的,
`markEventDelivered` 只写 `deliveredAt` 不物理删除。同一 `since` 重放返回同一批事件。
### workbench/host —— 服务层
| 文件 | 行数 | 职责 |
| --- | --- | --- |
| `workbench/host/paths.mjs` | 118 | 侧车目录、原子写、损坏隔离 |
| `workbench/host/service.mjs` | 1293 | 业务服务:项目/席位/绑定/配置/任务/派发/成果,`ServiceError` 翻译,事件化 |
| `workbench/host/contract.mjs` | 144 | 内部契约行解析(四动作)与模板 |
| `workbench/host/session-adapter.mjs` | 282 | 会话适配:创建/查证/投递/取消/模型/摘要 |
| `workbench/host/dispatch-service.mjs` | 207 | 派发:prepared → sending → accepted/rejected/unknown |
| `workbench/host/reconciler.mjs` | 181 | 对账:运行状态与账本对账,超时/重启/取消收口 |
| `workbench/host/routes.mjs` | 414 | HTTP 路由(11 条) |
| `workbench/host/workbench-host.mjs` | 188 | 会话层外壳:会话、派发、对账、契约入库 |
| `workbench/host/index.mjs` | 188 | 唯一 Host 入口:账本 + 外壳 + 路由装配,供 `index.js` 调用 |
### 账本位置
`%DSH_HOME%/sansheng-liubu/workbench.json`(`DSH_HOME` 缺省为 `~/.dsh`;
测试或临时实例可用 `DSH_SANSHENG_WORKBENCH_FILE` 覆盖)。
损坏处理:读不出来就把文件改名成同目录的 `.corrupt-<时间戳>` 隔离,**再**退回内存账本,
并把原因记进 `warnings`;不会静默清空。
## 2. HTTP 接口
前缀 `/sansheng/workbench`,全部同源。响应外层统一:
```json
{ "ok": true, "value": { } }
{ "ok": false, "error": { "code": "INVALID_STATE", "message": "…", "details": { } } }
```
| 方法 | 路径 | 请求体 / 查询 | 说明 |
| --- | --- | --- | --- |
| GET | `/bootstrap` | `?projectId=` | 一次取全:`{projects, projectId, project, seats, layout, tasks, artifacts, results, eventSeq}` |
| POST | `/project` | `hostWorkspaceId`, `displayNameCache?`, `canonicalRoot?` | 登记主机工作区↔项目;重复登记返回既有项目,不重建席位 |
| POST | `/bind` | `projectId`, `roleId`, `sessionId`, `allowReplace?` | 把某个会话绑成某部门;换绑需 `allowReplace` |
| POST | `/config` | `projectId`, `roleId`, `provider`, `model`, `reasoningEffort?`, `expectedRevision?` | 部门模型,CAS 写入;只影响该项目该部门 |
| POST | `/task` | `projectId`, `title`, `objective?`, `acceptance?`, `constraints?`, `scope?`, `ownerRoleId?`, `sourceRoleId?`, `originMessageRef?`, `returnTarget?`, `status?` | 建任务;`status:'queued'` 要求主责部门已接通 |
| POST | `/task/cancel` | `projectId`, `taskId`, `reason?` | 取消任务(终态不可再改) |
| POST | `/connect` | `projectId`, `roleId`, `sessionId?`, `agentPreset?` | 由 Host 建/定位部门会话并绑定;宿主没有会话能力时返回 `INVALID_STATE` |
| POST | `/dispatch` | `projectId`, `taskId`, `idempotencyKey`, `sourceRoleId?`, `targetRoleId`, `targetSessionId?`, `bindingGeneration?`, `packet?`, `sourceSessionId?`, `mode?`, `roleName?` | 派发任务单;有会话层时真投递,没有就只落账 `prepared`(UI 必须显示尚未接通) |
| POST | `/ingest` | `projectId`, `roleId`, `text` | 解析 Agent 输出里的契约行并落账(四动作) |
| POST | `/result` | `projectId`, `taskId`, `attemptId?`, `report?`, `runTerminal?`, `artifactRefs?`, `checks?`, `remainingItems?`, `blockedReason?`, `sourceMessageRef?`, `reportVersion?` | 登记结构化报告 / 运行终态;重复登记按 `attemptId+reportVersion` 与 `sourceMessageRef` 去重 |
| POST | `/artifact` | `projectId`, `taskId`, `displayName`, `mediaType?`, `fileRef?`, `versionOrHash?`, `verification?`, `sourceResultId?`, `revisesArtifactId?` | 直接登记成果(契约行 `registerArtifact` 之外的入口);带 `revisesArtifactId` 时版本号自动 +1 |
| POST | `/artifact/revision` | `projectId`, `artifactId`, `instruction`, `ownerRoleId?`, `status?` | 找主责部门改一份成果:只开一条修订任务,不重跑全链 |
| GET | `/events` | `?projectId=&since=` | 长轮询(默认 25s,内部 1s 轮询账本)增量事件;`since` 之后的才算新 |
错误码:`INVALID_INPUT` / `INVALID_ROLE` / `NOT_FOUND` / `CROSS_PROJECT` /
`CONFIG_CONFLICT` / `SESSION_CONFLICT` / `DUPLICATE_PROJECT` / `INVALID_STATE` /
`DISPATCH_INVALID` / `ATTEMPT_MISMATCH` / `REPORT_INVALID` / `INTERNAL`。
## 3. 内部契约行(Agent 怎么"上报")
Agent 不靠聊天里的"已完成"三个字更新任务,而是输出一行以 `【三省六部】` 开头的 JSON:
```
【三省六部】{"action":"dispatchTask","targetRoleId":"gongbu","title":"…","objective":"…"}
【三省六部】{"action":"reportTaskResult","taskId":"tsk_…","summary":"…","checks":["…"],"artifactRefs":["art_…"]}
【三省六部】{"action":"requestTaskInput","taskId":"tsk_…","question":"…"}
【三省六部】{"action":"syncDecision","taskId":"tsk_…","decision":"approved"}
```
- 解析:`parseContractLines(text)` 逐行匹配,坏 JSON / 未知 action 进 `invalid`,**不抛**。
- 入库:`ingestAgentOutput({projectId, roleId, text})`,四条动作各自落账。
- 模板:`describeContract()` 生成给 Agent 看的说明(已注入部门 system prompt)。
## 4. 会话与派发
### 创建(幂等)
宿主 `sessionController.create({sessionId, workspaceId|cwd, agentPreset})`:
`sessionId` 是**唯一**的幂等来源(同 id 同 cwd 同 preset → 返回同会话;
cwd 不同 `session/conflict`;preset 不同 `agent-preset/conflict`)。
`SessionCreateRequest` 里没有 `creationRequestId` —— 实施方案里那一步在宿主不存在,
我们改成"先写账本再建会话,失败留恢复记录"。
### 投递
`prompt({requestId, sessionId, mode:'queue'|'steer', content:[{text}]})`,
`requestId` 用 `attempt.id`(客户端铸造):宿主按它去重,跨重启仍有效。
所有异常在宿主侧折叠成 `session/agent-busy`,因此**投递超时只能判 `unknown`**,
再由 `Reconciler.verifyUnknown` 查证后收口,不能直接判成功或失败。
### 取消
`cancel({sessionId})` 同步返回 `accepted:true`,但**只对已挂载的 agent 生效**、
`keepInbox:true`(排队消息会继续跑)。所以:
- 账本只推进到 `cancel_requested`;
- 要真停还得 `updateQueue({sessionId, itemId, action:'remove'})`;
- 对账看到"跑停了"才写 `cancelled`。
### 模型
- 客户端面没有 `modelCatalog()`,必须从 Host 取。
- `selectModel()` 会连带把选择存成全局默认,所以**每次派发前覆写**,
并把实际用的 provider/model/effort 记进 `effectiveConfigSnapshot`。
- 部门配置变更只改 `desired`(CAS),不动历史;运行中的请求保持原配置。
- 模型不支持旧的 reasoningEffort 时要求重选,不透传非法枚举,不静默回退。
## 5. 完成判定
宿主"运行正常结束"≠ 业务完成。`completed` 需要三件事同时成立:
1. 运行终态是成功(`runTerminal:'succeeded'`);
2. 有可信的结构化报告(`summary` + `checks`),且与任务验收项对得上;
3. 成果引用(`artifactRefs`)能查到实体。
只满足 1 → `needs_attention`(等人补报告);只满足 2、1 未到 → 先登记、候终态;
用户可以主动停 → 记 `cancelled`,不算"成功但没报告"。
## 6. 项目隔离
- 账本是**单一文件**,但所有实体都带 `projectId`,服务层每次读写都校验归属;
- 绑定表主键是 `(projectId, roleId)`,不同项目可以各有自己的工部会话;
- 会话在宿主侧是全局唯一的,所以"同一会话不能再绑别的部门/项目"由账本强制;
- 配置、任务、派发、成果、事件全部按项目分片;切项目必须整树重取,
不允许把上一个项目的 seats/tasks 混进来。
## 7. 宿主接线(index.js)
```js
import { createWorkbenchHost } from './workbench/host/index.mjs'
```
- `apply()` 里在建完政策之后 `acquireWorkbench(ctx, presetId, log)`;
返回的 disposer 末尾 `releaseWorkbench(entry)`。
- 按**账本路径**引用计数:同一份账本只有一个写者;`apply()` 被多个 agent 调用时
不会重复建 store,最后一个卸载时才 `dispose()`。
- 用 `ctx.root ?? ctx` 创建:工作台属于整个应用,不随单个 agent 销毁消失。
- 整体包 try/catch:工作台起不来只打日志,政策插件(prompt/工具策略)照常工作。
- 没有真实宿主服务(单测里的 mock ctx)时直接跳过,不写真实账本、不起计时器。
日志前缀 `[sansheng-liubu:workbench]`。
### 晚到的服务怎么办
`apply()` 跑的那一刻,宿主不保证 `webServer` 与 `sessionController` 都已经装好,
所以两样都按「先试一次、没到就等它到」处理:
| 依赖 | 当场没有时 | 补挂方式 | 补挂后 |
|---|---|---|---|
| `webServer` | 路由不注册,`warnings` 记一条 | `ctx.inject(['webServer'], …)` 再注册一次 | 13 条接口可用 |
| `sessionController` | 会话层为空,`hasSessions=false`,派发只落账 | `ctx.inject(['sessionController'], …)` → `shell.attachSessions(controller)` | 可以接通部门、真投递 |
两条补挂都**只做一次且幂等**:已经挂上就不再换(`attachSessions` 第二次调用返回 `true`
但保留原实例)。这样用户不必为了「接通部门」专门多重启一次 DSH。
派发钩子是恒挂的:`shell.hasSessions===true` 走真投递,否则退回 `service.dispatchTask`
只写 `prepared`——**任何时候都不会把「没接通」显示成「已发送」**。
`createWorkbenchHost(ctx, { store })` 支持注入账本(测试与嵌入场景):注入了就用它,
不碰磁盘、不做损坏隔离,避免单测写到 `%DSH_HOME%` 下的真账本。
## 8. 尚未验证 / 已知限制
来自 `docs/v0.1-宿主能力记录.md` §8.2,按影响排序:
| 编号 | 未验证项 | 影响 | 现在的处置 |
| --- | --- | --- | --- |
| U7 | 宿主重启后客户端会话重建 | 重启后账本里的 `targetSessionId` 是否还能打开 | `connectDepartment` 先 `inspectSession`,失效才重建 |
| U8 | `follow` 断线重连是否零丢失 | 对账能否只依赖事件流 | 对账**不**只靠 follow,另有定时 `reconcileOnce` |
| U4 | 二次 `create` 真返回同 id | 幂等是否成立 | 已按"显式 sessionId"实现,验证后无需改代码 |
| U5 | 客户端是否透传 `requestId` | 投递幂等 | 派发走 Host 侧 `sessionController.prompt`,不依赖客户端 |
| U9 | `conversation.content` 能否在非主区实例化 | 全页工作台中间栏 | 先走"主区接管 + 复用原生 `renderFactorySlot`"路线 |
| U1 | `main` 槽的 SlotMap 声明 | 老面板的 `main` 重定向桩 | 与 v0.1 无关,保持现状 |
限制:
- 账本单文件、单写者:同一个 `%DSH_HOME%` 下只能跑一个 DSH 实例写它
(双开会被"同一账本只有一个写者"挡住,而不是写坏)。
- 事件长轮询最长 25 秒,页面隐藏时暂停,恢复时按 `since` 续读,不重放已读。
- 成果只存引用与摘要,不存文件本体。
## 9. 验证
```bash
export PATH="/c/Users/qyh15/AppData/Local/Programs/DeepSeek Harness/resources/runtime/primary-runtime/dependencies/node/bin:$PATH"
node --test --test-isolation=none test/policy.test.js workbench/test/*.test.mjs panel/test/client.test.js
```
当前:**182 passed / 0 failed**(core 60、host 16、service 22、routes 29、policy 11、panel 44)。

View File

@ -1,134 +0,0 @@
# 三省六部独立工作台 v0.1 · 验收记录
对应 `docs/v0.1-实施方案.md` 的 A01–A28 验收矩阵。**本文只记录跑过的东西**:
"已验"必须能指出具体测试名或具体产物;跑不了的写"待真机",不写"完成"。
- 记录时间:2026-11-10
- 代码位置:`C:\Users\qyh15\三省六部\workbench\`(`core/` 数据层、`host/` 宿主服务与路由、`panel/` 前端 bundle)
- 测试基线:`node --test --test-isolation=none test/policy.test.js workbench/test/*.test.mjs workbench/panel/test/client.test.mjs panel/test/client.test.js` → **200 tests / 200 pass / 0 fail**
测试命令(node 不在 PATH,必须先加运行时目录):
```bash
export PATH="/c/Users/qyh15/AppData/Local/Programs/DeepSeek Harness/resources/runtime/primary-runtime/dependencies/node/bin:$PATH"
node --test --test-isolation=none test/policy.test.js workbench/test/*.test.mjs workbench/panel/test/client.test.mjs panel/test/client.test.js
```
---
## 1. 逐项结论
状态口径:
- **已验(单测)**:有对应的自动化测试,跑得过。
- **已验(预览)**:有真 Chrome 渲染的产物(`docs/preview/`),但还没在真实 DSH 页面里跑过。
- **待真机**:逻辑在、测试覆盖不到,必须在重启后的 DSH 里点一遍。
- **未做**:本轮没实现。
| 项 | 判定标准 | 现状 | 证据 / 缺口 |
|---|---|---|---|
| A01 | 无普通聊天时打开上朝,不要求 Team | 待真机 | 前端 `main.conversation` 以 `priority:-1` 接管;需重启后确认独立进入 |
| A02 | 切 A/B、重命名/移动项目不换 session | 已验(单测) | `registerProject 同一工作区只建一个项目`;绑定只用 `hostWorkspaceId` 与 `bindingGeneration`,名称变更不触碰绑定 |
| A03 | 点分组节点不创建项目或十席会话 | 已验(单测) | `layoutGroups renders three tiers without inventing parent links`;`initial seats describe configuration rows without creating sessions` |
| A04 | 双击首次启动同部门只建一个 session | 已验(单测)+ 待真机 | `会话适配:缺 sessionId 时按 workspace 建会话且不重复建`;`绑定:同一会话被别处持有 → SESSION_CONFLICT`。真机二次点击要复验(U4) |
| A05 | 十席分别发短消息,输入/历史/实际 session 一致 | 已验(真实 bundle + 真实路由,伪宿主会话) | `--live` 模式把**真实 panel bundle** 打到**真实 Host 路由**上:新建任务存草稿 → 点「派工」→ `POST /dispatch` 200 且 `dispatch.status=accepted`,任务行变「工部 · 执行中」,伪 controller 收到 743 字符任务单(`docs/preview/v01-live-tasks-400-light.png`)。装配层测试另有完整闭环(契约回执 → Result → completed)。真宿主的十席输入/历史一致性仍需重启后逐个看 |
| A06 | A 工部改模型,B 工部用另一模型,全局默认不变 | 已验(单测)+ 待真机 | 配置按 `projectId+roleId` 存、`saveDepartmentConfig` CAS;**派发时默认不再调 `selectModel`**(部门模型由政策插件在 `agent/request` 上按角色覆写,再调一次会让宿主把全局默认存成本部门的),模型快照仍记在 `attempt.effectiveConfigSnapshot`。真机待看 `modelSelection` 投影 |
| A07 | 运行中改模型,本次仍用原模型 | 已验(单测) | `首次派发:固定模型快照 → prompt 用 attemptId 作幂等键`:`effectiveConfigSnapshot` 在派发时冻结 |
| A08 | 模型不支持旧 effort / 目录失效,校验错误可见 | 已验(单测) | `会话适配:prompt 必须带 requestId,错误分类可区分可重试与必失败` 覆盖 `model_unavailable`;不静默替换 |
| A09 | 丞相带文件交接工部,材料可读、引用可追溯 | 已验(单测,附件级已通) | `A09 交接材料:附件引用原样进 packet,成果引用带版本,文本里可读`:`{attachmentId}` 保留 name/mime/size,`{artifactId}` 自动补 `revision` 与成果显示名;`buildDispatchText` 渲染成 `成果 预算表 art_x(第 1 版)`、`附件 att_abc(预算.xlsx · application/vnd.ms-excel · 2048 字节)`;缺 ID / 未知 ID 报 `INVALID_INPUT` / `NOT_FOUND`。真机"从聊天里带附件"仍需重启后确认 |
| A10 | 正常完成:有效报告+终态+成果核验 | 已验(单测) | `完成判定分支一:报告+终态成功+成果有效 → completed` |
| A11 | 仅变 idle 或输出"已完成"不标记完成 | 已验(单测) | `对账:运行结束但无报告 → needs_attention`;`契约解析只认四动作`(正文里的"已完成"不进状态机) |
| A12 | 重复投递/重复完成/乱序事件不重复、不倒退 | 已验(单测 + 真实路由) | `重复点击同一幂等键:不重复投递`;`结果去重:同 (attemptId, reportVersion) 与同 sourceMessageRef 只登记一次`;`isRegressingEvent` 拒绝倒退终态;`--live` 场景 cancel:派工 accepted 后 `POST /task/cancel` 200,`task.status=cancelled`、`applied=true`,界面按钮消失并发绿条(`docs/preview/v01-live-cancel-400-light.png`) |
| A13 | 回执超时 → unknown 对账,不自动重发 | 已验(单测) | `投递超时:dispatch 记 unknown,不自动重发` + `verifyUnknown` |
| A14 | 用户直聊与派工同时到达,同 session 串行 | 已验(单测)+ 待真机 | 错误分类 `busy`;真实串行由宿主 inbox 保证,需真机观察 |
| A15 | A/B 同时跑,停止 A,B 继续 | 已验(单测)+ 待真机 | `cancelTask:业务落 cancelled,运行中的尝试只到 cancel_requested`;取消带 `attemptId`,不会误停 B |
| A16 | A 运行时切到 B,A 迟到回调不改 B | 已验(单测) | `对账` 全按 `attemptId` 判定;`宿主重启后查不到会话时不猜` |
| A17 | 刷新/关闭重开/重启宿主后绑定配置任务恢复 | 已验(单测,账本重开) | `A17 宿主重启:账本重开后项目/绑定/配置/任务/派发都还在,换绑代号不回退`:同一 `workbench.json` 新建 store + `load()` 后项目/绑定/配置(`config.model`、`configRevision`)/任务/幂等键全部还原,重复派发返回 `duplicate:true` 且同 `dispatch.id`;`events` 游标可重放。**U7 宿主重启后客户端重建仍需真机** |
| A18 | 伪造其他项目 session/task/artifact/run ID 被拒 | 已验(单测) | `项目隔离` 四条:`CROSS_PROJECT` / `NOT_FOUND` 且不泄露归属 |
| A19 | B 不自动获得 A 的材料/记忆 | 已验(单测,材料侧) | `A09/A19 跨项目成果引用被拒`:B 项目引用 A 的 `artifactId` → `CROSS_PROJECT`,`details` 不含 A 的归属;B 的 packet 只装本任务材料(无跨项目串带)。**记忆隔离属宿主能力,仍需真机** |
| A20 | 相同目录/父子目录识别为冲突,不宣称完全隔离 | 已验(单测) | `A20 同目录/父子目录登记成另一个项目时明确报冲突`:`DUPLICATE_PROJECT` + `relation: same/nested` + `allowSharedRoot` 显式放行 |
| A21 | 两窗口同时改设置/消费队列不覆盖 | 已验(单测) | `saveDepartmentConfig 走 CAS:旧 revision 冲突并带回当前值`;事件日志为只读游标,多标签页不互相偷事件 |
| A22 | 主责部门局部修改成果,保留来源/版本,不重跑全链 | 已验(单测 + 真实路由/真实 bundle) | `--live` 场景 revise:真实 `POST /artifact/revision` 200,返回 `kind:revision`、`scope.kind:artifact-revision`、`artifactRevision:1`,界面自动切任务页并显示带「修订」标签的新任务(`docs/preview/v01-live-revise-400-light.png`)。单测另验「只开一条修订任务、不重跑三省」
| A23 | 删除 session 或成果文件后显示失效并保留历史 | 已验(单测 + 真实路由/真实 bundle) | `--live` 场景 missing:`fileRef` 指向不存在文件时 `existence=missing`,界面显示虚线淡红卡 +「· 文件已失效」,账本记录保留(`docs/preview/v01-live-missing-400-light.png`)。注意 `verification.status` 仍为 `verified` —— 那是「结果被核验过」,与「文件现在还在不在」是两个维度,不去改写它
| A24 | 2560×1440 浅/深色、拖宽右栏 | 已验(预览) | `docs/preview/v01-workbench-rail-400-light.png` / `-dark.png`(800×1220,真 Chrome 渲染真实 bundle);拖宽逻辑 340–600 + `sansheng.workbench.railWidth` |
| A25 | 约 390 CSS px 手机宽度抽屉可用 | 已验(预览) | `docs/preview/v01-workbench-rail-390-light.png` / `-dark.png`(780×1220):三列卡片不再折行,「未接通」保持一行、模型名省略号;抽屉本身在真机里才展开(待真机) |
| A26 | 切主题/项目/部门后草稿、绑定、配置各归所属 | 已验(单测,数据归属)+ 待真机界面 | `A26 切项目后草稿、绑定、配置各归所属`:两个项目各自 `gongbu` 配置不同模型、绑不同会话、各存一条 draft 任务;`bootstrap(A)/(B)` 的席位配置、`binding.currentSessionId`、任务标题互不串带。界面切换时草稿保留仍需真机点一遍 |
| A27 | 键盘选卡片/模型按钮/分隔条/弹层,焦点可恢复 | 已验(单测)+ 待真机遍历 | 卡片 `role="button"` + `tabIndex` + Enter/Space;分隔条 `role="separator"` + `tabIndex` + `aria-valuenow/min/max`,方向键 ±16、Shift ±64、Home/End 到两端,未知键返回 `null` 不拦截默认行为(`A27 分隔条键盘` 单测)。宿主内真实 Tab 顺序与焦点恢复仍需重启后手测 |
| A28 | 原生聊天审批、附件、流式在工作台同页可用 | 待真机 | 结构上复用 `renderFactorySlot('conversation.content')`,不重造聊天;需真机确认没绕过审批 |
小计:**已验 22 项**(A02 A03 A04 A05 A06 A07 A08 A09 A10 A11 A12 A13 A15 A16 A17 A18 A19 A20 A21 A22 A23 A26 A27 的单测/装配层部分,A24 A25 的预览部分)、**待真机 4 项**(A01 A14 A28 + A04/A24/A25/A26 的真机部分)、**未做 0 项**。
> 说明:A06 之所以仍标"部分",是判定标准要求"全局默认模型不被改动",而这一点只能在真实宿主里
> 观察 `modelSelection` 投影才能坐实;代码侧已确认每次派发前覆写 `selectModel` 并记录
> `effectiveConfigSnapshot`,派发结束后不写回全局。A01/A05/A14/A25–A28 同理,都需要重启 DSH 后补证据。
---
## 2. 本轮新增/改动(相对上一版)
| 文件 | 改动 |
|---|---|
| `workbench/core/store.mjs` | `REFERENCES.artifacts` 增 `revisesArtifactId`(跨项目修订一律拒绝);`recordArtifact` 落 `revisesArtifactId / revision / revisionOfTaskId` |
| `workbench/host/service.mjs` | 新增 `normalizeRoot` + `rootConflict`(A20);`registerProject` 冲突即拒、`allowSharedRoot` 显式放行;新增 `requestArtifactRevision`(A22);`registerArtifact` 支持修订链与版本递增;新增 `artifactView`(A23,`fileExists` 可注入);`dispatchTask` 对修订任务自动补 `materialRefs`;`EVENT_OPS` 增 `requestArtifactRevision` |
| `workbench/host/routes.mjs` | 新增 `POST /sansheng/workbench/artifact/revision`(端点 11 → 12) |
| `workbench/host/index.mjs` / `workbench-host.mjs` | 把宿主 `existsSync` 注入 service(A23 真机可用),测试可替换 |
| `workbench/test/service.test.mjs` | 新增 3 条:A20 冲突、A22 修订链、A23 失效投影 |
| `workbench/test/routes.test.mjs` | 路由数 11 → 12 |
| `workbench/panel/lib/client.js` | 成果区补「文件已失效/位置未核验」标记、修订按钮与内联表单、任务「修订」标签 |
### 本轮(A09/A17/A19 补齐)
| 文件 | 改动 |
|---|---|
| `workbench/host/session-adapter.mjs` | 新增 `describeMaterialRef(ref)` 并用于 `buildDispatchText`:成果写成「成果 预算表 art_x(第 1 版)」,附件写成「附件 att_abc(预算.xlsx · application/vnd.ms-excel · 2048 字节)」,字符串材料原样 |
| `workbench/host/service.mjs` | 新增 `normalizeMaterialRefs(value, project)`:`{artifactId}` 校验同项目并自动补 `revision`/`title`(标题取 `artifact.displayName`),`{attachmentId}` 保留 name/mime/size,字符串放行,未知/缺 ID 报 `NOT_FOUND`/`INVALID_INPUT`;`dispatchTask` 的材料走它而不是裸数组 |
| `workbench/test/acceptance-extra.test.mjs` | 新增 3 例:A09 材料可读、A09/A19 跨项目材料被拒且不泄露归属、A17 账本重开后全量还原 |
| `workbench/test/service.test.mjs` | A22 断言补齐 `title`(材料引用现在带可读名) |
测试数:206 → **209**(全绿)。
---
## 3. 复现步骤(真机部分)
1. 确认主包已安装(朝堂面板已并回 `dsh-sansheng-liubu-mode`,不再有独立 workbench 包):
```bash
node scripts/workbench-preflight.mjs # 期望 5/5 通过:入口、bundle 语法、16 条路由、账本可写
```
> `workbench-preflight.mjs` 是严格只读自检:不装、不改配置、不创建文件,只回答「重启后会不会白屏 / 路由起不起得来」。
> 安装、修复与迁移是另外的显式操作;旧 `workbench-install.mjs` 现在只打印迁移说明。
2. **彻底退出 DSH 再启动**(托盘退出,不是关窗口);只对新会话生效。
3. 打开任意项目会话,右侧应出现「朝堂 / 任务 / 成果」。
4. 依次验:接通一个部门 → 派一条任务 → 完成 → 在成果区点「找主责部门修改」。
5. 白屏逃生:控制台 `localStorage['sansheng.workbench.main']='off'` 后刷新,接管会被跳过。
6. 完全回退:从 profile 移除 `dsh-sansheng-liubu-mode` 后重启(旧独立 workbench 包已退役,不要安装)。
---
## 4. 已知限制(不含未验证项)
- **L1** 账本损坏时改名隔离(`<file>.corrupt-<时间戳>`),以空账本启动;不做自动修复。
- **L2** 成果只记引用,不复制文件;文件被删后靠 `existence:'missing'` 显示,历史不移除。
- **L3** 目录冲突只做字符串级归一(大小写、分隔符、末尾斜杠),**不解析 junction/短路径真实目标**;命中即报,不宣称隔离。
- **L4** `selectModel` 在宿主侧会连带改全局默认模型,所以派发前一律覆写并快照,不依赖全局默认。
- **L5** `cancel` 不撤回已排队的消息,取消后 FIFO 可能继续跑;因此取消只到 `cancel_requested`,等对账收口。
- **L6** 事件是只读游标 + 可重放,不做"读一次就消失"的队列;两个标签页会看到同一批事件。
- **L7** 400px 栏宽下模型名仍可能截断(三列每列约 112px),完整值在 `title` 里。
## 5. 未验证清单(必须在真机补)
- U7:宿主重启后客户端能否重建并重新读取账本(决定刷新语义)。
- U8:`follow` 断线重连是否零丢失(决定对账预算)。
- U4:二次 `create` 是否真返回同一个 sessionId。
- U5:客户端 `prompt` 的 `requestId` 是否真的透传到服务端幂等表。
- U9:`conversation.content` 工厂嵌入非主区时是否仍工作(当前只接管 `main.conversation`,不涉及)。
- A06 全局默认模型是否被改动、A09 附件级引用、A25 手机抽屉、A27 键盘遍历。
---
## 6. 回退
代码回退用 Git,不建备份副本。注意:**回退代码不会自动回退业务数据**,
`%USERPROFILE%\.dsh\sansheng-liubu\workbench.json` 仍在;schema 变化要写显式迁移,不静默丢弃旧账本。

View File

@ -1,46 +0,0 @@
# 三省六部记忆设计(v2,0.12.0)
思路借鉴 DS Bot 的分层记忆(Bot 记忆 + 群记忆),但落在原生架构上、
按本项目一贯的隔离与记账规矩实现。不基于 DS Bot 构建(见 TODO.md 的否决记录)。
## 三层
| 层 | 文件 | 记什么 | 谁能读 |
|---|---|---|---|
| 部门记忆 | `~/.dsh/sansheng-liubu/memory/departments/<roleId>.md` | 这个部门自己摸出的经验,跟着部门跨项目 | 仅派给该部门的任务 |
| 项目记忆 | `~/.dsh/sansheng-liubu/memory/projects/<projectId>.md` | 这个项目发生过什么、结论是什么 | 仅本项目的派发 |
| 长期记忆 | `~/.dsh/sansheng-liubu/memory/long-term.md` | 用户偏好、长期有效的经验 | 所有项目的派发 |
项目之间互不可见。DS Bot 上游「Main Bot 可读写任意 Bot 记忆」的弱隔离
(归档分支 docs/p0 的 M-03 边界记录)不学。
## 怎么读(召回)
派发(dispatchTask)时,服务层把三层记忆的摘录并进上下文包的 excerpts:
部门记忆在前(主责部门自己那份,上限 2000 字)、项目记忆居中(上限 3000 字)、
长期记忆在后(上限 2000 字),超长截断并注明。
部门记忆只注入主责部门自己的那一份,别的部门的经验本不外借。
摘录随上下文包落账,事后可查「当时到底把哪段记忆发给了部门」。
记忆读失败不拦派发——记忆是参考资料,不是业务前置条件。
## 怎么写
1. **成果自动记账**:新成果汇报落账后记两行——项目记忆里一行
「<部门> 汇报成果(任务「<标题>」):<摘要>」,主责部门自己的部门记忆里
一行「在项目「<项目名>」汇报成果(任务「<标题>」):<摘要>」,都带日期小节。
重复汇报(幂等命中)不重复记;写失败不影响成果本身。
2. **接口读写**:POST `/sansheng/workbench/memory/get|put|append`
(scope = long-term | project | department;project 需带 projectId 且项目
必须存在,department 需带合法的 roleId)。
3. **手工编辑**:文件就是 Markdown,用户可直接打开改;程序写走
临时文件 + rename,不写半截。
## 上限与整理
单个记忆文件上限 64K 字符:写满会明确报错,要求先整理再写——
记忆要短而精,不是聊天记录的倾倒场。聊天正文仍由 DSH 会话保存,账本与记忆都不复制。
## 本版没做(后续)
- 工作台面板里的记忆查看/编辑界面(先用接口与文件)。
- 由模型自动提炼记忆(把流水账总结成条目)——v1 只有确定性记账,不引入额外模型调用。

View File

@ -1,13 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128" role="img" aria-label="三省六部">
<defs>
<linearGradient id="g" x1="0" y1="0" x2="1" y2="1">
<stop offset="0" stop-color="#9b6b2f"/>
<stop offset="1" stop-color="#5f351b"/>
</linearGradient>
</defs>
<rect x="10" y="14" width="108" height="100" rx="18" fill="url(#g)"/>
<path d="M31 45h66M39 61h50M47 77h34" fill="none" stroke="#f7e5b7" stroke-width="7" stroke-linecap="round"/>
<circle cx="31" cy="94" r="7" fill="#f7e5b7"/>
<circle cx="64" cy="94" r="7" fill="#f7e5b7"/>
<circle cx="97" cy="94" r="7" fill="#f7e5b7"/>
</svg>

Before

Width:  |  Height:  |  Size: 626 B

View File

@ -1,59 +1,46 @@
// 三省六部工作台 · 宿主入口。
//
// 0.11.0 起老预设线退役:不再有「上朝」模式、Team 政策插件与朝堂侧栏。
// 本入口只做一件事——在应用根上把工作台宿主拉起来(账本、HTTP 接口、
// 会话装配、记忆都在 workbench/host 里),插件卸载时把它停掉。
// 工作台宿主自身对缺失能力一律降级并给出 warnings,所以这里不预检、
// 不抛错:工作台起不来不该拖垮整个应用。
//
// 防重复启动:宿主只该有一份。若本插件被重复应用(例如旧预设段还留在
// profile 里、按会话重复挂载),后来的应用只增加引用计数,不再另起一份
// 宿主——两份宿主会重复注册路由、双写同一本账本。用 Symbol.for 注册到
// globalThis,是为了连「包被复制成两份、模块身份不同」的情况也拦得住。
// 三省六部宿主插件入口:只使用宿主公开注入服务,不 patch DSH,不写 profile 全局默认。
import { SanshengStore } from './src/host/store.js'
import { createProvisioner } from './src/host/provision.js'
import { SanshengService } from './src/host/service.js'
import { createApiHandler } from './src/host/api.js'
import { installPromptSection } from './src/host/prompt.js'
import { sanshengStatePath } from './src/host/paths.js'
import { ROUTE } from './src/host/constants.js'
import { createWorkbenchHost } from './workbench/host/index.mjs'
export const name = 'sansheng'
export const inject = ['workspaceRegistry', 'sessionController', 'agents', 'llm', 'systemPrompt', 'connection']
export const name = 'sansheng-liubu-workbench-host'
export function apply(ctx, config = {}) {
const store = new SanshengStore(
typeof config.statePath === 'string' && config.statePath !== '' ? config.statePath : sanshengStatePath(config.home),
)
// apply 必须同步返回(cordis 把异步/非函数返回值当非法 effect);状态在首次请求时惰性读入。
void store.ensureLoaded().catch(error => {
console.warn(`sansheng: ${error?.message ?? error}`)
})
const BOOT_KEY = Symbol.for('sansheng-liubu.workbench-host')
function release(entry) {
entry.refs -= 1
if (entry.refs > 0) return
if (globalThis[BOOT_KEY] === entry) delete globalThis[BOOT_KEY]
try {
entry.host.dispose()
} catch {
// 卸载失败不影响插件卸载;下次启动仍会从同一个账本继续。
const host = {
workspaceRegistry: ctx.workspaceRegistry,
sessionController: ctx.sessionController,
agents: ctx.agents,
llm: ctx.llm,
}
}
export function apply(ctx) {
if (ctx === null || ctx === undefined) return undefined
const existing = globalThis[BOOT_KEY]
if (existing !== undefined) {
existing.refs += 1
return () => release(existing)
}
let host = null
try {
host = createWorkbenchHost(ctx?.root ?? ctx, {})
} catch (error) {
try {
ctx?.logger?.info?.(`[sansheng-liubo] 工作台启动失败:${error?.message ?? error}`)
} catch {
// 日志失败不能影响应用启动。
}
return undefined
}
for (const warning of host.warnings ?? []) {
try {
ctx?.logger?.info?.(`[sansheng-liubo] ${warning}`)
} catch {
// 同上。
}
}
const entry = { host, refs: 1 }
globalThis[BOOT_KEY] = entry
return () => release(entry)
const provisioner = createProvisioner({ store, host })
const service = new SanshengService({ store, host, provisioner })
const handle = createApiHandler(service)
ctx.effect(() => installPromptSection(ctx, { store }), 'sansheng: prompt section')
// 复用宿主共享 /api 通道;浏览器带会话 Cookie 认证。
ctx.effect(() => ctx.connection.fetch.register({
path: ROUTE,
methods: ['POST'],
requestBody: 'buffered',
fetch: async request => {
let body
try { body = await request.json() } catch { body = {} }
const result = await handle(String(body?.endpoint ?? ''), body?.payload)
return new Response(JSON.stringify(result), { status: 200, headers: { 'content-type': 'application/json' } })
},
}), 'sansheng: api route')
}

View File

@ -1,42 +1,52 @@
{
"name": "dsh-sansheng-liubu-mode",
"version": "0.14.0",
"description": "三省六部工作台:十席独立会话、项目账本、派工与分层记忆",
"name": "dsh-sansheng-liubu",
"version": "0.3.1",
"description": "三省六部:每个项目固定十席角色与独立会话的 DSH 插件(第一版)。",
"keywords": [
"dsh-plugin",
"deepseek-harness",
"dsh",
"sansheng",
"multi-agent",
"agents"
],
"license": "Apache-2.0",
"type": "module",
"main": "./index.js",
"main": "index.js",
"exports": {
".": "./index.js",
"./package.json": "./package.json",
"./client": "./workbench/panel/lib/client.js"
"./client": "./client.js",
"./package.json": "./package.json"
},
"files": [
"index.js",
"client.js",
"src/",
"cordis.patch.yml",
"icon.svg",
"README.md",
"CHANGELOG.md",
"scripts",
"workbench"
"README.md"
],
"icon": "./icon.svg",
"scripts": {
"build": "node scripts/build-client.mjs",
"build:check": "node scripts/build-client.mjs --check",
"test": "node --test --test-timeout=120000 \"test/*.test.js\""
},
"peerDependencies": {
"@deepseek-ai/cordis": "*",
"@deepseek-ai/dsh-llm": "*",
"@deepseek-ai/dsh-web": "*"
},
"dsh": {
"manifestVersion": 1,
"bundle": {
"patch": "./cordis.patch.yml"
},
"client": {
"platform": "web",
"inject": [
"@deepseek-ai/dsh-api-session-controller",
"@deepseek-ai/dsh-client-ui-workspace",
"@deepseek-ai/dsh-client-ui-primitives"
]
},
"bundle": {
"patch": "./cordis.patch.yml"
}
},
"scripts": {
"test": "node --test --test-isolation=none workbench/test/*.test.mjs workbench/panel/test/client.test.mjs",
"workbench:preflight": "node scripts/workbench-preflight.mjs",
"preview:workbench": "node scripts/preview-workbench.mjs"
},
"license": "MIT"
"devDependencies": {
"esbuild": "0.28.2"
}
}

407
pnpm-lock.yaml Normal file
View File

@ -0,0 +1,407 @@
lockfileVersion: '9.0'
settings:
autoInstallPeers: true
excludeLinksFromLockfile: false
importers:
.:
dependencies:
'@deepseek-ai/cordis':
specifier: '*'
version: 4.1.0
'@deepseek-ai/dsh-llm':
specifier: '*'
version: 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-attachment@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))(@deepseek-ai/dsh-timeout@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))
'@deepseek-ai/dsh-web':
specifier: '*'
version: 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))(@deepseek-ai/dsh-llm@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-attachment@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))(@deepseek-ai/dsh-timeout@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))))
devDependencies:
esbuild:
specifier: 0.28.2
version: 0.28.2
packages:
'@deepseek-ai/cordis@4.1.0':
resolution: {integrity: sha512-CJrjNyBkKn1SfvBQUcgFYKFnLjS+uKrhdMsbHU60xabvi12d+xQ+IQSNlME5Z+B+4Zi6n4BDknKY94tEPeo47w==}
hasBin: true
peerDependencies:
'@deepseek-ai/cordis-plugin-include': ~1.1.0
'@deepseek-ai/cordis-plugin-loader': ~1.1.0
peerDependenciesMeta:
'@deepseek-ai/cordis-plugin-include':
optional: true
'@deepseek-ai/cordis-plugin-loader':
optional: true
'@deepseek-ai/cosmokit@1.9.0':
resolution: {integrity: sha512-5O1S53mZiJyZYcvxxD0Qv1EY7qFPSxbGyD8CbVK6gw7W9FvcXZj2YIX1ZkOqyQQ3Xt2rFkZDHJv0+V3Zmmp8CA==}
'@deepseek-ai/dsh-attachment@0.0.1-rc.1':
resolution: {integrity: sha512-zBBw6h+YKOf7U8uEZezbFUjLsA8VU1GfCIUonAZHG2hWDWhWbrGaoO9fL8KyncEDSWMLMoIoGo+ZxDEPVJZYOA==}
peerDependencies:
'@deepseek-ai/cordis': ^4.0.1-rc.1
'@deepseek-ai/dsh-brand': ^0.0.1-rc.1
'@deepseek-ai/dsh-invariants': ^0.0.1-rc.1
'@deepseek-ai/dsh-brand@0.0.1-rc.1':
resolution: {integrity: sha512-XhwNAugG/baCVA+BMMvjihYi9XMLcDUew3G63i+ATWIZCvpx8CghbgcV93DEeMH2sqhNuQAssmHgXkpRld3gyQ==}
peerDependencies:
'@deepseek-ai/cordis': ^4.0.1-rc.1
'@deepseek-ai/dsh-invariants': ^0.0.1-rc.1
'@deepseek-ai/dsh-invariants@0.0.1-rc.1':
resolution: {integrity: sha512-ZoGCGColviu3Tkdnv9hMkgBE4eg0hAz5GXR/knqRf7mJUeBlTCya2dIckYlqekYmp5L+1AeWxf9j+Lv1YRcvXw==}
peerDependencies:
'@deepseek-ai/cordis': ^4.0.1-rc.1
'@deepseek-ai/dsh-llm@0.0.1-rc.1':
resolution: {integrity: sha512-mRJj07IQNfRReGrhpMpL8AONiYKqfwzxvepg/ut9Wkj8oH2BuoftPS4cMnnXFFCUlYql04/sezwDLriYks/bmw==}
peerDependencies:
'@deepseek-ai/cordis': ^4.0.1-rc.1
'@deepseek-ai/dsh-attachment': ^0.0.1-rc.1
'@deepseek-ai/dsh-brand': ^0.0.1-rc.1
'@deepseek-ai/dsh-invariants': ^0.0.1-rc.1
'@deepseek-ai/dsh-timeout': ^0.0.1-rc.1
'@deepseek-ai/dsh-timeout@0.0.1-rc.1':
resolution: {integrity: sha512-lIMhY/JqA+eLpXXUN33xA7mlAYeHTDTWfcJ3CmEtplvGnvpDAHQ6oPeFs9JtWcfKbuNDZFMNutyhD0qoRkFQeg==}
peerDependencies:
'@deepseek-ai/cordis': ^4.0.1-rc.1
'@deepseek-ai/dsh-invariants': ^0.0.1-rc.1
'@deepseek-ai/dsh-web@0.0.1-rc.1':
resolution: {integrity: sha512-kbfr8aPtbsO9XOYqbdy39HwLPlVDH3GWjg9J2cJge5jgGPfN0lGlh5hcj4wvHxUEhGOZF+vieR/U8NmzeaeZMw==}
peerDependencies:
'@deepseek-ai/cordis': ^4.0.1-rc.1
'@deepseek-ai/dsh-invariants': ^0.0.1-rc.1
'@deepseek-ai/dsh-llm': ^0.0.1-rc.1
'@deepseek-ai/schemastery@3.19.0':
resolution: {integrity: sha512-bDXoYQa7ghAhmdYD5VPlzKxEzJV/aKkz5l4V5h1u06z8GAPN1ROewSjvR9WiXhpa52E9fng8lpH5QdCRIQgnyQ==}
'@esbuild/aix-ppc64@0.28.2':
resolution: {integrity: sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==}
engines: {node: '>=18'}
cpu: [ppc64]
os: [aix]
'@esbuild/android-arm64@0.28.2':
resolution: {integrity: sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==}
engines: {node: '>=18'}
cpu: [arm64]
os: [android]
'@esbuild/android-arm@0.28.2':
resolution: {integrity: sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==}
engines: {node: '>=18'}
cpu: [arm]
os: [android]
'@esbuild/android-x64@0.28.2':
resolution: {integrity: sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==}
engines: {node: '>=18'}
cpu: [x64]
os: [android]
'@esbuild/darwin-arm64@0.28.2':
resolution: {integrity: sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==}
engines: {node: '>=18'}
cpu: [arm64]
os: [darwin]
'@esbuild/darwin-x64@0.28.2':
resolution: {integrity: sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==}
engines: {node: '>=18'}
cpu: [x64]
os: [darwin]
'@esbuild/freebsd-arm64@0.28.2':
resolution: {integrity: sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==}
engines: {node: '>=18'}
cpu: [arm64]
os: [freebsd]
'@esbuild/freebsd-x64@0.28.2':
resolution: {integrity: sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==}
engines: {node: '>=18'}
cpu: [x64]
os: [freebsd]
'@esbuild/linux-arm64@0.28.2':
resolution: {integrity: sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==}
engines: {node: '>=18'}
cpu: [arm64]
os: [linux]
'@esbuild/linux-arm@0.28.2':
resolution: {integrity: sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==}
engines: {node: '>=18'}
cpu: [arm]
os: [linux]
'@esbuild/linux-ia32@0.28.2':
resolution: {integrity: sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==}
engines: {node: '>=18'}
cpu: [ia32]
os: [linux]
'@esbuild/linux-loong64@0.28.2':
resolution: {integrity: sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==}
engines: {node: '>=18'}
cpu: [loong64]
os: [linux]
'@esbuild/linux-mips64el@0.28.2':
resolution: {integrity: sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==}
engines: {node: '>=18'}
cpu: [mips64el]
os: [linux]
'@esbuild/linux-ppc64@0.28.2':
resolution: {integrity: sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==}
engines: {node: '>=18'}
cpu: [ppc64]
os: [linux]
'@esbuild/linux-riscv64@0.28.2':
resolution: {integrity: sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==}
engines: {node: '>=18'}
cpu: [riscv64]
os: [linux]
'@esbuild/linux-s390x@0.28.2':
resolution: {integrity: sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==}
engines: {node: '>=18'}
cpu: [s390x]
os: [linux]
'@esbuild/linux-x64@0.28.2':
resolution: {integrity: sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==}
engines: {node: '>=18'}
cpu: [x64]
os: [linux]
'@esbuild/netbsd-arm64@0.28.2':
resolution: {integrity: sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==}
engines: {node: '>=18'}
cpu: [arm64]
os: [netbsd]
'@esbuild/netbsd-x64@0.28.2':
resolution: {integrity: sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==}
engines: {node: '>=18'}
cpu: [x64]
os: [netbsd]
'@esbuild/openbsd-arm64@0.28.2':
resolution: {integrity: sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==}
engines: {node: '>=18'}
cpu: [arm64]
os: [openbsd]
'@esbuild/openbsd-x64@0.28.2':
resolution: {integrity: sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==}
engines: {node: '>=18'}
cpu: [x64]
os: [openbsd]
'@esbuild/openharmony-arm64@0.28.2':
resolution: {integrity: sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==}
engines: {node: '>=18'}
cpu: [arm64]
os: [openharmony]
'@esbuild/sunos-x64@0.28.2':
resolution: {integrity: sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==}
engines: {node: '>=18'}
cpu: [x64]
os: [sunos]
'@esbuild/win32-arm64@0.28.2':
resolution: {integrity: sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==}
engines: {node: '>=18'}
cpu: [arm64]
os: [win32]
'@esbuild/win32-ia32@0.28.2':
resolution: {integrity: sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==}
engines: {node: '>=18'}
cpu: [ia32]
os: [win32]
'@esbuild/win32-x64@0.28.2':
resolution: {integrity: sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==}
engines: {node: '>=18'}
cpu: [x64]
os: [win32]
'@standard-schema/spec@1.1.0':
resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
esbuild@0.28.2:
resolution: {integrity: sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==}
engines: {node: '>=18'}
hasBin: true
snapshots:
'@deepseek-ai/cordis@4.1.0':
dependencies:
'@deepseek-ai/cosmokit': 1.9.0
'@standard-schema/spec': 1.1.0
'@deepseek-ai/cosmokit@1.9.0': {}
'@deepseek-ai/dsh-attachment@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))':
dependencies:
'@deepseek-ai/cordis': 4.1.0
'@deepseek-ai/dsh-brand': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))
'@deepseek-ai/dsh-invariants': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)
'@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))':
dependencies:
'@deepseek-ai/cordis': 4.1.0
'@deepseek-ai/dsh-invariants': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)
'@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)':
dependencies:
'@deepseek-ai/cordis': 4.1.0
'@deepseek-ai/schemastery': 3.19.0
'@deepseek-ai/dsh-llm@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-attachment@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))(@deepseek-ai/dsh-timeout@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))':
dependencies:
'@deepseek-ai/cordis': 4.1.0
'@deepseek-ai/dsh-attachment': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))
'@deepseek-ai/dsh-brand': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))
'@deepseek-ai/dsh-invariants': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)
'@deepseek-ai/dsh-timeout': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))
'@deepseek-ai/schemastery': 3.19.0
'@deepseek-ai/dsh-timeout@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))':
dependencies:
'@deepseek-ai/cordis': 4.1.0
'@deepseek-ai/dsh-invariants': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)
'@deepseek-ai/dsh-web@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))(@deepseek-ai/dsh-llm@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-attachment@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))(@deepseek-ai/dsh-timeout@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))))':
dependencies:
'@deepseek-ai/cordis': 4.1.0
'@deepseek-ai/dsh-invariants': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)
'@deepseek-ai/dsh-llm': 0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-attachment@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-brand@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0))(@deepseek-ai/dsh-timeout@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)(@deepseek-ai/dsh-invariants@0.0.1-rc.1(@deepseek-ai/cordis@4.1.0)))
'@deepseek-ai/schemastery': 3.19.0
'@deepseek-ai/schemastery@3.19.0':
dependencies:
'@deepseek-ai/cosmokit': 1.9.0
'@standard-schema/spec': 1.1.0
'@esbuild/aix-ppc64@0.28.2':
optional: true
'@esbuild/android-arm64@0.28.2':
optional: true
'@esbuild/android-arm@0.28.2':
optional: true
'@esbuild/android-x64@0.28.2':
optional: true
'@esbuild/darwin-arm64@0.28.2':
optional: true
'@esbuild/darwin-x64@0.28.2':
optional: true
'@esbuild/freebsd-arm64@0.28.2':
optional: true
'@esbuild/freebsd-x64@0.28.2':
optional: true
'@esbuild/linux-arm64@0.28.2':
optional: true
'@esbuild/linux-arm@0.28.2':
optional: true
'@esbuild/linux-ia32@0.28.2':
optional: true
'@esbuild/linux-loong64@0.28.2':
optional: true
'@esbuild/linux-mips64el@0.28.2':
optional: true
'@esbuild/linux-ppc64@0.28.2':
optional: true
'@esbuild/linux-riscv64@0.28.2':
optional: true
'@esbuild/linux-s390x@0.28.2':
optional: true
'@esbuild/linux-x64@0.28.2':
optional: true
'@esbuild/netbsd-arm64@0.28.2':
optional: true
'@esbuild/netbsd-x64@0.28.2':
optional: true
'@esbuild/openbsd-arm64@0.28.2':
optional: true
'@esbuild/openbsd-x64@0.28.2':
optional: true
'@esbuild/openharmony-arm64@0.28.2':
optional: true
'@esbuild/sunos-x64@0.28.2':
optional: true
'@esbuild/win32-arm64@0.28.2':
optional: true
'@esbuild/win32-ia32@0.28.2':
optional: true
'@esbuild/win32-x64@0.28.2':
optional: true
'@standard-schema/spec@1.1.0': {}
esbuild@0.28.2:
optionalDependencies:
'@esbuild/aix-ppc64': 0.28.2
'@esbuild/android-arm': 0.28.2
'@esbuild/android-arm64': 0.28.2
'@esbuild/android-x64': 0.28.2
'@esbuild/darwin-arm64': 0.28.2
'@esbuild/darwin-x64': 0.28.2
'@esbuild/freebsd-arm64': 0.28.2
'@esbuild/freebsd-x64': 0.28.2
'@esbuild/linux-arm': 0.28.2
'@esbuild/linux-arm64': 0.28.2
'@esbuild/linux-ia32': 0.28.2
'@esbuild/linux-loong64': 0.28.2
'@esbuild/linux-mips64el': 0.28.2
'@esbuild/linux-ppc64': 0.28.2
'@esbuild/linux-riscv64': 0.28.2
'@esbuild/linux-s390x': 0.28.2
'@esbuild/linux-x64': 0.28.2
'@esbuild/netbsd-arm64': 0.28.2
'@esbuild/netbsd-x64': 0.28.2
'@esbuild/openbsd-arm64': 0.28.2
'@esbuild/openbsd-x64': 0.28.2
'@esbuild/openharmony-arm64': 0.28.2
'@esbuild/sunos-x64': 0.28.2
'@esbuild/win32-arm64': 0.28.2
'@esbuild/win32-ia32': 0.28.2
'@esbuild/win32-x64': 0.28.2

57
scripts/build-client.mjs Normal file
View File

@ -0,0 +1,57 @@
// Builds client.js (browser half) from src/client. Mirrors the DS Bot wrapper so dsh can
// load it as a classic script and resolve platform modules from the shell.
// node scripts/build-client.mjs writes client.js
// node scripts/build-client.mjs --check exit 1 if client.js differs from a fresh build
import { readFileSync, writeFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'
const PLUGIN = dirname(dirname(fileURLToPath(import.meta.url)))
const OUTPUT = join(PLUGIN, 'client.js')
const PLATFORM_MODULES = ['react', 'react-dom', '@deepseek-ai/dsh-client-ui-primitives']
export async function bundleClient() {
let esbuild
try { esbuild = await import('esbuild') } catch {
throw new Error('缺少 esbuild:请先在包内安装 devDependencies(pnpm/npm i),再构建 client.js。')
}
const result = await esbuild.build({
absWorkingDir: PLUGIN,
entryPoints: ['src/client/index.js'],
bundle: true,
format: 'cjs',
platform: 'browser',
target: 'es2022',
external: PLATFORM_MODULES,
treeShaking: false,
charset: 'utf8',
write: false,
logLevel: 'silent',
})
if (result.warnings.length > 0) throw new Error('esbuild warnings:\n' + result.warnings.map(w => w.text).join('\n'))
return [
'// Generated from src/client by `npm run build` (scripts/build-client.mjs). Do not edit by hand.',
'window.__ModuleLoader__.load({',
" id: 'dsh-sansheng-liubu',",
' factory: (require) => {',
'const module = { exports: {} }',
result.outputFiles[0].text.trimEnd(),
"return Object.defineProperty({ ...module.exports }, Symbol.toStringTag, { value: 'Module' })",
' },',
'})',
'',
].join('\n')
}
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const next = await bundleClient()
if (process.argv.includes('--check')) {
let current = ''
try { current = readFileSync(OUTPUT, 'utf8') } catch {}
if (current !== next) { console.error('client.js 与 src/client 不一致,请运行 npm run build'); process.exit(1) }
console.log('client.js 是最新的')
} else {
writeFileSync(OUTPUT, next)
console.log('已写出 client.js')
}
}

File diff suppressed because it is too large Load Diff

View File

@ -1,17 +0,0 @@
#!/usr/bin/env node
// 退役说明(0.13.0+):朝堂面板已并回主包 `dsh-sansheng-liubu-mode`。
// 本脚本不再安装、卸载或改写任何 profile 文件,只打印迁移说明。
//
// 安装/修复/迁移是独立授权操作;自检请用 `node scripts/workbench-preflight.mjs`。
console.error([
'dsh-sansheng-liubu-workbench 已退役:面板已并回主包 dsh-sansheng-liubu-mode。',
'不要再安装或启用独立的 workbench 包,也不需要再运行本脚本的 on/off。',
'迁移:',
' 1. 从 profile 的 dependencies / dsh.profile.bundles 中移除 dsh-sansheng-liubu-workbench(若存在);',
' 2. 安装或更新 dsh-sansheng-liubu-mode;',
' 3. 彻底退出并重启 DSH;',
' 4. 运行 node scripts/workbench-preflight.mjs 做严格只读自检。',
'本脚本不会改动任何文件。',
].join('\n'))
process.exitCode = 2

View File

@ -1,113 +0,0 @@
// 重启前自检:严格只读,不创建、覆盖或迁移任何用户文件。
//
// 0.13.0 起朝堂面板已并回主包 `dsh-sansheng-liubu-mode`,不再有独立的
// `dsh-sansheng-liubu-workbench` 安装包。自检只回答“当前这份包能不能在
// 宿主上正常加载”,安装/修复/迁移是另外的显式操作,不混在这里。
//
// 用法:node scripts/workbench-preflight.mjs
// 退出码:0 全通;1 有失败项(打印哪一项失败、为什么)。
import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import vm from 'node:vm'
import { createWorkbenchHost } from '../workbench/host/index.mjs'
import { WorkbenchStore } from '../workbench/core/store.mjs'
const PACKAGE_NAME = 'dsh-sansheng-liubu-mode'
const PACKAGE_ROOT = path.resolve(import.meta.dirname, '..')
const results = []
function check(name, run) {
try {
const detail = run()
results.push({ name, ok: true, detail })
} catch (error) {
results.push({ name, ok: false, detail: error?.message ?? String(error) })
}
}
function dshHome(env = process.env) {
const value = typeof env.DSH_HOME === 'string' && env.DSH_HOME.trim() ? env.DSH_HOME.trim() : ''
return value === '' ? path.join(os.homedir(), '.dsh') : value
}
let packageJson = null
check('读取本包 package.json', () => {
const file = path.join(PACKAGE_ROOT, 'package.json')
packageJson = JSON.parse(fs.readFileSync(file, 'utf8'))
if (packageJson.name !== PACKAGE_NAME) {
throw new Error(`包名是 ${packageJson.name},预期 ${PACKAGE_NAME}`)
}
return `${packageJson.name} ${packageJson.version}`
})
let entryFile = null
check('面板客户端入口存在且属于主包', () => {
const exported = packageJson?.exports?.['./client']
const rel = typeof exported === 'string' ? exported : exported?.default
if (typeof rel !== 'string') throw new Error('package.json 没有 exports["./client"]')
entryFile = path.join(PACKAGE_ROOT, rel)
const size = fs.statSync(entryFile).size
if (size < 1024) throw new Error(`入口文件过小(${size} 字节),可能是空壳`)
return `${path.relative(PACKAGE_ROOT, entryFile)} · ${size} 字节`
})
check('客户端 bundle 语法可解析(语法错会让整页白屏)', () => {
if (entryFile === null) throw new Error('上一个检查没通过,跳过')
const text = fs.readFileSync(entryFile, 'utf8')
if (!text.includes('__ModuleLoader__')) throw new Error('入口不像 DSH 客户端 bundle(缺少 __ModuleLoader__)')
if (!text.includes(PACKAGE_NAME)) throw new Error(`入口里没有主包 id ${PACKAGE_NAME}`)
// 只解析不执行:能抓住未闭合括号、非法 token 这类致命错误。
new vm.Script(text, { filename: entryFile })
return `${Math.round(text.length / 1024)} KB`
})
check('Host 侧装配:内存账本上能起 16 条路由', () => {
const routes = new Map()
const fakeCtx = {
get: () => undefined,
webServer: {
register(route) {
routes.set(route.path, route)
return () => routes.delete(route.path)
},
},
}
const store = new WorkbenchStore({ file: null })
const host = createWorkbenchHost(fakeCtx, { store, startReconciler: false, load: false })
try {
if (routes.size !== 16) throw new Error(`注册了 ${routes.size} 条路由,预期 16 条`)
// bootstrap 要落在具体项目上才有席位;这里现建一个临时项目,不写磁盘。
const project = host.service.registerProject({ hostWorkspaceId: 'preflight' }).project
const boot = host.service.bootstrap(project.id)
if (!Array.isArray(boot.seats) || boot.seats.length !== 10) throw new Error('bootstrap 没有给出十席')
return `${routes.size} 条路由 · 十席就位`
} finally {
host.dispose()
}
})
check('账本落点可写(只做 access 检查,不创建文件)', () => {
const dir = path.join(dshHome(), 'sansheng-liubu')
// 从目标目录向上找第一个真实存在的父目录;只检查写权限,不创建目录或文件。
let probe = dir
for (;;) {
if (fs.existsSync(probe)) break
const parent = path.dirname(probe)
if (parent === probe) throw new Error(`找不到可检查的父目录:${dir}`)
probe = parent
}
fs.accessSync(probe, fs.constants.W_OK)
return `${dir}(自上而下检查到 ${probe})`
})
let failed = 0
for (const row of results) {
const mark = row.ok ? 'PASS' : 'FAIL'
if (!row.ok) failed += 1
process.stdout.write(`[${mark}] ${row.name}${row.detail ? ` — ${row.detail}` : ''}\n`)
}
process.stdout.write(`\n${results.length - failed}/${results.length} 通过\n`)
if (failed > 0) process.exitCode = 1

889
src/client/index.js Normal file
View File

@ -0,0 +1,889 @@
// 三省六部 Web 插件入口:左侧追加「三省六部」入口,点开右侧工作台。
// 所有对宿主可选服务的调用都用 ctx.get(...) 特性探测,探测不到就降级,不伪造接口。
import { createElement as h, Fragment, useCallback, useEffect, useMemo, useRef, useState } from 'react'
import { createPortal } from 'react-dom'
import { SEAT_IDS, SEATS } from '../shared/roles.js'
import {
buildWorkbenchView,
findModelOption,
updateDraft,
clearDraft,
UNCHOSEN_MODEL_LABEL,
} from './workbench.js'
import { request } from './transport.js'
import { CSS as WORKBENCH_CSS } from './styles.js'
import { install as installNativePanel } from '../native/index.js'
export const inject = ['sessions', 'uiWorkspace', 'uiConversation', 'slots', 'theme', 'layout']
const PLUGIN_ID = 'dsh-sansheng'
const TAB_KIND = 'sansheng-workbench'
const TAB_TYPE_ID = 'dsh-sansheng:workbench'
function installStyles(doc, tag, text) {
if (!doc || !doc.head) return null
const style = doc.createElement('style')
// 带上插件 id,避免被 ClientModuleSystem 当作别人的模块样式回收。
style.dataset.plugin = PLUGIN_ID
style.dataset.sansheng = tag
style.textContent = text
doc.head.appendChild(style)
return style
}
// ---------- 小图标(createElement,无 JSX) ----------
function svgWrap(children, props) {
return h('svg', {
viewBox: '0 0 24 24', width: 16, height: 16, fill: 'none', stroke: 'currentColor',
strokeWidth: 1.6, strokeLinecap: 'round', strokeLinejoin: 'round', 'aria-hidden': 'true',
...(props || {}),
}, children)
}
const TreeIcon = (props) => svgWrap([
h('rect', { key: 'a', x: 9, y: 2, width: 6, height: 5, rx: 1 }),
h('path', { key: 'b', d: 'M12 7v5M5 16v-4h14v4' }),
h('rect', { key: 'c', x: 2, y: 16, width: 6, height: 5, rx: 1 }),
h('rect', { key: 'd', x: 16, y: 16, width: 6, height: 5, rx: 1 }),
], props)
const CloseIcon = (props) => svgWrap([h('path', { key: 'p', d: 'm6 6 12 12M6 18 18 6' })], props)
const FolderIcon = (props) => svgWrap([h('path', { key: 'p', d: 'M3 7V5a2 2 0 0 1 2-2h5l2 3h7a2 2 0 0 1 2 2v11H3Z' })], props)
const GearIcon = (props) => svgWrap([
h('path', { key: 'a', d: 'M4 6h16M4 12h16M4 18h16' }),
h('circle', { key: 'b', cx: 9, cy: 6, r: 2 }),
h('circle', { key: 'c', cx: 16, cy: 12, r: 2 }),
h('circle', { key: 'd', cx: 8, cy: 18, r: 2 }),
], props)
const ChevronIcon = (props) => h('svg', {
viewBox: '0 0 24 24', width: 14, height: 14, fill: 'none', stroke: 'currentColor',
strokeWidth: 1.6, strokeLinecap: 'round', strokeLinejoin: 'round',
className: 'ssw-chevron', 'aria-hidden': 'true',
}, h('path', { d: 'm6 9 6 6 6-6' }))
// 每个席位一个简单线性图标,沿用外观方案的“图标 + 两字名称 + 状态点”卡片。
const SEAT_ICON_PATHS = {
lead: ['M12 12a4 4 0 1 0 0-8 4 4 0 0 0 0 8Z', 'M4.5 20c0-3.2 3.4-5 7.5-5s7.5 1.8 7.5 5'],
zhongshu: ['M7 3h7l4 4v14H7z', 'M14 3v4h4', 'M9.5 12h5', 'M9.5 16h5'],
shangshu: ['M4 4h6.5v6.5H4z', 'M13.5 4H20v6.5h-6.5z', 'M4 13.5h6.5V20H4z', 'M13.5 13.5H20V20h-6.5z'],
menxia: ['M12 3l7 3v6c0 4-3 7-7 9-4-2-7-5-7-9V6z', 'm9 12 2 2 4-4'],
libu: ['M12 11a3.5 3.5 0 1 0 0-7 3.5 3.5 0 0 0 0 7Z', 'M5 20c0-3 3-4.5 7-4.5s7 1.5 7 4.5'],
hubu: ['M4 5h16v14H4z', 'M4 10h16', 'M10 5v14'],
lipu: ['M7 3h10v18H7z', 'M10 8h4', 'M10 12h4', 'M10 16h4'],
bingbu: ['M4 5h16v12H4z', 'm8 13 3-6 5 6', 'M4 20h16'],
xingbu: ['M6 3h12v18l-6-3-6 3z', 'm9 10 2 2 4-4'],
gongbu: ['m8 8-4 4 4 4', 'm16 8 4 4-4 4', 'M13 5l-2 14'],
}
function SeatIcon(props) {
const paths = SEAT_ICON_PATHS[props && props.id] ?? SEAT_ICON_PATHS.lead
return h('svg', {
viewBox: '0 0 24 24', width: 16, height: 16, fill: 'none', stroke: 'currentColor',
strokeWidth: 1.6, strokeLinecap: 'round', strokeLinejoin: 'round', 'aria-hidden': 'true',
className: 'ssw-seat-icon',
}, paths.map((d, index) => h('path', { key: index, d })))
}
function isFn(value) { return typeof value === 'function' }
function safeCall(obj, name) {
try {
if (!obj || !isFn(obj[name])) return undefined
return obj[name]()
} catch { return undefined }
}
function snapshotOf(obj) {
if (!obj) return undefined
if (isFn(obj.getSnapshot)) {
try { return obj.getSnapshot() } catch { return undefined }
}
return obj
}
export function apply(ctx) {
if (typeof document !== 'undefined') installStyles(document, 'workbench', WORKBENCH_CSS)
const get = (name) => { try { return ctx.get(name) } catch { return undefined } }
// ---------- 当前项目 / 工作区(特性探测,拿不到就提示用户先选项目) ----------
function workspaceItems() {
const fromWorkspaces = snapshotOf(get('workspaces')?.list)?.items
if (Array.isArray(fromWorkspaces)) return fromWorkspaces
const fromUi = snapshotOf(get('uiWorkspace')?.workspaces)?.items
if (Array.isArray(fromUi)) return fromUi
return []
}
function normalizeWorkspace(item) {
if (!item || typeof item !== 'object') return null
const workspaceId = item.workspaceId ?? item.id ?? null
if (typeof workspaceId !== 'string' || !workspaceId) return null
return {
workspaceId,
name: typeof item.name === 'string' ? item.name : (typeof item.title === 'string' ? item.title : undefined),
path: typeof item.path === 'string' ? item.path : undefined,
}
}
function currentSessionId() {
const snap = snapshotOf(get('sessions')?.list) ?? snapshotOf(get('sessions'))
if (!snap || typeof snap !== 'object') return null
for (const key of ['activeId', 'currentId', 'selectedId']) {
if (typeof snap[key] === 'string' && snap[key]) return snap[key]
}
if (snap.byId && typeof snap.byId === 'object') {
const main = Object.values(snap.byId).find(session => (session?.retainedBy?.mainView ?? 0) > 0)
if (main && typeof main.id === 'string') return main.id
}
return null
}
function currentWorkspaceId() {
const candidates = []
for (const holder of [get('workspaces'), get('uiWorkspace')]) {
if (!holder) continue
for (const key of ['currentWorkspaceId', 'currentId', 'activeId']) {
if (isFn(holder[key])) candidates.push(safeCall(holder, key))
else if (typeof holder[key] === 'string') candidates.push(holder[key])
}
for (const key of ['current', 'active', 'selected', 'currentWorkspace']) {
const value = holder[key]
const snap = snapshotOf(value)
if (snap && typeof snap === 'object') candidates.push(snap.workspaceId ?? snap.id)
else if (typeof value === 'string') candidates.push(value)
}
}
const sessionId = currentSessionId()
if (sessionId) {
const owner = workspaceItems().find(item => Array.isArray(item.sessionIds) && item.sessionIds.includes(sessionId))
if (owner) candidates.push(owner.workspaceId ?? owner.id)
}
return candidates.find(id => typeof id === 'string' && id) ?? null
}
function currentWorkspace() {
const items = workspaceItems().map(normalizeWorkspace).filter(Boolean)
const id = currentWorkspaceId()
if (id) {
const hit = items.find(item => item.workspaceId === id)
return hit || { workspaceId: id, name: undefined, path: undefined }
}
if (items.length === 1) return items[0]
return null
}
function seatRecordOf(view, id) {
const seats = view && view.project ? view.project.seats : null
if (Array.isArray(seats)) return seats.find(seat => seat && seat.id === id) || null
if (seats && typeof seats === 'object') return seats[id] || null
return null
}
// ---------- 会话导航(特性探测;拿不到只发意图并 console.warn) ----------
function navigateToSession(sessionId) {
if (!sessionId) return false
const attempts = []
const ui = get('uiWorkspace')
if (ui) {
if (isFn(ui.openSession)) attempts.push(() => ui.openSession(sessionId))
if (isFn(ui.open)) attempts.push(() => ui.open(sessionId))
}
const sessions = get('sessions')
if (sessions) {
if (isFn(sessions.open)) attempts.push(() => sessions.open(sessionId))
if (isFn(sessions.openSession)) attempts.push(() => sessions.openSession(sessionId))
if (isFn(sessions.select)) attempts.push(() => sessions.select(sessionId))
}
for (const name of ['navigation', 'navigator', 'router']) {
const svc = get(name)
if (!svc) continue
if (isFn(svc.openSession)) attempts.push(() => svc.openSession(sessionId))
if (isFn(svc.navigate)) attempts.push(() => svc.navigate({ sessionId }))
if (isFn(svc.open)) attempts.push(() => svc.open(sessionId))
}
for (const run of attempts) {
try {
const result = run()
if (result && isFn(result.then)) result.catch(() => {})
return true
} catch { /* 换下一个候选 */ }
}
console.warn('[sansheng] 未找到可用的会话导航接口,仅发出 navigate 意图:', sessionId)
try {
if (typeof window !== 'undefined') {
window.dispatchEvent(new CustomEvent('sansheng:navigate', { detail: { sessionId } }))
}
} catch { /* 忽略 */ }
return false
}
// ---------- 右侧标签页(真实契约:register 类型 + 正文/标题 slot;不可用时回退浮动面板) ----------
function ensureRightTab() {
const tabs = get('sidebarRightTabs')
if (!tabs || !isFn(tabs.get)) return false
try { return !!(tabs.get(TAB_KIND) || tabs.get(TAB_TYPE_ID)) } catch { return false }
}
// 桌面版右栏常是收起状态:只 openTab 不展开,用户会以为“点了没反应”。
function revealRightTab() {
const right = get('sidebarRight')
if (!right) return
try {
const rows = isFn(right.openTabs?.getSnapshot) ? right.openTabs.getSnapshot() : []
const row = Array.isArray(rows) ? rows.find(item => item && item.kind === TAB_KIND) : null
if (row && isFn(right.focus)) right.focus(row.tabId)
if (isFn(right.isExpanded) && !right.isExpanded() && isFn(right.toggleExpanded)) right.toggleExpanded()
} catch (error) {
console.warn('[sansheng] 展开右侧栏失败:', error && error.message ? error.message : error)
}
}
function tryOpenRightTab() {
// 桌面版右栏由 dsh-better-sidebar 接管:它自己的 openTab 会排队等待会话面板挂载,
// 主区正被切走时也不会丢;直接调宿主 sidebarRight 反而会因“没有挂载的会话面板”失败。
const bs = get('betterSidebar')
if (bs && isFn(bs.openTab)) {
try {
const snap = isFn(bs.getSnapshot) ? bs.getSnapshot() : null
const sessionId = snap && typeof snap === 'object' ? snap.sessionId : undefined
if (!sessionId) return false
bs.openTab({ type: TAB_KIND, title: '三省六部' })
for (const delay of [200, 600, 1200]) setTimeout(revealRightTab, delay)
return true
} catch (error) {
console.warn('[sansheng] better-sidebar 打开失败,改用宿主接口:', error && error.message ? error.message : error)
}
}
const right = get('sidebarRight')
if (!right || !isFn(right.openTab)) return false
if (!ensureRightTab()) return false
try { right.openTab(TAB_KIND) } catch (error) {
console.warn('[sansheng] 打开右侧标签失败,改用浮动面板:', error && error.message ? error.message : error)
return false
}
// 右栏(尤其 better-sidebar 的原生面)是异步落位的,不能同步看不到就当失败,
// 否则会误退成主区渲染、把中间聊天顶掉。这里先乐观返回,再多次补一次聚焦/展开。
revealRightTab()
for (const delay of [150, 500, 1200]) setTimeout(revealRightTab, delay)
return true
}
function SanshengTabBody() {
return h('div', { className: 'ssw-tab-body' }, h(SanshengWorkbench, {}))
}
function SanshengTabTitle() {
return h('span', { className: 'ssw-tab-title' }, '三省六部')
}
// 宿主按 definition.id 选 slot(TabSlot: entryKey=definition.id),因此 slot key 必须等于类型 id。
function registerRightTabType() {
// 桌面版:向 better-sidebar 注册一个原生右侧标签(它自己负责正文/标题与落位)。
try {
const bs = get('betterSidebar')
if (bs && isFn(bs.registerTab)) {
const dispose = bs.registerTab({
id: TAB_KIND,
title: '三省六部',
description: '十席角色与独立会话的当前项目工作台',
icon: (size) => h(TreeIcon, { width: size, height: size }),
order: 32,
single: true,
component: () => h('div', { className: 'ssw-tab-body' }, h(SanshengWorkbench, {})),
})
return () => { try { if (isFn(dispose)) dispose() } catch { /* 忽略 */ } }
}
} catch (error) {
console.warn('[sansheng] 注册 better-sidebar 标签失败:', error && error.message ? error.message : error)
}
try {
if (!isFn(ctx.inject)) return
ctx.inject(['sidebarRightTabs'], (injected) => {
const tabs = injected.get('sidebarRightTabs')
if (!tabs || !isFn(tabs.register)) return
let disposeType = null, disposeBody = null, disposeTitle = null
try {
disposeType = tabs.register({ id: TAB_TYPE_ID, kind: TAB_KIND, keepMounted: true, priority: 'extension', title: () => '三省六部' })
disposeBody = ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({
name: 'sidebar.right.pane.tab', key: TAB_TYPE_ID, inject: (sessionId) => ({ sessionId }),
}, SanshengTabBody))
disposeTitle = ctx.slots.inject('sidebar.right.pane.tab.title', () => ctx.slots.register({
name: 'sidebar.right.pane.tab.title', key: TAB_TYPE_ID, inject: (sessionId) => ({ sessionId }),
}, SanshengTabTitle))
} catch (error) {
console.warn('[sansheng] 注册右侧标签失败:', error && error.message ? error.message : error)
try { disposeBody && disposeBody() } catch { /* 忽略 */ }
try { disposeTitle && disposeTitle() } catch { /* 忽略 */ }
try { disposeType && disposeType() } catch { /* 忽略 */ }
return
}
return () => {
try { disposeBody && disposeBody() } catch { /* 忽略 */ }
try { disposeTitle && disposeTitle() } catch { /* 忽略 */ }
try { disposeType && disposeType() } catch { /* 忽略 */ }
}
})
} catch (error) {
console.warn('[sansheng] 注册右侧标签失败:', error && error.message ? error.message : error)
}
}
// ---------- 工作台组件 ----------
function SanshengWorkbench(props) {
const onClose = props && props.onClose ? props.onClose : null
const [phase, setPhase] = useState('loading')
const [error, setError] = useState(null)
const [errorRetryable, setErrorRetryable] = useState(true)
const [notice, setNotice] = useState(null)
const [view, setView] = useState(null)
const [models, setModels] = useState(null)
const [selectedSeatId, setSelectedSeatId] = useState(SEAT_IDS[0])
const [draft, setDraft] = useState({})
const [busy, setBusy] = useState(false)
const [configOpen, setConfigOpen] = useState(false)
const [reportOpen, setReportOpen] = useState(false)
const [tab, setTab] = useState('court')
const [tasks, setTasks] = useState([])
const [artifacts, setArtifacts] = useState([])
const [taskFormOpen, setTaskFormOpen] = useState(false)
const [taskDraft, setTaskDraft] = useState({ title: '', goal: '', ownerSeatId: SEAT_IDS[0] })
const [artifactFormOpen, setArtifactFormOpen] = useState(false)
const [artifactDraft, setArtifactDraft] = useState({ title: '', path: '', summary: '' })
const alive = useRef(true)
useEffect(() => () => { alive.current = false }, [])
const loadProject = useCallback(async () => {
setPhase('loading'); setError(null); setErrorRetryable(true); setNotice(null)
const workspace = currentWorkspace()
if (!workspace) { setPhase('no-workspace'); return }
try {
const projectView = await request('open', {
workspaceId: workspace.workspaceId,
name: workspace.name,
path: workspace.path,
})
let modelCatalog = null
try { modelCatalog = await request('models') } catch (modelError) {
console.warn('[sansheng] 模型目录加载失败:', modelError && modelError.message ? modelError.message : modelError)
}
let taskList = []
let artifactList = []
try { taskList = (await request('tasks', { projectId: projectView.project.id })).tasks ?? [] } catch (taskError) {
console.warn('[sansheng] 任务加载失败:', taskError && taskError.message ? taskError.message : taskError)
}
try { artifactList = (await request('artifacts', { projectId: projectView.project.id })).artifacts ?? [] } catch (artifactError) {
console.warn('[sansheng] 成果加载失败:', artifactError && artifactError.message ? artifactError.message : artifactError)
}
if (!alive.current) return
setView(projectView)
setModels(modelCatalog)
setTasks(taskList)
setArtifacts(artifactList)
setPhase('ready')
} catch (loadError) {
if (!alive.current) return
setError(loadError && loadError.message ? loadError.message : '加载失败')
setErrorRetryable(!(loadError && loadError.retryable === false))
setPhase('error')
}
}, [])
useEffect(() => { void loadProject() }, [loadProject])
const wb = buildWorkbenchView(view, { selectedSeatId, models, draft })
const seatById = useMemo(() => {
const map = {}
for (const seat of wb.seats) map[seat.id] = seat
return map
}, [wb.seats])
function pickSeat(id) {
if (!id) return
if (id !== selectedSeatId) {
setSelectedSeatId(id)
setConfigOpen(false)
}
const seat = seatById[id]
if (seat && seat.status === 'bound') {
const rec = seatRecordOf(view, id)
if (rec && rec.sessionId) {
navigateToSession(rec.sessionId)
setNotice('已切换到' + seat.name + '会话')
return
}
}
if (seat && seat.status !== 'bound' && seat.status !== 'creating') setNotice('「' + seat.name + '」还没开启,点下面的按钮开启这个部门')
}
function setModelValue(value) {
setDraft(prev => updateDraft(prev, selectedSeatId, { modelValue: value }))
}
function setInstructions(value) {
setDraft(prev => updateDraft(prev, selectedSeatId, { instructions: value }))
}
async function enableSelectedSeat() {
const projectId = view && view.project ? view.project.id : null
if (!projectId) return
const seatId = wb.selected.id
setBusy(true); setError(null); setNotice('正在开启「' + wb.selected.name + '」…')
try {
const next = await request('enableSeat', { projectId, seatId })
if (!alive.current) return
setView(next)
setNotice('已开启「' + wb.selected.name + '」的独立会话')
} catch (enableError) {
if (alive.current) setError(enableError && enableError.message ? enableError.message : '开启失败')
} finally {
if (alive.current) setBusy(false)
}
}
async function enableSeats() {
const projectId = view && view.project ? view.project.id : null
if (!projectId) return
setBusy(true); setError(null); setNotice('正在启用十席…')
try {
const next = await request('enable', { projectId })
if (!alive.current) return
setView(next)
setNotice('十席已启用(建立独立会话,不自动运行模型)')
} catch (enableError) {
if (alive.current) setError(enableError && enableError.message ? enableError.message : '启用失败')
} finally {
if (alive.current) setBusy(false)
}
}
async function saveConfig() {
const projectId = view && view.project ? view.project.id : null
if (!projectId) return
const seatId = wb.selected.id
const value = wb.selected.modelValue
if (!value) { setNotice('请先为当前角色选择模型'); return }
const option = findModelOption(wb.selected.modelOptions, value)
const model = option
? (option.reasoningEffort
? { provider: option.provider, model: option.model, reasoningEffort: option.reasoningEffort }
: { provider: option.provider, model: option.model })
: null
setBusy(true); setError(null); setNotice('保存中…')
try {
await request('configure', { projectId, seatId, model, instructions: wb.selected.instructions })
const next = await request('project', { projectId })
if (!alive.current) return
setView(next)
setDraft(prev => clearDraft(prev, seatId))
setNotice('已保存')
} catch (saveError) {
if (alive.current) setError(saveError && saveError.message ? saveError.message : '保存失败')
} finally {
if (alive.current) setBusy(false)
}
}
async function reloadTasks(projectId) {
try {
const result = await request('tasks', { projectId })
if (alive.current) setTasks(result.tasks ?? [])
} catch (error) {
if (alive.current) setNotice(error && error.message ? error.message : '任务列表刷新失败')
}
}
async function createTask() {
const projectId = view && view.project ? view.project.id : null
if (!projectId) return
const title = taskDraft.title.trim()
if (!title) { setNotice('任务标题不能为空'); return }
setBusy(true); setError(null)
try {
await request('taskCreate', { projectId, title, goal: taskDraft.goal, ownerSeatId: taskDraft.ownerSeatId })
setTaskDraft({ title: '', goal: '', ownerSeatId: taskDraft.ownerSeatId })
setTaskFormOpen(false)
await reloadTasks(projectId)
setNotice('已存为草稿;点「派工」才会交给部门。')
} catch (error) {
if (alive.current) setError(error && error.message ? error.message : '新建任务失败')
} finally { if (alive.current) setBusy(false) }
}
async function dispatchTask(taskId) {
const projectId = view && view.project ? view.project.id : null
if (!projectId) return
setBusy(true); setError(null)
try {
const result = await request('taskDispatch', { projectId, taskId })
await reloadTasks(projectId)
setNotice(result.delivered ? '已派工到该部门会话。' : '已记录为待执行(当前宿主暂不支持直接发送)。')
} catch (error) {
if (alive.current) setError(error && error.message ? error.message : '派工失败')
} finally { if (alive.current) setBusy(false) }
}
async function cancelTask(taskId) {
const projectId = view && view.project ? view.project.id : null
if (!projectId) return
setBusy(true); setError(null)
try {
await request('taskCancel', { projectId, taskId })
await reloadTasks(projectId)
setNotice('任务已取消。')
} catch (error) {
if (alive.current) setError(error && error.message ? error.message : '取消失败')
} finally { if (alive.current) setBusy(false) }
}
async function addArtifact() {
const projectId = view && view.project ? view.project.id : null
if (!projectId) return
const title = artifactDraft.title.trim()
if (!title) { setNotice('成果名称不能为空'); return }
setBusy(true); setError(null)
try {
const result = await request('artifactAdd', { projectId, title, path: artifactDraft.path, summary: artifactDraft.summary })
setArtifactDraft({ title: '', path: '', summary: '' })
setArtifactFormOpen(false)
setArtifacts(list => [...list, result.artifact])
setNotice('成果已登记。')
} catch (error) {
if (alive.current) setError(error && error.message ? error.message : '登记成果失败')
} finally { if (alive.current) setBusy(false) }
}
const seatCard = (seat) => h('button', {
key: seat.id, type: 'button', className: 'ssw-seat',
'aria-pressed': seat.selected ? 'true' : 'false',
title: seat.name + ' · ' + seat.duty + '(' + seat.statusLabel + ')',
onClick: () => pickSeat(seat.id),
},
h('span', { className: 'ssw-role-top' },
h('span', { className: 'ssw-role-name' }, seat.name),
h('span', { className: 'ssw-dot', 'data-status': seat.status, 'aria-hidden': 'true' }),
),
h('span', { className: 'ssw-role-duty' }, seat.duty),
)
const pickList = (ids) => ids.map(id => seatById[id]).filter(Boolean)
const tree = h('section', { className: 'ssw-tree', 'aria-label': '切换角色' },
h('div', { className: 'ssw-lead' }, pickList(wb.groups.lead).map(seatCard)),
h('div', { className: 'ssw-sansheng' },
h('span', { className: 'ssw-group-label' }, '三省'),
h('div', { className: 'ssw-trio' }, pickList(wb.groups.sansheng).map(seatCard)),
),
h('div', { className: 'ssw-ministries' },
h('span', { className: 'ssw-group-label' }, '六部 · 尚书统筹'),
h('div', { className: 'ssw-six' }, pickList(wb.groups.liubu).map(seatCard)),
),
)
const head = h('header', { className: 'ssw-head' },
h(TreeIcon),
h('strong', { className: 'ssw-head-title' }, '工作台'),
onClose
? h('button', { type: 'button', className: 'ssw-icon-btn', onClick: onClose, 'aria-label': '收起工作台' }, h(CloseIcon))
: null,
)
const projectInfo = h('div', { className: 'ssw-project' },
h('div', { className: 'ssw-project-line', style: { justifyContent: 'flex-end' } },
h('span', { className: 'ssw-count' }, wb.project.seatCount + ' 个角色 · ' + wb.project.sessionCount + ' 个会话'),
),
h('div', { className: 'ssw-project-title' }, wb.projectTitle || '未命名项目'),
)
const selectedStatus = wb.selected.status
const detailActions = h('div', { className: 'ssw-current-actions' },
selectedStatus === 'bound'
? h('button', {
type: 'button', className: 'ssw-primary', disabled: busy,
onClick: () => pickSeat(wb.selected.id),
}, '开始对话')
: h('button', {
type: 'button', className: 'ssw-primary', disabled: busy || selectedStatus === 'creating',
onClick: enableSelectedSeat,
}, selectedStatus === 'creating' ? '正在开启…' : '开启「' + wb.selected.name + '」'),
)
const optionEls = wb.selected.modelOptions.map(option => h('option', { key: option.value, value: option.value }, option.label))
if (wb.selected.modelValue && !wb.selected.modelOptions.some(option => option.value === wb.selected.modelValue)) {
optionEls.push(h('option', { key: '__current__', value: wb.selected.modelValue }, wb.selected.modelLabel))
}
const config = h('section', { className: 'ssw-config' },
h('button', {
type: 'button', className: 'ssw-config-toggle', 'aria-expanded': configOpen ? 'true' : 'false',
onClick: () => setConfigOpen(value => !value),
},
h(GearIcon),
h('span', null, '配置' + wb.selected.name + (wb.selected.dirty ? ' · 未保存' : '')),
h(ChevronIcon),
),
configOpen
? h('div', { className: 'ssw-config-body' },
h('label', { className: 'ssw-label' }, '默认模型(开启该部门时应用)'),
h('select', {
className: 'ssw-field', value: wb.selected.modelValue, disabled: busy,
onChange: event => setModelValue(event.target.value),
},
h('option', { value: '', disabled: true }, UNCHOSEN_MODEL_LABEL),
...optionEls,
),
h('label', { className: 'ssw-label' }, '角色补充说明'),
h('textarea', {
className: 'ssw-field ssw-textarea', rows: 4, value: wb.selected.instructions, disabled: busy,
placeholder: '补充该角色在当前项目中的工作要求',
onChange: event => setInstructions(event.target.value),
}),
h('p', { className: 'ssw-scope-note' }, '这里预配置的模型会在开启该部门或按需派工时应用;丞相派工不选择模型。只影响当前项目当前角色。'),
h('div', { className: 'ssw-save-row' },
h('button', { type: 'button', className: 'ssw-primary', disabled: busy, onClick: saveConfig }, busy ? '保存中…' : '保存配置'),
wb.selected.dirty ? h('span', { className: 'ssw-save-status' }, '有未保存修改') : null,
),
)
: null,
)
const report = h('section', { className: 'ssw-report' },
h('button', {
type: 'button', className: 'ssw-report-toggle', 'aria-expanded': reportOpen ? 'true' : 'false',
onClick: () => setReportOpen(value => !value),
}, reportOpen ? '收起角色职责' : '全部角色职责'),
reportOpen
? h('div', { className: 'ssw-report-list' },
SEAT_IDS.map(id => {
const rec = seatRecordOf(view, id)
const m = rec && rec.model
const modelLabel = m && m.model ? (m.model + (m.reasoningEffort ? ' · ' + m.reasoningEffort : '')) : '未选择模型'
return h('div', { key: id, className: 'ssw-report-item', 'data-seat': id },
h('div', { className: 'ssw-report-head' },
h('strong', null, SEATS[id].label),
h('span', null, SEATS[id].duty),
),
h('p', { className: 'ssw-report-model' }, '模型:' + modelLabel),
h('p', { className: 'ssw-report-text' }, SEATS[id].responsibility),
)
}),
)
: null,
)
const statusEl = error
? h('p', { className: 'ssw-error', role: 'alert' }, error)
: (notice ? h('p', { className: 'ssw-notice', role: 'status' }, notice) : null)
const tabCounts = { court: wb.project.seatCount, tasks: tasks.length, artifacts: artifacts.length }
const tabBar = h('div', { className: 'ssw-tabs', role: 'tablist' },
[['court', '朝堂'], ['tasks', '任务'], ['artifacts', '成果']].map(([id, label]) => h('button', {
key: id, type: 'button', role: 'tab', 'aria-selected': tab === id ? 'true' : 'false',
className: 'ssw-tab' + (tab === id ? ' is-active' : ''), onClick: () => setTab(id),
}, h('span', null, label), h('span', { className: 'ssw-tab-count' }, String(tabCounts[id] ?? 0)))))
const TASK_STATUS_LABEL = { draft: '草稿', prepared: '待执行', dispatched: '已派工', done: '已完成', cancelled: '已取消', failed: '失败' }
const taskRows = tasks.length === 0
? h('p', { className: 'ssw-empty-line' }, '这个项目还没有任务。点「新建任务」先存一张草稿。')
: tasks.map(task => h('article', { key: task.id, className: 'ssw-row', 'data-task': task.id },
h('div', { className: 'ssw-row-top' },
h('strong', { className: 'ssw-row-title' }, task.title),
h('span', { className: 'ssw-badge', 'data-status': task.status }, TASK_STATUS_LABEL[task.status] ?? task.status)),
h('p', { className: 'ssw-row-meta' }, (SEATS[task.ownerSeatId]?.label ?? task.ownerSeatId) + (task.goal ? ' · ' + task.goal : '')),
task.note ? h('p', { className: 'ssw-row-note' }, task.note) : null,
h('div', { className: 'ssw-row-actions' },
(task.status === 'draft' || task.status === 'prepared' || task.status === 'failed')
? h('button', { type: 'button', className: 'ssw-link', disabled: busy, onClick: () => dispatchTask(task.id) }, task.status === 'prepared' ? '重试派工' : '派工')
: null,
(task.status !== 'done' && task.status !== 'cancelled')
? h('button', { type: 'button', className: 'ssw-link ssw-link-muted', disabled: busy, onClick: () => cancelTask(task.id) }, '取消')
: null)))
const taskView = h('section', { className: 'ssw-page' },
h('div', { className: 'ssw-page-head' },
h('strong', null, '任务 · ' + tasks.length),
h('button', { type: 'button', className: 'ssw-primary', onClick: () => setTaskFormOpen(value => !value) }, taskFormOpen ? '收起' : '新建任务')),
taskFormOpen ? h('form', { className: 'ssw-form', onSubmit: event => { event.preventDefault(); void createTask() } },
h('label', { className: 'ssw-label' }, '标题'),
h('input', { className: 'ssw-field', value: taskDraft.title, placeholder: '交给部门做什么', onChange: event => setTaskDraft({ ...taskDraft, title: event.target.value }) }),
h('label', { className: 'ssw-label' }, '目标(可选)'),
h('textarea', { className: 'ssw-field ssw-textarea', rows: 3, value: taskDraft.goal, onChange: event => setTaskDraft({ ...taskDraft, goal: event.target.value }) }),
h('label', { className: 'ssw-label' }, '主责部门'),
h('select', { className: 'ssw-field', value: taskDraft.ownerSeatId, onChange: event => setTaskDraft({ ...taskDraft, ownerSeatId: event.target.value }) },
SEAT_IDS.map(id => h('option', { key: id, value: id }, SEATS[id].label))),
h('div', { className: 'ssw-save-row' }, h('button', { type: 'submit', className: 'ssw-primary', disabled: busy }, busy ? '保存中…' : '保存草稿')),
) : null,
h('div', { className: 'ssw-list' }, taskRows))
const artifactRows = artifacts.length === 0
? h('p', { className: 'ssw-empty-line' }, '这个项目还没有登记成果。')
: artifacts.map(item => h('article', { key: item.id, className: 'ssw-row', 'data-artifact': item.id },
h('div', { className: 'ssw-row-top' }, h('strong', { className: 'ssw-row-title' }, item.title)),
item.summary ? h('p', { className: 'ssw-row-meta' }, item.summary) : null,
item.path ? h('p', { className: 'ssw-row-note' }, item.path) : null))
const artifactView = h('section', { className: 'ssw-page' },
h('div', { className: 'ssw-page-head' },
h('strong', null, '成果 · ' + artifacts.length),
h('button', { type: 'button', className: 'ssw-primary', onClick: () => setArtifactFormOpen(value => !value) }, artifactFormOpen ? '收起' : '登记成果')),
artifactFormOpen ? h('form', { className: 'ssw-form', onSubmit: event => { event.preventDefault(); void addArtifact() } },
h('label', { className: 'ssw-label' }, '成果名称'),
h('input', { className: 'ssw-field', value: artifactDraft.title, onChange: event => setArtifactDraft({ ...artifactDraft, title: event.target.value }) }),
h('label', { className: 'ssw-label' }, '文件路径(可选)'),
h('input', { className: 'ssw-field', value: artifactDraft.path, onChange: event => setArtifactDraft({ ...artifactDraft, path: event.target.value }) }),
h('label', { className: 'ssw-label' }, '说明(可选)'),
h('textarea', { className: 'ssw-field ssw-textarea', rows: 3, value: artifactDraft.summary, onChange: event => setArtifactDraft({ ...artifactDraft, summary: event.target.value }) }),
h('div', { className: 'ssw-save-row' }, h('button', { type: 'submit', className: 'ssw-primary', disabled: busy }, busy ? '保存中…' : '保存')),
) : null,
h('div', { className: 'ssw-list' }, artifactRows))
const detail = h('section', { className: 'ssw-current' },
h('div', { className: 'ssw-current-top' },
h('strong', { className: 'ssw-current-name' }, wb.selected.name),
h('span', { className: 'ssw-current-label' }, '角色职责 · ' + wb.selected.statusLabel),
),
h('p', { className: 'ssw-current-text' }, wb.selected.responsibility),
detailActions,
)
const courtView = h(Fragment, null, tree, detail, config)
let body
if (phase === 'loading') body = h('div', { className: 'ssw-loading' }, '正在加载工作台…')
else if (phase === 'no-workspace') body = h('div', { className: 'ssw-empty' },
h('p', null, '请先选择项目'),
h('p', { className: 'ssw-hint' }, '在左侧工作区里选中一个项目后再打开三省六部。'),
h('button', { type: 'button', className: 'ssw-primary', onClick: loadProject }, '重新检查'),
)
else if (phase === 'error' && !view) body = h('div', { className: 'ssw-empty' },
h('p', { className: 'ssw-error' }, error || '加载失败'),
errorRetryable
? h('button', { type: 'button', className: 'ssw-primary', onClick: loadProject }, '重试')
: null,
)
else body = h(Fragment, null, projectInfo, tabBar,
tab === 'tasks' ? taskView : tab === 'artifacts' ? artifactView : courtView, statusEl)
return h('div', { className: 'ssw-root ssw-scope' }, head, body)
}
// ---------- 左侧导航入口 ----------
// 宿主正式扩展点是 sidebar.panellist:一行导航 + 一个同名 keyed main 页(插件/任务看板/记忆系统同机制)。
// 位置钉在记忆系统(order 30)与技能管理(31)之后、宿主「更多」之前。
const NAV_PANEL_ID = 'sansheng-workbench'
const NAV_ORDER = 32
function openRightWorkbench() {
return tryOpenRightTab()
}
function closeRightWorkbench() {
const layout = get('layout')
if (layout && isFn(layout.selectPanel)) {
try { layout.selectPanel(null); return } catch { /* 换下一个候选 */ }
}
const right = get('sidebarRight')
if (right && isFn(right.closeTab)) {
try { right.closeTab(TAB_KIND); return } catch { /* 忽略 */ }
}
}
// 导航行内容(宿主只把这里当图标渲染,标签由宿主按 label() 画)。
// 点击只开右侧工作台,并阻止冒泡,避免宿主把主区切成面板页——中央原生聊天因此保持原样。
function SanshengNavButton(props) {
const size = props && typeof props.size === 'number' ? props.size : 16
const [floating, setFloating] = useState(false)
const stop = (event) => {
if (event && isFn(event.stopPropagation)) event.stopPropagation()
}
const onClick = (event) => {
if (event && isFn(event.stopPropagation)) event.stopPropagation()
if (event && isFn(event.preventDefault)) event.preventDefault()
if (openRightWorkbench()) { setFloating(false); return }
setFloating(value => !value)
}
let panel = null
if (floating) {
const card = h('div', { className: 'ssw-float', role: 'dialog', 'aria-label': '三省六部工作台' },
h(SanshengWorkbench, { onClose: () => setFloating(false) }))
const canPortal = typeof document !== 'undefined' && document.body && isFn(createPortal)
panel = canPortal ? createPortal(card, document.body) : card
}
return h(Fragment, null,
h('span', {
className: 'ssw-nav-hit', role: 'presentation', title: '三省六部', onClick,
onPointerDown: stop, onMouseDown: stop,
'aria-expanded': floating ? 'true' : 'false',
}, h(TreeIcon, { width: size, height: size })),
panel,
)
}
// 兜底:若宿主按整行点击切了主区,先把工作台打开到右侧并切回会话;
// 右侧打不开时就在主区直接渲染工作台(而不是空白),保证点击一定有反应。
function backToChat() {
const layout = get('layout')
if (layout && isFn(layout.selectPanel)) { try { layout.selectPanel(null) } catch { /* 忽略 */ } }
}
function SanshengNavFallback() {
const [mode, setMode] = useState('pending')
useEffect(() => {
// 整行点击会先把主区切成本页(此时会话面板已卸载,右栏开不了)。
// 立刻切回会话,然后在会话重新挂载后用全局定时器重试打开右栏;
// 这些定时器不随本组件卸载取消,否则切回会话就把自己“清理”掉了。
const hasBetter = !!get('betterSidebar')
backToChat()
if (!hasBetter) {
const timer = setTimeout(() => { if (!openRightWorkbench()) setMode('inline') }, 400)
return () => clearTimeout(timer)
}
for (const delay of [200, 600, 1200, 2000]) {
setTimeout(() => {
try { if (openRightWorkbench()) backToChat() } catch { /* 忽略 */ }
}, delay)
}
}, [])
useEffect(() => {
if (mode !== 'docked') return
backToChat()
const timer = setTimeout(backToChat, 700)
return () => clearTimeout(timer)
}, [mode])
if (mode === 'pending') return null
if (mode === 'docked') return null
return h('div', { className: 'ssw-tab-body' },
h('div', { className: 'ssw-inline-bar' },
h('span', null, '右侧工作台未能打开,先显示在这里'),
h('button', { type: 'button', className: 'ssw-link', onClick: backToChat }, '返回对话'),
),
h(SanshengWorkbench, {}),
)
}
function registerNavEntry() {
if (!ctx.slots || !isFn(ctx.slots.inject) || !isFn(ctx.slots.register)) {
console.warn('[sansheng] 宿主未提供 slots.inject / slots.register,无法注册左侧导航入口')
return
}
try {
ctx.slots.inject('main', () => ctx.slots.inject('sidebar.panellist', () => {
const disposers = []
const disposeAll = () => {
for (const dispose of disposers.splice(0)) { try { if (isFn(dispose)) dispose() } catch { /* 忽略 */ } }
}
try {
disposers.push(ctx.slots.register({ name: 'main', key: NAV_PANEL_ID, inject: () => ({}) }, SanshengNavFallback))
disposers.push(ctx.slots.register({ name: 'sidebar.panellist', id: NAV_PANEL_ID, order: NAV_ORDER, label: () => '三省六部' }, SanshengNavButton))
} catch (error) {
disposeAll()
console.warn('[sansheng] 注册左侧导航入口失败:', error && error.message ? error.message : error)
return undefined
}
return disposeAll
}))
} catch (error) {
console.warn('[sansheng] 注册左侧导航入口失败:', error && error.message ? error.message : error)
}
}
// 左侧导航行(宿主正式槽位,位置在记忆系统之后、更多之前)。
registerNavEntry()
// 右侧工作台标签类型:需在 apply 时就注册(宿主按类型 id 选正文 slot)。
registerRightTabType()
// dsh-go 原生面板:浏览器(无 dshGo 服务)或桥未就绪时,install 内部安静退出。
try {
installNativePanel(ctx)
} catch (error) {
console.warn('[sansheng] 原生面板注册失败:', error && error.message ? error.message : error)
}
}

127
src/client/styles.js Normal file
View File

@ -0,0 +1,127 @@
// 三省六部工作台样式:白蓝主题,自带深色适配。
// 所有选择器以 .ssw- 前缀隔离,避免污染宿主样式;变量参考 preview/index.html。
// 不依赖任何构建工具,作为普通字符串导出,由入口注入 <style>。
export const CSS = `
.ssw-scope{--ssw-bg:#ffffff;--ssw-side:#f8f9fa;--ssw-rail:#f8fafc;--ssw-card:#ffffff;--ssw-line:#e3e8ef;--ssw-strong:#c7d8f5;--ssw-ink:#0f172a;--ssw-muted:#667085;--ssw-faint:#98a2b3;--ssw-blue:#4263eb;--ssw-wash:#eef2ff;--ssw-frame:#3b82f6;--ssw-wire:#c9d6ea;--ssw-danger:#dc2626;--ssw-ok:#16a34a;box-sizing:border-box;color:var(--ssw-ink);font-family:Inter,"Segoe UI","Microsoft YaHei",sans-serif;font-size:13px;line-height:1.5}
.ssw-scope *,.ssw-scope *::before,.ssw-scope *::after{box-sizing:border-box}
.ssw-scope :where(button){font:inherit;color:inherit;background:transparent;border:0;cursor:pointer}
.ssw-scope button:disabled{cursor:default;opacity:.55}
.ssw-scope :focus-visible{outline:2px solid var(--ssw-blue);outline-offset:2px}
body[data-ds-dark-theme] .ssw-scope,html[data-theme=dark] .ssw-scope,.ssw-scope[data-ssw-theme=dark]{--ssw-bg:#14171c;--ssw-side:#171b21;--ssw-rail:#161a20;--ssw-card:#1e232b;--ssw-line:#2c333d;--ssw-strong:#3b4a63;--ssw-frame:#6ea8ff;--ssw-ink:#e6ebf2;--ssw-muted:#a9b4c2;--ssw-faint:#7b8797;--ssw-blue:#6ea8ff;--ssw-wash:#1d2b40;--ssw-wire:#3a4350;--ssw-danger:#f87171;--ssw-ok:#4ade80}
.ssw-float{position:fixed;right:14px;bottom:70px;z-index:2147483000;width:min(374px,calc(100vw - 28px));max-height:calc(100vh - 96px);display:flex;flex-direction:column;background:#ffffff;border:1px solid #e3e8ef;border-radius:12px;box-shadow:0 18px 50px -12px rgba(16,24,40,.28),0 4px 12px -2px rgba(16,24,40,.12);overflow:hidden}
body[data-ds-dark-theme] .ssw-float,html[data-theme=dark] .ssw-float{background:#161a20;border-color:#2c333d}
.ssw-root{container-type:inline-size;display:flex;flex-direction:column;min-height:0;height:100%;overflow:auto;background:var(--ssw-rail);color:var(--ssw-ink)}
.ssw-head{flex:none;height:52px;display:flex;align-items:center;gap:8px;padding:0 16px;border-bottom:1px solid var(--ssw-line);background:var(--ssw-card)}
.ssw-head svg{width:18px;height:18px;color:var(--ssw-muted)}
.ssw-head-title{font-size:13px;font-weight:600}
.ssw-icon-btn{margin-left:auto;display:inline-flex;align-items:center;justify-content:center;width:30px;height:30px;border-radius:6px;color:var(--ssw-muted)}
.ssw-icon-btn:hover{background:var(--ssw-wash);color:var(--ssw-blue)}
.ssw-project{padding:22px 20px 0}
.ssw-project-line{display:flex;align-items:center;justify-content:space-between;margin-bottom:5px}
.ssw-eyebrow{display:inline-flex;align-items:center;gap:6px;font-size:11px;color:var(--ssw-muted)}
.ssw-eyebrow svg{width:14px;height:14px}
.ssw-count{font-size:10px;color:var(--ssw-faint)}
.ssw-project-title{font-size:21px;font-weight:650;letter-spacing:.5px;margin:4px 0 16px}
.ssw-enable{margin:0 16px 4px;padding:12px;border:1px solid var(--ssw-strong);background:var(--ssw-wash);border-radius:10px}
.ssw-enable-note{margin:0 0 10px;font-size:12px;color:var(--ssw-muted);line-height:1.7}
.ssw-primary{min-height:36px;background:var(--ssw-blue);color:#ffffff;border-radius:7px;padding:8px 13px;font-size:12px;font-weight:500}
.ssw-primary:hover{filter:brightness(1.05)}
.ssw-tree{padding:24px 20px 4px;position:relative}
.ssw-lead{width:168px;margin:0 auto;position:relative}
.ssw-lead::after{content:none}
.ssw-sansheng{position:relative;margin-top:24px}
.ssw-trio{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:9px}
.ssw-seat{position:relative;width:100%;display:flex;flex-direction:column;gap:6px;padding:14px 12px 12px;border:1px solid var(--ssw-line);border-radius:12px;background:var(--ssw-card);text-align:left;min-height:80px;box-shadow:0 1px 2px rgba(16,24,40,.04);transition:border-color .15s,box-shadow .15s,transform .15s}
.ssw-seat:hover{border-color:var(--ssw-blue);transform:translateY(-1px);box-shadow:0 3px 8px rgba(16,24,40,.06)}
.ssw-seat[aria-pressed=true]{border-color:var(--ssw-blue);background:var(--ssw-wash);box-shadow:0 0 0 2px rgba(59,130,246,.12)}
.ssw-lead .ssw-seat{min-height:84px}
.ssw-role-top{display:flex;align-items:center;justify-content:space-between;gap:6px}
.ssw-role-name{font-size:14px;font-weight:600;letter-spacing:2px}
.ssw-role-duty{font-size:11px;color:var(--ssw-muted);line-height:1.5}
.ssw-dot{flex:none;width:6px;height:6px;border-radius:50%;border:1px solid var(--ssw-faint);background:transparent}
.ssw-dot[data-status=bound]{background:var(--ssw-ok);border-color:var(--ssw-ok)}
.ssw-dot[data-status=failed],.ssw-dot[data-status=missing]{background:var(--ssw-danger);border-color:var(--ssw-danger)}
.ssw-dot[data-status=creating]{background:var(--ssw-blue);border-color:var(--ssw-blue)}
.ssw-ministries{position:relative;margin-top:18px}
.ssw-group-label{display:flex;align-items:center;gap:10px;margin:0 2px 8px;font-size:11px;font-weight:600;letter-spacing:.5px;color:var(--ssw-muted)}
.ssw-six{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px}
.ssw-six .ssw-seat{min-height:76px;padding:12px}
.ssw-report{padding:0 20px;margin-top:4px}
.ssw-report-toggle{font-size:12px;color:var(--ssw-blue);padding:7px 2px;font-weight:500}
.ssw-report-list{display:flex;flex-direction:column;gap:8px;margin-top:4px}
.ssw-report-item{border:1px solid var(--ssw-line);border-radius:9px;padding:9px 11px;background:var(--ssw-card)}
.ssw-report-head{display:flex;gap:8px;align-items:baseline}
.ssw-report-head strong{font-size:13px;letter-spacing:1px}
.ssw-report-head span{font-size:10px;color:var(--ssw-muted)}
.ssw-report-model{margin:4px 0 0;font-size:11px;color:var(--ssw-blue);letter-spacing:.2px}
.ssw-report-text{margin:4px 0 0;font-size:12px;line-height:1.7;color:var(--ssw-muted)}
.ssw-current{margin:14px 20px 0;padding:16px;border:1px solid var(--ssw-line);border-radius:11px;background:var(--ssw-card)}
.ssw-current-top{display:flex;align-items:center;justify-content:space-between;margin-bottom:9px}
.ssw-current-name{font-size:13px;font-weight:600}
.ssw-current-label{font-size:10px;color:var(--ssw-faint)}
.ssw-current-text{margin:0;font-size:12px;line-height:1.8;color:var(--ssw-muted)}
.ssw-config{margin:10px 20px 20px;border:1px solid var(--ssw-line);border-radius:10px;background:var(--ssw-card);overflow:hidden}
.ssw-config-toggle{display:flex;align-items:center;gap:8px;width:100%;padding:12px 13px;font-size:12px;color:var(--ssw-ink)}
.ssw-config-toggle svg{width:15px;height:15px;color:var(--ssw-muted)}
.ssw-chevron{margin-left:auto;transition:transform .2s}
.ssw-config-toggle[aria-expanded=true] .ssw-chevron{transform:rotate(180deg)}
.ssw-config-body{padding:0 13px 14px}
.ssw-label{display:block;font-size:11px;color:var(--ssw-muted);margin:12px 0 6px}
.ssw-field{width:100%;border:1px solid var(--ssw-line);background:var(--ssw-bg);color:var(--ssw-ink);border-radius:6px;padding:8px;font-size:12px;line-height:1.5}
.ssw-textarea{resize:vertical;min-height:84px;font-family:inherit}
.ssw-scope-note{margin:10px 0;font-size:10px;line-height:1.6;color:var(--ssw-faint)}
.ssw-save-row{display:flex;align-items:center;gap:10px}
.ssw-save-status{font-size:10px;color:var(--ssw-muted)}
.ssw-notice{margin:12px 16px 16px;font-size:11px;color:var(--ssw-muted)}
.ssw-error{margin:12px 16px 16px;font-size:11px;color:var(--ssw-danger)}
.ssw-loading,.ssw-empty{padding:36px 20px;text-align:center;font-size:12px;color:var(--ssw-muted)}
.ssw-empty .ssw-primary{margin-top:12px}
/* 导航行图标:尺寸/颜色全部跟随宿主导航行,不自己画背景,避免比同类导航项突兀。 */
.ssw-nav-hit{display:inline-flex;align-items:center;justify-content:center;width:16px;height:16px;color:inherit;cursor:pointer}
.ssw-nav-hit svg{width:16px;height:16px;flex:none;display:block}
.ssw-hint{margin:6px 0 0;font-size:11px;color:var(--ssw-faint)}
.ssw-current-actions{margin-top:10px;display:flex;gap:8px}
.ssw-inline-bar{flex:none;display:flex;align-items:center;justify-content:space-between;gap:8px;padding:8px 12px;border-bottom:1px solid var(--ssw-line);background:var(--ssw-card);font-size:12px;color:var(--ssw-muted)}
.ssw-link{color:var(--ssw-blue);font-size:12px;padding:2px 4px}
@media (prefers-reduced-motion:reduce){.ssw-scope *{transition:none!important}}
.ssw-tabs{display:flex;gap:6px;margin:0 20px;padding:4px;border:1px solid var(--ssw-line);border-radius:12px;background:var(--ssw-side)}
.ssw-tab{flex:1;display:flex;align-items:center;justify-content:center;gap:6px;padding:7px 6px;border-radius:6px;font-size:12px;color:var(--ssw-muted)}
.ssw-tab.is-active{background:var(--ssw-card);color:var(--ssw-blue);font-weight:600;box-shadow:0 1px 2px rgba(16,24,40,.06)}
.ssw-tab-count{font-size:10px;color:var(--ssw-faint)}
.ssw-page{padding:12px 16px 0}
.ssw-page-head{display:flex;align-items:center;justify-content:space-between;margin-bottom:10px}
.ssw-page-head strong{font-size:13px}
.ssw-list{display:flex;flex-direction:column;gap:8px}
.ssw-row{border:1px solid var(--ssw-line);border-radius:9px;padding:9px 11px;background:var(--ssw-card)}
.ssw-row-top{display:flex;align-items:center;justify-content:space-between;gap:8px}
.ssw-row-title{font-size:13px}
.ssw-row-meta{margin:4px 0 0;font-size:11px;color:var(--ssw-muted)}
.ssw-row-note{margin:4px 0 0;font-size:10px;color:var(--ssw-faint)}
.ssw-row-actions{display:flex;gap:10px;margin-top:6px}
.ssw-link{color:var(--ssw-blue);font-size:12px;padding:2px 2px}
.ssw-link-muted{color:var(--ssw-muted)}
.ssw-badge{font-size:10px;padding:2px 6px;border-radius:999px;background:var(--ssw-wash);color:var(--ssw-blue)}
.ssw-badge[data-status=done]{background:rgba(22,163,74,.12);color:var(--ssw-ok)}
.ssw-badge[data-status=cancelled]{background:rgba(107,114,128,.14);color:var(--ssw-muted)}
.ssw-badge[data-status=failed]{background:rgba(220,38,38,.12);color:var(--ssw-danger)}
.ssw-form{margin-bottom:12px;padding:10px;border:1px solid var(--ssw-line);border-radius:9px;background:var(--ssw-side)}
.ssw-empty-line{margin:10px 0;font-size:12px;color:var(--ssw-faint)}
.ssw-project-line{align-items:baseline;margin-bottom:10px}
.ssw-project-title{margin:0}
.ssw-tab-body{height:100%;min-height:0;display:flex;flex-direction:column}
.ssw-tab-body .ssw-root{flex:1;min-height:0}
.ssw-tab-title{font-size:13px}
.ssw-group-label::after{content:"";height:1px;background:var(--ssw-line);flex:1}
.ssw-role-top{width:100%}
.ssw-tab-count{padding:1px 5px;border-radius:5px;background:var(--ssw-rail)}
.ssw-current-name{font-size:15px;letter-spacing:1px}
.ssw-current-label{padding:3px 7px;border-radius:5px;background:var(--ssw-side)}
.ssw-config-toggle:hover{background:var(--ssw-side)}
/* 按工作台本身的宽度适配:宽屏居中,右侧窄栏保持紧凑。 */
.ssw-root > :is(.ssw-project,.ssw-tree,.ssw-report,.ssw-page){width:100%;max-width:720px;align-self:center;flex-shrink:0}
.ssw-root > :is(.ssw-tabs,.ssw-current,.ssw-config,.ssw-enable,.ssw-notice,.ssw-error){width:calc(100% - 40px);max-width:680px;margin-left:auto;margin-right:auto;flex-shrink:0}
.ssw-enable{margin-top:12px}
@container(max-width:380px){.ssw-root > :is(.ssw-tabs,.ssw-current,.ssw-config,.ssw-enable,.ssw-notice,.ssw-error){width:calc(100% - 24px);margin-left:auto;margin-right:auto}
.ssw-project{padding:16px 12px 0}.ssw-tabs{margin:0 12px}.ssw-tree{padding:20px 12px 4px}.ssw-current{margin:12px 12px 0}.ssw-config{margin:10px 12px 16px}.ssw-report{padding:0 12px}.ssw-trio,.ssw-six{gap:6px}.ssw-seat,.ssw-six .ssw-seat{padding:10px 8px}.ssw-role-duty{font-size:10px}}
`

51
src/client/transport.js Normal file
View File

@ -0,0 +1,51 @@
// 三省六部 Web 传输层:POST api/sansheng,契约见 CONTRACT.md。
// 请求体 { endpoint, payload };成功 { ok:true, value };失败 { ok:false, error:{code,message} }。
const ROUTE = 'api/sansheng'
export class SanshengRequestError extends Error {
constructor(message, code, retryable = true) {
super(message)
this.name = 'SanshengRequestError'
this.code = code || 'sansheng/error'
this.retryable = retryable !== false
}
}
export async function request(endpoint, payload, signal) {
let response
try {
response = await fetch(ROUTE, {
method: 'POST',
credentials: 'same-origin',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ endpoint, payload: payload ?? null }),
signal,
})
} catch (error) {
if (error && error.name === 'AbortError') throw error
const detail = error && error.message ? error.message : String(error)
throw new SanshengRequestError('无法连接 DSH,请确认它仍在运行(' + detail + ')', 'NETWORK')
}
if (!response.ok) {
throw new SanshengRequestError('HTTP ' + response.status, 'HTTP_' + response.status)
}
let result
try {
result = await response.json()
} catch (error) {
throw new SanshengRequestError('响应不是合法 JSON', 'sansheng/bad-response')
}
if (!result || result.ok !== true) {
const code = result && result.error && result.error.code ? result.error.code : 'sansheng/error'
const message = result && result.error && result.error.message ? result.error.message : '请求失败'
const retryable = !(result && result.error && result.error.retryable === false)
throw new SanshengRequestError(message, code, retryable)
}
return result.value
}
export default request

231
src/client/workbench.js Normal file
View File

@ -0,0 +1,231 @@
// 纯视图模型:不 import React、不触碰 DOM,可被 node 直接 import 测试。
// 依据 CONTRACT.md「Web 工作台」一节生成 buildWorkbenchView(view, ui) 的返回结构;
// 十席名称 / 职责全文一律取自共享的 src/shared/roles.js,保证三端一致。
import { SEATS, SEAT_IDS, SEAT_GROUPS } from '../shared/roles.js'
// 未选择模型时的固定文案,两端 UI 必须一致。
export const UNCHOSEN_MODEL_LABEL = '请选择模型'
export const SEAT_STATUS_LABELS = Object.freeze({
pending: '待启用',
creating: '创建中',
bound: '已绑定',
failed: '创建失败',
missing: '会话缺失',
})
const DEFAULT_SEAT_STATUS = 'pending'
export function seatStatusLabel(status) {
if (typeof status !== 'string') return '未知状态'
return SEAT_STATUS_LABELS[status] ?? '未知状态'
}
export function projectStatusLabel(status) {
switch (status) {
case 'pending': return '待启用'
case 'provisioning': return '启用中'
case 'ready': return '已启用'
case 'error': return '启用失败'
default: return '未知状态'
}
}
// 把 models 端点返回的目录摊平成下拉选项。value 形如 provider::model[::effort],
// 永远不等于 'inherit'(界面不提供“跟随宿主模型”)。
export function collectModelOptions(models) {
const out = []
const seen = new Set()
const providers = Array.isArray(models?.providers) ? models.providers : []
for (const entry of providers) {
const provider = typeof entry?.provider === 'string' ? entry.provider : ''
if (!provider) continue
const list = Array.isArray(entry?.models) ? entry.models : []
for (const item of list) {
const model = typeof item?.model === 'string' ? item.model : ''
if (!model) continue
const efforts = Array.isArray(item?.reasoningEffort)
? item.reasoningEffort.filter(e => typeof e === 'string' && e.trim() !== '')
: []
if (efforts.length > 0) {
for (const effort of efforts) {
const value = provider + '::' + model + '::' + effort
if (value === 'inherit' || seen.has(value)) continue
seen.add(value)
out.push({ value, label: model + ' · ' + effort, provider, model, reasoningEffort: effort })
}
} else {
const value = provider + '::' + model
if (value === 'inherit' || seen.has(value)) continue
seen.add(value)
out.push({ value, label: model, provider, model })
}
}
}
return out
}
export function findModelOption(options, modelValue) {
if (!Array.isArray(options)) return undefined
return options.find(option => option.value === modelValue)
}
// 把某个席已保存的 model 对象映射成 { modelValue, modelLabel }。
export function describeModel(model, options) {
if (!model || typeof model !== 'object' || typeof model.provider !== 'string' || typeof model.model !== 'string') {
return { modelValue: '', modelLabel: UNCHOSEN_MODEL_LABEL }
}
const effort = typeof model.reasoningEffort === 'string' && model.reasoningEffort ? model.reasoningEffort : undefined
const match = (Array.isArray(options) ? options : []).find(option =>
option.provider === model.provider
&& option.model === model.model
&& (option.reasoningEffort ?? undefined) === effort)
if (match) return { modelValue: match.value, modelLabel: match.label }
const modelLabel = effort ? model.model + ' · ' + effort : model.model
const modelValue = effort
? model.provider + '::' + model.model + '::' + effort
: model.provider + '::' + model.model
return { modelValue, modelLabel }
}
// 兼容两种入参:CONTRACT 的项目视图用数组;共享 schema 里可能以 seatId 为键。
function normalizeSeats(seats) {
const map = {}
if (Array.isArray(seats)) {
for (const seat of seats) {
if (seat && typeof seat === 'object' && typeof seat.id === 'string') map[seat.id] = seat
}
} else if (seats && typeof seats === 'object') {
for (const [id, seat] of Object.entries(seats)) {
if (seat && typeof seat === 'object') map[id] = { id, ...seat }
}
}
return map
}
function cloneGroups() {
const out = {}
for (const key of Object.keys(SEAT_GROUPS)) out[key] = Array.from(SEAT_GROUPS[key])
return out
}
function pickSelectedId(requested) {
if (typeof requested === 'string' && SEAT_IDS.includes(requested)) return requested
return SEAT_IDS[0]
}
function hasOwn(obj, key) {
return obj !== null && obj !== undefined && Object.prototype.hasOwnProperty.call(obj, key)
}
export function draftOf(draft, seatId) {
if (!draft || typeof draft !== 'object') return {}
const entry = draft[seatId]
return entry && typeof entry === 'object' ? entry : {}
}
// 返回新的草稿映射(不可变):保留其它席的草稿,便于“切换角色不丢草稿”。
export function updateDraft(draft, seatId, patch) {
const base = draft && typeof draft === 'object' ? draft : {}
const previous = base[seatId] && typeof base[seatId] === 'object' ? base[seatId] : {}
return { ...base, [seatId]: { ...previous, ...(patch ?? {}) } }
}
export function clearDraft(draft, seatId) {
if (!draft || typeof draft !== 'object' || !hasOwn(draft, seatId)) return draft ?? {}
const next = { ...draft }
delete next[seatId]
return next
}
export function buildWorkbenchView(view, ui) {
const safeView = view && typeof view === 'object' ? view : {}
const project = safeView.project && typeof safeView.project === 'object' ? safeView.project : {}
const status = typeof project.status === 'string' ? project.status : 'pending'
const ready = status === 'ready'
const seatMap = normalizeSeats(project.seats)
const selectedSeatId = pickSelectedId(ui?.selectedSeatId)
const models = ui?.models ?? null
const modelOptions = collectModelOptions(models)
const draft = ui?.draft ?? null
const seats = SEAT_IDS.map(id => {
const def = SEATS[id]
const rec = seatMap[id] ?? {}
const seatStatus = typeof rec.status === 'string' ? rec.status : DEFAULT_SEAT_STATUS
return {
id,
name: def.label,
duty: def.duty,
status: seatStatus,
statusLabel: seatStatusLabel(seatStatus),
selected: id === selectedSeatId,
}
})
const seatDef = SEATS[selectedSeatId]
const seatRec = seatMap[selectedSeatId] ?? {}
const draftEntry = draftOf(draft, selectedSeatId)
let described
if (hasOwn(draftEntry, 'modelValue')) {
const raw = draftEntry.modelValue
if (raw === '' || raw === null || raw === undefined) {
described = { modelValue: '', modelLabel: UNCHOSEN_MODEL_LABEL }
} else {
const match = findModelOption(modelOptions, raw)
described = match
? { modelValue: match.value, modelLabel: match.label }
: { modelValue: String(raw), modelLabel: String(raw) }
}
} else if (hasOwn(draftEntry, 'model')) {
described = describeModel(draftEntry.model, modelOptions)
} else {
described = describeModel(seatRec.model ?? null, modelOptions)
}
const instructions = hasOwn(draftEntry, 'instructions')
? draftEntry.instructions
: (typeof seatRec.instructions === 'string' ? seatRec.instructions : '')
const selectedStatus = typeof seatRec.status === 'string' ? seatRec.status : DEFAULT_SEAT_STATUS
let boundCount = 0
let sessionCount = 0
for (const id of SEAT_IDS) {
const rec = seatMap[id]
if (rec?.status === 'bound') boundCount += 1
if (rec?.sessionId) sessionCount += 1
}
return {
projectTitle: typeof project.name === 'string' ? project.name : '',
ready,
project: {
id: project.id ?? '',
name: typeof project.name === 'string' ? project.name : '',
status,
statusLabel: projectStatusLabel(status),
workspaceId: project.workspaceId ?? null,
path: project.path ?? null,
seatCount: seats.length,
boundCount,
sessionCount,
},
seats,
groups: cloneGroups(),
selected: {
id: selectedSeatId,
name: seatDef.label,
duty: seatDef.duty,
responsibility: seatDef.responsibility,
status: selectedStatus,
statusLabel: seatStatusLabel(selectedStatus),
sessionId: seatRec.sessionId ?? null,
modelValue: described.modelValue,
modelLabel: described.modelLabel,
instructions,
modelOptions,
dirty: Object.keys(draftEntry).length > 0,
},
}
}

72
src/host/api.js Normal file
View File

@ -0,0 +1,72 @@
import { SEAT_IDS } from '../shared/roles.js'
function bad(message, code = 'sansheng/invalid') {
const error = new Error(message)
error.code = code
return error
}
function requireProjectId(payload) {
const id = payload?.projectId
if (typeof id !== 'string' || id.trim() === '') throw bad('缺少 projectId')
return id
}
function requireTaskId(payload) {
const id = payload?.taskId
if (typeof id !== 'string' || id.trim() === '') throw bad('缺少 taskId')
return id
}
// 生成 POST /api/sansheng 的处理函数:{endpoint,payload} -> {ok,value}|{ok,error}
export function createApiHandler(service) {
return async function handle(endpoint, payload) {
try {
switch (endpoint) {
case 'list':
return { ok: true, value: await service.list() }
case 'project':
return { ok: true, value: await service.project(requireProjectId(payload)) }
case 'open':
return { ok: true, value: await service.open(payload ?? {}) }
case 'enable':
return { ok: true, value: await service.enable(requireProjectId(payload)) }
case 'enableSeat': {
const seatId = payload?.seatId
if (!SEAT_IDS.includes(seatId)) throw bad(`未知席 ${String(seatId)}`)
return { ok: true, value: await service.enableSeat(requireProjectId(payload), seatId) }
}
case 'configure': {
const projectId = requireProjectId(payload)
const seatId = payload?.seatId
if (!SEAT_IDS.includes(seatId)) throw bad(`未知席 ${String(seatId)}`)
return { ok: true, value: await service.configure(projectId, seatId, { model: payload?.model, instructions: payload?.instructions }) }
}
case 'models':
return { ok: true, value: await service.models() }
case 'tasks':
return { ok: true, value: await service.tasks(requireProjectId(payload)) }
case 'taskCreate':
return { ok: true, value: await service.taskCreate(requireProjectId(payload), payload ?? {}) }
case 'taskDispatch':
return { ok: true, value: await service.taskDispatch(requireProjectId(payload), requireTaskId(payload)) }
case 'taskCancel':
return { ok: true, value: await service.taskCancel(requireProjectId(payload), requireTaskId(payload)) }
case 'artifacts':
return { ok: true, value: await service.artifacts(requireProjectId(payload)) }
case 'artifactAdd':
return { ok: true, value: await service.artifactAdd(requireProjectId(payload), payload ?? {}) }
default:
throw bad(`未知 endpoint ${String(endpoint)}`)
}
} catch (error) {
return {
ok: false,
error: {
code: error?.code ?? 'sansheng/error',
message: error?.message ?? String(error),
// 只有重试可能改变结果时才让界面显示“重试”;文件格式类错误重试没有意义。
retryable: error?.retryable !== false,
},
}
}
}
}

1
src/host/constants.js Normal file
View File

@ -0,0 +1 @@
export const ROUTE = '/api/sansheng'

34
src/host/model.js Normal file
View File

@ -0,0 +1,34 @@
// 模型配置:只记录会话级 model/selection 事件,绝不写 profile 全局默认。
// 关键约束:不调用 sessionController.selectModel / saveSelection(它们会改全局默认)。
export class ModelError extends Error {
constructor(code, message) { super(message); this.name = 'ModelError'; this.code = code }
}
export function normalizeSelection(selection) {
if (selection === null || selection === undefined) return null
if (typeof selection !== 'object') throw new ModelError('sansheng/model-invalid', '模型选择必须是对象或 null')
const { provider, model, reasoningEffort } = selection
if (typeof provider !== 'string' || provider.trim() === '') throw new ModelError('sansheng/model-invalid', '缺少 provider')
if (typeof model !== 'string' || model.trim() === '') throw new ModelError('sansheng/model-invalid', '缺少 model')
const out = { provider, model }
if (reasoningEffort !== undefined && reasoningEffort !== null && reasoningEffort !== '') out.reasoningEffort = reasoningEffort
return out
}
// 对一个已绑定会话应用模型选择。返回 agent.model.current()。
export async function applyModel(host, sessionId, selection) {
const normalized = normalizeSelection(selection)
if (!normalized) return null
const resolved = await host.sessionController.resolveAgent(sessionId)
if (!resolved || (resolved && 'error' in resolved)) {
const err = resolved?.error
throw new ModelError('sansheng/unbound', `会话不可用:${err?.message ?? err?.code ?? 'resolve failed'}`)
}
const agent = resolved.agent
// 用 llm 校验路由/思考强度,不能只依赖 select 的字符串。
await host.llm.resolveCallConfig(normalized)
// 复核对象仍是此 ID 的活跃 Agent。
if (host.agents.get(sessionId) !== agent) throw new ModelError('sansheng/conflict', '配置期间 Agent 已变化')
agent.model.select(normalized)
return agent.model.current()
}

14
src/host/paths.js Normal file
View File

@ -0,0 +1,14 @@
import { homedir } from 'node:os'
import { join } from 'node:path'
/** DSH 主目录,与宿主一致:优先 DSH_HOME,否则 ~/.dsh。 */
export function dshHome(env = process.env) {
const fromEnv = env.DSH_HOME
if (typeof fromEnv === 'string' && fromEnv.trim() !== '') return fromEnv
return join(homedir(), '.dsh')
}
/** 三省六部自己的项目状态文件;与用户其它 DSH 数据分开存放。 */
export function sanshengStatePath(home = dshHome()) {
return join(home, 'sansheng', 'state.json')
}

30
src/host/prompt.js Normal file
View File

@ -0,0 +1,30 @@
import { seatBySessionId } from '../shared/roles.js'
export const PROMPT_SECTION = 'sansheng'
export function renderSeatPrompt({ project, seatId, seat }) {
const lines = [
`你在「${project?.name ?? project?.id ?? '当前项目'}」项目中担任${seat.label}(${seatId})。`,
`本席职责:${seat.responsibility}`,
]
const note = project?.seats?.[seatId]?.instructions
if (typeof note === 'string' && note.trim() !== '') lines.push(`补充说明:${note.trim()}`)
lines.push('只在本项目本席会话内工作;不要修改其他项目或其他席的配置,也不要替用户提升权限。')
return lines.join('\n')
}
// 注册动态 systemPrompt section:只对十席会话注入本席角色文本,其它会话返回空串。
export function installPromptSection(ctx, { store }) {
return ctx.systemPrompt.section({
name: PROMPT_SECTION,
order: 60,
interpolate: false,
text: context => {
const sessionId = context?.agent?.id
if (!sessionId) return ''
const found = seatBySessionId(store.state?.projects, sessionId)
if (!found) return ''
return renderSeatPrompt({ project: found.project, seatId: found.seatId, seat: found.seat })
},
})
}

191
src/host/provision.js Normal file
View File

@ -0,0 +1,191 @@
// 严格会话创建/恢复:先持久化计划 ID,再查是否已存在,只创建缺失项;
// ID 不一致立即停止后续创建并保留记录;失败保留已完成绑定,重试只补未完成项。
import { randomUUID } from 'node:crypto'
import { SEAT_IDS, SEATS } from '../shared/roles.js'
import { applyModel } from './model.js'
export class ProvisionError extends Error {
constructor(code, message) { super(message); this.name = 'ProvisionError'; this.code = code }
}
function isNotFound(error) {
if (!error) return false
const code = String(error.code ?? '')
if (/not.?found/i.test(code)) return true
const message = String(error.message ?? '')
return /not.?found|不存在|ENOENT/i.test(message)
}
export function createProvisioner({ store, host, now = () => Date.now() }) {
const locks = new Map()
function withLock(key, fn) {
const prev = locks.get(key) ?? Promise.resolve()
const run = prev.then(fn, fn)
const guarded = run.finally(() => { if (locks.get(key) === guarded) locks.delete(key) })
locks.set(key, guarded)
return guarded
}
async function markBound(projectId, seatId, sessionId) {
await store.mutate(s => {
const p = s.projects[projectId]
const st = p.seats[seatId]
st.sessionId = sessionId
st.status = 'bound'
st.error = null
st.updatedAt = now()
p.updatedAt = now()
})
}
async function markFailed(projectId, seatId, message) {
await store.mutate(s => {
const st = s.projects[projectId].seats[seatId]
st.status = 'failed'
st.error = String(message)
st.updatedAt = now()
})
}
async function markMismatch(projectId, seatId, planned, actual) {
await store.mutate(s => {
const st = s.projects[projectId].seats[seatId]
st.status = 'failed'
st.error = `会话 ID 不一致:计划 ${planned},实际 ${actual ?? 'null'};已停止后续创建,请核对`
st.updatedAt = now()
})
}
// 建好会话后立即应用该席预先配置的模型;没有配置就保持原样(绝不在这里替角色挑模型)。
async function applyPreconfiguredModel(projectId, seatId) {
const seat = store.get(projectId)?.seats?.[seatId]
if (!seat || !seat.sessionId || !seat.model) return
try { await applyModel(host, seat.sessionId, seat.model) } catch (error) {
console.warn('[sansheng] 应用预配置模型失败:', error && error.message ? error.message : error)
}
}
async function ensureSeat(projectId, seatId) {
await store.ensureLoaded()
const seat = store.get(projectId).seats[seatId]
if (seat.status === 'bound' && seat.sessionId) return { ok: true, skipped: true }
// 先持久化计划 sessionId 与 creating 状态,再发起宿主调用。
await store.mutate(s => {
const st = s.projects[projectId].seats[seatId]
if (!st.plannedSessionId) st.plannedSessionId = randomUUID()
st.status = 'creating'
st.error = null
st.updatedAt = now()
s.projects[projectId].updatedAt = now()
})
const project = store.get(projectId)
const planned = project.seats[seatId].plannedSessionId
// 已存在则不重建,按既有会话恢复绑定。
let resolved
try { resolved = await host.sessionController.resolveAgent(planned) } catch (error) {
await markFailed(projectId, seatId, `resolve: ${error?.message ?? error}`)
return { ok: false }
}
if (resolved && !('error' in resolved) && resolved.agent) {
await markBound(projectId, seatId, planned)
await applyPreconfiguredModel(projectId, seatId)
return { ok: true, recovered: true }
}
if (resolved && 'error' in resolved && resolved.error && !isNotFound(resolved.error)) {
await markFailed(projectId, seatId, `resolve: ${resolved.error?.message ?? resolved.error?.code ?? 'error'}`)
return { ok: false }
}
// 创建缺失项。返回 ID 必须与计划一致,否则保留实际 ID 并停止后续创建。
let returned
try {
returned = await host.sessionController.create({ sessionId: planned, workspaceId: project.workspaceId ?? undefined })
} catch (error) {
await markFailed(projectId, seatId, `create: ${error?.message ?? error}`)
return { ok: false }
}
if (!returned || returned.sessionId !== planned) {
await markMismatch(projectId, seatId, planned, returned?.sessionId ?? null)
return { ok: false, fatal: true }
}
await markBound(projectId, seatId, planned)
await applyPreconfiguredModel(projectId, seatId)
return { ok: true }
}
// 只开启一个部门(用户手动点,或派工按需触发)。
async function enableSeat(projectId, seatId) {
return withLock(projectId, async () => {
await store.ensureLoaded()
const project = store.get(projectId)
if (!project) throw new ProvisionError('sansheng/not-found', `项目 ${projectId} 不存在`)
if (!SEAT_IDS.includes(seatId)) throw new ProvisionError('sansheng/invalid', `未知席 ${String(seatId)}`)
const result = await ensureSeat(projectId, seatId)
if (result.ok && typeof host.sessionController.rename === 'function') {
const seat = store.get(projectId)?.seats?.[seatId]
if (seat?.sessionId) {
try { await host.sessionController.rename({ sessionId: seat.sessionId, title: `${SEATS[seatId].label}会话` }) } catch { /* 标题失败不影响绑定 */ }
}
}
await store.mutate(s => {
const p = s.projects[projectId]
const allBound = SEAT_IDS.every(id => p.seats[id]?.status === 'bound')
p.status = allBound ? 'ready' : (p.status === 'error' ? 'pending' : p.status)
p.updatedAt = now()
p.revision = (p.revision ?? 0) + 1
})
return { projectId, seatId, ...result }
})
}
async function enable(projectId) {
return withLock(projectId, async () => {
await store.ensureLoaded()
const project = store.get(projectId)
if (!project) throw new ProvisionError('sansheng/not-found', `项目 ${projectId} 不存在`)
await store.mutate(s => {
const p = s.projects[projectId]
p.status = 'provisioning'
p.updatedAt = now()
p.revision = (p.revision ?? 0) + 1
})
let fatal = false
for (const seatId of SEAT_IDS) {
const result = await ensureSeat(projectId, seatId)
if (result.fatal) { fatal = true; break }
}
// 预热:把每个已绑定会话加载一次(resolveAgent 会 resume 冷会话并生成 summary),
// 否则 DSH 左侧工作区会话树(orderByRecency 依赖 summary)会跳过这些会话不显示。
if (typeof host.sessionController.resolveAgent === 'function') {
for (const seatId of SEAT_IDS) {
const seat = store.get(projectId)?.seats?.[seatId]
if (!seat || !seat.sessionId || seat.status !== 'bound') continue
try { await host.sessionController.resolveAgent(seat.sessionId) } catch { /* 预热失败不影响绑定 */ }
}
}
// 给每个已绑定会话写标题(如“丞相会话”),让左侧工作区列表能收录并显示为独立对话。
if (typeof host.sessionController.rename === 'function') {
for (const seatId of SEAT_IDS) {
const seat = store.get(projectId)?.seats?.[seatId]
if (!seat || !seat.sessionId || seat.status !== 'bound') continue
try {
await host.sessionController.rename({ sessionId: seat.sessionId, title: `${SEATS[seatId].label}会话` })
} catch { /* 标题失败不影响绑定;下次启用会重试 */ }
}
}
await store.mutate(s => {
const p = s.projects[projectId]
const allBound = SEAT_IDS.every(id => p.seats[id].status === 'bound')
p.status = allBound ? 'ready' : 'error'
p.updatedAt = now()
p.revision = (p.revision ?? 0) + 1
})
return { projectId, fatal }
})
}
return { enable, enableSeat, ensureSeat }
}

288
src/host/service.js Normal file
View File

@ -0,0 +1,288 @@
import { SEAT_IDS, SEATS, SEAT_GROUPS } from '../shared/roles.js'
import { emptyTask, emptyArtifact } from '../shared/schema.js'
import { applyModel, normalizeSelection } from './model.js'
export class ServiceError extends Error {
constructor(code, message) { super(message); this.name = 'ServiceError'; this.code = code }
}
export function seatView(seatId, seat) {
const def = SEATS[seatId]
return {
id: seatId,
label: def.label,
duty: def.duty,
responsibility: def.responsibility,
status: seat.status,
sessionId: seat.sessionId ?? null,
model: seat.model ?? null,
instructions: seat.instructions ?? '',
error: seat.error ?? null,
}
}
export function projectView(project) {
return {
revision: project.revision ?? 0,
project: {
id: project.id,
name: project.name,
workspaceId: project.workspaceId ?? null,
path: project.path ?? null,
status: project.status,
seats: SEAT_IDS.map(id => seatView(id, project.seats[id])),
groups: {
lead: [...SEAT_GROUPS.lead],
sansheng: [...SEAT_GROUPS.sansheng],
liubu: [...SEAT_GROUPS.liubu],
},
},
}
}
export function normalizeCatalog(catalog) {
const providers = []
const entryFor = provider => {
let entry = providers.find(p => p.provider === provider)
if (!entry) { entry = { provider, models: [] }; providers.push(entry) }
return entry
}
const groups = catalog?.providers ?? catalog?.groups ?? catalog?.entries ?? []
if (Array.isArray(groups)) {
for (const g of groups) {
const provider = g?.provider ?? g?.id ?? g?.ref ?? g?.name
const list = g?.models ?? g?.entries ?? []
for (const m of Array.isArray(list) ? list : []) {
const modelId = typeof m === 'string' ? m : (m?.model ?? m?.id ?? m?.name)
if (!provider || !modelId) continue
const entry = entryFor(provider)
if (entry.models.some(x => x.model === modelId)) continue
const effort = typeof m === 'object' ? (m.reasoningEffort ?? m.reasoning) : undefined
entry.models.push(effort ? { model: modelId, reasoningEffort: effort } : { model: modelId })
}
}
}
const def = catalog?.default ?? catalog?.deploymentDefault ?? null
return {
providers,
default: def && (def.provider || def.model) ? { provider: def.provider ?? null, model: def.model ?? null } : null,
failures: catalog?.failures ?? catalog?.isolated ?? [],
}
}
export class SanshengService {
constructor({ store, host, provisioner }) {
this.store = store
this.host = host
this.provisioner = provisioner
}
async list() {
await this.store.ensureLoaded()
return {
projects: [...this.store.list()]
.sort((a, b) => String(a.name).localeCompare(String(b.name), 'zh-Hans-CN'))
.map(p => ({ id: p.id, name: p.name, status: p.status, revision: p.revision ?? 0 })),
}
}
async open({ workspaceId, name, path } = {}) {
await this.store.ensureLoaded()
if (!workspaceId && !path) throw new ServiceError('sansheng/invalid', '需要 workspaceId 或 path')
const registry = this.host.workspaceRegistry
let ws
if (workspaceId) {
ws = registry.get(workspaceId)
if (!ws) throw new ServiceError('sansheng/not-found', `未找到工作区 ${workspaceId}`)
} else {
ws = await registry.resolveByPath(path)
if (!ws) ws = await registry.create(path, name)
}
const id = ws.id ?? ws.workspaceId
await this.store.mutate(() => {
this.store.ensureProjectRecord({
id,
name: name ?? ws.title ?? ws.name ?? id,
workspaceId: id,
path: ws.path ?? path ?? null,
})
})
return projectView(this.store.get(id))
}
async project(projectId) {
await this.store.ensureLoaded()
const p = this.store.get(projectId)
if (!p) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
return projectView(p)
}
async enable(projectId) {
await this.store.ensureLoaded()
if (!this.store.get(projectId)) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
await this.provisioner.enable(projectId)
return this.project(projectId)
}
async enableSeat(projectId, seatId) {
await this.store.ensureLoaded()
if (!this.store.get(projectId)) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
if (!SEAT_IDS.includes(seatId)) throw new ServiceError('sansheng/invalid', `未知席 ${String(seatId)}`)
await this.provisioner.enableSeat(projectId, seatId)
return this.project(projectId)
}
async configure(projectId, seatId, { model, instructions } = {}) {
await this.store.ensureLoaded()
if (!SEAT_IDS.includes(seatId)) throw new ServiceError('sansheng/invalid', `未知席 ${seatId}`)
const project = this.store.get(projectId)
if (!project) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
const seat = project.seats[seatId]
let normalized
let applied = null
if (model !== undefined) {
normalized = normalizeSelection(model) // 可能抛 sansheng/model-invalid
if (seat.sessionId) applied = await applyModel(this.host, seat.sessionId, normalized)
}
if (instructions !== undefined && typeof instructions !== 'string') {
throw new ServiceError('sansheng/invalid', 'instructions 必须是字符串')
}
await this.store.mutate(s => {
const target = s.projects[projectId].seats[seatId]
if (model !== undefined) target.model = normalized
if (instructions !== undefined) target.instructions = instructions
target.updatedAt = Date.now()
s.projects[projectId].updatedAt = Date.now()
s.projects[projectId].revision = (s.projects[projectId].revision ?? 0) + 1
})
return { seat: seatView(seatId, this.store.get(projectId).seats[seatId]), applied }
}
async models() {
await this.store.ensureLoaded()
const catalog = await this.host.sessionController.modelCatalog()
return normalizeCatalog(catalog)
}
async tasks(projectId) {
await this.store.ensureLoaded()
const project = this.store.get(projectId)
if (!project) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
return { tasks: [...(project.tasks ?? [])] }
}
async taskCreate(projectId, input = {}) {
await this.store.ensureLoaded()
if (!this.store.get(projectId)) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
const title = String(input.title ?? '').trim()
if (!title) throw new ServiceError('sansheng/invalid', '任务标题不能为空')
if (!SEAT_IDS.includes(input.ownerSeatId)) throw new ServiceError('sansheng/invalid', `未知主责席 ${String(input.ownerSeatId)}`)
const goal = typeof input.goal === 'string' ? input.goal : ''
const task = await this.store.mutate(s => {
const project = s.projects[projectId]
project.taskSeq = (project.taskSeq ?? 0) + 1
const next = emptyTask({ id: `task-${project.taskSeq}`, title, goal, ownerSeatId: input.ownerSeatId })
if (!Array.isArray(project.tasks)) project.tasks = []
project.tasks.push(next)
project.updatedAt = Date.now()
project.revision = (project.revision ?? 0) + 1
return { ...next }
})
return { task }
}
async taskDispatch(projectId, taskId) {
await this.store.ensureLoaded()
const project = this.store.get(projectId)
if (!project) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
const task = (project.tasks ?? []).find(item => item.id === taskId)
if (!task) throw new ServiceError('sansheng/not-found', `任务 ${taskId} 不存在`)
if (task.status === 'done' || task.status === 'cancelled') throw new ServiceError('sansheng/invalid', '已完成或已取消的任务不能再次派工')
let seat = project.seats[task.ownerSeatId]
if (!seat || seat.status !== 'bound' || !seat.sessionId) {
// 按需开启:丞相派工时只给出主责部门,由系统用该部门预配置的模型开启会话;丞相不选模型。
await this.provisioner.enableSeat(projectId, task.ownerSeatId)
seat = this.store.get(projectId)?.seats?.[task.ownerSeatId]
if (!seat || seat.status !== 'bound' || !seat.sessionId) {
throw new ServiceError('sansheng/seat-unbound', `「${SEATS[task.ownerSeatId]?.label ?? task.ownerSeatId}」的会话还没开启成功,请稍后重试`)
}
}
const text = `【任务】${task.title}${task.goal ? '\n' + task.goal : ''}`
let delivered = false
let note = ''
const controller = this.host.sessionController
for (const name of ['sendMessage', 'appendMessage', 'prompt', 'sendUserMessage']) {
if (typeof controller?.[name] !== 'function') continue
try {
await controller[name]({ sessionId: seat.sessionId, text, content: text })
delivered = true
break
} catch (error) {
note = `发送失败:${error?.message ?? error}`
}
}
const next = await this.store.mutate(s => {
const target = s.projects[projectId].tasks.find(item => item.id === taskId)
target.status = delivered ? 'dispatched' : 'prepared'
target.note = delivered ? '' : (note || '宿主未提供发送接口,已记录待执行')
target.sessionId = seat.sessionId
target.dispatchedAt = Date.now()
target.updatedAt = Date.now()
s.projects[projectId].updatedAt = Date.now()
s.projects[projectId].revision = (s.projects[projectId].revision ?? 0) + 1
return { ...target }
})
return { task: next, delivered }
}
async taskCancel(projectId, taskId) {
await this.store.ensureLoaded()
if (!this.store.get(projectId)) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
const next = await this.store.mutate(s => {
const target = s.projects[projectId].tasks.find(item => item.id === taskId)
if (!target) throw new ServiceError('sansheng/not-found', `任务 ${taskId} 不存在`)
if (target.status === 'done') throw new ServiceError('sansheng/invalid', '已完成的任务不能取消')
target.status = 'cancelled'
target.updatedAt = Date.now()
s.projects[projectId].revision = (s.projects[projectId].revision ?? 0) + 1
return { ...target }
})
return { task: next }
}
async artifacts(projectId) {
await this.store.ensureLoaded()
const project = this.store.get(projectId)
if (!project) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
return { artifacts: [...(project.artifacts ?? [])] }
}
async artifactAdd(projectId, input = {}) {
await this.store.ensureLoaded()
if (!this.store.get(projectId)) throw new ServiceError('sansheng/not-found', `项目 ${projectId} 不存在`)
const title = String(input.title ?? '').trim()
if (!title) throw new ServiceError('sansheng/invalid', '成果名称不能为空')
const artifact = await this.store.mutate(s => {
const project = s.projects[projectId]
if (input.taskId && !(project.tasks ?? []).some(item => item.id === input.taskId)) {
throw new ServiceError('sansheng/invalid', `关联任务 ${input.taskId} 不存在`)
}
project.artifactSeq = (project.artifactSeq ?? 0) + 1
const next = emptyArtifact({
id: `artifact-${project.artifactSeq}`,
title,
path: typeof input.path === 'string' ? input.path : '',
summary: typeof input.summary === 'string' ? input.summary : '',
taskId: input.taskId ?? null,
})
if (!Array.isArray(project.artifacts)) project.artifacts = []
project.artifacts.push(next)
project.updatedAt = Date.now()
project.revision = (project.revision ?? 0) + 1
return { ...next }
})
return { artifact }
}
}

153
src/host/store.js Normal file
View File

@ -0,0 +1,153 @@
// 项目状态存储:单个 JSON 文件,原子写,读取时严格校验。
// 读取时按版本分流:当前格式直接校验;旧格式先迁移再原子写回;其它情况一律报明确错误,
// 不静默回退成“健康空状态”,也绝不覆盖原始文件。
import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
import { dirname } from 'node:path'
import { STATE_VERSION, emptyState, emptyProject, validateState } from '../shared/schema.js'
import { isLegacyState, migrateLegacyState } from '../shared/migrate.js'
import { seatBySessionId } from '../shared/roles.js'
export class StoreError extends Error {
constructor(code, message, { retryable = true } = {}) {
super(message)
this.name = 'StoreError'
this.code = code
this.retryable = retryable
}
}
function isObject(v) { return v !== null && typeof v === 'object' && !Array.isArray(v) }
// 旧版本状态没有任务/成果字段:读入时就地补空数组,不需要改文件版本。
function normalizeProjects(state) {
for (const project of Object.values(state.projects ?? {})) {
if (!Array.isArray(project.tasks)) project.tasks = []
if (!Array.isArray(project.artifacts)) project.artifacts = []
if (!Number.isFinite(project.taskSeq)) project.taskSeq = 0
if (!Number.isFinite(project.artifactSeq)) project.artifactSeq = 0
}
return state
}
export class SanshengStore {
constructor(file) {
this.file = file
this.state = emptyState()
this._queue = Promise.resolve()
this._loaded = false
this._loadPromise = null
}
// 惰性加载:插件 apply 必须同步返回,真实 HTTP 请求到达时再确保状态已读入。
ensureLoaded() {
if (this._loaded) return Promise.resolve()
if (!this._loadPromise) {
this._loadPromise = this.load().catch(error => { this._loadPromise = null; throw error })
}
return this._loadPromise
}
async load() {
let raw
try {
raw = await readFile(this.file, 'utf8')
} catch (error) {
if (error?.code === 'ENOENT') { this.state = emptyState(); this._loaded = true; return }
throw new StoreError('sansheng/state-unreadable', `无法读取状态文件:${error?.message ?? error}`)
}
let parsed
try { parsed = JSON.parse(raw) } catch (error) {
throw new StoreError(
'sansheng/state-json',
`状态文件不是合法 JSON:${error.message}。文件未被改动;请修复该文件或从版本库恢复。`,
{ retryable: false },
)
}
if (!isObject(parsed)) {
throw new StoreError('sansheng/state-corrupt', '状态文件顶层不是对象。文件未被改动。', { retryable: false })
}
// 1) 已经是当前格式:严格校验。
if (parsed.version === STATE_VERSION) {
const valid = validateState(parsed)
if (!valid.ok) {
throw new StoreError('sansheng/state-corrupt', `状态文件损坏:${valid.error}。文件未被改动。`, { retryable: false })
}
this.state = normalizeProjects(valid.state)
this._loaded = true
return
}
// 2) 已知旧格式:转换成当前格式,校验通过后原子写回。
if (isLegacyState(parsed)) {
const migrated = migrateLegacyState(parsed)
if (!migrated.ok) {
throw new StoreError(migrated.code, `${migrated.message}。原文件未被改动。`, { retryable: false })
}
this.state = migrated.state
if (migrated.warnings.length > 0) {
console.warn('[sansheng] 旧数据迁移提示:', migrated.warnings.join(';'))
}
// 只有转换结果已经过 validateState,才会走到这里写盘;写失败(磁盘错误等)不覆盖原文件。
await this.save()
this._loaded = true
return
}
// 3) 未知版本:明确说“不支持”,不再谎报“损坏”。
throw new StoreError(
'sansheng/state-unsupported',
`状态文件格式不受支持:检测到版本 ${String(parsed.version)},本插件当前格式为 ${STATE_VERSION}(可自动升级的旧格式为 2/3)。文件未被改动。`,
{ retryable: false },
)
}
snapshot() { return structuredClone(this.state) }
get(projectId) { return this.state.projects[projectId] }
list() { return Object.values(this.state.projects) }
seatBySession(sessionId) { return seatBySessionId(this.state.projects, sessionId) }
// 所有写操作经此串行化:同一时刻只有一个 mutate 在跑,失败回滚内存状态。
async mutate(fn) {
const run = async () => {
await this.ensureLoaded()
const before = structuredClone(this.state)
try {
const result = await fn(this.state)
this.state.seq = (this.state.seq ?? 0) + 1
await this.save()
return result
} catch (error) {
this.state = before
throw error
}
}
this._queue = this._queue.then(run, run)
return this._queue
}
async save() {
await mkdir(dirname(this.file), { recursive: true })
const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`
await writeFile(tmp, JSON.stringify(this.state, null, 2), 'utf8')
await rename(tmp, this.file)
}
// 确保项目记录存在;已存在则只补空字段,不覆盖既有会话/配置。
ensureProjectRecord({ id, name, workspaceId = null, path = null, now = Date.now() }) {
let project = this.state.projects[id]
if (!project) {
project = emptyProject({ id, name: name ?? id, workspaceId, path, now })
this.state.projects[id] = project
return project
}
if (name && !project.name) project.name = name
if (workspaceId && !project.workspaceId) project.workspaceId = workspaceId
if (path && !project.path) project.path = path
project.updatedAt = now
project.revision = (project.revision ?? 0) + 1
return project
}
}

201
src/native/index.js Normal file
View File

@ -0,0 +1,201 @@
// dsh-go 原生接入:把纯视图树挂到宿主原生面板桥。
// 全程用特性探测(ctx.inject + typeof 检查),不 import 宿主内部源码。
import { buildPanelView } from './panel.js'
import { SEAT_IDS } from '../shared/roles.js'
const PANEL_ID = 'sansheng'
// 进程内缓存:原生作用域没有 workspaceId,只能由 sessionId 反查项目。
// 真实数据源需要宿主注入的服务或 HTTP 接通;拿不到时视图如实显示提示。
const viewBySession = new Map()
const selectionBySession = new Map()
const modelsBySession = new Map()
/** 把一个项目视图中各席的 sessionId 记入缓存,供 scope.sessionId 反查。 */
function cacheProject(project) {
if (!project || typeof project !== 'object') return
const seats = project.seats
for (const id of SEAT_IDS) {
let seat = null
if (Array.isArray(seats)) seat = seats.find((s) => s && s.id === id) || null
else if (seats && typeof seats === 'object') seat = seats[id] || null
if (seat && typeof seat.sessionId === 'string' && seat.sessionId) {
viewBySession.set(seat.sessionId, project)
}
}
}
/** 由 scope 反查项目视图:优先宿主注入的反查服务,其次 sessions.binding,最后进程内缓存。 */
function resolveProject(native, scope) {
const sid = scope && typeof scope.sessionId === 'string' ? scope.sessionId : null
const lookup = (native && (native.sansheng || native.sanshengProjects)) || null
if (lookup && typeof lookup.projectForScope === 'function') {
try {
const p = lookup.projectForScope(scope)
if (p) { cacheProject(p); return p }
} catch (e) { /* 特性探测失败,忽略 */ }
}
if (lookup && typeof lookup.projectForSession === 'function' && sid) {
try {
const p = lookup.projectForSession(sid)
if (p) { cacheProject(p); return p }
} catch (e) { /* ignore */ }
}
let workspaceId = null
try {
const sessions = native && native.sessions
if (sessions && typeof sessions.binding === 'function' && sid) {
const b = sessions.binding(sid)
workspaceId = (b && (b.workspaceId || (b.workspace && b.workspace.id))) || null
}
} catch (e) { /* ignore */ }
if (lookup && typeof lookup.projectForWorkspace === 'function' && workspaceId) {
try {
const p = lookup.projectForWorkspace(workspaceId)
if (p) { cacheProject(p); return p }
} catch (e) { /* ignore */ }
}
if (sid && viewBySession.has(sid)) return viewBySession.get(sid)
return null
}
/** 组装 buildPanelView 所需的 input。 */
function makeView(native, scope) {
const sid = scope && typeof scope.sessionId === 'string' ? scope.sessionId : null
const project = resolveProject(native, scope)
const selectedSeatId = sid && selectionBySession.has(sid) ? selectionBySession.get(sid) : null
const models = sid && modelsBySession.has(sid) ? modelsBySession.get(sid) : null
return buildPanelView({ project, selectedSeatId, models })
}
/** 归一化事件里的 action(dsh-go 可能回传对象或字符串 + value)。 */
function normalizeAction(event) {
const a = event && event.action
if (a && typeof a === 'object') return a
const v = event && event.value
if (v && typeof v === 'object' && typeof v.type === 'string') return v
if (typeof a === 'string') return Object.assign({ type: a }, v && typeof v === 'object' ? v : {})
return null
}
async function handleEvent(native, scope, event) {
const sid = scope && typeof scope.sessionId === 'string' ? scope.sessionId : null
const action = normalizeAction(event)
if (!action || typeof action.type !== 'string') return []
switch (action.type) {
case 'sansheng/select-seat': {
if (sid && action.seatId) selectionBySession.set(sid, action.seatId)
return [{ type: 'refresh', id: PANEL_ID }]
}
case 'sansheng/select-model': {
if (sid && action.seatId) selectionBySession.set(sid, action.seatId)
// 模型持久化需要宿主 HTTP / 服务接通;原生面板暂不静默写入。
return [{ type: 'toast', text: '模型选择在原生面板暂未接持久化,请在 Web 端保存(需真机核验)' }]
}
case 'sansheng/enter-session': {
// effect 契约暂无会话跳转;优先探测宿主扩展方法,否则如实提示。
const bridged = native && native.dshGo
const open =
(bridged && (bridged.openSession || bridged.navigate)) ||
(native && native.sansheng && native.sansheng.openSession)
if (typeof open === 'function' && action.sessionId) {
try {
await open(action.sessionId)
return [{ type: 'toast', text: '已请求打开会话' }]
} catch (e) { /* 落到提示分支 */ }
}
return [{ type: 'toast', text: '原生 effect 暂不支持会话跳转,请从宿主会话列表进入(需真机核验)' }]
}
default:
return []
}
}
/** 可选 data 提供者:尽力通过宿主 HTTP 的 list/project 反查项目(特性探测 fetch)。 */
function makeDataProvider(native, dshGo) {
return function data(scope, emit) {
let cancelled = false
const run = async () => {
if (typeof fetch !== 'function') return
const sid = scope && typeof scope.sessionId === 'string' ? scope.sessionId : null
if (!sid) return
const post = async (endpoint, payload) => {
const res = await fetch('/api/sansheng', {
method: 'POST',
credentials: 'same-origin',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ endpoint, payload: payload == null ? null : payload }),
})
if (!res.ok) throw new Error('HTTP ' + res.status)
const r = await res.json()
if (!r || r.ok !== true) throw new Error((r && r.error && r.error.message) || 'request failed')
return r.value
}
const list = await post('list')
const projects = list && Array.isArray(list.projects) ? list.projects : []
for (const meta of projects) {
const value = await post('project', { projectId: meta.id })
const project = value && value.project ? value.project : value
cacheProject(project)
const seats = project && project.seats
const found = Array.isArray(seats)
? seats.some((s) => s && s.sessionId === sid)
: seats && Object.values(seats).some((s) => s && s.sessionId === sid)
if (found) {
if (!cancelled) {
try { emit({ project }) } catch (e) { /* ignore */ }
try { if (dshGo && typeof dshGo.refresh === 'function') dshGo.refresh(PANEL_ID, scope) } catch (e) { /* ignore */ }
}
return
}
}
}
run().catch(() => {})
return () => { cancelled = true }
}
}
/**
* 原生接入入口。
* @param {object} ctx Cordis context(由宿主注入)。
* @returns {() => void} disposer
*/
export function install(ctx) {
if (!ctx || typeof ctx.inject !== 'function') return () => {}
return ctx.inject(['dshGo', 'sessions'], (native) => {
const dshGo = native && native.dshGo
// 特性探测:宿主没有 dshGo.panel 就安静退出(不是 dsh-go / 桥未就绪)。
if (!dshGo || typeof dshGo.panel !== 'function') return () => {}
const disposers = []
try {
const offPanel = native.dshGo.panel(PANEL_ID, {
view: (scope, caps) => makeView(native, scope),
data: makeDataProvider(native, native.dshGo),
})
if (typeof offPanel === 'function') disposers.push(offPanel)
} catch (e) { /* 桥不完整时保持静默 */ }
if (typeof native.dshGo.on === 'function') {
try {
const offOn = native.dshGo.on(PANEL_ID, (scope, event) => handleEvent(native, scope, event))
if (typeof offOn === 'function') disposers.push(offOn)
} catch (e) { /* ignore */ }
}
return () => {
for (const off of disposers) {
try { off() } catch (e) { /* ignore */ }
}
}
})
}
export default { install }

198
src/native/panel.js Normal file
View File

@ -0,0 +1,198 @@
// dsh-go 原生面板:纯视图树构造函数。
// 仅依赖共享的角色定义(纯 JS),不 import 任何宿主 / React / DOM 代码。
// 硬约束(在下方逻辑中自然满足,并由 test/native.test.js 断言):
// 节点总数 ≤120、最大深度 ≤8、任何 options / items 列表 ≤8 项、无自由文本输入控件。
import { SEATS, SEAT_IDS, SEAT_GROUPS } from '../shared/roles.js'
const GROUP_ORDER = ['lead', 'sansheng', 'liubu']
const GROUP_TITLE = { lead: '统领', sansheng: '三省', liubu: '六部' }
const MAX_OPTIONS = 8 // 原生单选最多 8 项(含“请选择模型”占位)
const PROJECT_STATUS_TEXT = {
pending: '待启用',
provisioning: '启用中',
ready: '已就绪',
error: '异常',
}
const SEAT_STATUS_TEXT = {
pending: '待启用',
creating: '创建中',
bound: '已绑定',
failed: '失败',
missing: '缺失',
}
function asText(v) {
return typeof v === 'string' ? v : ''
}
/** 兼容 project.seats 为数组(项目视图)或对象(内部状态)。 */
function seatRecords(project) {
const out = {}
const seats = project ? project.seats : null
if (Array.isArray(seats)) {
for (const s of seats) if (s && SEATS[s.id]) out[s.id] = s
} else if (seats && typeof seats === 'object') {
for (const id of SEAT_IDS) if (seats[id]) out[id] = seats[id]
}
return out
}
function isBound(seat) {
return !!seat && typeof seat.sessionId === 'string' && seat.sessionId.length > 0
}
function modelValue(model) {
if (!model || typeof model !== 'object') return ''
if (typeof model.provider !== 'string' || typeof model.model !== 'string') return ''
return model.provider + '::' + model.model
}
function flattenModels(models) {
const opts = []
const providers = models && Array.isArray(models.providers) ? models.providers : []
for (const p of providers) {
const pid = asText(p && p.provider)
if (!pid) continue
const list = Array.isArray(p && p.models) ? p.models : []
for (const m of list) {
const mid = typeof m === 'string' ? m : asText(m && m.model)
if (!mid) continue
opts.push({ value: pid + '::' + mid, label: pid + ' / ' + mid })
if (opts.length >= MAX_OPTIONS - 1) break // 留一位给占位项
}
if (opts.length >= MAX_OPTIONS - 1) break
}
return opts
}
/** 模型原生单选:value 为空显示“请选择模型”。整体 ≤8 项。 */
function buildModelSelect(project, seat, models) {
const real = flattenModels(models)
const options = [{ value: '', label: '请选择模型' }].concat(real).slice(0, MAX_OPTIONS)
const want = modelValue(seat && seat.model)
const value = options.some((o) => o.value === want) ? want : ''
return {
type: 'select',
label: '模型',
value,
options,
action: { type: 'sansheng/select-model', seatId: (seat && seat.id) || null, projectId: (project && project.id) || null },
}
}
/** 单个角色按钮:label 恰为两字;选中者高亮(selected + primary)。 */
function seatButton(project, seat, selectedSeatId) {
const meta = SEATS[seat.id]
const selected = seat.id === selectedSeatId
return {
type: 'button',
seatId: seat.id,
label: meta.label,
selected,
variant: selected ? 'primary' : 'ghost',
action: { type: 'sansheng/select-seat', seatId: seat.id, projectId: (project && project.id) || null },
}
}
/** 一个分组(stack):标题 + 若干 row,每行 ≤3 个角色按钮(六部拆两行)。 */
function groupNode(project, records, key, selectedSeatId) {
const ids = (SEAT_GROUPS[key] || []).filter((id) => records[id] && SEATS[id])
if (ids.length === 0) return null
const perRow = key === 'liubu' ? 3 : ids.length
const rows = []
for (let i = 0; i < ids.length; i += perRow) {
const slice = ids.slice(i, i + perRow)
rows.push({ type: 'row', children: slice.map((id) => seatButton(project, records[id], selectedSeatId)) })
}
return {
type: 'stack',
group: key,
children: [{ type: 'text', text: GROUP_TITLE[key] + ' · ' + ids.length + ' 席' }].concat(rows),
}
}
/** 选中席详情:名称/职责/只读补充说明/模型单选/进入会话按钮。 */
function selectedDetail(project, records, selectedSeatId, models) {
const seat = selectedSeatId ? records[selectedSeatId] : null
if (!seat) {
return { type: 'callout', tone: 'info', text: '点击上方角色卡片查看职责、模型与进入会话。' }
}
const meta = SEATS[seat.id]
const bound = isBound(seat)
const statusLabel = SEAT_STATUS_TEXT[seat.status] || asText(seat.status) || '未知'
const instructions = asText(seat.instructions).trim() || '(未填写)'
return {
type: 'stack',
detail: seat.id,
children: [
{ type: 'text', text: meta.label + ' · ' + meta.duty + ' · ' + statusLabel },
{ type: 'callout', tone: 'info', text: '职责:' + meta.responsibility },
{ type: 'text', text: '角色补充说明(只读,请在 Web 端编辑)' },
{ type: 'callout', tone: 'warn', text: instructions },
buildModelSelect(project, seat, models),
{
type: 'button',
label: bound ? '进入' + meta.label + '会话' : meta.label + '尚未绑定会话',
variant: bound ? 'primary' : 'ghost',
disabled: !bound,
action: {
type: 'sansheng/enter-session',
seatId: seat.id,
projectId: (project && project.id) || null,
sessionId: isBound(seat) ? seat.sessionId : null,
},
},
],
}
}
/**
* 构造原生面板视图树。
* @param {{ project: object|null, selectedSeatId?: string|null, models?: object|null }} input
* @returns {object} 原生 view 节点
*/
export function buildPanelView(input) {
const { project = null, selectedSeatId = null, models = null } = input || {}
if (!project || typeof project !== 'object') {
return {
type: 'stack',
children: [
{ type: 'text', text: '三省六部' },
{
type: 'callout',
tone: 'warn',
text: '无法确定当前项目:原生面板作用域不含 workspaceId,且未能由 sessionId 反查到所属项目。请从已启用「三省六部」的项目会话中打开,或在 Web 工作台查看。',
},
],
}
}
const records = seatRecords(project)
// 选中席:显式传入优先;否则默认丞相(首屏有一个可见的选中态)。
const sel = selectedSeatId && records[selectedSeatId] ? selectedSeatId : records.lead ? 'lead' : null
const ready = project.status === 'ready'
const boundCount = SEAT_IDS.filter((id) => isBound(records[id])).length
const children = [
{ type: 'text', text: '三省六部 · ' + (asText(project.name) || '未命名项目') },
{
type: 'callout',
tone: ready ? 'good' : 'warn',
text: (PROJECT_STATUS_TEXT[project.status] || '状态未知') + ' · 已绑定 ' + boundCount + '/10 席',
},
]
for (const key of GROUP_ORDER) {
const g = groupNode(project, records, key, sel)
if (g) children.push(g)
}
children.push(selectedDetail(project, records, sel, models))
return { type: 'stack', children }
}
export default buildPanelView

197
src/shared/migrate.js Normal file
View File

@ -0,0 +1,197 @@
// 旧格式(v2/v3)→ 当前格式(v1)的纯转换:不做任何 IO,便于隔离单测。
//
// 旧版(DS Bot 时期)只有三个角色 lead / shangshu / gongbu,各绑定一个 Bot(真实存的是
// sessionId),项目还有 roomId、delivery、submissionSeq、maxReworks 等业务字段,以及
// 顶层 reviews / dispatches / reworks / artifacts / leases / events 六类记录。
// 新版固定十席,只认识项目与十席的会话/模型/说明。
//
// 迁移原则:
// 1. 能一一对应的直接搬:三角色 → lead / shangshu / gongbu 三席,Bot 的 sessionId 即会话 ID。
// 2. 不做任何猜测式绑定:其余七席保持 pending 空席,不生成替代会话。
// 3. 无法对应的角色、会话、模型与全部旧业务记录原样保存在 legacy 中,一条不丢。
// 4. leases 是运行期租约,只存档、不恢复为“运行中”。
// 5. 转换结果必须通过新版 validateState 才返回;否则视为转换失败,调用方不得写盘。
import { SEAT_IDS } from './roles.js'
import { STATE_VERSION, emptySeat, validateState, validModel } from './schema.js'
export const LEGACY_VERSIONS = Object.freeze([2, 3])
// 旧版角色 id 与新版席 id 同名,因此是一一对应的直搬。
const LEGACY_ROLE_TO_SEAT = Object.freeze({ lead: 'lead', shangshu: 'shangshu', gongbu: 'gongbu' })
// 旧项目里这些字段新版没有对应位置,全部收进 project.legacy。
const PROJECT_LEGACY_KEYS = Object.freeze([
'roomId', 'delivery', 'submissionSeq', 'maxReworks', 'schemaVersion', 'workDir',
])
// 顶层这些字段是新版自己的,其余未知字段收进 legacy.extras。
const TOP_KNOWN_KEYS = Object.freeze([
'version', 'seq', 'projects', 'reviews', 'dispatches', 'reworks', 'artifacts', 'leases', 'events',
])
function isObject(v) { return v !== null && typeof v === 'object' && !Array.isArray(v) }
function isStr(v) { return typeof v === 'string' && v.trim() !== '' }
function cleanModel(model) {
if (model === null || model === undefined || !validModel(model)) return null
const out = { provider: model.provider, model: model.model }
if (typeof model.reasoningEffort === 'string') out.reasoningEffort = model.reasoningEffort
return out
}
export function isLegacyState(raw) {
return isObject(raw) && LEGACY_VERSIONS.includes(raw.version)
}
function fail(code, message) { return { ok: false, code, message } }
function pickProjectId(legacy, usedIds) {
// 优先沿用宿主工作区 ID:这样用户再次打开同一工作区时接上旧项目,而不是新建一个。
const preferred = []
if (isStr(legacy.workspaceId)) preferred.push(legacy.workspaceId)
if (isStr(legacy.id)) preferred.push(legacy.id)
for (const candidate of preferred) {
if (!usedIds.has(candidate)) return candidate
}
const base = preferred[0] ?? 'legacy-project'
let index = 2
while (usedIds.has(`${base}-${index}`)) index += 1
return `${base}-${index}`
}
function migrateProject(legacy, key, usedIds, fromVersion, now, warnings) {
if (!isObject(legacy)) return fail('sansheng/state-corrupt', `旧项目 ${key} 不是对象,无法迁移`)
const legacyId = isStr(legacy.id) ? legacy.id : key
if (isStr(legacy.id) && legacy.id !== key) {
// 旧数据里项目键与 id 不一致属于可疑数据,但不阻断:保留原值并在提示中说明。
warnings.push(`项目键 ${key} 与项目 id ${legacy.id} 不一致,已按 id 归档`)
}
const id = pickProjectId({ ...legacy, id: legacyId }, usedIds)
usedIds.add(id)
const seats = {}
for (const seatId of SEAT_IDS) seats[seatId] = emptySeat(seatId)
const unmappedBots = {}
const unmappedModels = {}
const bots = isObject(legacy.bots) ? legacy.bots : {}
const models = isObject(legacy.models) ? legacy.models : {}
for (const [role, rawSessionId] of Object.entries(bots)) {
const seatId = LEGACY_ROLE_TO_SEAT[role]
if (!seatId) { unmappedBots[role] = rawSessionId; continue }
if (!isStr(rawSessionId)) {
warnings.push(`项目 ${legacyId} 的 ${role} 没有有效会话 ID,该席保持未绑定`)
continue
}
const seat = seats[seatId]
seat.sessionId = rawSessionId
seat.plannedSessionId = rawSessionId
seat.status = 'bound'
seat.updatedAt = Number.isFinite(legacy.updatedAt) ? legacy.updatedAt : now
}
// 旧版三角色缺任何一个都提示,不代建会话。
for (const role of Object.keys(LEGACY_ROLE_TO_SEAT)) {
if (!isStr(bots[role])) warnings.push(`项目 ${legacyId} 缺少 ${role} 的旧会话,对应席保持未绑定`)
}
for (const [role, rawModel] of Object.entries(models)) {
const seatId = LEGACY_ROLE_TO_SEAT[role]
if (!seatId) { unmappedModels[role] = rawModel; continue }
if (rawModel === null || rawModel === undefined) continue
const model = cleanModel(rawModel)
if (model) seats[seatId].model = model
else {
unmappedModels[role] = rawModel
warnings.push(`项目 ${legacyId} 的 ${role} 模型格式无法识别,已原样保留;该席显示为未选择模型`)
}
}
const extras = {}
for (const [k, v] of Object.entries(legacy)) {
if (['id', 'name', 'workspaceId', 'workDir', 'path', 'bots', 'models', 'createdAt', 'updatedAt', ...PROJECT_LEGACY_KEYS].includes(k)) continue
extras[k] = v
}
return {
ok: true,
id,
project: {
id,
name: isStr(legacy.name) ? legacy.name : legacyId,
workspaceId: isStr(legacy.workspaceId) ? legacy.workspaceId : null,
path: isStr(legacy.workDir) ? legacy.workDir : (isStr(legacy.path) ? legacy.path : null),
status: 'pending',
seats,
tasks: [],
artifacts: [],
taskSeq: 0,
artifactSeq: 0,
revision: 0,
createdAt: Number.isFinite(legacy.createdAt) ? legacy.createdAt : now,
updatedAt: Number.isFinite(legacy.updatedAt) ? legacy.updatedAt : now,
legacy: {
fromVersion,
legacyId,
roomId: isStr(legacy.roomId) ? legacy.roomId : null,
delivery: isObject(legacy.delivery) ? legacy.delivery : null,
submissionSeq: Number.isFinite(legacy.submissionSeq) ? legacy.submissionSeq : 0,
maxReworks: Number.isFinite(legacy.maxReworks) ? legacy.maxReworks : null,
schemaVersion: Number.isFinite(legacy.schemaVersion) ? legacy.schemaVersion : fromVersion,
workDir: isStr(legacy.workDir) ? legacy.workDir : null,
unmappedBots,
unmappedModels,
extras,
},
},
}
}
export function migrateLegacyState(raw, { now = Date.now() } = {}) {
if (!isLegacyState(raw)) {
return fail('sansheng/state-unsupported', `状态文件格式不受支持(版本 ${String(raw?.version)}),可升级的旧格式为 2/3`)
}
if (!isObject(raw.projects)) return fail('sansheng/state-corrupt', '旧状态缺少 projects 对象,无法迁移')
const warnings = []
const projects = {}
const usedIds = new Set()
for (const [key, value] of Object.entries(raw.projects)) {
const result = migrateProject(value, key, usedIds, raw.version, now, warnings)
if (!result.ok) return result
projects[result.id] = result.project
}
const extras = {}
for (const [k, v] of Object.entries(raw)) {
if (!TOP_KNOWN_KEYS.includes(k)) extras[k] = v
}
const state = {
version: STATE_VERSION,
seq: Number.isFinite(raw.seq) ? raw.seq : 0,
projects,
legacy: {
fromVersion: raw.version,
migratedAt: now,
notes: warnings,
reviews: Array.isArray(raw.reviews) ? raw.reviews : [],
dispatches: Array.isArray(raw.dispatches) ? raw.dispatches : [],
reworks: Array.isArray(raw.reworks) ? raw.reworks : [],
artifacts: isObject(raw.artifacts) ? raw.artifacts : {},
events: Array.isArray(raw.events) ? raw.events : [],
// 运行期租约只存档;新版不读 leases,绝不能把它当成“正在运行”。
leases: {
restored: false,
note: '旧版 leases 仅存档,不恢复为运行中状态',
items: isObject(raw.leases) ? raw.leases : {},
},
extras,
},
}
const valid = validateState(state)
if (!valid.ok) return fail('sansheng/state-migrate-failed', `旧数据转换后未通过校验:${valid.error}`)
return { ok: true, state, warnings }
}

82
src/shared/roles.js Normal file
View File

@ -0,0 +1,82 @@
// 十席固定编制。id 与 preview 原型保持一致;显示名一律两字。
// duty 为卡片短摘要;responsibility 为项目规划里从旧代码逐字沿用的职责说明。
export const SEAT_IDS = Object.freeze([
'lead', 'zhongshu', 'shangshu', 'menxia',
'libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu',
])
export const SEATS = Object.freeze({
lead: {
id: 'lead', label: '丞相', duty: '接需求 · 协调汇报',
responsibility: '面向用户承接想法:判断是否需要开工、必要时派给具体部门,并把各部门结果汇总成对用户的一次交付。',
},
zhongshu: {
id: 'zhongshu', label: '中书', duty: '调查 · 澄清 · 规划',
responsibility: '先把问题问清、把材料看全,再给出可执行的方案与验收标准草案,不直接产出最终交付物。',
},
shangshu: {
id: 'shangshu', label: '尚书', duty: '分工 · 组织交付',
responsibility: '把已经明确的方案拆成部门分工并组织交付;六部直属于尚书这一同级分组,六部之间不是上下级。',
},
menxia: {
id: 'menxia', label: '门下', duty: '审议 · 整体审核',
responsibility: '对方案和交付做独立审议,指出风险与不达标处。首版没有门下审核的任务必须如实标注“未审核”。',
},
libu: {
id: 'libu', label: '吏部', duty: '角色 · 技能配置',
responsibility: '对角色、技能与编制给出建议;职责不含绕过用户授权去改权限或其他项目设置。',
},
hubu: {
id: 'hubu', label: '户部', duty: '数据 · 表格计算',
responsibility: '处理数据、表格与计算,结论应可复算。',
},
lipu: {
id: 'lipu', label: '礼部', duty: '文档 · 内容呈现',
responsibility: '负责文档、内容与呈现形式,产出可编辑的源文件。',
},
bingbu: {
id: 'bingbu', label: '兵部', duty: '环境 · 调试部署',
responsibility: '负责环境、调试与部署;部署/发布等外部副作用仍服从用户授权与宿主审批。',
},
xingbu: {
id: 'xingbu', label: '刑部', duty: '测试 · 风险检查',
responsibility: '做测试与风险检查,给出可追溯的检查结果,而不是一句“已通过”。',
},
gongbu: {
id: 'gongbu', label: '工部', duty: '代码 · 工程产出',
responsibility: '负责代码实现与工程产出,交付可编辑源文件与真实检查结果。',
},
})
// 工作台布局:丞相居中;三省一排;六部两排。
export const SEAT_GROUPS = Object.freeze({
lead: Object.freeze(['lead']),
sansheng: Object.freeze(['zhongshu', 'shangshu', 'menxia']),
liubu: Object.freeze(['libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu']),
})
export function isSeatId(id) {
return SEAT_IDS.includes(id)
}
export function seatOf(id) {
return SEATS[id]
}
export function seatLabel(id) {
return SEATS[id]?.label ?? ''
}
/** 由 sessionId 反查所属席(用于 systemPrompt section 与项目归属校验)。 */
export function seatBySessionId(projects, sessionId) {
if (!sessionId || !projects) return undefined
for (const project of Object.values(projects)) {
for (const seatId of SEAT_IDS) {
if (project?.seats?.[seatId]?.sessionId === sessionId) {
return { project, seatId, seat: SEATS[seatId] }
}
}
}
return undefined
}

128
src/shared/schema.js Normal file
View File

@ -0,0 +1,128 @@
// 项目状态 schema(版本 1)。前后端共用:宿主只接受明确合法的结构,
// 合法 JSON 但结构错误一律视为损坏,绝不静默回退成“健康空状态”。
import { SEAT_IDS } from './roles.js'
export const STATE_VERSION = 1
export const SEAT_STATUS = Object.freeze(['pending', 'creating', 'bound', 'failed', 'missing'])
export const PROJECT_STATUS = Object.freeze(['pending', 'provisioning', 'ready', 'error'])
// 任务:草稿 → 已派工/待执行 → 完成 / 取消 / 失败
export const TASK_STATUS = Object.freeze(['draft', 'dispatched', 'prepared', 'done', 'cancelled', 'failed'])
const SEAT_STATUS_SET = new Set(SEAT_STATUS)
const PROJECT_STATUS_SET = new Set(PROJECT_STATUS)
const TASK_STATUS_SET = new Set(TASK_STATUS)
function isObject(v) { return v !== null && typeof v === 'object' && !Array.isArray(v) }
function isStr(v) { return typeof v === 'string' && v.trim() !== '' }
export function emptyState() {
return { version: STATE_VERSION, seq: 0, projects: {} }
}
export function emptySeat(seatId) {
return {
seatId,
sessionId: null,
plannedSessionId: null,
status: 'pending',
model: null,
instructions: '',
error: null,
updatedAt: 0,
}
}
export function emptyProject({ id, name, workspaceId = null, path = null, now = Date.now() }) {
const seats = {}
for (const seatId of SEAT_IDS) seats[seatId] = emptySeat(seatId)
return {
id,
name,
workspaceId,
path,
status: 'pending',
seats,
// 任务与交付成果:按项目隔离保存;旧数据没有这两个字段时按空数组处理。
tasks: [],
artifacts: [],
taskSeq: 0,
artifactSeq: 0,
revision: 0,
createdAt: now,
updatedAt: now,
}
}
export function emptyTask({ id, title = '', goal = '', ownerSeatId = 'lead', now = Date.now() }) {
return { id, title, goal, ownerSeatId, status: 'draft', note: '', sessionId: null, createdAt: now, updatedAt: now, dispatchedAt: null }
}
export function emptyArtifact({ id, title = '', path = '', summary = '', taskId = null, now = Date.now() }) {
return { id, title, path, summary, taskId, createdAt: now }
}
export function validModel(model) {
if (model === null || model === undefined) return true
if (!isObject(model)) return false
if (!isStr(model.provider) || !isStr(model.model)) return false
if (model.reasoningEffort !== undefined && typeof model.reasoningEffort !== 'string') return false
return true
}
function seatProblem(seat, seatId, projectId) {
if (!isObject(seat)) return `项目 ${projectId} 的席 ${seatId} 不是对象`
if (seat.seatId !== seatId) return `项目 ${projectId} 的席 ${seatId} 的 seatId 不一致`
if (!SEAT_STATUS_SET.has(seat.status)) return `项目 ${projectId} 的席 ${seatId} 状态非法:${String(seat.status)}`
for (const field of ['sessionId', 'plannedSessionId']) {
if (!(seat[field] === null || isStr(seat[field]))) return `项目 ${projectId} 的席 ${seatId} 的 ${field} 非法`
}
if (!validModel(seat.model)) return `项目 ${projectId} 的席 ${seatId} 的 model 非法`
if (typeof seat.instructions !== 'string') return `项目 ${projectId} 的席 ${seatId} 的 instructions 非法`
if (!(seat.error === null || typeof seat.error === 'string')) return `项目 ${projectId} 的席 ${seatId} 的 error 非法`
return undefined
}
function projectProblem(project, id) {
if (!isObject(project)) return `项目 ${id} 不是对象`
if (!isStr(project.id)) return `项目 ${id} 缺少 id`
if (project.id !== id) return `项目键 ${id} 与 id ${project.id} 不一致`
if (typeof project.name !== 'string') return `项目 ${id} 的 name 非法`
if (!PROJECT_STATUS_SET.has(project.status)) return `项目 ${id} 状态非法:${String(project.status)}`
if (!(project.workspaceId === null || isStr(project.workspaceId))) return `项目 ${id} 的 workspaceId 非法`
if (!(project.path === null || typeof project.path === 'string')) return `项目 ${id} 的 path 非法`
if (!Number.isFinite(project.revision)) return `项目 ${id} 的 revision 非法`
if (!isObject(project.seats)) return `项目 ${id} 缺少 seats`
const keys = Object.keys(project.seats).sort()
if (keys.length !== SEAT_IDS.length || keys.join(',') !== [...SEAT_IDS].sort().join(',')) {
return `项目 ${id} 的席不是固定的十席`
}
for (const seatId of SEAT_IDS) {
const problem = seatProblem(project.seats[seatId], seatId, id)
if (problem) return problem
}
if (project.tasks !== undefined && !Array.isArray(project.tasks)) return `项目 ${id} 的 tasks 不是数组`
for (const [index, task] of (project.tasks ?? []).entries()) {
if (!isObject(task)) return `项目 ${id} 的 tasks[${index}] 不是对象`
if (!isStr(task.id)) return `项目 ${id} 的 tasks[${index}] 缺少 id`
if (!TASK_STATUS_SET.has(task.status)) return `项目 ${id} 的任务 ${task.id} 状态非法:${String(task.status)}`
}
if (project.artifacts !== undefined && !Array.isArray(project.artifacts)) return `项目 ${id} 的 artifacts 不是数组`
for (const [index, artifact] of (project.artifacts ?? []).entries()) {
if (!isObject(artifact)) return `项目 ${id} 的 artifacts[${index}] 不是对象`
if (!isStr(artifact.id)) return `项目 ${id} 的 artifacts[${index}] 缺少 id`
}
return undefined
}
export function validateState(raw) {
if (!isObject(raw)) return { ok: false, error: '状态顶层不是对象' }
if (raw.version !== STATE_VERSION) return { ok: false, error: `不支持的状态版本 ${String(raw.version)}` }
if (!isObject(raw.projects)) return { ok: false, error: 'projects 不是对象' }
if (raw.seq !== undefined && !Number.isFinite(raw.seq)) return { ok: false, error: 'seq 不是数字' }
for (const [id, project] of Object.entries(raw.projects)) {
const problem = projectProblem(project, id)
if (problem) return { ok: false, error: problem }
}
return { ok: true, state: raw }
}

44
test/api.test.js Normal file
View File

@ -0,0 +1,44 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { createApiHandler } from '../src/host/api.js'
import { setupService } from './helpers.js'
test('HTTP 处理器端到端', async () => {
const { service } = await setupService()
const handle = createApiHandler(service)
let r = await handle('list')
assert.ok(r.ok)
assert.deepEqual(r.value.projects, [])
r = await handle('open', { path: '/api', name: '接口项目' })
assert.ok(r.ok)
const id = r.value.project.id
r = await handle('enable', { projectId: id })
assert.ok(r.ok)
assert.equal(r.value.project.status, 'ready')
r = await handle('configure', { projectId: id, seatId: 'gongbu', model: { provider: 'deepseek', model: 'deepseek-chat' }, instructions: '说明' })
assert.ok(r.ok)
assert.deepEqual(r.value.seat.model, { provider: 'deepseek', model: 'deepseek-chat' })
r = await handle('project', { projectId: id })
assert.ok(r.ok)
assert.equal(r.value.project.seats.length, 10)
r = await handle('models')
assert.ok(r.ok)
assert.ok(r.value.providers.length >= 1)
r = await handle('nope')
assert.ok(!r.ok)
assert.equal(r.error.code, 'sansheng/invalid')
r = await handle('project', {})
assert.ok(!r.ok)
r = await handle('project', { projectId: 'missing' })
assert.ok(!r.ok)
assert.equal(r.error.code, 'sansheng/not-found')
})

141
test/client.test.js Normal file
View File

@ -0,0 +1,141 @@
// 只测纯视图模型:绝不 import 会拉起 React 的 index.js。
import test from 'node:test'
import assert from 'node:assert/strict'
import {
buildWorkbenchView,
collectModelOptions,
updateDraft,
UNCHOSEN_MODEL_LABEL,
} from '../src/client/workbench.js'
// 与 CONTRACT.md 一致:十席固定编制、两字显示名。
const SEAT_ROWS = [
['lead', '丞相'],
['zhongshu', '中书'],
['shangshu', '尚书'],
['menxia', '门下'],
['libu', '吏部'],
['hubu', '户部'],
['lipu', '礼部'],
['bingbu', '兵部'],
['xingbu', '刑部'],
['gongbu', '工部'],
]
const GROUPS = {
lead: ['lead'],
sansheng: ['zhongshu', 'shangshu', 'menxia'],
liubu: ['libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'],
}
const MODELS = {
providers: [
{
provider: 'deepseek',
models: [
{ model: 'deepseek-chat' },
{ model: 'deepseek-reasoner', reasoningEffort: ['low', 'high'] },
],
},
],
default: { provider: 'deepseek', model: 'deepseek-chat' },
failures: [],
}
function makeView(seatPatch, projectPatch) {
const seats = SEAT_ROWS.map(pair => {
const id = pair[0]
const patch = (seatPatch && seatPatch[id]) || {}
return {
id,
label: '',
duty: '',
responsibility: '',
status: 'pending',
sessionId: null,
model: null,
instructions: '',
...patch,
}
})
return {
revision: 1,
project: {
id: 'ws-1',
name: '测试项目',
workspaceId: 'ws-1',
path: 'D:/x',
status: 'ready',
seats,
groups: GROUPS,
...(projectPatch || {}),
},
}
}
test('十席固定编制,名称均为两字', () => {
const out = buildWorkbenchView(makeView(), { selectedSeatId: 'lead', models: MODELS, draft: {} })
assert.equal(out.seats.length, 10)
assert.deepEqual(out.seats.map(s => s.id), SEAT_ROWS.map(r => r[0]))
for (const seat of out.seats) {
assert.equal(Array.from(seat.name).length, 2, seat.id + ' 的名称应为两字,实际 ' + seat.name)
}
// 缺省入参也不应抛错,且仍是十席。
const bare = buildWorkbenchView(undefined, undefined)
assert.equal(bare.seats.length, 10)
})
test('groups 键与分组归属正确', () => {
const out = buildWorkbenchView(makeView(), { selectedSeatId: 'shangshu', models: MODELS, draft: {} })
assert.deepEqual(Object.keys(out.groups).sort(), ['lead', 'liubu', 'sansheng'])
assert.deepEqual(out.groups.lead, ['lead'])
assert.deepEqual(out.groups.sansheng, ['zhongshu', 'shangshu', 'menxia'])
assert.deepEqual(out.groups.liubu, ['libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'])
})
test('未选模型时显示“请选择模型”,且 modelOptions 无 inherit 选项', () => {
const out = buildWorkbenchView(makeView(), { selectedSeatId: 'lead', models: MODELS, draft: {} })
assert.equal(out.selected.modelLabel, UNCHOSEN_MODEL_LABEL)
assert.equal(out.selected.modelLabel, '请选择模型')
assert.equal(out.selected.modelValue, '')
assert.ok(Array.isArray(out.selected.modelOptions))
assert.ok(out.selected.modelOptions.length > 0)
assert.ok(!out.selected.modelOptions.some(o => o.value === 'inherit'))
assert.ok(!out.selected.modelOptions.some(o => o.value === 'inherit'))
// 顶层也再次覆核,防止某处泄漏“跟随宿主模型”。
assert.ok(!collectModelOptions(MODELS).some(o => o.value === 'inherit'))
})
test('选中模型后显示具体名称', () => {
const view = makeView({ lead: { model: { provider: 'deepseek', model: 'deepseek-chat' }, status: 'bound', sessionId: 'sess-lead' } })
const out = buildWorkbenchView(view, { selectedSeatId: 'lead', models: MODELS, draft: {} })
assert.equal(out.selected.modelLabel, 'deepseek-chat')
assert.equal(out.selected.modelValue, 'deepseek::deepseek-chat')
assert.equal(out.selected.sessionId, 'sess-lead')
assert.equal(out.selected.name, '丞相')
// selected 必须带齐契约要求的字段。
for (const key of ['id', 'name', 'responsibility', 'duty', 'modelValue', 'modelLabel', 'instructions', 'modelOptions']) {
assert.ok(key in out.selected, 'selected 缺少字段 ' + key)
}
})
test('切换角色保留草稿', () => {
// 工部写一句草稿,再切到吏部写一句:两席草稿互不覆盖。
let draft = updateDraft({}, 'gongbu', { instructions: '工部草稿' })
draft = updateDraft(draft, 'libu', { instructions: '吏部草稿' })
assert.equal(draft.gongbu.instructions, '工部草稿')
assert.equal(draft.libu.instructions, '吏部草稿')
const view = makeView()
const gongbuView = buildWorkbenchView(view, { selectedSeatId: 'gongbu', models: MODELS, draft })
assert.equal(gongbuView.selected.id, 'gongbu')
assert.equal(gongbuView.selected.instructions, '工部草稿')
assert.equal(gongbuView.selected.dirty, true)
// 切到吏部——工部草稿仍在 draft 映射里,切回工部应原样保留。
const libuView = buildWorkbenchView(view, { selectedSeatId: 'libu', models: MODELS, draft })
assert.equal(libuView.selected.instructions, '吏部草稿')
const again = buildWorkbenchView(view, { selectedSeatId: 'gongbu', models: MODELS, draft })
assert.equal(again.selected.instructions, '工部草稿')
})

106
test/fake-ctx.js Normal file
View File

@ -0,0 +1,106 @@
// 测试用 fake 宿主:模拟 DSH 注入的公开服务,便于隔离验证,不接触真实 DSH。
import { mkdtemp } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
export async function tempStateFile() {
const dir = await mkdtemp(join(tmpdir(), 'sansheng-test-'))
return join(dir, 'state.json')
}
export function createFakeHost(opts = {}) {
const sessions = new Map() // sessionId -> agent
const workspaces = new Map() // id -> { id, name, path }
const calls = { create: [], resolve: [], selectModel: 0, agentSelect: [], createAt: [] }
const control = {
failCreateOrder: null, // 第 N 次 create 抛错(1 起)
mismatchCreateOrder: null, // 第 N 次 create 返回另一个 ID
catalog: opts.catalog ?? {
providers: [{ provider: 'deepseek', models: ['deepseek-chat', 'deepseek-reasoner'] }],
default: { provider: 'deepseek', model: 'deepseek-chat' },
failures: [],
},
validRoutes: opts.validRoutes ?? new Set(['deepseek/deepseek-chat', 'deepseek/deepseek-reasoner']),
}
let createCount = 0
const workspaceRegistry = {
get(id) { return workspaces.get(id) },
list() { return [...workspaces.values()] },
async resolveByPath(p) { return [...workspaces.values()].find(w => w.path === p) },
async create(p, title) { const id = `ws-${workspaces.size + 1}`; const w = { id, name: title ?? id, path: p }; workspaces.set(id, w); return w },
}
function agentFor(sessionId) {
let agent = sessions.get(sessionId)
if (!agent) {
agent = {
id: sessionId,
_selection: null,
model: {
current() { return agent._selection },
select(selection) { agent._selection = selection; calls.agentSelect.push({ sessionId, selection }) },
},
}
sessions.set(sessionId, agent)
}
return agent
}
const sessionController = {
async resolveAgent(sessionId) {
calls.resolve.push(sessionId)
if (sessions.has(sessionId)) return { agent: sessions.get(sessionId) }
return { error: { code: 'session/not-found', message: 'session not found' } }
},
async create({ sessionId, workspaceId, cwd } = {}) {
createCount += 1
const order = createCount
calls.create.push({ sessionId, workspaceId, cwd, order })
if (control.failCreateOrder === order) {
const error = new Error('simulated create failure')
error.code = 'session/create-failed'
throw error
}
let actual = sessionId
if (control.mismatchCreateOrder === order) actual = `minted-${Math.random().toString(36).slice(2, 8)}`
agentFor(actual)
return { sessionId: actual }
},
async modelCatalog() { return control.catalog },
// 我们的代码绝不能调用它(会写 profile 全局默认);被调用即失败并计数。
async selectModel() { calls.selectModel += 1; throw new Error('sessionController.selectModel must not be called') },
}
const agents = { get(id) { return sessions.get(id) }, list() { return [...sessions.values()] } }
const llm = {
async resolveCallConfig(selection) {
const key = `${selection.provider}/${selection.model}`
if (control.validRoutes.size > 0 && !control.validRoutes.has(key)) {
const error = new Error(`unknown route ${key}`)
error.code = 'llm/unknown-model'
throw error
}
return { ...selection }
},
}
let promptSection = null
const systemPrompt = { section(def) { promptSection = def; return () => { promptSection = null } } }
let route = null
const connection = { fetch: { register(def) { route = def; return () => {} } } }
const host = { workspaceRegistry, sessionController, agents, llm, systemPrompt }
const ctx = {
workspaceRegistry, sessionController, agents, llm, systemPrompt, connection,
effect(fn) { const dispose = fn(); return dispose },
}
return {
host, ctx, calls, control, sessions, workspaces,
getPromptSection() { return promptSection },
getRoute() { return route },
addWorkspace(id, name, path) { workspaces.set(id, { id, name, path }) },
// 预置一个已存在的会话(用于“已存在不重建”测试)
addSession(sessionId) { return agentFor(sessionId) },
}
}

18
test/helpers.js Normal file
View File

@ -0,0 +1,18 @@
import { SanshengStore } from '../src/host/store.js'
import { createProvisioner } from '../src/host/provision.js'
import { SanshengService } from '../src/host/service.js'
import { createFakeHost, tempStateFile } from './fake-ctx.js'
export async function setupService(opts = {}) {
const file = await tempStateFile()
const store = new SanshengStore(file)
await store.load()
const fake = opts.fake ?? createFakeHost(opts)
const provisioner = createProvisioner({ store, host: fake.host })
const service = new SanshengService({ store, host: fake.host, provisioner })
return { file, store, fake, provisioner, service }
}
export function seatById(view, id) {
return view.project.seats.find(s => s.id === id)
}

52
test/integration.test.js Normal file
View File

@ -0,0 +1,52 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { setupService } from './helpers.js'
import { buildWorkbenchView } from '../src/client/workbench.js'
import { buildPanelView } from '../src/native/panel.js'
function childNodes(node) {
const kids = node?.children ?? node?.items ?? []
return Array.isArray(kids) ? kids : []
}
function countNodes(node) {
if (!node || typeof node !== 'object') return 0
let total = 1
for (const child of childNodes(node)) total += countNodes(child)
return total
}
function depth(node) {
if (!node || typeof node !== 'object') return 0
let max = 0
for (const child of childNodes(node)) max = Math.max(max, depth(child))
return 1 + max
}
test('宿主项目视图可直接喂给 Web 纯视图模型', async () => {
const { service } = await setupService()
const opened = await service.open({ path: '/ui', name: '界面项目' })
await service.enable(opened.project.id)
await service.configure(opened.project.id, 'gongbu', { model: { provider: 'deepseek', model: 'deepseek-chat' } })
const view = await service.project(opened.project.id)
const models = await service.models()
const vm = buildWorkbenchView(view, { selectedSeatId: 'gongbu', models })
assert.equal(vm.seats.length, 10)
assert.ok(vm.seats.every(s => s.name.length === 2))
assert.deepEqual(vm.groups, { lead: ['lead'], sansheng: ['zhongshu', 'shangshu', 'menxia'], liubu: ['libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'] })
assert.equal(vm.ready, true)
assert.equal(vm.selected.id, 'gongbu')
assert.match(vm.selected.modelLabel, /deepseek-chat/)
assert.ok(!vm.selected.modelOptions.some(o => o.value === 'inherit'))
})
test('宿主项目视图可直接喂给原生面板并满足容量约束', async () => {
const { service } = await setupService()
const opened = await service.open({ path: '/ui2', name: '原生项目' })
await service.enable(opened.project.id)
const view = await service.project(opened.project.id)
const models = await service.models()
const tree = buildPanelView({ project: view.project, selectedSeatId: 'lead', models })
assert.ok(countNodes(tree) <= 120, '节点数应 ≤120')
assert.ok(depth(tree) <= 8, '深度应 ≤8')
})

47
test/isolation.test.js Normal file
View File

@ -0,0 +1,47 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { SanshengStore } from '../src/host/store.js'
import { createProvisioner } from '../src/host/provision.js'
import { SanshengService } from '../src/host/service.js'
import { createFakeHost } from './fake-ctx.js'
import { setupService, seatById } from './helpers.js'
test('两个项目十席会话与模型互相隔离', async () => {
const { service, fake } = await setupService()
const a = await service.open({ path: '/A', name: '甲项目' })
const b = await service.open({ path: '/B', name: '乙项目' })
await service.enable(a.project.id)
await service.enable(b.project.id)
await service.configure(a.project.id, 'gongbu', { model: { provider: 'deepseek', model: 'deepseek-chat' } })
await service.configure(b.project.id, 'gongbu', { model: { provider: 'deepseek', model: 'deepseek-reasoner' } })
const pa = await service.project(a.project.id)
const pb = await service.project(b.project.id)
assert.deepEqual(seatById(pa, 'gongbu').model, { provider: 'deepseek', model: 'deepseek-chat' })
assert.deepEqual(seatById(pb, 'gongbu').model, { provider: 'deepseek', model: 'deepseek-reasoner' })
// 两会话 ID 集合不相交
const sa = new Set(pa.project.seats.map(s => s.sessionId))
for (const seat of pb.project.seats) assert.ok(!sa.has(seat.sessionId))
})
test('重启后十席不重复,配置与会话保持不变', async () => {
const { service, store, fake, file } = await setupService()
const a = await service.open({ path: '/A', name: '甲项目' })
await service.enable(a.project.id)
await service.configure(a.project.id, 'gongbu', { model: { provider: 'deepseek', model: 'deepseek-reasoner' } })
const before = await service.project(a.project.id)
const sessionsBefore = before.project.seats.map(s => s.sessionId)
// 模拟重启:新 store + 新 service 读同一文件、同一 fake 宿主
const store2 = new SanshengStore(file)
await store2.load()
const provisioner2 = createProvisioner({ store: store2, host: fake.host })
const service2 = new SanshengService({ store: store2, host: fake.host, provisioner: provisioner2 })
const createdBefore = fake.calls.create.length
const again = await service2.enable(a.project.id) // 再次启用不应重建
assert.equal(fake.calls.create.length, createdBefore, '重启后不得重复创建会话')
assert.equal(again.project.seats.map(s => s.sessionId).join(','), sessionsBefore.join(','))
assert.deepEqual(seatById(again, 'gongbu').model, { provider: 'deepseek', model: 'deepseek-reasoner' })
})

135
test/migrate.test.js Normal file
View File

@ -0,0 +1,135 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { writeFile, readFile } from 'node:fs/promises'
import { SanshengStore } from '../src/host/store.js'
import { createProvisioner } from '../src/host/provision.js'
import { SanshengService } from '../src/host/service.js'
import { migrateLegacyState } from '../src/shared/migrate.js'
import { validateState } from '../src/shared/schema.js'
import { createFakeHost, tempStateFile } from './fake-ctx.js'
function legacyV3() {
return {
version: 3,
seq: 7,
projects: {
'prj-1': {
submissionSeq: 2,
delivery: { include: ['docs'], exclude: ['node_modules'] },
id: 'prj-1',
name: '示例项目',
workspaceId: 'ws-9',
workDir: 'D:/work/demo',
roomId: 'session-room-1',
bots: { lead: 'session-lead', shangshu: 'session-shang', gongbu: 'session-gong' },
models: {
lead: { provider: 'deepseek', model: 'deepseek-chat' },
shangshu: { id: 'legacy-model' },
gongbu: { provider: 'deepseek', model: 'deepseek-reasoner', reasoningEffort: 'high' },
},
maxReworks: 3,
createdAt: 111,
updatedAt: 222,
schemaVersion: 3,
},
},
reviews: [{ id: 'rv-1' }],
dispatches: [{ id: 'dp-1' }],
reworks: [{ id: 'rw-1' }],
artifacts: { 'a-1': { path: 'x' } },
leases: { 'prj-1': { until: 999 } },
events: [{ id: 'ev-1' }],
}
}
test('格式 3 迁移:项目、三席会话、模型与旧业务记录都保留', () => {
const migrated = migrateLegacyState(legacyV3(), { now: 5000 })
assert.equal(migrated.ok, true, migrated.message)
const state = migrated.state
assert.equal(state.version, 1)
assert.equal(state.seq, 7)
const project = state.projects['ws-9']
assert.ok(project, '项目应按宿主工作区 ID 归档')
assert.equal(project.name, '示例项目')
assert.equal(project.path, 'D:/work/demo')
assert.equal(project.legacy.legacyId, 'prj-1')
assert.equal(project.legacy.roomId, 'session-room-1')
assert.deepEqual(project.legacy.delivery, { include: ['docs'], exclude: ['node_modules'] })
// 三席按旧 Bot 的 sessionId 绑定,其它七席保持 pending 且不生成会话。
assert.equal(project.seats.lead.status, 'bound')
assert.equal(project.seats.lead.sessionId, 'session-lead')
assert.equal(project.seats.shangshu.sessionId, 'session-shang')
assert.equal(project.seats.gongbu.status, 'bound')
for (const seatId of ['zhongshu', 'menxia', 'libu', 'hubu', 'lipu', 'bingbu', 'xingbu']) {
assert.equal(project.seats[seatId].status, 'pending', seatId)
assert.equal(project.seats[seatId].sessionId, null, seatId)
assert.equal(project.seats[seatId].plannedSessionId, null, seatId)
}
// 可识别模型直搬;无法识别的模型不硬绑,原样保留并提示。
assert.deepEqual(project.seats.lead.model, { provider: 'deepseek', model: 'deepseek-chat' })
assert.deepEqual(project.seats.gongbu.model, { provider: 'deepseek', model: 'deepseek-reasoner', reasoningEffort: 'high' })
assert.equal(project.seats.shangshu.model, null)
assert.deepEqual(project.legacy.unmappedModels.shangshu, { id: 'legacy-model' })
// 旧业务记录一条不丢。
assert.equal(state.legacy.fromVersion, 3)
assert.equal(state.legacy.reviews.length, 1)
assert.equal(state.legacy.dispatches.length, 1)
assert.equal(state.legacy.reworks.length, 1)
assert.equal(state.legacy.events.length, 1)
assert.deepEqual(state.legacy.artifacts['a-1'], { path: 'x' })
assert.deepEqual(state.legacy.leases.items['prj-1'], { until: 999 })
assert.equal(state.legacy.leases.restored, false)
assert.equal(validateState(state).ok, true)
assert.ok(migrated.warnings.some(w => w.includes('shangshu')))
})
test('已是当前格式或未知版本都不会被当成旧格式迁移', () => {
assert.equal(migrateLegacyState({ version: 1, projects: {} }).ok, false)
assert.equal(migrateLegacyState({ version: 9, projects: {} }).ok, false)
})
test('迁移后写回为格式 1,重复加载不再改写也不重复建会话', async () => {
const file = await tempStateFile()
await writeFile(file, JSON.stringify(legacyV3()), 'utf8')
const store = new SanshengStore(file)
await store.load()
const first = await readFile(file, 'utf8')
assert.equal(JSON.parse(first).version, 1)
const again = new SanshengStore(file)
await again.load()
const second = await readFile(file, 'utf8')
assert.equal(first, second, '第二次加载不得再次改写文件')
// 启用只补缺失的七席;三个已绑定席不新建会话,重复启用也不重复建。
const fake = createFakeHost()
const provisioner = createProvisioner({ store: again, host: fake.host })
const service = new SanshengService({ store: again, host: fake.host, provisioner })
await service.enable('ws-9')
assert.equal(fake.calls.create.length, 7)
const createdIds = new Set(fake.calls.create.map(c => c.sessionId))
assert.ok(!createdIds.has('session-lead') && !createdIds.has('session-shang') && !createdIds.has('session-gong'))
await service.enable('ws-9')
assert.equal(fake.calls.create.length, 7, '再次启用不应重复建会话')
})
test('未知版本给“格式不支持”,损坏 JSON 与结构错误给各自错误,均不改动原文件', async () => {
const cases = [
{ text: JSON.stringify({ version: 9, projects: {} }), code: 'sansheng/state-unsupported' },
{ text: '{ 不是 json', code: 'sansheng/state-json' },
{ text: JSON.stringify({ version: 3, projects: [] }), code: 'sansheng/state-corrupt' },
{ text: JSON.stringify({ version: 1, projects: { a: { id: 'a' } } }), code: 'sansheng/state-corrupt' },
]
for (const item of cases) {
const file = await tempStateFile()
await writeFile(file, item.text, 'utf8')
const store = new SanshengStore(file)
await assert.rejects(() => store.load(), err => err.code === item.code, item.code)
assert.equal(await readFile(file, 'utf8'), item.text, '失败时不得覆盖原文件')
}
})

44
test/model.test.js Normal file
View File

@ -0,0 +1,44 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { setupService, seatById } from './helpers.js'
async function ready() {
const ctx = await setupService()
const opened = await ctx.service.open({ path: '/pm', name: '模型项目' })
const id = opened.project.id
await ctx.service.enable(id)
return { ...ctx, id }
}
test('配置模型走 agent.model.select,不调用 controller.selectModel', async () => {
const { service, fake, id } = await ready()
const res = await service.configure(id, 'gongbu', { model: { provider: 'deepseek', model: 'deepseek-chat' } })
assert.equal(fake.calls.selectModel, 0)
assert.equal(fake.calls.agentSelect.length, 1)
assert.deepEqual(res.seat.model, { provider: 'deepseek', model: 'deepseek-chat' })
const p = await service.project(id)
assert.deepEqual(seatById(p, 'gongbu').model, { provider: 'deepseek', model: 'deepseek-chat' })
})
test('非法模型被 validate 拒绝且不落库', async () => {
const { service, fake, id } = await ready()
await assert.rejects(
() => service.configure(id, 'hubu', { model: { provider: 'ghost', model: 'nope' } }),
err => err.code === 'sansheng/model-invalid' || err.code === 'llm/unknown-model',
)
assert.equal(fake.calls.agentSelect.length, 0)
const p = await service.project(id)
assert.equal(seatById(p, 'hubu').model, null)
})
test('缺 provider/model 直接拒绝', async () => {
const { service, id } = await ready()
await assert.rejects(() => service.configure(id, 'libu', { model: { provider: 'deepseek' } }), err => err.code === 'sansheng/model-invalid')
})
test('补充说明可保存并持久化', async () => {
const { service, store, id } = await ready()
await service.configure(id, 'xingbu', { instructions: '只跑只读检查' })
const p = await service.project(id)
assert.equal(seatById(p, 'xingbu').instructions, '只跑只读检查')
})

192
test/native.test.js Normal file
View File

@ -0,0 +1,192 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { buildPanelView } from '../src/native/panel.js'
import { SEATS, SEAT_GROUPS } from '../src/shared/roles.js'
/** 递归遍历视图树(沿 children),depth 从 1 起。 */
function traverse(node, fn, depth = 1) {
if (!node || typeof node !== 'object') return
fn(node, depth)
const kids = Array.isArray(node.children) ? node.children : []
for (const k of kids) traverse(k, fn, depth + 1)
}
function analyze(root) {
let count = 0
let maxDepth = 0
let maxOptions = 0
let maxItems = 0
const types = new Set()
const seatNodes = []
traverse(root, (n, d) => {
count += 1
if (d > maxDepth) maxDepth = d
if (typeof n.type === 'string') types.add(n.type)
if (Array.isArray(n.options)) maxOptions = Math.max(maxOptions, n.options.length)
if (Array.isArray(n.items)) maxItems = Math.max(maxItems, n.items.length)
if (typeof n.seatId === 'string') seatNodes.push(n)
})
return { count, maxDepth, maxOptions, maxItems, types, seatNodes }
}
function makeProject() {
const seats = Object.keys(SEATS).map((id) => ({
id,
label: SEATS[id].label,
duty: SEATS[id].duty,
responsibility: SEATS[id].responsibility,
status: 'bound',
sessionId: 'sess-' + id,
model: id === 'gongbu' ? { provider: 'demo', model: 'deepseek-chat' } : null,
instructions: id === 'lead' ? '优先用中文,先给结论。' : '',
}))
return {
id: 'p1',
name: '演示项目',
workspaceId: 'ws-1',
path: 'D:/demo',
status: 'ready',
seats,
groups: SEAT_GROUPS,
}
}
const MODELS = {
providers: [
{ provider: 'demo', models: [{ model: 'deepseek-chat' }, { model: 'deepseek-reasoner' }] },
],
default: { provider: 'demo', model: 'deepseek-chat' },
failures: [],
}
function build(extra) {
return buildPanelView(Object.assign({ project: makeProject(), selectedSeatId: 'gongbu', models: MODELS }, extra || {}))
}
test('十席:恰好十席、名称两字、分组齐全', () => {
const view = build()
const m = analyze(view)
// 恰好十席(唯一 seatId 的按钮节点)
const ids = m.seatNodes.map((n) => n.seatId)
assert.equal(ids.length, 10, '十席按钮应为 10 个')
assert.equal(new Set(ids).size, 10, '十席 seatId 应互不相同')
assert.deepEqual([...ids].sort(), Object.keys(SEATS).sort(), '应覆盖固定十席')
// 名称两字,且与共享定义一致
for (const n of m.seatNodes) {
assert.equal(Array.from(n.label).length, 2, n.seatId + ' 的名称应为两字:' + n.label)
assert.equal(n.label, SEATS[n.seatId].label)
}
// 分组齐全:lead / sansheng / liubu
const groups = []
traverse(view, (n) => { if (typeof n.group === 'string') groups.push(n.group) })
assert.deepEqual(groups.sort(), ['lead', 'liubu', 'sansheng'].sort(), '应包含三个分组')
// 各分组席数:1 / 3 / 6
const countInGroup = (groupKey) => {
let groupNode = null
traverse(view, (n) => { if (n.group === groupKey) groupNode = n })
assert.ok(groupNode, '缺少分组 ' + groupKey)
let c = 0
traverse(groupNode, (n) => { if (typeof n.seatId === 'string') c += 1 })
return c
}
assert.equal(countInGroup('lead'), 1)
assert.equal(countInGroup('sansheng'), 3)
assert.equal(countInGroup('liubu'), 6)
// 分组定义一致性
assert.equal(SEAT_GROUPS.liubu.length, 6)
})
test('容量:节点 ≤120、深度 ≤8、options/items ≤8', () => {
const m = analyze(build())
assert.ok(m.count <= 120, '节点数应 ≤120,实际 ' + m.count)
assert.ok(m.maxDepth <= 8, '最大深度应 ≤8,实际 ' + m.maxDepth)
assert.ok(m.maxOptions <= 8, 'options 项数应 ≤8,实际 ' + m.maxOptions)
assert.ok(m.maxItems <= 8, 'items 项数应 ≤8,实际 ' + m.maxItems)
})
test('模型为原生单选且不超过 8 项,含“请选择模型”占位', () => {
const view = build()
let select = null
traverse(view, (n) => { if (n.type === 'select') select = n })
assert.ok(select, '应存在模型单选节点')
assert.ok(Array.isArray(select.options))
assert.ok(select.options.length <= 8)
assert.equal(select.options[0].value, '')
assert.equal(select.options[0].label, '请选择模型')
// 已选中的工部模型应回填为具体 provider::model
assert.equal(select.value, 'demo::deepseek-chat')
// 即使喂入大量模型候选,也要被截断到 ≤8(含占位)
const many = { providers: [{ provider: 'p', models: Array.from({ length: 20 }, (_, i) => ({ model: 'm' + i })) }] }
const bigView = buildPanelView({ project: makeProject(), selectedSeatId: 'gongbu', models: many })
let bigSelect = null
traverse(bigView, (n) => { if (n.type === 'select') bigSelect = n })
assert.ok(bigSelect.options.length <= 8, '模型候选应被截断到 ≤8 项')
})
test('不存在自由文本输入控件(input/textarea)', () => {
const view = build()
const bad = []
traverse(view, (n) => {
if (n.type === 'input' || n.type === 'textarea') bad.push(n.type)
if (typeof n.component === 'string' && (n.component === 'input' || n.component === 'textarea')) bad.push(n.component)
})
assert.deepEqual(bad, [], '不应出现自由文本控件:' + bad.join(','))
// 同时确认渲染出的类型集合里没有意外控件
const m = analyze(view)
assert.ok(!m.types.has('input'))
assert.ok(!m.types.has('textarea'))
})
test('选中席出现在树里并高亮', () => {
const view = build({ selectedSeatId: 'bingbu' })
const m = analyze(view)
const hit = m.seatNodes.find((n) => n.seatId === 'bingbu')
assert.ok(hit, '选中的兵部应出现在树中')
assert.equal(hit.selected, true, '选中席应标记 selected=true')
assert.equal(hit.variant, 'primary', '选中席应高亮(primary)')
// 其它席不应被标记选中
const others = m.seatNodes.filter((n) => n.seatId !== 'bingbu')
assert.ok(others.every((n) => n.selected !== true), '非选中席不应高亮')
// 详情区应出现选中席名称(两字名)
let hasName = false
traverse(view, (n) => { if (n.type === 'text' && typeof n.text === 'string' && n.text.includes(SEATS.bingbu.label)) hasName = true })
assert.ok(hasName, '详情区应包含选中席名称')
})
test('进入会话按钮:表达意图(含 seatId/sessionId),未绑定则禁用', () => {
const view = build({ selectedSeatId: 'hubu' })
let enter = null
traverse(view, (n) => {
if (n.type === 'button' && n.action && n.action.type === 'sansheng/enter-session') enter = n
})
assert.ok(enter, '应存在进入会话按钮')
assert.equal(enter.action.seatId, 'hubu')
assert.equal(enter.action.sessionId, 'sess-hubu')
assert.equal(enter.disabled, false)
// 未绑定席:按钮禁用
const project = makeProject()
const hubu = project.seats.find((s) => s.id === 'hubu')
hubu.sessionId = null
hubu.status = 'pending'
const view2 = buildPanelView({ project, selectedSeatId: 'hubu', models: MODELS })
let enter2 = null
traverse(view2, (n) => {
if (n.type === 'button' && n.action && n.action.type === 'sansheng/enter-session') enter2 = n
})
assert.equal(enter2.disabled, true, '未绑定席的进入会话按钮应禁用')
})
test('缺少项目时给出安全提示(scope 无 workspaceId 的兜底)', () => {
const view = buildPanelView({ project: null, selectedSeatId: null, models: null })
let shown = false
traverse(view, (n) => { if (n.type === 'callout' && typeof n.text === 'string' && n.text.includes('无法确定当前项目')) shown = true })
assert.ok(shown, '无项目时应显示安全提示')
const m = analyze(view)
assert.ok(m.count <= 120 && m.maxDepth <= 8)
})

17
test/nav.test.js Normal file
View File

@ -0,0 +1,17 @@
// 左侧入口的静态契约:必须走宿主正式槽位 sidebar.panellist,且不再挂在「新会话」行。
import test from 'node:test'
import assert from 'node:assert/strict'
import { readFile } from 'node:fs/promises'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'
const root = dirname(dirname(fileURLToPath(import.meta.url)))
test('左侧入口使用 sidebar.panellist,位置在记忆系统与更多之间(order 32)', async () => {
const source = await readFile(join(root, 'src/client/index.js'), 'utf8')
assert.match(source, /name: 'sidebar\.panellist'/)
assert.match(source, /order: NAV_ORDER/)
assert.match(source, /const NAV_ORDER = 32/)
assert.ok(!source.includes('sidebar.session.action'), '不得再占用新会话右侧槽位')
assert.ok(!source.includes('SanshengSessionAction'), '旧的新会话入口应已删除')
})

35
test/prompt.test.js Normal file
View File

@ -0,0 +1,35 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { installPromptSection } from '../src/host/prompt.js'
import { setupService, seatById } from './helpers.js'
test('只对十席会话注入角色提示', async () => {
const { service, store, fake } = await setupService()
installPromptSection(fake.ctx, { store })
const section = fake.getPromptSection()
assert.ok(section)
assert.equal(section.name, 'sansheng')
const opened = await service.open({ path: '/pp', name: '提示项目' })
await service.enable(opened.project.id)
const p = await service.project(opened.project.id)
const seat = seatById(p, 'gongbu')
const text = section.text({ agent: { id: seat.sessionId } })
assert.match(text, /工部/)
assert.match(text, /代码实现与工程产出/)
assert.equal(section.text({ agent: { id: 'other-session' } }), '')
assert.equal(section.text({}), '')
})
test('补充说明出现在提示里', async () => {
const { service, store, fake } = await setupService()
installPromptSection(fake.ctx, { store })
const opened = await service.open({ path: '/pp2', name: 'p' })
await service.enable(opened.project.id)
await service.configure(opened.project.id, 'libu', { instructions: '先问清目标' })
const p = await service.project(opened.project.id)
const text = fake.getPromptSection().text({ agent: { id: seatById(p, 'libu').sessionId } })
assert.match(text, /先问清目标/)
})

67
test/provision.test.js Normal file
View File

@ -0,0 +1,67 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { SEAT_IDS } from '../src/shared/roles.js'
import { setupService, seatById } from './helpers.js'
test('启用创建十席并全部绑定', async () => {
const { service, fake } = await setupService()
const opened = await service.open({ path: '/p1', name: '项目一' })
const id = opened.project.id
assert.equal(opened.project.seats.length, 10)
const enabled = await service.enable(id)
assert.equal(enabled.project.status, 'ready')
assert.equal(fake.calls.create.length, 10)
for (const seat of enabled.project.seats) {
assert.equal(seat.status, 'bound')
assert.ok(seat.sessionId)
}
assert.equal(new Set(enabled.project.seats.map(s => s.sessionId)).size, 10)
assert.equal(fake.calls.selectModel, 0)
})
test('已存在会话不重建(按既有会话恢复绑定)', async () => {
const { service, store, fake } = await setupService()
const opened = await service.open({ path: '/p2', name: '项目二' })
const id = opened.project.id
const planned = 'pre-lead-session'
await store.mutate(s => { s.projects[id].seats.lead.plannedSessionId = planned })
fake.addSession(planned)
const enabled = await service.enable(id)
assert.equal(enabled.project.status, 'ready')
assert.equal(seatById(enabled, 'lead').sessionId, planned)
assert.equal(fake.calls.create.filter(c => c.sessionId === planned).length, 0)
assert.equal(fake.calls.create.length, 9)
})
test('返回 ID 不一致:立即停止后续创建并记录', async () => {
const { service, fake } = await setupService()
fake.control.mismatchCreateOrder = 1
const opened = await service.open({ path: '/p3', name: '项目三' })
const enabled = await service.enable(opened.project.id)
assert.equal(fake.calls.create.length, 1)
assert.equal(enabled.project.status, 'error')
const failed = enabled.project.seats.filter(s => s.status === 'failed')
assert.equal(failed.length, 1)
assert.match(failed[0].error, /不一致/)
assert.equal(enabled.project.seats.filter(s => s.status === 'pending').length, 9)
})
test('失败保留已完成绑定,重试只补未完成项', async () => {
const { service, fake } = await setupService()
fake.control.failCreateOrder = 2
const opened = await service.open({ path: '/p4', name: '项目四' })
const id = opened.project.id
const first = await service.enable(id)
assert.equal(first.project.status, 'error')
const boundBefore = first.project.seats.filter(s => s.status === 'bound').map(s => s.sessionId)
assert.equal(boundBefore.length, 9)
fake.control.failCreateOrder = null
const createdBefore = fake.calls.create.length
const second = await service.enable(id)
assert.equal(second.project.status, 'ready')
const nowBound = second.project.seats.filter(s => s.status === 'bound').map(s => s.sessionId)
for (const sid of boundBefore) assert.ok(nowBound.includes(sid), '已绑定的会话 ID 不能变')
assert.equal(nowBound.length, 10)
assert.equal(fake.calls.create.length, createdBefore + 1, '重试只应补一个会话')
})

29
test/roles.test.js Normal file
View File

@ -0,0 +1,29 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { SEAT_IDS, SEATS, SEAT_GROUPS, seatLabel, isSeatId } from '../src/shared/roles.js'
test('十席固定且显示名两字', () => {
assert.equal(SEAT_IDS.length, 10)
assert.equal(new Set(SEAT_IDS).size, 10)
for (const id of SEAT_IDS) {
assert.equal(SEATS[id].id, id)
assert.equal(SEATS[id].label.length, 2, `${id} 显示名必须是两字`)
assert.ok(SEATS[id].duty && SEATS[id].duty.length > 0)
assert.ok(SEATS[id].responsibility && SEATS[id].responsibility.length > 0)
}
})
test('分组覆盖全部十席且结构正确', () => {
const all = [...SEAT_GROUPS.lead, ...SEAT_GROUPS.sansheng, ...SEAT_GROUPS.liubu].sort()
assert.deepEqual(all, [...SEAT_IDS].sort())
assert.deepEqual([...SEAT_GROUPS.lead], ['lead'])
assert.deepEqual([...SEAT_GROUPS.sansheng], ['zhongshu', 'shangshu', 'menxia'])
assert.equal(SEAT_GROUPS.liubu.length, 6)
})
test('seatLabel / isSeatId', () => {
assert.equal(seatLabel('gongbu'), '工部')
assert.equal(seatLabel('lead'), '丞相')
assert.ok(isSeatId('lead'))
assert.ok(!isSeatId('nope'))
})

48
test/store.test.js Normal file
View File

@ -0,0 +1,48 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { writeFile } from 'node:fs/promises'
import { SanshengStore, StoreError } from '../src/host/store.js'
import { emptyState } from '../src/shared/schema.js'
import { tempStateFile } from './fake-ctx.js'
test('缺少文件加载为空状态', async () => {
const file = await tempStateFile()
const store = new SanshengStore(file)
await store.load()
assert.deepEqual(store.snapshot(), emptyState())
})
test('保存后可重新加载,项目含十席', async () => {
const file = await tempStateFile()
const store = new SanshengStore(file)
await store.load()
await store.mutate(() => { store.ensureProjectRecord({ id: 'ws-1', name: '项目一', workspaceId: 'ws-1', path: '/p1' }) })
const again = new SanshengStore(file)
await again.load()
const p = again.get('ws-1')
assert.equal(p.name, '项目一')
assert.equal(Object.keys(p.seats).length, 10)
})
test('非法 JSON 单独报错(不回退空状态,也不谎报结构损坏)', async () => {
const file = await tempStateFile()
await writeFile(file, '{ 不是 json', 'utf8')
const store = new SanshengStore(file)
await assert.rejects(() => store.load(), err => err instanceof StoreError && err.code === 'sansheng/state-json')
})
test('未知版本给出“格式不支持”而不是“损坏”', async () => {
const file = await tempStateFile()
await writeFile(file, JSON.stringify({ version: 9, projects: {} }), 'utf8')
const store = new SanshengStore(file)
await assert.rejects(() => store.load(), err => err.code === 'sansheng/state-unsupported')
})
test('seats 不是固定十席视为损坏', async () => {
const file = await tempStateFile()
const state = emptyState()
state.projects.bad = { id: 'bad', name: 'x', workspaceId: null, path: null, status: 'pending', revision: 0, seats: {} }
await writeFile(file, JSON.stringify(state), 'utf8')
const store = new SanshengStore(file)
await assert.rejects(() => store.load(), err => err.code === 'sansheng/state-corrupt')
})

78
test/tasks.test.js Normal file
View File

@ -0,0 +1,78 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { setupService } from './helpers.js'
async function readyProject() {
const ctx = await setupService()
const opened = await ctx.service.open({ path: '/tasks', name: '任务项目' })
await ctx.service.enable(opened.project.id)
return { ...ctx, projectId: opened.project.id }
}
test('任务:新建草稿、派工记录、取消,按项目保存', async () => {
const { service, projectId } = await readyProject()
const created = await service.taskCreate(projectId, { title: '整理需求', goal: '写清楚验收标准', ownerSeatId: 'zhongshu' })
assert.equal(created.task.status, 'draft')
assert.equal(created.task.ownerSeatId, 'zhongshu')
const listed = await service.tasks(projectId)
assert.equal(listed.tasks.length, 1)
const dispatched = await service.taskDispatch(projectId, created.task.id)
// 测试宿主没有发送接口,因此只记录为待执行,而不是假装已送达
assert.equal(dispatched.delivered, false)
assert.equal(dispatched.task.status, 'prepared')
assert.ok(dispatched.task.note.length > 0)
assert.ok(dispatched.task.sessionId)
const cancelled = await service.taskCancel(projectId, created.task.id)
assert.equal(cancelled.task.status, 'cancelled')
await assert.rejects(() => service.taskDispatch(projectId, created.task.id), err => err.code === 'sansheng/invalid')
})
test('任务:缺标题、未知主责席被拒绝;派工按需开启该部门会话', async () => {
const ctx = await setupService()
const opened = await ctx.service.open({ path: '/tasks2', name: '未启用项目' })
await assert.rejects(() => ctx.service.taskCreate(opened.project.id, { title: '', ownerSeatId: 'lead' }), err => err.code === 'sansheng/invalid')
await assert.rejects(() => ctx.service.taskCreate(opened.project.id, { title: 'x', ownerSeatId: 'nope' }), err => err.code === 'sansheng/invalid')
const created = await ctx.service.taskCreate(opened.project.id, { title: '待派工', ownerSeatId: 'lead' })
const dispatched = await ctx.service.taskDispatch(opened.project.id, created.task.id)
// 派工时按需开启主责部门,不要求先手动启用十席
assert.equal(dispatched.task.status, 'prepared')
assert.ok(dispatched.task.sessionId)
const view = await ctx.service.project(opened.project.id)
assert.equal(view.project.seats.find(s => s.id === 'lead').status, 'bound')
})
test('单席开启:应用预先配置的模型,且不要求开启十席', async () => {
const ctx = await setupService()
const opened = await ctx.service.open({ path: '/seat-model', name: '按需开启' })
await ctx.service.configure(opened.project.id, 'gongbu', { model: { provider: 'deepseek', model: 'deepseek-reasoner', reasoningEffort: 'high' } })
const view = await ctx.service.enableSeat(opened.project.id, 'gongbu')
const seat = view.project.seats.find(s => s.id === 'gongbu')
assert.equal(seat.status, 'bound')
// 其它席保持未开启
assert.equal(view.project.seats.filter(s => s.status === 'bound').length, 1)
const applied = ctx.fake.calls.agentSelect.find(item => item.sessionId === seat.sessionId)
assert.ok(applied, '建会话后应把预配置模型应用到这个会话')
assert.deepEqual(applied.selection, { provider: 'deepseek', model: 'deepseek-reasoner', reasoningEffort: 'high' })
})
test('成果:登记、列表、关联任务校验', async () => {
const { service, projectId } = await readyProject()
const task = await service.taskCreate(projectId, { title: '产出文档', ownerSeatId: 'lipu' })
const added = await service.artifactAdd(projectId, { title: '需求说明.pdf', path: 'D:/out/需求说明.pdf', summary: '首版', taskId: task.task.id })
assert.equal(added.artifact.title, '需求说明.pdf')
const list = await service.artifacts(projectId)
assert.equal(list.artifacts.length, 1)
await assert.rejects(() => service.artifactAdd(projectId, { title: '', path: '' }), err => err.code === 'sansheng/invalid')
await assert.rejects(() => service.artifactAdd(projectId, { title: 'x', taskId: 'missing' }), err => err.code === 'sansheng/invalid')
})
test('任务与成果按项目隔离', async () => {
const { service, projectId } = await readyProject()
const other = await service.open({ path: '/other', name: '另一个项目' })
await service.taskCreate(projectId, { title: 'A 项目任务', ownerSeatId: 'lead' })
const otherTasks = await service.tasks(other.project.id)
assert.equal(otherTasks.tasks.length, 0)
})

23
test/wiring.test.js Normal file
View File

@ -0,0 +1,23 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { apply, name, inject } from '../index.js'
import { createFakeHost, tempStateFile } from './fake-ctx.js'
test('apply 注册提示词与 /api/sansheng 路由并可处理请求', async () => {
const fake = createFakeHost()
const statePath = await tempStateFile()
await apply(fake.ctx, { statePath })
assert.equal(name, 'sansheng')
assert.ok(inject.includes('connection'))
assert.ok(fake.getPromptSection(), '应注册 systemPrompt section')
const route = fake.getRoute()
assert.equal(route.path, '/api/sansheng')
assert.deepEqual(route.methods, ['POST'])
const res = await route.fetch({ json: async () => ({ endpoint: 'open', payload: { path: '/w', name: '接线项目' } }) })
const body = await res.json()
assert.ok(body.ok)
assert.equal(body.value.project.seats.length, 10)
})

View File

@ -1,81 +0,0 @@
// 稳定随机 ID:所有业务主键都由这里生成,名称/路径只作属性,不复用为键。
// 随机源可注入,测试里给定字符表就能复现同一串 ID,避免断言依赖运气。
const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
/** 方案里出现的所有前缀;拼错前缀属于开发期错误,直接抛而不是静默接受。 */
export const ID_PREFIXES = Object.freeze({
project: 'proj',
binding: 'bind',
config: 'cfg',
task: 'task',
dispatch: 'dsp',
attempt: 'att',
contextPacket: 'ctx',
result: 'res',
artifact: 'art',
event: 'evt',
authorization: 'auth',
})
export const ID_ENTITIES = Object.freeze(Object.keys(ID_PREFIXES))
/** 默认随机源:crypto.getRandomValues,取 0..35 的字符。 */
export function cryptoRandom() {
const crypto = globalThis.crypto
if (!crypto || typeof crypto.getRandomValues !== 'function') {
throw new Error('缺少可用的随机源,请注入 random 参数')
}
const bytes = crypto.getRandomValues(new Uint8Array(8))
// 除 36 取余有轻微偏差,但只用于 ID 唯一性,不用于安全令牌。
return ALPHABET[bytes[0] % ALPHABET.length]
}
/**
* 注入的随机源可以返回数字(映射到字母表)或单个字符(必须来自字母表)。
* 两种都接受是为了测试能写 `() => 0` 这样最直白的桩。
*/
function pick(random, index) {
const value = random(index)
if (typeof value === 'number') {
if (!Number.isInteger(value)) throw new Error('随机源必须返回整数或字母表内字符')
// 随机源常被测试当作递增计数器使用,数值可能超过字母表长度甚至为负;
// 先取绝对整数再取模,保证任意整数都能映射到合法字符。
return ALPHABET[Math.abs(value) % 36]
}
const char = String(value)
if (char.length !== 1 || !ALPHABET.includes(char)) throw new Error(`随机源返回了字母表外字符: ${char}`)
return char
}
/**
* 生成 `<prefix>_<随机串>`。
* 前缀既可用实体名('task')也可用前缀本身('task'),两者一致时可省心。
*/
export function newId(prefix, options = {}) {
const { random = cryptoRandom, length = 12 } = options
const known = ID_PREFIXES[prefix]
const resolved = known ?? (Object.values(ID_PREFIXES).includes(prefix) ? prefix : undefined)
if (resolved === undefined) throw new Error(`未知 ID 前缀: ${prefix}`)
if (!Number.isInteger(length) || length < 4 || length > 64) throw new Error('ID 随机串长度须为 4..64')
let out = ''
for (let index = 0; index < length; index += 1) out += pick(random, index)
return `${resolved}_${out}`
}
/** 每个实体一个绑定好随机源的生成器,便于在服务层统一注入并保持测试确定性。 */
export function createIdFactory(options = {}) {
const { random = cryptoRandom, length = 12 } = options
const factory = {}
for (const entity of ID_ENTITIES) {
factory[entity] = () => newId(ID_PREFIXES[entity], { random, length })
}
return Object.freeze(factory)
}
/** 校验外部传入的 ID 形状(防伪 ID 进账;存在性仍由 store 查表)。 */
export function isIdOf(entity, value) {
const prefix = ID_PREFIXES[entity]
if (typeof value !== 'string' || typeof prefix !== 'string') return false
return value.startsWith(`${prefix}_`) && value.length > prefix.length + 1
}

View File

@ -1,194 +0,0 @@
// 记忆层:模仿 DS Bot 的分层记忆,但按本项目的隔离规矩落在原生账本之外。
//
// 三层:
// - 长期记忆(long-term.md):跨项目只此一份,记用户偏好与长期有效的经验。
// - 项目记忆(projects/<projectId>.md):一个项目一份,记这个项目发生过什么、
// 结论是什么;项目之间互不可见——DS Bot 上游「主 Bot 可读全部 Bot 记忆」的
// 弱隔离(归档分支 docs/p0 记录的 M-03 边界)不学。
// - 部门记忆(departments/<roleId>.md):一个席位一份,跟着部门跨项目走,
// 记这个部门自己摸出的经验;派发时只注入目标部门自己那一份,
// 别的部门读不到——隔离规矩与项目记忆一致。
//
// 都是 Markdown:用户可以直接打开看、打开改。程序写入走临时文件 + rename,
// 不写半截;读取惰性(文件不存在 = 空记忆),构造时不碰磁盘,测试与预检
// 装配不会在真实侧车目录里留下东西。
//
// 记忆是参考资料,不是账本:本模块只对「形状不对」(非法项目 ID、超上限)
// 抛 MemoryError;读不到文件一律按空记忆处理,绝不让记忆拖垮业务流程。
import {
existsSync,
mkdirSync,
readFileSync,
renameSync,
rmSync,
writeFileSync,
} from 'node:fs'
import { dirname, join } from 'node:path'
import { isIdOf } from './ids.mjs'
import { isRoleId } from './roles.mjs'
/** 单个记忆文件的字符上限:记忆要短而精,写满说明该整理了。 */
export const MEMORY_FILE_MAX_CHARS = 64 * 1024
/** 派发注入时的摘录上限:交接材料是给部门开工看的,不能被记忆淹没。 */
export const MEMORY_EXCERPT_CHARS = Object.freeze({ department: 2000, project: 3000, longTerm: 2000 })
export class MemoryError extends Error {
constructor(code, message, details = undefined) {
super(message)
this.name = 'MemoryError'
this.code = code
if (details !== undefined) this.details = details
}
}
function requireProjectId(projectId) {
if (!isIdOf('project', projectId)) {
throw new MemoryError('INVALID_ID', `项目 ID 不合法:${String(projectId)}`, { field: 'projectId' })
}
return projectId
}
function requireRoleId(roleId) {
if (!isRoleId(roleId)) {
throw new MemoryError('INVALID_ID', `部门 ID 不合法:${String(roleId)}`, { field: 'roleId' })
}
return roleId
}
function requireMemoryText(text, field = 'text') {
if (typeof text !== 'string') {
throw new MemoryError('INVALID_INPUT', `${field} 必须是字符串`, { field })
}
if (text.length > MEMORY_FILE_MAX_CHARS) {
throw new MemoryError('INVALID_INPUT', `记忆内容超过 ${MEMORY_FILE_MAX_CHARS} 字符上限,请先整理再写入`, { field })
}
return text
}
/** 原子写:先写同目录临时文件再 rename,崩溃时不会留下半截记忆。 */
function writeFileAtomic(file, text) {
mkdirSync(dirname(file), { recursive: true })
const tmp = `${file}.tmp-${process.pid}`
writeFileSync(tmp, text, 'utf8')
try {
renameSync(tmp, file)
} catch (error) {
try { rmSync(tmp, { force: true }) } catch { /* 临时文件清不掉不影响主流程 */ }
throw error
}
}
function readIfExists(file) {
if (!existsSync(file)) return null
return readFileSync(file, 'utf8')
}
function excerptOf(label, text, cap) {
const trimmed = text.trim()
if (trimmed === '') return null
if (trimmed.length <= cap) return `「${label}」\n${trimmed}`
return `「${label}」\n${trimmed.slice(0, cap)}\n…(已截断,完整内容见记忆文件)`
}
/**
* @param {object} options
* @param {string} options.dir 记忆根目录(宿主装配时给侧车目录下的 memory/)
* @param {() => number} [options.clock] 时间源,可注入以便测试复现
*/
export function createMemoryStore(options = {}) {
const { dir, clock = Date.now } = options
if (typeof dir !== 'string' || dir.trim() === '') {
throw new MemoryError('INVALID_INPUT', 'createMemoryStore 需要 dir(记忆根目录)')
}
const longTermFile = join(dir, 'long-term.md')
const projectFile = (projectId) => join(dir, 'projects', `${requireProjectId(projectId)}.md`)
const departmentFile = (roleId) => join(dir, 'departments', `${requireRoleId(roleId)}.md`)
const today = () => new Date(clock()).toISOString().slice(0, 10)
function appendTo(file, title, text) {
const entry = requireMemoryText(text, 'text')
if (entry.trim() === '') {
throw new MemoryError('INVALID_INPUT', 'append 的内容不能为空', { field: 'text' })
}
const current = readIfExists(file)
const head = current === null || current.trim() === '' ? `# ${title}\n` : current.replace(/\s+$/, '') + '\n'
const next = `${head}\n## ${today()}\n\n${entry.trim()}\n`
if (next.length > MEMORY_FILE_MAX_CHARS) {
throw new MemoryError('INVALID_INPUT', `记忆文件已达 ${MEMORY_FILE_MAX_CHARS} 字符上限,请先整理再追加`, {})
}
writeFileAtomic(file, next)
return { text: next }
}
function writeWhole(file, text) {
const value = requireMemoryText(text)
writeFileAtomic(file, value)
return { text: value }
}
const readLongTermFile = () => {
const text = readIfExists(longTermFile)
return { text: text ?? '', exists: text !== null }
}
const readProjectFile = (projectId) => {
const text = readIfExists(projectFile(projectId))
return { text: text ?? '', exists: text !== null }
}
const readDepartmentFile = (roleId) => {
const text = readIfExists(departmentFile(roleId))
return { text: text ?? '', exists: text !== null }
}
return Object.freeze({
dir,
longTermPath: longTermFile,
projectPath: projectFile,
departmentPath: departmentFile,
readLongTerm: readLongTermFile,
writeLongTerm(text) {
return writeWhole(longTermFile, text)
},
appendLongTerm(text) {
return appendTo(longTermFile, '长期记忆', text)
},
readProject: readProjectFile,
writeProject(projectId, text) {
return writeWhole(projectFile(projectId), text)
},
appendProject(projectId, text) {
return appendTo(projectFile(projectId), '项目记忆', text)
},
readDepartment: readDepartmentFile,
writeDepartment(roleId, text) {
return writeWhole(departmentFile(roleId), text)
},
appendDepartment(roleId, text) {
return appendTo(departmentFile(roleId), '部门记忆', text)
},
/**
* 派发时用的摘录:部门记忆在前(干活的人是谁),项目记忆居中
* (这次活的来龙去脉),长期记忆在后(不变的偏好与规矩)。
* roleId 缺失或不合法时跳过部门层——摘录是尽力而为,绝不因此抛错。
* 没有内容的层不产生摘录;返回纯字符串数组,直接并进上下文包的 excerpts。
*/
excerptsFor(projectId, roleId = null) {
const out = []
if (isRoleId(roleId)) {
const department = excerptOf('部门记忆', readDepartmentFile(roleId).text, MEMORY_EXCERPT_CHARS.department)
if (department !== null) out.push(department)
}
const project = excerptOf('项目记忆', readProjectFile(projectId).text, MEMORY_EXCERPT_CHARS.project)
if (project !== null) out.push(project)
const longTerm = excerptOf('长期记忆', readLongTermFile().text, MEMORY_EXCERPT_CHARS.longTerm)
if (longTerm !== null) out.push(longTerm)
return out
},
})
}

View File

@ -1,192 +0,0 @@
// 十席角色常量:新工作台的身份只来自可信的 (projectId, roleId) 绑定,
// 不再用 Team membership 推断,也不再让模型自报角色。
// 布局按「丞相居中在顶 → 三省一列一个 → 六部两排(吏户礼 / 兵刑工)」给出,
// UI 直接按 order 渲染稳定三列,连线的上下级由结构表达,不靠坐标猜测。
/**
* column:布局列(lead 跨三列居中)。
* row:视觉行号(0 丞相、1 三省、2/3 六部一排/二排)。
* tier:leaders = 丞相与三省,ministries = 六部;分组只用于展示,不是 session 父子关系。
*/
const SEATS = [
{
id: 'lead',
name: '丞相',
short: '丞',
tier: 'leaders',
group: 'lead',
column: 'span',
row: 0,
duty: '接需求、分流、协调、汇报',
responsibility: '面向用户承接想法:判断是否需要开工、必要时派给具体部门,并把各部门结果汇总成对用户的一次交付。',
canDispatch: true,
},
{
id: 'zhongshu',
name: '中书',
short: '中',
tier: 'leaders',
group: 'sansheng',
column: 'left',
row: 1,
duty: '调查、澄清、规划',
responsibility: '先把问题问清、把材料看全,再给出可执行的方案与验收标准草案,不直接产出最终交付物。',
canDispatch: false,
},
{
id: 'shangshu',
name: '尚书',
short: '尚',
tier: 'leaders',
group: 'sansheng',
column: 'center',
row: 1,
duty: '分工建议、组织交付',
responsibility: '把已经明确的方案拆成部门分工并组织交付;六部直属于尚书这一同级分组,六部之间不是上下级。',
canDispatch: true,
},
{
id: 'menxia',
name: '门下',
short: '门',
tier: 'leaders',
group: 'sansheng',
column: 'right',
row: 1,
duty: '审议与整体审核',
responsibility: '对方案和交付做独立审议,指出风险与不达标处。首版没有门下审核的任务必须如实标注“未审核”。',
canDispatch: false,
},
{
id: 'libu',
name: '吏部',
short: '吏',
tier: 'ministries',
group: 'ministries',
column: 'left',
row: 2,
duty: '角色和技能配置建议',
responsibility: '对角色、技能与编制给出建议;职责不含绕过用户授权去改权限或其他项目设置。',
canDispatch: false,
},
{
id: 'hubu',
name: '户部',
short: '户',
tier: 'ministries',
group: 'ministries',
column: 'center',
row: 2,
duty: '数据、表格、计算',
responsibility: '处理数据、表格与计算,结论应可复算。',
canDispatch: false,
},
{
id: 'lipu',
name: '礼部',
short: '礼',
tier: 'ministries',
group: 'ministries',
column: 'right',
row: 2,
duty: '文档、内容、呈现',
responsibility: '负责文档、内容与呈现形式,产出可编辑的源文件。',
canDispatch: false,
},
{
id: 'bingbu',
name: '兵部',
short: '兵',
tier: 'ministries',
group: 'ministries',
column: 'left',
row: 3,
duty: '环境、调试、部署',
responsibility: '负责环境、调试与部署;部署/发布等外部副作用仍服从用户授权与宿主审批。',
canDispatch: false,
},
{
id: 'xingbu',
name: '刑部',
short: '刑',
tier: 'ministries',
group: 'ministries',
column: 'center',
row: 3,
duty: '测试与风险检查',
responsibility: '做测试与风险检查,给出可追溯的检查结果,而不是一句“已通过”。',
canDispatch: false,
},
{
id: 'gongbu',
name: '工部',
short: '工',
tier: 'ministries',
group: 'ministries',
column: 'right',
row: 3,
duty: '代码实现与工程产出',
responsibility: '负责代码实现与工程产出,交付可编辑源文件与真实检查结果。',
canDispatch: false,
},
]
export const ROLE_IDS = Object.freeze(SEATS.map((seat) => seat.id))
const byId = new Map(SEATS.map((seat) => [seat.id, Object.freeze(seat)]))
/** 稳定顺序(上表即布局顺序),UI 与初始化都按这个序写,避免每次渲染顺序抖动。 */
export const ROLES = Object.freeze(ROLE_IDS.map((id) => byId.get(id)))
/** 布局顺序 = 数组顺序;单独导出常量是为了让调用方不必依赖“数组被排序过”这个隐含约定。 */
export const LAYOUT_ORDER = ROLE_IDS
export const LEADERS = Object.freeze(ROLES.filter((seat) => seat.tier === 'leaders').map((seat) => seat.id))
export const MINISTRIES = Object.freeze(ROLES.filter((seat) => seat.tier === 'ministries').map((seat) => seat.id))
export function isRoleId(value) {
return typeof value === 'string' && byId.has(value)
}
/** 未知角色返回 undefined,由调用方决定报错文案(不同入口提示不同)。 */
export function getRole(roleId) {
return byId.get(roleId)
}
/** 找不到就抛:角色是内部常量,拼错属于代码错误而非用户输入错误。 */
export function requireRole(roleId) {
const seat = byId.get(roleId)
if (seat === undefined) throw new Error(`未知角色: ${String(roleId)}`)
return seat
}
export const ROLE_NAMES = Object.freeze(Object.fromEntries(ROLES.map((seat) => [seat.id, seat.name])))
/** 存储与显示的兼容映射:旧代码用“中书省/尚书省/门下省”,roleId 不变,名称不参与身份。 */
export const ROLE_NAME_ALIASES = Object.freeze({
zhongshu: Object.freeze(['中书省']),
shangshu: Object.freeze(['尚书省']),
menxia: Object.freeze(['门下省']),
})
/** 按布局把十席分成分组,供右侧部门树一次画完:top / sansheng / ministries 两排。 */
export function layoutGroups() {
return {
lead: ROLES.filter((seat) => seat.id === 'lead').map((seat) => seat.id),
sansheng: ROLES.filter((seat) => seat.group === 'sansheng').map((seat) => seat.id),
ministries: [
ROLES.filter((seat) => seat.tier === 'ministries' && seat.row === 2).map((seat) => seat.id),
ROLES.filter((seat) => seat.tier === 'ministries' && seat.row === 3).map((seat) => seat.id),
],
}
}
/** 首版允许主动派工的席:丞相默认,尚书在用户明确要求时经同一权限校验。 */
export function canDispatch(roleId) {
return byId.get(roleId)?.canDispatch === true
}
/** 初始化项目时用的角色清单(不创建会话,只建配置与绑定初值)。 */
export function initialSeats() {
return ROLES.map((seat) => ({ roleId: seat.id, name: seat.name, tier: seat.tier }))
}

View File

@ -1,138 +0,0 @@
// 四套状态机分开维护:部门运行、任务结论、投递进度、单次尝试。
// 合并成一个大状态会让“空闲”被当成“已完成”,正是方案 7.3/8.1 明确禁止的误判。
export const TASK_STATES = Object.freeze([
'draft',
'queued',
'running',
'waiting_input',
'needs_attention',
'completed',
'failed',
'cancelled',
])
export const DISPATCH_STATES = Object.freeze(['prepared', 'sending', 'accepted', 'unknown', 'rejected'])
export const ATTEMPT_STATES = Object.freeze([
'queued',
'running',
'succeeded',
'failed',
'cancel_requested',
'cancelled',
'unknown',
])
export const DEPARTMENT_STATES = Object.freeze(['uninitialized', 'idle', 'queued', 'running', 'unavailable'])
/**
* Task:draft 校验通过且授权有效才入队;waiting_input 只能回到原任务的执行路径,
* completed 是唯一“可交付”终态;needs_attention 仍可补报后完成,也可显式失败/取消。
* 终态(completed / failed / cancelled)不回到任何活动状态:重试一律新 attempt 或新任务。
*/
const TASK_TRANSITIONS = Object.freeze({
draft: Object.freeze(['queued', 'cancelled']),
queued: Object.freeze(['running', 'waiting_input', 'needs_attention', 'failed', 'cancelled']),
running: Object.freeze(['waiting_input', 'needs_attention', 'completed', 'failed', 'cancelled']),
waiting_input: Object.freeze(['queued', 'running', 'cancelled']),
needs_attention: Object.freeze(['running', 'completed', 'failed', 'cancelled']),
completed: Object.freeze([]),
failed: Object.freeze([]),
cancelled: Object.freeze([]),
})
/** Dispatch:发出不等于接收;超时可能 unknown,必须先对账,不能自动当失败重试。 */
const DISPATCH_TRANSITIONS = Object.freeze({
prepared: Object.freeze(['sending', 'rejected', 'unknown']),
sending: Object.freeze(['accepted', 'unknown', 'rejected']),
accepted: Object.freeze([]),
unknown: Object.freeze(['accepted', 'rejected']),
rejected: Object.freeze([]),
})
/** Attempt:cancel_requested 不等于已取消;unknown 必须先核对宿主运行再定终态。 */
const ATTEMPT_TRANSITIONS = Object.freeze({
queued: Object.freeze(['running', 'cancelled', 'failed', 'unknown']),
running: Object.freeze(['succeeded', 'failed', 'cancel_requested', 'unknown']),
cancel_requested: Object.freeze(['cancelled', 'succeeded', 'unknown']),
succeeded: Object.freeze([]),
failed: Object.freeze([]),
cancelled: Object.freeze([]),
unknown: Object.freeze(['succeeded', 'failed', 'cancelled', 'running']),
})
/** Department 只表达会话运行情况:unavailable 是绑定失效,仍保留旧引用。 */
const DEPARTMENT_TRANSITIONS = Object.freeze({
uninitialized: Object.freeze(['idle', 'queued', 'unavailable']),
idle: Object.freeze(['queued', 'running', 'unavailable']),
queued: Object.freeze(['running', 'idle', 'unavailable']),
running: Object.freeze(['idle', 'queued', 'unavailable']),
unavailable: Object.freeze(['uninitialized', 'idle']),
})
const MACHINES = Object.freeze({
task: Object.freeze({ key: 'task', name: 'Task', states: TASK_STATES, transitions: TASK_TRANSITIONS }),
dispatch: Object.freeze({ key: 'dispatch', name: 'Dispatch', states: DISPATCH_STATES, transitions: DISPATCH_TRANSITIONS }),
attempt: Object.freeze({ key: 'attempt', name: 'Attempt', states: ATTEMPT_STATES, transitions: ATTEMPT_TRANSITIONS }),
department: Object.freeze({ key: 'department', name: 'Department', states: DEPARTMENT_STATES, transitions: DEPARTMENT_TRANSITIONS }),
})
export const STATE_MACHINES = Object.freeze(
Object.fromEntries(Object.entries(MACHINES).map(([key, machine]) => [key, Object.freeze({
name: machine.name,
states: machine.states,
transitions: machine.transitions,
})])),
)
export const TERMINAL_STATES = Object.freeze({
task: Object.freeze(['completed', 'failed', 'cancelled']),
dispatch: Object.freeze(['accepted', 'rejected']),
attempt: Object.freeze(['succeeded', 'failed', 'cancelled']),
department: Object.freeze([]),
})
function machineOf(kind) {
const machine = MACHINES[kind]
if (machine === undefined) throw new Error(`未知状态机: ${String(kind)}`)
return machine
}
export function statesOf(kind) {
return machineOf(kind).states
}
export function isState(kind, value) {
return machineOf(kind).states.includes(value)
}
export function allowedTransitions(kind, from) {
const machine = machineOf(kind)
if (!machine.states.includes(from)) throw new Error(`${machine.name} 未知状态: ${String(from)}`)
return machine.transitions[from]
}
export function canTransition(kind, from, to) {
// 同状态重复写入不算迁移:事件重放时应由调用方静默忽略,而不是报错。
if (from === to) return true
return allowedTransitions(kind, from).includes(to)
}
const MACHINE_KEY = Object.freeze({ task: 'task', dispatch: 'dispatch', attempt: 'attempt', department: 'department' })
export function isTerminal(kind, state) {
return TERMINAL_STATES[machineOf(kind).key].includes(state)
}
/** 非法迁移一律抛错:状态倒退还沉默会让故障矩阵里“终态不被覆盖”的保证失效。 */
export function assertTransition(kind, from, to) {
const machine = machineOf(kind)
if (!machine.states.includes(from)) throw new Error(`${machine.name} 当前状态非法: ${String(from)}`)
if (!machine.states.includes(to)) throw new Error(`${machine.name} 目标状态非法: ${String(to)}`)
if (from === to) return to
if (!machine.transitions[from].includes(to)) {
throw new Error(`${machine.name} 不允许从 ${from} 迁移到 ${to}`)
}
return to
}

File diff suppressed because it is too large Load Diff

View File

@ -1,436 +0,0 @@
// 任务生命周期:纯函数 + 显式副作用端口。
// 判定永远不读聊天文本,只认结构化报告、宿主真实终态和可解析的成果引用——
// 这是“agent 说已完成”与“任务完成”分开的落点。
// 副作用(写 store、入队、回传)由调用方注入,core 本身不碰网络和调度。
import { assertTransition, isState, isTerminal } from './states.mjs'
import { isRoleId } from './roles.mjs'
export class TaskError extends Error {
constructor(code, message, details = undefined) {
super(message)
this.name = 'TaskError'
this.code = code
if (details !== undefined) this.details = details
}
}
const TASK_BASE_TRANSITIONS = Object.freeze([
['draft', 'queued'],
['queued', 'running'],
['running', 'waiting_input'],
['running', 'needs_attention'],
['running', 'completed'],
['running', 'failed'],
['waiting_input', 'queued'],
['waiting_input', 'running'],
['needs_attention', 'completed'],
['needs_attention', 'running'],
['needs_attention', 'failed'],
// 取消可在任何非终态发起
['draft', 'cancelled'],
['queued', 'cancelled'],
['running', 'cancelled'],
['waiting_input', 'cancelled'],
['needs_attention', 'cancelled'],
// 入队后模型不可用:允许直接失败并保留错误
['queued', 'failed'],
])
export const TASK_TRANSITIONS = Object.freeze(TASK_BASE_TRANSITIONS.map(([from, to]) => Object.freeze([from, to])))
const TERMINAL_TASK_STATES = Object.freeze(['completed', 'failed', 'cancelled'])
/** seq 比较:仅当新事件 seq 严格大于已见 seq 才视为“更新”。 */
export function isStaleSeq(lastSeq, nextSeq) {
if (lastSeq === null || lastSeq === undefined) return false
if (!Number.isFinite(nextSeq)) return true
return nextSeq <= lastSeq
}
/** 乱序/重复事件:达到终态后任何“回到活动态”的事件都必须忽略,而不是报错中断处理。 */
export function isRegressingEvent(currentStatus, nextStatus) {
if (TERMINAL_TASK_STATES.includes(currentStatus)) return currentStatus !== nextStatus
return false
}
function transition(state, next, extra = {}) {
assertTransition('task', state, next)
return next
}
function requireString(value, field) {
if (typeof value !== 'string' || value.trim() === '') {
throw new TaskError('INVALID_INPUT', `${field} 必须是非空字符串`)
}
return value
}
function requireTask(task) {
if (task === null || typeof task !== 'object' || typeof task.id !== 'string') {
throw new TaskError('INVALID_TASK', '任务记录不合法')
}
return task
}
/**
* createTask:只建草稿。draft 不等于入队,校验通过且授权有效后才 startTask 入队。
* ownerRoleId 与 sourceRoleId 都必须是已知席,来源席默认丞相。
*/
export function createTask(options, deps = {}) {
const { projectId, title, objective, acceptance = [], ownerRoleId, sourceRoleId = 'lead', originMessageRef = null, scope = null, constraints = [], returnTarget = null } = options ?? {}
requireString(projectId, 'projectId')
requireString(title, 'title')
requireString(objective, 'objective')
if (!isRoleId(ownerRoleId)) throw new TaskError('INVALID_ROLE', `未知主责部门: ${String(ownerRoleId)}`)
if (!isRoleId(sourceRoleId)) throw new TaskError('INVALID_ROLE', `未知来源部门: ${String(sourceRoleId)}`)
const id = typeof deps.newTaskId === 'function' ? deps.newTaskId() : undefined
const stamp = typeof deps.now === 'function' ? deps.now() : new Date().toISOString()
return {
...(id === undefined ? {} : { id }),
projectId,
title,
objective,
acceptance: Array.isArray(acceptance) ? [...acceptance] : [String(acceptance)],
constraints: Array.isArray(constraints) ? [...constraints] : [],
scope: scope ?? null,
ownerRoleId,
sourceRoleId,
originMessageRef,
returnTarget,
status: 'draft',
activeAttemptId: null,
attempts: [],
startedAt: null,
endedAt: null,
reportReceivedAt: null,
needsAttentionReason: null,
failureReason: null,
waitingReason: null,
revision: 1,
createdAt: stamp,
updatedAt: stamp,
}
}
/** 入队:唯一需要的前置是 draft,或者 waiting_input 拿到补充。 */
export function startTask(task, deps = {}) {
requireTask(task)
if (task.status !== 'draft' && task.status !== 'waiting_input') {
throw new TaskError('INVALID_STATE', `只有草稿或待补充的任务可以入队,当前 ${task.status}`)
}
const stamp = stampOf(deps)
return {
...task,
status: transition(task.status, 'queued'),
waitingReason: null,
revision: task.revision + 1,
updatedAt: stamp,
}
}
/**
* beginAttempt:队列中的任务进入执行,并绑定一次尝试。
* 每次重试都是新 attempt,旧尝试(及旧结果引用)保留,不覆盖成“第一次就成功”。
*/
export function beginAttempt(task, attempt, deps = {}) {
requireTask(task)
if (task.status !== 'queued' && task.status !== 'waiting_input' && task.status !== 'needs_attention' && task.status !== 'running') {
throw new TaskError('INVALID_STATE', `任务 ${task.status} 不能开始新的尝试`)
}
// 是否“仍有活动尝试”不能只看 activeAttemptId 是否为空:
// 取消/失败/对账后,Attempt 已转 cancelled/failed/succeeded 终态,但任务的 activeAttemptId 仍指向它(保留审计),
// 若只看非空就会把取消后的重试挡在 ACTIVE_ATTEMPT 上。deps.attemptLookup 由调用方注入(core 不读 store),
// 只有明确查到“非终态”尝试时才算有活动尝试;查不到(undefined/null)时保持旧行为,按非空处理。
// 另:attempt 的 unknown 是待对账状态,不算终态,仍会挡住重试。
const hasActiveAttempt = task.activeAttemptId !== null && task.activeAttemptId !== undefined
&& !isSettledAttempt(task.activeAttemptId, deps)
// running 下换尝试等于重试:必须先把旧尝试对账(失败/取消),否则两次运行会同时往一个任务里写结果。
if (task.status === 'running' && hasActiveAttempt) {
throw new TaskError('ACTIVE_ATTEMPT', '当前尝试仍在运行,先对账再重试')
}
if (attempt === null || typeof attempt !== 'object' || typeof attempt.id !== 'string') {
throw new TaskError('INVALID_ATTEMPT', '尝试记录不合法')
}
if (attempt.projectId !== task.projectId) {
throw new TaskError('CROSS_PROJECT', '尝试与任务不属于同一项目')
}
if (attempt.taskId !== task.id) {
throw new TaskError('CROSS_TASK', '尝试挂在别的任务上')
}
if (task.status === 'needs_attention' && hasActiveAttempt) {
throw new TaskError('ACTIVE_ATTEMPT', '仍有未对账的尝试,先完成或标记失败')
}
const stamp = stampOf(deps)
return {
...task,
status: transition(task.status, 'running'),
activeAttemptId: attempt.id,
attempts: [...task.attempts, attempt.id],
startedAt: task.startedAt ?? stamp,
needsAttentionReason: null,
waitingReason: null,
revision: task.revision + 1,
updatedAt: stamp,
}
}
/** 结构化报告是否“可信”:summary 非空、成果引用形状正确、检查是真实结果而非空话。 */
export function validateReport(report) {
const errors = []
if (report === null || typeof report !== 'object') return ['报告必须是对象']
if (!report.attemptId || typeof report.attemptId !== 'string') errors.push('缺少 attemptId')
if (!report.taskId || typeof report.taskId !== 'string') errors.push('缺少 taskId')
if (typeof report.summary !== 'string' || report.summary.trim() === '') errors.push('结果摘要为空')
if (report.artifactRefs !== undefined) {
if (!Array.isArray(report.artifactRefs)) errors.push('artifactRefs 必须是数组')
else {
for (const ref of report.artifactRefs) {
if (typeof ref !== 'string' || !ref.startsWith('art_')) errors.push(`成果引用形状非法: ${String(ref)}`)
}
}
}
if (report.checks !== undefined && !Array.isArray(report.checks)) errors.push('checks 必须是数组')
return errors
}
/**
* 三条完成条件各占一票,缺一条都不能标 completed:
* 1. 可信结构化报告(有摘要、有检查、没有未解决阻塞)
* 2. 宿主运行终态成功(由调用方从宿主取得,不能猜“空闲=成功”)
* 3. 成果引用有效(引用指向本项目现存成果,或被显式标为不可用)
*/
export function checkCompletion(input) {
const { report = null, runTerminal = null, artifactRefs = [], artifactLookup = null } = input ?? {}
const blockers = []
let reportOk = false
if (report !== null) {
const errors = validateReport(report)
if (errors.length > 0) blockers.push(...errors)
else if (typeof report.blockedReason === 'string' && report.blockedReason.trim() !== '') {
blockers.push('报告标记了阻塞原因')
} else reportOk = true
} else {
blockers.push('未收到结构化报告')
}
const runOk = runTerminal === 'succeeded'
if (runTerminal === null) blockers.push('宿主运行尚未结束')
else if (!runOk) blockers.push(`宿主运行终态为 ${String(runTerminal)}`)
const refs = Array.isArray(artifactRefs) ? artifactRefs : []
const invalidRefs = []
for (const ref of refs) {
if (typeof ref !== 'string' || !ref.startsWith('art_')) invalidRefs.push(String(ref))
else if (typeof artifactLookup === 'function') {
const artifact = artifactLookup(ref)
if (artifact === undefined || artifact === null) invalidRefs.push(ref)
else if (artifact.verification?.status === 'missing') invalidRefs.push(ref)
}
}
if (invalidRefs.length > 0) blockers.push(`成果引用无效: ${invalidRefs.join(', ')}`)
// 纯分析任务允许没有文件,所以“引用为空”本身不算失败,但登记结果时不能伪造附件。
return { reportOk, runOk, refsValid: invalidRefs.length === 0, blockers, ok: reportOk && runOk && invalidRefs.length === 0 }
}
/**
* 完成判定三分支:
* - 报告 + 终态成功 + 成果有效 → completed
* - 只有报告(运行未结束) → 保持 running 等终态(waiting 只是“候选结果已存”)
* - 只有终态(无报告) → needs_attention,提供补报入口,不显示已完成
*/
export function evaluateCompletion(task, input, deps = {}) {
return decide(task, { kind: 'completion', ...input }, deps)
}
/**
* 统一事件入口:先按 seq 去重、再按状态机判定。旧 seq 或终态后的事件返回
* { applied:false, stale:true, task },让调用方知道“什么都没变”而不是误以为写入失败。
*/
export function decide(task, event, deps = {}) {
requireTask(task)
if (event === null || typeof event !== 'object') throw new TaskError('INVALID_EVENT', '事件必须是对象')
const nextSeq = event.seq
if (nextSeq !== undefined && isStaleSeq(task.lastSeq ?? null, nextSeq)) {
return { applied: false, stale: true, task }
}
const stamp = stampOf(deps)
const base = nextSeq === undefined ? task : { ...task, lastSeq: nextSeq }
const commit = (next) => ({
applied: true,
stale: false,
task: applyStamp({ ...next, id: task.id, projectId: task.projectId }, next, stamp, base),
})
switch (event.kind) {
case 'completion': {
if (isTerminal('task', task.status)) return { applied: false, stale: true, task, reason: '任务已终态' }
const verdict = checkCompletion(event)
if (!verdict.reportOk && verdict.runOk) {
return commit({
...base,
status: transition(task.status, 'needs_attention'),
needsAttentionReason: '宿主运行已结束但没有有效的结构化报告',
reportReceivedAt: base.reportReceivedAt ?? null,
})
}
// 用户主动停止的会话,运行终态是 cancelled 而不是"成功但没报告":
// 这一票足以把任务收成 cancelled,不需要也不可能再等到结构化报告。
if (event.runTerminal === 'cancelled' && !verdict.reportOk) {
return commit({ ...base, status: transition(task.status, 'cancelled'), endedAt: stamp })
}
if (!verdict.ok) {
// 报告不完整:只记录候选报告,等下一次带完整信息的事件。
return { applied: false, stale: false, task: base, reason: verdict.blockers.join('; '), verdict }
}
return commit({
...base,
status: transition(task.status, 'completed'),
reportReceivedAt: stamp,
needsAttentionReason: null,
failureReason: null,
})
}
case 'report': {
if (isTerminal('task', task.status)) return { applied: false, stale: true, task }
const errors = validateReport(event.report)
if (errors.length > 0) throw new TaskError('INVALID_REPORT', errors.join('; '), { errors })
// 报告先到:保存候选结果,等待宿主终态。
return commit({ ...base, reportReceivedAt: stamp, needsAttentionReason: null })
}
case 'run_terminal': {
if (isTerminal('task', task.status)) return { applied: false, stale: true, task }
const state = event.runTerminal
if (state === 'succeeded') {
// 只有报告已经到达,才可能在这里直接完成;否则留给 completion 判定。
if (base.reportReceivedAt !== null && base.status === 'running') {
return commit({ ...base, status: transition(task.status, 'completed') })
}
return { applied: false, stale: false, task: base, reason: '等待结构化报告' }
}
if (state === 'cancelled') {
return commit({ ...base, status: transition(task.status, 'cancelled'), endedAt: stamp })
}
return commit({
...base,
status: transition(task.status, 'needs_attention'),
needsAttentionReason: `宿主运行终态为 ${String(state)}`,
})
}
case 'input_required': {
if (task.status !== 'running' && task.status !== 'queued') {
return { applied: false, stale: false, task, reason: `任务 ${task.status} 不接受待补充状态` }
}
return commit({ ...base, status: transition(task.status, 'waiting_input'), waitingReason: String(event.reason ?? '') })
}
case 'input_supplied': {
if (task.status !== 'waiting_input') return { applied: false, stale: false, task, reason: '任务不在待补充状态' }
return commit({ ...base, status: transition(task.status, 'running'), waitingReason: null })
}
case 'retry': {
if (task.status !== 'failed' && task.status !== 'cancelled') {
return { applied: false, stale: false, task, reason: '只有失败或已取消的任务可以重试(新任务)' }
}
throw new TaskError('RETRY_REQUIRES_NEW_TASK', '失败/取消后的重试必须创建新任务与新尝试,不能复活旧记录')
}
default:
throw new TaskError('UNKNOWN_EVENT', `未知事件类型: ${String(event.kind)}`)
}
}
/** 结束时间只写一次:重复到达的终态事件不应改动“最后一次改动时间”。 */
function applyStamp(task, next, stamp, base) {
const now = { ...base, ...next, updatedAt: stamp }
// completed/failed/cancelled 结束时间只写一次,重复写入会伪造“最后一次改动时间”。
if (TERMINAL_TASK_STATES.includes(now.status) && now.endedAt === null) now.endedAt = stamp
if (!Number.isFinite(now.revision) || now.revision < 1) now.revision = 1
else if (now.status !== task.status) now.revision = task.revision + 1
return now
}
function stampOf(deps) {
return typeof deps.now === 'function' ? deps.now() : new Date().toISOString()
}
/**
* activeAttemptId 指向的尝试是否已对账(终态)。
* 调用方通过 deps.attemptLookup(attemptId) 提供当前 Attempt 记录;core 不直接读 store。
* unknown 是“待核对宿主”的中间态,不是终态,因此仍然算活动尝试。
*/
function isSettledAttempt(attemptId, deps) {
const lookup = deps?.attemptLookup
if (typeof lookup !== 'function') return false
const record = lookup(attemptId)
if (record === null || record === undefined || typeof record !== 'object') return false
return isTerminal('attempt', record.state)
}
// ---------- 便捷包装:每个都只调用 decide,签名简单便于调用方阅读 ----------
export function requestInput(task, reason, deps = {}) {
return decide(task, { kind: 'input_required', reason, seq: deps.seq }, deps)
}
export function supplyInput(task, deps = {}) {
return decide(task, { kind: 'input_supplied', seq: deps.seq }, deps)
}
export function completeTask(task, input, deps = {}) {
return decide(task, { kind: 'completion', ...input, seq: input?.seq }, deps)
}
/** 失败必须带原因:没有原因的失败在详情页无法给出恢复入口。 */
export function failTask(task, reason, deps = {}) {
requireTask(task)
requireString(reason, 'reason')
if (isTerminal('task', task.status)) {
return { applied: false, stale: true, task, reason: '任务已终态' }
}
const stamp = stampOf(deps)
return {
applied: true,
stale: false,
task: {
...task,
status: transition(task.status, 'failed'),
failureReason: reason,
updatedAt: stamp,
endedAt: task.endedAt ?? stamp,
revision: task.revision + 1,
},
}
}
/** 取消是请求,不是结果:这里只落“已取消”的业务结论,宿主的 cancel_requested 另记在 attempt。 */
export function cancelTask(task, reason = '用户取消', deps = {}) {
requireTask(task)
if (isTerminal('task', task.status)) {
return { applied: false, stale: true, task, reason: '任务已终态' }
}
const stamp = stampOf(deps)
return {
applied: true,
stale: false,
task: {
...task,
status: transition(task.status, 'cancelled'),
failureReason: task.failureReason ?? null,
cancelReason: reason,
updatedAt: stamp,
endedAt: task.endedAt ?? stamp,
revision: task.revision + 1,
},
}
}
/** 把 decide 的结果套到 store 上:只有 applied 才写,避免陈旧事件产生 revision 抖动。 */
export function applyDecision(store, taskId, decision) {
if (store === undefined || store === null) throw new TaskError('INVALID_STORE', '需要 store')
if (decision === null || typeof decision !== 'object') throw new TaskError('INVALID_DECISION', '判定结果不合法')
if (decision.applied !== true) return decision
const saved = store.updateTask(decision.task)
return { ...decision, task: saved }
}
/** 任务是否仍在进行(UI 需要区分终态与活动态,但不允许显示百分比)。 */
export function isOpenTask(task) {
return task !== null && typeof task === 'object' && isState('task', task.status) && !isTerminal('task', task.status)
}

View File

@ -1,144 +0,0 @@
// 部门 ↔ 程序的内部操作契约(方案 §6)。
//
// 四个动作是唯一的“业务事实来源”:
// dispatchTask / reportTaskResult / requestTaskInput / syncDecision
// 部门在会话里怎么说话都不影响账本;账本只认这四条结构化调用。
//
// 部门在没有自建 HTTP 通道时,用一段可解析的行内指令表达这四个动作:
// 【三省六部】{"action":"reportTaskResult","taskId":"task_…","attemptId":"att_…",…}
// 指令行必须单独成行,前缀固定、正文是单行 JSON。解析器宁可返回 null 也不猜测:
// 解析失败的行当普通文本,绝不用“看起来像”的句子更新任务状态(方案明令禁止)。
//
// 这里只做“文本 ↔ 结构化调用”的纯转换,不碰网络、不碰 store,便于单测。
export const CONTRACT_ACTION_PREFIX = '【三省六部】'
/** 四个合法动作:多一个少一个都属于“意图不明”,直接拒绝而不是猜。 */
export const CONTRACT_ACTIONS = Object.freeze([
'dispatchTask',
'reportTaskResult',
'requestTaskInput',
'syncDecision',
])
const ACTION_SET = new Set(CONTRACT_ACTIONS)
export class ContractError extends Error {
constructor(code, message, details = undefined) {
super(message)
this.name = 'ContractError'
this.code = code
if (details !== undefined) this.details = details
}
}
/**
* 从一段部门输出里取出全部契约行。
*
* 返回 { calls, invalid }:
* - calls:解析成功的调用,按出现顺序;
* - invalid:看起来像契约行但 JSON 坏了/缺 action 的行(附原文,便于在 UI 上提示重发)。
*
* 一个动作只接受一行一条。同一行里塞数组视为格式错误:批量派发必须逐条写,
* 否则“派发到一半失败”无法解释是哪一条。
*/
export function parseContractLines(text) {
const calls = []
const invalid = []
if (typeof text !== 'string' || text === '') return { calls, invalid }
const lines = text.split(/\r?\n/)
for (const raw of lines) {
const line = raw.trim()
if (!line.startsWith(CONTRACT_ACTION_PREFIX)) continue
const body = line.slice(CONTRACT_ACTION_PREFIX.length).trim()
let parsed
try {
parsed = JSON.parse(body)
} catch (error) {
invalid.push({ line: raw, reason: `JSON 解析失败:${error.message}` })
continue
}
if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
invalid.push({ line: raw, reason: '契约正文必须是单个对象' })
continue
}
if (typeof parsed.action !== 'string' || !ACTION_SET.has(parsed.action)) {
invalid.push({ line: raw, reason: `未知动作:${String(parsed.action)}` })
continue
}
calls.push({ action: parsed.action, payload: parsed })
}
return { calls, invalid }
}
/** 给部门用的指令模板:只描述字段,不塞业务判断,避免模板把“已完成”写成结论。 */
const TEMPLATES = Object.freeze({
dispatchTask: {
taskId: 'task_…',
targetRoleId: 'gongbu',
idempotencyKey: '<同一任务同一意图固定不变>',
packet: { objective: '…', acceptance: ['…'], constraints: [], materialRefs: [] },
},
reportTaskResult: {
taskId: 'task_…',
attemptId: 'att_…',
reportVersion: 1,
summary: '做了什么、结果是什么',
checks: [{ name: '检查项', ok: true, detail: '证据' }],
artifactRefs: ['art_…'],
},
requestTaskInput: {
taskId: 'task_…',
attemptId: 'att_…',
reason: '缺什么、为什么必须由用户决定',
},
syncDecision: {
taskId: 'task_…',
decision: 'approve | reject | retry',
note: '可选说明',
},
})
/** 渲染成可直接贴进部门系统提示的一小段说明。 */
export function describeContract() {
const lines = [
`需要走程序的动作,请单独起一行,写作:${CONTRACT_ACTION_PREFIX}{…单行 JSON…}`,
'平台只认下面四个动作,且只认结构化字段——在正文里写“已完成”不会改变任务状态。',
]
for (const action of CONTRACT_ACTIONS) {
lines.push(`· ${action}:${JSON.stringify(TEMPLATES[action])}`)
}
return lines.join('\n')
}
/**
* 单条调用的轻量校验(字段存在性与形状)。业务级校验(归属、状态机、幂等)在 service 层,
* 这里只拦“明显没法处理”的调用,让错误尽早、可读地回到部门。
*/
export function validateContractCall(call) {
const errors = []
if (call === null || typeof call !== 'object') return ['调用必须是对象']
if (!ACTION_SET.has(call.action)) errors.push(`未知动作:${String(call.action)}`)
const payload = call.payload ?? {}
if (typeof payload.taskId !== 'string' || payload.taskId.trim() === '') errors.push('缺少 taskId')
switch (call.action) {
case 'dispatchTask':
if (typeof payload.idempotencyKey !== 'string' || payload.idempotencyKey.trim() === '') {
errors.push('dispatchTask 必须带 idempotencyKey(同一意图固定不变)')
}
break
case 'reportTaskResult':
if (typeof payload.attemptId !== 'string' || payload.attemptId.trim() === '') errors.push('reportTaskResult 必须带 attemptId')
if (typeof payload.summary !== 'string' || payload.summary.trim() === '') errors.push('reportTaskResult 必须带非空 summary')
break
case 'requestTaskInput':
if (typeof payload.reason !== 'string' || payload.reason.trim() === '') errors.push('requestTaskInput 必须带 reason')
break
case 'syncDecision':
if (typeof payload.decision !== 'string' || payload.decision.trim() === '') errors.push('syncDecision 必须带 decision')
break
default:
break
}
return errors
}

View File

@ -1,211 +0,0 @@
// DispatchService:把“账本里的一纸派发”变成“部门会话里真实收到的一条消息”。
//
// 方案 §7.5 的时序在这里落成四段,每一步失败都有明确去向:
// prepared → 选定会话与配置快照 → sending → prompt(requestId=attemptId)
// ├─ 成功 → accepted
// ├─ 宿主明确拒绝 → rejected(任务保留在排队态,可重试,不算业务失败)
// └─ 超时/断线 → unknown(先查证再决定,绝不自动当失败重发)
//
// 幂等的两层:dispatch 行按 (projectId, idempotencyKey) 去重;prompt 按 attemptId 当 requestId。
// 因此“用户连点两次”与“发送超时后重试”都不会让部门收到两条任务单。
import { buildDispatchText } from './session-adapter.mjs'
import { describeContract } from './contract.mjs'
export const DISPATCH_OUTCOMES = Object.freeze(['accepted', 'rejected', 'unknown'])
export class DispatchError extends Error {
constructor(code, message, details = undefined) {
super(message)
this.name = 'DispatchError'
this.code = code
if (details !== undefined) this.details = details
}
}
/**
* @param {object} options
* @param {object} options.store WorkbenchStore
* @param {object} options.service 工作台服务
* @param {object} options.sessions createSessionAdapter 的产物
* @param {(message: string) => void} [options.log]
* @param {string} [options.clientTimeZone] 派发提示里的时区,默认 Asia/Shanghai
*/
export function createDispatchService(options = {}) {
const { store, service, sessions, log = () => {}, clientTimeZone = 'Asia/Shanghai',
applyModelToSessions = false } = options
if (store === undefined || typeof store.findDispatchByIdempotencyKey !== 'function') {
throw new DispatchError('NO_STORE', 'DispatchService 需要 WorkbenchStore')
}
if (service === undefined || typeof service.dispatchTask !== 'function') {
throw new DispatchError('NO_SERVICE', 'DispatchService 需要工作台服务')
}
if (sessions === undefined || typeof sessions.sendPrompt !== 'function') {
throw new DispatchError('NO_SESSIONS', 'DispatchService 需要会话适配层')
}
const contractGuide = describeContract()
/**
* 派发一个已入队任务。返回 { dispatch, attempt, outcome, duplicate }。
*
* 注意顺序:先写账(dispatch+attempt,同一次事务)再发消息。发送前崩溃只会留下
* prepared 行,对账器会把它当“未发出”处理;先发后写则会出现“部门已收到但账上没有”。
*/
async function dispatch(input = {}) {
const projectId = requireText(input.projectId, 'projectId')
const taskId = requireText(input.taskId, 'taskId')
const idempotencyKey = requireText(input.idempotencyKey, 'idempotencyKey')
// 1) 账务:去重 + 校验 + 落 prepared
const prepared = service.dispatchTask({
projectId,
taskId,
idempotencyKey,
sourceRoleId: input.sourceRoleId,
targetRoleId: input.targetRoleId,
targetSessionId: input.targetSessionId,
bindingGeneration: input.bindingGeneration,
packet: input.packet,
attemptId: input.attemptId,
})
const { dispatch, attempt, duplicate } = splitPrepared(prepared)
if (duplicate) {
// 重复点击:什么都不再做,返回既有结论(含 unknown 的历史要由对账处理)。
return { dispatch, attempt, outcome: outcomeOf(dispatch), duplicate: true }
}
if ((dispatch.status ?? dispatch.state) === 'accepted') return { dispatch, attempt, outcome: 'accepted', duplicate: false }
// 2) 发送:先把 dispatch 推到 sending,再动宿主,避免“宿主已收但账上还是 prepared”。
store.updateDispatch(dispatch.id, { status: 'sending', state: 'sending', sendingAt: new Date().toISOString() })
const task = store.getTask(taskId)
const packet = attempt?.contextPacketId === undefined || attempt?.contextPacketId === null
? null
: store.getContextPacket(attempt.contextPacketId)
const roleName = input.roleName ?? null
try {
// 3) 固定本轮配置:模型只在发送前覆写一次,运行中改配置不影响这一轮。
// 默认不碰宿主会话的模型选择:部门模型由政策插件在 agent/request 上按角色覆写,
// 再调 selectModel 既重复,又会让宿主后台把全局默认模型存成本部门的(A06)。
// 只有显式 applyModelToSessions:true 时才落这一步。
const snapshot = attempt?.effectiveConfigSnapshot ?? null
if (applyModelToSessions && snapshot !== null && snapshot.provider && snapshot.model) {
await sessions.applyModel({
sessionId: attempt.sessionId,
provider: snapshot.provider,
model: snapshot.model,
reasoningEffort: snapshot.reasoningEffort ?? undefined,
})
}
const text = buildDispatchText({ task, packet, contractGuide, roleName })
const result = await sessions.sendPrompt({
sessionId: attempt.sessionId,
requestId: attempt.id,
text,
mode: input.mode ?? 'queue',
clientTimeZone,
})
if (result.accepted !== true) {
markRejected({ dispatch, attempt, reason: '宿主未确认接收' })
return { dispatch: store.getDispatch(dispatch.id), attempt, outcome: 'rejected', duplicate: false }
}
// 宿主确认接收 = 这一轮真的开始跑:任务与尝试同时进 running。
// 只改尝试不改任务,运行终态就无处落地(completion 会因任务仍在 queued 而被丢弃)。
service.startAttempt({
projectId: dispatch.projectId,
taskId: dispatch.taskId,
attemptId: attempt.id,
hostRunId: null,
})
markAccepted({ dispatch, attempt })
return { dispatch: store.getDispatch(dispatch.id), attempt: store.getAttempt(attempt.id), outcome: 'accepted', duplicate: false }
} catch (error) {
const code = error?.code ?? 'unknown'
if (code === 'conflict' || code === 'rejected') {
markRejected({ dispatch, attempt, reason: error?.message ?? String(error) })
return { dispatch: store.getDispatch(dispatch.id), attempt, outcome: 'rejected', duplicate: false }
}
// 超时、断线、context 丢失:一律 unknown —— 先查证,不重发。
markUnknown({ dispatch, attempt, reason: code })
log(`[sansheng-liubo] 派发 ${dispatch.id} 结果未知(${code}):${error?.message ?? error}`)
return { dispatch: store.getDispatch(dispatch.id), attempt, outcome: 'unknown', duplicate: false }
}
}
/**
* 对 unknown 的派发做查证:问宿主该会话是否有过这次 attempt 的请求。
* 查不到就保持 unknown(再次对账),查到有 → accepted;宿主明确从未收到 → rejected。
*/
async function verifyUnknown(dispatchId) {
const dispatch = store.getDispatch(dispatchId)
if (dispatch === undefined) throw new DispatchError('NOT_FOUND', `派发不存在:${dispatchId}`)
if ((dispatch.status ?? dispatch.state) !== 'unknown') return { dispatch, outcome: outcomeOf(dispatch), changed: false }
const attempt = dispatch.attemptId === null ? null : store.getAttempt(dispatch.attemptId)
if (attempt === null) return { dispatch, outcome: 'unknown', changed: false }
const known = await sessions.inspectSession(attempt.sessionId)
if (known === null) return { dispatch, outcome: 'unknown', changed: false }
// 会话存在:宿主已经接受过这条消息(prompt 幂等键会挡住重复投递),按 accepted 收口。
store.updateDispatch(dispatch.id, { status: 'accepted', state: 'accepted', verifiedAt: new Date().toISOString() })
if (attempt.state === 'unknown') {
store.updateAttempt(attempt.id, { state: 'running', hostRunId: attempt.hostRunId ?? null })
}
return { dispatch: store.getDispatch(dispatch.id), outcome: 'accepted', changed: true }
}
function splitPrepared(result) {
// service.dispatchTask 返回 { dispatch, attempt, task, roleId, duplicate }(形状见 P1 Phase2)。
if (result === null || typeof result !== 'object' || result.dispatch === undefined) {
throw new DispatchError('BAD_PREPARED', '服务返回的派发结果形状不正确')
}
return { dispatch: result.dispatch, attempt: result.attempt ?? null, duplicate: result.duplicate === true }
}
function markAccepted({ dispatch, attempt }) {
const stamp = new Date().toISOString()
store.mutate(() => {
store.updateDispatch(dispatch.id, { status: 'accepted', state: 'accepted', acceptedAt: stamp })
if (attempt !== null && attempt.state === 'queued') {
store.updateAttempt(attempt.id, { state: 'running', startedAt: stamp })
}
})
}
function markRejected({ dispatch, attempt, reason }) {
const stamp = new Date().toISOString()
store.mutate(() => {
store.updateDispatch(dispatch.id, { status: 'rejected', state: 'rejected', rejectedAt: stamp, error: String(reason ?? '') })
if (attempt !== null && (attempt.state === 'queued' || attempt.state === 'unknown')) {
store.updateAttempt(attempt.id, { state: 'failed', endedAt: stamp, error: String(reason ?? '') })
}
})
}
function markUnknown({ dispatch, attempt, reason }) {
const stamp = new Date().toISOString()
store.mutate(() => {
store.updateDispatch(dispatch.id, { status: 'unknown', state: 'unknown', unknownAt: stamp, error: String(reason ?? '') })
if (attempt !== null && attempt.state === 'queued') {
store.updateAttempt(attempt.id, { state: 'unknown' })
}
})
}
return Object.freeze({ dispatch, verifyUnknown })
}
function outcomeOf(dispatch) {
if ((dispatch.status ?? dispatch.state) === 'accepted') return 'accepted'
if ((dispatch.status ?? dispatch.state) === 'rejected') return 'rejected'
if ((dispatch.status ?? dispatch.state) === 'unknown') return 'unknown'
return 'prepared'
}
function requireText(value, field) {
if (typeof value !== 'string' || value.trim() === '') {
throw new DispatchError('INVALID_INPUT', `${field} 必须是非空字符串`, { field })
}
return value
}

View File

@ -1,230 +0,0 @@
// Host 侧装配:把账本、业务服务、会话层和 HTTP 路由接在一起。
//
// 这一层是唯一知道“账本文件在哪、损坏了怎么办”的地方:
// - 账本损坏(不是 JSON / schemaVersion 不符)时不崩溃:把坏文件改名留存,
// 从空账本启动,并把 warning 交给调用方(index.js / 诊断页)显示。
// 悄悄删掉或不说话都会让人以为“历史记录丢了”。
// - 宿主没有 webServer 时照常返回 service,只是路由不注册,registered=false;
// 若宿主稍后提供了 webServer,用 ctx.inject 补注册一次(不重复建 store)。
// - 宿主没有 sessionController 时,工作台仍能读写账本(投影可用),
// 但派发只落账不投递,UI 显示“尚未接通”,绝不假装成功。
//
// 与 workbench-host.mjs 的关系:那边是「账本 + 会话层 + 对账」的纯逻辑外壳,
// 这边负责文件、损坏隔离、HTTP 与生命周期,并把路由钩子接到外壳上。
import { existsSync, renameSync } from 'node:fs'
import { WorkbenchStore, SCHEMA_VERSION } from '../core/store.mjs'
import { corruptPathFor, ensureSidecarDir, resolveSidecarDir, resolveStorePath } from './paths.mjs'
import { registerWorkbenchRoutes } from './routes.mjs'
import { createWorkbenchHost as createWorkbenchShell } from './workbench-host.mjs'
export { createWorkbenchService } from './service.mjs'
export { createMemoryStore, MemoryError, MEMORY_FILE_MAX_CHARS, MEMORY_EXCERPT_CHARS } from '../core/memory.mjs'
export {
createWorkbenchHost as createWorkbenchShell,
CONTRACT_ACTIONS,
CONTRACT_ACTION_PREFIX,
describeContract,
parseContractLines,
WORKBENCH_HOST_VERSION,
} from './workbench-host.mjs'
export {
buildRouteTable,
listWorkbenchRoutes,
registerWorkbenchRoutes,
MAX_BODY_BYTES,
ROUTE_PREFIX,
} from './routes.mjs'
export {
SIDECAR_DIR_NAME,
corruptPathFor,
ensureSidecarDir,
quarantineFile,
readJsonSafe,
resolveSidecarDir,
resolveSidecarFile,
resolveStorePath,
writeFileAtomic,
writeJsonAtomic,
} from './paths.mjs'
/**
* 创建 Host 侧工作台。
*
* @param {object|null} ctx 宿主上下文(可为 null:服务仍可用,只是没有路由/会话)。
* @param {object} [options]
* @param {string} [options.file] 账本路径;默认 %DSH_HOME%/sansheng-liubu/workbench.json。
* @param {object} [options.env] 计算默认路径用的环境变量。
* @param {() => number} [options.clock] 注入时钟。
* @param {() => string} [options.random] 注入随机源(测试里固定 ID 用)。
* @param {boolean} [options.load=true] 是否从磁盘加载既有账本。
* @param {string} [options.presetId] 部门会话显式使用的 agentPreset;缺省不指定,走宿主默认创建流程。
* @param {boolean} [options.startReconciler=true] 是否启动周期对账。
* @param {number} [options.longPollMs] 事件长轮询上限(毫秒)。
* @param {number} [options.pollIntervalMs] 长轮询内部检查间隔(毫秒)。
* @returns {object} 见文件末尾 return 语句的字段说明。
*/
export function createWorkbenchHost(ctx, options = {}) {
const env = options.env ?? process.env
const clock = options.clock ?? Date.now
const file = options.file === undefined ? resolveStorePath(env) : options.file
const warnings = []
const log = typeof options.log === 'function' ? options.log : () => {}
// 测试与嵌入场景可以自带账本;自带时不碰磁盘路径,也不做损坏隔离(那是文件的责任)。
const injectedStore = options.store ?? null
const store = injectedStore ?? new WorkbenchStore({
file,
clock,
env,
...(options.random === undefined ? {} : { random: options.random }),
})
if (injectedStore === null && options.load !== false && file !== null && file !== '') {
ensureSidecarDir(env)
if (existsSync(file)) {
try {
store.load()
} catch (error) {
// 损坏与版本不符都是“这个文件不能用”:改名留存后从空账本启动。
// 绝不覆盖原文件——里面可能是用户唯一一份历史。
const stamp = new Date(clock()).toISOString().replace(/[:.]/g, '-')
let quarantined = corruptPathFor(file, stamp)
try {
renameSync(file, quarantined)
} catch (renameError) {
// 改名失败(被占用/权限不足):不能继续往同一个文件写,退回纯内存账本。
quarantined = null
warnings.push(
`账本损坏且无法改名留存(${renameError?.code ?? 'UNKNOWN'}):${error?.message ?? ''};本次使用内存账本`,
)
}
if (quarantined !== null) {
warnings.push(
`账本损坏(${error?.code ?? 'ERROR'}:${error?.message ?? ''}),已改名留存为 ${quarantined},以空账本启动`,
)
}
}
}
}
// 外壳持有 store 与 service,并在宿主有能力时装配会话层/派发/对账。
const shell = createWorkbenchShell(ctx, {
store,
presetId: options.presetId,
startReconciler: options.startReconciler,
clock,
// 成果文件是否还在,由宿主文件系统回答(A23 失效显示);测试可注入替身。
fileExists: options.fileExists ?? existsSync,
})
const service = shell.service
const hooks = routeHooks(shell, service)
let routes = registerWorkbenchRoutes(ctx, service, { ...options, ...hooks })
let registered = routes.registered !== false
if (!registered) warnings.push(`工作台接口未注册:${routes.reason ?? '宿主未提供 webServer'}`)
// 宿主稍后才提供 webServer 时补注册一次;cordis 会在依赖出现时回调,
// 插件卸载时随作用域一起清理,不需要手工跟踪。
if (!registered && ctx !== null && typeof ctx?.inject === 'function') {
try {
ctx.inject(['webServer'], (scoped) => {
if (registered) return
const late = registerWorkbenchRoutes({ webServer: scoped?.webServer }, service, { ...options, ...hooks })
if (late.registered === false) return
routes = late
registered = true
})
} catch (error) {
warnings.push(`工作台接口补注册失败:${error?.message ?? error}`)
}
}
// 会话层也可能晚到:apply 时 sessionController 还没装好,等它出现再挂载一次,
// 这样用户不必为了「接通部门」而多重启一次 DSH。
if (shell.hasSessions === false && ctx !== null && typeof ctx?.inject === 'function') {
try {
ctx.inject(['sessionController'], (scoped) => {
if (shell.hasSessions === true) return
const controller = scoped?.sessionController ?? scoped?.remote?.session ?? null
if (controller === null) return
if (!shell.attachSessions(controller)) return
log('[sansheng-liubo] 会话层已就绪,部门可以接通与派发')
})
} catch (error) {
warnings.push(`会话层补挂失败:${error?.message ?? error}`)
}
}
shell.start()
const dispose = () => {
try {
routes()
} finally {
shell.dispose()
}
}
return {
store,
service,
shell,
routes,
get sessions() {
return shell.sessions
},
get reconciler() {
return shell.reconciler
},
get dispatchService() {
return shell.dispatchService
},
get hasSessions() {
return shell.hasSessions
},
attachSessions: shell.attachSessions,
presetId: shell.presetId,
connectDepartment: shell.connectDepartment,
dispatchTask: shell.dispatchTask,
ingestAgentOutput: shell.ingestAgentOutput,
file: store.file,
sidecarDir: resolveSidecarDir(env),
get registered() {
return registered
},
warning: warnings.length === 0 ? null : warnings.join(';'),
warnings,
/** 卸载路由与后台服务(幂等);账本不删除,下次启动继续用。 */
dispose,
schemaVersion: SCHEMA_VERSION,
}
}
/**
* 路由钩子:只有宿主真有能力时才接管,否则让路由退回“只落账”的保守路径。
* 这样“没接通”永远不会被伪装成“已发送”。
*/
function routeHooks(shell, service) {
return {
connect: (input) => shell.connectDepartment(input),
ingest: (input) => shell.ingestAgentOutput(input),
// 会话层可能晚到,所以钩子恒挂:真挂上了就走派发,没挂上就退回「只落账」,
// 绝不把「没接通」伪装成「已发送」。
dispatch: (input) => {
if (shell.hasSessions === true) return shell.dispatchTask(input)
return service.dispatchTask({
projectId: input.projectId,
taskId: input.taskId,
idempotencyKey: input.idempotencyKey,
sourceRoleId: input.sourceRoleId,
targetRoleId: input.targetRoleId,
targetSessionId: input.targetSessionId,
bindingGeneration: input.bindingGeneration,
packet: input.packet,
})
},
}
}
export default createWorkbenchHost

View File

@ -1,132 +0,0 @@
// 侧车(sidecar)路径与目录:业务账、导出物都放在宿主允许的位置,不进项目目录。
// 默认 %DSH_HOME%/sansheng-liubu/;没有 DSH_HOME 时退回 ~/.dsh。
// env 可注入:测试与多实例部署用同一套函数,不读第二份全局配置。
//
// 原子写在 store 里还有一份(先写 .tmp 再 rename);这里只给 HTTP/导出这类
// “宿主侧杂项文件”用同一套规则,避免两处对“半截文件”的处理不一致。
import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
import { homedir } from 'node:os'
import { dirname, join, resolve, win32 } from 'node:path'
export const SIDECAR_DIR_NAME = 'sansheng-liubu'
// DSH_HOME 是 Windows 绝对路径(盘符或 UNC)时按 Windows 语义拼:在 POSIX 上
// 直接 resolve 会把 C:\… 当相对路径拼到当前目录后面。与 core/store 的
// defaultStorePath 同一条规则,两处必须一致。
const WINDOWS_ABSOLUTE = /^[A-Za-z]:[\\/]/
function isWindowsAbsolute(value) {
return typeof value === 'string' && (WINDOWS_ABSOLUTE.test(value) || value.startsWith('\\\\'))
}
function joinUnder(dir, name) {
return isWindowsAbsolute(dir) ? win32.join(dir, name) : join(dir, name)
}
/** 侧车目录:DSH_HOME 优先,其次 ~/.dsh;相对路径按当前目录解析,不做猜测。 */
export function resolveSidecarDir(env = process.env) {
const raw = env && typeof env.DSH_HOME === 'string' ? env.DSH_HOME.trim() : ''
if (isWindowsAbsolute(raw)) return win32.join(raw, SIDECAR_DIR_NAME)
const home = raw === '' ? join(homedir(), '.dsh') : raw
return resolve(home, SIDECAR_DIR_NAME)
}
/**
* 账本文件路径。DSH_SANSHENG_WORKBENCH_FILE 可整体改写(用于独立测试实例);
* 它必须指向具体文件名,不能只是目录,否则会在目录名上写半截 JSON。
*/
export function resolveStorePath(env = process.env) {
const override = env && typeof env.DSH_SANSHENG_WORKBENCH_FILE === 'string'
? env.DSH_SANSHENG_WORKBENCH_FILE.trim()
: ''
if (override !== '') return isWindowsAbsolute(override) ? win32.normalize(override) : resolve(override)
return joinUnder(resolveSidecarDir(env), 'workbench.json')
}
/** 派生路径:同一侧车目录下按用途分开,便于用户自己备份或清理而不碰账本。 */
export function resolveSidecarFile(name, env = process.env) {
if (typeof name !== 'string' || name.trim() === '') throw new Error('name 必须是非空字符串')
if (name.includes('/') || name.includes('\\')) throw new Error('name 只能是一级文件名,不能带目录分隔符')
return joinUnder(resolveSidecarDir(env), name)
}
/** 目录级入口:所有写入前都先建目录,缺目录不该表现为“保存失败”。 */
export function ensureSidecarDir(env = process.env) {
const dir = resolveSidecarDir(env)
mkdirSync(dir, { recursive: true })
return dir
}
/** 损坏文件的改名后缀:.corrupt-<时间戳>,保留现场且不覆盖下一次的结果。 */
export function corruptPathFor(file, stamp = Date.now()) {
return `${file}.corrupt-${stamp}`
}
/**
* 把可能损坏的文件挪到一边:返回新路径;文件不存在返回 null(不算错误)。
* 只改名不删除——损坏的账本里可能有用户唯一的业务记录,删掉就等于替用户做了决定。
*/
export function quarantineFile(file, stamp = Date.now()) {
if (!existsSync(file)) return null
let target = corruptPathFor(file, stamp)
let attempt = 1
while (existsSync(target)) {
target = `${corruptPathFor(file, stamp)}-${attempt}`
attempt += 1
}
renameSync(file, target)
return target
}
/**
* 原子写文本:同目录 .tmp → rename。
* Windows 上覆盖 rename 可能因杀软/索引占用失败,退化成“删旧再改名”;
* 最坏情况是目标短暂缺失,而不是留下半截内容。
*/
export function writeFileAtomic(file, text) {
const target = resolve(file)
mkdirSync(dirname(target), { recursive: true })
const tmp = `${target}.${process.pid}.${Date.now()}.tmp`
try {
writeFileSync(tmp, String(text), 'utf8')
try {
renameSync(tmp, target)
} catch {
rmSync(target, { force: true })
renameSync(tmp, target)
}
} finally {
rmSync(tmp, { force: true })
}
return target
}
/**
* 原子写 JSON:两空格缩进加尾换行,适合人读与 git diff。
* 不能序列化的值(BigInt、循环引用)直接抛错,不写一份“看起来写成了”的内容。
*/
export function writeJsonAtomic(file, value) {
const text = `${JSON.stringify(value, null, 2)}\n`
return writeFileAtomic(file, text)
}
/** 读 JSON;文件不存在或解析失败都返回 fallback,让调用方决定是否报错。 */
export function readJsonSafe(file, fallback = null) {
try {
if (!existsSync(file)) return fallback
return JSON.parse(readFileSync(file, 'utf8'))
} catch {
return fallback
}
}
/** 文件是否可读且非空;用于“成果文件已被删除”这类检查,不做内容解析。 */
export function fileLooksUsable(file) {
try {
const info = statSync(file)
return info.isFile() && info.size > 0
} catch {
return false
}
}

View File

@ -1,181 +0,0 @@
// Reconciler:把“部门会话里真实发生了什么”折算成 attempt 的终态。
//
// 方案 §7.4 的硬约束:宿主运行结束 ≠ 业务完成。所以这里只做“运行终态”的判定,
// 业务完成由 tasks.decide 用(结构化报告 + 运行终态 + 成果引用)三票共同决定。
//
// 数据来源只有两类可信信号:
// 1. 宿主 follow 事件里的 turn/结束信号(附加 latest.assistant-stream 之外的持久帧);
// 2. 主动查询 controller.list() 里该会话的 running 位。
// 绝不从聊天文本推断“做完了”。
import { classifyHostError } from './session-adapter.mjs'
export const RECONCILER_DEFAULT_INTERVAL_MS = 30000
export const RECONCILER_MIN_INTERVAL_MS = 5000
/**
* @param {object} options
* @param {object} options.store WorkbenchStore
* @param {object} options.service 工作台服务(reportRunTerminal / markDispatch / syncDecision…)
* @param {object} options.sessions createSessionAdapter 的产物
* @param {() => number} [options.clock]
* @param {(message: string) => void} [options.log]
*/
export function createReconciler(options = {}) {
const { store, service, sessions, clock = Date.now, log = () => {} } = options
if (store === undefined || typeof store.listOpenAttempts !== 'function') {
throw new Error('createReconciler 需要 WorkbenchStore')
}
if (service === undefined || typeof service.reportRunTerminal !== 'function') {
throw new Error('createReconciler 需要工作台服务')
}
let timer = null
let running = false
/**
* 单次对账。返回结构化结果供日志与测试断言,不吞异常也不抛出:
* 一个会话查不到不该阻断其它会话的对账。
*/
async function reconcileOnce() {
if (running) return { skipped: true, reason: 'busy', checked: 0, changed: [] }
running = true
const outcome = { skipped: false, checked: 0, changed: [], errors: [] }
try {
const open = store.listOpenAttempts()
for (const attempt of open) {
outcome.checked += 1
try {
const change = await reconcileAttempt(attempt)
if (change !== null) outcome.changed.push(change)
} catch (error) {
outcome.errors.push({ attemptId: attempt.id, message: messageOf(error) })
log(`[sansheng-liubo] 对账 ${attempt.id} 失败:${messageOf(error)}`)
}
}
} finally {
running = false
}
return outcome
}
/**
* 单个 attempt 的对账:
* - 宿主问不到(null)→ 什么也不改,等下一轮(宁可晚,不可猜);
* - 还在跑 → 只把 queued 推进到 running,不改结论;
* - 已停 → 依 state 决定:cancel_requested 转 cancelled,其余转 succeeded(再交 completion 三票判定)。
*/
async function reconcileAttempt(attempt) {
const projectId = attempt.projectId
let task = store.getTask(attempt.taskId)
if (task === undefined) return null
const runningFlag = await sessions.isRunning(attempt.sessionId)
if (runningFlag === null) return null
const now = new Date(clock()).toISOString()
if (runningFlag) {
if (attempt.state === 'queued') {
store.updateAttempt(attempt.id, { state: 'running', hostRunId: attempt.hostRunId ?? null, heartbeatAt: now })
// 任务要跟着进 running:只有任务处于 running 时,运行终态才能折算成
// completed / needs_attention / cancelled,否则终态会被状态机丢弃。
if (task.status === 'queued') {
try {
// service.startAttempt 会同时把任务推进到 running,并把最新任务读回来。
const started = service.startAttempt({
projectId,
taskId: task.id,
attemptId: attempt.id,
hostRunId: attempt.hostRunId ?? null,
})
task = started.task ?? task
} catch (error) {
log(`[sansheng-liubo] 任务 ${task.id} 推进 running 被拒:${messageOf(error)}`)
}
}
return { attemptId: attempt.id, from: 'queued', to: 'running' }
}
return null
}
// 宿主说会话不跑了:这是“运行终态 = 正常结束”,不是业务完成。
// 用户点过停止(cancel_requested)的尝试记为 cancelled,不当成成功运行。
// 用户点过停止:可能是适配器已经写过 cancel_requested,也可能只是刚发出停止请求
// (cancel() 是同步 accepted,不等于已停)。两种都按取消收口,否则"取消与成功竞争"里
// 被取消的这一次会被记成成功运行,任务显示已完成。
const cancelRequested = attempt.state === 'cancel_requested' || sessions.wasCancelRequested(attempt.sessionId)
if (attempt.state === 'running' || attempt.state === 'queued' || cancelRequested) {
const nextState = cancelRequested ? 'cancelled' : 'succeeded'
// running 不能直接到 cancelled:用户请求过停止的,先记 cancel_requested 再收口,
// 状态机与审计都保留"请求过停止"这一步。
if (nextState === 'cancelled' && attempt.state !== 'cancel_requested') {
store.updateAttempt(attempt.id, { state: 'cancel_requested', cancelRequestedAt: now })
}
store.updateAttempt(attempt.id, { state: nextState, endedAt: now })
applyTerminal({ attempt, task, terminal: nextState === 'cancelled' ? 'cancelled' : 'succeeded' })
return { attemptId: attempt.id, from: attempt.state, to: nextState }
}
return null
}
function applyTerminal({ attempt, task, terminal }) {
try {
// 任务侧:run_terminal 只是“一票”。没报告时只会变 needs_attention,不会变 completed。
service.reportRunTerminal({
projectId: attempt.projectId,
taskId: attempt.taskId,
attemptId: attempt.id,
runTerminal: terminal,
})
} catch (error) {
// 状态机拒绝重复/乱序终态是正常情况:记一行,不抛出。
log(`[sansheng-liubo] 任务 ${task.id} 记录运行终态被拒:${messageOf(error)}`)
}
}
/** 一个会话里出现了新的 assistant 完成回合:作为“可能已结束”的信号触发一次定向对账。 */
async function onSessionFrame({ sessionId }) {
const open = store.listOpenAttempts().filter((row) => row.sessionId === sessionId)
if (open.length === 0) return { checked: 0 }
for (const attempt of open) {
try {
await reconcileAttempt(attempt)
} catch (error) {
log(`[sansheng-liubo] 帧触发对账失败:${messageOf(error)}`)
}
}
return { checked: open.length }
}
function start({ intervalMs = RECONCILER_DEFAULT_INTERVAL_MS } = {}) {
if (timer !== null) return
const period = Math.max(RECONCILER_MIN_INTERVAL_MS, Number(intervalMs) || RECONCILER_DEFAULT_INTERVAL_MS)
timer = setInterval(() => {
reconcileOnce().catch((error) => log(`[sansheng-liubo] 周期对账异常:${messageOf(error)}`))
}, period)
// 宿主退出时不要让定时器把进程吊住。
if (typeof timer.unref === 'function') timer.unref()
}
function stop() {
if (timer !== null) {
clearInterval(timer)
timer = null
}
}
return Object.freeze({
reconcileOnce,
reconcileAttempt,
onSessionFrame,
start,
stop,
get scheduled() {
return timer !== null
},
})
}
function messageOf(error) {
return error instanceof Error ? error.message : String(error)
}
export { classifyHostError }

View File

@ -1,471 +0,0 @@
// 工作台 HTTP 路由:把 service 暴露给宿主 Web 服务。
//
// 设计取舍:
// - 全部 exact 路由,不做前缀匹配:/sansheng/workbench/xxx 未登记的一律 404,
// 不会因为前缀相同就把未知路径交给某个 handler 兜底。
// - 非 GET 只接受 POST(其余方法 405),未实现的路径 404,参数错误 400,体过大 413。
// - 统一包装 { ok:true, value } / { ok:false, error:{ code, message, details? } },
// Content-Type 带 charset、Cache-Control: no-store、Content-Length 手写。
// - 事件通道用长轮询而不是 SSE:宿主侧只是一个普通 HTTP handler,
// 浏览器刷新/断线重连后靠 since 补齐天然幂等,不需要管连接生命周期;
// 最长挂 25 秒,远低于常见代理/浏览器的空闲超时,也不占住宿主的事件循环。
// - 任何 ctx.webServer 的缺失都在 registerWorkbenchRoutes 里探测并降级:
// 返回一个 no-op 的 dispose,route 列表照常给出,便于诊断而不至于让插件加载失败。
import { ServiceError } from './service.mjs'
export const ROUTE_PREFIX = '/sansheng/workbench'
/** 请求体字节上限:契约里最大的是交接材料(摘录 + 引用),256 KB 足够且能挡住误传大文件。 */
export const MAX_BODY_BYTES = 256 * 1024
/** 长轮询最长挂起时间(毫秒)。浏览器重连后靠 since 补齐,所以不需要真正的无限等待。 */
export const DEFAULT_LONG_POLL_MS = 25_000
/** 轮询间隔:太密会白烧 CPU,太疏会让“有新事件立刻返回”的承诺打折。 */
const POLL_INTERVAL_MS = 1_000
/** 业务错误码 → HTTP 状态码。未列出的统一 400。 */
const STATUS_OF_CODE = Object.freeze({
INVALID_INPUT: 400,
INVALID_ROLE: 400,
INVALID_STATE: 400,
DISPATCH_INVALID: 400,
ATTEMPT_MISMATCH: 400,
REPORT_INVALID: 400,
NOT_FOUND: 404,
CROSS_PROJECT: 409,
CONFIG_CONFLICT: 409,
SESSION_CONFLICT: 409,
DUPLICATE_PROJECT: 409,
INTERNAL: 500,
})
function statusOf(error) {
if (error instanceof ServiceError) return STATUS_OF_CODE[error.code] ?? 400
if (error !== null && typeof error === 'object' && typeof error.code === 'string') {
return STATUS_OF_CODE[error.code] ?? 400
}
return 500
}
/** 响应写出:统一头 + 手写 Content-Length,HEAD 不写体。 */
function sendJson(res, status, payload, extraHeaders = undefined) {
const body = JSON.stringify(payload)
const headers = {
'Content-Type': 'application/json; charset=utf-8',
'Cache-Control': 'no-store',
'Content-Length': Buffer.byteLength(body),
...(extraHeaders ?? {}),
}
res.writeHead(status, headers)
res.end(body)
return body
}
function sendOk(res, value, extraHeaders) {
return sendJson(res, 200, { ok: true, value }, extraHeaders)
}
function sendError(res, error) {
const status = statusOf(error)
const code = typeof error?.code === 'string' ? error.code : 'INTERNAL'
const message = status === 500 && !(error instanceof ServiceError)
? '内部错误'
: (typeof error?.message === 'string' ? error.message : '请求失败')
const payload = { ok: false, error: { code, message } }
if (error?.details !== undefined) payload.error.details = error.details
return sendJson(res, status, payload)
}
/**
* 读请求体:按字节累计,超限立即拒绝(不再继续读,避免被巨大体拖住)。
* 空体视为 {},让无参 POST 也能走同一个入口。
*/
async function readJsonBody(req, limit = MAX_BODY_BYTES) {
const chunks = []
let total = 0
for await (const chunk of req) {
const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
total += buffer.length
if (total > limit) {
const error = new ServiceError('INVALID_INPUT', `请求体超过 ${limit} 字节上限`, { limit })
error.httpStatus = 413
throw error
}
chunks.push(buffer)
}
const text = Buffer.concat(chunks).toString('utf8').trim()
if (text === '') return {}
try {
const parsed = JSON.parse(text)
if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
throw new Error('not an object')
}
return parsed
} catch {
const error = new ServiceError('INVALID_INPUT', '请求体必须是 JSON 对象')
error.httpStatus = 400
throw error
}
}
async function readBody(req, limit) {
try {
return await readJsonBody(req, limit)
} catch (error) {
// 体超限与 JSON 非法是 HTTP 层语义,借 httpStatus 覆盖默认映射。
if (typeof error.httpStatus === 'number') {
const wrapped = new ServiceError(error.code, error.message, error.details)
wrapped.httpStatus = error.httpStatus
throw wrapped
}
throw error
}
}
/** 从 URL 里取查询参数(不依赖宿主框架,纯 node URL)。 */
function queryOf(url) {
const index = typeof url === 'string' ? url.indexOf('?') : -1
if (index < 0) return new URLSearchParams('')
const rest = url.slice(index + 1)
const hash = rest.indexOf('#')
return new URLSearchParams(hash < 0 ? rest : rest.slice(0, hash))
}
function pathOf(url) {
if (typeof url !== 'string') return ''
const cut = url.search(/[?#]/)
return cut < 0 ? url : url.slice(0, cut)
}
/**
* 长轮询:最多挂 maxWaitMs,期间每 pollIntervalMs 检查一次是否有新事件;
* 一旦有就立刻返回(不等到窗口结束),没有就等到窗口结束返回空列表 + 当前 seq。
* 客户端断开(req 触发 close)时立即结束,不留悬挂计时器。
*/
async function waitForEvents(service, projectId, since, options) {
const maxWaitMs = options.longPollMs ?? DEFAULT_LONG_POLL_MS
const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS
const immediate = service.listEvents(projectId, since, options.eventLimit === undefined ? {} : { limit: options.eventLimit })
if (immediate.events.length > 0 || immediate.reset) return immediate
const deadline = Date.now() + maxWaitMs
while (Date.now() < deadline) {
const remain = deadline - Date.now()
await sleep(Math.max(1, Math.min(pollIntervalMs, remain)))
const fresh = service.listEvents(projectId, since, options.eventLimit === undefined ? {} : { limit: options.eventLimit })
if (fresh.events.length > 0 || fresh.reset) return fresh
}
return service.listEvents(projectId, since, options.eventLimit === undefined ? {} : { limit: options.eventLimit })
}
function sleep(ms) {
return new Promise((resolve) => {
const timer = setTimeout(resolve, ms)
// 计时器不应阻止进程退出(测试里尤其明显)。
if (typeof timer.unref === 'function') timer.unref()
})
}
/** 统一 handler 包装:方法校验、异常兜底、响应头注入。 */
function wrap(handler, { methods = ['POST'], allowBody = true, bodyLimit = MAX_BODY_BYTES } = {}) {
return async (req, res) => {
try {
const method = String(req.method ?? 'GET').toUpperCase()
if (!methods.includes(method)) {
res.setHeader('Allow', methods.join(', '))
sendJson(res, 405, { ok: false, error: { code: 'METHOD_NOT_ALLOWED', message: `仅支持 ${methods.join(', ')}` } })
return
}
const body = allowBody && method === 'POST' ? await readBody(req, bodyLimit) : {}
const url = req.url ?? ''
const value = await handler({ req, res, body, method, query: queryOf(url), path: pathOf(url) })
// handler 自己已经写过响应(例如长轮询中途断开)时不再写第二遍。
if (res.writableEnded === true) return
const headers = value !== null && typeof value === 'object' && value.__headers !== undefined ? value.__headers : undefined
const payload = headers === undefined ? value : value.payload
sendOk(res, payload, headers)
} catch (error) {
if (res.writableEnded === true) return
const status = typeof error?.httpStatus === 'number' ? error.httpStatus : statusOf(error)
const code = typeof error?.code === 'string' ? error.code : 'INTERNAL'
const payload = { ok: false, error: { code, message: error?.message ?? '请求失败' } }
if (error?.details !== undefined) payload.error.details = error.details
sendJson(res, status, payload)
}
}
}
/**
* 路由表:path → handler 定义。集中声明,便于诊断页一次性列出全部端点。
* 每个 handler 都从 body/query 取参数并原样交给 service,不在路由层做业务判断。
*/
export function buildRouteTable(service, options = {}) {
const select = options.projectIdFrom === undefined ? (body) => body.projectId : options.projectIdFrom
return Object.freeze({
[`${ROUTE_PREFIX}/bootstrap`]: {
method: 'GET',
handler: async ({ query }) => service.bootstrap(query.get('projectId') ?? undefined),
},
[`${ROUTE_PREFIX}/project`]: {
method: 'POST',
handler: async ({ body }) => service.registerProject({
hostWorkspaceId: body.hostWorkspaceId,
displayNameCache: body.displayNameCache,
canonicalRoot: body.canonicalRoot,
}),
},
[`${ROUTE_PREFIX}/bind`]: {
method: 'POST',
handler: async ({ body }) => service.bindDepartmentSession({
projectId: select(body),
roleId: body.roleId,
sessionId: body.sessionId,
allowReplace: body.allowReplace,
creationRequestId: body.creationRequestId,
}),
},
[`${ROUTE_PREFIX}/config`]: {
method: 'POST',
handler: async ({ body }) => service.saveDepartmentConfig({
projectId: select(body),
roleId: body.roleId,
provider: body.provider,
model: body.model,
reasoningEffort: body.reasoningEffort,
expectedRevision: body.expectedRevision,
}),
},
[`${ROUTE_PREFIX}/task`]: {
method: 'POST',
handler: async ({ body }) => service.createTask({
projectId: select(body),
title: body.title,
objective: body.objective,
acceptance: body.acceptance,
constraints: body.constraints,
scope: body.scope,
ownerRoleId: body.ownerRoleId,
sourceRoleId: body.sourceRoleId,
originMessageRef: body.originMessageRef,
returnTarget: body.returnTarget,
status: body.status,
}),
},
[`${ROUTE_PREFIX}/task/cancel`]: {
method: 'POST',
handler: async ({ body }) => service.cancelTask({
projectId: select(body),
taskId: body.taskId,
reason: body.reason,
}),
},
[`${ROUTE_PREFIX}/connect`]: {
method: 'POST',
handler: async ({ body }) => {
if (typeof options.connect !== 'function') {
throw new ServiceError('INVALID_STATE', '宿主未提供会话能力,暂时无法接通部门')
}
return options.connect({
projectId: select(body),
roleId: body.roleId,
sessionId: body.sessionId,
agentPreset: body.agentPreset,
})
},
},
[`${ROUTE_PREFIX}/dispatch`]: {
method: 'POST',
handler: async ({ body }) => {
const ledger = {
projectId: select(body),
taskId: body.taskId,
idempotencyKey: body.idempotencyKey,
sourceRoleId: body.sourceRoleId,
targetRoleId: body.targetRoleId,
targetSessionId: body.targetSessionId,
bindingGeneration: body.bindingGeneration,
packet: body.packet,
}
// 有 Host 会话能力时走 DispatchService:它会真的把任务单送进部门会话,
// 并把 prepared → sending → accepted/rejected/unknown 走完。
// 没有会话层时只落账(prepared),UI 据此显示“尚未接通”,绝不假装已发送。
if (typeof options.dispatch === 'function') {
return options.dispatch({
...ledger,
sourceSessionId: body.sourceSessionId,
mode: body.mode,
roleName: body.roleName,
})
}
return service.dispatchTask(ledger)
},
},
[`${ROUTE_PREFIX}/ingest`]: {
method: 'POST',
handler: async ({ body }) => {
if (typeof options.ingest !== 'function') {
throw new ServiceError('INVALID_STATE', '宿主未提供契约解析能力')
}
return options.ingest({
projectId: select(body),
roleId: body.roleId,
text: body.text,
})
},
},
[`${ROUTE_PREFIX}/result`]: {
method: 'POST',
handler: async ({ body }) => service.reportTaskResult({
projectId: select(body),
taskId: body.taskId,
attemptId: body.attemptId,
report: body.report,
runTerminal: body.runTerminal,
artifactRefs: body.artifactRefs,
checks: body.checks,
remainingItems: body.remainingItems,
blockedReason: body.blockedReason,
sourceMessageRef: body.sourceMessageRef,
reportVersion: body.reportVersion,
}),
},
[`${ROUTE_PREFIX}/artifact/revision`]: {
method: 'POST',
handler: async ({ body }) => service.requestArtifactRevision({
projectId: select(body),
artifactId: body.artifactId,
instruction: body.instruction,
ownerRoleId: body.ownerRoleId,
sourceRoleId: body.sourceRoleId,
title: body.title,
acceptance: body.acceptance,
constraints: body.constraints,
status: body.status,
originMessageRef: body.originMessageRef,
returnTarget: body.returnTarget,
}),
},
[`${ROUTE_PREFIX}/artifact`]: {
method: 'POST',
handler: async ({ body }) => service.registerArtifact({
projectId: select(body),
taskId: body.taskId,
ownerRoleId: body.ownerRoleId,
fileRef: body.fileRef,
displayName: body.displayName,
mediaType: body.mediaType,
versionOrHash: body.versionOrHash,
verification: body.verification,
sourceResultId: body.sourceResultId,
revisesArtifactId: body.revisesArtifactId,
}),
},
[`${ROUTE_PREFIX}/memory/get`]: {
method: 'POST',
handler: async ({ body }) => service.getMemory({
scope: body.scope,
projectId: select(body),
roleId: body.roleId,
}),
},
[`${ROUTE_PREFIX}/memory/put`]: {
method: 'POST',
handler: async ({ body }) => service.putMemory({
scope: body.scope,
projectId: select(body),
roleId: body.roleId,
text: body.text,
}),
},
[`${ROUTE_PREFIX}/memory/append`]: {
method: 'POST',
handler: async ({ body }) => service.appendMemory({
scope: body.scope,
projectId: select(body),
roleId: body.roleId,
text: body.text,
}),
},
[`${ROUTE_PREFIX}/events`]: {
method: 'GET',
handler: async ({ query, req, res }) => {
const projectId = query.get('projectId') ?? undefined
const since = Number(query.get('since') ?? 0)
if (query.get('since') !== null && !Number.isFinite(since)) {
throw new ServiceError('INVALID_INPUT', 'since 必须是数字', { field: 'since' })
}
const immediateOnly = query.get('wait') === '0'
if (immediateOnly || (options.longPollMs ?? DEFAULT_LONG_POLL_MS) <= 0) {
return service.listEvents(projectId, since, { limit: options.eventLimit })
}
return waitForEvents(service, projectId, since, {
...options,
// 客户端断开时不再等满窗口:把当前结果写回去(或让外层发现已结束)。
onAbort: () => {
if (res.writableEnded !== true && res.destroyed !== true) {
sendOk(res, service.listEvents(projectId, since, { limit: options.eventLimit }), { Connection: 'close' })
}
},
})
},
},
})
}
/**
* 注册路由。宿主没有 webServer(或没有 register)时返回 no-op dispose,
* 并在返回值上标 registered:false,调用方可据此提示“宿主不支持工作台接口”。
*
* @returns {() => void} dispose:卸载全部已注册路由;重复调用无副作用。
*/
export function registerWorkbenchRoutes(ctx, service, options = {}) {
const disposes = []
const server = ctx?.webServer
if (server === undefined || server === null || typeof server.register !== 'function') {
const noop = () => {}
noop.registered = false
noop.reason = '宿主未提供 webServer.register'
return noop
}
const table = buildRouteTable(service, options)
const bodyLimit = options.maxBodyBytes ?? MAX_BODY_BYTES
try {
for (const [path, def] of Object.entries(table)) {
const methods = def.method === 'GET' ? ['GET'] : ['POST']
const handler = wrap(def.handler, { methods, allowBody: def.method === 'POST', bodyLimit })
const dispose = server.register({ kind: 'exact', path, handler })
if (typeof dispose === 'function') disposes.push(dispose)
}
} catch (error) {
// 部分注册失败:先把已注册的回滚,避免留下半套路由(前端会看到一多半 404)。
for (const dispose of disposes.reverse()) {
try {
dispose()
} catch {
// 卸载失败不影响主流程:宿主要么已卸载,要么进程即将重启。
}
}
throw error
}
let disposed = false
const dispose = () => {
if (disposed) return
disposed = true
for (const fn of disposes.reverse()) {
try {
fn()
} catch {
// 同上:dispose 必须幂等且不抛。
}
}
}
dispose.registered = true
dispose.paths = Object.keys(table)
return dispose
}
/** 供诊断页使用:列出全部端点与其方法。 */
export function listWorkbenchRoutes() {
return Object.entries(buildRouteTable({ bootstrap: () => null }, {})).map(([path, def]) => ({ path, method: def.method }))
}

File diff suppressed because it is too large Load Diff

View File

@ -1,350 +0,0 @@
// 会话适配层:把 Host 的 SessionController 收敛成“派发只需要几个动作”。
//
// 依据 docs/v0.1-宿主能力记录.md(P0 实测的类型层事实):
// - create({workspaceId}) 幂等:同一 workspace 已绑定时返回同一个会话,不会造出第二个;
// - create 里没有 creationRequestId,也没有 cwd+workspaceId 同时给的用法(会 bad-request);
// - prompt 的 requestId 才是真幂等键(跨重启有效),所以 attemptId 直接当 requestId 用;
// - cancel() 只是“请求取消”,accepted:true ≠ 已取消,终态必须靠 follow/对账得到。
//
// 这一层只做三件事:拿到会话、送一条消息、听它的事件。其余判定留在核心层。
export class SessionAdapterError extends Error {
constructor(code, message, details = undefined) {
super(message)
this.name = 'SessionAdapterError'
this.code = code
if (details !== undefined) this.details = details
}
}
/** 把宿主抛出的杂异常收敛成“可重试 / 必失败”两类,reconciler 依赖这个区分。 */
export function classifyHostError(error) {
const code = error && typeof error.code === 'string' ? error.code : ''
const message = error instanceof Error ? error.message : String(error)
if (code === 'session/conflict' || /session\/conflict/.test(message)) return 'conflict'
if (code === 'session/model-unavailable' || /model-unavailable/.test(message)) return 'model_unavailable'
if (code === 'session/agent-busy' || /agent-busy/.test(message)) return 'busy'
if (code === 'session/writer-held' || /writer-held/.test(message)) return 'transient'
if (/timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|socket hang up/i.test(message)) return 'transient'
return 'unknown'
}
/**
* @param {object} options
* @param {object} options.sessionController Host 的 ctx.sessionController(或同形状替身)。
* @param {(event: object) => void} [options.onEvent] 订阅回调:任意会话事件(对账与 UI 都用它)。
* @param {(message: string) => void} [options.log] 诊断日志出口;默认吞掉。
*/
export function createSessionAdapter(options = {}) {
const { sessionController, onEvent, log = () => {} } = options
if (sessionController === undefined || sessionController === null || typeof sessionController.prompt !== 'function') {
throw new SessionAdapterError('NO_SESSION_CONTROLLER', '会话适配层需要 Host 的 sessionController')
}
const controller = sessionController
/** 正在跑 follow 的会话:sessionId → { controller: AbortController, done: Promise<void> } */
const followers = new Map()
// 被用户明确要求停止过的会话(只影响对账收口,不影响派发)。
const cancelRequested = new Set()
let disposed = false
function ensureAlive() {
if (disposed) throw new SessionAdapterError('DISPOSED', '会话适配层已释放')
}
/**
* 拿到(或复用)一个会话。上层传入的 sessionId 是 store 里登记的绑定;
* 为空时用 workspaceId 建一个新会话,并把 host 返回的 id 交回给上层登记。
*/
async function ensureSession({ workspaceId, sessionId, agentPreset } = {}) {
ensureAlive()
if (typeof sessionId === 'string' && sessionId.trim() !== '') {
// 已有绑定:不重建,只确认宿主能看到它(看不到就交给上层判定绑定失效)。
const known = await inspectSession(sessionId)
return { sessionId, created: false, known }
}
if (typeof workspaceId !== 'string' || workspaceId.trim() === '') {
throw new SessionAdapterError('NO_TARGET', '既没有绑定会话也没有 workspaceId,无法接通部门')
}
const request = { workspaceId }
if (typeof agentPreset === 'string' && agentPreset.trim() !== '') request.agentPreset = agentPreset
try {
const value = await controller.create(request)
if (value === null || typeof value !== 'object' || typeof value.sessionId !== 'string') {
throw new SessionAdapterError('BAD_CREATE_RESULT', '宿主 create 未返回 sessionId')
}
return { sessionId: value.sessionId, created: true, agentPreset: value.agentPreset ?? null }
} catch (error) {
throw new SessionAdapterError(classifyHostError(error), `接通部门会话失败:${messageOf(error)}`, { cause: error })
}
}
async function inspectSession(sessionId) {
if (typeof controller.inspect !== 'function') return null
try {
return await controller.inspect(sessionId)
} catch {
return null
}
}
/**
* 送一条消息。requestId 由调用方(attemptId)给,重试同一条 attempt 不会重复投递;
* 超时/未知一律抛 transient,由 reconciler 决定是查证还是标 unknown。
*/
async function sendPrompt({ sessionId, requestId, text, mode = 'queue', signal, clientTimeZone } = {}) {
ensureAlive()
if (typeof sessionId !== 'string' || sessionId.trim() === '') {
throw new SessionAdapterError('NO_SESSION', '送消息前必须有 sessionId')
}
if (typeof text !== 'string' || text.trim() === '') {
throw new SessionAdapterError('EMPTY_PROMPT', '送消息内容为空')
}
if (typeof requestId !== 'string' || requestId.trim() === '') {
throw new SessionAdapterError('NO_REQUEST_ID', '送消息必须带 requestId(幂等键)')
}
const request = {
requestId,
sessionId,
mode: mode === 'steer' ? 'steer' : 'queue',
content: [{ type: 'text', text }],
}
if (typeof clientTimeZone === 'string' && clientTimeZone !== '') request.clientTimeZone = clientTimeZone
try {
const value = await controller.prompt(request, signal)
return { accepted: value?.accepted === true }
} catch (error) {
throw new SessionAdapterError(classifyHostError(error), `投递失败:${messageOf(error)}`, { cause: error })
}
}
/**
* 取消只是“请求取消”;调用方必须等 follow 上的终态或对账结果,不能直接当已停。
* 这里额外记下"这个会话被用户要求停过",对账时用它把停跑结果收口成 cancelled,
* 避免"取消与成功竞争"里被取消的那一次被记成成功运行。
*/
function requestCancel(sessionId) {
ensureAlive()
try {
const value = controller.cancel({ sessionId })
if (value?.accepted === true) cancelRequested.add(sessionId)
return { accepted: value?.accepted === true }
} catch (error) {
throw new SessionAdapterError(classifyHostError(error), `取消失败:${messageOf(error)}`, { cause: error })
}
}
/** 该会话是否被明确要求过停止(跨本次进程有效;宿主重启后由 attempt 状态兜底)。 */
function wasCancelRequested(sessionId) {
return cancelRequested.has(sessionId)
}
/** 新一轮派发成功投递后可清掉停止标记:同一会话的下一次运行不该继承上一次的取消意图。 */
function clearCancelRequest(sessionId) {
return cancelRequested.delete(sessionId)
}
/** 每次派发都显式覆写模型:宿主 selectModel 会顺手改全局默认,所以用快照固定本轮。 */
async function applyModel({ sessionId, provider, model, reasoningEffort } = {}) {
ensureAlive()
if (typeof controller.selectModel !== 'function') return { selected: false, reason: 'controller 无 selectModel' }
if (typeof provider !== 'string' || provider === '' || typeof model !== 'string' || model === '') {
return { selected: false, reason: '未配置模型' }
}
const request = { sessionId, provider, model }
if (typeof reasoningEffort === 'string' && reasoningEffort !== '') request.reasoningEffort = reasoningEffort
try {
const value = await controller.selectModel(request)
return { selected: true, selection: value?.selected ?? null }
} catch (error) {
// 模型不可用是“本次派发不能开工”,不是“任务失败”,交由上层标 unavailable 并保留任务。
throw new SessionAdapterError(classifyHostError(error), `模型切换失败:${messageOf(error)}`, { cause: error })
}
}
async function getSessionSummary(sessionId) {
if (typeof controller.list !== 'function') return null
try {
const value = await controller.list({}, new AbortController().signal)
const items = Array.isArray(value?.items) ? value.items : []
return items.find((row) => row.sessionId === sessionId) ?? null
} catch {
return null
}
}
/** 宿主是否还在跑这个会话:null 表示问不到(不当成“已结束”)。 */
async function isRunning(sessionId) {
const summary = await getSessionSummary(sessionId)
if (summary === null) return null
return summary.running === true
}
/**
* 订阅会话事件。alreadyAttached 时不重复起流:同一个会话只留一条 follow,
* 避免双窗口/重启后重建出两条流导致事件重复。
*
* @param {string|object} target 普通会话 id,或宿主 `SessionAddress` 对象
* (普通会话 `{kind:'session', sessionId}`;直接子代理会话
* `{kind:'subagent', parentSessionId, childSessionId, mode}`)。
* @param {object} [options]
* @param {(frame: object) => void} [options.onFrame]
* @param {(failure: {sessionId: string, code: string, message: string}) => void} [options.onError]
*/
function follow(target, { onFrame, onError } = {}) {
ensureAlive()
const address = normalizeAddress(target)
const sessionId = address.kind === 'subagent' ? address.childSessionId : address.sessionId
if (followers.has(sessionId)) return followers.get(sessionId).handle
if (typeof controller.follow !== 'function') throw new SessionAdapterError('NO_FOLLOW', 'controller 无 follow')
const abort = new AbortController()
const handle = { sessionId, address, stop: () => abort.abort() }
const done = (async () => {
try {
const stream = controller.follow({ address }, abort.signal)
for await (const frame of stream) {
if (disposed || abort.signal.aborted) break
if (frame?.type === 'assistant-stream') continue
try {
if (typeof onFrame === 'function') onFrame(frame)
if (typeof onEvent === 'function') onEvent({ sessionId, frame })
} catch (error) {
log(`[sansheng-liubu] 处理会话帧失败:${messageOf(error)}`)
}
}
if (!abort.signal.aborted && !disposed) log(`[sansheng-liubu] 会话订阅正常结束:${sessionId}`)
} catch (error) {
if (abort.signal.aborted) {
log(`[sansheng-liubu] 会话订阅已取消:${sessionId}`)
} else {
const failure = {
sessionId,
code: error?.code ?? (error?.name === 'AbortError' ? 'ABORTED' : 'FOLLOW_FAILED'),
message: messageOf(error),
}
log(`[sansheng-liubu] 会话流中断(${failure.code}):${failure.message}`)
try {
if (typeof onError === 'function') onError(failure)
} catch (handlerError) {
log(`[sansheng-liubu] 订阅失败回调异常:${messageOf(handlerError)}`)
}
}
} finally {
followers.delete(sessionId)
}
})()
followers.set(sessionId, { handle, done })
return handle
}
function unfollow(sessionId) {
const entry = followers.get(sessionId)
if (entry === undefined) return false
entry.handle.stop()
return true
}
function dispose() {
disposed = true
for (const entry of followers.values()) entry.handle.stop()
followers.clear()
}
return Object.freeze({
ensureSession,
inspectSession,
sendPrompt,
requestCancel,
wasCancelRequested,
clearCancelRequest,
applyModel,
getSessionSummary,
isRunning,
follow,
unfollow,
dispose,
get following() {
return [...followers.keys()]
},
})
}
function normalizeAddress(target) {
if (typeof target === 'string' && target.trim() !== '') return { kind: 'session', sessionId: target }
if (target !== null && typeof target === 'object') {
if (target.kind === 'subagent'
&& typeof target.parentSessionId === 'string'
&& typeof target.childSessionId === 'string') {
return {
kind: 'subagent',
parentSessionId: target.parentSessionId,
childSessionId: target.childSessionId,
mode: ['one-shot', 'continuable', 'unknown'].includes(target.mode) ? target.mode : 'unknown',
}
}
if (typeof target.sessionId === 'string' && target.sessionId !== '') {
return { kind: 'session', sessionId: target.sessionId }
}
}
throw new SessionAdapterError('BAD_ADDRESS', '会话订阅需要普通 sessionId 或宿主 SessionAddress')
}
function messageOf(error) {
return error instanceof Error ? error.message : String(error)
}
/**
* 把一条材料引用写成人能读的一行,并保留可追溯的 ID。
* - 字符串:原样(历史数据里的自由文本引用)
* - {artifactId, revision}:成果引用,带版本号
* - {attachmentId, name, mime, size}:附件引用(A09 附件级交接)
*/
export function describeMaterialRef(ref) {
if (typeof ref === 'string') return ref
if (ref === null || typeof ref !== 'object') return String(ref)
if (typeof ref.artifactId === 'string' && ref.artifactId !== '') {
const version = Number.isInteger(ref.revision) && ref.revision > 0 ? `(第 ${ref.revision} 版)` : ''
const title = typeof ref.title === 'string' && ref.title !== '' ? ` ${ref.title}` : ''
return `成果${title} ${ref.artifactId}${version}`
}
if (typeof ref.attachmentId === 'string' && ref.attachmentId !== '') {
const bits = []
if (typeof ref.name === 'string' && ref.name !== '') bits.push(ref.name)
if (typeof ref.mime === 'string' && ref.mime !== '') bits.push(ref.mime)
if (Number.isInteger(ref.size) && ref.size > 0) bits.push(`${ref.size} 字节`)
const suffix = bits.length === 0 ? '' : `(${bits.join(' · ')})`
return `附件 ${ref.attachmentId}${suffix}`
}
return JSON.stringify(ref)
}
/**
* 把一次派发写成部门能直接执行的提示词。只放事实(任务、验收、材料、回传方式),
* 不写“请确认已完成”这类引导语——完成判定只认结构化报告。
*/
export function buildDispatchText({ task, packet, contractGuide, roleName } = {}) {
const lines = []
const name = typeof roleName === 'string' && roleName !== '' ? roleName : '你'
lines.push(`【任务单 ${task?.id ?? ''}】${task?.title ?? ''}`)
if (typeof task?.objective === 'string' && task.objective !== '') lines.push(`目标:${task.objective}`)
const acceptance = Array.isArray(packet?.acceptance) && packet.acceptance.length > 0 ? packet.acceptance : task?.acceptance
if (Array.isArray(acceptance) && acceptance.length > 0) {
lines.push('验收标准:')
for (const item of acceptance) lines.push(`- ${String(item)}`)
}
const constraints = Array.isArray(packet?.constraints) ? packet.constraints : task?.constraints
if (Array.isArray(constraints) && constraints.length > 0) {
lines.push('约束:')
for (const item of constraints) lines.push(`- ${String(item)}`)
}
const refs = Array.isArray(packet?.materialRefs) ? packet.materialRefs : []
if (refs.length > 0) {
lines.push('相关材料:')
for (const ref of refs) lines.push(`- ${describeMaterialRef(ref)}`)
}
lines.push('')
lines.push(`完成后请用结构化回传(不要只在正文里说“已完成”,那样不算完成):`)
lines.push(typeof contractGuide === 'string' && contractGuide !== '' ? contractGuide : '')
lines.push('')
lines.push(`(你是本项目的 ${name};任务与成果归属由程序按项目登记,不要自行改派给其他部门。)`)
return lines.join('\n')
}

View File

@ -1,328 +0,0 @@
// 工作台 Host 外壳:把 store + service + 适配层 + 两个后台服务组装成一个可挂载组件。
//
// 挂载方式(index.js 里):
// const host = createWorkbenchHost(ctx, { store, presetId })
// ctx.effect(() => () => host.dispose(), 'sansheng-liubo: workbench')
//
// 能力探测优先:宿主没有 sessionController 时,工作台仍然能读写账本(投影可用),
// 但任何“派发/接通”都返回 NO_SESSION_CONTROLLER,UI 显示“尚未接通”,绝不假装成功。
import { join } from 'node:path'
import { WorkbenchStore, defaultStorePath } from '../core/store.mjs'
import { createMemoryStore } from '../core/memory.mjs'
import { resolveSidecarDir } from './paths.mjs'
import { createWorkbenchService } from './service.mjs'
import { createSessionAdapter } from './session-adapter.mjs'
import { createDispatchService } from './dispatch-service.mjs'
import { createReconciler } from './reconciler.mjs'
import { CONTRACT_ACTIONS, CONTRACT_ACTION_PREFIX, parseContractLines, describeContract } from './contract.mjs'
export const WORKBENCH_HOST_VERSION = 1
/**
* @param {object} ctx Host 插件上下文(cordis Context)
* @param {object} [options]
* @param {object} [options.store] 已有 store(测试注入);缺省按环境建一个。
* @param {object} [options.service] 已有 service;缺省按 store 新建。给了 service 就必须同时给 store,
* 否则两边的账不是同一本。
* @param {string} [options.presetId] 部门会话显式使用的 agentPreset;缺省不指定,走宿主默认创建流程。
* @param {boolean} [options.startReconciler] 是否启动周期对账,默认 true。
*/
export function createWorkbenchHost(ctx, options = {}) {
const log = (message) => {
try {
ctx?.logger?.info?.(message)
} catch {
/* 日志失败不能影响业务 */
}
}
const store = options.store ?? createStore(options)
// 记忆层:默认落在侧车目录的 memory/ 下(惰性读写,装配本身不碰磁盘);
// 测试可注入 options.memory,用 null 明确关掉。
const memory = options.memory === null
? null
: (options.memory ?? createMemoryStore({ dir: join(resolveSidecarDir(options.env ?? process.env), 'memory'), clock: options.clock }))
const service = options.service ?? createWorkbenchService({ store, clock: options.clock, fileExists: options.fileExists, memory })
// 会话层是可选能力:宿主没有 sessionController(或版本不提供)时整体降级。
// 注意 apply 时宿主可能还没把 sessionController 装好,所以这里只是「尝试挂载」,
// 真正的挂载动作集中在 mountSessions,宿主晚到时由 attachSessions 再补一次。
let sessions = null
let dispatchService = null
let reconciler = null
let hasSessions = false
let started = false
function mountSessions(controller) {
const usable = controller !== null && typeof controller?.prompt === 'function'
if (!usable) return false
if (sessions !== null) return true
try {
sessions = createSessionAdapter({ sessionController: controller, log })
} catch (error) {
log(`[sansheng-liubo] 会话层不可用:${error?.message ?? error}`)
sessions = null
return false
}
dispatchService = createDispatchService({ store, service, sessions, log, applyModelToSessions: options.applyModelToSessions === true })
reconciler = createReconciler({ store, service, sessions, log })
hasSessions = true
if (started && options.startReconciler !== false) reconciler.start()
followBoundSessions()
return true
}
/**
* 订阅一个部门会话。subscribe 失败与正常结束分开处理:
* - 正常结束/主动取消只记日志;
* - 订阅失败把该绑定标成 unavailable,界面会显示“绑定失效,需重新接通”,
* 而不是让用户对着一个永远不更新的会话猜。
*/
function followSession(sessionId) {
if (sessions === null || typeof sessionId !== 'string' || sessionId === '') return
try {
sessions.follow(sessionId, {
onFrame: (frame) => {
if (reconciler !== null) {
void Promise.resolve(reconciler.onSessionFrame({ sessionId })).catch((error) => {
log(`[sansheng-liubo] 帧事件对账失败:${error?.message ?? error}`)
})
}
void frame
},
onError: (failure) => {
log(`[sansheng-liubo] 会话 ${failure.sessionId} 订阅失败(${failure.code}):${failure.message}`)
markSessionUnavailable(failure.sessionId, failure.message)
},
})
} catch (error) {
const code = error?.code ?? 'UNKNOWN'
log(`[sansheng-liubo] 无法订阅会话 ${sessionId}(${code}):${error?.message ?? error}`)
// 宿主没有 follow 能力是“功能缺席”,不是绑定失效:不要因此标坏部门。
if (code !== 'NO_FOLLOW') markSessionUnavailable(sessionId, error?.message ?? String(error))
}
}
/** 找到持有该会话的项目/席位,并把绑定状态标成 unavailable。 */
function markSessionUnavailable(sessionId, reason) {
if (typeof sessionId !== 'string' || sessionId === '') return
for (const project of store.listProjects()) {
let seats = []
try {
seats = service.listSeats(project.id)
} catch {
continue
}
for (const seat of seats) {
const binding = store.getBinding(project.id, seat.roleId)
if (binding?.currentSessionId !== sessionId) continue
try {
service.setDepartmentStatus({ projectId: project.id, roleId: seat.roleId, status: 'unavailable' })
} catch (error) {
log(`[sansheng-liubo] 标记 ${seat.roleId} 订阅失败状态被拒:${error?.message ?? error}`)
}
log(`[sansheng-liubo] 部门 ${seat.roleId} 的会话订阅失败:${reason ?? 'unknown'}`)
return
}
}
}
/** 会话层晚挂或重挂后,把账本里已有的部门绑定重新接上事件流。 */
function followBoundSessions() {
if (sessions === null) return 0
let count = 0
for (const project of store.listProjects()) {
for (const seat of service.listSeats(project.id)) {
const binding = store.getBinding(project.id, seat.roleId)
if (binding?.currentSessionId) {
followSession(binding.currentSessionId)
count += 1
}
}
}
if (count > 0) log(`[sansheng-liubo] 已恢复 ${count} 个部门会话订阅`)
return count
}
/** 宿主稍后才提供 sessionController 时补挂(不重启也能用)。返回是否挂上。 */
function attachSessions(controller) {
const mounted = mountSessions(controller ?? null)
if (!mounted) log('[sansheng-liubo] 会话控制器仍不可用,派发继续保持“只落账”')
return mounted
}
mountSessions(ctx?.sessionController ?? ctx?.remote?.session ?? null)
const presetId = typeof options.presetId === 'string' && options.presetId !== '' ? options.presetId : null
/**
* 显式预设先用宿主公开的 preset 名册校验;名册服务缺席时不假装能验,
* 交给 `sessionController.create` 返回它自己的 agent-preset/not-found。
*/
async function assertAgentPreset(agentPreset) {
if (typeof agentPreset !== 'string' || agentPreset.trim() === '') return
let presets = null
try {
presets = typeof ctx?.get === 'function' ? ctx.get('agentPresets') : ctx?.agentPresets
} catch {
presets = null
}
if (presets === null || presets === undefined || typeof presets.list !== 'function') return
let roster = null
try {
roster = await presets.list()
} catch (error) {
log(`[sansheng-liubo] 无法读取宿主预设名册:${error?.message ?? error}`)
return
}
if (!Array.isArray(roster)) return
if (!roster.some((row) => row?.id === agentPreset)) {
const error = new Error(`指定的预设“${agentPreset}”不存在或未启用`)
error.code = 'INVALID_INPUT'
throw error
}
}
/**
* 接通某个部门的会话:已有绑定就直接用,没有就按 workspace 建一个并登记。
* 绑定替换由 store 的 bindSession 判定(allowReplace),账上和宿主保持一致。
*/
async function connectDepartment(input = {}) {
const projectId = requireText(input.projectId, 'projectId')
const roleId = requireText(input.roleId, 'roleId')
const project = store.getProject(projectId)
if (project === undefined) throw new Error('项目不存在')
if (sessions === null) {
throw new Error('宿主未提供会话能力,暂时无法接通部门(账本仍可读写)')
}
const binding = store.getBinding(projectId, roleId)
const existing = binding?.currentSessionId ?? null
if (existing !== null) {
const known = await sessions.inspectSession(existing)
if (known !== null) {
followSession(existing)
return { sessionId: existing, created: false, seat: seatOf(projectId, roleId) }
}
}
const requestedPreset = input.agentPreset ?? presetId
await assertAgentPreset(requestedPreset)
const target = await sessions.ensureSession({
workspaceId: project?.hostWorkspaceId,
sessionId: input.sessionId ?? null,
agentPreset: requestedPreset,
})
// 账上登记:同一会话被别的部门占用时 store 会拒绝,正是我们要的“会话独占”。
const saved = service.bindDepartmentSession({
projectId,
roleId,
sessionId: target.sessionId,
allowReplace: existing !== null,
})
followSession(target.sessionId)
return { sessionId: target.sessionId, created: target.created === true, seat: saved.seat }
}
function seatOf(projectId, roleId) {
return service.listSeats(projectId).find((seat) => seat.roleId === roleId) ?? null
}
/** 派发(对 UI 的唯一入口)。没有会话层时返回明确错误,不假装已发送。 */
async function dispatchTask(input = {}) {
if (dispatchService === null) {
return { ok: false, code: 'NO_SESSION_CONTROLLER', message: '宿主未提供会话能力,派发已停在工作台账内' }
}
return dispatchService.dispatch(input)
}
/** 处理部门输出里的契约行:只认结构化字段,解析失败的行原样返回给 UI 提示。 */
function ingestAgentOutput({ projectId, roleId, text } = {}) {
const parsed = parseContractLines(text)
const applied = []
const failed = []
for (const call of parsed.calls) {
try {
applied.push(applyContractCall({ projectId, roleId, call }))
} catch (error) {
failed.push({ action: call.action, code: error?.code ?? 'unknown', message: error?.message ?? String(error) })
}
}
return { applied, failed, invalid: parsed.invalid }
}
function applyContractCall({ projectId, roleId, call }) {
const payload = { ...call.payload, projectId }
switch (call.action) {
case 'dispatchTask':
if (payload.sourceRoleId === undefined) payload.sourceRoleId = roleId
return { action: call.action, result: service.dispatchTask(payload) }
case 'reportTaskResult':
return { action: call.action, result: service.reportTaskResult(payload) }
case 'requestTaskInput':
return { action: call.action, result: service.requestTaskInput(payload) }
case 'syncDecision':
return { action: call.action, result: service.syncDecision(payload) }
default:
throw new Error(`未知动作:${String(call.action)}`)
}
}
function start() {
if (started) return
started = true
if (options.startReconciler !== false && reconciler !== null) reconciler.start()
}
function dispose() {
if (reconciler !== null) reconciler.stop()
if (sessions !== null) sessions.dispose()
started = false
}
return Object.freeze({
version: WORKBENCH_HOST_VERSION,
store,
service,
memory,
// 会话层可能晚到:用 getter,调用方总能读到最新挂载结果。
get sessions() {
return sessions
},
get reconciler() {
return reconciler
},
get dispatchService() {
return dispatchService
},
get hasSessions() {
return hasSessions
},
attachSessions,
presetId,
connectDepartment,
dispatchTask,
ingestAgentOutput,
bootstrap: (projectId) => service.bootstrap(projectId),
listEvents: (projectId, since, opts) => service.listEvents(projectId, since, opts),
start,
dispose,
})
}
function createStore(options) {
const file = options.storeFile ?? defaultStorePath(process.env)
const store = new WorkbenchStore({ file })
try {
store.load()
} catch {
// 读到坏账本时不静默清空:由 paths.quarantineFile 在 HTTP 层隔离,这里保持空账可写。
}
return store
}
function requireText(value, field) {
if (typeof value !== 'string' || value.trim() === '') throw new Error(`${field} 必须是非空字符串`)
return value
}
export { CONTRACT_ACTIONS, CONTRACT_ACTION_PREFIX, parseContractLines, describeContract }

View File

@ -1,9 +0,0 @@
# dsh-sansheng-liubu-workbench bundle patch
#
# One insert row loads the package: the host entry is a no-op stub, the
# actual feature lives in the web client (./client export, see the `dsh`
# manifest in package.json).
- insert:
- id: dsh-sansheng-liubu-workbench
name: 'dsh-sansheng-liubu-workbench'
config: {}

View File

@ -1,15 +0,0 @@
/**
* dsh-sansheng-liubu-workbench — 三省六部工作台面板(Web 客户端包)。
*
* 宿主侧入口只是占位:profile 组合要求 bundles 列表里的每个包都声明
* dsh.bundle(补丁层),且补丁行加载的宿主插件就是本文件。面板的实际
* 功能全在 Web 客户端(lib/client.js,见 package.json 的 dsh.client)。
* 缺了这层声明时,宿主会在启动时以 "declares no dsh.bundle" 跳过本包,
* 右侧栏的「朝堂」入口便不会出现。
*/
/** Plugin identity for cordis.yml rows. */
export const name = 'dsh-sansheng-liubu-workbench'
/** Plugin body: nothing host-side; the client half does the work. */
export function apply(ctx) {}

File diff suppressed because it is too large Load Diff

View File

@ -1,10 +0,0 @@
{
"name": "dsh-sansheng-liubu-mode-panel-source",
"version": "0.14.0",
"description": "三省六部工作台面板源码(已并入 dsh-sansheng-liubu-mode,不是独立安装包)",
"type": "module",
"private": true,
"files": [
"lib/**"
]
}

View File

@ -1,668 +0,0 @@
import test from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import vm from "node:vm";
const CLIENT_PATH = fileURLToPath(new URL("../lib/client.js", import.meta.url));
const SOURCE = readFileSync(CLIENT_PATH, "utf8");
function createStorage(initial) {
const map = new Map(Object.entries(initial || {}));
return {
getItem(key) {
return map.has(key) ? map.get(key) : null;
},
setItem(key, value) {
map.set(key, String(value));
},
removeItem(key) {
map.delete(key);
},
};
}
function createReact() {
function createElement(type, props) {
const children = Array.prototype.slice.call(arguments, 2);
return { type: type, props: props || {}, children: children };
}
class Component {
constructor(props) {
this.props = props;
this.state = {};
}
}
return {
createElement: createElement,
Component: Component,
useState: function (initial) {
return [initial, function () {}];
},
useRef: function (initial) {
return { current: initial };
},
useEffect: function () {},
useCallback: function (fn) {
return fn;
},
useMemo: function (fn) {
return fn();
},
useContext: function () {
return null;
},
createContext: function (value) {
return { _value: value };
},
Fragment: "Fragment",
};
}
function createDocument() {
const appended = [];
return {
appended: appended,
hidden: false,
head: {
appendChild: function (node) {
appended.push(node);
},
},
body: {},
querySelector: function () {
return null;
},
createElement: function (tagName) {
return {
tagName: tagName,
dataset: {},
textContent: "",
appendChild: function () {},
setAttribute: function () {},
};
},
addEventListener: function () {},
removeEventListener: function () {},
};
}
function loadPlugin(options) {
options = options || {};
const storage = createStorage(options.storage);
const document = createDocument();
const react = createReact();
let definition = null;
const window = {
__ModuleLoader__: {
load: function (loaded) {
definition = loaded;
},
},
};
const sandbox = {
window: window,
document: document,
console: console,
URL: URL,
Map: Map,
Set: Set,
WeakMap: WeakMap,
Promise: Promise,
setTimeout: setTimeout,
clearTimeout: clearTimeout,
localStorage: storage,
Symbol: Symbol,
};
vm.runInNewContext(SOURCE, sandbox, { filename: CLIENT_PATH });
assert.ok(definition, "bundle 应该调用 window.__ModuleLoader__.load");
assert.equal(definition.id, "dsh-sansheng-liubu-mode", "bundle id 必须是主包包名(面板已并回主包)");
const exports = definition.factory(function (id) {
if (id === "react") return react;
throw new Error("unexpected require: " + id);
});
return { exports: exports, react: react, storage: storage, document: document, definition: definition };
}
function createCtx(options) {
options = options || {};
const registrations = [];
const injections = [];
const tabs = [];
const effects = [];
const ctx = {
slots: {
inject: function (name, factory) {
injections.push(name);
const value = factory();
if (value !== undefined) registrations.push(value);
return function () {};
},
register: function (spec, component) {
const registration = { spec: spec, component: component };
registrations.push(registration);
return registration;
},
},
effect: function (factory, label) {
effects.push(label);
const value = factory();
return typeof value === "function" ? value : function () {};
},
get: function (name) {
return options.services ? options.services[name] : undefined;
},
uiWorkspace: {
currentWorkspaceId: options.workspaceId || "ws-1",
openSession: function () {},
},
};
if (!options.noTabs) {
ctx.sidebarRightTabs = {
register: function (spec) {
tabs.push(spec);
return function () {};
},
};
}
return { ctx: ctx, registrations: registrations, injections: injections, tabs: tabs, effects: effects };
}
test("bundle 契约:id、inject 与纯函数导出", function () {
const plugin = loadPlugin();
const api = plugin.exports;
assert.deepEqual(Array.from(api.inject), ["slots", "sessions", "workspaces", "uiWorkspace", "uiConversation"]);
assert.equal(typeof api.apply, "function");
assert.equal(typeof api.WorkbenchRail, "function");
assert.equal(typeof api.__test, "object");
const expected = ["computeRailLayout", "statusOf", "mergeEvents", "apiPath", "pickProjectId", "workspaceIdOf", "formatModelLine", "ROLE_META"];
for (const key of expected) assert.ok(key in api.__test, "__test 缺少 " + key);
assert.equal(Object.keys(api.__test.ROLE_META).length, 10);
assert.deepEqual(Object.keys(api.__test.ROLE_META).slice(0, 4), ["lead", "zhongshu", "shangshu", "menxia"]);
});
test("computeRailLayout:丞相跨三列居中、三省一列、六部 3×2", function () {
const layout = loadPlugin().exports.__test.computeRailLayout(400);
assert.equal(layout.width, 400);
assert.equal(layout.nodes.length, 10);
const byId = {};
for (const node of layout.nodes) {
assert.equal(typeof node.id, "string");
assert.equal(typeof node.x, "number");
assert.equal(typeof node.y, "number");
assert.equal(typeof node.col, "number");
assert.equal(typeof node.row, "number");
byId[node.id] = node;
}
const lead = byId.lead;
assert.equal(lead.col, 1);
assert.equal(lead.span, 3);
assert.ok(Math.abs(lead.x + lead.w / 2 - 200) < 0.001, "丞相应水平居中");
assert.ok(Math.abs(lead.x - (400 - lead.w) / 2) < 0.001);
const san = ["zhongshu", "shangshu", "menxia"].map((id) => byId[id]);
assert.deepEqual(Array.from(san, (node) => node.col), [0, 1, 2]);
assert.deepEqual(Array.from(san, (node) => node.row), [1, 1, 1]);
assert.equal(new Set(Array.from(san, (node) => node.y)).size, 1, "三省应在同一行");
assert.ok(san[0].x < san[1].x && san[1].x < san[2].x, "三省 x 必须递增");
const six = layout.nodes.filter((node) => node.row >= 2);
assert.equal(six.length, 6);
assert.deepEqual(Array.from(six, (node) => node.id), ["libu", "hubu", "lipu", "bingbu", "xingbu", "gongbu"]);
assert.equal(six[5].id, "gongbu", "第 6 个是工部");
assert.deepEqual(Array.from(six, (node) => node.col), [0, 1, 2, 0, 1, 2]);
assert.deepEqual(Array.from(six, (node) => node.row), [2, 2, 2, 3, 3, 3]);
assert.ok(layout.groups.ministries.y > layout.groups.sansheng.y + layout.groups.sansheng.h);
assert.ok(layout.height > 0);
});
test("computeRailLayout:窄栏仍是三列且不出现负宽度", function () {
const layout = loadPlugin().exports.__test.computeRailLayout(340);
assert.equal(layout.nodes.length, 10);
assert.equal(new Set(Array.from(layout.nodes, (node) => node.col)).size, 3);
for (const node of layout.nodes) assert.ok(node.w > 0, node.id + " 宽度必须为正");
assert.ok(layout.leadWidth <= 184);
});
test("statusOf:六种部门状态与未知值兜底", function () {
const { statusOf } = loadPlugin().exports.__test;
assert.equal(statusOf("uninitialized"), "未接通");
assert.equal(statusOf("idle"), "空闲");
assert.equal(statusOf("queued"), "排队");
assert.equal(statusOf("running"), "正在运行");
assert.equal(statusOf("unavailable"), "不可用");
assert.equal(statusOf("needs_attention"), "需人处理");
assert.equal(statusOf("something-new"), "未知");
assert.equal(statusOf(null), "未接通");
assert.equal(statusOf(""), "未接通");
});
test("mergeEvents:按 eventId 去重、按 seq 升序、忽略乱序重复", function () {
const { mergeEvents } = loadPlugin().exports.__test;
const merged = mergeEvents(
[{ eventId: "a", seq: 3 }, { eventId: "b", seq: 1 }],
[{ eventId: "b", seq: 1 }, { eventId: "c", seq: 2 }, { eventId: "a", seq: 3 }],
);
assert.equal(merged.length, 3);
assert.deepEqual(Array.from(merged, (event) => event.eventId), ["b", "c", "a"]);
assert.deepEqual(Array.from(merged, (event) => event.seq), [1, 2, 3]);
const again = mergeEvents(merged, []);
assert.deepEqual(Array.from(again, (event) => event.eventId), ["b", "c", "a"]);
assert.deepEqual(Array.from(mergeEvents([], [])), []);
});
test("formatModelLine:无配置跟随宿主,有配置拼 provider/model · effort", function () {
const { formatModelLine } = loadPlugin().exports.__test;
assert.equal(formatModelLine(null), "跟随宿主");
assert.equal(formatModelLine(undefined), "跟随宿主");
assert.equal(formatModelLine({}), "跟随宿主");
assert.equal(formatModelLine({ provider: "", model: "" }), "跟随宿主");
assert.equal(formatModelLine({ provider: "deepseek", model: "", reasoningEffort: "high" }), "跟随宿主");
assert.equal(formatModelLine({ provider: "deepseek", model: "deepseek-v4", reasoningEffort: "high" }), "deepseek/deepseek-v4 · 高");
assert.equal(formatModelLine({ provider: "deepseek", model: "deepseek-v4" }), "deepseek/deepseek-v4");
assert.equal(formatModelLine({ provider: "deepseek", model: "deepseek-v4", reasoningEffort: "custom" }), "deepseek/deepseek-v4 · custom");
// model 自带 provider 前缀时只留最后一段,完整路径放 title。
assert.equal(
formatModelLine({ provider: "magpie", model: "workbuddy/deepseek-v4", reasoningEffort: "high" }),
"deepseek-v4 · 高",
);
});
test("seatDisplayName:name 与 short 同时存在时必须用完整名", function () {
const { seatDisplayName, modelTitle } = loadPlugin().exports.__test;
assert.equal(seatDisplayName({ roleId: "lead", name: "丞相", short: "丞" }), "丞相");
assert.equal(seatDisplayName({ roleId: "zhongshu", name: "中书", short: "中" }), "中书");
assert.equal(seatDisplayName({ roleId: "lead" }), "丞相", "缺 name 时回落到 ROLE_META 的完整名");
assert.equal(seatDisplayName({ roleId: "lead", short: "丞" }), "丞相", "short 不能优先于 ROLE_META 的完整名");
assert.equal(seatDisplayName({ name: "", roleId: "unknown" }), "unknown");
assert.equal(modelTitle(null), "跟随宿主(未单独配置模型)");
assert.equal(
modelTitle({ provider: "magpie", model: "workbuddy/deepseek-v4", reasoningEffort: "high" }),
"magpie/workbuddy/deepseek-v4 · 高",
);
});
test("wirePathsFromLayout:量不到 DOM 时仍能生成三支 + 主干连线", function () {
const { computeRailLayout, wirePathsFromLayout } = loadPlugin().exports.__test;
const layout = computeRailLayout(400);
const paths = wirePathsFromLayout(layout);
assert.equal(paths.length, 4, "三省三支 + 尚书到六部一条主干");
const branch = paths.filter((item) => item.kind === "branch");
const trunk = paths.filter((item) => item.kind === "trunk");
assert.equal(branch.length, 3);
assert.equal(trunk.length, 1);
assert.deepEqual(Array.from(branch).map((item) => item.key), ["lead-zhongshu", "lead-shangshu", "lead-menxia"]);
for (const item of branch) {
const id = item.key.replace(/^lead-/, "");
const card = layout.sansheng.find((node) => node.id === id);
assert.ok(item.d.includes(" C "), "分支必须用三次贝塞尔收口,垂直进入卡片顶边");
assert.ok(!item.d.includes(" Q "), "不要退回二次贝塞尔(会在卡片顶边上方擦成一条横线)");
const tail = item.d.match(/ C [0-9.]+ [0-9.]+ [0-9.]+ [0-9.]+ ([0-9.]+) ([0-9.]+)$/);
assert.ok(tail, "分支末尾应是第二个控制点 + 终点");
assert.ok(Math.abs(Number(tail[1]) - card.cx) < 0.06, "终点 x 应等于卡片顶边中点");
assert.equal(Number(tail[2]), card.y, "终点 y 应落在卡片顶边");
}
const shangshu = layout.sansheng.find((node) => node.id === "shangshu");
assert.equal(trunk[0].d, "M 200 " + (shangshu.y + shangshu.h) + " L 200 " + layout.groups.ministries.y);
});
test("apiPath:拼出同源工作台路径并编码查询串", function () {
const { apiPath } = loadPlugin().exports.__test;
assert.equal(apiPath("bootstrap"), "/sansheng/workbench/bootstrap");
assert.equal(apiPath("/connect"), "/sansheng/workbench/connect");
assert.equal(apiPath("events", { projectId: "p-1", since: 7 }), "/sansheng/workbench/events?projectId=p-1&since=7");
assert.equal(apiPath("events", { projectId: "p 1", since: undefined }), "/sansheng/workbench/events?projectId=p%201");
assert.equal(apiPath("bootstrap", {}), "/sansheng/workbench/bootstrap");
});
test("pickProjectId:只按明确的 hostWorkspaceId 匹配,缺省不再退回首项目", function () {
const { pickProjectId } = loadPlugin().exports.__test;
const data = {
projectId: "p-default",
projects: [
{ id: "p-other", hostWorkspaceId: "ws-other" },
{ id: "p-mine", hostWorkspaceId: "ws-mine" },
],
};
assert.equal(pickProjectId(data, "ws-mine"), "p-mine");
assert.equal(pickProjectId(data, "ws-missing"), null);
assert.equal(pickProjectId(data), null, "没有工作区身份时不能回退到默认项目");
assert.equal(pickProjectId(data, ""), null);
assert.equal(pickProjectId({ projects: [{ id: "p-only" }] }, "ws-only"), null);
assert.equal(pickProjectId({ projects: [] }, "ws-x"), null);
});
test("workspaceIdOf:从当前 mainView 会话反查工作区,绝不猜第一个", function () {
const { workspaceIdOf } = loadPlugin().exports.__test;
const sessions = {
list: {
getSnapshot: () => ({
byId: {
"s-1": { id: "s-1", retainedBy: { mainView: 1 } },
"s-2": { id: "s-2", retainedBy: {} },
},
}),
},
};
const workspaces = {
list: {
getSnapshot: () => ({
items: [
{ workspaceId: "ws-first", sessionIds: ["s-2"] },
{ workspaceId: "ws-current", sessionIds: ["s-1"] },
],
}),
},
};
const ctx = {
get(name) {
if (name === "sessions") return sessions;
if (name === "workspaces") return workspaces;
return undefined;
},
};
assert.equal(workspaceIdOf(ctx), "ws-current");
// 没有 mainView 会话时返回 null,绝不拿列表第一项。
const noSelection = {
get(name) {
if (name === "sessions") return { list: { getSnapshot: () => ({ byId: {} }) } };
if (name === "workspaces") return workspaces;
return undefined;
},
};
assert.equal(workspaceIdOf(noSelection), null);
});
test("apply:注册朝堂页签、pane 槽与 priority -1 的 main.conversation", function () {
const plugin = loadPlugin();
const mock = createCtx();
plugin.exports.apply(mock.ctx);
assert.ok(mock.injections.includes("sidebar.right.pane.tab"));
assert.ok(mock.injections.includes("sidebar.right.pane.tab.title"));
assert.ok(mock.injections.includes("main.conversation"));
assert.equal(mock.tabs.length, 1);
assert.equal(mock.tabs[0].id, "sansheng-liubu-workbench");
assert.equal(mock.tabs[0].priority, "builtin");
assert.equal(mock.tabs[0].title(), "朝堂");
assert.ok(Array.isArray(mock.tabs[0].guide) && mock.tabs[0].guide.length === 1, "原生降级必须带 guide 入口");
assert.equal(mock.tabs[0].guide[0].id, "sansheng-liubu-workbench");
assert.equal(mock.tabs[0].guide[0].title(), "朝堂");
assert.equal(typeof mock.tabs[0].guide[0].description(), "string");
const main = mock.registrations.find((entry) => entry.spec && entry.spec.name === "main.conversation");
assert.ok(main, "必须注册 main.conversation");
assert.equal(main.spec.priority, -1);
assert.deepEqual(Array.from(Object.keys(main.spec.children)), ["conversation.header"]);
});
test("apply:服务晚到与重挂时只保留一个朝堂入口,先清理旧注册", function () {
const plugin = loadPlugin();
const registered = [];
const disposed = [];
const watchers = new Map();
const ctx = {
slots: {
inject: function () {},
register: function (spec) { return { spec: spec } },
},
effect: function (factory) {
const value = factory();
return typeof value === "function" ? value : function () {};
},
get: function () { return undefined; },
inject: function (names, callback) {
watchers.set(names[0], { callback: callback, cleanup: null });
return function () {};
},
};
plugin.exports.apply(ctx);
assert.equal(registered.length, 0, "服务未就绪时不能假装注册");
const better = {
registerTab: function (spec) {
registered.push({ kind: "better", spec: spec });
return function () { disposed.push("better"); };
},
};
const native = {
register: function (spec) {
registered.push({ kind: "native", spec: spec });
return function () { disposed.push("native"); };
},
};
const betterWatcher = watchers.get("betterSidebar");
betterWatcher.cleanup = betterWatcher.callback({ get: function () { return better; } });
assert.equal(registered.length, 1);
assert.equal(registered[0].kind, "better");
const nativeWatcher = watchers.get("sidebarRightTabs");
nativeWatcher.cleanup = nativeWatcher.callback({ get: function () { return native; } });
assert.equal(registered.length, 1, "betterSidebar 在场时不能重复注册原生入口");
betterWatcher.cleanup();
assert.equal(registered.length, 2, "betterSidebar 卸载后应补注册原生入口");
assert.equal(registered[1].kind, "native");
betterWatcher.cleanup = betterWatcher.callback({ get: function () { return better; } });
assert.equal(registered.length, 3, "betterSidebar 重挂后应重新注册 better 入口");
assert.equal(registered[2].kind, "better");
assert.ok(disposed.includes("native"), "切回 better 前必须先释放原生注册");
});
test("apply:localStorage 逃生开关 sansheng.workbench.main=off 时不接管主区", function () {
const plugin = loadPlugin({ storage: { "sansheng.workbench.main": "off" } });
const mock = createCtx();
plugin.exports.apply(mock.ctx);
assert.equal(mock.injections.includes("main.conversation"), false);
assert.ok(mock.injections.includes("sidebar.right.pane.tab"));
});
test("main.conversation:非绑定会话只透传原生 header/content,不加右栏", function () {
const plugin = loadPlugin();
const mock = createCtx();
plugin.exports.apply(mock.ctx);
const main = mock.registrations.find((entry) => entry.spec && entry.spec.name === "main.conversation");
const tree = main.component({
sessionId: "session-1",
useSession: function () {
return { openState: "open", blank: true, running: false, promptAttempted: false };
},
useSessions: function (select) {
return select({ byId: { "session-1": { blank: true } } });
},
useConversation: function () {
return { activeTargets: new Set() };
},
renderSlot: function (name) {
return { type: "header-slot", name: name };
},
renderFactorySlot: function (name, params) {
return { type: "content-slot", name: name, params: params };
},
widthControls: { width: 900 },
});
assert.equal(tree.props.className, "wb-main-native");
const children = tree.children[0];
assert.equal(children[0].type, "header-slot");
assert.equal(children[1].type, "content-slot");
assert.equal(children[1].params.phase, "hero");
assert.deepEqual(children[1].params.hero, true);
assert.ok(!JSON.stringify(tree).includes("wb-main-rail"), "非工作台会话不能出现右栏");
});
test("WorkbenchRail:无数据时也渲染完整骨架与三个内部页签", function () {
const plugin = loadPlugin();
const mock = createCtx();
const tree = plugin.exports.WorkbenchRail({ ctx: mock.ctx, compact: true });
assert.ok(tree.props.className.includes("wb-rail"));
assert.ok(tree.props.className.includes("is-compact"));
const serialized = JSON.stringify(tree);
assert.ok(serialized.includes("三省六部"));
assert.ok(serialized.includes("朝堂"));
assert.ok(serialized.includes("任务"));
assert.ok(serialized.includes("成果"));
assert.ok(serialized.includes("十席 · 0 席已接通"));
assert.ok(serialized.includes("六部 · 同级"));
assert.ok(serialized.includes("正在读取") === false);
});
test("main.conversation:接管逻辑抛错时回退原生会话,不白屏", function () {
const plugin = loadPlugin();
const mock = createCtx();
plugin.exports.apply(mock.ctx);
const main = mock.registrations.find((entry) => entry.spec && entry.spec.name === "main.conversation");
const warnings = [];
const originalWarn = console.warn;
console.warn = function () {
warnings.push(Array.from(arguments));
};
try {
const tree = main.component({
sessionId: "session-1",
useSession: function () {
// 模拟接管逻辑在渲染途中抛异常(理论上不应发生,但必须兜住)。
throw new Error("boom");
},
useSessions: function () {
return undefined;
},
useConversation: function () {
return { activeTargets: new Set() };
},
renderSlot: function (name) {
return { type: "header-slot", name: name };
},
renderFactorySlot: function (name, params) {
return { type: "content-slot", name: name, params: params };
},
});
assert.equal(tree.props.className, "wb-main-native");
assert.equal(tree.children[0][0].type, "header-slot");
assert.equal(tree.children[0][1].type, "content-slot");
assert.ok(!JSON.stringify(tree).includes("wb-main-split"), "回退时不能拼右栏");
assert.ok(!JSON.stringify(tree).includes("wb-main-resizer"), "回退时不能拼分隔条");
assert.ok(
warnings.some((args) => String(args[0]).includes("接管失败")),
"回退时要留下可诊断的 console.warn",
);
} finally {
console.warn = originalWarn;
}
});
test("existenceLabel:missing / unknown / ok 三态,unknown 不能被当成正常", function () {
const plugin = loadPlugin();
const { existenceLabel } = plugin.exports.__test;
assert.equal(existenceLabel("missing"), "文件已失效");
assert.equal(existenceLabel("unknown"), "位置未核验");
assert.equal(existenceLabel("ok"), "");
assert.equal(existenceLabel(undefined), "");
assert.notEqual(existenceLabel("unknown"), "");
assert.ok(!existenceLabel("unknown").includes("正常"), "unknown 不能显示成正常");
assert.ok(!existenceLabel("ok").includes("正常"), "ok 也不必写正常,静默即可");
});
test("verificationLabel:英文枚举翻成中文,别和「文件已失效」读成自相矛盾", function () {
const plugin = loadPlugin();
const { verificationLabel } = plugin.exports.__test;
assert.equal(verificationLabel("verified"), "已核验");
assert.equal(verificationLabel("unverified"), "未核验");
assert.equal(verificationLabel("rejected"), "未通过");
assert.equal(verificationLabel(undefined), "核验未知");
// 「已核验」说的是结果被核验过,不是文件还在——不能出现「存在」「有效」这类字眼。
assert.ok(!/存在|有效/.test(verificationLabel("verified")));
});
test("revisionLabel:第 N 版,只有真正修订且 N>1 才写「修订自上一版」", function () {
const plugin = loadPlugin();
const { revisionLabel } = plugin.exports.__test;
assert.equal(revisionLabel({ revision: 1, revisesArtifactId: "art-0" }), "第 1 版");
assert.ok(!revisionLabel({ revision: 1, revisesArtifactId: "art-0" }).includes("修订自"));
assert.equal(revisionLabel({ revision: 2, revisesArtifactId: "art-0" }), "第 2 版 · 修订自上一版");
assert.equal(revisionLabel({ revision: 3, revisesArtifactId: null }), "第 3 版");
assert.equal(revisionLabel({}), "第 1 版");
assert.equal(revisionLabel(null), "第 1 版");
});
test("taskKindLabel:只给 kind=revision 加「修订」标签", function () {
const plugin = loadPlugin();
const { taskKindLabel } = plugin.exports.__test;
assert.equal(taskKindLabel({ kind: "revision" }), "修订");
assert.equal(taskKindLabel({ kind: "normal" }), "");
assert.equal(taskKindLabel({}), "");
assert.equal(taskKindLabel(null), "");
});
test("A27 分隔条键盘:方向键 / Shift / Home / End 有确定步长,其它键不动", function () {
const { railResizeTarget } = loadPlugin().exports.__test;
// 默认 16px 一档,Shift 加速到 64px。
assert.equal(railResizeTarget("ArrowLeft", { width: 400 }), 384);
assert.equal(railResizeTarget("ArrowRight", { width: 400 }), 416);
assert.equal(railResizeTarget("ArrowRight", { width: 400, shift: true }), 464);
assert.equal(railResizeTarget("ArrowLeft", { width: 400, shift: true }), 340); // 400-64 撞下限 340
// 两端截断,不会跑出 340–600。
assert.equal(railResizeTarget("Home", { width: 500 }), 340);
assert.equal(railResizeTarget("End", { width: 500 }), 600);
assert.equal(railResizeTarget("ArrowLeft", { width: 340 }), 340);
assert.equal(railResizeTarget("ArrowRight", { width: 600 }), 600);
assert.equal(railResizeTarget("ArrowRight", { width: 595, shift: true }), 600);
// 不认识的键返回 null:调用方不能 preventDefault,浏览器的默认行为要保留。
assert.equal(railResizeTarget("Tab", { width: 400 }), null);
assert.equal(railResizeTarget("Enter", { width: 400 }), null);
assert.equal(railResizeTarget(undefined, { width: 400 }), null);
});
test("任务行动作:草稿可派工、排队可派可取消、终态不给按钮", () => {
const { taskActionKeys } = loadPlugin().exports.__test;
// 草稿只是记在账本里,还没进部门队列,只能派工。
assert.equal(taskActionKeys({ status: "draft" }).join(","), 'dispatch');
// 排队:既能补派(幂等键会去重),也能取消。
assert.equal(taskActionKeys({ status: "queued" }).join(","), 'dispatch,cancel');
// 正在跑 / 需人处理:只能取消,不再重复派。
assert.equal(taskActionKeys({ status: "running" }).join(","), 'cancel');
assert.equal(taskActionKeys({ status: "needs_attention" }).join(","), 'cancel');
// 终态不给动作:避免对已完成任务再派一次。
assert.equal(taskActionKeys({ status: "completed" }).join(","), '');
assert.equal(taskActionKeys({ status: "cancelled" }).join(","), '');
assert.equal(taskActionKeys({ status: "failed" }).join(","), '');
assert.equal(taskActionKeys(null).join(","), '');
});

View File

@ -1,251 +0,0 @@
// A09 / A17 / A19 的补强验收:附件级材料引用、宿主重启后的账本恢复、项目间材料隔离。
import test from 'node:test'
import assert from 'node:assert/strict'
import { mkdtempSync, rmSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { WorkbenchStore } from '../core/store.mjs'
import { createWorkbenchService } from '../host/service.mjs'
import { buildDispatchText, describeMaterialRef } from '../host/session-adapter.mjs'
const clock = () => 1700000000000
function memoryStore() {
return new WorkbenchStore({ file: null, clock })
}
function seed(service, hostWorkspaceId) {
const project = service.registerProject({ hostWorkspaceId, displayNameCache: hostWorkspaceId }).project
const binding = service.bindDepartmentSession({ projectId: project.id, roleId: 'gongbu', sessionId: `ses_${hostWorkspaceId}` })
return { project, generation: binding.binding.bindingGeneration }
}
test('A09 交接材料:附件引用原样进 packet,成果引用带版本,文本里可读', () => {
const store = memoryStore()
const service = createWorkbenchService({ store, clock })
const { project, generation } = seed(service, 'ws-a')
const task = service.createTask({
projectId: project.id,
ownerRoleId: 'gongbu',
sourceRoleId: 'lead',
title: '按预算出方案',
objective: 'o',
status: 'queued',
}).task
const artifact = service.registerArtifact({
projectId: project.id,
ownerRoleId: 'gongbu',
taskId: task.id,
displayName: '预算表',
fileRef: 'C:/work/预算.xlsx',
kind: 'spreadsheet',
}).artifact
const dispatched = service.dispatchTask({
projectId: project.id,
taskId: task.id,
idempotencyKey: 'k-material',
targetRoleId: 'gongbu',
targetSessionId: 'ses_ws-a',
bindingGeneration: generation,
packet: {
materialRefs: [
{ artifactId: artifact.id },
{ attachmentId: 'att_abc', name: '预算.xlsx', mime: 'application/vnd.ms-excel', size: 2048 },
'聊天里贴过的那段口径',
],
},
})
const refs = dispatched.contextPacket.materialRefs
assert.deepEqual(refs[0], { artifactId: artifact.id, revision: 1, title: '预算表' })
assert.deepEqual(refs[1], { attachmentId: 'att_abc', name: '预算.xlsx', mime: 'application/vnd.ms-excel', size: 2048 })
assert.equal(refs[2], '聊天里贴过的那段口径')
// 派发文本必须把材料写成能读的一行,并保留可追溯 ID。
const text = buildDispatchText({ task, packet: dispatched.contextPacket, contractGuide: 'G', roleName: '工部' })
assert.ok(text.includes(`成果 预算表 ${artifact.id}(第 1 版)`))
assert.match(text, /附件 att_abc(预算\.xlsx · application\/vnd\.ms-excel · 2048 字节)/)
assert.match(text, /聊天里贴过的那段口径/)
// 纯函数本身也单独锁一下:非对象、空串、缺 ID 都不该糊过去。
assert.equal(describeMaterialRef(null), 'null')
assert.equal(describeMaterialRef('a.xlsx'), 'a.xlsx')
})
test('A09/A19 交接材料不能越权:别的项目的成果引用直接拒绝,且不泄露归属', () => {
const store = memoryStore()
const service = createWorkbenchService({ store, clock })
const a = seed(service, 'ws-a')
const b = seed(service, 'ws-b')
const taskA = service.createTask({
projectId: a.project.id,
ownerRoleId: 'gongbu',
sourceRoleId: 'lead',
title: 'A 的任务',
objective: 'o',
status: 'queued',
}).task
const artifact = service.registerArtifact({
projectId: a.project.id,
ownerRoleId: 'gongbu',
taskId: taskA.id,
title: 'A 的成果',
fileRef: 'C:/work/a.xlsx',
}).artifact
const task = service.createTask({
projectId: b.project.id,
ownerRoleId: 'gongbu',
sourceRoleId: 'lead',
title: 'B 的任务',
objective: 'o',
status: 'queued',
}).task
assert.throws(
() =>
service.dispatchTask({
projectId: b.project.id,
taskId: task.id,
idempotencyKey: 'k-cross',
targetRoleId: 'gongbu',
targetSessionId: 'ses_ws-b',
bindingGeneration: b.generation,
packet: { materialRefs: [{ artifactId: artifact.id }] },
}),
(error) => error.code === 'CROSS_PROJECT' && !JSON.stringify(error.details ?? {}).includes(a.project.id),
)
// 正常派发:B 的上下文包里只有自己的东西,绝不自动继承 A 的材料。
const dispatched = service.dispatchTask({
projectId: b.project.id,
taskId: task.id,
idempotencyKey: 'k-own',
targetRoleId: 'gongbu',
targetSessionId: 'ses_ws-b',
bindingGeneration: b.generation,
})
assert.deepEqual(dispatched.contextPacket.materialRefs, [])
// 缺 ID 的引用、空字符串都要明确报错,而不是“尽力猜”。
assert.throws(
() =>
service.dispatchTask({
projectId: b.project.id,
taskId: task.id,
idempotencyKey: 'k-bad',
targetRoleId: 'gongbu',
targetSessionId: 'ses_ws-b',
bindingGeneration: b.generation,
packet: { materialRefs: [{ name: '没有 ID 的东西' }] },
}),
(error) => error.code === 'INVALID_INPUT',
)
})
test('A17 宿主重启:账本重开后项目/绑定/配置/任务/派发都还在,换绑代号不回退', () => {
const dir = mkdtempSync(join(tmpdir(), 'wb-restart-'))
const file = join(dir, 'workbench.json')
try {
const first = new WorkbenchStore({ file, clock })
first.load()
const service = createWorkbenchService({ store: first, clock })
const { project, generation } = seed(service, 'ws-restart')
service.saveDepartmentConfig({ projectId: project.id, roleId: 'gongbu', provider: 'magpie', model: 'workbuddy/deepseek-v4.1-flash', expectedRevision: 0 })
const task = service.createTask({
projectId: project.id,
ownerRoleId: 'gongbu',
sourceRoleId: 'lead',
title: '重启前建的任务',
objective: 'o',
status: 'queued',
}).task
const dispatched = service.dispatchTask({
projectId: project.id,
taskId: task.id,
idempotencyKey: 'k-restart',
targetRoleId: 'gongbu',
targetSessionId: 'ses_ws-restart',
bindingGeneration: generation,
})
assert.equal(dispatched.dispatch.idempotencyKey, 'k-restart')
// —— 模拟宿主重启:新建 store 从同一文件重开 ——
const second = new WorkbenchStore({ file, clock })
second.load()
const revived = createWorkbenchService({ store: second, clock })
const projects = revived.listProjects()
assert.equal(projects.length, 1)
assert.equal(projects[0].hostWorkspaceId, 'ws-restart')
const seats = revived.listSeats(project.id)
const gongbu = seats.find((seat) => seat.roleId === 'gongbu')
assert.equal(gongbu.connected, true)
assert.equal(gongbu.config.model, 'workbuddy/deepseek-v4.1-flash')
assert.equal(gongbu.config.configRevision, 1)
const revivedTask = revived.getTask(project.id, task.id)
assert.equal(revivedTask.title, '重启前建的任务')
// 幂等键跨重启仍有效:再点一次不会重复投递。
const again = revived.dispatchTask({
projectId: project.id,
taskId: task.id,
idempotencyKey: 'k-restart',
targetRoleId: 'gongbu',
targetSessionId: 'ses_ws-restart',
bindingGeneration: generation,
})
assert.equal(again.duplicate, true)
assert.equal(again.dispatch.id, dispatched.dispatch.id)
} finally {
rmSync(dir, { recursive: true, force: true })
}
})
test('A26 切项目后草稿、绑定、配置各归所属,不互相串', () => {
const store = memoryStore()
const service = createWorkbenchService({ store, clock })
const a = service.registerProject({ hostWorkspaceId: 'ws-a', displayNameCache: 'A' }).project
const b = service.registerProject({ hostWorkspaceId: 'ws-b', displayNameCache: 'B' }).project
// 两个项目各自的工部配置不同,且都绑了不同会话。
service.saveDepartmentConfig({ projectId: a.id, roleId: 'gongbu', provider: 'magpie', model: 'workbuddy/deepseek-v4.1-flash', expectedRevision: 0 })
service.saveDepartmentConfig({ projectId: b.id, roleId: 'gongbu', provider: 'magpie', model: 'workbuddy/deepseek-v4.1-pro', expectedRevision: 0 })
service.bindDepartmentSession({ projectId: a.id, roleId: 'gongbu', sessionId: 'ses_a_gongbu' })
service.bindDepartmentSession({ projectId: b.id, roleId: 'gongbu', sessionId: 'ses_b_gongbu' })
// A 里存一份草稿(还没派工的修订单)。
const taskA = service.createTask({
projectId: a.id, ownerRoleId: 'gongbu', sourceRoleId: 'lead',
title: 'A 的草稿', objective: 'o', status: 'draft',
}).task
const taskB = service.createTask({
projectId: b.id, ownerRoleId: 'gongbu', sourceRoleId: 'lead',
title: 'B 的草稿', objective: 'o', status: 'draft',
}).task
const bootA = service.bootstrap(a.id)
const bootB = service.bootstrap(b.id)
const gongbuA = bootA.seats.find((seat) => seat.roleId === 'gongbu')
const gongbuB = bootB.seats.find((seat) => seat.roleId === 'gongbu')
// 配置与绑定各归各的:切项目不会把 A 的模型/会话带到 B。
assert.equal(gongbuA.config.model, 'workbuddy/deepseek-v4.1-flash')
assert.equal(gongbuB.config.model, 'workbuddy/deepseek-v4.1-pro')
assert.equal(gongbuA.binding.currentSessionId, 'ses_a_gongbu')
assert.equal(gongbuB.binding.currentSessionId, 'ses_b_gongbu')
// 草稿也只是各自项目里的任务,不会出现在对方列表里。
const titlesA = bootA.tasks.map((task) => task.title)
const titlesB = bootB.tasks.map((task) => task.title)
assert.ok(titlesA.includes('A 的草稿'))
assert.ok(!titlesA.includes('B 的草稿'))
assert.ok(titlesB.includes('B 的草稿'))
assert.ok(!titlesB.includes('A 的草稿'))
assert.equal(taskA.projectId, a.id)
assert.equal(taskB.projectId, b.id)
})

View File

@ -1,275 +0,0 @@
// 装配层测试:index.mjs 把 store / service / 会话层 / HTTP 路由拼在一起的那一层。
// 这里专门验「宿主稍后才给 sessionController」这条真实时序——它决定用户要不要多重启一次。
import test from 'node:test'
import assert from 'node:assert/strict'
import { Readable } from 'node:stream'
import { createWorkbenchHost } from '../host/index.mjs'
import { WorkbenchStore } from '../core/store.mjs'
const clock = () => 1700000000000
const WS = 'ws_demo'
/** 最小 webServer 替身:记下注册的路由,卸载时清掉。 */
function fakeWebServer() {
const routes = new Map()
return {
routes,
register(route) {
routes.set(route.path, route)
return () => routes.delete(route.path)
},
}
}
/** 最小 cordis 替身:inject 只把回调存起来,测试手动触发「依赖出现」。 */
function fakeCtx({ webServer = null, controller = null } = {}) {
const pending = []
return {
webServer,
sessionController: controller,
get: () => undefined,
inject(deps, callback) {
pending.push({ deps, callback })
return { dispose() {} }
},
fire(dep, scoped) {
const hit = pending.filter((row) => row.deps.includes(dep))
for (const row of hit) row.callback(scoped)
return hit.length
},
pending,
}
}
function fakeRes() {
const res = {
statusCode: 0,
headers: {},
body: '',
writableEnded: false,
headersSent: false,
setHeader(name, value) {
this.headers[String(name).toLowerCase()] = value
return this
},
writeHead(status, headers) {
this.statusCode = status
for (const [name, value] of Object.entries(headers ?? {})) this.headers[String(name).toLowerCase()] = value
this.headersSent = true
return this
},
end(chunk) {
if (chunk !== undefined) this.body += String(chunk)
this.writableEnded = true
return this
},
get json() {
return this.body === '' ? null : JSON.parse(this.body)
},
}
return res
}
function fakeReq(method, url, body) {
const text = body === undefined ? '' : JSON.stringify(body)
const stream = Readable.from(body === undefined ? [] : [Buffer.from(text, 'utf8')])
stream.method = method
stream.url = url
stream.headers = { 'content-type': 'application/json' }
return stream
}
async function callRoute(webServer, suffix, method, body) {
const route = [...webServer.routes.values()].find((item) => String(item.path).endsWith(suffix))
assert.notEqual(route, undefined, `未注册路由:${suffix}`)
const res = fakeRes()
await route.handler(fakeReq(method, route.path, body), res)
return res.json
}
/** 所有测试都用内存账本,绝不碰 %DSH_HOME% 下的真账本。 */
function memoryStore() {
return new WorkbenchStore({ file: null, clock })
}
function tinyController(seed = ['ses_gongbu']) {
const sessions = new Map()
const prompts = []
for (const sessionId of seed) {
sessions.set(sessionId, { sessionId, workspaceId: WS, running: false, accepted: new Set() })
}
return {
prompts,
sessions,
async create(request) {
const sessionId = request.sessionId ?? 'ses_auto'
sessions.set(sessionId, { sessionId, workspaceId: request.workspaceId ?? WS, running: false, accepted: new Set() })
return { sessionId }
},
async prompt(request) {
prompts.push(request)
const row = sessions.get(request.sessionId)
if (row === undefined || !row.accepted) throw Object.assign(new Error('no session'), { code: 'session/conflict' })
row.accepted.add(request.requestId)
return { accepted: true }
},
cancel() {
return { accepted: true }
},
}
}
test('装配层:宿主先有 webServer、后有 sessionController 时,派发从“只落账”升级为真投递', async () => {
const store = memoryStore()
const webServer = fakeWebServer()
const ctx = fakeCtx({ webServer })
const host = createWorkbenchHost(ctx, { store, startReconciler: false })
assert.equal(host.store, store)
assert.equal(host.registered, true)
assert.equal(webServer.routes.size, 16)
assert.equal(host.hasSessions, false)
const project = host.service.registerProject({ hostWorkspaceId: WS }).project
const bound = host.service.bindDepartmentSession({ projectId: project.id, roleId: 'gongbu', sessionId: 'ses_gongbu' })
const generation = bound.binding.bindingGeneration
const task = host.service.createTask({
projectId: project.id,
ownerRoleId: 'gongbu',
sourceRoleId: 'lead',
title: '接线后派发',
objective: 'o',
status: 'queued',
}).task
// 还没有会话层:路由只落账,状态停在 prepared,不伪装成已发送。
const before = await callRoute(webServer, '/dispatch', 'POST', {
projectId: project.id,
taskId: task.id,
idempotencyKey: 'k-ledger',
targetRoleId: 'gongbu',
targetSessionId: 'ses_gongbu',
bindingGeneration: generation,
})
assert.equal(before.ok, true)
assert.equal(before.value.dispatch.status, 'prepared')
// 宿主晚到:装配层自己把会话层补挂上,不需要重建工作台、也不需要多重启一次。
const controller = tinyController()
assert.equal(ctx.fire('sessionController', { sessionController: controller }), 1)
assert.equal(host.hasSessions, true)
assert.notEqual(host.dispatchService, null)
assert.notEqual(host.reconciler, null)
// 同一份账本、同一张任务,换新的幂等键再派一次:这次真的投递到会话。
const after = await callRoute(webServer, '/dispatch', 'POST', {
projectId: project.id,
taskId: task.id,
idempotencyKey: 'k-live',
targetRoleId: 'gongbu',
targetSessionId: 'ses_gongbu',
bindingGeneration: generation,
})
assert.equal(after.ok, true)
assert.equal(after.value.dispatch.state ?? after.value.dispatch.status, 'accepted')
assert.equal(controller.prompts.length, 1)
host.dispose()
assert.equal(webServer.routes.size, 0)
})
test('装配层:重复挂载会话层是幂等的,不会把已挂上的换掉', () => {
const store = memoryStore()
const ctx = fakeCtx({ webServer: fakeWebServer() })
const host = createWorkbenchHost(ctx, { store, startReconciler: false })
assert.equal(host.hasSessions, false)
assert.equal(host.attachSessions(tinyController()), true)
const first = host.sessions
assert.equal(host.attachSessions(tinyController()), true)
assert.equal(host.sessions, first)
host.dispose()
})
test('A05 两席闭环:丞相派工给工部 → 工部回执 → 成果登记 → 任务完成', async () => {
const store = memoryStore()
const webServer = fakeWebServer()
const controller = tinyController(['ses_gongbu'])
const ctx = fakeCtx({ webServer, controller })
const host = createWorkbenchHost(ctx, { store, startReconciler: false })
assert.equal(host.hasSessions, true, '有 sessionController 时就该能派发')
// 1) 项目 + 工部接通(丞相那一席由账本自带,不需要建会话也能当派发方)
const project = host.service.registerProject({ hostWorkspaceId: WS, displayNameCache: '闭环' }).project
const bound = host.service.bindDepartmentSession({ projectId: project.id, roleId: 'gongbu', sessionId: 'ses_gongbu' })
// 2) 丞相开任务并派给工部
const task = host.service.createTask({
projectId: project.id,
ownerRoleId: 'gongbu',
sourceRoleId: 'lead',
title: '做一版预算',
objective: '给出预算表',
status: 'queued',
}).task
const dispatched = await callRoute(webServer, '/dispatch', 'POST', {
projectId: project.id,
taskId: task.id,
targetRoleId: 'gongbu',
idempotencyKey: 'loop-1',
targetSessionId: 'ses_gongbu',
bindingGeneration: bound.binding.bindingGeneration,
})
assert.equal(dispatched.ok, true, JSON.stringify(dispatched))
assert.equal(dispatched.value.dispatch.status, 'accepted')
assert.equal(controller.prompts.length, 1, '工部会话应真实收到一条任务单')
assert.ok(controller.prompts[0].content[0].text.includes('做一版预算'))
const attempt = store.listAttempts(task.id)[0]
assert.ok(attempt, '派发要落一条 attempt')
// 3) 工部登记成果,再用契约行回执(正文里说“已完成”不算)
const artifact = host.service.registerArtifact({
projectId: project.id,
ownerRoleId: 'gongbu',
taskId: task.id,
displayName: '预算表',
fileRef: 'C:/work/预算.xlsx',
verification: { status: 'verified' },
}).artifact
const ingest = await callRoute(webServer, '/ingest', 'POST', {
projectId: project.id,
roleId: 'gongbu',
text: `【三省六部】${JSON.stringify({
action: 'reportTaskResult',
taskId: task.id,
attemptId: attempt.id,
reportVersion: 1,
report: {
summary: '预算表已出',
checks: [{ name: '合计对得上', ok: true, detail: '与台账一致' }],
artifactRefs: [artifact.id],
},
})}`,
})
assert.equal(ingest.ok, true, JSON.stringify(ingest))
assert.equal(ingest.value.applied.length, 1, JSON.stringify(ingest.value.failed))
// 4) 会话跑完:报告 + 终态成功 + 成果有效 → 任务完成
host.service.reportRunTerminal({
projectId: project.id,
taskId: task.id,
attemptId: attempt.id,
runTerminal: 'succeeded',
})
const done = store.getTask(task.id)
assert.equal(done.status, 'completed')
assert.ok(store.listResults(task.id).length >= 1, '回执要落成 Result,而不是只改任务状态')
assert.equal(store.listArtifacts(project.id).length, 1)
assert.equal(store.getDispatch(dispatched.value.dispatch.id).status, 'accepted')
});

View File

@ -1,406 +0,0 @@
// Host 层测试:契约解析、会话适配、派发幂等、对账与工作台外壳。
// 全部用假 SessionController(与 P0 记录的签名同形)驱动,不连真宿主,
// 这样“首次派发 / 重复点击 / 超时未知 / 宿主重启后对账”都能确定性地复现。
import test from 'node:test'
import assert from 'node:assert/strict'
import { WorkbenchStore } from '../core/store.mjs'
import { createWorkbenchService } from '../host/service.mjs'
import {
CONTRACT_ACTION_PREFIX,
parseContractLines,
validateContractCall,
describeContract,
} from '../host/contract.mjs'
import { buildDispatchText, classifyHostError, createSessionAdapter } from '../host/session-adapter.mjs'
import { createDispatchService } from '../host/dispatch-service.mjs'
import { createReconciler } from '../host/reconciler.mjs'
import { createWorkbenchHost } from '../host/workbench-host.mjs'
const clock = () => 1700000000000
const WS = 'ws_demo'
/** 假宿主:行为可控,记录每次 create/prompt/cancel,便于断言“没重发”。 */
function fakeController(behaviour = {}) {
const calls = { create: [], prompt: [], cancel: [], selectModel: [], inspect: [], list: 0 }
const sessions = new Map()
let next = 1
const controller = {
calls,
sessions,
async create(request) {
calls.create.push(request)
const existing = [...sessions.values()].find((row) => row.workspaceId === request.workspaceId)
if (existing !== undefined && request.sessionId === undefined) return { sessionId: existing.sessionId }
const sessionId = request.sessionId ?? `ses_${next++}`
sessions.set(sessionId, { sessionId, workspaceId: request.workspaceId ?? null, running: false, accepted: new Set() })
return { sessionId, agentPreset: request.agentPreset ?? null }
},
async inspect(sessionId) {
calls.inspect.push(sessionId)
const row = sessions.get(sessionId)
if (row === undefined) throw Object.assign(new Error('not found'), { code: 'session/not-found' })
return { sessionId, attached: true }
},
async prompt(request) {
calls.prompt.push(request)
const row = sessions.get(request.sessionId)
if (row === undefined) throw Object.assign(new Error('no session'), { code: 'session/conflict' })
if (behaviour.promptFails === 'timeout') throw Object.assign(new Error('timeout picking up request'), { code: 'ETIMEDOUT' })
if (behaviour.promptFails === 'busy') throw Object.assign(new Error('agent busy'), { code: 'session/agent-busy' })
if (row.accepted.has(request.requestId)) return { accepted: true }
row.accepted.add(request.requestId)
row.running = behaviour.staysRunning !== false
return { accepted: true }
},
cancel(request) {
calls.cancel.push(request)
const row = sessions.get(request.sessionId)
if (row !== undefined) row.running = false
return { accepted: true }
},
async selectModel(request) {
calls.selectModel.push(request)
if (behaviour.selectModelFails === true) {
throw Object.assign(new Error('model unavailable'), { code: 'session/model-unavailable' })
}
return { selected: { provider: request.provider, model: request.model } }
},
async list() {
calls.list += 1
return {
items: [...sessions.values()].map((row) => ({ sessionId: row.sessionId, running: row.running, agentAvailable: true, updatedAt: '', blank: false })),
}
},
}
return controller
}
function freshWorkbench(behaviour = {}) {
const store = new WorkbenchStore({ file: null, clock, env: { DSH_HOME: '/tmp/never-used' } })
const service = createWorkbenchService({ store, clock })
const controller = fakeController(behaviour)
const sessions = createSessionAdapter({ sessionController: controller })
const dispatch = createDispatchService({ store, service, sessions })
const reconciler = createReconciler({ store, service, sessions, clock })
const project = service.registerProject({ hostWorkspaceId: WS, displayNameCache: '演示项目' }).project
// 接通丞相与工部两个会话(首版两席闭环)。
for (const roleId of ['lead', 'gongbu']) {
const sessionId = roleId === 'lead' ? 'ses_lead' : 'ses_gongbu'
controller.sessions.set(sessionId, { sessionId, workspaceId: WS, running: false, accepted: new Set() })
service.bindDepartmentSession({ projectId: project.id, roleId, sessionId, allowReplace: false })
}
service.saveDepartmentConfig({
projectId: project.id,
roleId: 'gongbu',
provider: 'magpie',
model: 'workbuddy/deepseek-v4.1-flash',
expectedRevision: 0,
})
return { store, service, controller, sessions, dispatch, reconciler, projectId: project.id }
}
// ---------- 契约 ----------
test('契约解析只认四动作,坏 JSON 与未知动作都不改状态', () => {
const text = [
'普通正文,不含指令。',
`${CONTRACT_ACTION_PREFIX}{"action":"reportTaskResult","taskId":"task_1","attemptId":"att_1","summary":"完成"}`,
`${CONTRACT_ACTION_PREFIX}{"action":"finalizeEverything","taskId":"task_1"}`,
`${CONTRACT_ACTION_PREFIX}{不是 JSON}`,
'我已经完成了。',
].join('\n')
const { calls, invalid } = parseContractLines(text)
assert.equal(calls.length, 1)
assert.equal(calls[0].action, 'reportTaskResult')
assert.equal(invalid.length, 2)
assert.match(invalid[0].reason, /未知动作/)
assert.match(invalid[1].reason, /JSON/)
// 纯文本“已完成”不产生任何调用:这是方案明令禁止的推断路径。
assert.deepEqual(parseContractLines('任务已完成,请查收').calls, [])
assert.deepEqual(parseContractLines(null), { calls: [], invalid: [] })
})
test('validateContractCall 拦住缺幂等键/缺摘要的调用', () => {
assert.deepEqual(validateContractCall({ action: 'dispatchTask', payload: { taskId: 'task_1', idempotencyKey: 'k' } }), [])
assert.deepEqual(validateContractCall({ action: 'reportTaskResult', payload: { taskId: 'task_1', attemptId: 'att_1', summary: 's' } }), [])
assert.match(validateContractCall({ action: 'dispatchTask', payload: { taskId: 'task_1' } })[0], /idempotencyKey/)
assert.match(validateContractCall({ action: 'reportTaskResult', payload: { taskId: 't' } }).join(';'), /attemptId/)
assert.match(validateContractCall({ action: 'requestTaskInput', payload: { taskId: 't', attemptId: 'a' } }).join(';'), /reason/)
assert.match(validateContractCall({ action: 'syncDecision', payload: { taskId: 't' } }).join(';'), /decision/)
assert.match(describeContract(), /reportTaskResult/)
})
// ---------- 会话适配 ----------
test('会话适配:缺 sessionId 时按 workspace 建会话且不重复建', async () => {
const controller = fakeController()
const sessions = createSessionAdapter({ sessionController: controller })
const first = await sessions.ensureSession({ workspaceId: WS, agentPreset: 'sansheng-liubu' })
const second = await sessions.ensureSession({ workspaceId: WS, agentPreset: 'sansheng-liubu' })
assert.equal(first.created, true)
assert.equal(first.sessionId, second.sessionId, '同一 workspace 不能建出第二个会话')
assert.equal(controller.calls.create.length, 2)
await assert.rejects(() => sessions.ensureSession({}), /workspaceId/)
})
test('会话适配:prompt 必须带 requestId,错误分类可区分可重试与必失败', async () => {
const controller = fakeController()
const sessions = createSessionAdapter({ sessionController: controller })
await assert.rejects(() => sessions.sendPrompt({ sessionId: 'ses_1', text: 'hi' }), /requestId/)
await assert.rejects(() => sessions.sendPrompt({ sessionId: 'ses_1', requestId: 'r1', text: ' ' }), /为空/)
assert.equal(classifyHostError(Object.assign(new Error('x'), { code: 'session/conflict' })), 'conflict')
assert.equal(classifyHostError(Object.assign(new Error('x'), { code: 'session/model-unavailable' })), 'model_unavailable')
assert.equal(classifyHostError(new Error('request timeout')), 'transient')
assert.equal(classifyHostError(new Error('随便什么')), 'unknown')
})
test('会话适配:follow 发送 kind=session 地址,同一会话只保留一条流', async () => {
let address = null
const controller = {
...fakeController(),
follow(request, signal) {
address = request.address
return (async function* () {
yield { type: 'turn/start' }
while (!signal.aborted) await new Promise((resolve) => setTimeout(resolve, 5))
})()
},
}
const sessions = createSessionAdapter({ sessionController: controller })
const first = sessions.follow('ses_follow')
await new Promise((resolve) => setTimeout(resolve, 10))
assert.deepEqual(address, { kind: 'session', sessionId: 'ses_follow' })
assert.equal(sessions.follow('ses_follow'), first, '同一会话不能起第二条流')
first.stop()
await new Promise((resolve) => setTimeout(resolve, 10))
})
test('会话适配:直接子代理使用 kind=subagent 地址,订阅失败回调可见', async () => {
let address = null
let failure = null
const controller = {
...fakeController(),
follow(request) {
address = request.address
return (async function* () {
throw Object.assign(new Error('session not found'), { code: 'session/not-found' })
})()
},
}
const sessions = createSessionAdapter({ sessionController: controller })
sessions.follow(
{ kind: 'subagent', parentSessionId: 'ses_parent', childSessionId: 'ses_child', mode: 'one-shot' },
{ onError: (value) => { failure = value } },
)
await new Promise((resolve) => setTimeout(resolve, 10))
assert.deepEqual(address, {
kind: 'subagent',
parentSessionId: 'ses_parent',
childSessionId: 'ses_child',
mode: 'one-shot',
})
assert.equal(failure?.sessionId, 'ses_child')
assert.equal(failure?.code, 'session/not-found')
})
test('派发提示词只写事实,不给“已完成”下定义', () => {
const text = buildDispatchText({
task: { id: 'task_1', title: '整理报表', objective: '合并三张表', acceptance: ['口径一致'], constraints: ['只读源文件'] },
packet: { materialRefs: ['a.xlsx'] },
contractGuide: '(结构化回传说明)',
roleName: '工部',
})
assert.match(text, /任务单 task_1/)
assert.match(text, /口径一致/)
assert.match(text, /a\.xlsx/)
assert.match(text, /不要只在正文里说“已完成”/)
})
// ---------- 派发 ----------
test('首次派发:固定模型快照 → prompt 用 attemptId 作幂等键 → dispatch accepted', async () => {
const { store, service, controller, dispatch, projectId } = freshWorkbench()
const task = service.createTask({ projectId, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: '导出报表', objective: '按模板导出' }).task
const result = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k1' })
assert.equal(result.outcome, 'accepted')
assert.equal(result.duplicate, false)
const attempt = store.getAttempt(result.attempt.id)
assert.equal(attempt.state, 'running')
// A06:默认不调 selectModel(部门模型由政策插件在 agent/request 上覆写,
// 再调一次会让宿主把全局默认模型存成本部门的)。模型快照仍记在 attempt 上。
assert.equal(controller.calls.selectModel.length, 0, "默认不碰宿主的模型选择")
assert.equal(attempt.effectiveConfigSnapshot.model, "workbuddy/deepseek-v4.1-flash")
assert.equal(controller.calls.prompt.length, 1)
assert.equal(controller.calls.prompt[0].requestId, attempt.id, 'attemptId 就是 prompt 的幂等键')
assert.equal(store.getDispatch(result.dispatch.id).state, 'accepted')
})
test('重复点击同一幂等键:不重复投递、返回既有结论', async () => {
const { service, controller, dispatch, projectId } = freshWorkbench()
const task = service.createTask({ projectId, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: 't', objective: 'o' }).task
const first = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'same' })
const second = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'same' })
assert.equal(second.duplicate, true)
assert.equal(second.dispatch.id, first.dispatch.id)
assert.equal(controller.calls.prompt.length, 1, '第二次点击不能再发一条消息')
})
test('投递超时:dispatch 记 unknown,不自动重发', async () => {
const { store, service, controller, dispatch, projectId } = freshWorkbench({ promptFails: 'timeout' })
const task = service.createTask({ projectId, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: 't', objective: 'o' }).task
const result = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k-timeout' })
assert.equal(result.outcome, 'unknown')
assert.equal(store.getDispatch(result.dispatch.id).state, 'unknown')
assert.equal(store.getAttempt(result.attempt.id).state, 'unknown')
assert.equal(controller.calls.prompt.length, 1)
// 再点一次同一幂等键:仍是 unknown,不会再发第二遍
const again = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k-timeout' })
assert.equal(again.duplicate, true)
assert.equal(controller.calls.prompt.length, 1)
// 查证:会话确实存在 → 收口为 accepted
const verified = await dispatch.verifyUnknown(result.dispatch.id)
assert.equal(verified.outcome, 'accepted')
assert.equal(store.getAttempt(result.attempt.id).state, 'running')
})
test('部门未接通时派发被拒,任务留在账上而不是变成失败', async () => {
const { store, service, dispatch, projectId } = freshWorkbench()
// 户部没有接通会话:只能先存草稿,入队会被明确拒绝(派给没会话的部门只会在投递阶段撞 unknown)。
const task = service.createTask({ projectId, ownerRoleId: 'hubu', sourceRoleId: 'lead', title: 't', objective: 'o', status: 'draft' }).task
await assert.rejects(
() => dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k' }),
(error) => error.code === 'INVALID_STATE',
)
assert.equal(store.getTask(task.id).status, 'draft', '被拒的派发不改任务状态')
})
// ---------- 对账 ----------
test('对账:宿主还在跑只推进 running,不判完成', async () => {
const { store, service, dispatch, reconciler, projectId } = freshWorkbench({ staysRunning: true })
const task = service.createTask({ projectId, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: 't', objective: 'o' }).task
const result = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k' })
const outcome = await reconciler.reconcileOnce()
assert.equal(outcome.checked >= 1, true)
assert.equal(store.getTask(task.id).status, 'running', '还在跑就不是完成')
assert.equal(store.getAttempt(result.attempt.id).state, 'running')
})
test('对账:运行结束但无报告 → needs_attention,而不是 completed', async () => {
const { store, service, controller, dispatch, reconciler, projectId } = freshWorkbench()
const task = service.createTask({ projectId, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: 't', objective: 'o' }).task
const result = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k' })
controller.sessions.get('ses_gongbu').running = false
await reconciler.reconcileOnce()
assert.equal(store.getAttempt(result.attempt.id).state, 'succeeded')
assert.equal(store.getTask(task.id).status, 'needs_attention')
assert.match(store.getTask(task.id).needsAttentionReason, /结构化报告/)
})
test('对账:取消请求后宿主停跑 → attempt cancelled、任务 cancelled', async () => {
const { store, service, controller, dispatch, reconciler, sessions, projectId } = freshWorkbench()
const task = service.createTask({ projectId, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: 't', objective: 'o' }).task
const result = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k' })
// 只发停止请求:cancel() 是同步 accepted,不等于已停,此时尝试仍停在 running。
sessions.requestCancel('ses_gongbu')
controller.sessions.get('ses_gongbu').running = false
await reconciler.reconcileOnce()
assert.equal(store.getAttempt(result.attempt.id).state, 'cancelled')
assert.equal(store.getTask(task.id).status, 'cancelled')
})
test('对账:宿主重启后查不到会话时不猜,保持原状', async () => {
const { store, service, controller, dispatch, reconciler, projectId } = freshWorkbench()
const task = service.createTask({ projectId, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: 't', objective: 'o' }).task
const result = await dispatch.dispatch({ projectId, taskId: task.id, idempotencyKey: 'k' })
// 让 list 抛错:问不到 = null
controller.list = async () => {
throw new Error('host restarting')
}
const outcome = await reconciler.reconcileOnce()
assert.equal(outcome.changed.length, 0)
assert.equal(store.getAttempt(result.attempt.id).state, 'running')
})
// ---------- 工作台外壳 ----------
test('工作台外壳:浏览器侧/无会话能力时降级为只读账本', async () => {
const store = new WorkbenchStore({ file: null, clock })
const host = createWorkbenchHost({}, { store })
assert.equal(host.hasSessions, false)
const project = host.service.registerProject({ hostWorkspaceId: WS }).project
const bootstrap = host.bootstrap(project.id)
assert.equal(bootstrap.seats.length, 10)
assert.equal(bootstrap.seats.filter((seat) => seat.connected).length, 0)
assert.equal(bootstrap.seats[0].pendingLabel, '尚未接通')
const dispatched = await host.dispatchTask({ projectId: project.id, taskId: 'task_x', idempotencyKey: 'k' })
assert.equal(dispatched.ok, false)
assert.equal(dispatched.code, 'NO_SESSION_CONTROLLER')
})
test('工作台外壳:接通部门写出绑定,且同一会话不能同时属于两个部门', async () => {
const store = new WorkbenchStore({ file: null, clock })
const controller = fakeController()
const host = createWorkbenchHost({ sessionController: controller }, { store })
const project = host.service.registerProject({ hostWorkspaceId: WS }).project
const gongbu = await host.connectDepartment({ projectId: project.id, roleId: 'gongbu' })
assert.equal(gongbu.created, true)
assert.equal(gongbu.seat.connected, true)
// 把工部已在用的会话硬塞给户部:store 必须拒绝(会话独占)
await assert.rejects(
() => host.connectDepartment({ projectId: project.id, roleId: 'hubu', sessionId: gongbu.sessionId }),
(error) => error.code === 'SESSION_CONFLICT',
)
const seats = host.bootstrap(project.id).seats
assert.equal(seats.find((seat) => seat.roleId === 'gongbu').connected, true)
assert.equal(seats.find((seat) => seat.roleId === 'hubu').connected, false)
})
test('工作台外壳:ingestAgentOutput 只应用可解析的契约行', () => {
const store = new WorkbenchStore({ file: null, clock })
const host = createWorkbenchHost({}, { store })
const project = host.service.registerProject({ hostWorkspaceId: WS }).project
// 无会话能力的外壳里工部未接通,只能建草稿;这里要验的是契约解析,不是入队资格。
const task = host.service.createTask({ projectId: project.id, ownerRoleId: 'gongbu', sourceRoleId: 'lead', title: 't', objective: 'o', status: 'draft' }).task
// 草稿要先入队,才谈得上 waiting_input。
store.updateTask({ ...store.getTask(task.id), status: 'queued' })
const text = [
'正文里说一句“已完成”,不算数。',
`${CONTRACT_ACTION_PREFIX}${JSON.stringify({ action: 'requestTaskInput', taskId: task.id, reason: '缺口径' })}`,
].join('\n')
const out = host.ingestAgentOutput({ projectId: project.id, roleId: 'gongbu', text })
assert.equal(out.applied.length, 1)
assert.equal(out.failed.length, 0)
assert.equal(store.getTask(task.id).status, 'waiting_input')
})
test('工作台外壳:sessionController 晚到后仍能补挂会话层(不必多重启一次)', async () => {
const store = new WorkbenchStore({ file: null, clock })
// 模拟 apply 那一刻宿主还没装好 sessionController。
const host = createWorkbenchHost({}, { store })
const project = host.service.registerProject({ hostWorkspaceId: WS }).project
assert.equal(host.hasSessions, false)
const refused = await host.dispatchTask({ projectId: project.id, taskId: 'task_x', idempotencyKey: 'k1', sourceRoleId: 'lead', targetRoleId: 'gongbu', targetSessionId: 'ses_gongbu', bindingGeneration: 0 })
assert.equal(refused.ok, false)
assert.equal(refused.code, 'NO_SESSION_CONTROLLER')
// 宿主稍后把会话控制器交过来:同一实例直接挂上,不需要重建工作台。
const controller = fakeController()
assert.equal(host.attachSessions(controller), true)
assert.equal(host.hasSessions, true)
assert.notEqual(host.sessions, null)
assert.notEqual(host.dispatchService, null)
assert.notEqual(host.reconciler, null)
// 重复挂载必须幂等:不能把已有会话层换掉。
const first = host.sessions
assert.equal(host.attachSessions(fakeController()), true)
assert.equal(host.sessions, first)
// 挂上之后「接通部门」才真正建会话并登记到账本。
const connected = await host.connectDepartment({ projectId: project.id, roleId: 'gongbu' })
assert.equal(connected.sessionId, 'ses_gongbu'.replace('ses_gongbu', connected.sessionId))
assert.equal(store.getBinding(project.id, 'gongbu').currentSessionId, connected.sessionId)
})

View File

@ -1,58 +0,0 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import {
createIdFactory,
ID_ENTITIES,
ID_PREFIXES,
cryptoRandom,
isIdOf,
newId,
} from '../core/ids.mjs'
test('every entity prefix appears in the plan and generated ids round-trip', () => {
for (const entity of ID_ENTITIES) {
const id = newId(entity, { random: () => 0 })
assert.match(id, new RegExp(`^${ID_PREFIXES[entity]}_[0-9a-z]{12}$`), `${entity} 前缀正确`)
assert.equal(isIdOf(entity, id), true)
}
// 前缀本身也能直接使用,方便调用方不想记实体名的场景。
assert.match(newId('task', { random: () => 3 }), /^task_3{12}$/)
})
test('prefixes stay unique so ids cannot be confused across entities', () => {
const prefixes = Object.values(ID_PREFIXES)
assert.equal(new Set(prefixes).size, prefixes.length)
assert.deepEqual(prefixes.slice(0, 3), ['proj', 'bind', 'cfg'])
})
test('injected random source makes ids reproducible', () => {
const seq = (limit) => {
let index = 0
return () => index++ % limit
}
assert.equal(newId('project', { random: seq(36), length: 6 }), 'proj_012345')
const a = createIdFactory({ random: () => 1, length: 4 })
const b = createIdFactory({ random: () => 1, length: 4 })
for (const entity of ID_ENTITIES) {
assert.equal(a[entity](), b[entity]())
assert.match(a[entity](), new RegExp(`^${ID_PREFIXES[entity]}_`))
}
})
test('character alphabet values are accepted and unknown prefixes rejected', () => {
assert.equal(newId('result', { random: (i) => ['a', 'b', 'c', 'd'][i], length: 4 }), 'res_abcd')
assert.throws(() => newId('nope', { random: () => 0 }), /未知 ID 前缀/)
assert.throws(() => newId('task', { random: () => 'Z', length: 4 }), /字母表外/)
assert.throws(() => newId('task', { random: () => 1.5, length: 4 }), /整数/)
assert.throws(() => newId('task', { random: () => 0, length: 2 }), /4..64/)
assert.equal(isIdOf('task', 'dsp_abc'), false)
assert.equal(isIdOf('task', 'task_'), false)
assert.equal(isIdOf('task', undefined), false)
})
test('default crypto source produces distinct ids', () => {
if (typeof globalThis.crypto?.getRandomValues !== 'function') return
assert.match(cryptoRandom(), /^[0-9a-z]$/)
const ids = new Set(Array.from({ length: 50 }, () => newId('task')))
assert.ok(ids.size >= 45, '随机 ID 冲突率应很低')
})

Some files were not shown because too many files have changed in this diff Show More