Compare commits

...

71 Commits

Author SHA1 Message Date
QQ 832e265038 Merge pull request 'fix: 稳定朝堂入口、工作区项目识别与项目隔离' (#1) from fix/workbench-entry-project-isolation into master 2026-11-12 21:03:27 +08:00
newbie efc4a32c75 fix: stabilize workbench entry, project identity and session subscriptions 2026-11-12 18:52:15 +08:00
QQ 257c47f78c Import workbench/panel/lib/client.js 2026-11-12 15:42:30 +08:00
QQ 0cd0aea49d Import package.json 2026-11-12 15:41:41 +08:00
QQ 8f158c5028 更新 workbench/panel/lib/client.js 2026-11-12 14:21:56 +08:00
QQ a194838211 更新 package.json 2026-11-12 14:21:51 +08:00
QQ 297a2ee915 更新 CHANGELOG.md 2026-11-12 14:21:46 +08:00
QQ 1d8b496866 更新 workbench/panel/lib/client.js 2026-11-12 14:16:54 +08:00
QQ 3ffa57dbf4 更新 package.json 2026-11-12 14:16:49 +08:00
QQ 14a1f5c68c 更新 CHANGELOG.md 2026-11-12 14:16:47 +08:00
QQ 9855b03555 更新 workbench/panel/test/client.test.mjs 2026-11-12 13:28:55 +08:00
QQ 1aad975955 更新 workbench/panel/package.json 2026-11-12 13:28:51 +08:00
QQ ef7a2f9604 更新 workbench/panel/lib/client.js 2026-11-12 13:28:47 +08:00
QQ 4235f31368 更新 package.json 2026-11-12 13:28:42 +08:00
QQ 4e077fd6f3 更新 CHANGELOG.md 2026-11-12 13:28:38 +08:00
QQ 9fa80ac7d5 Import workbench/panel/package.json 2026-11-12 10:58:44 +08:00
QQ 4feab4d632 Import workbench/panel/index.js 2026-11-12 10:58:39 +08:00
QQ d3ed94d03d Import workbench/panel/cordis.patch.yml 2026-11-12 10:58:36 +08:00
QQ e7fd451227 Import package.json 2026-11-12 10:58:10 +08:00
QQ 2839f9873a Import cordis.patch.yml 2026-11-12 10:57:17 +08:00
QQ e7c63439d6 Import TODO.md 2026-11-12 10:57:13 +08:00
QQ 126f97e808 更新 TODO.md 2026-11-10 23:06:05 +08:00
QQ 935053a9ca 更新 TODO.md 2026-11-10 22:55:06 +08:00
QQ e46fd57599 package.json 2026-11-10 22:37:04 +08:00
QQ 56ec629134 index.js 2026-11-10 22:36:59 +08:00
QQ 2c0f507ba1 cordis.patch.yml 2026-11-10 22:36:56 +08:00
QQ fda101736f CHANGELOG.md 2026-11-10 22:36:52 +08:00
QQ ed31d3c5d7 0.11.0 退役老预设线:workbench/test/memory.test.mjs 2026-11-10 22:25:27 +08:00
QQ 6212092172 0.11.0 退役老预设线:workbench/host/service.mjs 2026-11-10 22:25:23 +08:00
QQ e42896c9c5 0.11.0 退役老预设线:workbench/host/routes.mjs 2026-11-10 22:25:18 +08:00
QQ f15e7d112c 0.11.0 退役老预设线:workbench/core/memory.mjs 2026-11-10 22:25:14 +08:00
QQ d1d0529e0c 0.11.0 退役老预设线:package.json 2026-11-10 22:25:10 +08:00
QQ 7b6e301697 0.11.0 退役老预设线:docs/记忆设计.md 2026-11-10 22:25:07 +08:00
QQ 8c05acf6b4 0.11.0 退役老预设线:README.md 2026-11-10 22:24:31 +08:00
QQ 9c83e19ec4 0.11.0 退役老预设线:CHANGELOG.md 2026-11-10 22:24:22 +08:00
QQ 04fb4f2d8b 0.11.0 退役老预设线:删除 test/policy.test.js 2026-11-10 22:13:37 +08:00
QQ 7a49e4b541 0.11.0 退役老预设线:删除 scripts/preview.mjs 2026-11-10 22:13:30 +08:00
QQ 1139dfd735 0.11.0 退役老预设线:删除 scripts/mode.mjs 2026-11-10 22:13:25 +08:00
QQ 568f1d8e43 0.11.0 退役老预设线:删除 scripts/check-install.mjs 2026-11-10 22:13:21 +08:00
QQ f941429f69 0.11.0 退役老预设线:删除 preset.patch.yml 2026-11-10 22:13:18 +08:00
QQ 834683a7ba 0.11.0 退役老预设线:删除 panel/test/client.test.js 2026-11-10 22:13:05 +08:00
QQ 79f5156c72 0.11.0 退役老预设线:删除 panel/package.json 2026-11-10 22:12:58 +08:00
QQ 99121d7d54 0.11.0 退役老预设线:删除 panel/lib/model.js 2026-11-10 22:12:55 +08:00
QQ c5ee75988e 0.11.0 退役老预设线:删除 panel/lib/client.js 2026-11-10 22:12:50 +08:00
QQ 5fe1d5e4c8 0.11.0 退役老预设线:删除 panel/index.js 2026-11-10 22:12:43 +08:00
QQ a6801c95f3 0.11.0 退役老预设线:删除 panel/cordis.patch.yml 2026-11-10 22:12:38 +08:00
QQ 017a3acb19 0.11.0 退役老预设线:删除 panel/README.md 2026-11-10 22:12:33 +08:00
QQ badcc35c5a 0.11.0 退役老预设线:package.json 2026-11-10 22:12:30 +08:00
QQ 3976930c3d 0.11.0 退役老预设线:删除 locale/zh.json 2026-11-10 22:12:27 +08:00
QQ d23be0a6a2 0.11.0 退役老预设线:删除 locale/en.json 2026-11-10 22:12:23 +08:00
QQ 96f6221891 0.11.0 退役老预设线:index.js 2026-11-10 22:12:20 +08:00
QQ 899fcec590 0.11.0 退役老预设线:TODO.md 2026-11-10 22:12:17 +08:00
QQ 077aeb651d 0.11.0 退役老预设线:README.md 2026-11-10 22:12:13 +08:00
QQ 4400e9dca6 0.11.0 退役老预设线:CHANGELOG.md 2026-11-10 22:12:09 +08:00
QQ bd75d8186e feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:51:06 +08:00
QQ 48478d9e55 feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:51:02 +08:00
QQ ade684b6e6 feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:51:00 +08:00
QQ 003d52941d feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:46 +08:00
QQ 7e9fc669d6 feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:42 +08:00
QQ 585f4cda3b feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:39 +08:00
QQ 05795c4d69 feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:35 +08:00
QQ a475b28a0f feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:32 +08:00
QQ 611fd4c3e1 feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:25 +08:00
QQ dc4c1abe6f feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:20 +08:00
QQ 0aaf54c471 feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:17 +08:00
QQ 96bb4eb682 feat(workbench): 分层记忆——长期记忆+项目记忆,派发注入与成果自动记账(0.10.0) 2026-11-10 21:50:13 +08:00
QQ b9a1fb71fa docs(todo): DS Bot 适配方向已否决,记录实测冲突依据(M-02/M-03) 2026-11-10 21:20:02 +08:00
QQ 6b557f8cf2 feat(policy): 未分类工具默认拦截,问清只读还是改动、登记后才放行(POLICY_VERSION 0.5.0) 2026-11-10 21:09:19 +08:00
QQ 6edacc3065 feat(policy): 未分类工具默认拦截,问清只读还是改动、登记后才放行(POLICY_VERSION 0.5.0) 2026-11-10 21:08:56 +08:00
QQ 646f33589c fix(workbench): Windows 风格 DSH_HOME 在 POSIX 上按 Windows 语义拼账本路径 2026-11-10 21:05:28 +08:00
QQ 6f660ff2b4 fix(workbench): Windows 风格 DSH_HOME 在 POSIX 上按 Windows 语义拼账本路径 2026-11-10 21:05:08 +08:00
43 changed files with 1580 additions and 6036 deletions

View File

@ -1,6 +1,70 @@
# Changelog
> 版本号以 `package.json` 为准(当前 0.9.2)。更早的 0.6.x 条目沿用旧编号,保留作历史。
> 版本号以 `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 — 模型设置这次真的会落到部门身上

103
README.md
View File

@ -1,78 +1,55 @@
# 「上朝」DSH 多 Agent 模式
# 三省六部工作台
面向 DeepSeek Harness Web GUI 的 Agent Preset,mode id 保持 `sansheng-liubu`。
给 DeepSeek Harness(DSH)用的多角色工作台:丞相、三省、六部共十席,
每一席都是一个**独立会话**(不是谁的子 agent),身份由程序按
「项目 + 席位」的绑定注入,项目之间互不串扰。
**本插件默认不开启。** 装上它不会往 DSH 的模式选择器里塞「上朝」,也不会成为新会话的默认模式。只有你按下面步骤显式启用、并在新建会话时主动选中「上朝」,这套流程才开始运行。
## 它怎么运转
启用之后,尚未加入 Agent Team 的默认主 Agent 会自动担任丞相(Lead),你可以直接与丞相对话,其余部门由丞相按流程创建。
- **账本**:项目、任务、派工、成果都记在一本账本里
(`~/.dsh/sansheng-liubu/workbench.json`),聊天原文不复制,
留在各席位自己的会话里。
- **派工**:在工作台里选项目、选席位、写任务单,程序把材料直接
投递到那个席位的会话;投递以请求号防重复,结果回来自动对账。
- **模型**:每个席位可以单独选模型,存在账本与会话绑定里,
不借别的会话、不靠猜。
- **记忆**:三层 Markdown 记忆,派工时自动带上相关片段——
部门记忆(每个部门一份、跨项目,`memory/departments/<部门>.md`)、
项目记忆(按项目隔离,`memory/projects/<项目>.md`)与长期记忆
(跨项目,`memory/long-term.md`),都是纯文本,可以直接打开改。
设计说明见 `docs/记忆设计.md`。
## 启用方式(选了才生效)
## 安装与启用
```powershell
node scripts/mode.mjs status # 现在开没开
node scripts/mode.mjs on # 让「上朝」出现在模式选择器里
node scripts/mode.mjs off # 彻底移除这个选项
本包只发布一条:`dsh-sansheng-liubu-mode`。朝堂面板已并回主包,**不要**
再单独安装 `dsh-sansheng-liubu-workbench`;旧脚本 `workbench-install.mjs`
现在只打印迁移说明,不会再改任何 profile 文件。
```sh
node scripts/workbench-preflight.mjs # 严格只读自检:入口、bundle 语法、路由、账本可写
```
`on` 只是把 [preset.patch.yml](preset.patch.yml) 里那段 insert 写入 `~/.dsh/profiles/desktop/cordis.patch.yml`(带标记,可原样撤回),**不会**替你选中它。执行后彻底重启 DSH,新建会话时在模式选择器里主动选「上朝」,这套流程才启动;不选就一直是普通模式。
`off` 把那段 insert 整段删掉,文件回到原样;已存在的会话仍保留它自己的模式记录,不会被切成别的模式。
包自带的 [cordis.patch.yml](cordis.patch.yml) 是空层(`[]`),这是刻意的——装包本身不产生任何行为。想手工合并也可以,规则同上:顶层保持数组,删掉 `[]` 再接那段 insert。
若重启后模式选择器里看不到「上朝」,把 `dsh-sansheng-liubu-mode` 也加进 `~/.dsh/profiles/desktop/package.json` 的 `dsh.profile.bundles` 再重启——预设按包名解析那支策略插件,个别部署要求它显式列出。这条不影响「默认关闭」:加进 bundles 只是让插件可加载,策略仍只在会话 preset 为 `sansheng-liubu` 时才生效。
## 部门职责
- `lead`(丞相):统筹、决策、组队与管理型工具;调用须留痕。
- `zhongshu`(中书省):调查与规划,只读。
- `menxia`(门下省):准奏、封驳、验收与查账,只读。
- `shangshu`(尚书省):任务依赖和分工调度,只读。
- `libu`(吏部):Agent 与技能维护、成员编制与角色配置;只动技能、角色与配置文档,不开命令行。
- `hubu`(户部):数据、表格与计算;依据真实数据给出可复算的结论,不补造数据。
- `lipu`(礼部):文档、汇报、文案润色与可视化产出。
- `bingbu`(兵部):环境运行、调试与部署,以及工具装配、发放、回收、登记、销账;只发不批。
- `xingbu`(刑部):按风险开展的专项测试与独立验证;只跑不部署,不替代门下审议。
- `gongbu`(工部/图像司):编码与工程实现;识图、OCR、截图与视觉分析;通过 `dsh-image-gen` 执行生图、批量生图和图片编辑。
执行部门常备 `read`、`write`、`edit`、`bash`、`grep`、`glob` 等工具;规划/审议部门保持只读。
## Image-gen 接管
上朝插件不再自行注册图片工具或读取图片 Provider 凭据,而是复用已安装的 `dsh-image-gen`:
- `generate_image`:单张生图;
- `generate_images`:批量生图;
- `edit_image`:参考图与连续编辑。
三项工具只允许工部在已准奏且处于执行中的任务里调用。Provider、模型、API Key、Base URL、订阅登录、计费和结果保存均由 Image-gen 配置管理。`image_generate` 与 `codex_image_generate` 继续被上朝策略拒绝。
请在“插件 → 已安装 → dsh-image-gen”中配置并测试 Provider。修改插件配置或本模式后需彻底重启 DSH。
## 工具审核则例
1. 部门申请工具须写明用途、范围、期限;门下准奏后由兵部发放,限期使用,到期回收销账。
2. 只读工具由门下专决;写入须注明 writeScopes;涉费、删除、全局配置须人工签字。
3. `task_board_*`、`automation_*` 归丞相执掌并留痕;部门调用管理型工具须持门下准奏记录。
4. 门下验收查账;越界者下次从严;工具不得转借。
安装、修复与迁移是独立授权操作;自检不会创建、覆盖或迁移用户文件。
改完安装后要**彻底退出并重启 DSH** 才生效。
## 验证
```powershell
node --check index.js
node --test --test-isolation=none test/policy.test.js panel/test/client.test.js
node scripts/check-install.mjs
```sh
npm test # 工作台全量单测
node scripts/workbench-preflight.mjs # 装配与安装状态预检
```
`check-install.mjs` 会确认三件事:包自带 patch 是空层(不注册预设)、`preset.patch.yml` 能复现出同一个 preset id、以及你的 profile 当前到底有没有启用「上朝」(输出里的 `modeEnabled`)。
真机验收矩阵在 `docs/v0.1-验收记录.md`,标「待真机」的条目
只能在装了 DSH 的机器上验。
## 回滚
## 0.11.0 退役说明
版本历史统一走 Git,不建备份目录、不留时间戳副本:
老预设线已整体退役:不再有「上朝」模式、基于 Team 成员身份的
政策插件(工具守卫、按部门改模型)、朝堂侧栏与组建朝班流程。
根目录 `index.js` 现在只负责在应用根上启动工作台宿主。
```powershell
git log --oneline # 找目标提交
git revert <sha> # 或 git reset --hard <sha>
```
回滚后重启 DSH。mode id 与 preset id 不变。
升级注意:如果你的 DSH 配置文件 `cordis.patch.yml` 里还留着
以前写入的上朝预设段,请把它删掉再重启;如果 profile 里还登记了
`dsh-sansheng-liubu-workbench`,也一并移除(面板已并回本包)。本包的包名
保持 `dsh-sansheng-liubu-mode` 不变,只是为了既有 bundle 登记继续有效,
它不再提供任何模式。

50
TODO.md
View File

@ -1,22 +1,26 @@
# 三省六部开发 TODO
更新日期:2026-11-07
更新日期: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 用户确认)
## v1.0 优先级与后续 DS Bot 适配(2026-11-07 用户确认;2026-11-10 已否决)
当前优先顺序:先完成三省六部 v1.0 并验证可用,再开展 DS Bot 适配。本节更新版本推进顺序;上文 v0.1 与首次提交条目保留为历史规划,不代表当前仓库尚无实现或提交。本次仅记录待办,不代表 v1.0 或适配已经完成。
**结论(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 单测通过宣称可用。
- [ ] v1.0 完成后评估并适配 DS Bot,借鉴长期 Bot、主 Bot/群聊管理、直接投递与派活、分阶段 Goal、分层记忆、独立模型配置、权限与审批机制。
- 已否决(2026-11-10):「v1.0 完成后评估并适配 DS Bot」作废;长期 Bot、主 Bot/群聊管理、分阶段 Goal、分层记忆等机制仅作参考阅读。
- [ ] 适配前核对 DS Bot 的实际接口、宿主版本兼容性、数据与会话隔离、许可证及维护状态,固定验证版本;文档所述能力不等于已经在本机验证。
- [ ] 优先评估配置、角色模板、Skill 或薄插件的复用方式;是否采用其运行时、是否需要 fork,待验证后决定,不把此前助手提出的迁移建议当作用户已确认方案。
- [ ] 适配保留三省六部的用户授权、拟案/审议/调度分工、按需召集与定向修改机制;当前不因借鉴 DS Bot 而替换现有实现或扩大 v1.0 范围。
@ -28,12 +32,29 @@
以下角色与模型的搭配均为推荐候选,不代表用户已确认绑定;具体默认模型须后续选定。用户明确偏好尽量不用 Claude。
- [ ] 尽量不用 Claude,不列入默认模型,也不因困难自动切换到 Claude。
- [ ] 中书省优先 GPT 系列,具体型号依据实际可用 API、规划质量与工具调用能力选择。
- [ ] 门下省优先 Kimi 系列,具体型号依据审核能力和实际通道选择;需检查页面图像时核实图片输入支持。
- [ ] 礼部优先支持图像输入的 Flash 模型,用户提出 MiMo Flash 或其他视觉 Flash 作为候选。不能仅凭 Flash 名称假定支持图像,接入前验证具体型号、API 图片传递和页面理解能力。
- [ ] 尽量不用 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。
## 面板与基础接口
@ -146,3 +167,14 @@
- 执行前依赖检查: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,8 +1,12 @@
# 三省六部模式:默认不注册任何东西。
# 三省六部工作台 · 宿主包补丁层
#
# 装上本包不会往 DSH 的模式选择器里塞「上朝」,也不会成为新会话的默认模式——
# 想上朝时,把 preset.patch.yml 里的 insert 合并进
# ~/.dsh/profiles/desktop/cordis.patch.yml
# 再彻底重启 DSH,新会话才能在模式选择器里看到并选择「上朝」。
# 想退出:删掉那段 insert,重启即可;已存在的会话仍保留它自己的模式记录。
[]
# 一行 insert 把宿主入口(index.js)挂进应用:账本、HTTP 接口、会话
# 装配与三层记忆都在 workbench/host 里。0.11.0–0.12.1 期间本文件是
# 空层([]),以为 bundle 加载会自动带起宿主入口——实际不会:没有
# insert 行,宿主插件根本不被应用,从商店单独安装时工作台后端不
# 启动(接口 404)。0.12.2 起补上这一行,与其它插件包同一装法。
# 老预设线(上朝模式/朝堂侧栏)仍保持退役,本层不恢复任何预设。
- insert:
- id: dsh-sansheng-liubu-mode
name: 'dsh-sansheng-liubu-mode'
config: {}

View File

@ -70,8 +70,8 @@
| 现象 | 处理 |
| --- | --- |
| 中央区白屏或样式崩了 | 控制台执行 `localStorage['sansheng.workbench.main']='off'`,刷新。接管被整个跳过,原生聊天照旧 |
| 右栏不出现 | `node scripts/workbench-preflight.mjs` 看 7 项自检;再确认重启是**彻底退出**而不是关窗口 |
| 右栏不出现 | `node scripts/workbench-preflight.mjs` 看 5 项自检;再确认重启是**彻底退出**而不是关窗口 |
| 派工后一直「已备好」 | 宿主没接上会话层:重启获取一次;右栏会提示「已记入台账,但暂时没有真的发出」 |
| 完全不想用了 | `node scripts/workbench-install.mjs off` 再重启 |
| 完全不想用了 | 从 profile 移除 `dsh-sansheng-liubu-mode` 后重启(独立 workbench 包已退役) |
账本在 `%USERPROFILE%\.dsh\sansheng-liubu\workbench.json`。它是唯一事实来源,删掉等于清空工作台;Git 回退代码不会回退它。

View File

@ -90,22 +90,20 @@ node --test --test-isolation=none test/policy.test.js workbench/test/*.test.mjs
## 3. 复现步骤(真机部分)
1. 安装前端 bundle(已执行过一次,幂等):
1. 确认主包已安装(朝堂面板已并回 `dsh-sansheng-liubu-mode`,不再有独立 workbench 包):
```bash
node scripts/workbench-install.mjs on # 写进 profile 的 dependencies + dsh.profile.bundles + node_modules junction
node scripts/workbench-install.mjs status # 期望 installed=true, targetExists=true
node scripts/workbench-preflight.mjs # 期望 7/7 通过:链接、入口、bundle 语法、12 条路由、账本可写
node scripts/workbench-preflight.mjs # 期望 5/5 通过:入口、bundle 语法、16 条路由、账本可写
```
> `workbench-preflight.mjs` 是只读自检:不装、不改配置,只回答「重启后会不会白屏 / 路由起不起得来」。
> 它会真的创建 `%DSH_HOME%\sansheng-liubu` 目录(插件运行时本来也会建),除此之外不写任何东西。
> `workbench-preflight.mjs` 是严格只读自检:不装、不改配置、不创建文件,只回答「重启后会不会白屏 / 路由起不起得来」。
> 安装、修复与迁移是另外的显式操作;旧 `workbench-install.mjs` 现在只打印迁移说明。
2. **彻底退出 DSH 再启动**(托盘退出,不是关窗口);只对新会话生效。
3. 打开任意项目会话,右侧应出现「朝堂 / 任务 / 成果」。
4. 依次验:接通一个部门 → 派一条任务 → 完成 → 在成果区点「找主责部门修改」。
5. 白屏逃生:控制台 `localStorage['sansheng.workbench.main']='off'` 后刷新,接管会被跳过。
6. 完全回退:`node scripts/workbench-install.mjs off` 再重启。
6. 完全回退:从 profile 移除 `dsh-sansheng-liubu-mode` 后重启(旧独立 workbench 包已退役,不要安装)。
---

46
docs/记忆设计.md Normal file
View File

@ -0,0 +1,46 @@
# 三省六部记忆设计(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 只有确定性记账,不引入额外模型调用。

480
index.js
View File

@ -1,455 +1,59 @@
import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { createWorkbenchHost, resolveStorePath } from './workbench/host/index.mjs'
// 三省六部工作台 · 宿主入口。
//
// 0.11.0 起老预设线退役:不再有「上朝」模式、Team 政策插件与朝堂侧栏。
// 本入口只做一件事——在应用根上把工作台宿主拉起来(账本、HTTP 接口、
// 会话装配、记忆都在 workbench/host 里),插件卸载时把它停掉。
// 工作台宿主自身对缺失能力一律降级并给出 warnings,所以这里不预检、
// 不抛错:工作台起不来不该拖垮整个应用。
//
// 防重复启动:宿主只该有一份。若本插件被重复应用(例如旧预设段还留在
// profile 里、按会话重复挂载),后来的应用只增加引用计数,不再另起一份
// 宿主——两份宿主会重复注册路由、双写同一本账本。用 Symbol.for 注册到
// globalThis,是为了连「包被复制成两份、模块身份不同」的情况也拦得住。
const PRESET_ID = 'sansheng-liubu'
export const POLICY_VERSION = '0.4.0'
import { createWorkbenchHost } from './workbench/host/index.mjs'
/**
* 默认不强制任何 provider/model:宿主未必注册了这些适配器,强行指定会让整轮请求
* 以 NO_ADAPTER 失败(例如 "no adapter registered for provider xiaomi")。
* 角色模型改由面板里的「联动模型」按当前宿主目录选择,或在 preset 配置里显式给 routes。
*/
export const DEFAULT_ROUTES = Object.freeze({})
export const name = 'sansheng-liubu-workbench-host'
/** 三省六部:丞相 1 + 三省 3 + 六部 6 = 10 席;六部为吏、户、礼、兵、刑、工。 */
export const COURT_ROLES = Object.freeze([
'lead', 'zhongshu', 'menxia', 'shangshu',
'libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu',
])
const KNOWN_ROLES = new Set(['zhongshu', 'menxia', 'shangshu', 'libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'])
const READ_ONLY_ROLES = new Set(['lead', 'zhongshu', 'menxia', 'shangshu', 'minister'])
const EXECUTION_ROLES = new Set(['libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'])
const IMAGE_TOOLS = new Set(['generate_image', 'generate_images', 'edit_image'])
const FORBIDDEN_IMAGE_TOOLS = new Set(['image_generate', 'codex_image_generate'])
export const READ_ONLY_TOOLSET = Object.freeze(['read', 'grep', 'glob'])
export const EXECUTION_TOOLSET = Object.freeze(['read', 'write', 'edit', 'bash', 'pwsh', 'grep', 'glob'])
const BOOT_KEY = Symbol.for('sansheng-liubu.workbench-host')
const MANAGEMENT_TOOL_PREFIXES = Object.freeze(['task_board_', 'automation_'])
const OTHER_MANAGEMENT_TOOLS = new Set(['create_skill', 'plugin_manager'])
const HUMAN_SIGNATURE_TOOLS = new Set([
'create_skill', 'plugin_manager', 'remote_ssh_delete', 'automation_delete',
])
const MUTATING_TOOLS = new Set([
'write', 'edit', 'pwsh', 'bash',
'remote_ssh_write', 'remote_ssh_mkdir', 'remote_ssh_exec',
'ws_mcp_call', ...IMAGE_TOOLS,
])
/**
* 六部各自可改什么,按职责划线,不互相借用:
* - 吏部:技能与角色文件(.md/.json/.yml 等),不开命令行,避免改代码或环境。
* - 户部:数据文件(xlsx/csv/parquet 等);重算与渲染交 Office/Univer 工具,故不开命令行。
* - 礼部:文档、汇报与截图等材料产出。
* - 兵部:跑命令、定位问题,另含远程与 MCP 通道。
* - 刑部:测试与专项验证,只跑不部署;远程命令会绕过风险分级,因此不给。
* - 工部:代码实现,含 Image-gen 生图。
*/
const ROLE_ALLOWED_MUTATIONS = Object.freeze({
libu: new Set(['write', 'edit']),
hubu: new Set(['write', 'edit']),
lipu: new Set(['write', 'edit', 'pwsh', 'bash']),
bingbu: new Set([
'write', 'edit', 'pwsh', 'bash',
'remote_ssh_write', 'remote_ssh_mkdir', 'remote_ssh_exec', 'ws_mcp_call',
]),
xingbu: new Set(['write', 'edit', 'pwsh', 'bash']),
gongbu: new Set(['write', 'edit', 'pwsh', 'bash', ...IMAGE_TOOLS]),
})
const TOOL_GOVERNANCE = `## 工具开放审核则例
一、凡部门需用工具,须奏明用途、范围、期限,经门下省审核,准奏后由兵部发放,限期使用,到期收回销账。
二、只读之具,门下可专决;改易文件者,须注明写入范围;涉费、删除、全局配置者,须人工签字。
三、兵部掌武库:工具装配、发放、回收、登记,只发不批;管理型工具(task_board_*、automation_*)与付费开关归丞相执掌,用时留痕;执行部门常备文件读写、命令行、测试之具。
四、门下验收查账,越界者下次从严;所授之具不得转借。`
const LEAD_PROMPT = `# 三省六部模式:丞相
你是本会话的丞相,也是 Agent Team Lead。你直接面向用户,负责定策、组队、监督制度执行与最终回奏;不要亲自修改文件。
## 固定组织(三省六部十席)
- zhongshu(中书省):调查现状、澄清需求、起草方案,只读。
- menxia(门下省):独立审议、准奏或封驳,并在执行后验收,只读。
- shangshu(尚书省):把批准方案转成任务依赖、按吏户礼兵刑工六部分工,只读。
- libu(吏部):Agent 与技能维护,只动技能、角色与配置文档。
- hubu(户部):数据、表格与计算,负责真实数据与可复算的结论。
- lipu(礼部):文档、汇报与可视化产出。
- bingbu(兵部):环境运行、调试与部署,掌工具装配、发放、回收、登记与销账,只发不批。
- xingbu(刑部):按风险做专项测试与独立验证,只跑不部署。
- gongbu(工部):编码与工程实现,负责落盘改动、构建与安装脚本。
## 强制流程
1. 对实质性任务,先创建 zhongshu、menxia、shangshu;成员名必须完全使用上述英文 id。
2. 在共享任务板建立“中书拟案”→“门下审议”→“尚书派工”→执行任务→“尚书合成”→“门下审核”的依赖链。
3. 中书提交可执行方案和验收标准;门下只能输出准奏或封驳,封驳必须给出阻塞问题;审议默认一轮。
4. 门下准奏前不得进入执行。准奏后先向用户回奏「方案 + 审议结论 + 拟派分工」,取得用户明确确认(“准奏”“开始”“可以”等)后,才让尚书派工;六部成员(libu、hubu、lipu、bingbu、xingbu、gongbu)只有 Lead 能创建,且只召集本任务真正用到的部门,不得为凑齐六部而拆分。
5. 每个执行部门必须先领取自己的 in_progress 任务;写入范围写进 writeScopes,依赖必须全部完成;执行完先自检再上缴。
6. 六部完成后由尚书合成一份整体结果,再交门下按验收标准审核;审核失败时,执行部门修复一次,再次失败则如实报告并请求用户决定。
7. 回复用户前必须等待所有必需成员完成,最终使用“丞相回奏”格式汇总方案、审议、执行、验证和风险;若只有部分成果通过,必须附「部分 → 主责部门」清单,写清哪一部门未交付及原因。
${TOOL_GOVERNANCE}
禁止调用 GPT 模型或 codex_image_generate。`
const ROLE_PROMPTS = Object.freeze({
zhongshu: `# 中书省职责
你负责调查、规划和任务拆解。只读,不得修改文件或运行有副作用的命令。先读取实际项目与约束,再产出:目标、非目标、任务 DAG、writeScopes、风险和验收标准。将结果发送给丞相与门下省。收到封驳后只针对阻塞问题修订。\n\n${TOOL_GOVERNANCE}`,
menxia: `# 门下省职责
你是独立审核者,只读,不得替中书改方案或替执行部门实施。审议必须给出 verdict=approve|reject、blockingIssues、risks、acceptanceCriteria。存在阻塞问题必须封驳;准奏时完成“门下审议”任务。执行后查验工具发放、使用、回收与销账记录,并依据验收标准检查证据;验收对象是尚书合成的整体结果,六部须先自检再上缴。\n\n${TOOL_GOVERNANCE}`,
shangshu: `# 尚书省职责
你只负责调度设计,不直接写文件,也不能创建 teammate。把门下批准的方案转成共享任务、依赖、负责人建议和互不重叠的 writeScopes;按吏户礼兵刑工的职责分工,通知丞相创建本任务真正需要的六部成员。跟踪状态、汇总异常,并在所需部门完成或部分完成后合成一份整体结果(含未完成项与主责部门)交门下审核。只调用必要的部门:一个部门能完成的不要拆给多个部门,同类小任务合并派工。\n\n${TOOL_GOVERNANCE}`,
libu: `# 吏部职责
你负责 Agent 与技能维护:技能设计与评估、角色配置与成员编制文档。可用的写入工具限于此范围,不写业务代码、不跑命令行、不改数据。仅当新增或实质改进技能时才安排评测,普通配置修改不启动多代理基准测试;不擅自更换模型或扩大权限。实施前领取自己的任务并确认 blocker 已完成,仅改声明的 writeScopes,完成后提交改动清单与自检结果。\n\n常备工具:write、edit、read、grep、glob。\n\n${TOOL_GOVERNANCE}`,
hubu: `# 户部职责
你负责数据与计算:表格、数据文件、统计与可复算的结论。可用的写入工具只用于数据文件;读取、重算与渲染交宿主提供的 Office / Univer 工具,不跑命令行。依据实际数据选择统计方法,不把表格操作等同于统计验证,不补造数据;无法核实时如实标注未核实。实施前领取自己的任务并确认 blocker 已完成,完成后提交数据来源、口径与复算方式。\n\n常备工具:write、edit、read、grep、glob。\n\n${TOOL_GOVERNANCE}`,
lipu: `# 礼部职责
你负责文档、汇报、文案润色与可视化产出,包括 README、变更记录与演示材料。实施前领取自己的任务并确认所有 blocker 已完成;仅修改声明的 writeScopes。完成后向丞相和门下提交成稿与自检结果。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
bingbu: `# 兵部职责
你负责环境运行、调试与部署,并掌武库:工具装配、发放、回收、登记、销账,只发不批。实施前读取任务、领取任务并确认所有 blocker 已完成;仅修改声明的 writeScopes。先复现再定位,运行适用命令与测试,报告复现步骤、根因、修复文件、测试结果、工具台账和剩余风险。部署发布须在授权范围内。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
xingbu: `# 刑部职责
你负责按风险开展的专项测试与独立验证,不承担门下成品审议,也不部署。采用复现定位与有效测试设计:给出问题位置、证据与影响,不越权修改他部成果;修复由主责部门完成。不是每项任务都必经你手,只在风险需要时受派。实施前领取自己的任务并确认 blocker 已完成;仅修改声明的 writeScopes(测试代码与报告)。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
gongbu: `# 工部职责
你负责代码实现、构建、安装脚本与文件落地。实施前领取自己的任务并确认所有 blocker 已完成;仅修改声明的 writeScopes。先读后改,改完运行适用的构建或测试命令,报告修改文件、执行结果和剩余风险。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
minister: `# 执行成员职责
你是三省六部团队中的临时成员。服从丞相调度,先领取任务并尊重依赖与 writeScopes;不要绕过门下审核。\n\n${TOOL_GOVERNANCE}`,
})
export function roleFromMembership(membership) {
// A normal newly-created preset session has no Agent Team membership yet.
// Treat that primary/default agent as the Chancellor so users converse with
// the Lead immediately, before the Chancellor creates the remaining court.
if (!membership) return 'lead'
if (membership.role === 'lead') return 'lead'
const name = String(membership.name || '').trim().toLowerCase()
return KNOWN_ROLES.has(name) ? name : 'minister'
}
export function routeForRole(role, routes = DEFAULT_ROUTES) {
if (!routes) return undefined
return routes[role] ?? routes.minister
}
export function toolsetForRole(role) {
return EXECUTION_ROLES.has(role) ? [...EXECUTION_TOOLSET] : [...READ_ONLY_TOOLSET]
}
function hasExecutableAssignment(role, tasks) {
const byId = new Map(tasks.map(task => [task.id, task]))
return tasks.some(task => task.status === 'in_progress' && task.ownerName === role &&
(task.blockedBy ?? []).every(id => byId.get(id)?.status === 'completed'))
}
function managementApproval(role, toolName, tasks, now = Date.now()) {
return tasks.find(task => {
const approval = task?.approval
if (task.status !== 'in_progress' || task.ownerName !== role || !approval) return false
if (approval.reviewer !== 'menxia' || approval.verdict !== 'approve') return false
if (!approval.purpose || !approval.scope || !approval.expiresAt) return false
if (Date.parse(approval.expiresAt) <= now) return false
return Array.isArray(approval.tools) && approval.tools.some(entry => entry === toolName ||
(entry.endsWith('*') && toolName.startsWith(entry.slice(0, -1))))
})
}
function isManagementTool(toolName) {
return OTHER_MANAGEMENT_TOOLS.has(toolName) || MANAGEMENT_TOOL_PREFIXES.some(prefix => toolName.startsWith(prefix))
}
export function evaluateToolPolicy(role, toolName, tasks = [], options = {}) {
const audit = typeof options.audit === 'function' ? options.audit : () => {}
if (FORBIDDEN_IMAGE_TOOLS.has(toolName)) return `上朝模式只允许使用 Image-gen 工具,不得调用 ${toolName}。`
const destructiveBoardAction = toolName === 'task_board_manage' && options.args?.action === 'delete'
if ((HUMAN_SIGNATURE_TOOLS.has(toolName) || destructiveBoardAction) && options.humanSigned !== true) {
return `${toolName} 涉及删除或全局配置,须先取得人工签字。`
}
if (isManagementTool(toolName)) {
if (role === 'lead') {
audit({ action: 'management-tool', role, toolName, decision: 'allow', authority: 'chancellor' })
return undefined
}
const approval = managementApproval(role, toolName, tasks, options.now)
if (!approval) return `${role} 调用管理型工具 ${toolName} 前须提交用途、范围、期限,并取得门下省准奏记录。`
audit({ action: 'management-tool', role, toolName, decision: 'allow', approvalId: approval.id })
return undefined
}
if (!MUTATING_TOOLS.has(toolName)) return undefined
if (READ_ONLY_ROLES.has(role)) return `${role} 是只读规划、审核或调度角色,不得调用写入型工具 ${toolName}。`
if (!EXECUTION_ROLES.has(role)) return `${role} 不是获准的执行部门,不能调用 ${toolName}。`
if (!ROLE_ALLOWED_MUTATIONS[role]?.has(toolName)) return `${toolName} 不属于 ${role} 的职责范围。`
if (!hasExecutableAssignment(role, tasks)) return `${role} 尚未准奏:请先领取一个 in_progress 且所有 blocker 已完成的共享任务。`
return undefined
}
function rolePrompt(role) { return role === 'lead' ? LEAD_PROMPT : ROLE_PROMPTS[role] ?? ROLE_PROMPTS.minister }
function normalizeRoutes(routes = {}) {
const merged = { ...DEFAULT_ROUTES }
for (const [role, route] of Object.entries(routes)) {
if (!route || typeof route !== 'object') continue
if (typeof route.provider !== 'string' || typeof route.model !== 'string') continue
merged[role] = { provider: route.provider, model: route.model,
...(typeof route.reasoningEffort === 'string' ? { reasoningEffort: route.reasoningEffort } : {}) }
}
return merged
}
/**
* 面板上的「部门模型」走这条指令:宿主的 session.selectModel 会拒绝子会话
* (`session.header.origin === "subagent"` → session/agent-busy),所以部门模型
* 只能由本插件在 agent/request 时改,面板则用 /dept-model 把选择下发过来。
*/
export const DEPT_MODEL_COMMAND = 'dept-model'
export const DEPT_MODEL_USAGE = '<部门> <provider> <model> [推理等级] | list | clear [部门]'
export function routesFilePath(env = process.env) {
const home = typeof env.DSH_HOME === 'string' && env.DSH_HOME.trim() ? env.DSH_HOME.trim() : path.join(os.homedir(), '.dsh')
return path.join(home, 'sansheng-liubu', 'routes.json')
}
export function readStoredRoutes(file) {
try {
const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
return normalizeRoutes(parsed && typeof parsed === 'object' ? parsed : {})
} catch (error) { return {} }
}
export function writeStoredRoutes(file, routes) {
try {
fs.mkdirSync(path.dirname(file), { recursive: true })
fs.writeFileSync(file, JSON.stringify(routes, null, 2) + '\n', 'utf8')
return true
} catch (error) { return false }
}
export function parseDeptModelCommand(rawInput) {
const tokens = String(rawInput === undefined || rawInput === null ? '' : rawInput).trim().split(/\s+/).filter(Boolean)
if (tokens.length === 0 || tokens[0].toLowerCase() === 'list') return { action: 'list' }
const head = tokens[0].toLowerCase()
if (head === 'clear' || head === 'reset') {
const role = (tokens[1] || '').toLowerCase()
if (role && !COURT_ROLES.includes(role)) return { action: 'error', reason: `未知部门:${tokens[1]}` }
return { action: 'clear', role: role || undefined }
}
if (!COURT_ROLES.includes(head)) return { action: 'error', reason: `未知部门:${tokens[0]}(可用:${COURT_ROLES.join('、')})` }
if (tokens.length < 3) return { action: 'error', reason: `用法:/${DEPT_MODEL_COMMAND} ${DEPT_MODEL_USAGE}` }
const reasoningEffort = tokens[3]
return {
action: 'set',
role: head,
route: { provider: tokens[1], model: tokens[2], ...(reasoningEffort ? { reasoningEffort } : {}) },
}
}
export function describeDeptRoutes(routes = {}) {
const entries = Object.entries(routes).filter(([, route]) => route && route.provider && route.model)
if (entries.length === 0) return `十席目前都跟随宿主默认模型;用 /${DEPT_MODEL_COMMAND} ${DEPT_MODEL_USAGE} 逐个固定。`
return '部门固定模型:' + entries
.map(([role, route]) => `${role}=${route.provider}/${route.model}${route.reasoningEffort ? '·' + route.reasoningEffort : ''}`)
.join(';')
}
function registerDeptModelCommand(ctx, handler) {
if (!ctx.commands || typeof ctx.commands.register !== 'function') return () => {}
try {
const dispose = ctx.effect(function* () {
yield ctx.commands.register({
name: DEPT_MODEL_COMMAND,
description: '固定某个部门的模型(面板「模型设置」用)',
input: { hint: DEPT_MODEL_USAGE },
handler: invocation => handler(invocation && invocation.rawInput),
})
}, `sansheng-liubu: /${DEPT_MODEL_COMMAND}`)
return typeof dispose === 'function' ? dispose : () => {}
} catch (error) {
ctx.logger?.warn?.(`[sansheng-liubu] 注册 /${DEPT_MODEL_COMMAND} 失败:${error && error.message ? error.message : error}`)
return () => {}
}
}
const INSTALLATIONS = globalThis[Symbol.for('dsh.sansheng-liubu.installations')] ??=
new WeakMap()
/**
* 工作台是“整台机器一份”,不是“每个 agent 一份”:同一份账本只能有一个写者。
* 但本插件的 apply 可能被多次调用(每个组合了「上朝」预设的 agent 各一次),
* 所以按账本路径引用计数:最后一个卸载时才真的 dispose,中途不重复建 store。
*/
const WORKBENCH = globalThis[Symbol.for('dsh.sansheng-liubu.workbench')] ??= new Map()
/**
* 只有真的跑在宿主里才建工作台:单测用 mock ctx 调 apply() 时不该往
* %DSH_HOME% 写账本、也不该起对账计时器。cordis 的 Context 一定有 get()。
*/
function hostSurfaceAvailable(ctx) {
if (!ctx) return false
if (typeof ctx.get === 'function') return true
return Boolean(ctx.webServer || ctx.sessionController || ctx.remote)
}
function acquireWorkbench(ctx, presetId, log) {
if (!hostSurfaceAvailable(ctx)) return null
let file = null
try {
file = resolveStorePath(process.env)
} catch {
// 拿不到路径就退回内存账本,不能因为一个路径算不出来就让政策插件加载失败。
file = null
}
const key = file ?? '(memory)'
const existing = WORKBENCH.get(key)
if (existing) {
existing.refs += 1
return existing
}
const entry = { refs: 1, host: null, key }
try {
// 挂在 root 上:工作台属于整个应用,不该随某个 agent 的销毁一起消失。
entry.host = createWorkbenchHost(ctx?.root ?? ctx, { presetId })
for (const warning of entry.host.warnings ?? []) log?.(warning)
log?.(`账本 ${entry.host.file};接口${entry.host.registered ? '已注册' : '未注册'};`
+ `会话层${entry.host.hasSessions ? '可用' : '不可用(派发只落账)'}`)
} catch (error) {
log?.(`工作台启动失败:${error?.message ?? error}`)
entry.host = null
}
WORKBENCH.set(key, entry)
return entry
}
function releaseWorkbench(entry) {
if (!entry || entry !== WORKBENCH.get(entry.key)) return
function release(entry) {
entry.refs -= 1
if (entry.refs > 0) return
WORKBENCH.delete(entry.key)
if (globalThis[BOOT_KEY] === entry) delete globalThis[BOOT_KEY]
try {
entry.host?.dispose?.()
entry.host.dispose()
} catch {
// 卸载失败不影响插件卸载;下次启动仍会从同一个账本继续。
}
}
export const name = 'sansheng-liubu-mode'
export const inject = ['agents', 'agentTeams', 'agentPresets', 'systemPrompt', 'tools', 'commands']
export function apply(ctx, config = {}) {
const presetId = typeof config.presetId === 'string' ? config.presetId : PRESET_ID
const routeFile = routesFilePath()
const routes = normalizeRoutes({ ...readStoredRoutes(routeFile), ...(config.routes || {}) })
const owned = new Map()
const audit = entry => ctx.logger?.info?.(`[sansheng-liubu:audit] ${JSON.stringify({ at: new Date().toISOString(), ...entry })}`)
// 工作台:账本 + 部门会话 + HTTP 接口。整体失败只记日志,不能让政策插件加载不了——
// 「上朝」的 prompt/工具策略是刚需,工作台是增量能力。
const logWorkbench = message => {
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-liubu:workbench] ${message}`)
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 workbench = acquireWorkbench(ctx, presetId, logWorkbench)
const persist = () => {
if (writeStoredRoutes(routeFile, routes)) return
ctx.logger?.warn?.(`[sansheng-liubu] 路由表写入失败:${routeFile}`)
}
const runDeptModel = rawInput => {
const parsed = parseDeptModelCommand(rawInput)
if (parsed.action === 'error') return { kind: 'error', text: parsed.reason }
if (parsed.action === 'list') return { kind: 'success', text: describeDeptRoutes(routes) }
if (parsed.action === 'clear') {
if (parsed.role) delete routes[parsed.role]
else for (const role of Object.keys(routes)) delete routes[role]
persist()
return {
kind: 'success',
text: parsed.role ? `${parsed.role} 已恢复跟随宿主默认模型。` : '十席都已恢复跟随宿主默认模型。',
}
}
routes[parsed.role] = parsed.route
persist()
const effort = parsed.route.reasoningEffort ? `(推理等级 ${parsed.route.reasoningEffort})` : ''
return {
kind: 'success',
text: `${parsed.role} 已固定为 ${parsed.route.provider}/${parsed.route.model}${effort},该部门下一轮开工即生效。`,
}
}
const disposeCommand = registerDeptModelCommand(ctx, runDeptModel)
const uninstall = agent => {
const release = owned.get(agent)
if (!release) return
owned.delete(agent)
release()
}
const install = agent => {
if (owned.has(agent)) return
if (ctx.agentPresets.composedPreset(agent.ctx) !== presetId) return
const membership = ctx.agentTeams.tryMembership(agent)
const role = roleFromMembership(membership)
if (!role) return
const existing = INSTALLATIONS.get(agent)
if (existing) {
existing.refs += 1
owned.set(agent, () => {
existing.refs -= 1
if (existing.refs === 0) { existing.dispose(); INSTALLATIONS.delete(agent) }
})
return
}
const scoped = agent.ctx
const dispose = scoped.effect(() => {
const disposers = []
try {
disposers.push(scoped.systemPrompt.section({
name: 'sansheng-liubu:role',
order: scoped.systemPrompt.getSectionOrder('TEAM_POLICY') + 1,
text: rolePrompt(role),
}))
disposers.push(scoped.on('agent/request', async (_payload, next) => {
const resolved = await next()
const route = routeForRole(role, routes)
if (!route) return resolved
const { reasoningEffort: _oldEffort, ...base } = resolved
return { ...base, provider: route.provider, model: route.model,
...(route.reasoningEffort ? { reasoningEffort: route.reasoningEffort } : {}) }
}, { prepend: true }))
disposers.push(scoped.tools.guard(execution => {
const tasks = ctx.agentTeams.listTasks(agent)
return evaluateToolPolicy(role, execution.name, tasks, {
audit,
humanSigned: execution?.approval?.humanSigned === true || execution?.humanSigned === true,
args: execution?.args,
})
}))
} catch (error) {
for (const cleanup of disposers.reverse()) cleanup()
throw error
}
return () => { for (const cleanup of disposers.reverse()) cleanup() }
})
const shared = { refs: 1, dispose }
INSTALLATIONS.set(agent, shared)
owned.set(agent, () => {
shared.refs -= 1
if (shared.refs === 0) { shared.dispose(); INSTALLATIONS.delete(agent) }
})
}
for (const agent of ctx.agents.list()) install(agent)
const disposeCreated = ctx.on('agent/created', ({ agent }) => install(agent))
const disposeDisposed = ctx.on('agent/disposed', ({ agent }) => uninstall(agent))
return () => {
disposeCommand()
disposeCreated()
disposeDisposed()
for (const agent of [...owned.keys()]) uninstall(agent)
releaseWorkbench(workbench)
}
const entry = { host, refs: 1 }
globalThis[BOOT_KEY] = entry
return () => release(entry)
}

