personal-bot 0.2.6 → 0.2.8

package/resources/references/compute.md

@@ -1,97 +1,20 @@
 # Python 计算
 
-## 环境
+环境上下文的 `python.state` 是当前共享环境状态。ready 时通过 Bash 使用 `python` 或 `python3`，直接导入第三方库。项目构建和测试使用项目声明的环境。
 
-主会话与专家的 `pbot_environment.python` 给出当前共享 Python 3.11+ 环境状态。为 ready 时，通过 Bash 使用 python 或 python3，按任务导入第三方库原生 API。项目构建和测试遵循项目声明的环境，在对应命令中使用。
+## 环境异常
 
-状态未就绪或依赖异常时，可自主诊断，只暂停依赖该环境的计算，不自动退回系统 Python，不删除或重建共享环境。额外依赖或共享环境变更先核对已有授权及影响范围；未获授权时说明所需变更并询问。需要重试 setup 时，使用当前宿主的 `/pbot python setup` 原生入口；需要用户执行会话操作时说明该入口；专家将所需会话操作或补充授权交回主会话。
+未就绪或依赖异常时可自主诊断，只暂停依赖该环境的计算，不退回系统 Python，不删除或重建共享环境。完整准备错误可在 `/pbot status` 查看，修复后用 `/pbot python setup` 重试；需要用户执行会话操作时说明入口，专家向主会话交回所需条件。
 
-所有 pbot 工作区共用当前用户的环境。更新依赖前停止相关计算，避免影响其他工作区；不同插件版本的依赖要求可能冲突。库清单说明可用方法，不代替本次环境状态检查。
+所有 pbot 工作区共用该环境。更改依赖会影响其他工作区，停止相关计算后再更新。安装与许可信息见 [Python 说明](../../python/README.md)。
 
-## 预装原生库
+## 按项目运行
 
-| 库 | 常用导入 | 用途 |
-| --- | --- | --- |
-| NumPy | `import numpy as np` | 数组与数值运算 |
-| pandas | `import pandas as pd` | 行情表、时间序列和文件读写 |
-| TA-Lib | `import talib` | 技术指标与形态函数 |
-| backtesting | `from backtesting import Backtest, Strategy` | 策略回测 |
-| SciPy | `from scipy import stats, optimize, signal` | 统计检验、优化、信号处理 |
-| statsmodels | `import statsmodels.api as sm` | 回归、时间序列、统计诊断 |
-| scikit-learn | `import sklearn` | 预处理、预测模型、聚类与评估；导入名为 sklearn |
-| Matplotlib | `import matplotlib.pyplot as plt` | 保存静态图表 |
-| seaborn | `import seaborn as sns` | 基于 Matplotlib 的统计图表 |
-| openpyxl | `import openpyxl` | Excel `.xlsx` 读写；也可用 pandas 的 openpyxl 引擎 |
-| PyArrow | `import pyarrow as pa` | Arrow、Parquet、Feather；也可用 pandas 的 pyarrow 引擎 |
-| Bokeh | `from bokeh.plotting import figure` | 交互式 HTML 图表，backtesting 绘图也使用它 |
+沿用项目的工作目录、脚本或模块入口、输入参数与输出位置。包内相对导入通常使用项目根目录下的 `python -m 包.模块`，不为绕过导入错误随意改 `sys.path`。相对数据路径取决于 cwd 或脚本自身的处理；交付时提供实际产物路径，并检查结果。
 
-这些库提供计算能力，不替代数据依据、统计假设或验证。时间序列建模按时间切分训练与验证数据，预处理只在训练集拟合，避免未来数据泄漏。
+预装库包括 NumPy、pandas、SciPy、statsmodels、scikit-learn（导入名 sklearn）、Matplotlib、seaborn、Bokeh、openpyxl、PyArrow、TA-Lib 和 backtesting。按任务查阅当前版本的原生 API。
 
