Compare commits
71 Commits
feat/v1-pl
...
master
| Author | SHA1 | Date |
|---|---|---|
|
|
832e265038 | |
|
|
efc4a32c75 | |
|
|
257c47f78c | |
|
|
0cd0aea49d | |
|
|
8f158c5028 | |
|
|
a194838211 | |
|
|
297a2ee915 | |
|
|
1d8b496866 | |
|
|
3ffa57dbf4 | |
|
|
14a1f5c68c | |
|
|
9855b03555 | |
|
|
1aad975955 | |
|
|
ef7a2f9604 | |
|
|
4235f31368 | |
|
|
4e077fd6f3 | |
|
|
9fa80ac7d5 | |
|
|
4feab4d632 | |
|
|
d3ed94d03d | |
|
|
e7fd451227 | |
|
|
2839f9873a | |
|
|
e7c63439d6 | |
|
|
126f97e808 | |
|
|
935053a9ca | |
|
|
e46fd57599 | |
|
|
56ec629134 | |
|
|
2c0f507ba1 | |
|
|
fda101736f | |
|
|
ed31d3c5d7 | |
|
|
6212092172 | |
|
|
e42896c9c5 | |
|
|
f15e7d112c | |
|
|
d1d0529e0c | |
|
|
7b6e301697 | |
|
|
8c05acf6b4 | |
|
|
9c83e19ec4 | |
|
|
04fb4f2d8b | |
|
|
7a49e4b541 | |
|
|
1139dfd735 | |
|
|
568f1d8e43 | |
|
|
f941429f69 | |
|
|
834683a7ba | |
|
|
79f5156c72 | |
|
|
99121d7d54 | |
|
|
c5ee75988e | |
|
|
5fe1d5e4c8 | |
|
|
a6801c95f3 | |
|
|
017a3acb19 | |
|
|
badcc35c5a | |
|
|
3976930c3d | |
|
|
d23be0a6a2 | |
|
|
96f6221891 | |
|
|
899fcec590 | |
|
|
077aeb651d | |
|
|
4400e9dca6 | |
|
|
bd75d8186e | |
|
|
48478d9e55 | |
|
|
ade684b6e6 | |
|
|
003d52941d | |
|
|
7e9fc669d6 | |
|
|
585f4cda3b | |
|
|
05795c4d69 | |
|
|
a475b28a0f | |
|
|
611fd4c3e1 | |
|
|
dc4c1abe6f | |
|
|
0aaf54c471 | |
|
|
96bb4eb682 | |
|
|
b9a1fb71fa | |
|
|
6b557f8cf2 | |
|
|
6edacc3065 | |
|
|
646f33589c | |
|
|
6f660ff2b4 |
66
CHANGELOG.md
66
CHANGELOG.md
|
|
@ -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
103
README.md
|
|
@ -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
50
TODO.md
|
|
@ -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,席位可单独选模型,翰林应在碰到这类材料时主动提醒用户切换。
|
||||
|
|
|
|||
|
|
@ -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: {}
|
||||
|
|
|
|||
|
|
@ -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 回退代码不会回退它。
|
||||
|
|
|
|||
|
|
@ -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 包已退役,不要安装)。
|
||||
|
||||
---
|
||||
|
||||
|
|
|
|||
|
|
@ -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
480
index.js
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +0,0 @@
|
|||
{
|
||||
"meta": {
|
||||
"title": "Imperial Court",
|
||||
"description": "A Chancellor-led multi-agent mode for planning, review, dispatch, visual work, writing, and coding."
|
||||
}
|
||||
}
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
{
|
||||
"meta": {
|
||||
"title": "上朝",
|
||||
"description": "丞相统筹的多 Agent 协作模式,提供规划、审核、调度、图像、写作和代码能力。"
|
||||
}
|
||||
}
|
||||
28
package.json
28
package.json
|
|
@ -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"
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
```
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
# 三省六部 Agent 面板:只加载 Web 客户端 bundle,不参与 Agent 策略。
|
||||
- insert:
|
||||
- id: sansheng-agent-panel
|
||||
name: dsh-sansheng-liubu-panel
|
||||
|
|
@ -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 能正常加载。
|
||||
}
|
||||
2095
panel/lib/client.js
2095
panel/lib/client.js
File diff suppressed because it is too large
Load Diff
|
|
@ -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 }) } }
|
||||
}
|
||||
|
|
@ -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
|
|
@ -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
|
||||
|
|
@ -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))
|
||||
106
scripts/mode.mjs
106
scripts/mode.mjs
|
|
@ -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)
|
||||
}
|
||||
1154
scripts/preview.mjs
1154
scripts/preview.mjs
File diff suppressed because it is too large
Load Diff
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 })
|
||||
})
|
||||
|
|
@ -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
|
||||
},
|
||||
})
|
||||
}
|
||||
|
|
@ -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')
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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] 长轮询内部检查间隔(毫秒)。
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
||||
/** 目录级入口:所有写入前都先建目录,缺目录不该表现为“保存失败”。 */
|
||||
|
|
|
|||
|
|
@ -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 }) => {
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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: {}
|
||||
|
|
@ -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) {}
|
||||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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: ['只读源文件'] },
|
||||
|
|
|
|||
|
|
@ -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) }
|
||||
})
|
||||
|
|
@ -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 () => {
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
})
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue