personal-bot 0.2.3 → 0.2.5

package/src/extension/setup-cli.ts

@@ -0,0 +1,109 @@
+import { mkdir, readFile, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { executeSetup, packageChoices, parseCatalog, parseSetupArgs } from "../services/installation/setup-service.js";
+import { npmName, ordinaryNpm } from "../common/package-source.js";
+import type { InstalledPackage, SetupPlan } from "../services/installation/setup-service.js";
+import { PiBootstrapRequired, PiSetup, piPackageName } from "../integrations/installation/pi-setup.js";
+import { inspectSystem, SetupProcesses } from "../integrations/installation/processes.js";
+import { resolveWorkspace } from "../integrations/installation/workspace.js";
+import { SetupUI } from "../ui/setup.js";
+
+const root = new URL("../../", import.meta.url);
+const quote = (value: string) => "'" + value.replaceAll("'", "'\\''") + "'";
+
+export async function main(args: string[]): Promise<number> {
+  let options: ReturnType<typeof parseSetupArgs>;
+  try { options = parseSetupArgs(args); }
+  catch (error) { console.error(String(error)); return 2; }
+  const manifest = JSON.parse(await readFile(new URL("package.json", root), "utf8")) as { version: string };
+  if (options.action === "version") { console.log(manifest.version); return 0; }
+  if (options.action === "help") {
+    console.log("Personal Bot " + manifest.version + "\n\n用法：pbot setup [--workspace <目录>]\n" +
+      "      npx personal-bot@latest setup\n\nsetup 安装或升级 Pi、pbot 和选中的插件，然后启动 Pi 执行 /pbot init。\n" +
+      "支持 Linux/macOS，需要 Node.js 22.19+、npm 和 Python 3.11+。\n--help 显示帮助；--version 显示安装器版本。");
+    return 0;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error("setup 需要交互终端。请在终端运行 npx personal-bot@latest setup。"); return 2;
+  }
+  const controller = new AbortController();
+  const cancel = () => controller.abort(new Error("安装已取消；已完成的步骤保留。"));
+  process.on("SIGINT", cancel); process.on("SIGTERM", cancel);
+  const ui = new SetupUI(controller), processes = new SetupProcesses(controller.signal);
+  try {
+    const cwd = process.cwd();
+    ui.text("Personal Bot " + manifest.version + " — 安装与升级\n正在检查 Node/npm、Python 和 tmux…");
+    const system = await inspectSystem(processes, cwd);
+    const supplied = options.workspace ?? await ui.ask("工作区目录（当前、已有或新建目录）", cwd);
+    const workspace = await resolveWorkspace(supplied, cwd, homedir());
+    const host = new PiSetup(processes, system.npm, cwd);
+    let pi = await host.inspectPi();
+    let installed: InstalledPackage[];
+    try { installed = await host.inspectPackages(pi, workspace); }
+    catch (error) {
+      if (!(error instanceof PiBootstrapRequired)) throw error;
+      const version = await host.latest(piPackageName);
+      ui.text(error.message + "\n需先安装 Pi 才能使用其原生接口核对这些来源。目标版本：" + version);
+      if (!await ui.confirm("先通过 npm 安装 Pi，再继续选择工作区插件")) return 130;
+      pi = await host.ensurePi(undefined, version);
+      installed = await host.inspectPackages(pi, workspace);
+    }
+    const catalog = parseCatalog(JSON.parse(await readFile(new URL("resources/installer/plugins.json", root), "utf8")));
+    const choices = packageChoices(catalog, installed), optional = choices.filter(choice => !choice.required);
+    ui.text("\nPersonal Bot 必装。选择配套插件（取消勾选不会卸载已有插件）：");
+    const selected = await ui.selectMany(optional.map(choice => choice.plugin.label + " — " + choice.plugin.description),
+      optional.flatMap((choice, index) => choice.selected ? [index] : []));
+    optional.forEach((choice, index) => { choice.selected = selected.includes(index); });
+    for (const choice of choices.filter(item => item.selected)) {
+      if (choice.existing.some(pkg => !ordinaryNpm(pkg.source))) {
+        ui.text("\n" + choice.plugin.label + " 的已有来源：\n" + choice.existing.map(pkg =>
+          "  " + pkg.scope + ": " + pkg.source + " (" + (pkg.version ?? "版本未知") + ")").join("\n"));
+        choice.keep = !await ui.confirm("切换到 npm 最新稳定版", false);
+      }
+      if (choice.keep) {
+        if (choice.existing.length !== 1 || !choice.existing[0]?.installedPath) choice.error = "保留来源未安装或存在多份来源，请先通过 Pi 原生配置处理。";
+      } else {
+        const others = choice.existing.filter(pkg => !npmName(pkg.source));
+        if (others.length > 1 || others.some(pkg => pkg.scope === "user")) {
+          choice.error = "请先用 pi config 调整全局或重复来源的加载范围，再切换到 npm。";
+        } else {
+          try { choice.target = await host.latest(npmName(choice.plugin.source)!); }
+          catch (error) { controller.signal.throwIfAborted(); choice.error = String(error); }
+        }
+      }
+    }
+    const plan: SetupPlan = { workspace, piVersion: await host.latest(piPackageName), packages: choices,
+      ...(pi ? { pi } : {}), ...(system.tmux ? { tmux: system.tmux } : {}) };
+    ui.text("\n安装计划\n工作区：" + workspace + "\nPi：" + (pi ? pi.command + " (" + pi.version + ")" : "通过 npm 全局安装") + " → " + plan.piVersion);
+    if (system.tmux) ui.text("tmux：" + [system.tmux.command, ...system.tmux.args].map(quote).join(" "));
+    for (const choice of choices) {
+      ui.text("  " + choice.plugin.label + ": " + (!choice.selected ? "本次跳过" : choice.error ??
+        (choice.keep ? "保留 " + choice.existing[0]?.source : (choice.existing.map(pkg => pkg.version ?? "未知").join(", ") || "未安装") + " → " + choice.target)));
+      if (choice.selected && choice.existing.some(pkg => pkg.filtered)) ui.text("    保留已有资源过滤；如 pbot 被禁用，请通过 pi config --local 启用。");
+    }
+    const blocking = choices.find(choice => choice.required && choice.error);
+    if (blocking) throw new Error(blocking.error);
+    ui.text("升级前请停止活动 pbot 子会话和相关 Python 脚本。Pi 为当前用户共用，插件只处理此工作区。");
+    if (!await ui.confirm("执行以上计划")) return 130;
+    await mkdir(workspace, { recursive: true });
+    if (await realpath(workspace) !== workspace) throw new Error("工作区路径已发生变化，请重新运行 setup。");
+    const result = await executeSetup(plan, host, item => ui.text("[" + item.state + "] " + item.name + ": " + item.detail), controller.signal);
+    const failed = result.results.some(item => item.state === "failed");
+    if (!result.pi) return 1;
+    ui.text("\n软件安装阶段结束。初始化、Python 环境和外部服务的状态由 Pi/pbot/插件分别报告。");
+    if (await ui.confirm(failed ? "部分插件失败，是否仍先启动 Pi" : "立即启动 Pi", !failed)) {
+      process.stdin.pause();
+      await host.start(result.pi, workspace);
+    } else {
+      ui.text("稍后执行：\ncd " + quote(workspace) + "\n" + quote(result.pi.command) + " --extension " +
+        quote(fileURLToPath(new URL("extension/setup-guard.js", new URL("../", import.meta.url)))) + " '/pbot init'");
+    }
+    return failed ? 1 : 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return controller.signal.aborted ? 130 : 1;
+  } finally {
+    process.off("SIGINT", cancel); process.off("SIGTERM", cancel);
+  }
+}

package/src/extension/setup-guard.ts

@@ -0,0 +1,12 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+// Native extension commands run before input handlers. Reaching this handler for
+// /pbot init means it was not dispatched; never let the setup input reach a model.
+export default function setupGuard(pi: ExtensionAPI) {
+  pi.on("input", (event, ctx) => {
+    if (event.text.trim() !== "/pbot init") return { action: "continue" };
+    ctx.ui.notify("pbot 未加载或命令存在冲突。请检查项目信任和 pi config --local 后重新运行 setup。", "error");
+    ctx.shutdown();
+    return { action: "handled" };
+  });
+}

package/src/extension/subagent-entry.ts

@@ -1,25 +1,25 @@
 import { readFile, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { existsSync, realpathSync } from "node:fs";
-import { randomUUID } from "node:crypto";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { AgentFiles, descriptor, launch, status, cycle } from "../storage/agent-files.js";
+import { AgentFiles, descriptor, launch } from "../storage/agent-files.js";
+import { AgentRun } from "../services/agents/agent-run.js";
 import { TeamFiles } from "../storage/team-files.js";
 import { TeamService } from "../services/agents/team-service.js";
 import { teamMessageTool } from "../tools/teams/tool.js";
-import { teamBrief, teamContext } from "../integrations/pi/team-context.js";
+import { teamContext } from "../integrations/pi/team-context.js";
+import { teamBrief } from "../integrations/team-context.js";
 import { readAgentSession } from "../integrations/pi/pi-agents.js";
 import type { TeamLink } from "../model/team.js";
 import { PythonEnvironmentService } from "../services/workspace/python-environment-service.js";
 import { activatePython } from "../integrations/python-activation.js";
 import { authorizeMutation } from "../services/workspace/workspace-files.js";
-import { agentText } from "../integrations/pi/agent-resources.js";
+import { agentText } from "../integrations/agent-resources.js";
 import { agentInput } from "../integrations/pi/agent-input.js";
 import { agentFileTools } from "../integrations/pi/agent-tools.js";
 import { resourceRoot } from "../common/paths.js";
 import { requireThat } from "../common/validation.js";
 import { packageVersion, releaseLine } from "../common/version.js";
-import type { AgentCycle, AgentStatus } from "../model/agent.js";
 
 /** Explicit child composition; never installs main commands or approval capabilities. */
 export default function subagent(pi: ExtensionAPI) {
@@ -36,19 +36,10 @@ export default function subagent(pi: ExtensionAPI) {
   let ready = false, disposed = false;
   let ctx: ExtensionContext | undefined, timer: ReturnType<typeof setInterval> | undefined;
   let python: PythonEnvironmentService | undefined, restorePython: (() => void) | undefined;
-  let processing = false, closing = false, current: AgentCycle | undefined, startLeaf: string | null = null;
-  let queuedRequests: string[] = [], interactive = false;
-  const accepted = new Set<string>();
-  const saved = files.optional(id, "status.json", status);
-  let snapshot: AgentStatus = { generation, state: "starting", activity: "启动", updatedAt: Date.now() };
-  if (saved?.generation === generation) for (const requestId of saved.accepted ?? []) accepted.add(requestId);
+  let processing = false, closing = false, startLeaf: string | null = null;
+  const execution = new AgentRun(files, id, generation);
   let lastActivity = 0;
-  const save = (patch: Partial<AgentStatus>) => {
-    snapshot = { ...snapshot, ...patch, updatedAt: Date.now() };
-    if (current) snapshot.cycle = structuredClone(current);
-    snapshot.accepted = [...accepted];
-    files.write(id, "status.json", snapshot, status);
-  };
+  const save = execution.save.bind(execution);
   const ensure = () => {
     lifetime.signal.throwIfAborted(); files.check();
     const run = files.read(id, "launch.json", launch);
@@ -66,18 +57,16 @@ export default function subagent(pi: ExtensionAPI) {
     catch (error) { if ((error as NodeJS.ErrnoException).code !== "PBOT_CONTROL_BUSY") throw error; }
   };
   const finish = (aborted: boolean) => {
-    if (!ctx || !current) return;
+    if (!ctx || !execution.current) return;
     const branch = ctx.sessionManager.getBranch();
     const at = startLeaf === null ? -1 : branch.findIndex(e => e.id === startLeaf);
     const last = branch.slice(at + 1).filter(e => e.type === "message" && e.message.role === "assistant").at(-1);
     const assistant = last?.type === "message" && last.message.role === "assistant" ? last.message : undefined;
     const text = assistant?.content.filter(p => p.type === "text").map(p => p.text).join("\n") ?? "";
-    current = { ...current, finishedAt: Date.now(), leaf: assistant ? ctx.sessionManager.getLeafId() : null,
-      state: aborted ? "cancelled" : assistant?.stopReason === "stop" && text.trim() ? "completed" : "failed",
-      ...(!assistant || assistant.stopReason !== "stop" ? { error: assistant?.errorMessage ?? "没有有效最终回答。" } : {}) };
-    files.write(id, "completions/" + current.cycleId + ".json", current, cycle, true);
-    save({ state: "idle", activity: current.state });
-    current = undefined; activeTeam = undefined;
+    execution.finish({ position: assistant ? ctx.sessionManager.getLeafId() : null, answer: text,
+      state: aborted ? "cancelled" : assistant?.stopReason === "stop" ? "completed" : "failed",
+      ...(!assistant || assistant.stopReason !== "stop" ? { error: assistant?.errorMessage ?? "没有有效最终回答。" } : {}) });
+    activeTeam = undefined;
   };
   const shutdown = async () => {
     if (closing) return;
@@ -105,33 +94,31 @@ export default function subagent(pi: ExtensionAPI) {
       if (activeTeam) {
         if (Date.now() >= activeTeam.run.deadlineAt) {
           pauseTeam("已到期限");
-          if (!interactive && current?.source !== "mixed") {
+          if (!execution.interactive && execution.current?.source !== "mixed") {
             ctx.abort();
-            if (!current && ctx.isIdle()) await shutdown();
+            if (!execution.current && ctx.isIdle()) await shutdown();
           }
         }
         return;
       }
       const links = teams.links();
       for (const request of files.messages(id)) {
-        if (request.generation !== generation || accepted.has(request.requestId)) continue;
+        if (request.generation !== generation || execution.accepted(request.requestId)) continue;
         const link = links.get(request.requestId);
         if (link && (link.team.closed || link.run.state !== "running" || link.run.deadlineAt <= Date.now())) continue;
-        if (link && (!ctx.isIdle() || ctx.hasPendingMessages() || current || interactive || queuedRequests.length)) break;
+        if (link && (!ctx.isIdle() || ctx.hasPendingMessages() || execution.current || execution.interactive || execution.pending)) break;
         const content = await agentInput(d.cwd, request, lifetime.signal);
         requireThat(ctx.model, "子会话没有可用模型。");
         requireThat(ctx.modelRegistry.hasConfiguredAuth(ctx.model) || await ctx.modelRegistry.getProviderAuth(ctx.model.provider), "子会话模型未认证，请配置原生 Pi 认证后显式恢复。");
         ensure();
         const accept = () => {
           bindSession();
-          accepted.add(request.requestId);
           pi.appendEntry("pbot.agent-input", { requestId: request.requestId, generation });
-          if (current) { current.requestIds.push(request.requestId); if (current.source === "interactive") current.source = "mixed"; }
-          else queuedRequests.push(request.requestId);
-          save({ state: "busy", activity: "消息已接收" });
+          execution.claim(request.requestId);
+          execution.consume(request.requestId);
         };
         if (link) {
-          if (!ctx.isIdle() || ctx.hasPendingMessages() || current || interactive || queuedRequests.length) break;
+          if (!ctx.isIdle() || ctx.hasPendingMessages() || execution.current || execution.interactive || execution.pending) break;
           activeTeam = teams.claim(id, generation, request.requestId, accept);
           if (!activeTeam) continue;
         } else accept();
@@ -146,7 +133,7 @@ export default function subagent(pi: ExtensionAPI) {
   };
   pi.registerTool({ ...teamMessageTool(teams, { check: ensure }, () => ({
     kind: "member", agentId: id, generation,
-    ...(activeTeam && current?.source === "parent" ? { requestId: activeTeam.request.requestId } : {}),
+    ...(activeTeam && execution.current?.source === "parent" ? { requestId: activeTeam.request.requestId } : {}),
   })), namespace: { name: "pbot", description: "团队公共通信，不提供管理或递归委派。" } });
   pi.on("resources_discover", async () => {
     if (d.options.noSkills) return {};
@@ -171,22 +158,12 @@ export default function subagent(pi: ExtensionAPI) {
         (previous === null || previous === file), "子会话身份、工作目录或文件不匹配。");
       // Native setup-only sessions have a path but no file. Do not manufacture a conversation to persist it.
       if (previous !== null || existsSync(file)) { readAgentSession(d, file, true); bindSession(); }
+      const receipts: { requestId: string; generation: string }[] = [];
       for (const entry of ctx.sessionManager.getEntries()) if (entry.type === "custom" && entry.customType === "pbot.agent-input") {
-        const receipt = entry.data as { requestId?: string }; if (receipt.requestId) accepted.add(receipt.requestId);
-      }
-      if (saved?.generation === generation && saved.cycle?.state === "running") {
-        const interrupted: AgentCycle = { ...saved.cycle, state: "interrupted", finishedAt: Date.now() };
-        if (!files.completions(id).some(c => c.cycleId === interrupted.cycleId)) files.write(id, "completions/" + interrupted.cycleId + ".json", interrupted, cycle, true);
-      }
-      // A receipt without a cycle is uncertain, not permission to replay after reload.
-      for (const link of teams.links().values()) {
-        const q = link.request;
-        if (q.agentId !== id || q.generation !== generation || !accepted.has(q.requestId) ||
-          files.completions(id).some(c => c.generation === generation && c.requestIds.includes(q.requestId))) continue;
-        const interrupted: AgentCycle = { cycleId: q.requestId, generation, startedAt: files.read(id, "launch.json", launch).startedAt,
-          finishedAt: Date.now(), state: "interrupted", leaf: null, requestIds: [q.requestId], source: "parent", error: "领取后执行结果不明；未重跑。" };
-        files.write(id, "completions/" + interrupted.cycleId + ".json", interrupted, cycle, true);
+        const receipt = entry.data as { requestId?: string; generation?: string };
+        if (typeof receipt.requestId === "string" && typeof receipt.generation === "string") receipts.push({ requestId: receipt.requestId, generation: receipt.generation });
       }
+      execution.recover(receipts);
       const active = pi.getActiveTools();
       for (const tool of agentFileTools(d.cwd, lifetime.signal, async (path, change, cancel) => {
         ensure();
@@ -220,7 +197,7 @@ export default function subagent(pi: ExtensionAPI) {
     });
     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 && !interactive && current?.source !== "mixed") {
+    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);
@@ -230,7 +207,7 @@ export default function subagent(pi: ExtensionAPI) {
     return;
   });
   pi.on("turn_end", (event, context) => {
-    if (!activeTeam || current?.source !== "parent" || event.outcome === "aborted") return;
+    if (!activeTeam || execution.current?.source !== "parent" || event.outcome === "aborted") return;
     const link = teams.links().get(activeTeam.request.requestId);
     if (!link) return;
     const message = teamContext(link, context);
@@ -246,34 +223,28 @@ export default function subagent(pi: ExtensionAPI) {
       return { action: "handled" };
     }
     if (event.source !== "extension") {
-      if (current) current.source = current.source === "parent" ? "mixed" : current.source;
-      else interactive = true;
-      save({ state: "busy", activity: "人工输入" });
+      execution.humanInput();
       pauseTeam("成员由人工接管");
     }
     return;
   });
   pi.on("agent_start", (_event, context) => {
     ctx = context;
-    if (current) { save({ state: "busy", activity: "继续思考" }); return; }
-    startLeaf = ctx.sessionManager.getLeafId();
-    current = { cycleId: randomUUID(), generation, startedAt: Date.now(), state: "running", leaf: null,
-      requestIds: queuedRequests, source: interactive ? queuedRequests.length ? "mixed" : "interactive" : "parent" };
-    queuedRequests = []; interactive = false;
-    save({ state: "busy", activity: "思考" });
+    if (!execution.current) startLeaf = ctx.sessionManager.getLeafId();
+    execution.begin();
   });
   pi.on("tool_call", event => {
     try {
       ensure();
       requireThat(event.toolName !== "pbot_agent" && event.toolName !== "pbot_team", "子会话禁止管理和委派。");
-      if (activeTeam && current?.source === "parent" && Date.now() >= activeTeam.run.deadlineAt) {
+      if (activeTeam && execution.current?.source === "parent" && Date.now() >= activeTeam.run.deadlineAt) {
         ctx?.abort(); throw new Error("团队请求已到期限。");
       }
       save({ state: "busy", activity: event.toolName });
     } catch (error) { return { block: true, reason: String(error) }; }
     return;
   });
-  pi.on("message_update", () => { if (current && Date.now() - lastActivity > 1000) { lastActivity = Date.now(); save({ state: "busy", activity: "回答" }); } });
+  pi.on("message_update", () => { if (execution.current && Date.now() - lastActivity > 1000) { lastActivity = Date.now(); save({ state: "busy", activity: "回答" }); } });
   pi.on("agent_settled", (event, context) => { ctx = context; finish(event.aborted); });
   pi.on("session_before_switch", () => ({ cancel: true }));
   pi.on("session_before_fork", () => ({ cancel: true }));
@@ -285,8 +256,8 @@ export default function subagent(pi: ExtensionAPI) {
     try {
       teams.files.setReady(id, generation, false); ready = false;
       pauseTeam("子会话关闭或重新载入");
-      if (current) finish(true);
-      if (event.reason !== "reload" && snapshot.state !== "error") save({ state: "stopped", activity: "已停止" });
+      if (execution.current) finish(true);
+      if (event.reason !== "reload" && execution.state !== "error") save({ state: "stopped", activity: "已停止" });
     } finally {
       try { await python?.close(); } finally { restorePython?.(); teams.dispose(); ctx = undefined; }
     }

package/src/extension/teams-command.ts

@@ -3,58 +3,65 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { agentOwner } from "../integrations/pi/agent-context.js";
 import type { WorkspaceInstance } from "./lifecycle.js";
 import type { Confirmations } from "../ui/confirmation.js";
+import { readPage } from "../ui/pi/reader.js";
+import { choose } from "../ui/pi/menu.js";
+import { stateLabel } from "../ui/presentation.js";
 import { showAgents } from "./agents-command.js";
 
 export async function showTeams(pi: ExtensionAPI, instance: WorkspaceInstance, ctx: ExtensionCommandContext, confirmations: Confirmations) {
   instance.check();
   const owner = () => agentOwner(ctx), views = () => instance.agents.list(owner()), service = instance.teams;
   service.recover(owner());
-  const values = service.list(owner(), views());
-  if (ctx.mode !== "tui") { ctx.ui.notify(JSON.stringify({ teams: values }), "info"); return; }
-  if (confirmations.presenting) { ctx.ui.notify("请先处理主会话批准。", "info"); return; }
-  if (!values.length) { ctx.ui.notify("没有团队；先用 pbot_agent start 创建成员，再用 pbot_team create 组队。", "info"); return; }
-  const options = values.map(v => v.name + (v.owned ? " · " + (v.closed ? "closed" : v.run?.state ?? "open") + " · 在途 " + v.activeCount : " · 其他分支"));
-  const selected = await ctx.ui.select("pbot 团队", options), value = values[options.indexOf(selected ?? "")];
-  if (!value) return;
-  if (!value.owned) { ctx.ui.notify("请返回所属分支操作。", "info"); return; }
-  const action = await ctx.ui.select(value.name, ["状态", "公共记录", "发布信息", "新批次", "暂停", "关闭", "成员 TUI/报告"]);
-  instance.check();
-  if (action === "状态") { ctx.ui.notify(JSON.stringify(service.status(value.teamId, owner(), views()), null, 2), "info"); return; }
-  if (action === "成员 TUI/报告") { await showAgents(pi, instance, ctx, confirmations, value.members.map(m => m.agentId)); return; }
-  if (action === "暂停") { service.pause(value.teamId, owner()); return; }
-  if (action === "关闭") { service.close(value.teamId, owner(), views()); return; }
-  if (action === "发布信息") {
-    const text = await ctx.ui.editor("公开给全体成员（不会唤醒模型）");
-    instance.check();
-    if (text?.trim()) service.post(value.teamId, { kind: "user", owner: owner() }, randomUUID(), text);
-    return;
-  }
-  if (action === "新批次") {
-    const mode = await ctx.ui.select("协作策略", ["roundRobin", "parallel"]);
-    if (mode !== "roundRobin" && mode !== "parallel") return;
-    const instruction = await ctx.ui.editor("本批次要求；不要把新批次当作未知外部操作的重试");
-    if (!instruction?.trim()) return;
-    const rounds = await ctx.ui.input("轮数 1–10；期限默认 15 分钟", "2");
-    if (rounds === undefined) return;
-    instance.check();
-    service.run(value.teamId, owner(), { instruction, mode, rounds: rounds.trim() ? Number(rounds) : 2 }, views());
-    return;
-  }
-  if (action !== "公共记录") return;
-  let page: { afterSeq?: number; seq?: number; offset?: number } = {};
+  if (ctx.mode !== "tui") { ctx.ui.notify(JSON.stringify({ teams: service.list(owner(), views()) }), "info"); return; }
+  if (confirmations.presenting) { ctx.ui.notify("请先处理待确认操作。", "info"); return; }
   for (;;) {
-    instance.check();
-    const data = service.read(value.teamId, { kind: "user", owner: owner() }, page);
-    await ctx.ui.editor("公共记录（查看不领取模型通知）", data.messages.map(m =>
-      "#" + m.seq + " " + m.author.name + (m.replyTo ? " → #" + m.replyTo : "") + "\n" + m.text +
-      (m.nextOffset === null ? "" : "\n[本条未完，字符 " + m.nextOffset + "/" + m.totalLength + "]")).join("\n\n") || "尚无消息");
-    const last = data.messages.at(-1);
-    if (last?.nextOffset !== null && last?.nextOffset !== undefined) {
-      if (await ctx.ui.select("继续阅读", ["本条后续", "返回"]) !== "本条后续") return;
-      page = { seq: last.seq, offset: last.nextOffset };
-    } else if (last && last.seq < data.lastSeq) {
-      if (await ctx.ui.select("继续阅读", ["后续消息", "返回"]) !== "后续消息") return;
-      page = { afterSeq: last.seq };
-    } else return;
+    instance.check(); const values = service.list(owner(), views());
+    if (!values.length) { ctx.ui.notify("还没有团队。请主助手为已有专家组队。", "info"); return; }
+    const options = values.map(v => v.name + " · " + (v.owned ? stateLabel(v.closed ? "closed" : v.run?.state ?? "open") + " · 在途 " + v.activeCount : "其他分支"));
+    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 = service.status(picked.teamId, owner(), views()); if (!value.owned) break;
+      const action = await choose(ctx, value.name + " · " + stateLabel(value.closed ? "closed" : value.run?.state ?? "open"),
+        ["状态", "公共记录", "成员会话", ...(!value.closed ? ["发布消息", ...(value.run?.state === "running" ? ["暂停"] : ["新批次"]), "关闭团队"] : [])]);
+      if (!action) break;
+      instance.check();
+      try {
+        if (action === "状态") {
+          const run = value.run;
+          await readPage(ctx, value.name, [value.brief, "", ...value.members.map(member => `${member.name} · ${member.role} · ${stateLabel(member.state)}`), "",
+            ...(run ? [`批次  ${stateLabel(run.state)} · ${run.mode === "parallel" ? "并行" : "轮流"} · ${run.rounds} 轮`,
+              `进展  已安排 ${run.scheduled} · 已交付 ${run.published} · 在途 ${value.activeCount}`, ...(run.reason ? [run.reason] : [])] : ["尚无批次"])].join("\n"));
+        } else if (action === "成员会话") await showAgents(pi, instance, ctx, confirmations, value.members.map(m => m.agentId));
+        else if (action === "暂停") { service.pause(value.teamId, owner()); ctx.ui.notify("已暂停新安排。", "info"); }
+        else if (action === "关闭团队") { service.close(value.teamId, owner(), views()); ctx.ui.notify("团队已关闭。", "info"); }
+        else if (action === "发布消息") {
+          const text = await ctx.ui.editor("公共消息"); instance.check();
+          if (text?.trim()) { service.post(value.teamId, { kind: "user", owner: owner() }, randomUUID(), text); ctx.ui.notify("消息已发布。", "info"); }
+        } else if (action === "新批次") {
+          const strategy = await ctx.ui.select("讨论模式", ["轮流讨论", "并行轮次"]); if (!strategy) continue;
+          const instruction = await ctx.ui.editor("任务与交付要求"); if (!instruction?.trim()) continue;
+          const rounds = await ctx.ui.input("轮数（1–10，默认 2）"); if (rounds === undefined) continue;
+          instance.check(); service.run(value.teamId, owner(), { instruction, mode: strategy === "并行轮次" ? "parallel" : "roundRobin", rounds: rounds.trim() ? Number(rounds) : 2 }, views());
+          ctx.ui.notify("新批次已开始。", "info");
+        } else if (action === "公共记录") await messages(value.teamId);
+      } catch (error) { ctx.ui.notify(error instanceof Error ? error.message : String(error), "error"); }
+    }
+  }
+  async function messages(teamId: string) {
+    let page: { afterSeq?: number; seq?: number; offset?: number } = {};
+    for (;;) {
+      instance.check(); const data = service.read(teamId, { kind: "user", owner: owner() }, page);
+      await readPage(ctx, "公共记录", data.messages.map(message => `#${message.seq} ${message.author.name}${message.replyTo ? ` → #${message.replyTo}` : ""}\n${message.text}` +
+        (message.nextOffset === null ? "" : `\n[未完 · ${message.nextOffset}/${message.totalLength}]`)).join("\n\n") || "尚无消息。");
+      const last = data.messages.at(-1);
+      if (last?.nextOffset !== null && last?.nextOffset !== undefined) {
+        if (await ctx.ui.select("公共记录", ["继续本条", "返回"]) !== "继续本条") return;
+        page = { seq: last.seq, offset: last.nextOffset };
+      } else if (last && last.seq < data.lastSeq) {
+        if (await ctx.ui.select("公共记录", ["后续消息", "返回"]) !== "后续消息") return;
+        page = { afterSeq: last.seq };
+      } else return;
+    }
   }
 }

package/src/integrations/{pi/agent-resources.ts → agent-resources.ts}

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { resourceRoot } from "../../common/paths.js";
-import { requireThat } from "../../common/validation.js";
+import { resourceRoot } from "../common/paths.js";
+import { requireThat } from "../common/validation.js";
 
 export async function agentText(agent: "coordinator" | "general-purpose", root: string) {
   requireThat(agent === "coordinator" || agent === "general-purpose", "未知职责。");

package/src/integrations/dsh/dsh-agents.ts

@@ -0,0 +1,97 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent, AgentHandle, AgentSetup } from "@deepseek-ai/dsh-agent";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import type { AgentDescriptor, AgentSessionReference } from "../../model/agent.js";
+import type { AgentHost } from "../../services/agents/agent-service.js";
+import { requireThat } from "../../common/validation.js";
+import { openDshAgent, readDshAgentSession, readDshReport } from "./session.js";
+
+type NativeRun = {
+  generation: string;
+  controller: AbortController;
+  opening: Promise<AgentHandle>;
+  handle?: AgentHandle;
+  closing?: Promise<void>;
+};
+
+/** Native handles belong to the execution component, independently of browser observers. */
+export class DshAgents implements AgentHost {
+  readonly kind = "dsh";
+  readonly #runs = new Map<string, NativeRun>();
+  #closed = false;
+  constructor(readonly ctx: Context, readonly parent: Agent,
+    readonly composition: {
+      setup(d: AgentDescriptor, directory: string, generation: string): AgentSetup;
+      ready(agent: Agent, generation: string): void;
+      stopping(agent: Agent, generation: string): Promise<void>;
+    }, readonly lifetime: AbortSignal) {}
+  available() {
+    this.lifetime.throwIfAborted();
+    requireThat(!this.#closed && this.ctx.agents.get(this.parent.id) === this.parent, "dsh 父会话或执行组件已关闭。");
+  }
+  alive(id: string) {
+    const run = this.#runs.get(id);
+    return Boolean(this.ctx.agents.get(SessionId(id))) || Boolean(run && (run.closing || !run.handle));
+  }
+  private reference(d: AgentDescriptor, reference: AgentSessionReference) {
+    requireThat(reference.host === "dsh" && reference.sessionId === d.agentId, "不能接管其他宿主或其他身份的原生会话。");
+  }
+  async validateSession(d: AgentDescriptor, reference: AgentSessionReference) {
+    this.available(); this.reference(d, reference);
+    requireThat(!this.alive(d.agentId), "原生专家仍被占用，不能恢复。");
+    await readDshAgentSession(this.ctx, d);
+    requireThat(!this.alive(d.agentId), "原生专家仍被占用，不能恢复。");
+  }
+  async launch(d: AgentDescriptor, directory: string, generation: string, reference: AgentSessionReference, resume: boolean, signal: AbortSignal) {
+    this.available(); this.reference(d, reference);
+    requireThat(!this.alive(d.agentId), "dsh 专家仍在运行或释放中。");
+    const previous = this.#runs.get(d.agentId);
+    if (previous) await this.release(d.agentId, previous.generation);
+    signal.throwIfAborted(); this.available();
+    const controller = new AbortController();
+    const combined = AbortSignal.any([signal, this.lifetime, controller.signal]);
+    const opening = Promise.resolve().then(() => openDshAgent(this.ctx, d, this.parent, resume,
+      this.composition.setup(d, directory, generation), combined));
+    const run: NativeRun = { generation, controller, opening };
+    this.#runs.set(d.agentId, run);
+    try {
+      run.handle = await opening;
+      if (combined.aborted) {
+        await this.release(d.agentId, generation);
+        combined.throwIfAborted();
+      }
+      this.composition.ready(run.handle.agent, generation);
+    } catch (error) {
+      if (!run.handle && this.#runs.get(d.agentId) === run) this.#runs.delete(d.agentId);
+      throw error;
+    }
+  }
+  release(id: string, generation: string) {
+    const run = this.#runs.get(id);
+    if (!run) return this.ctx.agents.get(SessionId(id)) ? Promise.reject(new Error("原生专家仍由其他执行实例持有；当前组件不能释放。")) : Promise.resolve();
+    if (run.generation !== generation) return Promise.resolve();
+    if (run.closing) return run.closing;
+    run.controller.abort();
+    run.closing = (async () => {
+      const handle = run.handle ?? await run.opening.catch(() => undefined);
+      let failure: unknown;
+      if (handle) {
+        try { await this.composition.stopping(handle.agent, generation); } catch (error) { failure = error; }
+        await handle.dispose();
+      }
+      if (this.#runs.get(id) === run) this.#runs.delete(id);
+      if (failure) throw failure;
+    })();
+    return run.closing;
+  }
+  report(d: AgentDescriptor, reference: AgentSessionReference, position: string) {
+    this.reference(d, reference);
+    return readDshReport(this.ctx, d, position);
+  }
+  async close() {
+    this.#closed = true;
+    const results = await Promise.allSettled([...this.#runs].map(([id, run]) => this.release(id, run.generation)));
+    const errors = results.flatMap(r => r.status === "rejected" ? [r.reason] : []);
+    if (errors.length) throw new AggregateError(errors, "dsh 专家仍有未释放的执行资源。");
+  }
+}

package/src/integrations/dsh/history-summary.ts

@@ -0,0 +1,43 @@
+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 type { SessionId } from "@deepseek-ai/dsh-session";
+import { BlockAssembler, type PreparedLlmCall } from "@deepseek-ai/dsh-llm";
+import type { HistorySummarizer } from "../../model/history.js";
+import { resourceRoot } from "../../common/paths.js";
+import { requireThat } from "../../common/validation.js";
+import { reduceHistorySummary } from "../history-summary.js";
+
+declare module "@deepseek-ai/dsh-llm" {
+  interface LlmRequestPurposeMap { "pbot-history": true }
+}
+
+/** Independent text calls through the host's routing and authentication; no Agent or Session messages. */
+export function dshHistorySummarizer(ctx: Context, selection: ReturnType<Agent["model"]["current"]>, sessionId: SessionId): HistorySummarizer {
+  return async (text, signal) => {
+    requireThat(selection, "请先选择 dsh 模型。"); signal.throwIfAborted();
+    const system = await readFile(join(resourceRoot, "prompts/history-summary.md"), { encoding: "utf8", signal });
+    const prepare = () => ctx.llm.prepareCall({ provider: selection.provider, model: selection.model, maxTokens: 2048 }, signal,
+      (controls, model) => ({ ...controls, ...(model.reasoning?.efforts[0] ? { reasoningEffort: model.reasoning.efforts[0].id } : {}) }));
+    let first: PreparedLlmCall | undefined = await prepare();
+    const budget = Math.max(2000, Math.min(24000, Math.floor((first.context?.contextWindow ?? 12000) / 2)));
+    const ask: HistorySummarizer = async (content, signal) => {
+      signal.throwIfAborted();
+      const prepared = first ?? await prepare(); first = undefined;
+      const assembler = new BlockAssembler(); let finished = false;
+      for await (const chunk of prepared.stream({ ...prepared.config, system, sessionId, purpose: "pbot-history", signal, tools: [],
+        messages: [{ role: "user", content: [{ type: "text", text: content }] }] })) {
+        signal.throwIfAborted(); assembler.push(chunk); if (chunk.type === "finish") finished = true;
+      }
+      signal.throwIfAborted();
+      const reason = assembler.finish;
+      requireThat(finished && reason.kind === "stop", reason.kind === "error" || reason.kind === "aborted" ? reason.failure.message : "历史摘要未正常结束：" + reason.kind);
+      const blocks = assembler.blocks();
+      requireThat(!blocks.some(block => block.type === "tool-call"), "历史摘要不能执行工具。");
+      const answer = blocks.filter(block => block.type === "text").map(block => block.text).join("\n").trim();
+      requireThat(answer, "历史摘要为空。"); return answer;
+    };
+    return reduceHistorySummary(budget, ask)(text, signal);
+  };
+}