View File

@ -1,6 +0,0 @@
{
"meta": {
"title": "Imperial Court",
"description": "A Chancellor-led multi-agent mode for planning, review, dispatch, visual work, writing, and coding."
}
}

View File

@ -1,6 +0,0 @@
{
"meta": {
"title": "上朝",
"description": "丞相统筹的多 Agent 协作模式,提供规划、审核、调度、图像、写作和代码能力。"
}
}

View File

@ -1,40 +1,42 @@
{
"name": "dsh-sansheng-liubu-mode",
"version": "0.9.2",
"private": true,
"description": "上朝:丞相统筹的三省六部多 Agent 模式",
"version": "0.14.0",
"description": "三省六部工作台:十席独立会话、项目账本、派工与分层记忆",
"type": "module",
"main": "./index.js",
"exports": {
".": "./index.js",
"./package.json": "./package.json",
"./locale/*.json": "./locale/*.json"
"./client": "./workbench/panel/lib/client.js"
},
"files": [
"index.js",
"cordis.patch.yml",
"preset.patch.yml",
"icon.svg",
"locale/*.json",
"README.md",
"CHANGELOG.md",
"panel/**",
"panel/test",
"scripts",
"locale"
"workbench"
],
"icon": "./icon.svg",
"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"
]
}
},
"scripts": {
"test": "node --test --test-isolation=none test/policy.test.js panel/test/client.test.js",
"check:install": "node scripts/check-install.mjs",
"mode": "node scripts/mode.mjs",
"preview": "node scripts/preview.mjs"
"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"
}

