personal-bot 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "personal-bot",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/realqiyan/personal-bot.git"
@@ -10,7 +10,7 @@
     "registry": "https://registry.npmjs.org/",
     "tag": "latest"
   },
-  "description": "A personal assistant connecting knowledge, research, and action. Currently implemented as a Pi extension.",
+  "description": "A personal assistant connecting knowledge, research, and action for Pi and DeepSeek Harness.",
   "type": "module",
   "bin": {
     "pbot": "./bin/pbot.mjs"
@@ -26,6 +26,19 @@
     "prompts": [],
     "themes": []
   },
+  "dsh": {
+    "bundle": { "patch": "./resources/dsh/cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "inject": ["@deepseek-ai/dsh-api-remotes", "@deepseek-ai/dsh-client-ui-commands", "@deepseek-ai/dsh-client-file-upload"]
+    }
+  },
+  "exports": {
+    ".": { "types": "./lib/dsh.d.ts", "default": "./lib/dsh.js" },
+    "./dsh": { "types": "./lib/dsh.d.ts", "default": "./lib/dsh.js" },
+    "./client": { "types": "./lib/ui/dsh/index.d.ts", "default": "./lib/client.js" },
+    "./*": "./*"
+  },
   "files": [
     "npm-shrinkwrap.json",
     "bin",
@@ -42,25 +55,73 @@
     "docs"
   ],
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=22.19.0",
+    "dsh": "0.2.2-rc.1"
   },
   "scripts": {
     "check": "tsc --noEmit && npm run check:dependencies",
     "check:dependencies": "depcruise --config .dependency-cruiser.cjs src",
-    "build": "node scripts/clean-dist.mjs && tsc && npm run build:cli",
+    "build": "node scripts/clean-dist.mjs && tsc && npm run build:cli && npm run build:dsh",
     "build:cli": "node scripts/build-cli.mjs",
+    "build:dsh": "node scripts/build-dsh.mjs",
     "test": "npm run build && node --test --test-concurrency=1 tests/*/*.test.mjs",
     "test:smoke": "npm run build && node --test --test-concurrency=1 tests/smoke/*.test.mjs",
     "test:e2e": "npm run build && node --test --test-concurrency=1 tests/e2e/*.test.mjs",
-    "prepack": "npm run check && npm run build:cli"
+    "prepack": "npm run check && npm run build:cli && npm run build:dsh"
   },
   "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.1.0",
+    "@deepseek-ai/dsh-agent": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-session": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-session-persistence": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-session-query": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-commands": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-api-remotes": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-commands": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-file-upload": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-tools": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-home-paths": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-skill": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-skill-filesystem": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-working-directory": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-fs": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-attachment": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-fs-patch": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-user-approval": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-tool-executor-ptc": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-typert-registry": "0.2.2-rc.1",
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
   "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": { "optional": true },
+    "@deepseek-ai/dsh-agent": { "optional": true },
+    "@deepseek-ai/dsh-session": { "optional": true },
+    "@deepseek-ai/dsh-session-persistence": { "optional": true },
+    "@deepseek-ai/dsh-session-query": { "optional": true },
+    "@deepseek-ai/dsh-llm": { "optional": true },
+    "@deepseek-ai/dsh-commands": { "optional": true },
+    "@deepseek-ai/dsh-api-remotes": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-commands": { "optional": true },
+    "@deepseek-ai/dsh-client-file-upload": { "optional": true },
+    "@deepseek-ai/dsh-tools": { "optional": true },
+    "@deepseek-ai/dsh-home-paths": { "optional": true },
+    "@deepseek-ai/dsh-system-prompt": { "optional": true },
+    "@deepseek-ai/dsh-skill": { "optional": true },
+    "@deepseek-ai/dsh-skill-filesystem": { "optional": true },
+    "@deepseek-ai/dsh-working-directory": { "optional": true },
+    "@deepseek-ai/dsh-fs": { "optional": true },
+    "@deepseek-ai/dsh-attachment": { "optional": true },
+    "@deepseek-ai/dsh-fs-patch": { "optional": true },
+    "@deepseek-ai/dsh-user-approval": { "optional": true },
+    "@deepseek-ai/dsh-tool-executor-ptc": { "optional": true },
+    "@deepseek-ai/dsh-typert-protocol": { "optional": true },
+    "@deepseek-ai/dsh-typert-registry": { "optional": true },
     "@earendil-works/pi-ai": {
       "optional": true
     },
@@ -69,9 +130,6 @@
     },
     "@earendil-works/pi-tui": {
       "optional": true
-    },
-    "typebox": {
-      "optional": true
     }
   },
   "dependencies": {
@@ -80,12 +138,37 @@
     "semver": "7.8.5"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "1.4.0",
-    "@earendil-works/pi-coding-agent": "1.4.0",
-    "@earendil-works/pi-tui": "1.4.0",
+    "@deepseek-ai/cordis": "4.1.0",
+    "@deepseek-ai/dsh": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-agent": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-api-remotes": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-commands": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-file-upload": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-commands": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-session": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-session-persistence": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-session-query": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-tools": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-home-paths": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-skill": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-skill-filesystem": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-working-directory": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-fs": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-attachment": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-fs-patch": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-user-approval": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-tool-executor-ptc": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-typert-registry": "0.2.2-rc.1",
+    "@earendil-works/pi-ai": "1.5.0",
+    "@earendil-works/pi-coding-agent": "1.5.0",
+    "@earendil-works/pi-tui": "1.5.0",
     "@types/node": "24.10.1",
     "@types/semver": "7.7.1",
     "dependency-cruiser": "18.5.0",
+    "esbuild": "0.25.12",
     "typebox": "1.3.27",
     "typescript": "5.9.3"
   }

