personal-bot 0.2.4 → 0.2.5

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

package/src/extension/dsh/command.ts

@@ -0,0 +1,78 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type {} from "@deepseek-ai/dsh-commands";
+import { Type, type Static } from "typebox";
+import { object, json } from "../../common/json.js";
+import { requireThat, schema } from "../../common/validation.js";
+import { prepareWorkspace } from "../../services/workspace/workspace-preparation.js";
+import { executeAgent, type AgentInput } from "../../tools/agents/actions.js";
+import { dshAgentActionSchema } from "../../tools/agents/dsh-contract.js";
+import { executeTeam, executeTeamMessage } from "../../tools/teams/actions.js";
+import { teamActionSchema, teamParametersSchema, teamMessageActionSchema, teamMessageParametersSchema } from "../../tools/teams/contract.js";
+import { dshStatus, type PbotManagement } from "./management.js";
+import type { DshWorkspaces } from "./workspace.js";
+
+const validAgent = schema(dshAgentActionSchema), validTeam = schema(teamActionSchema), validMessage = schema(teamMessageActionSchema);
+const chatSchema = Type.Object({ agentId: Type.String({ minLength: 1 }), text: Type.Optional(Type.String({ maxLength: 24000 })),
+  delivery: Type.Optional(Type.Union([Type.Literal("steer"), Type.Literal("followUp")])),
+  files: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { maxItems: 32 })) }, { additionalProperties: false });
+const validChat = schema(chatSchema);
+const usage = '用法：/pbot status | init | python setup | agent {"action":…} | chat {"agentId":…,"text":…} | team {"action":…} | post {"teamId":…,"text":…} | history {"action":…} | records {"agentId":…}';
+
+export function registerDshCommand(ctx: Context, workspaces: DshWorkspaces, management: PbotManagement) {
+  ctx.commands.register({ name: "pbot", description: "Personal Bot 工作区与协作管理", recordInput: false,
+    input: { hint: "status | init | python setup | agent/chat/team/post/history/records JSON", attachments: true },
+    async handler({ agent, rawInput, signal, attachments, commandId }) {
+      signal.throwIfAborted();
+      const workspace = await workspaces.get(agent);
+      signal.throwIfAborted();
+      const command = rawInput.trim(), split = command.search(/\s/);
+      const verb = split < 0 ? command : command.slice(0, split);
+      requireThat(verb === "chat" || !attachments.length, "输入框附件仅用于 chat 人工对话。");
+      if (command === "init") {
+        await prepareWorkspace(workspace.root); workspace.check();
+        return { kind: "success", text: "资料目录已准备；已有文件保留。" };
+      }
+      if (command === "python setup") {
+        const result = await workspaces.preparePython(); workspace.check();
+        return { kind: "success", text: JSON.stringify(result, null, 2) };
+      }
+      if (!command || command === "status") return { kind: "success", text: JSON.stringify(dshStatus(workspaces, workspace), null, 2) };
+      requireThat(split >= 0, usage);
+      const input: unknown = JSON.parse(command.slice(split));
+      requireThat(object(input), "命令参数必须是 JSON 对象。");
+      let result: unknown;
+      switch (verb) {
+        case "agent": {
+          requireThat(validAgent(input), "dsh 专家参数无效或包含不支持的宿主选项。");
+          const selection = agent.model.current();
+          const output = await executeAgent(workspace.agents, input as AgentInput, workspace.owner, selection ? {
+            provider: selection.provider, model: selection.model,
+            ...(selection.reasoningEffort && (!input.provider || input.provider === selection.provider) && (!input.model || input.model === selection.model)
+              ? { thinking: selection.reasoningEffort } : {}),
+          } : {});
+          result = output.structuredContent; break;
+        }
+        case "chat": {
+          requireThat(validChat(input), "人工对话参数无效。");
+          const args = input as Static<typeof chatSchema>;
+          result = await workspace.expert(args.agentId).interact(args.text ?? "", args.delivery, args.files, attachments, signal); break;
+        }
+        case "team": {
+          requireThat(validTeam(input), "团队参数无效。");
+          result = executeTeam(workspace.teams, workspace.agents, input as Static<typeof teamParametersSchema>, workspace.owner).structuredContent; break;
+        }
+        case "post": {
+          const args = { ...input, action: "post" as const };
+          requireThat(input.action === undefined && validMessage(args), "公共消息参数无效。");
+          result = executeTeamMessage(workspace.teams, args as Static<typeof teamMessageParametersSchema>,
+            { kind: "user", owner: workspace.owner }, commandId).structuredContent; break;
+        }
+        case "history": result = await management.history({ parentSessionId: agent.id, input: json(input) }, signal); break;
+        case "records": result = await management.expert({ parentSessionId: agent.id, input: json(input) }, signal); break;
+        default: throw new Error(usage);
+      }
+      workspace.check();
+      return { kind: "success", text: JSON.stringify(result, null, 2) };
+    },
+  });
+}

