personal-bot 0.2.3 → 0.2.5

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); }
 }

package/src/extension/command.ts

@@ -2,6 +2,10 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { packageVersion } from "../common/version.js";
 import { prepareWorkspace } from "../services/workspace/workspace-preparation.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 { agentOwner } from "../integrations/pi/agent-context.js";
 import type { Lifecycle } from "./lifecycle.js";
 import { showAgents } from "./agents-command.js";
 import { showTeams } from "./teams-command.js";
@@ -9,39 +13,54 @@ import { showHistory } from "./history.js";
 
 export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirmations: Confirmations) {
   pi.registerCommand("pbot", {
-    description: "工作区：init、status、history、agents、teams、python setup",
+    description: "工作区、专家、团队与历史",
     getArgumentCompletions: prefix => {
       if (/\s/.test(prefix)) return null;
       return ["init", "status", "history", "agents", "teams", "python"]
-        .filter(command => command.startsWith(prefix))
-        .map(command => ({ value: command, label: command }));
+        .filter(command => command.startsWith(prefix)).map(command => ({ value: command, label: command }));
     },
     handler: async (args, ctx) => {
       const [, command, argument = ""] = args.trim().match(/^(\S+)(?:\s+([\s\S]*))?$/) ?? [];
       confirmations.resume();
-      if (command === "init" && !argument) {
-        await ctx.waitForIdle();
+      async function execute(command: string | undefined, argument: string) {
         const instance = lifecycle.get();
-        await prepareWorkspace(instance.root);
-        ctx.ui.notify("资料目录已准备；已有 AGENTS.md 保持不变。", "info");
-        return;
+        if (command === "init" && !argument) {
+          await ctx.waitForIdle(); instance.check(); await prepareWorkspace(instance.root);
+          ctx.ui.notify("资料目录已准备。", "info"); return;
+        }
+        if (command === "status" && !argument) {
+          const python = instance.pythonEnvironment.status;
+          if (ctx.mode !== "tui") { ctx.ui.notify(JSON.stringify({ workspaceRoot: instance.root, release: packageVersion, python }, null, 2), "info"); return; }
+          const agents = instance.agents.list(agentOwner(ctx)), history = instance.history.status;
+          await readPage(ctx, "工作区", [instance.root, "", `版本    ${packageVersion}`,
+            `模型    ${ctx.model && !(ctx.model.provider === "unknown" && ctx.model.id === "unknown") ? ctx.model.provider + "/" + ctx.model.id : "未选择"}`,
+            `专家    ${agents.length} 位 · ${agents.filter(value => value.alive).length} 位存活`,
+            `Python  ${stateLabel(python.state)}`, ...(python.directory ? [python.directory] : []), ...(python.error ? ["", python.error] : []),
+            "", `历史    ${history.organizing ? "整理中" : history.pending === null ? "查询时更新索引" : history.pending + " 项待整理"}`,
+            ...history.warnings].join("\n")); return;
+        }
+        if (command === "history") { await showHistory(instance, ctx, argument); return; }
+        if (command === "agents") { await showAgents(pi, instance, ctx, confirmations); return; }
+        if (command === "teams") { await showTeams(pi, instance, ctx, confirmations); return; }
+        if (command === "python" && argument === "setup") {
+          const cancel = instance.signal(ctx.signal); await ctx.waitForIdle();
+          ctx.ui.notify("正在准备 Python…", "info");
+          const result = await instance.preparePython(cancel);
+          ctx.ui.notify(ctx.mode === "tui" ? "Python 已就绪。" : JSON.stringify(result, null, 2), "info"); return;
+        }
+        ctx.ui.notify("/pbot init | status | history [关键词] | agents | teams | python setup", "info");
       }
-      if (command === "status" && !argument) {
-        const instance = lifecycle.get();
-        ctx.ui.notify(JSON.stringify({ workspaceRoot: instance.root, release: packageVersion, python: instance.pythonEnvironment.status }, null, 2), "info"); return;
-      }
-      if (command === "history") { await showHistory(lifecycle.get(), ctx, argument); return; }
-      if (command === "agents") { await showAgents(pi, lifecycle.get(), ctx, confirmations); return; }
-      if (command === "teams") { await showTeams(pi, lifecycle.get(), ctx, confirmations); return; }
-      if (command === "python" && argument === "setup") {
-        const instance = lifecycle.get(), cancel = instance.signal(ctx.signal);
-        await ctx.waitForIdle();
-        ctx.ui.notify("正在准备共享 Python 环境；安装可能需要数分钟。", "info");
-        const result = await instance.preparePython(cancel);
-        ctx.ui.notify(JSON.stringify(result, null, 2), "info");
-        return;
+      if (command || ctx.mode !== "tui") { await execute(command, argument); return; }
+      if (confirmations.presenting) { ctx.ui.notify("请先处理待确认操作。", "info"); return; }
+      for (;;) {
+        const instance = lifecycle.get(), agents = instance.agents.list(agentOwner(ctx));
+        const choices = ["专家 · " + agents.length, "团队", "历史", "工作区状态", "准备资料目录", "准备 Python"];
+        const choice = await choose(ctx, `Personal Bot · Python ${stateLabel(instance.pythonEnvironment.status.state)}`, choices);
+        if (!choice) return;
+        const command = ["agents", "teams", "history", "status", "init", "python"][choices.indexOf(choice)]!;
+        try { await execute(command, command === "python" ? "setup" : ""); }
+        catch (error) { ctx.ui.notify(error instanceof Error ? error.message : String(error), "error"); }
       }
-      ctx.ui.notify("用法：/pbot init | status | history [关键词] | agents | teams | python setup", "info");
     },
   });
 }

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

@@ -0,0 +1,148 @@
+import { randomUUID } from "node:crypto";
+import type { Context } from "@deepseek-ai/cordis";
+import { createUserMessage, type UserMessage } from "@deepseek-ai/dsh-llm";
+import { agentNotice, teamNotice } from "../../services/agents/agent-notices.js";
+import { deliveredDshNotices, pendingDshNotices } from "../../integrations/dsh/notifications.js";
+import { flushDshAgent } from "../../integrations/dsh/session.js";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { AgentService } from "../../services/agents/agent-service.js";
+import type { TeamService } from "../../services/agents/team-service.js";
+import type { AgentOwner, AgentCompletion } from "../../model/agent.js";
+import type { TeamInput } from "../../model/team.js";
+
+/** Server-owned scheduling survives browser disconnects; native cancellation pauses dispatch. */
+export class DshAgentEvents {
+  readonly #dispatching = new Map<string, TeamInput>();
+  readonly #signals = new Map<AbortSignal, () => void>();
+  #timer: ReturnType<typeof setInterval> | undefined;
+  #scan: Promise<void> | undefined;
+  #closed = false;
+  #pausePending = false;
+  #paused = false;
+  #error: string | undefined;
+  #errorKey: string | undefined;
+  #busySince: number | undefined;
+  #recovery: "retry" | "repair" | "reload" | undefined;
+  #completed: AgentCompletion[] = [];
+  #autoWake = false;
+  constructor(readonly ctx: Context, readonly agent: Agent, readonly agents: AgentService,
+    readonly teams: TeamService, readonly owner: AgentOwner, readonly check: () => void) {}
+  get error() { return this.#error; }
+  start() {
+    this.teams.recover(this.owner);
+    this.ctx.on("agent/pre-step", async ({ signal }, next) => {
+      if (!this.#signals.has(signal)) {
+        const cancel = () => { if (!this.#closed) {
+          this.#paused = true; this.#autoWake = false; this.#pausePending = true;
+          try { this.pauseTeams(); } catch (error) { this.recordError(error); }
+          void this.refresh();
+        } };
+        this.#signals.set(signal, cancel); signal.addEventListener("abort", cancel, { once: true });
+        if (signal.aborted) cancel();
+      }
+      await this.refresh(); this.check();
+      const decision = await next(); this.check();
+      if (decision.kind !== "enter" || this.#paused) return decision;
+      const note = this.notice(decision.messages);
+      return note ? { ...decision, messages: [...decision.messages, note] } : decision;
+    });
+    this.ctx.on("session/event", (session, event) => {
+      if (session !== this.agent.session || this.#closed) return;
+      if (event.type === "agent/inbox/spliced" && event.data.inserted.some(message => message.source.kind === "user")) { this.#paused = false; this.#autoWake = true; }
+      if (event.type === "user/message" && event.data.source.kind === "pbot-results") this.#autoWake = true;
+      if (event.type === "turn/end") {
+        for (const [signal, cancel] of this.#signals) signal.removeEventListener("abort", cancel); this.#signals.clear();
+        if (event.data.reason.kind === "aborted") {
+          this.#paused = true; this.#autoWake = false; this.#pausePending = true;
+          try { this.pauseTeams(); } catch (error) { this.recordError(error); }
+        }
+        void this.refresh();
+      }
+    });
+    this.#timer = setInterval(() => { void this.refresh(); }, 1000); this.#timer.unref();
+    this.ctx.effect(() => () => this.close());
+  }
+  private pauseTeams() {
+    if (!this.#pausePending) return;
+    try { this.teams.pauseAll(this.owner, "主会话中断"); this.#pausePending = false; this.#dispatching.clear(); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "PBOT_CONTROL_BUSY") { this.teams.fail(error); this.#dispatching.clear(); }
+      throw error;
+    }
+  }
+  private recordError(error: unknown) {
+    if (this.#closed || (error as Error).name === "AbortError") return;
+    if ((error as NodeJS.ErrnoException).code === "PBOT_CONTROL_BUSY") {
+      this.#busySince ??= Date.now(); if (Date.now() - this.#busySince < 5000) return;
+    } else this.#busySince = undefined;
+    const message = String(error);
+    let recovery: "retry" | "repair" | "reload" = (error as NodeJS.ErrnoException).code === "PBOT_CONTROL_BUSY" ? "retry" : "repair";
+    try { this.teams.check(); } catch { recovery = "reload"; }
+    if (message !== this.#error || recovery !== this.#recovery) {
+      this.ctx.logger.warn("pbot 协作扫描失败：" + message);
+      this.#errorKey = "agent-error:" + randomUUID();
+    }
+    this.#error = message; this.#recovery = recovery;
+  }
+  private notice(proposed: readonly UserMessage[] = []) {
+    const known = new Set([...deliveredDshNotices(this.agent.session.snapshotEvents()),
+      ...pendingDshNotices([...this.agent.inbox.nextTurn, ...this.agent.inbox.nextStep, ...proposed])]);
+    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先核对控制记录和原生报告；结果未知不是重跑许可。" +
+        (this.#recovery === "reload" ? "团队服务已停用；修复文件后还需重载服务端 personal-bot 插件。" :
+          this.#recovery === "retry" ? "控制锁持续占用，后台会继续重试；不会自动删除锁或重新提交任务。" : "报告或控制记录读取失败，修复后后台会重试扫描。") +
+        (this.#pausePending ? "\n\n团队暂停尚未确认，不能据此开始成员私人任务。" : "") };
+    } else {
+      value = teamNotice(this.teams.notifications(this.owner, this.agents.list(this.owner)), known) ??
+        agentNotice(this.#completed, this.teams.links(), known);
+    }
+    return value ? createUserMessage({ content: [{ type: "text", text: value.content }],
+      source: { kind: "pbot-results", form: "notice", summary: "Personal Bot 协作更新", keys: value.keys } }) : undefined;
+  }
+  refresh() {
+    if (this.#closed || this.#scan) return this.#scan ?? Promise.resolve();
+    this.#scan = (async () => {
+      try { await this.scan(); } catch (error) { this.recordError(error); }
+      if (this.#closed || this.#paused || !this.#autoWake || this.agent.status !== "idle") return;
+      try {
+        this.check(); const note = this.notice();
+        if (note) {
+          // A failed admission cannot start an automatic retry loop. Actual receipt or new human input re-arms wakeup.
+          this.#autoWake = false; this.agent.followup(note); await flushDshAgent(this.agent);
+        }
+      } catch (error) { this.recordError(error); }
+    })().finally(() => { this.#scan = undefined; });
+    return this.#scan;
+  }
+  private async scan() {
+    this.check(); this.pauseTeams(); await this.agents.refresh(this.owner);
+    if (this.#closed) return; this.check();
+    const completed = await this.agents.completions(this.owner);
+    if (this.#closed) return; this.check(); this.#completed = completed;
+    try {
+      this.pauseTeams();
+      for (const input of this.teams.advance(this.owner, this.agents.list(this.owner), completed)) this.#dispatching.set(input.requestId, input);
+      for (const [id, input] of this.#dispatching) {
+        try { this.agents.enqueueTeam(input, this.owner); this.#dispatching.delete(id); }
+        catch (error) {
+          const code = (error as NodeJS.ErrnoException).code;
+          if (code === "PBOT_CONTROL_BUSY") throw error;
+          if (code !== "TEAM_INPUT_STALE") throw error;
+          this.teams.pauseMember(input.agentId, "安排失效；未自动重发"); this.#dispatching.delete(id);
+        }
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "PBOT_CONTROL_BUSY") { this.teams.fail(error); this.#dispatching.clear(); }
+      throw error;
+    }
+    this.#error = undefined; this.#errorKey = undefined; this.#busySince = undefined; this.#recovery = undefined;
+  }
+  async close() {
+    this.#closed = true;
+    if (this.#timer) clearInterval(this.#timer); this.#timer = undefined;
+    for (const [signal, cancel] of this.#signals) signal.removeEventListener("abort", cancel); this.#signals.clear();
+    await this.#scan; this.#dispatching.clear();
+  }
+}

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

@@ -0,0 +1,251 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent, InboxTarget } from "@deepseek-ai/dsh-agent";
+import { foldConsumedWork } from "@deepseek-ai/dsh-agent";
+import { createUserMessage, type UserMessage, type FileBlock, type ImageBlock } from "@deepseek-ai/dsh-llm";
+import type { SessionEvent } from "@deepseek-ai/dsh-session";
+import { AgentRun } from "../../services/agents/agent-run.js";
+import type { TeamService } from "../../services/agents/team-service.js";
+import { AgentFiles, launch } from "../../storage/agent-files.js";
+import type { AgentDescriptor } from "../../model/agent.js";
+import type { TeamLink } from "../../model/team.js";
+import { requireThat } from "../../common/validation.js";
+import { dshInput, dshHumanInput } from "../../integrations/dsh/input.js";
+import { requestSource, finalDshAnswer } from "../../integrations/dsh/messages.js";
+import { flushDshAgent } from "../../integrations/dsh/session.js";
+import { createTeamContext, teamBrief } from "../../integrations/team-context.js";
+
+/** One expert's native event adapter. AgentRun and TeamService own durable business state. */
+export class DshAgentRuntime {
+  readonly execution: AgentRun;
+  readonly #lifetime = new AbortController();
+  readonly #inbox: Record<InboxTarget, UserMessage[]> = { "next-turn": [], "next-step": [] };
+  readonly #seen = new Map<string, Set<number>>();
+  #events = Promise.resolve();
+  #turnEvents: SessionEvent[] = [];
+  #answer = "";
+  #hasAnswer = false;
+  #activeTeam: TeamLink | undefined;
+  #pendingPause: string | undefined;
+  #pump: Promise<void> | undefined;
+  #timer: ReturnType<typeof setInterval> | undefined;
+  #stopping: Promise<void> | undefined;
+  #closing = false;
+  #failure: unknown;
+  #ready = false;
+  #teamTool = false;
+  constructor(readonly ctx: Context, readonly agent: Agent, readonly d: AgentDescriptor, readonly generation: string,
+    readonly files: AgentFiles, readonly teams: TeamService, readonly owner: { check(): void; release(): Promise<void> }) {
+    this.execution = new AgentRun(files, d.agentId, generation);
+  }
+  check = () => {
+    this.#lifetime.signal.throwIfAborted(); this.owner.check(); this.files.check();
+    const run = this.files.read(this.d.agentId, "launch.json", launch);
+    requireThat(run.generation === this.generation && !run.stop, "专家已停止或启动代次变化。");
+  };
+  actor = () => ({ kind: "member" as const, agentId: this.d.agentId, generation: this.generation,
+    ...(this.#activeTeam && this.execution.current?.source === "parent" ? { requestId: this.#activeTeam.request.requestId } : {}) });
+  private current() { return this.files.read(this.d.agentId, "launch.json", launch).generation === this.generation; }
+  private pause(reason: string) {
+    this.#pendingPause = reason;
+    try { this.teams.pauseMember(this.d.agentId, reason); this.#pendingPause = undefined; }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== "PBOT_CONTROL_BUSY") throw error; }
+  }
+  private enqueue(work: () => void | Promise<void>) {
+    this.#events = this.#events.then(work).catch(error => this.fail(error));
+  }
+  private fail(error: unknown) {
+    if (this.#failure) return;
+    this.#failure = error; this.#lifetime.abort();
+    try {
+      if (this.current()) {
+        this.teams.files.setReady(this.d.agentId, this.generation, false);
+        this.execution.save({ state: "error", activity: "控制失败", error: String(error) });
+        this.pause("专家控制失败");
+      }
+    } catch (failure) { this.ctx.logger.error("pbot 专家状态保存失败", failure); }
+    void this.owner.release().catch(failure => this.ctx.logger.error("pbot 专家释放失败", failure));
+  }
+  initialize(teamTool: boolean) {
+    this.check(); this.#teamTool = teamTool;
+    this.teams.files.setReady(this.d.agentId, this.generation, false);
+    this.pause("专家载入：旧批次不自动恢复");
+    this.execution.recover();
+    for (const event of this.agent.session.snapshotEvents()) if (event.type === "user/message" && event.data.source.kind === "pbot-team-context") {
+      const { teamId, seqs } = event.data.source, seen = this.#seen.get(teamId) ?? new Set<number>();
+      for (const seq of seqs) seen.add(seq); this.#seen.set(teamId, seen);
+    }
+    this.ctx.on("session/event", (session, event) => {
+      if (session === this.agent.session) this.enqueue(() => this.event(event));
+    });
+    this.ctx.on("agent/status", ({ agent, status }) => {
+      if (agent !== this.agent) return;
+      this.enqueue(() => {
+        if (!this.current() || this.#closing || this.#failure) return;
+        this.execution.save({ state: status === "idle" ? "idle" : "busy", activity: status === "idle" ? "空闲" : "执行" });
+      });
+    });
+    this.ctx.on("agent/pre-step", async (_payload, next) => {
+      await this.#events; this.check();
+      if (this.#activeTeam && !this.humanPending() && this.execution.current?.source === "parent" && Date.now() >= this.#activeTeam.run.deadlineAt) {
+        this.pause("已到期限"); this.agent.cancel({ kind: "hook", reason: "团队请求已到期限" });
+        return { kind: "reject" };
+      }
+      const decision = await next();
+      this.check();
+      if (decision.kind !== "enter" || !this.#activeTeam || this.execution.current?.source !== "parent" || this.humanPending() ||
+        decision.messages.some(message => message.source.kind === "user")) return decision;
+      const link = this.teams.links().get(this.#activeTeam.request.requestId);
+      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 } })] };
+    });
+    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());
+  }
+  /** Called only after native Agent creation has resolved, never from setup. */
+  start() {
+    this.check();
+    this.#timer = setInterval(() => { void this.pump(); }, 250); this.#timer.unref();
+    void this.pump();
+  }
+  async interact(text: string, delivery: "steer" | "followUp" = "steer", files: readonly string[] = [],
+    attachments: readonly (ImageBlock | FileBlock)[] = [], caller?: AbortSignal) {
+    this.check(); requireThat((text.trim().length > 0 || files.length || attachments.length) && text.length <= 24000, "请输入消息或附加文件；消息最多 24000 字符。");
+    const signal = caller ? AbortSignal.any([caller, this.#lifetime.signal]) : this.#lifetime.signal;
+    const message = await dshHumanInput(this.ctx, this.d.cwd, text, files, attachments, signal);
+    this.check(); signal.throwIfAborted();
+    this.teams.pauseMember(this.d.agentId, "成员由人工接管");
+    if (delivery === "followUp") this.agent.followup(message); else this.agent.steer(message);
+    // Native inbox admission transfers ownership to the expert, independently of the UI request.
+    await flushDshAgent(this.agent);
+    return { status: "queued" as const, messageId: message.id };
+  }
+  private async event(event: SessionEvent) {
+    if (!this.current()) return;
+    if (event.type === "turn/start") {
+      this.#turnEvents = []; this.#answer = ""; this.#hasAnswer = false;
+      this.execution.begin();
+    }
+    if (this.execution.current) this.#turnEvents.push(event);
+    if (event.type === "agent/inbox/spliced") {
+      const change = event.data;
+      const removed = this.#inbox[change.target].splice(change.start, change.removedCount ?? 0, ...change.inserted);
+      if (change.inserted.some(message => message.source.kind === "user")) this.pause("成员由人工接管");
+      for (const message of removed) {
+        if (message.source.kind === "user" && change.outcome !== "canceled") this.execution.enterHuman();
+        const source = requestSource(message, this.generation);
+        if (!source) continue;
+        if (change.outcome === "canceled") {
+          this.execution.cancelQueued(source.requestId);
+          if (this.#activeTeam?.request.requestId === source.requestId && !this.execution.current?.requestIds.includes(source.requestId)) this.#activeTeam = undefined;
+        } else this.execution.enter(source.requestId);
+      }
+    }
+    if (event.type === "user/message") {
+      const source = requestSource(event.data, this.generation);
+      if (source) this.execution.consume(source.requestId);
+      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>();
+        for (const seq of seqs) seen.add(seq); this.#seen.set(teamId, seen);
+      }
+    }
+    if (event.type === "assistant/message") {
+      this.#answer = finalDshAnswer(event); this.#hasAnswer = true;
+    }
+    if (event.type === "turn/end") {
+      const accounted = foldConsumedWork(this.#turnEvents).end?.seq === event.seq;
+      await flushDshAgent(this.agent);
+      const reason = event.data.reason;
+      this.execution.finish({
+        state: reason.kind === "aborted" ? "cancelled" : reason.kind === "interrupted" || reason.kind === "forked" ? "interrupted"
+          : reason.kind === "completed" && accounted ? "completed" : "failed",
+        position: this.#hasAnswer ? "dsh:" + event.seq : null,
+        answer: this.#answer,
+        ...(reason.kind === "error" ? { error: reason.error.message } : !["completed", "aborted"].includes(reason.kind) ? { error: reason.kind } : {}),
+      });
+      this.#activeTeam = undefined; this.#turnEvents = [];
+    }
+  }
+  private humanPending() { return [...this.agent.inbox.nextTurn, ...this.agent.inbox.nextStep].some(message => message.source.kind === "user"); }
+  private pump() {
+    if (this.#pump || this.#closing) return this.#pump ?? Promise.resolve();
+    this.#pump = this.deliver().catch(error => {
+      if ((error as NodeJS.ErrnoException).code === "PBOT_CONTROL_BUSY" || (this.#closing && this.#lifetime.signal.aborted)) return;
+      this.fail(error);
+    }).finally(() => { this.#pump = undefined; });
+    return this.#pump;
+  }
+  private async deliver() {
+    const run = this.files.read(this.d.agentId, "launch.json", launch);
+    if (run.generation !== this.generation || run.stop) { void this.owner.release().catch(error => this.fail(error)); return; }
+    await this.#events; this.check();
+    if (this.#pendingPause) { this.pause(this.#pendingPause); if (this.#pendingPause) return; }
+    const capable = this.#teamTool && !!this.ctx.tools.get("pbot_team_message", this.agent);
+    if (capable !== this.#ready) {
+      this.teams.files.setReady(this.d.agentId, this.generation, capable); this.#ready = capable;
+      if (!capable) this.pause("成员团队工具已停用");
+    }
+    if (this.#activeTeam) {
+      if (Date.now() >= this.#activeTeam.run.deadlineAt) {
+        this.pause("已到期限");
+        if (!this.humanPending() && !this.execution.interactive && this.execution.current?.source !== "mixed" && this.execution.current?.source !== "interactive") this.agent.cancel({ kind: "hook", reason: "团队请求已到期限" });
+      }
+      return;
+    }
+    const links = this.teams.links();
+    const idle = () => this.agent.status === "idle" && !this.agent.inbox.nextTurn.length && !this.agent.inbox.nextStep.length && !this.execution.current && !this.execution.pending && !this.execution.interactive;
+    for (const request of this.files.messages(this.d.agentId)) {
+      if (request.generation !== this.generation || this.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 && !idle()) break;
+      const message = await dshInput(this.ctx, this.d, request, this.#lifetime.signal);
+      this.check();
+      const submit = async () => {
+        this.check();
+        const accept = () => this.execution.claim(request.requestId);
+        if (link) {
+          if (!idle()) return;
+          this.#activeTeam = this.teams.claim(this.d.agentId, this.generation, request.requestId, accept);
+          if (!this.#activeTeam) return;
+        } else accept();
+        if (request.delivery === "followUp") this.agent.followup(message); else this.agent.steer(message);
+        await flushDshAgent(this.agent);
+      };
+      if (link) {
+        // Public status stays idle during native maintenance. Its idle admission is authoritative.
+        let entered = false;
+        try { await this.agent.runMaintenance(async signal => { entered = true; signal.throwIfAborted(); await submit(); }); }
+        catch (error) { if (entered) throw error; this.check(); }
+      } else await submit();
+      break;
+    }
+  }
+  stop() {
+    if (this.#stopping) return this.#stopping;
+    this.#closing = true; this.#lifetime.abort();
+    if (this.#timer) clearInterval(this.#timer); this.#timer = undefined;
+    this.#stopping = (async () => {
+      try {
+        if (this.current()) {
+          this.files.control(() => {
+            const run = this.files.read(this.d.agentId, "launch.json", launch);
+            if (run.generation === this.generation && !run.stop) { run.stop = true; this.files.write(this.d.agentId, "launch.json", run, launch); }
+          });
+          this.teams.files.setReady(this.d.agentId, this.generation, false); this.#ready = false;
+          this.pause("专家停止");
+          if (!this.#failure) this.execution.save({ state: "stopping", activity: "停止" });
+        }
+      } finally { this.agent.cancel({ kind: "disposed" }); }
+      await this.agent.whenIdle(); await this.#pump; await this.#events;
+      if (this.current() && !this.#failure) this.execution.save({ state: "stopped", activity: "已停止" });
+    })();
+    return this.#stopping;
+  }
+}