personal-bot 0.1.1 → 0.2.0

package/src/common/markdown.ts

@@ -0,0 +1,26 @@
+import type { Json } from "./json.js";
+
+/** Preserve original text, including embedded Markdown fences. */
+export function markdownBlock(text: string): string {
+  let fenceLength = 3;
+  for (const match of text.matchAll(/`+/g)) fenceLength = Math.max(fenceLength, match[0].length + 1);
+  const fence = "`".repeat(fenceLength);
+  return fence + "text\n" + text + "\n" + fence;
+}
+
+/** Render structured result fields without changing their machine-readable values. */
+export function markdownFields(value: Json, level = 2): string {
+  if (value === null || typeof value !== "object") return typeof value === "string" ? markdownBlock(value) : String(value);
+  if (Array.isArray(value)) return value.length ? value.map((item, index) =>
+    "#".repeat(level) + " " + (index + 1) + "\n\n" + markdownFields(item, level + 1)).join("\n\n") : "（空）";
+  const fields: string[] = [], sections: string[] = [];
+  for (const [key, item] of Object.entries(value)) {
+    if ((item !== null && typeof item === "object") || (typeof item === "string" && (item.includes("\n") || key === "report" || key === "text"))) {
+      sections.push("#".repeat(level) + " " + key + "\n\n" + markdownFields(item, level + 1));
+    } else {
+      const text = String(item).replace(/[\\`*_{}\[\]<>#!|]/g, "\\$&");
+      fields.push("- " + key + ": " + text);
+    }
+  }
+  return [fields.join("\n"), ...sections].filter(Boolean).join("\n\n");
+}

package/src/extension/agent-events.ts

@@ -3,26 +3,57 @@ import type { Lifecycle } from "./lifecycle.js";
 import type { Confirmations } from "../ui/confirmation.js";
 import { agentOwner, deliveredCycles } from "../integrations/pi/agent-context.js";
 import { agentBoard } from "../ui/agent-display.js";
+import { deliveredTeams } from "../integrations/pi/team-context.js";
+import type { TeamInput } from "../model/team.js";
+import { json } from "../common/json.js";
+import { markdownFields } from "../common/markdown.js";
 
 export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, confirmations: Confirmations) {
   let ctx: ExtensionContext | undefined, timer: ReturnType<typeof setInterval> | undefined;
   let paused = false;
+  let controlBusySince: number | undefined;
   const submitting = new Map<string, number>();
+  // Only a lock-busy, not-yet-published input is retried in this runtime. Reload discards this map.
+  const dispatching = new Map<string, TeamInput>();
+  let pausePending = false;
+  const pauseTeams = () => {
+    const instance = lifecycle.active;
+    if (!ctx || !instance) return;
+    pausePending = true;
+    try { instance.teams.pauseAll(agentOwner(ctx), "主会话中断"); pausePending = false; dispatching.clear(); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== "PBOT_CONTROL_BUSY") { instance.teams.fail(error); throw error; } }
+  };
   const notification = (): CustomMessageEntryDraft | undefined => {
     const instance = lifecycle.active;
     if (!ctx || !instance || paused || ctx.signal?.aborted) return;
-    const delivered = deliveredCycles(ctx), now = Date.now();
+    const delivered = new Set([...deliveredCycles(ctx), ...deliveredTeams(ctx)]), now = Date.now();
     for (const [key, at] of submitting) if (delivered.has(key) || now - at > 5000) submitting.delete(key);
-    const pending = instance.agents.completions(agentOwner(ctx)).filter(v => !delivered.has(v.agentId + ":" + v.cycle.cycleId) && !submitting.has(v.agentId + ":" + v.cycle.cycleId));
+    const owner = agentOwner(ctx), notes = instance.teams.notifications(owner, instance.agents.list(owner))
+      .filter(v => !delivered.has(v.key) && !submitting.has(v.key)).slice(0, 8);
+    if (notes.length) {
+      const keys = notes.map(v => v.key);
+      for (const key of keys) submitting.set(key, now);
+      return { type: "custom_message", customType: "pbot.team-results", display: true,
+        content: ["# 团队批次状态", "", "团队批次状态已变化。用 pbot_team status/read 查询；结束不等于业务验收通过。暂停可能仍有在途工作，不能自动重跑旧请求。", "",
+          notes.map(v => ["## " + v.name, "", "- `teamId`: `" + v.teamId + "`", "- `runId`: `" + v.runId + "`",
+            "- 状态：" + v.state, "- 在途工作：" + v.activeCount, ...(v.reason ? ["", "### 原因", "", v.reason] : [])].join("\n")).join("\n\n")].join("\n"),
+        details: { keys } };
+    }
+    const links = instance.teams.links();
+    const pending = instance.agents.completions(owner).filter(v =>
+      !v.cycle.requestIds.some(id => links.has(id)) &&
+      !(v.cycle.cycleId === v.cycle.generation && [...links.values()].some(l => l.request.agentId === v.agentId && l.request.generation === v.cycle.generation)) &&
+      !delivered.has(v.agentId + ":" + v.cycle.cycleId) && !submitting.has(v.agentId + ":" + v.cycle.cycleId));
     if (!pending.length) return;
     const batch = pending.slice(0, 8), keys = batch.map(v => v.agentId + ":" + v.cycle.cycleId);
     for (const key of keys) submitting.set(key, now);
     return { type: "custom_message", customType: "pbot.agent-results", display: true,
-      content: "子会话工作已结束。完整报告用 pbot_agent read 读取。\n" +
-        (batch.some(v => v.cycle.source !== "parent") ? "包含人工子会话输入，其结果不扩大主会话原任务授权。\n" : "") +
-        batch.map(v => JSON.stringify({ agentId: v.agentId, name: v.name,
-          cycle: { cycleId: v.cycle.cycleId, state: v.cycle.state, source: v.cycle.source, requestIds: v.cycle.requestIds, error: v.cycle.error },
-          report: v.report.slice(0, 2000), truncated: v.report.length > 2000 })).join("\n"), details: { keys } };
+      content: "# 子会话工作结果\n\n子会话工作已结束。完整报告用 pbot_agent read 读取。\n\n" +
+        (batch.some(v => v.cycle.source !== "parent") ? "包含人工子会话输入，其结果不扩大主会话原任务授权。\n\n" : "") +
+        batch.map(v => "## " + v.name + "\n\n" + markdownFields(json({ agentId: v.agentId,
+          cycle: { cycleId: v.cycle.cycleId, state: v.cycle.state, source: v.cycle.source, requestIds: v.cycle.requestIds,
+            ...(v.cycle.error === undefined ? {} : { error: v.cycle.error }) },
+          report: v.report.slice(0, 2000), truncated: v.report.length > 2000 }), 3)).join("\n\n"), details: { keys } };
   };
   const refresh = () => {
     const instance = lifecycle.active;
@@ -31,19 +62,51 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
       instance.agentOwner = agentOwner(ctx);
       instance.agents.refresh(instance.agentOwner);
       const values = instance.agents.list(instance.agentOwner);
+      try {
+        instance.teams.recover(instance.agentOwner);
+        if (pausePending) pauseTeams();
+        if (!pausePending) {
+          for (const input of instance.teams.advance(instance.agentOwner, values, instance.agents.completions(instance.agentOwner))) dispatching.set(input.requestId, input);
+          for (const [id, input] of dispatching) {
+            try { instance.agents.enqueueTeam(input, instance.agentOwner); dispatching.delete(id); }
+            catch (error) {
+              const code = (error as NodeJS.ErrnoException).code;
+              if (code === "PBOT_CONTROL_BUSY") break;
+              if (code !== "TEAM_INPUT_STALE") throw error;
+              dispatching.delete(id); instance.teams.pauseMember(input.agentId, "安排失效；未自动重发");
+            }
+          }
+        }
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "PBOT_CONTROL_BUSY") { instance.teams.fail(error); dispatching.clear(); }
+        throw error;
+      }
+      if (ctx.hasUI) {
+        const teams = instance.teams.list(instance.agentOwner, values);
+        ctx.ui.setStatus("pbot-teams", teams.length ? "团队 " + teams.filter(t => t.owned && t.run?.state === "running").length + " 运行 / " + teams.length : undefined);
+      }
       if (ctx.mode === "tui") ctx.ui.setWidget("pbot-agents", values.some(v => ["starting", "busy", "stopping"].includes(v.state)) ? (_tui, theme) => agentBoard(values, theme) : undefined);
       if (ctx.isIdle() && !paused) { const message = notification(); if (message) pi.sendMessage(message, { triggerTurn: true, deliverAs: "steer" }); }
-    } catch (error) { if (ctx.hasUI) ctx.ui.setStatus("pbot-agents-error", String(error)); }
+      controlBusySince = undefined;
+      if (ctx.hasUI) ctx.ui.setStatus("pbot-agents-error", undefined);
+    } catch (error) {
+      // Brief contention retries on the next scan; persistent locks remain visible.
+      if ((error as NodeJS.ErrnoException).code === "PBOT_CONTROL_BUSY") {
+        controlBusySince ??= Date.now();
+        if (Date.now() - controlBusySince < 5000) return;
+      } else controlBusySince = undefined;
+      if (ctx.hasUI) ctx.ui.setStatus("pbot-agents-error", String(error));
+    }
   };
   const boundary = (outcome: string, entries: SessionBoundaryDraft[], context: ExtensionContext) => {
     ctx = context;
-    if (outcome === "aborted" || ctx.signal?.aborted) { paused = true; confirmations.pause(); return; }
+    if (outcome === "aborted" || ctx.signal?.aborted) { paused = true; confirmations.pause(); pauseTeams(); return; }
     const message = notification();
     if (message) return { entries: [...entries, message], continue: true };
     return;
   };
   pi.on("session_start", (_event, context) => {
-    ctx = context; paused = false; confirmations.resume(); submitting.clear();
+    ctx = context; paused = false; pausePending = false; controlBusySince = undefined; confirmations.resume(); submitting.clear(); dispatching.clear();
     if (timer) clearInterval(timer);
     if (lifecycle.active) { lifecycle.active.agentOwner = agentOwner(ctx); timer = setInterval(refresh, 1000); timer.unref(); }
     refresh();
@@ -54,12 +117,12 @@ export function registerAgentEvents(pi: ExtensionAPI, lifecycle: Lifecycle, conf
   pi.on("turn_end", (event, context) => boundary(event.outcome, event.entries, context));
   pi.on("agent_before_settle", (event, context) => boundary(event.outcome, event.entries, context));
   pi.on("agent_settled", (event, context) => {
-    ctx = context; if (event.aborted) { paused = true; confirmations.pause(); }
+    ctx = context; if (event.aborted) { paused = true; confirmations.pause(); pauseTeams(); }
   });
   pi.on("tool_result", event => {
     if (event.toolName !== "pbot_agent") return;
     const keys = (event.details as { agentReadKeys?: string[] } | undefined)?.agentReadKeys;
     if (keys?.length) pi.appendEntry("pbot.agent-read", { keys, toolCallId: event.parentToolCallId ?? event.toolCallId });
   });
-  pi.on("session_shutdown", () => { if (timer) clearInterval(timer); timer = undefined; submitting.clear(); ctx = undefined; });
+  pi.on("session_shutdown", () => { if (timer) clearInterval(timer); timer = undefined; submitting.clear(); dispatching.clear(); pausePending = false; ctx = undefined; });
 }

package/src/extension/agents-command.ts

@@ -7,9 +7,9 @@ import { tmuxName } from "../integrations/pi/pi-agents.js";
 import { agentSummary } from "../ui/agent-display.js";
 import type { Confirmations } from "../ui/confirmation.js";
 
-export async function showAgents(_pi: ExtensionAPI, instance: WorkspaceInstance, ctx: ExtensionCommandContext, confirmations: Confirmations) {
+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);
+  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; }
@@ -17,31 +17,29 @@ export async function showAgents(_pi: ExtensionAPI, instance: WorkspaceInstance,
   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 action = await ctx.ui.select(value.name, ["进入 TUI", "阅读报告", "补充要求", "重命名", "停止", "恢复并继续"]);
-  if (action === "停止") { instance.agents.stop(value.agentId, owner); return; }
-  if (action === "重命名") { const name = await ctx.ui.input("名称"); if (name?.trim()) instance.agents.rename(value.agentId, name.trim(), owner); return; }
-  if (action === "补充要求" || action === "恢复并继续") {
+  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("任务或补充要求");
-    if (message?.trim()) {
-      if (action === "补充要求") instance.agents.send(value.agentId, message, "steer", owner);
-      else instance.agents.resume(value.agentId, message, owner);
-    }
+    instance.check();
+    if (message?.trim()) instance.agents.send(value.agentId, message, "steer", owner());
     return;
   }
-  if (action === "阅读报告") {
-    const page = instance.agents.read(value.agentId, owner);
-    await ctx.ui.editor("子会话报告（查看不领取通知）", page.report || page.error || page.state); return;
-  }
-  if (action !== "进入 TUI") return;
-  if (!instance.agents.host.alive(value.agentId)) { ctx.ui.notify("子会话已停止，请携新要求恢复。", "info"); return; }
+  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", [process.env.TMUX ? "switch-client" : "attach-session", "-t", "=" + tmuxName(value.agentId)], { stdio: "inherit" });
+      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");

package/src/extension/command.ts

@@ -4,13 +4,14 @@ import { prepareWorkspace } from "../services/workspace/workspace-preparation.js
 import type { Confirmations } from "../ui/confirmation.js";
 import type { Lifecycle } from "./lifecycle.js";
 import { showAgents } from "./agents-command.js";
+import { showTeams } from "./teams-command.js";
 
 export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirmations: Confirmations) {
   pi.registerCommand("pbot", {
-    description: "工作区：init、status、agents、python setup",
+    description: "工作区：init、status、agents、teams、python setup",
     getArgumentCompletions: prefix => {
       if (/\s/.test(prefix)) return null;
-      return ["init", "status", "agents", "python"]
+      return ["init", "status", "agents", "teams", "python"]
         .filter(command => command.startsWith(prefix))
         .map(command => ({ value: command, label: command }));
     },
@@ -29,6 +30,7 @@ export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirma
         ctx.ui.notify(JSON.stringify({ workspaceRoot: instance.root, release: packageVersion, python: instance.pythonEnvironment.status }, null, 2), "info"); 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();
@@ -37,7 +39,7 @@ export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirma
         ctx.ui.notify(JSON.stringify(result, null, 2), "info");
         return;
       }
-      ctx.ui.notify("用法：/pbot init | status | agents | python setup", "info");
+      ctx.ui.notify("用法：/pbot init | status | agents | teams | python setup", "info");
     },
   });
 }

package/src/extension/lifecycle.ts

@@ -5,6 +5,7 @@ import { authorizeMutation } from "../services/workspace/workspace-files.js";
 import type { AgentOwner } from "../model/agent.js";
 import type { PythonEnvironmentService } from "../services/workspace/python-environment-service.js";
 import type { AgentService } from "../services/agents/agent-service.js";
+import type { TeamService } from "../services/agents/team-service.js";
 import type { CallAccess } from "../tools/access.js";
 
 export class WorkspaceInstance implements CallAccess {
@@ -12,7 +13,7 @@ export class WorkspaceInstance implements CallAccess {
   #work = new AbortController();
   #closing: Promise<void> | undefined;
   #restorePython: (() => void) | undefined;
-  constructor(readonly root: string, readonly pythonEnvironment: PythonEnvironmentService, readonly agents: AgentService) {}
+  constructor(readonly root: string, readonly pythonEnvironment: PythonEnvironmentService, readonly agents: AgentService, readonly teams: TeamService) {}
   async preparePython(signal?: AbortSignal) {
     this.check();
     this.#restorePython?.();
@@ -45,8 +46,12 @@ export class WorkspaceInstance implements CallAccess {
     this.#work.abort();
     this.#closing = (async () => {
       try {
+        const errors: unknown[] = [];
+        try { if (this.agentOwner) this.teams.pauseAll(this.agentOwner, "主会话关闭或重新载入"); }
+        catch (error) { errors.push(error); }
+        this.teams.dispose();
         const results = await Promise.allSettled([this.agents.close(this.agentOwner, preserveAgents), this.pythonEnvironment.close()]);
-        const errors = results.filter(result => result.status === "rejected").map(result => result.reason);
+        errors.push(...results.filter(result => result.status === "rejected").map(result => result.reason));
         if (errors.length) throw new AggregateError(errors, "工作区关闭失败。");
       } finally { this.#restorePython?.(); this.#restorePython = undefined; }
     })();

package/src/extension/subagent-entry.ts

@@ -1,10 +1,16 @@
 import { readFile, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { realpathSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { createReadTool, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TextContent, ImageContent } from "@earendil-works/pi-ai";
 import { AgentFiles, descriptor, launch, status, cycle } from "../storage/agent-files.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 { 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";
@@ -24,7 +30,10 @@ export default function subagent(pi: ExtensionAPI) {
   const d = files.read(id, "descriptor.json", descriptor);
   requireThat(d.agentId === id && releaseLine(d.release) === releaseLine(packageVersion), "子会话身份或版本无效。");
   requireThat(files.read(id, "launch.json", launch).generation === generation, "子会话启动代次已失效。");
+  const teams = new TeamService(d.workspace, files, new TeamFiles(files));
   const lifetime = new AbortController();
+  let activeTeam: TeamLink | undefined, pendingPause: string | undefined;
+  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;
@@ -41,11 +50,21 @@ export default function subagent(pi: ExtensionAPI) {
     files.write(id, "status.json", snapshot, status);
   };
   const ensure = () => {
-    lifetime.signal.throwIfAborted();
+    lifetime.signal.throwIfAborted(); files.check();
     const run = files.read(id, "launch.json", launch);
     requireThat(run.generation === generation && !run.stop, "子会话已停止或启动代次变化。");
     requireThat(python, "子会话尚未就绪。");
   };
+  const bindSession = () => {
+    const file = ctx?.sessionManager.getSessionFile();
+    requireThat(file, "子会话必须使用持久原生会话。");
+    files.bindSession(id, file);
+  };
+  const pauseTeam = (reason: string) => {
+    pendingPause = reason;
+    try { teams.pauseMember(id, reason); pendingPause = undefined; }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== "PBOT_CONTROL_BUSY") throw error; }
+  };
   const finish = (aborted: boolean) => {
     if (!ctx || !current) return;
     const branch = ctx.sessionManager.getBranch();
@@ -58,15 +77,17 @@ export default function subagent(pi: ExtensionAPI) {
       ...(!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;
+    current = undefined; activeTeam = undefined;
   };
   const shutdown = async () => {
     if (closing) return;
     closing = true;
-    save({ state: "stopping", activity: "停止" });
     lifetime.abort(); ctx?.abort();
-    await python?.close();
-    ctx?.shutdown();
+    try {
+      teams.files.setReady(id, generation, false); ready = false;
+      pauseTeam("成员停止");
+      save({ state: "stopping", activity: "停止" });
+    } finally { try { await python?.close(); } finally { ctx?.shutdown(); } }
   };
   const pump = async () => {
     if (processing || !ctx || closing) return;
@@ -75,8 +96,28 @@ export default function subagent(pi: ExtensionAPI) {
       const run = files.read(id, "launch.json", launch);
       if (run.generation !== generation || run.stop) { await shutdown(); return; }
       if (pi.getSessionName() !== run.name) pi.setSessionName(run.name);
+      if (pendingPause) { pauseTeam(pendingPause); if (pendingPause) return; }
+      const capable = pi.getActiveTools().includes("pbot_team_message");
+      if (capable !== ready) {
+        teams.files.setReady(id, generation, capable); ready = capable;
+        if (!ready) pauseTeam("成员团队工具已停用");
+      }
+      if (activeTeam) {
+        if (Date.now() >= activeTeam.run.deadlineAt) {
+          pauseTeam("已到期限");
+          if (!interactive && current?.source !== "mixed") {
+            ctx.abort();
+            if (!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;
+        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;
         const content: (TextContent | ImageContent)[] = [];
         for (const path of request.files) {
           const output = await createReadTool(d.cwd).execute("file-" + request.requestId, { path }, lifetime.signal);
@@ -85,19 +126,33 @@ export default function subagent(pi: ExtensionAPI) {
         content.push({ type: "text", text: request.message || "请处理所附文件。" });
         requireThat(ctx.model, "子会话没有可用模型。");
         requireThat(ctx.modelRegistry.hasConfiguredAuth(ctx.model) || await ctx.modelRegistry.getProviderAuth(ctx.model.provider), "子会话模型未认证，请配置原生 Pi 认证后显式恢复。");
-        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: "消息已接收" });
+        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: "消息已接收" });
+        };
+        if (link) {
+          if (!ctx.isIdle() || ctx.hasPendingMessages() || current || interactive || queuedRequests.length) break;
+          activeTeam = teams.claim(id, generation, request.requestId, accept);
+          if (!activeTeam) continue;
+        } else accept();
         pi.sendUserMessage(content, ctx.isIdle() ? {} : { deliverAs: request.delivery });
         break;
       }
     } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "PBOT_CONTROL_BUSY") return;
       save({ state: "error", activity: "控制失败", error: String(error) });
       await shutdown();
     } finally { processing = false; }
   };
+  pi.registerTool({ ...teamMessageTool(teams, { check: ensure }, () => ({
+    kind: "member", agentId: id, generation,
+    ...(activeTeam && current?.source === "parent" ? { requestId: activeTeam.request.requestId } : {}),
+  })), namespace: { name: "pbot", description: "团队公共通信，不提供管理或递归委派。" } });
   pi.on("resources_discover", async () => {
     if (d.options.noSkills) return {};
     const skillPaths = [join(resourceRoot, "skills")];
@@ -112,7 +167,15 @@ export default function subagent(pi: ExtensionAPI) {
   pi.on("session_start", async (_event, context) => {
     ctx = context;
     try {
-      requireThat(realpathSync(ctx.cwd) === d.cwd && ctx.sessionManager.getSessionFile() === files.session(id), "子会话工作目录或文件不匹配。");
+      const run = files.read(id, "launch.json", launch);
+      requireThat(run.generation === generation && !run.stop, "子会话启动代次已失效或已停止。");
+      teams.files.setReady(id, generation, false);
+      pauseTeam("子会话载入：旧批次不自动恢复");
+      const file = ctx.sessionManager.getSessionFile(), previous = files.session(id);
+      requireThat(realpathSync(ctx.cwd) === d.cwd && ctx.sessionManager.getSessionId() === id && file &&
+        (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(); }
       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);
       }
@@ -120,6 +183,15 @@ export default function subagent(pi: ExtensionAPI) {
         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 active = pi.getActiveTools();
       for (const tool of agentFileTools(d.cwd, lifetime.signal, async (path, change, cancel) => {
         ensure();
@@ -132,27 +204,64 @@ export default function subagent(pi: ExtensionAPI) {
       try { const result = await python.setup(lifetime.signal); restorePython = activatePython(result.directory); }
       catch (error) { ctx.ui.notify(String(error), "warning"); }
       save({ state: "idle", activity: "空闲" });
-      timer = setInterval(() => void pump(), 250); timer.unref(); void pump();
-    } catch (error) { save({ state: "error", activity: "启动失败", error: String(error) }); ctx.shutdown(); }
+      ready = !pendingPause && pi.getActiveTools().includes("pbot_team_message");
+      teams.files.setReady(id, generation, ready);
+      const tick = () => void pump().catch(error => {
+        closing = true; lifetime.abort(); ctx?.abort();
+        console.error("子会话控制失败：", error); ctx?.shutdown();
+      });
+      timer = setInterval(tick, 250); timer.unref(); tick();
+    } catch (error) {
+      try { save({ state: "error", activity: "启动失败", error: String(error) }); }
+      finally { await shutdown(); }
+    }
   });
-  pi.on("before_agent_start", async event => {
-    ensure();
+  pi.on("before_agent_start", async (event, context) => {
+    ctx = context; ensure(); bindSession();
+    delete event.systemPromptOptions.sections.pbot_team;
     requireThat(python, "子会话计算环境状态不可用。");
     event.systemPromptOptions.sections.pbot_environment = JSON.stringify({
       workspaceRoot: d.workspace, cwd: d.cwd, resourceRoot, python: python.status,
     });
     event.systemPromptOptions.sections.pbot_workspace = await readFile(join(resourceRoot, "prompts/workspace.md"), "utf8");
     event.systemPromptOptions.sections.pbot_child = await agentText("general-purpose", d.workspace);
+    if (activeTeam && !interactive && current?.source !== "mixed") {
+      const link = teams.links().get(activeTeam.request.requestId);
+      requireThat(link, "团队关联不可读取。");
+      event.systemPromptOptions.sections.pbot_team = teamBrief(link);
+      const message = teamContext(link, context, link.request.throughSeq);
+      if (message) return { message };
+    }
+    return;
+  });
+  pi.on("turn_end", (event, context) => {
+    if (!activeTeam || current?.source !== "parent" || event.outcome === "aborted") return;
+    const link = teams.links().get(activeTeam.request.requestId);
+    if (!link) return;
+    const message = teamContext(link, context);
+    if (message) return { entries: [...event.entries, message] };
+    return;
   });
-  pi.on("input", event => {
+  pi.on("input", async event => {
+    try { ensure(); bindSession(); }
+    catch (error) {
+      try { save({ state: "error", activity: "会话引用失败", error: String(error) }); }
+      catch { /* A failed store must not allow the native input fallback. */ }
+      try { await shutdown(); } catch { ctx?.shutdown(); }
+      return { action: "handled" };
+    }
     if (event.source !== "extension") {
       if (current) current.source = current.source === "parent" ? "mixed" : current.source;
       else interactive = true;
+      save({ state: "busy", activity: "人工输入" });
+      pauseTeam("成员由人工接管");
     }
     return;
   });
   pi.on("agent_start", (_event, context) => {
-    ctx = context; startLeaf = ctx.sessionManager.getLeafId();
+    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;
@@ -161,7 +270,10 @@ export default function subagent(pi: ExtensionAPI) {
   pi.on("tool_call", event => {
     try {
       ensure();
-      requireThat(event.toolName !== "pbot_agent", "子会话禁止管理和委派。");
+      requireThat(event.toolName !== "pbot_agent" && event.toolName !== "pbot_team", "子会话禁止管理和委派。");
+      if (activeTeam && 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;
@@ -172,10 +284,16 @@ export default function subagent(pi: ExtensionAPI) {
   pi.on("session_before_fork", () => ({ cancel: true }));
   pi.on("session_before_tree", (_event, context) => ({ cancel: !context.isIdle() }));
   pi.on("session_shutdown", async event => {
+    if (disposed) return;
+    disposed = true;
     if (timer) clearInterval(timer); timer = undefined; closing = true; lifetime.abort();
-    if (current) finish(true);
-    await python?.close(); restorePython?.();
-    if (event.reason !== "reload" && snapshot.state !== "error") save({ state: "stopped", activity: "已停止" });
-    ctx = undefined;
+    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: "已停止" });
+    } finally {
+      try { await python?.close(); } finally { restorePython?.(); teams.dispose(); ctx = undefined; }
+    }
   });
 }

package/src/extension/teams-command.ts

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { agentOwner } from "../integrations/pi/agent-context.js";
+import type { WorkspaceInstance } from "./lifecycle.js";
+import type { Confirmations } from "../ui/confirmation.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 } = {};
+  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;
+  }
+}