View File

@ -1,39 +0,0 @@
# dsh-sansheng-liubu-panel
三省六部 Agent Team 的 DSH Web 客户端面板。它是独立插件包,避免与 `dsh-sansheng-liubu-mode` 的预设宿主插件重复加载。
## 功能
- 在会话头部显示当前团队成员数。
- 朝堂编制与任务流转收进会话右侧栏,用「朝堂 / 任务」页签切换;不再占用工作区主视图。
- 右侧栏顶部提供协作状态、`输入 @ 选择部门` 提示和子会话返回按钮;四个统计卡固定在侧栏内,可点击切换朝堂或任务。
- 朝堂图按丞相、三省、六部分层展示;选中部门后在侧栏下方配置模型、推理等级或进入其会话。
- 在 DSH 原生会话输入框输入 `@`,可直接选择已设官的部门并进入其子会话发送任务;不另造聊天框,也不会静默改写接收人。
- 进入部门子会话后侧栏自动选中对应部门;返回丞相主会话时恢复丞相选中。
- 复用 DSH 主题变量,支持明亮、深色和窄侧栏布局。
面板只读 `agentTeam` 投影并复用现有 `uiWorkspace.openSession`,不创建 Agent、不调用工具、不改变权限边界。
## 安装
在 DSH profile 的 `package.json` 中加入:
```json
"dependencies": {
"dsh-sansheng-liubu-panel": "link:C:/Users/qyh15/三省六部/panel"
},
"dsh": {
"profile": {
"bundles": ["dsh-sansheng-liubu-panel"]
}
}
```
安装后需要重启 DSH Host,再刷新 Web 页面。客户端 bundle 会在页面启动时由 `dsh-client-modules` 组合;只刷新页面不会让 Host 重新扫描新插件。
## 验证
```bash
node --test --test-isolation=none panel/test/client.test.js
node ../scripts/check-install.mjs
```

View File

@ -1,4 +0,0 @@
# 三省六部 Agent 面板:只加载 Web 客户端 bundle,不参与 Agent 策略。
- insert:
- id: sansheng-agent-panel
name: dsh-sansheng-liubu-panel

View File

@ -1,32 +0,0 @@
// 三省六部:Host 侧桥接。
//
// 浏览器不能直接创建 Agent(Agent Teams 只有 Lead 通过模型工具才能组建),
// 所以“组建朝班”走一条受控路径:面板把请求写进当前会话的草稿并通知用户发送,
// 或者(在有该能力时)直接投递一条预置指令给丞相会话。
//
// 这里同时导出可测试的纯函数,供 panel/test 直接调用,不依赖 cordis 运行时。
export const PRESET_ID = 'sansheng-liubu'
/** 组建朝班的指令:丞相据此创建三省,再由尚书创建六部。 */
export function formationPrompt(roles = ['zhongshu', 'menxia', 'shangshu']) {
const names = roles.join('、')
return [
'【上朝】请按三省六部流程组建朝班:',
`1. 立即创建 ${names} 三个部门成员(spawn_teammate),角色名必须与上述名称完全一致。`,
'2. 在共享任务板上建立:中书拟案 → 门下审议 → 尚书派工 的任务链,写清各自的 writeScopes。',
'3. 门下准奏后,由尚书按职责分派:吏部(Agent 与技能维护)、户部(数据与计算)、礼部(内容与呈现)、兵部(环境运行与部署)、刑部(按风险专项测试)、工部(开发实现);只召集本任务真正用到的部门,角色名为 libu/hubu/lipu/bingbu/xingbu/gongbu。',
'4. 每个阶段完成后向我汇报,得到我确认再进入下一阶段。',
].join('\n')
}
/** 下旨文本:面板里选部门 + 输入指令时使用。 */
export function decreePrompt(role, text) {
const body = String(text ?? '').trim()
if (body === '') return ''
return `【丞相下旨 · ${role}】\n${body}`
}
export function apply() {
// 面板完全在浏览器侧运行;Host 侧不需要注册服务,保留空实现让 Loader 能正常加载。
}

File diff suppressed because it is too large Load Diff

View File