-## 脚本、模块与产物
-
-已有脚本按项目文档在原位置运行，核对工作目录和入口。例如，替换以下占位路径后，从项目根目录运行脚本：
-
-```bash
-cd "/项目根目录" && python scripts/analyze.py --window 20
-```
-
-环境中只有 python3 命令时，将示例中的 python 换成 python3。包内相对导入通常使用模块入口，例如在项目根目录执行 `python -m analysis.main --window 20`。普通脚本导入同目录模块与 `-m` 的包导入遵循 Python 原生规则；不要为绕过错误随意改 sys.path。相对数据路径取决于工作目录或脚本自己的路径处理，应先核对约定。临时计算也可使用 `python -c` 或标准输入。
-
-按脚本或项目约定提供输入、参数和结果位置，使用实际 Bash 工具的超时与取消能力。
-
-Python 具有宿主文件和网络权限，不是沙箱；不得超出本次任务授权执行业务变更或改写历史记录。取消不回滚已发生的副作用。
-
-## 绘图与文件
-
-在无交互式图形界面的执行环境中使用 Matplotlib/seaborn 时，在导入 pyplot 或 seaborn 前选择 Agg 后端，保存图像并关闭 figure，不调用 `plt.show()`：
-
-```python
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-
-fig, ax = plt.subplots()
-ax.plot([1, 2, 3], [10, 12, 11])  # 示例数据，不是行情证据
-fig.savefig("chart.png", dpi=150, bbox_inches="tight")
-plt.close(fig)
-```
-
-文件按项目约定保存并交回实际产物路径；相对输出路径基于所选工作目录。Excel 可用 `pd.read_excel(path, engine="openpyxl")` 与 `df.to_excel(path, index=False, engine="openpyxl")`；Parquet 可用 `pd.read_parquet(path, engine="pyarrow")` 与 `df.to_parquet(path, index=False, engine="pyarrow")`。Feather 使用 `pd.read_feather` / `df.to_feather`。检查读写后的字段类型、时间单位与时区；Excel 不直接保存带时区的 datetime，转换前明确目标时区，不默默丢弃时区含义。
-
-## TA-Lib 技术指标
-
-常用原生函数包括 `SMA`、`EMA`、`MACD`、`RSI`、`BBANDS`、`ATR`、`ADX`、`STOCH`、`OBV` 和 `CDL*` 形态函数。用 `talib.get_function_groups()` 或 `talib.get_functions()` 查找能力，用 `help(talib.函数名)` 核对参数与返回值，不凭名称猜测。
-
-以下脚本从第一个命令行参数指定的 JSON 文件读取 close 数组，计算均线并输出严格 JSON：
-
-```python
-import json
-import sys
-import numpy as np
-import talib
-
-with open(sys.argv[1]) as file:
-    data = json.load(file)
-close = np.asarray(data["close"], dtype=np.float64)
-sma = talib.SMA(close, timeperiod=20)
-print(json.dumps({"sma20": [float(x) if np.isfinite(x) else None for x in sma]}, allow_nan=False))
-```
-
-使用前核对时间顺序、复权口径、缺失数据、单位和样本长度。多输入函数要求 OHLCV 数组按同一时间轴对齐。backtesting 策略可通过 `self.I(talib.SMA, self.data.Close, 20)` 注册指标。
-
-- `talib.MACD` 返回 `(macd, signal, hist)`，`hist = macd - signal`，不乘 2。
-- `talib.BBANDS` 返回 `(upper, middle, lower)`，默认使用 SMA 中轨和两倍总体标准差。
-- 暖机期输出 NaN；例如 SMA(20) 前 19 根、RSI(14) 前 14 根不可用。EMA、RSI 等按 TA-Lib 的种子与平滑规则计算，不等同于直接 pandas ewm。
-- NaN 输入可能影响后续输出，不擅自填零或把暖机值当成信号。持平序列的 RSI 在暖机后为 0，不是 50。
-- 指标可计算不证明策略有效。记录参数、TA-Lib 版本与数据依据；生成严格 JSON 时把非有限值转为 null。
-
-## backtesting 原生回测
-
-直接使用 `from backtesting import Backtest, Strategy`。继承 Strategy 定义 `init()` 和 `next()`，通过 `Backtest(data, 策略类, ...).run()` 运行。数据使用按时间升序的 OHLC DataFrame，可带 Volume，建议使用 DatetimeIndex；以当前安装版本的 API 为准。
-
-- 显式确定资金、手续费、价差、成交时点与仓位假设，不把库默认值当作投资规则。
-- 原生 Backtest 不自动提供 A 股 T+1、整手买入、涨跌停或交易日历约束。研究需要这些规则时，必须明确建模并验证；无法表达时说明限制，不能直接声称结果适用于该市场。
-- 按研究问题决定是否划分样本内/样本外及如何暖机，不默认套用固定回测流程。避免未来数据泄漏。
-- 按交付需要提取统计或交易记录，并说明参数与库版本。导出时处理原生结果中的 Series、DataFrame、时间和非有限值。
-
-环境与许可信息见 [Python 说明](../../python/README.md)。
+- 无图形界面的绘图：在导入 pyplot/seaborn 前选择 Matplotlib 的 Agg 后端，保存文件并关闭 figure。
+- Excel、Parquet、Feather：按格式选择 openpyxl 或 pyarrow；核对读写后的字段类型、时间单位与时区。Excel 不直接保存带时区的 datetime，转换前明确目标时区。
+- 统计或建模：记录数据与假设。时间序列按时间切分，预处理只在训练数据拟合，避免未来数据泄漏。
+- 技术指标或回测：再读 [指标与回测](compute-finance.md)，按本次问题确定数据口径和交易假设。

package/resources/references/task-conductor.md

@@ -4,30 +4,35 @@
 
 ## 准备能力
 
-先通过当前宿主的原生工具发现查找 Task Conductor，并加载 using-task-conductor 技能，以实际 MCP schema 为准。工具未直接显示不等于未安装；技能可用时，按技能处理连接或排障。
+通过当前宿主的原生工具发现查找 Task Conductor，读取 `using-task-conductor` 技能，再按实际 MCP schema 操作。工具未直接显示时，先按技能检查连接；技能缺失时检查插件安装和资源启用状态。
 
-以下安装命令只适用于 Pi。技能缺失时，用 `pi list` 检查插件及资源启用状态。已有旧版接入包时，先审阅官方升级说明，确认来源和作用域后显式替换旧包声明，不同时加载两份；服务更新与 MCP 配置另行核对，保留任务历史。确未安装则按本项目基线使用 Pi 1.5.0，核对已有安装授权，已覆盖时直接使用工作区安装命令，未覆盖时再请求授权：
+| 宿主 | 插件与技能入口 |
+| --- | --- |
+| Pi | `pi list` 查看来源与资源；从工作区根目录用 `pi install --local npm:task-conductor-plugin` 安装已发布接入，或用 `pi install --local /absolute/path/to/task-conductor/plugin` 加载未发布源码。当前会话执行 `/reload`，技能入口为 `/skill:using-task-conductor` |
+| dsh | 用 `dsh plugin --profile pbot list task-conductor-plugin --depth 0` 查看所选 profile；本地 tarball 使用 `dsh plugin --profile pbot add /absolute/path/to/task-conductor-plugin-<version>.tgz` 安装。重启对应宿主后，通过原生 skill 工具读取 `using-task-conductor`，或在聊天框调用 `/using-task-conductor`。桌面应用使用自己的原生插件页 |
 