package/python/README.md

@@ -4,12 +4,12 @@
 
 ## 自动准备与激活
 
-Pi 加载 Personal Bot 或原生 `/reload` 后自动执行 setup，无需另行确认或指定路径：
+Pi 加载 Personal Bot、原生 `/reload`，或 dsh 加载 pbot Host 组件时自动执行 setup，无需另行确认或指定路径。同一系统用户的两种宿主共用该环境：
 
 1. 共享 venv 不存在时创建，不使用系统 site-packages。
 2. 按 `requirements.lock` 补齐或对齐依赖，允许升级或降级；已匹配时不重新安装。
 3. 检查依赖关系、全部预装库导入和简单 TA-Lib 计算。
-4. 成功后将 venv 的 `bin` 放到当前 Pi 进程 PATH 前端，设置 `VIRTUAL_ENV`，移除 `PYTHONHOME`、`PYTHONPATH` 并禁用用户 site-packages。主会话与专家的原生 Bash 继承该环境。
+4. 成功后将 venv 的 `bin` 放到当前宿主进程 PATH 前端，设置 `VIRTUAL_ENV`，移除 `PYTHONHOME`、`PYTHONPATH` 并禁用用户 site-packages。主会话与专家的原生 Bash 继承该环境。
 
 | 系统 | 共享环境 |
 | --- | --- |
@@ -18,7 +18,7 @@ Pi 加载 Personal Bot 或原生 `/reload` 后自动执行 setup，无需另行
 
 首次准备从当前 PATH 选择 python3，无该命令时使用 python；需要 Python 3.11+ 和 venv/ensurepip。系统 Python 只用于创建独立 venv，不在系统环境中安装依赖。现有环境不自动替换基础解释器，也不删除额外安装的包。
 
-首次安装可能需要数分钟和网络。环境准备不依赖 `/pbot init` 或工作区资料；不需要 Personal Bot 时应通过 Pi 原生配置取消加载该扩展。`/pbot status` 显示环境状态。工作区关闭、重载或会话替换时恢复本扩展修改的进程环境变量，不覆盖期间其他代码对变量的新修改。外部终端和 shell 配置不变。
+首次安装可能需要数分钟和网络。环境准备不依赖 `/pbot init` 或工作区资料；不需要 Personal Bot 时通过所属宿主的原生配置取消加载。`/pbot status` 显示环境状态。所属激活生命周期关闭时恢复本扩展修改的进程环境变量；dsh 按整个 pbot 组件共享激活，不随某个浏览器页面或单个工作区关闭而恢复，不覆盖期间其他代码对变量的新修改。外部终端和 shell 配置不变。
 
 ## 失败与手工重试
 
@@ -45,7 +45,7 @@ python3 scripts/setup-python.py
 python3 scripts/setup-python.py --check  # 只检查，不创建或安装
 ```
 
-脚本不接受解释器或目标路径参数。独立脚本不能激活其父终端；自动激活由 pbot 完成。不修改工作区设置、脚本、历史运行记录或结果。准备脚本支持 Linux/macOS；插件其他宿主依赖仍须满足，未完成 macOS 实机验收。
+脚本不接受解释器或目标路径参数。独立脚本不能激活其父终端；自动激活由 pbot 完成。不修改工作区设置、脚本、历史运行记录或结果。准备脚本支持 Linux/macOS；插件其他宿主依赖仍须满足。dsh 桌面应用从登录 Shell 读取环境，Python 3.11+ 必须在该环境的 PATH 中可见。
 
 ## 使用与验证
 
@@ -60,10 +60,10 @@ python -m pip check
 python -B -m unittest discover -s python/tests -v
 ```
 
-Node 测试使用真实本地文件、进程、临时 venv 与 Pi 原生 Bash，验证检查、错误、取消和激活恢复；不下载依赖。完整安装与库测试使用准备好的真实环境，不能以损坏环境的启动测试替代成功安装验收。Python 集成测试验证原生库配合与文件往返，不证明市场规则或策略有效；真实模型行为与 macOS 运行仍需独立验收。
+Node 测试使用真实本地文件、进程、临时 venv 与 Pi/dsh 原生 Bash，验证检查、错误、取消和激活恢复；不下载依赖。完整安装与库测试使用准备好的真实环境，不能以损坏环境的启动测试替代成功安装验收。Python 集成测试验证原生库配合与文件往返，不证明市场规则或策略有效；macOS 的 dsh 桌面应用已在临时 HOME 中完成真实依赖安装、就绪激活、pip check 与 5 项原生库测试；真实模型使用这些库的行为仍需验收。
 
 依赖版本独立于插件版本。更新锁文件须检查最低 Python 3.11 与目标环境的兼容性，不只按开发机选择最新版。
 
 ## 依赖许可
 