@ -1,260 +0,0 @@
// 三省六部:纯逻辑层(不依赖 React / DOM),便于在 node --test 中直接验证。
// 这些函数只做数据投影与协议拼装:成员编排、状态归并、下旨文本、模型目录展开。
export const ROLE_IDS = Object.freeze(['lead', 'zhongshu', 'menxia', 'shangshu', 'libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'])
export const ROLE_LABELS = Object.freeze({
lead: '丞相',
zhongshu: '中书省',
menxia: '门下省',
shangshu: '尚书省',
libu: '吏部',
hubu: '户部',
lipu: '礼部',
bingbu: '兵部',
xingbu: '刑部',
gongbu: '工部',
})
export const ROLE_MARKS = Object.freeze({
lead: '丞',
zhongshu: '中',
menxia: '门',
shangshu: '尚',
libu: '吏',
hubu: '户',
lipu: '礼',
bingbu: '兵',
xingbu: '刑',
gongbu: '工',
})
export const ROLE_DUTIES = Object.freeze({
lead: '统筹全局,向用户汇报,最终交付',
zhongshu: '拟案规划,拆解任务与验收标准',
menxia: '审议准奏与交付验收,可否决',
shangshu: '派工调度,合成各部门成果',
libu: 'Agent 与技能维护、成员编制',
hubu: '数据、表格与计算,可复算结论',
lipu: '文档、汇报与可视化产出',
bingbu: '环境运行、调试与部署,掌武库',
xingbu: '按风险的专项测试与独立验证',
gongbu: '编码与工程实现',
})
/** 朝堂图布局:丞相居中在顶,三省为中层(左中书、中尚书、右门下),六部直隶尚书。 */
export const LAYOUT = Object.freeze({
lead: { row: 0, column: 'lead' },
zhongshu: { row: 1, column: 'zhongshu' },
shangshu: { row: 1, column: 'shangshu' },
menxia: { row: 1, column: 'menxia' },
libu: { row: 2, column: 'one' },
hubu: { row: 2, column: 'two' },
lipu: { row: 2, column: 'three' },
bingbu: { row: 2, column: 'four' },
xingbu: { row: 2, column: 'five' },
gongbu: { row: 2, column: 'six' },
})
export const STATUS_LABELS = Object.freeze({
running: '运行中',
inactive: '空闲',
provisioning: '创建中',
failed: '失败',
absent: '未设官',
})
export const TASK_STATUS_LABELS = Object.freeze({
pending: '待办',
in_progress: '执行中',
completed: '已完成',
})
/** 把 agentTeam 投影按官职编排成固定十席,缺员以 absent 占位,保证图结构稳定。 */
export function arrangeRoster(team) {
const members = Array.isArray(team?.members) ? team.members : []
const byRole = new Map()
for (const member of members) {
if (member?.name === undefined) continue
byRole.set(member.name, member)
}
return ROLE_IDS.map((role) => {
const member = byRole.get(role)
return {
role,
label: ROLE_LABELS[role],
mark: ROLE_MARKS[role],
duty: ROLE_DUTIES[role],
layout: LAYOUT[role],
id: member?.id,
member,
present: member !== undefined,
}
})
}
/** 运行状态(会话是否在跑)与任务状态(共享任务)必须分开表达,不能互相覆盖。 */
export function memberStatus(member, running, summaryRunning) {
if (member === undefined) return 'absent'
if (member.phase !== undefined && member.phase !== 'active') return member.phase
return running === true || summaryRunning === true ? 'running' : 'inactive'
}
export function roleLabel(role) {
return ROLE_LABELS[role] ?? '成员'
}
export function roleMark(role) {
return ROLE_MARKS[role] ?? '员'
}
export function modelLabel(model) {
if (typeof model === 'string') return model
if (!model || typeof model !== 'object') return ''
if (typeof model.name === 'string') return model.name
if (typeof model.model === 'string') return model.model
if (typeof model.id === 'string') return model.id
return ''
}
export function effortLabel(effort) {
if (typeof effort !== 'string') return ''
const table = { minimal: '极低', low: '低', medium: '中', high: '高', max: '最高', xhigh: '极高' }
return table[effort] ?? effort
}
export function taskBuckets(team) {
const tasks = Array.isArray(team?.tasks) ? team.tasks : []
const buckets = { pending: [], in_progress: [], completed: [] }
for (const task of tasks) {
const key = task?.status
if (key === 'pending' || key === 'in_progress' || key === 'completed') buckets[key].push(task)
else buckets.pending.push(task)
}
return buckets
}
export function tasksOfRole(team, role) {
const tasks = Array.isArray(team?.tasks) ? team.tasks : []
return tasks.filter((task) => task?.ownerName === role || task?.ownerName === roleLabel(role))
}
/** 所选成员的运行状态 + 任务状态摘要,供图下配置区展示。 */
export function statusSummary(seat, team, running, summaryRunning) {
const status = memberStatus(seat?.member, running, summaryRunning)
const owned = seat?.role === undefined ? [] : tasksOfRole(team, seat.role)
const buckets = taskBuckets({ tasks: owned })
return {
status,
statusLabel: STATUS_LABELS[status] ?? status,
owned,
runningCount: buckets.in_progress.length,
pendingCount: buckets.pending.length,
completedCount: buckets.completed.length,
}
}
/** 模型目录展开成扁平选项:每组 id 即 provider,行 id 为 provider/model。 */
export function modelOptions(catalog) {
const options = []
const groups = Array.isArray(catalog?.groups) ? catalog.groups : []
for (const group of groups) {
const provider = group?.id ?? group?.provider
for (const model of Array.isArray(group?.models) ? group.models : []) {
if (!provider || !model?.id) continue
const efforts = Array.isArray(model.reasoning?.efforts)
? model.reasoning.efforts.map((effort) => ({ id: effort.id, name: effort.name ?? effortLabel(effort.id) }))
: []
options.push({
provider,
model: model.id,
rowId: `${provider}/${model.id}`,
label: model.name ?? model.id,
efforts,
defaultEffort: model.reasoning?.defaultEffort,
})
}
}
return options
}
export function findModelOption(options, current) {
if (!current?.provider || !current?.model) return undefined
return options.find((option) => option.provider === current.provider && option.model === current.model)
}
/**
* 下旨文本:把用户输入包装成明确的“切到某部门执行”指令,并附带当前朝堂上下文。
* 部门会话是受控子会话,直接投递文本仍受角色提示词约束。
*/
export function decreeText(role, text, team) {
const body = String(text ?? '').trim()
if (body === '') return ''
const buckets = taskBuckets(team)
const active = buckets.in_progress.map((task) => task.subject ?? task.title ?? task.id).filter(Boolean)
const head = `【丞相下旨 · ${roleLabel(role)}】`
const context = active.length > 0 ? `\n当前在办:${active.join(';')}` : ''
return `${head}\n${body}${context}`
}
/** 交付物“部分 → 主责部门”清单:把共享任务按负责人归组成部门小结。 */
export function deliverySummary(team) {
const tasks = Array.isArray(team?.tasks) ? team.tasks : []
const byRole = new Map()
for (const task of tasks) {
const owner = task?.ownerName ?? 'lead'
const key = ROLE_IDS.includes(owner) ? owner : 'lead'
if (!byRole.has(key)) byRole.set(key, [])
byRole.get(key).push(task)
}
return ROLE_IDS.filter((role) => byRole.has(role)).map((role) => ({
role,
label: ROLE_LABELS[role],
tasks: byRole.get(role),
completed: byRole.get(role).filter((task) => task?.status === 'completed').length,
}))
}
export function shortText(value, limit = 120) {
const text = String(value ?? '').replace(/\s+/g, ' ').trim()
return text.length <= limit ? text : `${text.slice(0, limit - 1)}…`
}
/** 从 chat 快照里取最后一条用户指令与最后一条助手文本,用于卡片上的“最近动静”。 */
export function lastExchange(snapshot) {
if (!snapshot || typeof snapshot !== 'object') return { lastUser: '', lastAssistant: '' }
const nodes = []
const values = typeof snapshot.nodes?.values === 'function' ? snapshot.nodes.values() : []
for (const key of Array.isArray(values) ? values : Array.from(values ?? [])) {
const node = typeof snapshot.nodes?.get === 'function' ? snapshot.nodes.get(key) : undefined
if (node !== undefined) nodes.push(node)
}
let lastUser = ''
let lastAssistant = ''
for (const node of nodes) {
if (node.kind === 'user') {
const text = (Array.isArray(node.data?.content) ? node.data.content : [])
.filter((block) => block?.type === 'text')
.map((block) => block.text)
.join('\n')
if (text.trim() !== '') lastUser = shortText(text, 160)
} else if (node.kind === 'assistant-step') {
const text = (Array.isArray(node.data?.blocks) ? node.data.blocks : [])
.filter((block) => block?.kind === 'text')
.map((block) => block.text)
.join('\n')
if (text.trim() !== '') lastAssistant = shortText(text, 200)
}
}
return { lastUser, lastAssistant }
}
/** 校验一次模型切换请求;子代理会话不允许改模型,返回原因便于提示。 */
export function modelSwitchPlan(current, next, addressesSubagent) {
if (addressesSubagent === true) return { ok: false, reason: '子会话不能单独更换模型,请在丞相会话或新建会话时设置' }
if (!next?.provider || !next?.model) return { ok: false, reason: '未选择模型' }
const same = current?.provider === next.provider && current?.model === next.model
const effort = next.reasoningEffort ?? undefined
if (same && (current?.reasoningEffort ?? undefined) === effort) return { ok: false, reason: '与当前设置相同' }
return { ok: true, payload: { provider: next.provider, model: next.model, ...(effort === undefined ? {} : { reasoningEffort: effort }) } }
}

View File

@ -1,44 +0,0 @@
{
"name": "dsh-sansheng-liubu-panel",
"version": "0.9.2",
"private": true,
"description": "三省六部 Agent 面板:在 DSH Web GUI 中常驻显示并切换团队 Agent",
"type": "module",
"main": "./index.js",
"exports": {
".": "./index.js",
"./client": "./lib/client.js",
"./package.json": "./package.json"
},
"files": [
"index.js",
"cordis.patch.yml",
"lib/client.js",
"README.md",
"panel/test",
"scripts",
"icon.svg",
"locale"
],
"dsh": {
"manifestVersion": 1,
"bundle": {
"patch": "./cordis.patch.yml"
},
"client": {
"platform": "web",
"inject": [
"@deepseek-ai/dsh-api-session-controller",
"@deepseek-ai/dsh-client-locale",
"@deepseek-ai/dsh-client-ui-conversation",
"@deepseek-ai/dsh-client-ui-primitives",
"@deepseek-ai/dsh-client-ui-workspace",
"@deepseek-ai/dsh-client-ui-model-selection"
]
}
},
"peerDependencies": {
"@deepseek-ai/cordis": "~4.0.5"
},
"license": "MIT"
}

File diff suppressed because it is too large Load Diff

View File

@ -1,22 +0,0 @@
# 可选层:只有把下面的条目合并进
# ~/.dsh/profiles/desktop/cordis.patch.yml
# 并彻底重启 DSH 之后,「上朝」才会出现在模式选择器里。
# 不合并 = 永远不开;删掉 = 立即退出。
#
# 合并方式(PowerShell,在 profile 目录下):
# $patch = Get-Content ~/.dsh/profiles/desktop/cordis.patch.yml -Raw
# Get-Content ./preset.patch.yml -Raw | Add-Content ~/.dsh/profiles/desktop/cordis.patch.yml
# 注意保持 YAML 顶层是「数组」:删掉文件里那行 `[]` 之后再把本文件内容接在末尾。
- insert:
- id: preset-sansheng-liubu
name: '@deepseek-ai/dsh-agent-preset'
config:
id: sansheng-liubu
name: 上朝
description: 丞相统筹,中书规划、门下审核、尚书调度,工部通过 Image-gen 进行视觉创作、礼部文档、兵部代码与工具武库。
order: 30
plugins:
- id: sansheng-liubu-policy
name: dsh-sansheng-liubu-mode
config:
presetId: sansheng-liubu

View File