-```bash
-pi install --local npm:task-conductor-plugin
-```
+将 `pbot` 和示例路径替换为实际 profile 和产物。dsh 接入包含于尚未发布的 Task Conductor `0.1.6` 候选版本；发布前使用该版本的本地插件及配套服务，构建方法见 [dsh 指南](../../docs/dsh.md#task-conductor)或[上游接入说明](https://github.com/realqiyan/task-conductor/blob/master/docs/host-integrations.md)。宿主聊天命令在相应会话中执行，不能通过 Bash 代执行；已发现技能时直接读取其正文继续。
 
-需要重载及通过技能交互安装时，请用户在当前 Pi 会话执行 `/reload`，再执行 `/skill:using-task-conductor` 处理服务安装、setup 与原生 MCP 接入；这些斜杠命令不能通过 Bash 代执行。可直接读取已发现的技能继续可执行的步骤。复用已有原生连接，不在聊天中索取凭据值；CLI 配置查询不等价于当前会话的临时连接状态。插件可见不证明服务已连接，执行器 ready 不证明模型认证和执行成功。
+dsh 插件随包提供共享技能，并为根主会话创建原生 MCP 连接，工作目录取该会话 cwd。通过实际名称调用工具，如 `mcp__task-conductor__executor_list`、`mcp__task-conductor__task_list`；保留名称中的连字符。复用插件连接，已有手工连接按上游方法调整来源，避免重复注册。dsh 接入不需要 Pi 交互 CLI；服务的协调模型单独配置。
 
-在 dsh 中，按上游适用于当前版本的方式加载技能，并通过 dsh 原生 MCP 连接已有服务；不把 Pi 插件声明、`pi install` 或 `/reload` 用作 dsh 接入。服务端节点的执行器、认证与环境仍按其自身配置核对，不假定与当前 dsh 会话相同。
+服务安装、setup、连接与排障按上游技能处理。dsh 中用 `/task-conductor status` 查看连接状态；服务设置完成或故障修复后用 `/task-conductor connect` 重连。能力不可用时说明具体阻碍，继续不受影响的工作。
 
-能力不可用时说明依赖它的工作受阻，继续其他已授权工作；不以循环等待或后台子会话替代持久调度。
+## 使用 dsh 执行节点
 
-## 委派与许可
+通过 Task Conductor 管理员 CLI 或 Web 注册自定义执行端 `dsh-acp`，使用 dsh 的规范绝对可执行路径和 `["--profile", "acp"]` 参数；`dsh` 不是内置执行端 ID。注册与查询步骤见上游技能的 `references/custom-acp.md`。在任务节点的 `executorId` 中选择已就绪的 `dsh-acp`。
 
-提交前明确输入、工作目录、所需工具与模型认证、输出和完成条件。周期任务还须明确频率、时区、授权范围及每轮数据来源、期间与时点。
+执行端使用 Task Conductor 后台的运行环境及 dsh 的 `acp` profile，单独准备模型认证、工具、技能和 Python；当前主会话的配置不自动传给节点。
 
-核实节点实际具备的工具、技能和 Python 环境，不假定它继承主会话能力或批准通道。节点任务限定为本次交付，不再递归委派；普通 Pi 节点不是受限专家，这些约定也不是宿主隔离。
+## 定义任务
 
-没有可靠批准通道时，不安排需人工批准的后台操作或无人值守交易；不得绕过批准要求。调度和恢复任务不扩大已有授权。独立复核使用新的独立节点，只查询和计算；协调器验收不等于专业复核或业务批准。
+提交前写明输入、工作目录、所需工具与模型、输出。周期任务还需明确频率、时区、执行范围及每轮数据来源、期间与时点。
 
-## 核对与保存
+准备节点所需的工具、技能、Python 环境和认证。需要人工交互的步骤应留在交互会话中完成。节点直接完成分配的任务，不再递归委派。
 
-任务定义、执行和节点分别用 taskId、runId 和节点 ID 标识。提交响应不明时先查已有标识；未取得 ID 时，按接口可用的请求关联、任务列表、提交时间或任务特征查找并核对。未能确认是否已创建时保留未知状态，不重复提交。实时状态查询 Task Conductor；项目资料只保存必要定义、标识和有时点的结果依据。
+## 状态与结果
 
-取消当前执行与停止未来周期分别操作，并查询确认。pbot_agent stop 或当前宿主关闭不停止 Task Conductor。报告已设置调度须有实际提交结果；报告本轮成功须核对本轮产物与完成条件。
+任务定义、执行和节点分别用 taskId、runId 和节点 ID 标识。提交响应不明时先按已有 ID 查询；未取得 ID 时，按请求关联、任务列表、提交时间或任务特征查找，避免重复创建。实时状态查询 Task Conductor，项目资料保存任务定义、标识和结果位置。
+
+通知回到提交任务的原生持久会话；dsh 恢复原 Session 后可以继续接收待处理事件。同项目的新会话不会代收，仍可通过 MCP 查询任务。
+
+取消当前执行与停止未来周期分别操作，并查询确认。pbot_agent stop 或当前宿主关闭不停止 Task Conductor。报告时区分调度已创建和本轮已完成，并给出对应状态与产物位置。

package/resources/skills/project-maintenance/SKILL.md

@@ -5,17 +5,17 @@ description: 维护项目结论、分析口径与可复用任务定义。用于
 
 # 项目整理与维护
 
-让资料呈现当前结论、适用条件、分析口径和未决问题。重要结论或决策变化保留原因与原依据。
+让资料呈现当前结论、适用条件、分析口径和未决问题。重要结论或决策变化时简要说明原因。
 
 根据本次变化更新当前任务、所属正文及实际受影响的引用。整体整理按用户指定范围进行。
 
 ## 更新所属资料
 
-从根 AGENTS.md 和相关目录入口定位正文；入口未命中时，按主题、别名或项目名搜索。结合实际成果核对正文与入口，资料状态以对应证据为依据。
+从根 AGENTS.md 和相关目录入口定位正文；入口未命中时，按主题、别名或项目名搜索。
 
-按主题合并当前说明，保留理解、继续或复用任务所需的信息。新旧证据先核对对象、时期和条件；用已确认的新结论替换被取代的说明，同步相关说明与引用，保留未解决的冲突。
+按主题合并当前说明，保留继续或复用任务所需的信息。比较新旧内容的对象、时期和条件，替换过时说明，同步引用，保留未解决的冲突。
 
-历史证据与重要决策保留原有来源、时点、适用条件及必要理由，当前说明通过引用追溯。用户偏好与约束按其确认范围记录，推断与已确认约定分开。
+保留历史资料与重要决策的来源和时间，当前说明通过引用连接。用户偏好与约定按用户表达记录，不把推测写成既定约定。
 
 从项目结论中提炼可跨任务复用的概念、方法与口径，写入 knowledge/，说明适用条件并引用来源。知识按主题命名，需要保留历史的研究和决策按日期与主题命名。
 
@@ -23,20 +23,18 @@ description: 维护项目结论、分析口径与可复用任务定义。用于
 
 ## 复用任务定义
 
-需要跨会话继续或重复执行的任务，在所属项目或长期事务中保存交付用途、必要证据、可接受限制和完成条件。目标变化时同步受影响的交付条件。
+需要跨会话继续或重复执行的任务，在所属项目或长期事务中保存目标、输入、执行方式和预期产物，随任务变化更新。
 
-重复分析或报告的定义按需包含数据来源与查询方式、对象与筛选范围、期间与时区、单位、指标公式与分母、分组与比较基准、执行入口及核验条件。单次报告引用所用定义。
+重复分析或报告的定义按需包含数据来源与查询方式、对象与筛选范围、期间与时区、单位、指标公式与分母、分组与比较基准、执行入口。单次报告引用所用定义。
 
-按上次口径重做时，读取已有定义，沿用已确认选择，并核对来源、版本与关键前提是否仍适用。更新报告使用本次期间与数据；复现历史结果使用指定输入。口径变化说明对可比性的影响，验证状态随新的验证证据更新。
+按上次口径重做时，读取已有定义，检查来源、版本与关键前提是否仍适用。更新报告使用本次期间与数据；复现历史结果使用指定输入。口径变化说明对可比性的影响。
 
 ## 成果归集与清理
 
 用户要求整理或结项时，检查本次范围内的项目目录及 scratch/ 等临时产物位置。将结论与方法并入所属正文，将交付物与可复用源码归入对应项目，更新来源引用与执行入口。
 
-归集后清理本次范围内已被正文吸收或不再需要的临时文件。正式资料、历史记录与备份保持原样。
+归集后只清理本次范围内已被正文吸收或不再需要的临时文件，不删除正式资料、历史记录或备份。
 
 ## 项目结项
 
-以已确认的目标和交付条件判断完成状态，核对交付物、来源引用与执行入口确实可用。满足本次用途即可结项，已知限制留在正文；可选深化与必需工作分开。
-
-交付条件尚未满足时，记录具体缺口及其影响。完成状态、正文与证据一致后，同步项目入口和相关导航。
+按任务目标检查交付物和执行入口。满足本次用途即可结项；尚有缺口时说明剩余工作，额外建议另列。更新项目状态和相关导航，已知限制留在正文。

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

@@ -23,20 +23,20 @@ description: 接入或修复原生 CLI/MCP，核对认证与可用性，维护
 
 项目配置经 Pi 项目信任规则加载，同名条目可能覆盖用户级配置。修改前核对同名项，保留无关条目与已有用户级连接；迁移另按用户指定范围处理。认证使用原生登录或环境变量引用。
 
-外部修改配置后，请用户在当前 Pi 会话执行 `/reload`，再用 `/mcp` 核对实际配置来源和连接状态；不要声称已代用户完成会话操作。当前工具 schema 通过原生工具搜索或 codemode 按需取得。新增权限、安装或共享配置变更先核对已有授权，已授权的操作不重复询问。
+外部修改配置后，请用户在当前 Pi 会话执行 `/reload`，再用 `/mcp` 查看配置来源和连接状态。当前工具 schema 通过原生工具搜索或 codemode 按需取得。
 
 ### dsh
 
-使用当前固定版本的原生 MCP 组件、profile 设置、认证与工具发现。按其公开文档或当前 help 核对参数，不使用 Pi 的命令和 `.pi/mcp.json` 配置方式。连接可能服务于同一 profile 的多个工作区，修改前核对实际作用域及已有授权，不把 profile 配置称为工作区隔离。
+使用当前安装版本的原生 MCP 组件、profile 设置、认证与工具发现。按其公开文档或当前 help 核对参数，不使用 Pi 的命令和 `.pi/mcp.json` 配置方式。同一 profile 的连接可能供多个工作区使用，修改时留意影响范围。
 
-优先复用已有连接，保留无关条目与其他工作区配置。用原生界面或可用管理能力完成已授权操作，再从当前会话核对工具、认证与连接状态；确需用户执行原生操作时，明确对应入口。工具可见不代表连接或业务调用成功，不为验证连接擅自执行写操作。
+优先复用已有连接，保留无关条目与其他工作区配置。通过原生界面或管理能力修改配置，再从当前会话检查连接和工具；需要用户操作时说明入口。
 
-## 验证与手册
+## 检查与手册
 
-用本次获准的查询验证所需能力，将实际接口、时间、覆盖范围与结果依据保存在所属项目。区分配置已保存、连接可用和业务已验证。
+用一个简单的只读查询检查所需能力，失败时根据实际错误排障。
 
 `providers/<id>/GUIDE.md` 面向当前使用，保留用途、原生入口、可信资料位置及适用版本。仅补充原生定义未说明、且影响正确使用的口径或限制；工具目录与参数细节从原生 help 和 schema 按需取得。
 
-更新时按主题合并，用已确认且适用的新结论替换过时说明，并同步示例。验证信息只保留影响当前使用的最新结论、时点与范围，详细和历史证据引用所属项目。
+更新时按主题合并，替换过时说明并同步示例。手册保留当前用法和已知限制，需要详细记录时引用所属项目。
 
-`providers/AGENTS.md` 只做导航和已确认的选用约定。
+`providers/AGENTS.md` 只做导航和选用约定。

package/scripts/README.md

@@ -12,7 +12,7 @@
 
 ## dsh 构建
 
-`npm run build:dsh` 调用 `build-dsh.mjs`，由 tsconfig.dsh.json 编译 Host 与浏览器入口，再用 esbuild 将 Web 代码包装为固定版原生包根 Loader 模块。宿主 SDK 保持 external；完整 build 和 prepack 先构建 CLI、再构建 dsh，统一输出到 lib。
+`npm run build:dsh` 调用 `build-dsh.mjs`，由 tsconfig.dsh.json 编译 Host 与浏览器入口，再用 esbuild 将 Web 代码包装为当前开发基线的原生包根 Loader 模块。宿主 SDK 保持 external；完整 build 和 prepack 先构建 CLI、再构建 dsh，统一输出到 lib。
 
 ## 发布包消费者检查
 

package/src/dsh.ts

@@ -1,4 +1,7 @@
+import { join } from "node:path";
 import type { Context } from "@deepseek-ai/cordis";
+import * as SkillFilesystem from "@deepseek-ai/dsh-skill-filesystem";
+import { resourceRoot } from "./common/paths.js";
 import { registerDshCommand } from "./extension/dsh/command.js";
 import { registerDshManagement } from "./extension/dsh/management.js";
 import { DshWorkspaces, dshDependencies } from "./extension/dsh/workspace.js";
@@ -10,6 +13,7 @@ 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 或更新版本。");
+  await ctx.plugin(SkillFilesystem, { providerName: "pbot", includeDefaultRoots: false, bundledSkillDir: join(resourceRoot, "skills") });
   const workspaces = new DshWorkspaces(ctx);
   ctx.effect(() => () => workspaces.close());
   const management = registerDshManagement(ctx, workspaces);

package/src/extension/agent-events.ts

@@ -14,6 +14,7 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
   let paused = false, epoch = 0, refreshEpoch = 0;
   let refreshing: Promise<void> | undefined;
   let controlBusySince: number | undefined;
+  let recoveredFailure: string | undefined;
   let failure: { key: string; error: string; recovery: "retry" | "repair" | "reload" } | undefined;
   const recordFailure = (error: unknown) => {
     const busy = (error as NodeJS.ErrnoException).code === "PBOT_CONTROL_BUSY";
@@ -67,7 +68,19 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
     if (!ctx || !lifecycle.active || paused || ctx.signal?.aborted) return;
     const instance = lifecycle.active, revision = epoch;
     if (!failure) {
-      try { return await collectNotification(); }
+      try {
+        const message = await collectNotification();
+        if (message) return message;
+        if (!ctx || revision !== epoch || instance !== lifecycle.active || paused || ctx.signal?.aborted || failure || !recoveredFailure || controlBusySince !== undefined) return;
+        const delivered = deliveredCycles(ctx), key = recoveredFailure + ":recovered";
+        if (!delivered.has(recoveredFailure) || delivered.has(key)) return;
+        const now = Date.now(), sent = submitting.get(key);
+        if (sent !== undefined && now - sent < 5000) return;
+        submitting.set(key, now);
+        return { type: "custom_message", customType: "pbot.agent-recovered", display: true,
+          content: "# 子会话自动跟进已恢复\n\n后台扫描已恢复。成员状态和报告可通过 pbot_agent status/read 查看。",
+          details: { keys: [key], failureKey: recoveredFailure } };
+      }
       catch (error) { if (revision !== epoch || instance !== lifecycle.active) return; recordFailure(error); }
     }
     if (!ctx || !failure || deliveredCycles(ctx).has(failure.key)) return;
@@ -82,7 +95,7 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
     return { type: "custom_message", customType: "pbot.agent-error", display: true,
       content: ["# 子会话自动跟进故障", "", recovery,
         ...(pausePending ? ["", "团队暂停尚未确认，不能据此开始成员私人任务。"] : []), "",
-        "尚未交付的结果未确认。需要核对成员时，用 pbot_agent list/status 查询状态、pbot_agent read 读取可用报告；结果未知不构成重新提交的依据。", "",
+        "用 pbot_agent list/status 查询成员状态，pbot_agent read 读取可用报告。重试前先查看原请求结果，避免重复执行。", "",
         markdownFields({ error: failure.error })].join("\n"), details: { keys: [failure.key] } };
   };
   const refreshWork = async () => {
@@ -103,7 +116,6 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
             try { instance.agents.enqueueTeam(input, instance.agentOwner); dispatching.delete(id); }
             catch (error) {
               const code = (error as NodeJS.ErrnoException).code;
-              if (code === "PBOT_CONTROL_BUSY") break;
               if (code !== "TEAM_INPUT_STALE") throw error;
               dispatching.delete(id); instance.teams.pauseMember(input.agentId, "安排失效；未自动重发");
             }
@@ -119,6 +131,7 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
       }
       if (ctx.mode === "tui") ctx.ui.setWidget("pbot-agents", values.some(v => ["starting", "busy", "stopping"].includes(v.state)) ? (_tui, theme) => agentBoard(values, theme) : undefined);
       if (!pausePending) {
+        if (failure) recoveredFailure = failure.key;
         failure = undefined; controlBusySince = undefined;
         if (ctx.hasUI) ctx.ui.setStatus("pbot-agents-error", undefined);
       }
@@ -150,7 +163,7 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
     return;
   };
   pi.on("session_start", (_event, context) => {
-    epoch++; 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; recoveredFailure = undefined; confirmations.resume(); submitting.clear(); dispatching.clear();
     if (timer) clearInterval(timer);
     if (lifecycle.active) { lifecycle.active.agentOwner = agentOwner(ctx); timer = setInterval(() => { void refresh(); }, 1000); timer.unref(); }
     return refresh();

package/src/extension/command.ts

@@ -26,7 +26,7 @@ export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirma
         const instance = lifecycle.get();
         if (command === "init" && !argument) {
           await ctx.waitForIdle(); instance.check(); await prepareWorkspace(instance.root);
-          ctx.ui.notify("资料目录已准备。", "info"); return;
+          ctx.ui.notify("资料目录已准备。新建的 AGENTS.md 在 /reload 或下次启动后由 Pi 加载。", "info"); return;
         }
         if (command === "status" && !argument) {
           const python = instance.pythonEnvironment.status;

package/src/extension/dsh/agent-events.ts

@@ -90,7 +90,7 @@ export class DshAgentEvents {
     let value: { keys: string[]; content: string } | undefined;
     if (this.#error && this.#errorKey) {
       if (!known.has(this.#errorKey)) value = { keys: [this.#errorKey], content: "# 协作扫描故障\n\n" + this.#error +
-        "\n\n先核对控制记录和原生报告；结果未知不是重跑许可。" +
+        "\n\n先查看控制记录和原生报告，再决定是否重试，避免重复执行。" +
         (this.#recovery === "reload" ? "团队服务已停用；修复文件后还需重载服务端 personal-bot 插件。" :
           this.#recovery === "retry" ? "控制锁持续占用，后台会继续重试；不会自动删除锁或重新提交任务。" : "报告或控制记录读取失败，修复后后台会重试扫描。") +
         (this.#pausePending ? "\n\n团队暂停尚未确认，不能据此开始成员私人任务。" : "") };

package/src/extension/dsh/agent-runtime.ts

@@ -25,6 +25,7 @@ export class DshAgentRuntime {
   #answer = "";
   #hasAnswer = false;
   #activeTeam: TeamLink | undefined;
+  #teamBriefed = false;
   #pendingPause: string | undefined;
   #pump: Promise<void> | undefined;
   #timer: ReturnType<typeof setInterval> | undefined;
@@ -98,12 +99,11 @@ export class DshAgentRuntime {
       requireThat(link, "团队关联不可读取。");
       const seen = this.#seen.get(link.team.teamId) ?? new Set<number>();
       const context = createTeamContext(link, seen);
-      if (!context) return decision;
-      return { ...decision, messages: [...decision.messages, createUserMessage({ content: [{ type: "text", text: context.content }],
-        source: { kind: "pbot-team-context", form: "relay", teamId: link.team.teamId, seqs: context.seqs } })] };
+      if (this.#teamBriefed && !context) return decision;
+      const text = [...(this.#teamBriefed ? [] : [teamBrief(link)]), ...(context ? [context.content] : [])].join("\n\n");
+      return { ...decision, messages: [...decision.messages, createUserMessage({ content: [{ type: "text", text }],
+        source: { kind: "pbot-team-context", form: "relay", teamId: link.team.teamId, seqs: context?.seqs ?? [] } })] };
     });
-    this.ctx.systemPrompt.section({ name: "pbot:team", order: 600, interpolate: false,
-      text: () => this.#activeTeam && !this.humanPending() && this.execution.current?.source === "parent" ? teamBrief(this.#activeTeam) : "" });
     this.execution.save({ state: "idle", activity: "空闲" });
     this.ctx.effect(() => () => this.stop());
   }
@@ -128,7 +128,7 @@ export class DshAgentRuntime {
   private async event(event: SessionEvent) {
     if (!this.current()) return;
     if (event.type === "turn/start") {
-      this.#turnEvents = []; this.#answer = ""; this.#hasAnswer = false;
+      this.#turnEvents = []; this.#answer = ""; this.#hasAnswer = false; this.#teamBriefed = false;
       this.execution.begin();
     }
     if (this.execution.current) this.#turnEvents.push(event);
@@ -152,6 +152,7 @@ export class DshAgentRuntime {
       if (event.data.source.kind === "user") this.execution.humanInput();
       if (event.data.source.kind === "pbot-team-context") {
         const { teamId, seqs } = event.data.source, seen = this.#seen.get(teamId) ?? new Set<number>();
+        if (this.#activeTeam?.team.teamId === teamId) this.#teamBriefed = true;
         for (const seq of seqs) seen.add(seq); this.#seen.set(teamId, seen);
       }
     }

package/src/extension/events.ts

@@ -25,19 +25,24 @@ export function registerEvents(pi: ExtensionAPI, lifecycle: Lifecycle, confirmat
       else throw error;
     }
   });
-  pi.on("resources_discover", () => lifecycle.active ? { skillPaths: [join(resourceRoot, "skills")] } : {});
   pi.on("before_agent_start", async (event, ctx) => {
     const instance = lifecycle.active;
     if (!instance) return;
     instance.cancelWork();
-    const role = await agentText("coordinator", instance.root);
-    const workspace = await readFile(join(resourceRoot, "prompts/workspace.md"), "utf8");
-    instance.check();
-    event.systemPromptOptions.sections.pbot_workspace = workspace;
-    event.systemPromptOptions.sections.pbot_environment = JSON.stringify({
-      workspaceRoot: instance.root, cwd: ctx.cwd, resourceRoot, python: instance.pythonEnvironment.status,
-    });
-    event.systemPromptOptions.sections.pbot = role;
+    try {
+      const role = await agentText("coordinator", instance.root);
+      const workspace = await readFile(join(resourceRoot, "prompts/workspace.md"), "utf8");
+      instance.check();
+      const { state, directory } = instance.pythonEnvironment.status;
+      Object.assign(event.systemPromptOptions.sections, {
+        pbot_workspace: workspace,
+        pbot_environment: JSON.stringify({ workspaceRoot: instance.root, resourceRoot, python: { state, directory } }),
+        pbot: role,
+      });
+    } catch (error) {
+      // Pi reports hook errors but continues preparation unless the run is explicitly aborted.
+      ctx.abort(); throw error;
+    }
   });
   pi.on("input", () => { lifecycle.active?.cancelWork(); });
   pi.on("agent_end", () => { lifecycle.active?.cancelWork(); });

package/src/extension/subagent-entry.ts

@@ -134,7 +134,7 @@ export default function subagent(pi: ExtensionAPI) {
   pi.registerTool({ ...teamMessageTool(teams, { check: ensure }, () => ({
     kind: "member", agentId: id, generation,
     ...(activeTeam && execution.current?.source === "parent" ? { requestId: activeTeam.request.requestId } : {}),
-  })), namespace: { name: "pbot", description: "团队公共通信，不提供管理或递归委派。" } });
+  })), namespace: { name: "pbot", description: "团队公共通信。" } });
   pi.on("resources_discover", async () => {
     if (d.options.noSkills) return {};
     const skillPaths = [join(resourceRoot, "skills")];
@@ -189,22 +189,30 @@ export default function subagent(pi: ExtensionAPI) {
     }
   });
   pi.on("before_agent_start", async (event, context) => {
-    ctx = context; ensure(); bindSession();
-    delete event.systemPromptOptions.sections.pbot_team;
-    requireThat(python, "子会话计算环境状态不可用。");
-    event.systemPromptOptions.sections.pbot_environment = JSON.stringify({
-      workspaceRoot: d.workspace, cwd: d.cwd, resourceRoot, python: python.status,
-    });
-    event.systemPromptOptions.sections.pbot_workspace = await readFile(join(resourceRoot, "prompts/workspace.md"), "utf8");
-    event.systemPromptOptions.sections.pbot_child = await agentText("general-purpose", d.workspace);
-    if (activeTeam && !execution.interactive && execution.current?.source !== "mixed") {
-      const link = teams.links().get(activeTeam.request.requestId);
-      requireThat(link, "团队关联不可读取。");
-      event.systemPromptOptions.sections.pbot_team = teamBrief(link);
-      const message = teamContext(link, context, link.request.throughSeq);
-      if (message) return { message };
+    ctx = context;
+    try {
+      ensure(); bindSession();
+      requireThat(python, "子会话计算环境状态不可用。");
+      const workspace = await readFile(join(resourceRoot, "prompts/workspace.md"), "utf8");
+      const role = await agentText("general-purpose", d.workspace);
+      let brief: string | undefined, message;
+      if (activeTeam && !execution.interactive && execution.current?.source !== "mixed") {
+        const link = teams.links().get(activeTeam.request.requestId);
+        requireThat(link, "团队关联不可读取。");
+        brief = teamBrief(link);
+        message = teamContext(link, context, link.request.throughSeq);
+      }
+      const { state, directory } = python.status;
+      Object.assign(event.systemPromptOptions.sections, {
+        pbot_environment: JSON.stringify({ workspaceRoot: d.workspace, resourceRoot, python: { state, directory } }),
+        pbot_workspace: workspace, pbot_child: role,
+      });
+      if (brief) event.systemPromptOptions.sections.pbot_team = brief;
+      else delete event.systemPromptOptions.sections.pbot_team;
+      return message ? { message } : undefined;
+    } catch (error) {
+      context.abort(); throw error;
     }
-    return;
   });
   pi.on("turn_end", (event, context) => {
     if (!activeTeam || execution.current?.source !== "parent" || event.outcome === "aborted") return;

package/src/integrations/dsh/resources.ts

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
-import { FileSystemSkillProvider } from "@deepseek-ai/dsh-skill-filesystem";
+import type {} from "@deepseek-ai/dsh-skill";
 import type {} from "@deepseek-ai/dsh-working-directory";
 import type {} from "@deepseek-ai/dsh-tools";
 import { agentText } from "../agent-resources.js";
@@ -10,29 +10,32 @@ import { resourceRoot } from "../../common/paths.js";
 import { requireThat } from "../../common/validation.js";
 import type { AgentOptions } from "../../model/agent.js";
 
-export async function dshResources(ctx: Context, agent: Agent, root: string,
+export async function dshResources(ctx: Context, _agent: Agent, root: string,
   role: "coordinator" | "general-purpose", python: () => { state: string; directory?: string; error?: string }, check: () => void) {
-  let text = await agentText(role, root);
-  const workspace = await readFile(join(resourceRoot, "prompts/workspace.md"), "utf8");
+  const read = () => Promise.all([agentText(role, root), readFile(join(resourceRoot, "prompts/workspace.md"), "utf8")]);
+  const [text, workspace] = await read();
   check();
-  ctx.systemPrompt.section({ name: "pbot:role", order: 1, text: () => text, interpolate: false });
+  ctx.systemPrompt.section({ name: "pbot:role", order: 1, text, interpolate: false });
   ctx.systemPrompt.section({ name: "pbot:workspace", order: 2, text: workspace, interpolate: false });
   ctx.systemPrompt.context({ name: "pbot:environment", order: 300, required: true, interpolate: false,
-    text: () => JSON.stringify({ host: "dsh", workspaceRoot: root, cwd: ctx.workingDirectory.get(agent.session), resourceRoot, python: python() }) });
-  ctx.skills.registerProvider(control => new FileSystemSkillProvider(ctx, control, {
-    providerName: "pbot", includeDefaultRoots: false, customSkillDirs: [join(root, ".agents/skills")],
-    bundledSkillDir: join(resourceRoot, "skills"), watch: false,
-  }));
-  ctx.on("agent/pre-step", async (_payload, next) => {
-    check(); text = await agentText(role, root); check();
-    return next();
+    text: () => {
+      const { state, directory } = python();
+      return JSON.stringify({ workspaceRoot: root, resourceRoot, python: { state, ...(directory ? { directory } : {}) } });
+    } });
+  ctx.on("system-prompt/assemble", async (_assembly, _context, next) => {
+    check();
+    const [roleText, workspaceText] = await read();
+    check();
+    const assembly = await next();
+    return { ...assembly, sections: assembly.sections.map(section => section.name === "pbot:role" ? { ...section, text: roleText }
+      : section.name === "pbot:workspace" ? { ...section, text: workspaceText } : section) };
   });
 }
 
 /** Map the expert's native loadout; this is not isolation from Bash, CLI, or MCP. */
 export function dshExpertTools(ctx: Context, agent: Agent, options: AgentOptions) {
   const names = new Set(ctx.tools.definitions(agent).map(tool => tool.name));
-  const forbidden = new Set(["pbot_agent", "pbot_team", "pbot_history", "subagent", "list_subagent_models", "list_agents", "send_message", "interrupt_agent"]);
+  const forbidden = new Set(["pbot_agent", "pbot_team", "pbot_history", "subagent", "subagent_fork", "list_subagent_models", "list_agents", "send_message", "interrupt_agent"]);
   if (options.noSkills) forbidden.add("skill");
   if (options.tools) {
     for (const name of options.tools) requireThat((names.has(name) || name === "pbot_team_message") && !forbidden.has(name), "专家工具不可用：" + name);

package/src/integrations/dsh/session.ts

@@ -4,6 +4,7 @@ import { SessionId } from "@deepseek-ai/dsh-session";
 import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
 import type { SessionHeader } from "@deepseek-ai/dsh-session";
 import type {} from "@deepseek-ai/dsh-session-persistence";
+import type {} from "@deepseek-ai/dsh-agent-preset-registry";
 import type { AgentDescriptor } from "../../model/agent.js";
 import { requireThat } from "../../common/validation.js";
 
@@ -37,6 +38,7 @@ export async function openDshAgent(ctx: Context, d: AgentDescriptor, parent: Age
   signal.throwIfAborted();
   const compose: AgentSetup = async (agentCtx, agent) => {
     validateHeader(d, agent.session.header);
+    agentCtx.get("agentPresets")?.composeFrom(agentCtx, parent.ctx);
     if (resume) agent.inbox.clear();
     const commit = await setup(agentCtx, agent);
     await flushDshAgent(agent);

package/src/integrations/installation/pi-bridge.ts

@@ -44,20 +44,22 @@ export async function inspectPackages(root: string, workspace: string): Promise<
   for (const pkg of manager.listConfiguredPackages()) {
     const entries = (pkg.scope === "project" ? settings.getProjectSettings() : settings.getGlobalSettings()).packages ?? [];
     const entry = entries.find(item => sourceOf(item) === pkg.source);
-    let name = npmName(pkg.source), version: string | undefined;
+    let name = npmName(pkg.source), version: string | undefined, singleFile = false;
     if (pkg.installedPath) {
-      let file = pkg.installedPath;
-      if ((await stat(file)).isDirectory()) file = join(file, "package.json");
-      else file = ""; // Single-file extensions have no npm identity.
-      if (file) {
+      const info = await stat(pkg.installedPath);
+      singleFile = info.isFile(); // An existing standalone extension has no npm identity.
+      if (info.isDirectory()) {
         try {
-          const manifest = JSON.parse(await readFile(file, "utf8")) as { name?: string; version?: string };
+          const manifest = JSON.parse(await readFile(join(pkg.installedPath, "package.json"), "utf8")) as { name?: string; version?: string };
           if (name && manifest.name !== name) throw new Error(`安装包身份不匹配：${pkg.source}`);
-          name = typeof manifest.name === "string" ? manifest.name : name;
+          name = typeof manifest.name === "string" && manifest.name.trim() ? manifest.name : name;
           version = typeof manifest.version === "string" ? manifest.version : undefined;
         } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
       }
     }
+    if (!name && !singleFile) {
+      throw new Error(`无法辨认 ${pkg.scope} 来源的包身份：${pkg.source}。请先通过 Pi 原生配置恢复或修正该来源，再重新运行 setup。`);
+    }
     result.push({ source: pkg.source, scope: pkg.scope, filtered: pkg.filtered, entry,
       ...(pkg.installedPath ? { installedPath: pkg.installedPath } : {}), ...(name ? { name } : {}), ...(version ? { version } : {}) });
   }

package/src/integrations/pi/agent-context.ts

@@ -6,7 +6,7 @@ export function agentOwner(ctx: ExtensionContext): AgentOwner {
 export function deliveredCycles(ctx: ExtensionContext): Set<string> {
   const keys = new Set<string>();
   for (const entry of ctx.sessionManager.getBranch()) {
-    const data = entry.type === "custom_message" && ["pbot.agent-results", "pbot.agent-error"].includes(entry.customType) ? entry.details
+    const data = entry.type === "custom_message" && ["pbot.agent-results", "pbot.agent-error", "pbot.agent-recovered"].includes(entry.customType) ? entry.details
       : entry.type === "custom" && entry.customType === "pbot.agent-read" ? entry.data : undefined;
     if (entry.type === "custom" && entry.customType === "pbot.agent-read") {
       const receipt = entry.data as { toolCallId?: string };