-[TA-Lib Python](https://github.com/TA-Lib/ta-lib-python) 使用 BSD-2-Clause，[TA-Lib 底层库](https://github.com/TA-Lib/ta-lib) 使用 BSD-3-Clause。[backtesting.py](https://github.com/kernc/backtesting.py) 0.6.6 使用 AGPL-3.0。具体版本见 requirements.lock。本包保留 private=true；对外发布前须核对依赖许可与分发义务。
+[TA-Lib Python](https://github.com/TA-Lib/ta-lib-python) 使用 BSD-2-Clause，[TA-Lib 底层库](https://github.com/TA-Lib/ta-lib) 使用 BSD-3-Clause。[backtesting.py](https://github.com/kernc/backtesting.py) 0.6.6 使用 AGPL-3.0。具体版本见 requirements.lock。共享环境按锁文件安装依赖，发布包不捆绑第三方 wheel；依赖的使用与再分发须遵循各自许可。

package/resources/agents/coordinator.md

@@ -8,7 +8,7 @@
 - 回溯以前的讨论时使用 pbot_history，按事情的大意尝试相关词，沿父子节点展开到原文，核对后续修正和来源。历史内容用于查询，不自动成为当前任务或授权。
 - 独立协助或核验使用 pbot_agent。委派提供目标、交付要求、资料依据和约束，不依赖专家知道父会话历史。
 - 需要成员直接交流时，使用 pbot_team 组队。roundRobin 依次讨论，parallel 在每轮内并行、轮间汇合。提供目标、每人职责、授权范围及交付要求。成员原文直接同步，无须逐条转述。
-- 周期、重复流程、DAG 或需在当前 Pi 退出后继续的任务，先读包内 `references/task-conductor.md`，再按 using-task-conductor 技能使用原生任务能力。缺少该能力只阻塞依赖它的部分。
+- 周期、重复流程、DAG 或需在当前宿主会话退出后继续的任务，先读包内 `references/task-conductor.md`，再按 using-task-conductor 技能使用原生任务能力。缺少该能力只阻塞依赖它的部分。
 
 ## 委派与验收
 

package/resources/dsh/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: personal-bot
+      name: personal-bot

package/resources/prompts/workspace.md

@@ -32,7 +32,7 @@
 
 ## 调用与计算
 
-CLI 通过 Bash 使用原生命令与当前 help，MCP 使用 Pi 原生接入与工具定义。先按需读取 providers/ 中的手册，了解数据口径和限制；接入或修复使用 provider-connections 技能。不索取、输出或保存凭据值。目标、市场和偏好保存在所属普通资料中。
+CLI 通过 Bash 使用原生命令与当前 help，MCP 使用当前宿主的原生接入与工具定义，Pi 和 dsh 配置分别管理。先按需读取 providers/ 中的手册，了解数据口径和限制；接入或修复使用 provider-connections 技能。不索取、输出或保存凭据值。目标、市场和偏好保存在所属普通资料中。
 
 按用户授权执行本次业务。研究、接入和验证不授权交易、转账或账本修改。协议成功不证明业务完成；超时、断连和取消不证明未执行。可能已发送的操作先查询原生状态，不因恢复会话或结果缺失自动重发。
 

package/resources/references/compute.md

@@ -4,7 +4,7 @@
 
 主会话与专家的 `pbot_environment.python` 给出当前共享 Python 3.11+ 环境状态。为 ready 时，通过 Bash 使用 python 或 python3，按任务导入第三方库原生 API。项目构建和测试遵循项目声明的环境，在对应命令中使用。
 
-状态未就绪或依赖异常时，可自主诊断，只暂停依赖该环境的计算，不自动退回系统 Python，不删除或重建共享环境。额外依赖或共享环境变更先核对已有授权及影响范围；未获授权时说明所需变更并询问。需要重试 setup 时，请用户在当前 Pi 会话执行 `/pbot python setup`；专家将所需会话操作或补充授权交回主会话。
+状态未就绪或依赖异常时，可自主诊断，只暂停依赖该环境的计算，不自动退回系统 Python，不删除或重建共享环境。额外依赖或共享环境变更先核对已有授权及影响范围；未获授权时说明所需变更并询问。需要重试 setup 时，使用当前宿主的 `/pbot python setup` 原生入口；需要用户执行会话操作时说明该入口；专家将所需会话操作或补充授权交回主会话。
 
 所有 pbot 工作区共用当前用户的环境。更新依赖前停止相关计算，避免影响其他工作区；不同插件版本的依赖要求可能冲突。库清单说明可用方法，不代替本次环境状态检查。
 

package/resources/references/task-conductor.md

@@ -1,12 +1,12 @@
 # 原生 Task Conductor
 
-主会话需要周期、重复流程、DAG 或离开当前 Pi 后继续执行时使用本文。普通独立协助使用 pbot_agent。
+主会话需要周期、重复流程、DAG 或离开当前宿主会话后继续执行时使用本文。普通独立协助使用 pbot_agent。
 
 ## 准备能力
 
-先通过 Pi 原生工具发现查找 Task Conductor，并加载 using-task-conductor 技能，以实际 MCP schema 为准。工具未直接显示不等于未安装；技能可用时，按技能处理连接或排障。
+先通过当前宿主的原生工具发现查找 Task Conductor，并加载 using-task-conductor 技能，以实际 MCP schema 为准。工具未直接显示不等于未安装；技能可用时，按技能处理连接或排障。
 
-技能缺失时，用 `pi list` 检查插件及资源启用状态。已有旧版接入包时，先审阅官方升级说明，确认来源和作用域后显式替换旧包声明，不同时加载两份；服务更新与 MCP 配置另行核对，保留任务历史。确未安装则说明需要 Pi 1.4.0+，核对已有安装授权，已覆盖时直接使用工作区安装命令，未覆盖时再请求授权：
+以下安装命令只适用于 Pi。技能缺失时，用 `pi list` 检查插件及资源启用状态。已有旧版接入包时，先审阅官方升级说明，确认来源和作用域后显式替换旧包声明，不同时加载两份；服务更新与 MCP 配置另行核对，保留任务历史。确未安装则按本项目基线使用 Pi 1.5.0，核对已有安装授权，已覆盖时直接使用工作区安装命令，未覆盖时再请求授权：
 
 ```bash
 pi install --local npm:task-conductor-plugin
@@ -14,6 +14,8 @@ pi install --local npm:task-conductor-plugin
 
 需要重载及通过技能交互安装时，请用户在当前 Pi 会话执行 `/reload`，再执行 `/skill:using-task-conductor` 处理服务安装、setup 与原生 MCP 接入；这些斜杠命令不能通过 Bash 代执行。可直接读取已发现的技能继续可执行的步骤。复用已有原生连接，不在聊天中索取凭据值；CLI 配置查询不等价于当前会话的临时连接状态。插件可见不证明服务已连接，执行器 ready 不证明模型认证和执行成功。
 
+在 dsh 中，按上游适用于当前版本的方式加载技能，并通过 dsh 原生 MCP 连接已有服务；不把 Pi 插件声明、`pi install` 或 `/reload` 用作 dsh 接入。服务端节点的执行器、认证与环境仍按其自身配置核对，不假定与当前 dsh 会话相同。
+
 能力不可用时说明依赖它的工作受阻，继续其他已授权工作；不以循环等待或后台子会话替代持久调度。
 
 ## 委派与许可
@@ -28,4 +30,4 @@ pi install --local npm:task-conductor-plugin
 
 任务定义、执行和节点分别用 taskId、runId 和节点 ID 标识。提交响应不明时先查已有标识；未取得 ID 时，按接口可用的请求关联、任务列表、提交时间或任务特征查找并核对。未能确认是否已创建时保留未知状态，不重复提交。实时状态查询 Task Conductor；项目资料只保存必要定义、标识和有时点的结果依据。
 
-取消当前执行与停止未来周期分别操作，并查询确认。pbot_agent stop 或 Pi 关闭不停止 Task Conductor。报告已设置调度须有实际提交结果；报告本轮成功须核对本轮产物与完成条件。
+取消当前执行与停止未来周期分别操作，并查询确认。pbot_agent stop 或当前宿主关闭不停止 Task Conductor。报告已设置调度须有实际提交结果；报告本轮成功须核对本轮产物与完成条件。

package/resources/skills/provider-connections/SKILL.md

@@ -13,6 +13,10 @@ description: 接入或修复原生 CLI/MCP，核对认证与可用性，维护
 
 ## MCP
 
+先核对当前宿主、连接来源与实际配置范围。Pi 和 dsh 分别管理原生配置，不自动同步模型、认证或 MCP。
+
+### Pi
+
 可先用当前可见工具及 CLI 自主诊断。需要查看当前会话的连接、认证、工具与配置来源时，请用户在该 Pi 会话执行 `/mcp`；这是会话操作，不能通过 Bash 代执行。Bash 中使用 `pi mcp --help` 及相关子命令查询或配置；CLI 查询不等价于当前会话状态，尤其不能据此判断会话内临时连接。
 
 新增连接默认只接入当前项目。从工作区根目录执行 `pi mcp add --local <server> ...`，写入 `.pi/mcp.json`；删除项目连接使用 `pi mcp remove --local <server>`。add/remove 未指定 `--local` 时修改当前 Pi agent dir 的 `mcp.json`，仅在用户明确要求跨项目使用时选择该范围。第三方 setup 同样采用项目配置；无法指定范围时，改用 Pi 原生项目配置。
@@ -21,6 +25,12 @@ description: 接入或修复原生 CLI/MCP，核对认证与可用性，维护
 
 外部修改配置后，请用户在当前 Pi 会话执行 `/reload`，再用 `/mcp` 核对实际配置来源和连接状态；不要声称已代用户完成会话操作。当前工具 schema 通过原生工具搜索或 codemode 按需取得。新增权限、安装或共享配置变更先核对已有授权，已授权的操作不重复询问。
 
+### dsh
+
+使用当前固定版本的原生 MCP 组件、profile 设置、认证与工具发现。按其公开文档或当前 help 核对参数，不使用 Pi 的命令和 `.pi/mcp.json` 配置方式。连接可能服务于同一 profile 的多个工作区，修改前核对实际作用域及已有授权，不把 profile 配置称为工作区隔离。
+
+优先复用已有连接，保留无关条目与其他工作区配置。用原生界面或可用管理能力完成已授权操作，再从当前会话核对工具、认证与连接状态；确需用户执行原生操作时，明确对应入口。工具可见不代表连接或业务调用成功，不为验证连接擅自执行写操作。
+
 ## 验证与手册
 
 用本次获准的查询验证所需能力，将实际接口、时间、覆盖范围与结果依据保存在所属项目。区分配置已保存、连接可用和业务已验证。

package/scripts/README.md

@@ -10,8 +10,16 @@
 
 `npm run build:cli` 调用 `build-cli.mjs`，清理生成目录 lib，再按 tsconfig.cli.json 编译独立 CLI、Pi 检查桥接和启动保护。bin/pbot.mjs 转交已生成的入口。npm test 的构建与 prepack 都执行此步骤；扩展运行仍由 Pi 加载 src 源码。消费者直接使用发布包中的 lib，无需安装开发依赖。
 
+## dsh 构建
+
+`npm run build:dsh` 调用 `build-dsh.mjs`，由 tsconfig.dsh.json 编译 Host 与浏览器入口，再用 esbuild 将 Web 代码包装为固定版原生包根 Loader 模块。宿主 SDK 保持 external；完整 build 和 prepack 先构建 CLI、再构建 dsh，统一输出到 lib。
+
+## 发布包消费者检查
+
+`node scripts/check-consumer.mjs <tarball>` 在临时目录安装实际发布包，先检查独立 CLI 与宿主 SDK 缺省状态，再安装 package.json 中锁定的 Pi SDK，验证扩展、工具、技能和资料初始化。CI 使用 Node.js 22.19.0 执行，完整开发依赖、dsh 构建和全量测试仍使用 Node.js 24.9+。检查使用独立用户目录与损坏 Python 目标，不下载计算依赖或调用模型；结束后删除本次临时目录。
+
 ## 构建清理
 
 `clean-dist.mjs` 由 npm run build 调用，仅清理仓库内生成的 dist/，供 TypeScript 重新编译测试导入。
 
-本包不提供工作区升级命令或历史转换脚本。插件安装和更新由 Pi 原生包管理或用户维护的源码目录负责。
+本包不提供工作区升级命令或历史转换脚本。插件安装和更新由对应宿主的原生包管理或用户维护的源码目录负责。

package/src/dsh.ts

@@ -0,0 +1,22 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { registerDshCommand } from "./extension/dsh/command.js";
+import { registerDshManagement } from "./extension/dsh/management.js";
+import { DshWorkspaces, dshDependencies } from "./extension/dsh/workspace.js";
+import { requireThat } from "./common/validation.js";
+
+export const name = "personal-bot";
+export const inject = ["commands", "typert", ...dshDependencies];
+
+export async function apply(ctx: Context) {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  requireThat(major! > 24 || (major === 24 && minor! >= 9), "dsh 接入需要 Node.js 24.9.0 或更新版本。");
+  const workspaces = new DshWorkspaces(ctx);
+  ctx.effect(() => () => workspaces.close());
+  const management = registerDshManagement(ctx, workspaces);
+  registerDshCommand(ctx, workspaces, management);
+  ctx.on("agent/created", async ({ agent }) => {
+    if (ctx.agents.roots().includes(agent) && agent.session.header.origin !== "subagent") await workspaces.open(agent);
+  });
+  for (const agent of ctx.agents.roots()) if (agent.session.header.origin !== "subagent") await workspaces.open(agent);
+  void workspaces.preparePython().catch(error => ctx.logger.warn(String(error)));
+}

package/src/extension/agent-events.ts

@@ -6,12 +6,13 @@ import { agentOwner, deliveredCycles } from "../integrations/pi/agent-context.js
 import { agentBoard } from "../ui/agent-display.js";
 import { deliveredTeams } from "../integrations/pi/team-context.js";
 import type { TeamInput } from "../model/team.js";
-import { json } from "../common/json.js";
+import { agentNotice, teamNotice } from "../services/agents/agent-notices.js";
 import { markdownFields } from "../common/markdown.js";
 
 export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, confirmations: Confirmations) {
   let ctx: ExtensionContext | undefined, timer: ReturnType<typeof setInterval> | undefined;
-  let paused = false;
+  let paused = false, epoch = 0, refreshEpoch = 0;
+  let refreshing: Promise<void> | undefined;
   let controlBusySince: number | undefined;
   let failure: { key: string; error: string; recovery: "retry" | "repair" | "reload" } | undefined;
   const recordFailure = (error: unknown) => {
@@ -44,45 +45,32 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
       if (!busy) throw error;
     }
   };
-  const collectNotification = (): CustomMessageEntryDraft | undefined => {
-    const instance = lifecycle.active;
+  const collectNotification = async (): Promise<CustomMessageEntryDraft | undefined> => {
+    const instance = lifecycle.active, revision = epoch;
     if (!ctx || !instance || paused || ctx.signal?.aborted) return;
     const delivered = new Set([...deliveredCycles(ctx), ...deliveredTeams(ctx)]), now = Date.now();
     for (const [key, at] of submitting) if (delivered.has(key) || now - at > 5000) submitting.delete(key);
-    const owner = agentOwner(ctx), notes = instance.teams.notifications(owner, instance.agents.list(owner))
-      .filter(v => !delivered.has(v.key) && !submitting.has(v.key)).slice(0, 8);
-    if (notes.length) {
-      const keys = notes.map(v => v.key);
-      for (const key of keys) submitting.set(key, now);
-      return { type: "custom_message", customType: "pbot.team-results", display: true,
-        content: ["# 团队批次状态", "", "团队批次状态已变化。用 pbot_team status/read 查询；结束不等于业务验收通过。暂停可能仍有在途工作，不能自动重跑旧请求。", "",
-          notes.map(v => ["## " + v.name, "", "- `teamId`: `" + v.teamId + "`", "- `runId`: `" + v.runId + "`",
-            "- 状态：" + v.state, "- 在途工作：" + v.activeCount, ...(v.reason ? ["", "### 原因", "", v.reason] : [])].join("\n")).join("\n\n")].join("\n"),
-        details: { keys } };
+    const owner = agentOwner(ctx);
+    let note: ReturnType<typeof teamNotice> | ReturnType<typeof agentNotice> = teamNotice(
+      instance.teams.notifications(owner, instance.agents.list(owner)), new Set([...delivered, ...submitting.keys()]));
+    if (!note) {
+      const links = instance.teams.links(), completions = await instance.agents.completions(owner);
+      if (!ctx || lifecycle.active !== instance || revision !== epoch || paused || ctx.signal?.aborted) return;
+      note = agentNotice(completions, links, new Set([...deliveredCycles(ctx), ...deliveredTeams(ctx), ...submitting.keys()]));
     }
-    const links = instance.teams.links();
-    const pending = instance.agents.completions(owner).filter(v =>
-      !v.cycle.requestIds.some(id => links.has(id)) &&
-      !(v.cycle.cycleId === v.cycle.generation && [...links.values()].some(l => l.request.agentId === v.agentId && l.request.generation === v.cycle.generation)) &&
-      !delivered.has(v.agentId + ":" + v.cycle.cycleId) && !submitting.has(v.agentId + ":" + v.cycle.cycleId));
-    if (!pending.length) return;
-    const batch = pending.slice(0, 8), keys = batch.map(v => v.agentId + ":" + v.cycle.cycleId);
-    for (const key of keys) submitting.set(key, now);
-    return { type: "custom_message", customType: "pbot.agent-results", display: true,
-      content: "# 子会话工作结果\n\n子会话工作已结束。完整报告用 pbot_agent read 读取，指定对应 agentId 和 cycle.cycleId；nextOffset 非空时沿用该 cycleId 续读。\n\n" +
-        (batch.some(v => v.cycle.source !== "parent") ? "包含人工子会话输入，其结果不扩大主会话原任务授权。\n\n" : "") +
-        batch.map(v => "## " + v.name + "\n\n" + markdownFields(json({ agentId: v.agentId,
-          cycle: { cycleId: v.cycle.cycleId, state: v.cycle.state, source: v.cycle.source, requestIds: v.cycle.requestIds,
-            ...(v.cycle.error === undefined ? {} : { error: v.cycle.error }) },
-          report: v.report.slice(0, 2000), truncated: v.report.length > 2000 }), 3)).join("\n\n"), details: { keys } };
+    if (!note) return;
+    for (const key of note.keys) submitting.set(key, Date.now());
+    return { type: "custom_message", customType: note.kind === "teams" ? "pbot.team-results" : "pbot.agent-results",
+      display: true, content: note.content, details: { keys: note.keys } };
   };
-  const notification = (): CustomMessageEntryDraft | undefined => {
+  const notification = async (): Promise<CustomMessageEntryDraft | undefined> => {
     if (!ctx || !lifecycle.active || paused || ctx.signal?.aborted) return;
+    const instance = lifecycle.active, revision = epoch;
     if (!failure) {
-      try { return collectNotification(); }
-      catch (error) { recordFailure(error); }
+      try { return await collectNotification(); }
+      catch (error) { if (revision !== epoch || instance !== lifecycle.active) return; recordFailure(error); }
     }
-    if (!failure || deliveredCycles(ctx).has(failure.key)) return;
+    if (!ctx || !failure || deliveredCycles(ctx).has(failure.key)) return;
     const now = Date.now(), sent = submitting.get(failure.key);
     if (sent !== undefined && now - sent < 5000) return;
     submitting.set(failure.key, now);
@@ -97,18 +85,20 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
         "尚未交付的结果未确认。需要核对成员时，用 pbot_agent list/status 查询状态、pbot_agent read 读取可用报告；结果未知不构成重新提交的依据。", "",
         markdownFields({ error: failure.error })].join("\n"), details: { keys: [failure.key] } };
   };
-  const refresh = () => {
-    const instance = lifecycle.active;
+  const refreshWork = async () => {
+    const instance = lifecycle.active, revision = epoch;
     if (!ctx || !instance) return;
     try {
       instance.agentOwner = agentOwner(ctx);
-      instance.agents.refresh(instance.agentOwner);
+      await instance.agents.refresh(instance.agentOwner);
+      const completed = await instance.agents.completions(instance.agentOwner);
+      if (!ctx || lifecycle.active !== instance || revision !== epoch) return;
       const values = instance.agents.list(instance.agentOwner);
       try {
         instance.teams.recover(instance.agentOwner);
         if (pausePending) pauseTeams();
         if (!pausePending) {
-          for (const input of instance.teams.advance(instance.agentOwner, values, instance.agents.completions(instance.agentOwner))) dispatching.set(input.requestId, input);
+          for (const input of instance.teams.advance(instance.agentOwner, values, completed)) dispatching.set(input.requestId, input);
           for (const [id, input] of dispatching) {
             try { instance.agents.enqueueTeam(input, instance.agentOwner); dispatching.delete(id); }
             catch (error) {
@@ -133,26 +123,41 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
         if (ctx.hasUI) ctx.ui.setStatus("pbot-agents-error", undefined);
       }
     } catch (error) {
+      if (revision !== epoch || instance !== lifecycle.active) return;
       recordFailure(error);
     }
-    if (ctx.isIdle() && !paused) { const message = notification(); if (message) pi.sendMessage(message, { triggerTurn: true, deliverAs: "steer" }); }
+    if (ctx?.isIdle() && !paused) {
+      const message = await notification();
+      if (message && revision === epoch && instance === lifecycle.active && ctx?.isIdle() && !paused) pi.sendMessage(message, { triggerTurn: true, deliverAs: "steer" });
+    }
+  };
+  const refresh = (): Promise<void> => {
+    if (refreshing) return refreshEpoch === epoch ? refreshing : refreshing.then(() => refresh());
+    refreshEpoch = epoch;
+    const revision = epoch;
+    const pending = refreshWork().catch(error => { if (revision === epoch) recordFailure(error); }).finally(() => {
+      if (refreshing === pending) refreshing = undefined;
+    });
+    refreshing = pending;
+    return pending;
   };
-  const boundary = (outcome: string, entries: SessionBoundaryDraft[], context: ExtensionContext) => {
+  const boundary = async (outcome: string, entries: SessionBoundaryDraft[], context: ExtensionContext) => {
     ctx = context;
     if (outcome === "aborted" || ctx.signal?.aborted) { paused = true; confirmations.pause(); pauseTeams(); return; }
-    const message = notification();
-    if (message) return { entries: [...entries, message], continue: true };
+    const revision = epoch, instance = lifecycle.active;
+    const message = await notification();
+    if (message && revision === epoch && instance === lifecycle.active && !paused && !ctx?.signal?.aborted) return { entries: [...entries, message], continue: true };
     return;
   };
   pi.on("session_start", (_event, context) => {
-    ctx = context; paused = false; pausePending = false; controlBusySince = undefined; failure = undefined; confirmations.resume(); submitting.clear(); dispatching.clear();
+    epoch++; ctx = context; paused = false; pausePending = false; controlBusySince = undefined; failure = undefined; confirmations.resume(); submitting.clear(); dispatching.clear();
     if (timer) clearInterval(timer);
-    if (lifecycle.active) { lifecycle.active.agentOwner = agentOwner(ctx); timer = setInterval(refresh, 1000); timer.unref(); }
-    refresh();
+    if (lifecycle.active) { lifecycle.active.agentOwner = agentOwner(ctx); timer = setInterval(() => { void refresh(); }, 1000); timer.unref(); }
+    return refresh();
   });
   pi.on("input", (_event, context) => { ctx = context; paused = false; confirmations.resume(); });
   pi.on("before_agent_start", (_event, context) => { ctx = context; });
-  pi.on("session_tree", (_event, context) => { ctx = context; submitting.clear(); refresh(); });
+  pi.on("session_tree", (_event, context) => { epoch++; ctx = context; submitting.clear(); return refresh(); });
   pi.on("turn_end", (event, context) => boundary(event.outcome, event.entries, context));
   pi.on("agent_before_settle", (event, context) => boundary(event.outcome, event.entries, context));
   pi.on("agent_settled", (event, context) => {
@@ -163,5 +168,5 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
     const keys = (event.details as { agentReadKeys?: string[] } | undefined)?.agentReadKeys;
     if (keys?.length) pi.appendEntry("pbot.agent-read", { keys, toolCallId: event.parentToolCallId ?? event.toolCallId });
   });
-  pi.on("session_shutdown", () => { if (timer) clearInterval(timer); timer = undefined; submitting.clear(); dispatching.clear(); pausePending = false; ctx = undefined; });
+  pi.on("session_shutdown", () => { epoch++; if (timer) clearInterval(timer); timer = undefined; submitting.clear(); dispatching.clear(); pausePending = false; ctx = undefined; });
 }

package/src/extension/agents-command.ts

@@ -5,43 +5,57 @@ import type { WorkspaceInstance } from "./lifecycle.js";
 import { agentOwner } from "../integrations/pi/agent-context.js";
 import { tmuxName } from "../integrations/pi/pi-agents.js";
 import { agentSummary } from "../ui/agent-display.js";
+import { readPage } from "../ui/pi/reader.js";
+import { choose } from "../ui/pi/menu.js";
+import { stateLabel } from "../ui/presentation.js";
 import type { Confirmations } from "../ui/confirmation.js";
 
 export async function showAgents(_pi: ExtensionAPI, instance: WorkspaceInstance, ctx: ExtensionCommandContext, confirmations: Confirmations, agentIds?: string[]) {
   instance.check();
-  const owner = () => agentOwner(ctx), values = instance.agents.list(owner()).filter(v => !agentIds || agentIds.includes(v.agentId));
-  if (ctx.mode !== "tui") { ctx.ui.notify(JSON.stringify(values), "info"); return; }
-  if (!values.length) { ctx.ui.notify("没有子会话；用 pbot_agent start 创建。", "info"); return; }
-  if (confirmations.presenting) { ctx.ui.notify("请先处理主会话批准。", "info"); return; }
-  const options = values.map(v => agentSummary(v) + (v.owned ? "" : " · 其他分支"));
-  const selected = await ctx.ui.select("pbot 子会话", options);
-  const value = values[options.indexOf(selected ?? "")]; if (!value) return;
-  if (!value.owned) { ctx.ui.notify("请返回所属分支操作。", "info"); return; }
-  const inTmux = Boolean(process.env.TMUX);
-  const enterTui = "进入 TUI（返回：Ctrl+B → " + (inTmux ? "l" : "d") + "）";
-  const action = await ctx.ui.select(value.name, [enterTui, "补充要求", "重命名", "停止"]);
-  instance.check();
-  if (action === "停止") { instance.agents.stop(value.agentId, owner()); return; }
-  if (action === "重命名") { const name = await ctx.ui.input("名称"); instance.check(); if (name?.trim()) instance.agents.rename(value.agentId, name.trim(), owner()); return; }
-  if (action === "补充要求") {
-    const message = await ctx.ui.editor("任务或补充要求");
-    instance.check();
-    if (message?.trim()) instance.agents.send(value.agentId, message, "steer", owner());
-    return;
+  const owner = () => agentOwner(ctx), views = () => instance.agents.list(owner()).filter(v => !agentIds || agentIds.includes(v.agentId));
+  if (ctx.mode !== "tui") { ctx.ui.notify(JSON.stringify(views()), "info"); return; }
+  if (confirmations.presenting) { ctx.ui.notify("请先处理待确认操作。", "info"); return; }
+  for (;;) {
+    instance.check(); const values = views();
+    if (!values.length) { ctx.ui.notify("还没有专家。告诉主助手需要什么专家即可创建。", "info"); return; }
+    const options = values.map(v => agentSummary(v) + (v.owned ? "" : " · 其他分支"));
+    const selected = await choose(ctx, "专家", options), picked = values[options.indexOf(selected ?? "")]; if (!picked) return;
+    if (!picked.owned) { ctx.ui.notify("请返回所属分支操作。", "info"); continue; }
+    for (;;) {
+      instance.check(); const value = instance.agents.status(picked.agentId, owner()), inTmux = Boolean(process.env.TMUX);
+      const enterTui = value.alive ? "进入会话" : "打开原会话（待命）";
+      const action = await choose(ctx, `${value.name} · ${stateLabel(value.state)}`, [enterTui, "详情", ...(value.alive ? ["补充要求"] : []), "重命名", ...(value.alive ? ["停止"] : [])]);
+      if (!action) break;
+      instance.check();
+      try {
+        if (action === "详情") {
+          await readPage(ctx, value.name, [`状态  ${stateLabel(value.state)}`, `活动  ${value.activity}`, `模型  ${value.options.provider}/${value.options.model}`,
+            `目录  ${value.cwd}`, `ID    ${value.agentId}`, ...(value.error ? ["", value.error] : []), "", `返回主会话：Ctrl+B → ${inTmux ? "l" : "d"}`].join("\n")); continue;
+        }
+        if (action === "停止") { instance.agents.stop(value.agentId, owner()); ctx.ui.notify("已请求停止。", "info"); continue; }
+        if (action === "重命名") {
+          const name = await ctx.ui.input("新名称", value.name); instance.check();
+          if (name?.trim()) { instance.agents.rename(value.agentId, name.trim(), owner()); ctx.ui.notify("名称已更新。", "info"); } continue;
+        }
+        if (action === "补充要求") {
+          const message = await ctx.ui.editor("补充要求"); instance.check();
+          if (message?.trim()) { instance.agents.send(value.agentId, message, "steer", owner()); ctx.ui.notify("要求已排队。", "info"); } continue;
+        }
+        if (action !== enterTui) continue;
+        ctx.ui.notify(`返回主会话：Ctrl+B → ${inTmux ? "l" : "d"}`, "info");
+        let tui: TUI | undefined;
+        await ctx.ui.custom<void>((terminal, _theme, _keys, done) => { tui = terminal; queueMicrotask(() => done()); return new Text("", 0, 0); });
+        if (!tui) return;
+        instance.check(); await instance.agents.enter(value.agentId, owner()); const terminal = tui; terminal.stop();
+        try {
+          const code = await new Promise<number | null>(resolve => {
+            const child = spawn("tmux", [inTmux ? "switch-client" : "attach-session", "-t", "=" + tmuxName(value.agentId)], { stdio: "inherit" });
+            child.on("error", () => resolve(null)); child.on("close", resolve);
+          });
+          if (code !== 0) ctx.ui.notify("无法进入专家会话。", "error");
+        } finally { terminal.start(); terminal.requestRender(true); }
+        return;
+      } catch (error) { ctx.ui.notify(error instanceof Error ? error.message : String(error), "error"); }
+    }
   }
-  if (action !== enterTui) return;
-  let tui: TUI | undefined;
-  await ctx.ui.custom<void>((terminal, _theme, _keys, done) => { tui = terminal; queueMicrotask(() => done()); return new Text("", 0, 0); });
-  if (!tui) return;
-  instance.check();
-  instance.agents.enter(value.agentId, owner());
-  const terminal = tui;
-  terminal.stop();
-  try {
-    const code = await new Promise<number | null>(resolve => {
-      const child = spawn("tmux", [inTmux ? "switch-client" : "attach-session", "-t", "=" + tmuxName(value.agentId)], { stdio: "inherit" });
-      child.on("error", () => resolve(null)); child.on("close", resolve);
-    });
-    if (code !== 0) ctx.ui.notify("无法进入子会话。", "error");
-  } finally { terminal.start(); terminal.requestRender(true); }
 }