@ -1,92 +0,0 @@
import { readFile } from 'node:fs/promises'
import { createRequire } from 'node:module'
import { homedir } from 'node:os'
import { dirname, join, resolve } from 'node:path'
import { pathToFileURL } from 'node:url'
const profileDir = resolve(process.env.DSH_PROFILE_DIR ?? join(homedir(), '.dsh', 'profiles', 'desktop'))
const profilePath = join(profileDir, 'package.json')
const profile = JSON.parse(await readFile(profilePath, 'utf8'))
const profilePatchPath = join(profileDir, 'cordis.patch.yml')
function assert(condition, message) {
if (!condition) throw new Error(message)
}
/** 去掉整行注释后剩下的 YAML 主体。 */
function withoutComments(source) {
return source.replace(/^\s*#.*$/gm, '').trim()
}
for (const name of ['dsh-sansheng-liubu-mode', 'dsh-sansheng-liubu-panel']) {
assert(profile.dependencies?.[name]?.startsWith('link:'), `${name} must be a link dependency`)
}
// 面板常驻;模式故意不要求在 bundles 里——它必须由用户显式启用。
assert(
profile.dsh?.profile?.bundles?.includes('dsh-sansheng-liubu-panel'),
'panel must be listed in dsh.profile.bundles', // 面板是常驻 UI,不参与 Agent 策略
)
const requireFromProfile = createRequire(join(profileDir, 'package.json'))
const modeManifestPath = requireFromProfile.resolve('dsh-sansheng-liubu-mode/package.json')
const panelManifestPath = requireFromProfile.resolve('dsh-sansheng-liubu-panel/package.json')
const modeDir = dirname(modeManifestPath)
const modeManifest = JSON.parse(await readFile(modeManifestPath, 'utf8'))
const panelManifest = JSON.parse(await readFile(panelManifestPath, 'utf8'))
assert(modeManifest.dsh?.bundle?.patch, 'mode package must declare dsh.bundle.patch')
assert(panelManifest.dsh?.bundle?.patch, 'panel package must declare dsh.bundle.patch')
assert(panelManifest.dsh?.client?.platform === 'web', 'panel must declare a web client')
assert(panelManifest.dsh?.client?.inject?.length > 0, 'panel must declare client injections')
// 装包 ≠ 开模式:包自带的 patch 必须是空层,绝不能注册「上朝」预设。
const bundlePatch = await readFile(join(modeDir, modeManifest.dsh.bundle.patch), 'utf8')
assert(
!/preset-sansheng-liubu/.test(bundlePatch),
'bundle patch must not register the 上朝 preset; opting in goes through preset.patch.yml',
)
assert(
['', '[]'].includes(withoutComments(bundlePatch)),
'bundle patch must stay an empty layer so installing the mode changes nothing',
)
// 可选层必须存在,并且能复现出同一个 preset id 与策略插件。
const presetPatch = await readFile(join(modeDir, 'preset.patch.yml'), 'utf8')
assert(/id: preset-sansheng-liubu/.test(presetPatch), 'preset.patch.yml must declare preset-sansheng-liubu')
assert(/^\s+id: sansheng-liubu\s*$/m.test(presetPatch), 'preset.patch.yml must declare the sansheng-liubu preset id')
assert(/name: dsh-sansheng-liubu-mode/.test(presetPatch), 'preset.patch.yml must load dsh-sansheng-liubu-mode')
let modeEnabled = false
try {
modeEnabled = /preset-sansheng-liubu/.test(await readFile(profilePatchPath, 'utf8'))
} catch {
// 没有 patch 文件 = 从未启用过
}
const mode = await import(pathToFileURL(join(modeDir, modeManifest.main)).href)
const panel = await import(pathToFileURL(join(dirname(panelManifestPath), panelManifest.main)).href)
assert(typeof mode.apply === 'function', 'mode host entry must export apply')
assert(typeof panel.apply === 'function', 'panel host must export apply')
const clientSource = await readFile(join(dirname(panelManifestPath), 'lib', 'client.js'), 'utf8')
assert(clientSource.includes('id: "dsh-sansheng-liubu-panel"'), 'client bundle id must match the panel package name')
assert(clientSource.includes('"sidebar.right.pane.tab"'), 'client bundle must register the right sidebar tab')
// 0.5.4 起:「左侧栏导航列的一行 + main 重定向桩」是允许的(用户要求入口出现在那一列),
// 但范围严格限定为纯跳转:不得注册 panellist 的更多菜单动作,也不得注册整页面板。
assert(clientSource.includes('"sidebar.panellist"'), 'client bundle must register the left nav row')
assert(clientSource.includes('name: "sidebar.panellist"'), 'left nav row must go through the panellist slot')
assert(clientSource.includes('name: "main"'), 'left nav row needs a main redirect stub to leave the workspace empty')
assert(clientSource.includes('SanshengDockRedirect'), 'main slot must only be the redirect stub, not a full-page panel')
assert(!/sidebar\.panellist\.actions/.test(clientSource), 'client bundle must not register panellist more-menu actions')
assert(!clientSource.includes('h(SanshengPanel, { ...props, host })'), 'main slot must not render the court panel itself')
console.log(JSON.stringify({
profile: profilePath,
mode: modeManifestPath,
panel: panelManifestPath,
bundles: profile.dsh.profile.bundles.filter((name) => name.startsWith('dsh-sansheng-')),
modeEnabled,
hint: modeEnabled
? '「上朝」已启用:它只是模式选择器里的一个选项,不会自动成为新会话默认。'
: '「上朝」未启用(装包不等于开模式)。要当可选模式用:node scripts/mode.mjs on,再彻底重启 DSH。',
}, null, 2))

View File

@ -1,106 +0,0 @@
#!/usr/bin/env node
// 上朝的启用开关:只改 profile 的 cordis.patch.yml,不碰任何别的插件行。
//
// node scripts/mode.mjs status # 现在开没开
// node scripts/mode.mjs on # 让「上朝」出现在模式选择器里(仍需你在新会话中点选)
// node scripts/mode.mjs off # 彻底移除这个选项
//
// 改动是一段带标记的 YAML,重复执行结果一致;不开模式时 profile 里不留任何痕迹。
import { readFile, writeFile } from 'node:fs/promises'
import { homedir } from 'node:os'
import { join, resolve } from 'node:path'
const BEGIN = '# >>> 上朝 preset(scripts/mode.mjs 管理,勿手改)'
const END = '# <<< 上朝 preset'
const MARK = 'preset-sansheng-liubu'
const profileDir = resolve(process.env.DSH_PROFILE_DIR ?? join(homedir(), '.dsh', 'profiles', 'desktop'))
const patchPath = join(profileDir, 'cordis.patch.yml')
const presetTemplatePath = resolve(import.meta.dirname, '..', 'preset.patch.yml')
async function readOrEmpty(path) {
try {
return await readFile(path, 'utf8')
} catch (error) {
if (error.code === 'ENOENT') return ''
throw error
}
}
/** preset.patch.yml 里真正要被合并的那几行(去掉说明注释)。 */
async function presetBlock() {
const template = await readOrEmpty(presetTemplatePath)
const lines = template.split(/\r?\n/)
const start = lines.findIndex((line) => /^- insert:/.test(line))
if (start < 0) throw new Error(`${presetTemplatePath} 里找不到 "- insert:" 起始行`)
return lines.slice(start).join('\n').trimEnd()
}
/** 顶层若是空数组占位 `[]`,合并前要先去掉,否则 YAML 不再是单个数组。 */
function dropEmptyRoot(text) {
const kept = text.split(/\r?\n/).filter((line) => line.trim() !== '[]')
return kept.join('\n').trimEnd()
}
function isEnabled(text) {
return text.includes(MARK)
}
function isManaged(text) {
return text.includes(BEGIN)
}
function stripBlock(text) {
const lines = text.split(/\r?\n/)
const begin = lines.findIndex((line) => line.trim() === BEGIN)
const end = lines.findIndex((line) => line.trim() === END)
if (begin < 0 || end < begin) return null
return [...lines.slice(0, begin), ...lines.slice(end + 1)].join('\n')
}
async function status() {
const text = await readOrEmpty(patchPath)
return {
profilePatch: patchPath,
enabled: isEnabled(text),
managed: isManaged(text),
}
}
async function enable() {
const text = await readOrEmpty(patchPath)
if (isEnabled(text)) return { ...(await status()), changed: false, note: '已经启用,未改动' }
const body = dropEmptyRoot(text)
const parts = [body, BEGIN, await presetBlock(), END].filter((part) => part !== '')
await writeFile(patchPath, `${parts.join('\n')}\n`, 'utf8')
return { ...(await status()), changed: true, note: '已启用;彻底重启 DSH 后,新会话可选「上朝」' }
}
async function disable() {
const text = await readOrEmpty(patchPath)
if (!isEnabled(text)) return { ...(await status()), changed: false, note: '本来就没启用,未改动' }
const stripped = stripBlock(text)
if (stripped === null) {
throw new Error(`${patchPath} 里的预设行不是本脚本写入的(缺少标记行),请手动删除后重试`)
}
const body = stripped.trimEnd()
const next = body === '' ? '[]\n' : `${body}\n`
await writeFile(patchPath, next, 'utf8')
return { ...(await status()), changed: true, note: '已关闭;彻底重启 DSH 后生效' }
}
const action = (process.argv[2] ?? 'status').toLowerCase()
const handlers = { status, on: enable, off: disable }
const handler = handlers[action]
if (!handler) {
console.error(`未知动作:${action}(可用:status / on / off)`)
process.exit(2)
}
try {
console.log(JSON.stringify(await handler(), null, 2))
} catch (error) {
console.error(String(error?.message ?? error))
process.exit(1)
}

File diff suppressed because it is too large Load Diff

View File

@ -1,144 +1,17 @@
#!/usr/bin/env node
// 工作台前端(workbench/panel)的安装开关:只动 profile 的 package.json、
// bundles 列表,以及 node_modules 里的一个链接。它不碰 cordis.patch.yml,
// 也不改「上朝」预设——那是 scripts/mode.mjs 的事。
// 退役说明(0.13.0+):朝堂面板已并回主包 `dsh-sansheng-liubu-mode`。
// 本脚本不再安装、卸载或改写任何 profile 文件,只打印迁移说明。
//
// node scripts/workbench-install.mjs status # 现在装没装
// node scripts/workbench-install.mjs on # 装上(需要彻底重启 DSH 才生效)
// node scripts/workbench-install.mjs off # 卸掉
//
// 幂等:重复执行结果一致;不需要备份(版本历史由 Git 管)。
// 安装/修复/迁移是独立授权操作;自检请用 `node scripts/workbench-preflight.mjs`。
import { readFile, writeFile, mkdir, lstat, readlink, rm, symlink } from 'node:fs/promises'
import { existsSync } from 'node:fs'
import { homedir } from 'node:os'
import { dirname, join, resolve } from 'node:path'
const NAME = 'dsh-sansheng-liubu-workbench'
const REPO = resolve(import.meta.dirname, '..')
const TARGET = join(REPO, 'workbench', 'panel')
const profileDir = resolve(process.env.DSH_PROFILE_DIR ?? join(homedir(), '.dsh', 'profiles', 'desktop'))
const profilePath = join(profileDir, 'package.json')
const linkPath = join(profileDir, 'node_modules', NAME)
/** Windows 上 `link:` 依赖写成正斜杠;反斜杠在 profile 里会被当成转义。 */
const posix = (value) => value.replace(/\\/g, '/')
async function readProfile() {
return JSON.parse(await readFile(profilePath, 'utf8'))
}
async function writeProfile(profile) {
await writeFile(profilePath, `${JSON.stringify(profile, null, 2)}\n`, 'utf8')
}
async function linkState() {
try {
const stat = await lstat(linkPath)
if (!stat.isSymbolicLink()) return { linked: false, note: '不是链接(可能有同名真实目录)' }
const actual = await readlink(linkPath)
const resolved = resolve(profileDir, 'node_modules', actual)
const ok = resolved.toLowerCase() === resolve(TARGET).toLowerCase()
return { linked: ok, target: actual, note: ok ? undefined : `链接指向 ${actual}` }
} catch (error) {
if (error.code === 'ENOENT') return { linked: false, note: '链接不存在' }
throw error
}
}
async function status() {
const profile = await readProfile()
const link = await linkState()
const bundles = profile.dsh?.profile?.bundles ?? []
return {
profile: profilePath,
target: TARGET,
targetExists: existsSync(join(TARGET, 'lib', 'client.js')),
dependency: profile.dependencies?.[NAME] ?? null,
inBundles: bundles.includes(NAME),
link,
installed: profile.dependencies?.[NAME] === `link:${posix(TARGET)}` && bundles.includes(NAME) && link.linked,
}
}
async function ensureLink() {
await mkdir(dirname(linkPath), { recursive: true })
const state = await linkState()
if (state.linked) return { changed: false }
if (existsSync(linkPath) || state.note === '不是链接(可能有同名真实目录)') await rm(linkPath, { recursive: true, force: true })
// Windows 上用 junction:不需要管理员权限,跳转由文件系统处理。
await symlink(TARGET, linkPath, process.platform === 'win32' ? 'junction' : 'dir')
return { changed: true }
}
async function enable() {
if (!existsSync(join(TARGET, 'lib', 'client.js'))) {
throw new Error(`找不到 ${join(TARGET, 'lib', 'client.js')}:工作台前端还没构建出来,先别装。`)
}
const profile = await readProfile()
let changed = false
profile.dependencies ??= {}
const wanted = `link:${posix(TARGET)}`
if (profile.dependencies[NAME] !== wanted) {
profile.dependencies[NAME] = wanted
changed = true
}
profile.dsh ??= {}
profile.dsh.profile ??= {}
profile.dsh.profile.bundles ??= []
if (!profile.dsh.profile.bundles.includes(NAME)) {
profile.dsh.profile.bundles.push(NAME)
changed = true
}
if (changed) await writeProfile(profile)
const link = await ensureLink()
return {
...(await status()),
changed: changed || link.changed,
hint: changed || link.changed
? '已装上。彻底退出并重启 DSH 后生效(客户端 bundle 在启动时加载,热更新不覆盖)。'
: '本来就已经装好,未改动。',
}
}
async function disable() {
const profile = await readProfile()
let changed = false
if (profile.dependencies && NAME in profile.dependencies) {
delete profile.dependencies[NAME]
changed = true
}
const bundles = profile.dsh?.profile?.bundles
if (Array.isArray(bundles) && bundles.includes(NAME)) {
profile.dsh.profile.bundles = bundles.filter((name) => name !== NAME)
changed = true
}
if (changed) await writeProfile(profile)
let unlinked = false
try {
await rm(linkPath, { recursive: true, force: true })
unlinked = true
} catch {
/* 链接本来就不在 */
}
return {
...(await status()),
changed: changed || unlinked,
hint: changed || unlinked ? '已卸掉。彻底重启 DSH 后生效。' : '本来就没装,未改动。',
}
}
const action = (process.argv[2] ?? 'status').toLowerCase()
const handlers = { status, on: enable, off: disable }
const handler = handlers[action]
if (!handler) {
console.error(`未知动作:${action}(可用:status / on / off)`)
process.exit(2)
}
try {
console.log(JSON.stringify(await handler(), null, 2))
} catch (error) {
console.error(String(error?.message ?? error))
process.exit(1)
}
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,11 +1,8 @@
// 重启前自检:只读,不改任何东西。
// 重启前自检:严格只读,不创建、覆盖或迁移任何用户文件。
//
// 目的:把「重启 DSH 之后才发现客户端 bundle 根本没加载」这类问题提前挡掉。
// 检查四件事——
// 1. profile 里到底有没有把本插件链进去(dependencies + dsh.profile.bundles)
// 2. 链接指向的目录里,exports 声明的那个文件在不在
// 3. 那个文件是不是一段能解析的 JS(语法坏了会让整页白屏,且报错很难看懂)
// 4. Host 侧装配能不能在内存账本上跑起来(13 条路由 + bootstrap 可用)
// 0.13.0 起朝堂面板已并回主包 `dsh-sansheng-liubu-mode`,不再有独立的
// `dsh-sansheng-liubu-workbench` 安装包。自检只回答“当前这份包能不能在
// 宿主上正常加载”,安装/修复/迁移是另外的显式操作,不混在这里。
//
// 用法:node scripts/workbench-preflight.mjs
// 退出码:0 全通;1 有失败项(打印哪一项失败、为什么)。
@ -18,7 +15,8 @@ import vm from 'node:vm'
import { createWorkbenchHost } from '../workbench/host/index.mjs'
import { WorkbenchStore } from '../workbench/core/store.mjs'
const PLUGIN_ID = 'dsh-sansheng-liubu-workbench'
const PACKAGE_NAME = 'dsh-sansheng-liubu-mode'
const PACKAGE_ROOT = path.resolve(import.meta.dirname, '..')
const results = []
function check(name, run) {
@ -35,56 +33,38 @@ function dshHome(env = process.env) {
return value === '' ? path.join(os.homedir(), '.dsh') : value
}
const profileDir = path.join(dshHome(), 'profiles', 'desktop')
const profilePackage = path.join(profileDir, 'package.json')
let profile = null
check('读取 profile/package.json', () => {
profile = JSON.parse(fs.readFileSync(profilePackage, 'utf8'))
return profilePackage
})
check('profile 的 dependencies 里链了本插件', () => {
const spec = profile?.dependencies?.[PLUGIN_ID]
if (typeof spec !== 'string' || spec === '') throw new Error(`dependencies 里没有 ${PLUGIN_ID}`)
return spec
})
check('profile 的 bundles 里登记了本插件', () => {
const bundles = profile?.dsh?.profile?.bundles
if (!Array.isArray(bundles) || !bundles.includes(PLUGIN_ID)) {
throw new Error(`dsh.profile.bundles 里没有 ${PLUGIN_ID}(现有:${Array.isArray(bundles) ? bundles.join(', ') : '无'})`)
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 `${bundles.length} 个 bundle`
return `${packageJson.name} ${packageJson.version}`
})
const linkedDir = path.join(profileDir, 'node_modules', PLUGIN_ID)
let entryFile = null
check('链接目录与入口文件存在', () => {
const stat = fs.statSync(linkedDir)
if (!stat.isDirectory()) throw new Error(`${linkedDir} 不是目录`)
const pkg = JSON.parse(fs.readFileSync(path.join(linkedDir, 'package.json'), 'utf8'))
const exported = pkg?.exports?.['./client']
const rel = typeof exported === 'string' ? exported : exported?.import ?? exported?.default
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(linkedDir, rel)
entryFile = path.join(PACKAGE_ROOT, rel)
const size = fs.statSync(entryFile).size
if (size < 1024) throw new Error(`入口文件过小(${size} 字节),可能是空壳`)
return `${path.basename(entryFile)} · ${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(PLUGIN_ID)) throw new Error(`入口里没有插件 id ${PLUGIN_ID}`)
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 侧装配:内存账本上能起 13 条路由', () => {
check('Host 侧装配:内存账本上能起 16 条路由', () => {
const routes = new Map()
const fakeCtx = {
get: () => undefined,
@ -98,7 +78,7 @@ check('Host 侧装配:内存账本上能起 13 条路由', () => {
const store = new WorkbenchStore({ file: null })
const host = createWorkbenchHost(fakeCtx, { store, startReconciler: false, load: false })
try {
if (routes.size !== 13) throw new Error(`注册了 ${routes.size} 条路由,预期 13 条`)
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)
@ -109,13 +89,18 @@ check('Host 侧装配:内存账本上能起 13 条路由', () => {
}
})
check('账本落点可写(重启后第一次写账不会失败)', () => {
check('账本落点可写(只做 access 检查,不创建文件)', () => {
const dir = path.join(dshHome(), 'sansheng-liubu')
fs.mkdirSync(dir, { recursive: true })
const probe = path.join(dir, '.preflight')
fs.writeFileSync(probe, String(Date.now()))
fs.rmSync(probe, { force: true })
return dir
// 从目标目录向上找第一个真实存在的父目录;只检查写权限,不创建目录或文件。
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

View File

@ -1,164 +0,0 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import {
COURT_ROLES,
DEFAULT_ROUTES,
EXECUTION_TOOLSET,
inject,
roleFromMembership,
routeForRole,
toolsetForRole,
evaluateToolPolicy,
apply,
} from '../index.js'
const approvedTask = ownerName => ({ id: 'exec-1', status: 'in_progress', ownerName, blockedBy: [] })
function mockRuntime(role = 'lead') {
const sections = new Map()
const tools = new Map()
const agent = {
ctx: {
effect: callback => callback(),
systemPrompt: {
getSectionOrder: () => 0,
section: section => {
if (sections.has(section.name)) throw new Error(`duplicate prompt ${section.name}`)
sections.set(section.name, section)
return () => sections.delete(section.name)
},
},
on: () => () => {},
tools: {
register: definition => { tools.set(definition.name, definition); return () => tools.delete(definition.name) },
guard: callback => { agent.guard = callback; return () => { delete agent.guard } },
},
},
}
const ctx = {
agents: { list: () => [agent] },
agentPresets: { composedPreset: () => 'sansheng-liubu' },
agentTeams: {
tryMembership: () => role === 'unassigned' ? undefined : role === 'lead' ? { role: 'lead', name: 'lead' } : { role: 'teammate', name: role },
listTasks: () => [],
},
logger: { info: () => {}, warn: () => {} },
on: () => () => {},
}
return { ctx, agent, sections, tools }
}
test('maps roles and preserves model routes', () => {
assert.equal(roleFromMembership(undefined), 'lead')
assert.equal(roleFromMembership({ role: 'lead', name: 'lead' }), 'lead')
assert.equal(roleFromMembership({ role: 'teammate', name: 'menxia' }), 'menxia')
assert.equal(routeForRole('lead', DEFAULT_ROUTES), undefined, '默认不强制模型,避免宿主缺少适配器')
assert.deepEqual(routeForRole('lead', { lead: { provider: 'p', model: 'm', reasoningEffort: 'high' } }), { provider: 'p', model: 'm', reasoningEffort: 'high' })
assert.equal(routeForRole('gongbu', { minister: { provider: 'p', model: 'm' } }).model, 'm', '未列出的角色回退到 minister 路由')
assert.equal(inject.includes('sanshengLiubuGeneration'), false)
assert.equal(inject.includes('credentials'), false)
})
test('maps the normal unassigned primary agent to Chancellor automatically', () => {
const runtime = mockRuntime('unassigned')
const dispose = apply(runtime.ctx)
assert.match(runtime.sections.get('sansheng-liubu:role').text, /三省六部模式:丞相/)
dispose()
})
test('keeps execution file tools and planning roles read-only', () => {
for (const role of ['gongbu', 'libu', 'hubu', 'lipu', 'bingbu', 'xingbu']) {
assert.deepEqual(toolsetForRole(role), EXECUTION_TOOLSET)
}
for (const role of ['gongbu', 'lipu', 'bingbu', 'xingbu']) {
assert.equal(evaluateToolPolicy(role, 'bash', [approvedTask(role)]), undefined)
}
assert.match(evaluateToolPolicy('menxia', 'write', []), /只读/)
})
test('keeps clerk and revenue ministries off the command line', () => {
for (const role of ['libu', 'hubu']) {
assert.equal(evaluateToolPolicy(role, 'write', [approvedTask(role)]), undefined)
assert.match(evaluateToolPolicy(role, 'bash', [approvedTask(role)]), /不属于/)
}
assert.match(evaluateToolPolicy('libu', 'pwsh', [approvedTask('libu')]), /不属于/)
})
test('keeps the court at ten seats', () => {
assert.equal(COURT_ROLES.length, 10)
assert.deepEqual([...COURT_ROLES].sort(), ['bingbu', 'gongbu', 'hubu', 'lead', 'libu', 'lipu', 'menxia', 'shangshu', 'xingbu', 'zhongshu'])
for (const role of COURT_ROLES.filter((entry) => entry !== 'lead')) {
assert.equal(roleFromMembership({ role: 'teammate', name: role }), role, `${role} 是可识别的朝堂角色`)
}
assert.equal(roleFromMembership({ role: 'lead', name: 'lead' }), 'lead', '丞相由主会话担任')
})
test('allows Image-gen generation, batch, and edit only for approved Gongbu work', () => {
for (const tool of ['generate_image', 'generate_images', 'edit_image']) {
assert.match(evaluateToolPolicy('gongbu', tool, []), /尚未准奏/)
assert.equal(evaluateToolPolicy('gongbu', tool, [approvedTask('gongbu')]), undefined)
assert.match(evaluateToolPolicy('libu', tool, [approvedTask('libu')]), /不属于/)
assert.match(evaluateToolPolicy('lead', tool, []), /只读/)
}
})
test('blocks non-Image-gen image tools', () => {
for (const tool of ['image_generate', 'codex_image_generate']) {
assert.match(evaluateToolPolicy('gongbu', tool, [approvedTask('gongbu')]), /只允许使用 Image-gen/)
}
})
test('does not register duplicate image tools', () => {
const runtime = mockRuntime('gongbu')
const dispose = apply(runtime.ctx)
assert.equal(runtime.tools.size, 0)
assert.deepEqual([...runtime.sections.keys()], ['sansheng-liubu:role'])
const prompt = runtime.sections.get('sansheng-liubu:role').text
assert.ok(prompt.includes('工部职责') || prompt.includes('你负责代码实现'), '工部提示词已注册且不重复')
dispose()
})
test('role prompt registration remains idempotent', () => {
const runtime = mockRuntime('gongbu')
const disposeFirst = apply(runtime.ctx)
const disposeSecond = apply(runtime.ctx)
assert.deepEqual([...runtime.sections.keys()], ['sansheng-liubu:role'])
assert.equal(runtime.tools.size, 0)
disposeFirst()
assert.ok(runtime.sections.has('sansheng-liubu:role'))
disposeSecond()
assert.equal(runtime.sections.size, 0)
})
test('keeps management tool audit and approval rules', () => {
const audit = []
assert.equal(evaluateToolPolicy('lead', 'task_board_create', [], { audit: item => audit.push(item) }), undefined)
assert.equal(audit[0].authority, 'chancellor')
assert.match(evaluateToolPolicy('bingbu', 'automation_create', [approvedTask('bingbu')]), /门下省准奏记录/)
})
test('parses the department model command the panel sends', async () => {
const { parseDeptModelCommand, describeDeptRoutes, readStoredRoutes, writeStoredRoutes } = await import('../index.js')
assert.deepEqual(parseDeptModelCommand('gongbu deepseek deepseek-chat high'), {
action: 'set',
role: 'gongbu',
route: { provider: 'deepseek', model: 'deepseek-chat', reasoningEffort: 'high' },
})
assert.equal(parseDeptModelCommand('gongbu deepseek deepseek-chat').route.reasoningEffort, undefined)
assert.equal(parseDeptModelCommand('').action, 'list')
assert.equal(parseDeptModelCommand('list').action, 'list')
assert.deepEqual(parseDeptModelCommand('clear gongbu'), { action: 'clear', role: 'gongbu' })
assert.match(parseDeptModelCommand('hufu a b').reason, /未知部门/)
assert.match(parseDeptModelCommand('gongbu deepseek').reason, /用法/)
assert.match(describeDeptRoutes({ gongbu: { provider: 'p', model: 'm', reasoningEffort: 'high' } }), /gongbu=p\/m·high/)
const { mkdtempSync, rmSync } = await import('node:fs')
const { tmpdir } = await import('node:os')
const { join } = await import('node:path')
const dir = mkdtempSync(join(tmpdir(), 'sansheng-routes-'))
const file = join(dir, 'nested', 'routes.json')
assert.equal(writeStoredRoutes(file, { bingbu: { provider: 'p', model: 'm' } }), true)
assert.deepEqual(readStoredRoutes(file).bingbu, { provider: 'p', model: 'm' })
assert.deepEqual(readStoredRoutes(join(dir, 'missing.json')), {}, '读不到就当没有固定过')
rmSync(dir, { recursive: true, force: true })
})

194
workbench/core/memory.mjs Normal file
View File

@ -0,0 +1,194 @@
// 记忆层:模仿 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

@ -4,7 +4,7 @@
import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
import { homedir } from 'node:os'
import { dirname, join, resolve } from 'node:path'
import { dirname, join, resolve, win32 } from 'node:path'
import { createIdFactory, isIdOf, newId } from './ids.mjs'
import { ROLES, isRoleId } from './roles.mjs'
import { assertTransition, isTerminal, isState } from './states.mjs'
@ -80,8 +80,15 @@ export class StoreError extends Error {
}
}
// DSH_HOME 是 Windows 绝对路径(盘符或 UNC)时按 Windows 语义拼:在 POSIX 上
// 直接 resolve 会把 C:\… 当相对路径拼到当前目录后面,账本就落错地方了。
const WINDOWS_ABSOLUTE = /^[A-Za-z]:[\\/]/
export function defaultStorePath(env = process.env) {
const home = env.DSH_HOME && String(env.DSH_HOME).trim() !== '' ? env.DSH_HOME : join(homedir(), '.dsh')
if (typeof home === 'string' && (WINDOWS_ABSOLUTE.test(home) || home.startsWith('\\\\'))) {
return win32.join(home, 'sansheng-liubu', 'workbench.json')
}
return join(resolve(home), 'sansheng-liubu', 'workbench.json')
}

View File

@ -19,6 +19,7 @@ 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,
@ -57,7 +58,7 @@ export {
* @param {() => number} [options.clock] 注入时钟。
* @param {() => string} [options.random] 注入随机源(测试里固定 ID 用)。
* @param {boolean} [options.load=true] 是否从磁盘加载既有账本。
* @param {string} [options.presetId] 部门会话使用的 agentPreset,默认「上朝」。
* @param {string} [options.presetId] 部门会话显式使用的 agentPreset;缺省不指定,走宿主默认创建流程。
* @param {boolean} [options.startReconciler=true] 是否启动周期对账。
* @param {number} [options.longPollMs] 事件长轮询上限(毫秒)。
* @param {number} [options.pollIntervalMs] 长轮询内部检查间隔(毫秒)。

View File

@ -7,13 +7,27 @@
import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
import { homedir } from 'node:os'
import { dirname, join, resolve } from 'node:path'
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)
}
@ -26,15 +40,15 @@ 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 resolve(override)
return join(resolveSidecarDir(env), 'workbench.json')
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 join(resolveSidecarDir(env), name)
return joinUnder(resolveSidecarDir(env), name)
}
/** 目录级入口:所有写入前都先建目录,缺目录不该表现为“保存失败”。 */

View File

@ -361,6 +361,32 @@ export function buildRouteTable(service, options = {}) {
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 }) => {

View File

@ -123,7 +123,7 @@ function normalizeRunTerminal(value, field = 'runTerminal') {
const ATTEMPT_STATE_OF_RUN = Object.freeze({ succeeded: 'succeeded', failed: 'failed', cancelled: 'cancelled' })
export function createWorkbenchService(options = {}) {
const { store, clock = Date.now, env = process.env, fileExists = null } = options
const { store, clock = Date.now, env = process.env, fileExists = null, memory = null } = options
if (store === undefined || store === null || typeof store.mutate !== 'function') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'createWorkbenchService 需要 WorkbenchStore')
}
@ -663,6 +663,17 @@ export function createWorkbenchService(options = {}) {
if (typeof packet !== 'object' || Array.isArray(packet)) {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'packet 必须是对象', { field: 'packet' })
}
// 记忆注入:派发时把部门记忆、项目记忆与长期记忆的摘录并进交接材料,
// 部门开工前就能看到「自己以前摸出的经验」「这个项目之前发生过什么」
// 与「用户长期偏好」。记忆是参考资料:读失败不拦派发,按没有记忆处理。
let memoryExcerpts = []
if (memory !== null) {
try {
memoryExcerpts = memory.excerptsFor(project.id, task.ownerRoleId)
} catch {
memoryExcerpts = []
}
}
// 修订任务默认把「要改的那份成果 + 版本」带进交接材料:
// 主责部门不需要回头翻记录,也不会改到别的版本上。
const revisionMaterials = task.scope?.kind === 'artifact-revision' && typeof task.scope.artifactId === 'string'
@ -696,7 +707,7 @@ export function createWorkbenchService(options = {}) {
acceptance: packet.acceptance === undefined ? task.acceptance : optionalArray(packet.acceptance, 'packet.acceptance'),
constraints: packet.constraints === undefined ? task.constraints : optionalArray(packet.constraints, 'packet.constraints'),
originMessageRef: packet.originMessageRef ?? task.originMessageRef,
excerpts: optionalArray(packet.excerpts, 'packet.excerpts'),
excerpts: [...optionalArray(packet.excerpts, 'packet.excerpts'), ...memoryExcerpts],
materialRefs: normalizeMaterialRefs(
packet.materialRefs === undefined ? revisionMaterials : packet.materialRefs,
project,
@ -881,6 +892,25 @@ export function createWorkbenchService(options = {}) {
}
}
// 自动记账:新成果落账后记两行——项目记忆里一行(哪个部门、做了什么),
// 主责部门自己的部门记忆里也一行(在哪个项目、做了什么),两本记忆
// 都随干活自然生长。尽力而为:写失败不影响成果本身。
if (memory !== null) {
try {
memory.appendProject(project.id, `${task.ownerRoleId} 汇报成果(任务「${task.title}」):${summary.slice(0, 500)}`)
} catch {
// 记忆是参考资料,不拖垮业务。
}
try {
const projectLabel = typeof project.displayNameCache === 'string' && project.displayNameCache !== ''
? project.displayNameCache
: project.id
memory.appendDepartment(task.ownerRoleId, `在项目「${projectLabel}」汇报成果(任务「${task.title}」):${summary.slice(0, 500)}`)
} catch {
// 同上。
}
}
if (isTerminal('task', task.status)) {
return {
result: copy(recorded.result),
@ -1316,7 +1346,7 @@ export function createWorkbenchService(options = {}) {
// ---------- 投影 ----------
/**
* bootstrap:一次拿全。projectId 为空时取列表第一个;
* bootstrap:一次拿全。projectId 为空时只返回项目清单,不默认选中第一个;
* 传入的项目不可见按 NOT_FOUND 报错,不泄露其他项目是否存在。
*/
function bootstrap(projectId) {
@ -1324,8 +1354,6 @@ export function createWorkbenchService(options = {}) {
let selectedId = null
if (projectId !== undefined && projectId !== null && projectId !== '') {
selectedId = projectIdOf({ projectId }).id
} else if (projects.length > 0) {
selectedId = projects[0].id
}
if (selectedId === null) {
return {
@ -1422,6 +1450,74 @@ export function createWorkbenchService(options = {}) {
}
}
// ---------- 记忆 ----------
function requireMemoryScope(value) {
if (value !== 'long-term' && value !== 'project' && value !== 'department') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'scope 必须是 long-term、project 或 department', { field: 'scope' })
}
return value
}
function requireMemory() {
if (memory === null) {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, '宿主未启用记忆存储')
}
return memory
}
const getMemory = guard((input = {}) => {
const scope = requireMemoryScope(input.scope)
const mem = requireMemory()
if (scope === 'long-term') {
const found = mem.readLongTerm()
return { scope, text: found.text, exists: found.exists }
}
if (scope === 'department') {
const roleId = requireRole(input.roleId, 'roleId')
const found = mem.readDepartment(roleId)
return { scope, roleId, text: found.text, exists: found.exists }
}
const project = projectIdOf(input)
const found = mem.readProject(project.id)
return { scope, projectId: project.id, text: found.text, exists: found.exists }
})
const putMemory = guard((input = {}) => {
const scope = requireMemoryScope(input.scope)
const mem = requireMemory()
if (typeof input.text !== 'string') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'text 必须是字符串', { field: 'text' })
}
if (scope === 'long-term') {
mem.writeLongTerm(input.text)
return { scope, text: input.text }
}
if (scope === 'department') {
const roleId = requireRole(input.roleId, 'roleId')
mem.writeDepartment(roleId, input.text)
return { scope, roleId, text: input.text }
}
const project = projectIdOf(input)
mem.writeProject(project.id, input.text)
return { scope, projectId: project.id, text: input.text }
})
const appendMemory = guard((input = {}) => {
const scope = requireMemoryScope(input.scope)
const mem = requireMemory()
const text = requireText(input.text, 'text')
if (scope === 'long-term') {
return { scope, text: mem.appendLongTerm(text).text }
}
if (scope === 'department') {
const roleId = requireRole(input.roleId, 'roleId')
return { scope, roleId, text: mem.appendDepartment(roleId, text).text }
}
const project = projectIdOf(input)
return { scope, projectId: project.id, text: mem.appendProject(project.id, text).text }
})
const api = {
version: WORKBENCH_SERVICE_VERSION,
store,
@ -1454,6 +1550,10 @@ export function createWorkbenchService(options = {}) {
requestTaskInput,
supplyTaskInput,
syncDecision,
// 记忆
getMemory,
putMemory,
appendMemory,
// 成果
registerArtifact,
requestArtifactRevision,

View File

@ -182,16 +182,24 @@ export function createSessionAdapter(options = {}) {
/**
* 订阅会话事件。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(sessionId, { onFrame } = {}) {
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, stop: () => abort.abort() }
const handle = { sessionId, address, stop: () => abort.abort() }
const done = (async () => {
try {
const address = { sessionId }
const stream = controller.follow({ address }, abort.signal)
for await (const frame of stream) {
if (disposed || abort.signal.aborted) break
@ -203,8 +211,23 @@ export function createSessionAdapter(options = {}) {
log(`[sansheng-liubu] 处理会话帧失败:${messageOf(error)}`)
}
}
if (!abort.signal.aborted && !disposed) log(`[sansheng-liubu] 会话订阅正常结束:${sessionId}`)
} catch (error) {
if (!abort.signal.aborted) log(`[sansheng-liubu] 会话流中断:${messageOf(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)
}
@ -245,6 +268,26 @@ export function createSessionAdapter(options = {}) {
})
}
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)
}

View File

@ -7,7 +7,10 @@
// 能力探测优先:宿主没有 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'
@ -22,7 +25,7 @@ export const WORKBENCH_HOST_VERSION = 1
* @param {object} [options.store] 已有 store(测试注入);缺省按环境建一个。
* @param {object} [options.service] 已有 service;缺省按 store 新建。给了 service 就必须同时给 store,
* 否则两边的账不是同一本。
* @param {string} [options.presetId] 部门会话使用的 agentPreset,首版沿用「上朝」。
* @param {string} [options.presetId] 部门会话显式使用的 agentPreset;缺省不指定,走宿主默认创建流程。
* @param {boolean} [options.startReconciler] 是否启动周期对账,默认 true。
*/
export function createWorkbenchHost(ctx, options = {}) {
@ -35,7 +38,12 @@ export function createWorkbenchHost(ctx, options = {}) {
}
const store = options.store ?? createStore(options)
const service = options.service ?? createWorkbenchService({ store, clock: options.clock, fileExists: options.fileExists })
// 记忆层:默认落在侧车目录的 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 装好,所以这里只是「尝试挂载」,
@ -61,9 +69,82 @@ export function createWorkbenchHost(ctx, options = {}) {
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)
@ -73,7 +154,35 @@ export function createWorkbenchHost(ctx, options = {}) {
mountSessions(ctx?.sessionController ?? ctx?.remote?.session ?? null)
const presetId = typeof options.presetId === 'string' && options.presetId !== '' ? options.presetId : 'sansheng-liubu'
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 建一个并登记。
@ -91,12 +200,17 @@ export function createWorkbenchHost(ctx, options = {}) {
const existing = binding?.currentSessionId ?? null
if (existing !== null) {
const known = await sessions.inspectSession(existing)
if (known !== null) return { sessionId: existing, created: false, seat: seatOf(projectId, roleId) }
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: input.agentPreset ?? presetId,
agentPreset: requestedPreset,
})
// 账上登记:同一会话被别的部门占用时 store 会拒绝,正是我们要的“会话独占”。
const saved = service.bindDepartmentSession({
@ -105,6 +219,7 @@ export function createWorkbenchHost(ctx, options = {}) {
sessionId: target.sessionId,
allowReplace: existing !== null,
})
followSession(target.sessionId)
return { sessionId: target.sessionId, created: target.created === true, seat: saved.seat }
}
@ -168,6 +283,7 @@ export function createWorkbenchHost(ctx, options = {}) {
version: WORKBENCH_HOST_VERSION,
store,
service,
memory,
// 会话层可能晚到:用 getter,调用方总能读到最新挂载结果。
get sessions() {
return sessions

View File

@ -0,0 +1,9 @@
# 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: {}

15
workbench/panel/index.js Normal file
View File

@ -0,0 +1,15 @@
/**
* 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) {}

View File

@ -1,5 +1,5 @@
window.__ModuleLoader__.load({
id: "dsh-sansheng-liubu-workbench",
id: "dsh-sansheng-liubu-mode",
factory: (require) => {
var module = { exports: {} };
var exports = module.exports;
@ -15,7 +15,7 @@ window.__ModuleLoader__.load({
const API_BASE = "/sansheng/workbench";
const TAB_ID = "sansheng-liubu-workbench";
const TAB_KIND = "sansheng-liubu-workbench";
const CSS_ID = "dsh-sansheng-liubu-workbench/workbench.css";
const CSS_ID = "dsh-sansheng-liubu-mode/workbench.css";
const RAIL_WIDTH_KEY = "sansheng.workbench.railWidth";
const MAIN_SWITCH_KEY = "sansheng.workbench.main";
const RAIL_MIN = 340;
@ -175,16 +175,12 @@ window.__ModuleLoader__.load({
function pickProjectId(data, hostWorkspaceId) {
var projects = data && Array.isArray(data.projects) ? data.projects : [];
if (hostWorkspaceId) {
for (var i = 0; i < projects.length; i++) {
var project = projects[i];
if (project && project.hostWorkspaceId === hostWorkspaceId && project.id) return project.id;
}
return null;
}
if (data && typeof data.projectId === "string" && data.projectId) return data.projectId;
for (var j = 0; j < projects.length; j++) {
if (projects[j] && projects[j].id) return projects[j].id;
// 必须显式给出 hostWorkspaceId 才允许匹配;绝不在缺失时退回 bootstrap
// 默认项目或列表第一项——那会把 A 项目的席位/任务显示到 B 工作区。
if (typeof hostWorkspaceId !== "string" || hostWorkspaceId === "") return null;
for (var i = 0; i < projects.length; i++) {
var project = projects[i];
if (project && project.hostWorkspaceId === hostWorkspaceId && project.id) return project.id;
}
return null;
}
@ -433,75 +429,102 @@ window.__ModuleLoader__.load({
}
}
function betterSidebarOf(ctx) {
var candidates = [readService(ctx, "betterSidebar"), ctx && ctx.betterSidebar];
for (var i = 0; i < candidates.length; i++) {
var candidate = candidates[i];
if (candidate && typeof candidate.registerTab === "function") return candidate;
}
return null;
}
function sidebarRightTabsOf(ctx) {
var service = readService(ctx, "sidebarRightTabs");
if (service && typeof service.register === "function") return service;
return null;
}
function effectOf(ctx, factory, label) {
if (ctx && typeof ctx.effect === "function") return ctx.effect(factory, label);
function workspacesSnapshotOf(ctx) {
var service = readService(ctx, "workspaces");
var source = service && service.list ? service.list : service;
if (!source || typeof source.getSnapshot !== "function") return null;
try {
return factory();
return source.getSnapshot();
} catch (error) {
console.warn("[sansheng-workbench] " + label + " 注册失败", error);
return undefined;
return null;
}
}
/**
* 当前会话的公开来源:`sessions.list` 里保留在 `mainView` 引用源上的
* 那一条。当前 DSH 不提供 `SessionListState.current`,也不提供
* `uiWorkspace.currentWorkspaceId`/`selection`;这是宿主公开的等价事实。
*/
function currentSessionIdOf(ctx) {
var sessions = readService(ctx, "sessions");
var source = sessions && sessions.list ? sessions.list : sessions;
if (!source || typeof source.getSnapshot !== "function") return null;
try {
var snapshot = source.getSnapshot();
var byId = snapshot && snapshot.byId ? snapshot.byId : {};
var ids = Object.keys(byId);
for (var i = 0; i < ids.length; i++) {
var row = byId[ids[i]];
var retained = row && row.retainedBy ? row.retainedBy.mainView : 0;
if (typeof retained === "number" && retained > 0) return ids[i];
}
} catch (error) {
// 服务形状不认识时按“没有明确选择”处理。
}
return null;
}
/**
* 由明确的会话-工作区关系取当前 workspaceId;空工作区的“新会话”
* 在宿主里同样是一个选中的空白会话,因此这里不会回退到首个项目。
*/
function workspaceIdOf(ctx) {
var workspace = ctx && ctx.uiWorkspace;
if (!workspace) return null;
var direct = workspace.currentWorkspaceId || workspace.workspaceId;
if (direct) return String(direct);
try {
var selection = workspace.selection && typeof workspace.selection.getSnapshot === "function"
? workspace.selection.getSnapshot()
: null;
if (selection && selection.workspaceId) return String(selection.workspaceId);
} catch (error) {
// 忽略:拿不到工作区就退回 bootstrap 自带 projectId。
var snapshot = workspacesSnapshotOf(ctx);
if (!snapshot || !Array.isArray(snapshot.items)) return null;
var sessionId = currentSessionIdOf(ctx);
if (typeof sessionId === "string" && sessionId !== "") {
for (var i = 0; i < snapshot.items.length; i++) {
var item = snapshot.items[i];
if (!item || !Array.isArray(item.sessionIds)) continue;
if (item.sessionIds.indexOf(sessionId) !== -1 && item.workspaceId) return String(item.workspaceId);
}
}
// 可选的项目树状态服务(workspace-groups 等):只有它明确给出选择时才采用。
var selection = readService(ctx, "workspaceGroupsSelection") || readService(ctx, "workspaceGroups");
if (selection && typeof selection.selectedWorkspaceId === "string" && selection.selectedWorkspaceId) {
return selection.selectedWorkspaceId;
}
return null;
}
function workspaceItemOf(ctx, workspaceId) {
if (typeof workspaceId !== "string" || workspaceId === "") return null;
var snapshot = workspacesSnapshotOf(ctx);
if (!snapshot || !Array.isArray(snapshot.items)) return null;
for (var i = 0; i < snapshot.items.length; i++) {
var item = snapshot.items[i];
if (item && String(item.workspaceId) === workspaceId) return item;
}
return null;
}
function displayNameOf(ctx, workspaceId) {
var workspace = ctx && ctx.uiWorkspace;
var name = workspace && (workspace.currentWorkspaceName || workspace.workspaceName || workspace.displayName);
var workspace = workspaceItemOf(ctx, workspaceId);
var name = workspace && workspace.title;
if (typeof name === "string" && name) return name;
return workspaceId ? "工作区 " + workspaceId : "";
}
function canonicalRootOf(ctx) {
var workspace = ctx && ctx.uiWorkspace;
var root = workspace && (
workspace.currentWorkspaceRoot ||
workspace.workspaceRoot ||
(workspace.currentWorkspace && workspace.currentWorkspace.root)
);
function canonicalRootOf(ctx, workspaceId) {
var workspace = workspaceItemOf(ctx, workspaceId);
var root = workspace && workspace.path;
return typeof root === "string" && root ? root : null;
}
async function resolveWorkbenchProject(ctx) {
var hostWorkspaceId = workspaceIdOf(ctx);
var value = await apiGet("bootstrap");
var targetId = pickProjectId(value, hostWorkspaceId);
// 没有明确的项目选择:只返回项目清单供界面提示,绝不拿 bootstrap
// 默认的第一个项目冒充当前项目。
if (!hostWorkspaceId) return { projectId: null, value: value };
if (hostWorkspaceId && !targetId) {
var targetId = pickProjectId(value, hostWorkspaceId);
if (!targetId) {
var body = {
hostWorkspaceId: hostWorkspaceId,
displayNameCache: displayNameOf(ctx, hostWorkspaceId),
};
var root = canonicalRootOf(ctx);
var root = canonicalRootOf(ctx, hostWorkspaceId);
if (root) body.canonicalRoot = root;
var created = null;
@ -518,15 +541,15 @@ window.__ModuleLoader__.load({
targetId = (created.project && created.project.id) || created.id || targetId;
}
if (!targetId) {
// 登记失败后重新读一次清单再精确匹配;仍无匹配就明确返回“未选择”。
value = await apiGet("bootstrap");
targetId = pickProjectId(value, hostWorkspaceId) || value.projectId || null;
targetId = pickProjectId(value, hostWorkspaceId);
}
}
if (targetId && value.projectId !== targetId) {
if (!targetId) return { projectId: null, value: value };
if (value.projectId !== targetId) {
value = await apiGet("bootstrap", { projectId: targetId });
}
if (!targetId) targetId = value.projectId || null;
return { projectId: targetId, value: value };
}
@ -688,7 +711,7 @@ window.__ModuleLoader__.load({
var selector = "style[data-plugin-css=" + JSON.stringify(CSS_ID) + "]";
if (typeof document.querySelector === "function" && document.querySelector(selector) !== null) return;
var tag = document.createElement("style");
tag.dataset.plugin = "dsh-sansheng-liubu-workbench";
tag.dataset.plugin = "dsh-sansheng-liubu-mode";
tag.dataset.pluginCss = CSS_ID;
tag.textContent = CSS;
if (document.head && typeof document.head.appendChild === "function") document.head.appendChild(tag);
@ -1145,6 +1168,19 @@ window.__ModuleLoader__.load({
projectIdRef.current = result.projectId;
seqRef.current = Number(result.value && result.value.eventSeq) || 0;
setProjectId(result.projectId);
if (!result.projectId) {
// 没有明确项目时只保留项目清单;bootstrap 的默认项目数据不能
// 被渲染成“当前项目”,否则会误显示/误操作首项目。
setData(assign({}, result.value, {
projectId: null,
project: null,
seats: [],
tasks: [],
artifacts: [],
results: [],
}));
return;
}
setData(result.value);
}
@ -1192,14 +1228,17 @@ window.__ModuleLoader__.load({
function check() {
var next = workspaceIdOf(ctx);
if (!next || next === hostRef.current) return;
if (next === hostRef.current) return;
hostRef.current = next;
var token = ++pendingToken;
var loadToken = ++loadTokenRef.current;
setData(null);
setProjectId(null);
setSelectedArtifactId(null);
setNotice(null);
setError(null);
// No explicit project still re-reads the project list so the UI can
// show “select a project”; it never falls back to the first project.
resolveWorkbenchProject(ctx).then(function (result) {
if (cancelled || token !== pendingToken) return;
applyBootstrap(result, loadToken);
@ -1209,16 +1248,25 @@ window.__ModuleLoader__.load({
});
}
var selection = workspace.selection;
var sessionsService = readService(ctx, "sessions");
var workspacesService = readService(ctx, "workspaces");
if (sessionsService && sessionsService.list && typeof sessionsService.list.subscribe === "function") {
disposers.push(sessionsService.list.subscribe(check));
}
if (workspacesService && workspacesService.list && typeof workspacesService.list.subscribe === "function") {
disposers.push(workspacesService.list.subscribe(check));
}
// 兼容旧宿主:仍暴露 uiWorkspace 订阅时一并监听。
var selection = workspace && workspace.selection;
if (selection && typeof selection.subscribe === "function") {
var off = selection.subscribe(check);
if (typeof off === "function") disposers.push(off);
}
if (typeof workspace.subscribe === "function") {
if (workspace && typeof workspace.subscribe === "function") {
var offWorkspace = workspace.subscribe(check);
if (typeof offWorkspace === "function") disposers.push(offWorkspace);
}
if (typeof workspace.on === "function") {
if (workspace && typeof workspace.on === "function") {
var offEvent = workspace.on("change", check);
if (typeof offEvent === "function") disposers.push(offEvent);
}
@ -2012,7 +2060,15 @@ window.__ModuleLoader__.load({
}
var content;
if (view === "tasks") content = renderTasks();
if (!projectId && data !== null) {
content = h("div", { className: "wb-empty", role: "status", key: "no-project" }, [
h("div", { key: "title" }, "尚未选择工作区项目"),
h("div", { key: "detail", style: { marginTop: "6px", color: "var(--wb-ink-3)" } },
"请在左侧工作区项目树中选择一个项目(空工作区也可以);未选择项目时不会读取或修改任何项目。"),
]);
} else if (!projectId) {
content = renderCourt();
} else if (view === "tasks") content = renderTasks();
else if (view === "artifacts") content = renderArtifacts();
else content = renderCourt();
@ -2059,7 +2115,14 @@ window.__ModuleLoader__.load({
? renderFactorySlot(
"conversation.content",
{ variant: "main", phase: phaseValue, hero: heroValue },
{ slots: { widthControls: input.widthControls || {} } },
// widthControls 槽要的是组件本身(官方根组件传的是
// ConversationWidthControls 函数);宿主没有给真组件时
// 宁可不传 slots,让工厂用它自带的 NoConversationWidthControls
// 兜底。旧版在这里塞了个空对象 {},工厂把它当组件渲染,
// React 抛 #130(element type got: object),中央会话整片白屏。
typeof input.widthControls === "function"
? { slots: { widthControls: input.widthControls } }
: {},
)
: null,
]);
@ -2149,41 +2212,166 @@ window.__ModuleLoader__.load({
// 注册
// ---------------------------------------------------------------------
function entryDiagnostic(level, message) {
try {
if (level === "error") console.error("[sansheng-workbench][entry] " + message);
else if (level === "info") console.info("[sansheng-workbench][entry] " + message);
else console.warn("[sansheng-workbench][entry] " + message);
} catch (ignored) {
// 日志失败不能影响入口。
}
}
/** 把一次注册托管给 ctx.effect;没有 effect 的宿主/测试直接返回 disposer。 */
function ownRegistration(ctx, factory, label) {
if (ctx && typeof ctx.effect === "function") {
var dispose = ctx.effect(factory, label);
return typeof dispose === "function" ? dispose : function () {};
}
try {
var value = factory();
return typeof value === "function" ? value : function () {};
} catch (error) {
entryDiagnostic("error", label + " 注册失败:" + (error && error.message ? error.message : error));
return function () {};
}
}
function registerBetterEntry(ctx, better) {
return ownRegistration(ctx, function () {
return better.registerTab({
id: TAB_ID,
title: "朝堂",
description: "三省六部 · 十席部门树",
order: 5,
single: true,
component: function (props) {
return h(WorkbenchPanel, { ctx: ctx, scope: props && props.scope });
},
});
}, "三省六部工作台:better-sidebar 页签");
}
function registerNativeEntry(ctx, tabs) {
return ownRegistration(ctx, function () {
return tabs.register({
id: TAB_ID,
kind: TAB_KIND,
priority: "builtin",
title: function () {
return "朝堂";
},
// 原生右栏的 guide 是首次进入的唯一入口:没有它时页签类型虽注册,
// 用户也找不到可点的“朝堂”胶囊。guide 与 title 保持同一文案。
guide: [{
id: TAB_ID,
order: 5,
title: function () {
return "朝堂";
},
description: function () {
return "三省六部 · 十席部门树";
},
}],
});
}, "三省六部工作台:原生右侧栏页签");
}
/**
* 入口注册控制器:betterSidebar 与原生 sidebarRightTabs 都按服务生命周期
* 监听。任一时刻只保留一个活动入口;服务消失后自动清理,服务晚到/重挂
* 时重新注册,绝不重复叠加。
*/
function createEntryController(ctx) {
var better = null;
var nativeTabs = null;
var active = null;
function disposeActive() {
if (active === null) return;
var dispose = active.dispose;
active = null;
try {
if (typeof dispose === "function") dispose();
} catch (error) {
entryDiagnostic("error", "清理旧入口失败:" + (error && error.message ? error.message : error));
}
}
function reconcile() {
var wanted = better !== null
? { kind: "better", service: better }
: nativeTabs !== null
? { kind: "native", service: nativeTabs }
: null;
if (wanted === null) {
disposeActive();
entryDiagnostic("warn", "betterSidebar / sidebarRightTabs 均未就绪,等待服务");
return;
}
if (active !== null && active.kind === wanted.kind && active.service === wanted.service) return;
disposeActive();
try {
var dispose = wanted.kind === "better"
? registerBetterEntry(ctx, wanted.service)
: registerNativeEntry(ctx, wanted.service);
active = { kind: wanted.kind, service: wanted.service, dispose: typeof dispose === "function" ? dispose : function () {} };
entryDiagnostic("info", "已注册朝堂入口(" + (wanted.kind === "better" ? "betterSidebar" : "原生 sidebarRightTabs") + ")");
} catch (error) {
active = null;
entryDiagnostic("error", "朝堂入口注册失败:" + (error && error.message ? error.message : error));
}
}
function setBetter(service) {
better = service !== null && service !== undefined && typeof service.registerTab === "function" ? service : null;
reconcile();
}
function setNativeTabs(service) {
nativeTabs = service !== null && service !== undefined && typeof service.register === "function" ? service : null;
reconcile();
}
return {
setBetter: setBetter,
setNativeTabs: setNativeTabs,
reconcile: reconcile,
dispose: disposeActive,
get activeKind() {
return active === null ? null : active.kind;
},
};
}
function watchClientService(ctx, name, setter) {
if (ctx && typeof ctx.inject === "function") {
try {
ctx.inject([name], function (scope) {
setter(readService(scope, name));
return function () {
setter(null);
};
});
return;
} catch (error) {
entryDiagnostic("error", "监听服务 " + name + " 失败:" + (error && error.message ? error.message : error));
}
}
// 旧宿主或测试替身没有 ctx.inject:退化为一次同步探测。
setter(readService(ctx, name));
}
function apply(ctx) {
if (!ctx) throw new Error("三省六部工作台需要宿主上下文");
// 1) 右侧栏页签「朝堂」:优先 better-sidebar 的 registerTab。
var better = betterSidebarOf(ctx);
if (better) {
effectOf(ctx, function () {
return better.registerTab({
id: TAB_ID,
title: "朝堂",
description: "三省六部 · 十席部门树",
order: 5,
single: true,
component: function (props) {
return h(WorkbenchPanel, { ctx: ctx, scope: props && props.scope });
},
});
}, "三省六部工作台:better-sidebar 页签");
} else {
var tabs = sidebarRightTabsOf(ctx);
if (tabs) {
effectOf(ctx, function () {
return tabs.register({
id: TAB_ID,
kind: TAB_KIND,
priority: "builtin",
title: function () {
return "朝堂";
},
});
}, "三省六部工作台:右侧栏页签");
} else {
console.warn("[sansheng-workbench] 宿主没有 betterSidebar / sidebarRightTabs,页签可能无法停靠;pane 槽仍会注册。");
}
}
// 1) 右侧栏页签「朝堂」:服务生命周期驱动注册。
// 优先 better-sidebar;没有时用原生 sidebarRightTabs(含 guide 入口)。
// 两条路径由同一个控制器互斥,服务重挂不会重复注册。
var entry = createEntryController(ctx);
watchClientService(ctx, "betterSidebar", entry.setBetter);
watchClientService(ctx, "sidebarRightTabs", entry.setNativeTabs);
entry.reconcile();
// 2) 页签内容 + 标题:即使上面没有服务也注册,宿主若按槽渲染仍可用。
if (ctx.slots && typeof ctx.slots.inject === "function") {
@ -2203,18 +2391,28 @@ window.__ModuleLoader__.load({
// 逃生开关:localStorage["sansheng.workbench.main"] = "off" 时跳过本段。
if (mainTakeoverEnabled() && ctx.slots && typeof ctx.slots.inject === "function") {
ctx.slots.inject("main.conversation", function () {
return ctx.slots.register({
name: "main.conversation",
priority: -1,
children: {
"conversation.header": { kind: "single", scope: "session-maybe" },
},
}, createConversationMain(ctx));
try {
return ctx.slots.register({
name: "main.conversation",
priority: -1,
children: {
"conversation.header": { kind: "single", scope: "session-maybe" },
},
}, createConversationMain(ctx));
} catch (error) {
// 官方会话入口已声明 conversation.header:重复声明会被宿主拒绝,
// 退回不带 children 的注册——槽本身由官方入口声明、仍然存在,
// 组件里的 renderSlot("conversation.header") 照常工作。
return ctx.slots.register({
name: "main.conversation",
priority: -1,
}, createConversationMain(ctx));
}
});
}
}
exports.inject = ["slots", "sessions", "uiWorkspace", "uiConversation"];
exports.inject = ["slots", "sessions", "workspaces", "uiWorkspace", "uiConversation"];
exports.apply = apply;
exports.WorkbenchRail = WorkbenchRail;
exports.WorkbenchPanel = WorkbenchPanel;
@ -2225,6 +2423,8 @@ window.__ModuleLoader__.load({
mergeEvents: mergeEvents,
apiPath: apiPath,
pickProjectId: pickProjectId,
workspaceIdOf: workspaceIdOf,
currentSessionIdOf: currentSessionIdOf,
formatModelLine: formatModelLine,
seatDisplayName: seatDisplayName,
modelTitle: modelTitle,

View File

@ -1,26 +1,10 @@
{
"name": "dsh-sansheng-liubu-workbench",
"version": "0.1.0",
"private": true,
"description": "三省六部工作台:右侧朝堂部门树、任务与成果",
"name": "dsh-sansheng-liubu-mode-panel-source",
"version": "0.14.0",
"description": "三省六部工作台面板源码(已并入 dsh-sansheng-liubu-mode,不是独立安装包)",
"type": "module",
"exports": {
"./client": "./lib/client.js"
},
"private": true,
"files": [
"lib/**"
],
"dsh": {
"client": {
"platform": "web",
"inject": [
"@deepseek-ai/dsh-api-session-controller",
"@deepseek-ai/dsh-client-ui-workspace",
"@deepseek-ai/dsh-client-ui-primitives"
]
}
},
"peerDependencies": {
"@deepseek-ai/cordis": "~4.0.5"
}
]
}

View File

@ -121,7 +121,7 @@ function loadPlugin(options) {
vm.runInNewContext(SOURCE, sandbox, { filename: CLIENT_PATH });
assert.ok(definition, "bundle 应该调用 window.__ModuleLoader__.load");
assert.equal(definition.id, "dsh-sansheng-liubu-workbench", "bundle id 必须是包名");
assert.equal(definition.id, "dsh-sansheng-liubu-mode", "bundle id 必须是主包包名(面板已并回主包)");
const exports = definition.factory(function (id) {
if (id === "react") return react;
@ -182,12 +182,12 @@ test("bundle 契约:id、inject 与纯函数导出", function () {
const plugin = loadPlugin();
const api = plugin.exports;
assert.deepEqual(Array.from(api.inject), ["slots", "sessions", "uiWorkspace", "uiConversation"]);
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", "formatModelLine", "ROLE_META"];
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"]);
@ -336,7 +336,7 @@ test("apiPath:拼出同源工作台路径并编码查询串", function () {
assert.equal(apiPath("bootstrap", {}), "/sansheng/workbench/bootstrap");
});
test("pickProjectId:优先当前工作区,其次 bootstrap 默认项目", function () {
test("pickProjectId:只按明确的 hostWorkspaceId 匹配,缺省不再退回首项目", function () {
const { pickProjectId } = loadPlugin().exports.__test;
const data = {
projectId: "p-default",
@ -347,9 +347,51 @@ test("pickProjectId:优先当前工作区,其次 bootstrap 默认项目", fu
};
assert.equal(pickProjectId(data, "ws-mine"), "p-mine");
assert.equal(pickProjectId(data, "ws-missing"), null);
assert.equal(pickProjectId(data), "p-default");
assert.equal(pickProjectId({ projects: [{ id: "p-only" }] }), "p-only");
assert.equal(pickProjectId({ projects: [] }), 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 () {
@ -365,6 +407,10 @@ test("apply:注册朝堂页签、pane 槽与 priority -1 的 main.conversation
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");
@ -372,6 +418,62 @@ test("apply:注册朝堂页签、pane 槽与 priority -1 的 main.conversation
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();

View File

@ -129,7 +129,7 @@ test('装配层:宿主先有 webServer、后有 sessionController 时,派发
const host = createWorkbenchHost(ctx, { store, startReconciler: false })
assert.equal(host.store, store)
assert.equal(host.registered, true)
assert.equal(webServer.routes.size, 13)
assert.equal(webServer.routes.size, 16)
assert.equal(host.hasSessions, false)
const project = host.service.registerProject({ hostWorkspaceId: WS }).project

View File

@ -156,6 +156,55 @@ test('会话适配:prompt 必须带 requestId,错误分类可区分可重试
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: ['只读源文件'] },

View File

@ -0,0 +1,235 @@
// 记忆层测试:三层记忆的读写与隔离、派发注入、成果自动记账。
// 用真实 WorkbenchStore(内存账本)+ 临时目录里的真实记忆文件,不 mock 存储层。
import test from 'node:test'
import assert from 'node:assert/strict'
import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { WorkbenchStore } from '../core/store.mjs'
import { createMemoryStore, MEMORY_EXCERPT_CHARS } from '../core/memory.mjs'
import { createWorkbenchService } from '../host/service.mjs'
const FIXED_NOW = Date.parse('2026-11-10T12:00:00.000Z')
function makeWorld(withMemory = true) {
const dir = mkdtempSync(join(tmpdir(), 'sansheng-memory-'))
let counter = 1234567
const random = () => Math.imul(counter++, 2654435761) >>> 0
const store = new WorkbenchStore({ file: null, clock: () => FIXED_NOW, random })
const memory = createMemoryStore({ dir: join(dir, 'memory'), clock: () => FIXED_NOW })
const service = createWorkbenchService({
store,
clock: () => FIXED_NOW,
...(withMemory ? { memory } : {}),
})
const project = service.registerProject({ hostWorkspaceId: 'ws-1', displayNameCache: '项目一' }).project
service.bindDepartmentSession({ projectId: project.id, roleId: 'libu', sessionId: 'sess-libu' })
return { dir, store, memory, service, project }
}
function cleanup(world) {
rmSync(world.dir, { recursive: true, force: true })
}
// ---------- 记忆存储 ----------
test('memory store: long-term write/read and dated appends', () => {
const world = makeWorld()
try {
const { memory } = world
assert.deepEqual(memory.readLongTerm(), { text: '', exists: false })
memory.writeLongTerm('用户偏好:结论先行')
assert.equal(memory.readLongTerm().text, '用户偏好:结论先行')
memory.appendLongTerm('长期经验:先小步验证')
const text = memory.readLongTerm().text
assert.ok(text.includes('用户偏好:结论先行'))
assert.ok(text.includes('## 2026-11-10'))
assert.ok(text.includes('长期经验:先小步验证'))
// 文件就是普通 Markdown,落在 long-term.md
assert.equal(readFileSync(memory.longTermPath, 'utf8'), text)
} finally { cleanup(world) }
})
test('memory store: project memories are isolated and ids are validated', () => {
const world = makeWorld()
try {
const { memory, project } = world
const other = world.service.registerProject({ hostWorkspaceId: 'ws-2' }).project
memory.appendProject(project.id, '本项目的约定:数据先复算')
assert.ok(memory.readProject(project.id).text.includes('数据先复算'))
assert.equal(memory.readProject(other.id).exists, false, '别的项目读不到本项目记忆')
assert.throws(() => memory.readProject('../evil'), /不合法/)
assert.throws(() => memory.appendProject('task_abc', 'x'), /不合法/)
assert.throws(() => memory.appendLongTerm(' '), /不能为空/)
assert.throws(() => memory.writeLongTerm('x'.repeat(70 * 1024)), /上限/)
} finally { cleanup(world) }
})
test('memory store: excerpts are labeled, project first, and capped', () => {
const world = makeWorld()
try {
const { memory, project } = world
assert.deepEqual(memory.excerptsFor(project.id), [], '没有记忆就没有摘录')
memory.writeLongTerm('长'.repeat(MEMORY_EXCERPT_CHARS.longTerm + 100))
memory.writeProject(project.id, '项'.repeat(MEMORY_EXCERPT_CHARS.project + 100))
const excerpts = memory.excerptsFor(project.id)
assert.equal(excerpts.length, 2)
assert.ok(excerpts[0].startsWith('「项目记忆」'))
assert.ok(excerpts[1].startsWith('「长期记忆」'))
assert.ok(excerpts[0].includes('已截断'))
assert.ok(excerpts[0].length < MEMORY_EXCERPT_CHARS.project + 40)
} finally { cleanup(world) }
})
// ---------- 服务层 ----------
test('service memory API: scopes, project checks, and disabled memory', () => {
const world = makeWorld()
try {
const { service, project } = world
service.putMemory({ scope: 'long-term', text: '全局约定' })
assert.equal(service.getMemory({ scope: 'long-term' }).text, '全局约定')
service.appendMemory({ scope: 'project', projectId: project.id, text: '第一次结论' })
const got = service.getMemory({ scope: 'project', projectId: project.id })
assert.ok(got.text.includes('第一次结论'))
assert.throws(() => service.getMemory({ scope: 'sideways' }), (e) => e.code === 'INVALID_INPUT')
assert.throws(() => service.getMemory({ scope: 'project', projectId: 'proj_missing1' }), (e) => e.code === 'NOT_FOUND')
} finally { cleanup(world) }
const bare = makeWorld(false)
try {
assert.throws(() => bare.service.getMemory({ scope: 'long-term' }), (e) => e.code === 'INVALID_STATE')
} finally { cleanup(bare) }
})
test('dispatch injects memory excerpts into the context packet', () => {
const world = makeWorld()
try {
const { service, project } = world
service.putMemory({ scope: 'long-term', text: '长期偏好:先给结论' })
service.putMemory({ scope: 'project', projectId: project.id, text: '项目背景:二期工程' })
const task = service.createTask({ projectId: project.id, title: '甲', objective: '甲目标', ownerRoleId: 'libu' }).task
const dispatched = service.dispatchTask({
projectId: project.id,
taskId: task.id,
idempotencyKey: 'idem-mem-1',
packet: { excerpts: ['原始需求'] },
})
const excerpts = dispatched.contextPacket.excerpts
assert.equal(excerpts[0], '原始需求', '调用方摘录在最前')
assert.ok(excerpts.some((line) => line.startsWith('「项目记忆」') && line.includes('二期工程')))
assert.ok(excerpts.some((line) => line.startsWith('「长期记忆」') && line.includes('先给结论')))
} finally { cleanup(world) }
})
test('result report journals into project memory once, duplicates do not re-journal', () => {
const world = makeWorld()
try {
const { service, memory, project } = world
const task = service.createTask({ projectId: project.id, title: '乙', objective: '乙目标', ownerRoleId: 'libu' }).task
const dispatched = service.dispatchTask({ projectId: project.id, taskId: task.id, idempotencyKey: 'idem-mem-2' })
service.startAttempt({ projectId: project.id, taskId: task.id, attemptId: dispatched.attempt.id, hostRunId: 'run-1' })
const input = {
projectId: project.id,
taskId: task.id,
attemptId: dispatched.attempt.id,
report: { summary: '已完成测算' },
runTerminal: 'succeeded',
}
service.reportTaskResult(input)
service.reportTaskResult(input)
const text = memory.readProject(project.id).text
assert.ok(text.includes('libu 汇报成果'))
assert.ok(text.includes('已完成测算'))
assert.equal(text.split('已完成测算').length - 1, 1, '重复汇报只记一行')
} finally { cleanup(world) }
})
// ---------- 部门记忆(第三层) ----------
test('memory store: department memories are per-role, isolated, and validated', () => {
const world = makeWorld()
try {
const { memory } = world
assert.deepEqual(memory.readDepartment('gongbu'), { text: '', exists: false })
memory.appendDepartment('gongbu', '工部经验:先量尺寸再下料')
assert.ok(memory.readDepartment('gongbu').text.includes('先量尺寸再下料'))
assert.equal(memory.readDepartment('xingbu').exists, false, '别的部门读不到工部记忆')
// 文件落在 departments/<roleId>.md,就是普通 Markdown
assert.equal(readFileSync(memory.departmentPath('gongbu'), 'utf8'), memory.readDepartment('gongbu').text)
assert.throws(() => memory.readDepartment('not-a-role'), /不合法/)
assert.throws(() => memory.appendDepartment('../evil', 'x'), /不合法/)
} finally { cleanup(world) }
})
test('memory store: excerpts put department first when a role is given', () => {
const world = makeWorld()
try {
const { memory, project } = world
memory.writeDepartment('libu', '吏部经验:名册先行')
memory.writeProject(project.id, '项目背景')
memory.writeLongTerm('长期偏好')
const withRole = memory.excerptsFor(project.id, 'libu')
assert.equal(withRole.length, 3)
assert.ok(withRole[0].startsWith('「部门记忆」'))
assert.ok(withRole[1].startsWith('「项目记忆」'))
assert.ok(withRole[2].startsWith('「长期记忆」'))
const withoutRole = memory.excerptsFor(project.id)
assert.equal(withoutRole.length, 2, '不给部门就没有部门层(旧行为不变)')
const bogusRole = memory.excerptsFor(project.id, 'not-a-role')
assert.equal(bogusRole.length, 2, '非法部门跳过部门层,不抛错')
} finally { cleanup(world) }
})
test('service memory API: department scope roundtrip and role validation', () => {
const world = makeWorld()
try {
const { service } = world
service.putMemory({ scope: 'department', roleId: 'hubu', text: '户部全局约定' })
assert.equal(service.getMemory({ scope: 'department', roleId: 'hubu' }).text, '户部全局约定')
service.appendMemory({ scope: 'department', roleId: 'hubu', text: '追加一条' })
assert.ok(service.getMemory({ scope: 'department', roleId: 'hubu' }).text.includes('追加一条'))
assert.throws(() => service.getMemory({ scope: 'department', roleId: 'nobody' }), (e) => e.code === 'INVALID_ROLE')
assert.throws(() => service.putMemory({ scope: 'department', text: 'x' }), (e) => e.code === 'INVALID_ROLE')
} finally { cleanup(world) }
})
test('dispatch injects only the owner department memory', () => {
const world = makeWorld()
try {
const { service, project } = world
service.putMemory({ scope: 'department', roleId: 'libu', text: '吏部经验:先建名册' })
service.putMemory({ scope: 'department', roleId: 'gongbu', text: '工部经验:先量尺寸' })
const task = service.createTask({ projectId: project.id, title: '丙', objective: '丙目标', ownerRoleId: 'libu' }).task
const dispatched = service.dispatchTask({ projectId: project.id, taskId: task.id, idempotencyKey: 'idem-mem-3' })
const excerpts = dispatched.contextPacket.excerpts
const dept = excerpts.find((line) => line.startsWith('「部门记忆」'))
assert.ok(dept !== undefined && dept.includes('先建名册'), '带上主责部门自己的记忆')
assert.ok(!excerpts.some((line) => line.includes('先量尺寸')), '别的部门的记忆不注入')
} finally { cleanup(world) }
})
test('result report also journals into the owner department memory, once', () => {
const world = makeWorld()
try {
const { service, memory, project } = world
const task = service.createTask({ projectId: project.id, title: '丁', objective: '丁目标', ownerRoleId: 'libu' }).task
const dispatched = service.dispatchTask({ projectId: project.id, taskId: task.id, idempotencyKey: 'idem-mem-4' })
service.startAttempt({ projectId: project.id, taskId: task.id, attemptId: dispatched.attempt.id, hostRunId: 'run-9' })
const input = {
projectId: project.id,
taskId: task.id,
attemptId: dispatched.attempt.id,
report: { summary: '名册已建好' },
runTerminal: 'succeeded',
}
service.reportTaskResult(input)
service.reportTaskResult(input)
const text = memory.readDepartment('libu').text
assert.ok(text.includes('在项目「项目一」汇报成果'), '部门记忆里带项目名,跨项目时知道出处')
assert.ok(text.includes('名册已建好'))
assert.equal(text.split('名册已建好').length - 1, 1, '重复汇报只记一行')
assert.equal(memory.readDepartment('gongbu').exists, false, '没干活的部门不记账')
} finally { cleanup(world) }
})

View File

@ -106,7 +106,7 @@ function seedService(service) {
// ---------- 注册与降级 ----------
test('注册:十三条 exact 路由,dispose 幂等且能全部卸载', () => {
test('注册:十六条 exact 路由,dispose 幂等且能全部卸载', () => {
const { service } = makeService()
const { registered, disposed, dispose } = mount(service)
assert.deepEqual([...registered.keys()].sort(), [
@ -119,16 +119,19 @@ test('注册:十三条 exact 路由,dispose 幂等且能全部卸载', () =>
`${ROUTE_PREFIX}/dispatch`,
`${ROUTE_PREFIX}/events`,
`${ROUTE_PREFIX}/ingest`,
`${ROUTE_PREFIX}/memory/append`,
`${ROUTE_PREFIX}/memory/get`,
`${ROUTE_PREFIX}/memory/put`,
`${ROUTE_PREFIX}/project`,
`${ROUTE_PREFIX}/result`,
`${ROUTE_PREFIX}/task`,
`${ROUTE_PREFIX}/task/cancel`,
])
assert.equal(dispose.registered, true)
assert.equal(dispose.paths.length, 13)
assert.equal(dispose.paths.length, 16)
dispose()
dispose()
assert.equal(disposed.length, 13, '十三条路由各卸载一次,重复调用不再卸载')
assert.equal(disposed.length, 16, '十六条路由各卸载一次,重复调用不再卸载')
})
test('注册:宿主没有 webServer 时降级为 no-op,不抛', () => {
@ -162,7 +165,7 @@ test('注册:中途失败会回滚已注册的路由', () => {
test('listWorkbenchRoutes 列出端点与方法', () => {
const rows = listWorkbenchRoutes()
assert.equal(rows.length, 13)
assert.equal(rows.length, 16)
assert.deepEqual(rows.find((row) => row.path.endsWith('/bootstrap')), {
path: `${ROUTE_PREFIX}/bootstrap`,
method: 'GET',
@ -365,13 +368,16 @@ test('bootstrap:一次拿全,且只含选中项目', async () => {
assert.deepEqual(value.layout.lead, ['lead'])
})
test('bootstrap:不传 projectId 时选中第一个项目', async () => {
test('bootstrap:不传 projectId 时只返回项目清单,不默认选中第一个项目', async () => {
const { service } = makeService()
const { call } = mount(service)
const { a } = seedService(service)
const res = await call('GET', `${ROUTE_PREFIX}/bootstrap`)
assert.equal(res.statusCode, 200)
assert.equal(res.json.value.projectId, a.id)
assert.equal(res.json.value.projectId, null)
assert.equal(res.json.value.project, null)
assert.deepEqual(res.json.value.seats, [])
assert.equal(res.json.value.projects.some((project) => project.id === a.id), true)
})
test('bootstrap:伪造 projectId 返回 404,不泄露存在性', async () => {

View File

@ -491,9 +491,12 @@ test('bootstrap 一次拿全且只含选中项目的数据', () => {
assert.deepEqual(view.tasks.map((row) => row.id), [taskA.id])
assert.ok(!view.tasks.some((row) => row.id === taskB.id), '不串项目任务')
assert.equal(view.eventSeq, ctx.store.eventSeq)
// 不传 projectId 时取第一个项目
// 不传 projectId 时只返回项目清单,不默认选中第一个项目
const fallback = ctx.service.bootstrap()
assert.equal(fallback.projectId, view.projects[0].id)
assert.equal(fallback.projectId, null)
assert.equal(fallback.project, null)
assert.deepEqual(fallback.seats, [])
assert.equal(fallback.projects.length, 2)
expectCode(() => ctx.service.bootstrap('proj_ghost'), 'NOT_FOUND')
})