package/src/extension/dsh/files.ts

@@ -0,0 +1,61 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { ToolExecution, ToolExecutionToken } from "@deepseek-ai/dsh-tools";
+import { parsePatch } from "@deepseek-ai/dsh-fs-patch";
+import type {} from "@deepseek-ai/dsh-user-approval";
+import { object } from "../../common/json.js";
+import { requireThat } from "../../common/validation.js";
+import { mutationScope } from "../../services/workspace/workspace-files.js";
+
+/** Native filesystem mutations share the original workspace's confirmation rule.
+ * This does not confine Bash, Python, MCP, or other extensions. */
+export function registerDshFileEvents(ctx: Context, agent: Agent, root: string, expert: boolean, check: () => void) {
+  const lifetime = new AbortController();
+  const mutations = new Set(["write", "edit", "apply_patch"]);
+  const captured = new Map<ToolExecutionToken, { cwd: string; keys: string[]; approved: boolean }>();
+  ctx.effect(() => () => { lifetime.abort(); captured.clear(); });
+  async function targets(exec: Readonly<ToolExecution>) {
+    check(); const args = exec.arguments;
+    requireThat(exec.agent === agent && object(args), "文件操作会话或参数无效。");
+    const signal = AbortSignal.any([lifetime.signal, exec.signal]); signal.throwIfAborted();
+    let paths: string[];
+    if (exec.name === "apply_patch") {
+      requireThat(typeof args.input === "string", "补丁参数无效。");
+      paths = parsePatch(args.input).flatMap(operation => [operation.path, ...(operation.kind === "update" && operation.moveTo ? [operation.moveTo] : [])]);
+    } else {
+      requireThat(typeof args.file_path === "string" && args.file_path.trim().length > 0, "文件路径无效。");
+      paths = [args.file_path];
+    }
+    const anchor = ctx.fs.processPathFromHostPath(root);
+    requireThat(anchor !== undefined, "原生文件系统未映射当前工作区。");
+    const cwd = ctx.workingDirectory.get(agent.session);
+    const resolved = await Promise.all(paths.map(path => ctx.fs.resolve(path, { cwd, signal })));
+    signal.throwIfAborted(); check();
+    const outside = resolved.map(target => ctx.fs.processPath(target)).filter(path => mutationScope(anchor, path) === "outside");
+    return { cwd, keys: resolved.map(target => target.targetKey), outside, signal };
+  }
+  ctx.on("tools/pre-execute", async (exec, next) => {
+    if (!mutations.has(exec.name)) return next();
+    const value = await targets(exec), record = { cwd: value.cwd, keys: value.keys, approved: !value.outside.length };
+    captured.set(exec.token, record);
+    if (value.outside.length && expert) return { kind: "deny", reason: "专家不能修改工作区外文件。" };
+    const policy = await next(); value.signal.throwIfAborted(); check();
+    if (policy.kind === "deny" || policy.kind === "cancel" || !value.outside.length) return policy;
+    const scopeReason = "Personal Bot: confirm changes outside the original workspace: " + JSON.stringify(value.outside);
+    const reason = [policy.kind === "ask" ? policy.reason : undefined, scopeReason].filter(Boolean).join("\n");
+    const outcome = await ctx.approval.request({ agent, toolName: exec.name, callId: exec.callId, signal: value.signal, reason,
+      displayReason: { en: reason, "zh-CN": "允许本次修改原工作区之外的文件：" + value.outside.join("、") + (policy.kind === "ask" && policy.reason ? "\n" + policy.reason : "") } });
+    value.signal.throwIfAborted(); check();
+    record.approved = outcome === "allowed-once";
+    return record.approved ? { kind: "allow" } : { kind: "deny", reason: "用户未确认文件修改。" };
+  });
+  ctx.on("tools/execute", async (exec, next) => {
+    if (!mutations.has(exec.name)) return next();
+    const record = captured.get(exec.token);
+    requireThat(record?.approved, "文件操作没有有效的范围检查或确认。");
+    const value = await targets(exec);
+    requireThat(record.cwd === value.cwd && record.keys.length === value.keys.length && record.keys.every((key, index) => key === value.keys[index]), "确认期间文件路径或工作目录已变化。");
+    return next();
+  });
+  ctx.on("tools/result", exec => { captured.delete(exec.token); });
+}