pi-extended-teams 2.3.0 → 2.3.1

package/extensions/events/register-events.ts

@@ -51,6 +51,20 @@ function hasPersistedTeamSettings(ctx: any): boolean {
     && fs.existsSync(projectSettingsPath(ctx.cwd));
 }
 
+export function registerAgentReportRenderer(pi: any): void {
+  pi.registerMessageRenderer?.("pi-extended-teams-report", (message: any, _renderOptions: any, theme: any) => {
+    const d = message.details || {};
+    const meta = [
+      d.elapsedMs ? formatElapsed(d.elapsedMs) : "",
+      typeof d.tokens === "number" ? `${formatTokenCount(d.tokens)} tok` : "",
+    ].filter(Boolean).join(" · ");
+    const mark = d.ok === false ? theme.fg("warning", "✗") : theme.fg("success", "✓");
+    const headline = `${mark} ${d.name || "agent"} reported${meta ? ` · ${meta}` : ""}`;
+    const body = typeof message.content === "string" ? message.content : "";
+    return new Text(`${theme.bold(headline)}\n\n${body}`, 0, 0);
+  });
+}
+
 export function registerExtensionEvents(pi: any, options: RegisterEventsOptions): void {
   let teammateWakeIfUnread: (() => Promise<void>) | null = null;
   let teammatePendingInboxWake = false;
@@ -131,17 +145,7 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
     }
   };
 
-  pi.registerMessageRenderer?.("pi-extended-teams-report", (message: any, _renderOptions: any, theme: any) => {
-    const d = message.details || {};
-    const meta = [
-      d.elapsedMs ? formatElapsed(d.elapsedMs) : "",
-      typeof d.tokens === "number" ? `${formatTokenCount(d.tokens)} tok` : "",
-    ].filter(Boolean).join(" · ");
-    const mark = d.ok === false ? theme.fg("warning", "✗") : theme.fg("success", "✓");
-    const headline = `${mark} ${d.name || "agent"} reported${meta ? ` · ${meta}` : ""}`;
-    const body = typeof message.content === "string" ? message.content : "";
-    return new Text(`${theme.bold(headline)}\n\n${body}`, 0, 0);
-  });
+  registerAgentReportRenderer(pi);
 
   pi.on("session_start", async (_event: any, ctx: any) => {
     paths.ensureDirs();

package/extensions/index.ts

@@ -25,6 +25,8 @@ import { parseQualifiedModel } from "../src/utils/model-resolution";
 import { formatAnimatedProgress, formatContextUsage, formatElapsed, formatModelLabel } from "./ui/renderers.js";
 import type { CompletedAgentReport, RunningReadAgent } from "./runtime/types.js";
 import { createPendingChildController } from "./runtime/pending-child-controller.js";
+import { createTeamHost } from "./runtime/team-host";
+import { registerLeadAttachment, type TeamExecutionOwner } from "./runtime/lead-attachment";
 import { createActiveAgentSleepController, runWithActiveAgentSleepAssertion } from "./runtime/active-agent-sleep.js";
 import { createTeammateInterrupter } from "./runtime/teammate-interrupt.js";
 export { panelBgFill, framePanel, frameWidget, frameWidgetFullWidth, logWindowStart } from "./ui/frame.js";
@@ -39,9 +41,17 @@ import type { Member } from "../src/utils/models";
 import { projectAgentStatus, projectLifecycleFence } from "../src/orchestration/status-projection";
 import { getTerminalAdapter } from "../src/adapters/terminal-registry";
 import { createSpawnResourcePlan, parentProjectTrustForSpawn } from "./resources/spawn-resource-plan.js";
-import { generateExtensionInstanceId, listLifecycleTombstones, onLifecycleTombstoneCleared, readLifecycleTombstone } from "../src/utils/lifecycle-tombstone";
+import { generateExtensionInstanceId, generateLifecycleRunId, listLifecycleTombstones, onLifecycleTombstoneCleared, readLifecycleTombstone } from "../src/utils/lifecycle-tombstone";
 
-export default function (pi: ExtensionAPI) {
+export default function (pi: ExtensionAPI): void {
+  if (process.env.PI_AGENT_NAME) { createExecutionRuntime(pi); return; }
+  registerLeadAttachment(pi, () => {
+    const host = createTeamHost();
+    return createExecutionRuntime(host.api as unknown as ExtensionAPI, host);
+  });
+}
+
+function createExecutionRuntime(pi: ExtensionAPI, host?: ReturnType<typeof createTeamHost>): TeamExecutionOwner {
   const isTeammate = !!process.env.PI_AGENT_NAME;
   const agentName = process.env.PI_AGENT_NAME || "team-lead";
   const extensionInstanceId = generateExtensionInstanceId();
@@ -67,6 +77,14 @@ export default function (pi: ExtensionAPI) {
   let readHelperQueueDrainPending = false;
   let sessionCtx: any = null;
   let extensionShuttingDown = false;
+  let executionClosing = false;
+  const pendingRootAdmissions = new Set<Promise<void>>();
+  function trackRootAdmission(): () => void {
+    let settle!: () => void;
+    const pending = new Promise<void>(resolve => { settle = resolve; });
+    pendingRootAdmissions.add(pending);
+    return () => { pendingRootAdmissions.delete(pending); settle(); };
+  }
   const lifecycleFenceClearUnsubscribe = onLifecycleTombstoneCleared((clearedTeamName) => {
     if (clearedTeamName === teamName) void drainReadHelperQueueOnce();
   });
@@ -82,6 +100,7 @@ export default function (pi: ExtensionAPI) {
   let teamActivityStatusSnapshotSignature: string | null = null;
   let teamActivityWidgetMounted = false;
   let teamActivityWidgetTui: { requestRender?: () => void } | null = null;
+  let presentationGeneration = 0;
   let teamActivityRenderInFlight = false;
   let teamActivityRenderDirty = false;
   let teamActivityRenderTimer: NodeJS.Timeout | null = null;
@@ -93,8 +112,10 @@ export default function (pi: ExtensionAPI) {
   // instead of unread count prevents a read message being replaced by a new one
   // at the same count from silently suppressing the new wake.
   const leadWakeNotifiedMessageKeys = new Set<string>();
-  const createCurrentSpawnResourcePlan = (input: { cwd: string; projectTrusted: boolean }) => {
-    return createSpawnResourcePlan({ ...input, pi });
+  const createCurrentSpawnResourcePlan = async (input: { cwd: string; projectTrusted: boolean }) => {
+    while (host && !host.ready) await host.whenAttached();
+    const projectTrusted = host ? parentProjectTrustForSpawn(sessionCtx, input.cwd) : input.projectTrusted;
+    return createSpawnResourcePlan({ ...input, projectTrusted, pi });
   };
   let teamToolsRuntime: TeamToolsRuntime | undefined;
   const pendingChildController = createPendingChildController();
@@ -447,9 +468,12 @@ export default function (pi: ExtensionAPI) {
   }
 
   async function notifyLeadOfInboxReports(targetTeamName: string): Promise<void> {
-    if (isTeammate) return;
+    if (isTeammate || extensionShuttingDown) return;
+    const generation = presentationGeneration;
     const unread = await messaging.peekInbox(targetTeamName, agentName, true);
+    if (generation !== presentationGeneration) return;
     await renderLeadInboxStatus();
+    if (generation !== presentationGeneration) return;
     await wakeLeadForInboxReports(unread);
   }
 
@@ -530,6 +554,7 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
+    const generation = presentationGeneration;
     teamActivityRenderInFlight = true;
     let renderError: unknown;
     try {
@@ -538,6 +563,7 @@ export default function (pi: ExtensionAPI) {
     } catch (error) {
       renderError = error;
     } finally {
+      if (generation !== presentationGeneration) return;
       teamActivityRenderInFlight = false;
       if (renderError) {
         teamActivityRenderDirty = false;
@@ -602,6 +628,8 @@ export default function (pi: ExtensionAPI) {
 
   async function renderTeamActivityStatusNow() {
     if (!sessionCtx?.ui) return;
+    const generation = presentationGeneration;
+    const isCurrent = () => generation === presentationGeneration && !extensionShuttingDown;
 
     const now = Date.now();
     const activityTeamName = teamName || null;
@@ -630,6 +658,7 @@ export default function (pi: ExtensionAPI) {
           runtimeStatus: await runtime.readRuntimeStatus(activityTeamName, member.name).catch(() => null),
         })))
       : [];
+    if (!isCurrent()) return;
     const runtimeOnlyMembers = runtimeOnlyCandidates
       .filter((entry): entry is { member: Member; runtimeStatus: runtime.AgentRuntimeStatus } => isVisibleRuntimeOnlyMember(entry.member, entry.runtimeStatus, now))
       .filter(({ member, runtimeStatus }) => member.lifecycleRunId === runtimeStatus.lifecycleRunId);
@@ -678,6 +707,7 @@ export default function (pi: ExtensionAPI) {
       }
     }
     const unreadLeadMessages = activityTeamName ? await messaging.readInbox(activityTeamName, agentName, true, false).catch(() => []) : [];
+    if (!isCurrent()) return;
     leadInboxUnreadCount = unreadLeadMessages.length;
     clearLeadInboxWidgetOnce();
 
@@ -746,6 +776,7 @@ export default function (pi: ExtensionAPI) {
         joinedAt: member.joinedAt,
       });
       const runtimeStatus = await runtime.readRuntimeStatus(activityTeamName!, member.name).catch(() => null);
+      if (!isCurrent()) return;
       const elapsed = formatElapsed(now - (runtimeStatus?.startedAt || member.joinedAt));
       const modelLabel = formatModelLabel(member.model, member.thinking);
       const contextUsage = formatRunningContextUsage(runtimeStatus?.contextUsage);
@@ -870,12 +901,13 @@ export default function (pi: ExtensionAPI) {
   }
 
   async function drainReadHelperQueueOnce() {
-    if (isTeammate || !sessionCtx || !teamName) return;
+    if (isTeammate || !sessionCtx || !teamName || (host && !host.ready)) return;
     if (readHelperQueueDraining) {
       readHelperQueueDrainPending = true;
       return;
     }
     readHelperQueueDraining = true;
+    const settled = trackRootAdmission();
     try {
       for (let drained = 0; drained < 10 && teamName; drained++) {
         const [nextQueued] = await listReadHelperQueue(teamName);
@@ -886,6 +918,8 @@ export default function (pi: ExtensionAPI) {
 
         try {
           const config = await teams.readConfig(queued.teamName);
+          const launchContext = sessionCtx;
+          if (!launchContext || (host && !host.ready)) return;
           if (config.members.some(member => member.name === queued.name)) {
             throw new Error(`Teammate ${queued.name} already exists in team ${queued.teamName}.`);
           }
@@ -894,7 +928,7 @@ export default function (pi: ExtensionAPI) {
           const parsedModel = parseQualifiedModel(level.model);
           const provider = parsedModel?.provider;
           const modelId = parsedModel?.model;
-          const model = provider && modelId ? sessionCtx.modelRegistry?.find?.(provider, modelId) : undefined;
+          const model = provider && modelId ? launchContext.modelRegistry?.find?.(provider, modelId) : undefined;
           if (!model) throw new Error(`Read helper model \"${level.model}\" from intent tier ${level.slot} is not available in the lead session.`);
 
           const helperPrompt = buildReadHelperPrompt(queued.teamName, queued.requester, queued.prompt);
@@ -916,9 +950,15 @@ export default function (pi: ExtensionAPI) {
             helperKind: "read_helper",
           };
 
+          member.lifecycleRunId = generateLifecycleRunId();
           await teams.addMember(queued.teamName, member);
+          if (executionClosing) {
+            await shutdownTeammate(queued.teamName, member);
+            await removeQueuedReadHelperRequest(queued.teamName, queued.id);
+            break;
+          }
           observeReadAgentLaunch(
-            runInProcessAgentWithSleepAssertion(queued.teamName, member, helperPrompt, sessionCtx, readAgentOptions())
+            runInProcessAgentWithSleepAssertion(queued.teamName, member, helperPrompt, launchContext, readAgentOptions())
           );
           await removeQueuedReadHelperRequest(teamName, queued.id);
         } catch (e) {
@@ -971,6 +1011,7 @@ export default function (pi: ExtensionAPI) {
         }
       }
     } finally {
+      settled();
       readHelperQueueDraining = false;
       if (readHelperQueueDrainPending) {
         readHelperQueueDrainPending = false;
@@ -1023,9 +1064,12 @@ export default function (pi: ExtensionAPI) {
 
     leadInboxPollTimer = setInterval(async () => {
       if (!teamName) return;
+      const generation = presentationGeneration;
       try {
         const unread = await messaging.readInbox(teamName, agentName, true, false);
+        if (generation !== presentationGeneration) return;
         await renderLeadInboxStatus();
+        if (generation !== presentationGeneration) return;
         await wakeLeadForInboxReports(unread);
       } catch {
         // Ignore errors for lead polling
@@ -1055,11 +1099,12 @@ export default function (pi: ExtensionAPI) {
   pi.events?.on?.("pi-prompt:prompt-build:start", async (payload: any) => {
     if (isTeammate || !sessionCtx) return;
     const requestedTeamName = teamPaths.sanitizeName(payload?.teamName || `prompt-build-${Date.now()}`);
-
+    const launchContext = sessionCtx;
+    const settled = trackRootAdmission();
     try {
       const prompts = Array.isArray(payload?.prompts) ? payload.prompts : [];
       activePromptBuildTeamName = requestedTeamName;
-      const cwd = payload?.cwd || sessionCtx.cwd;
+      const cwd = payload?.cwd || launchContext.cwd;
       const agentNamePrefix = teamPaths.sanitizeName(payload?.agentNamePrefix || "prompt-branch");
       if (payload?.model || payload?.thinking || payload?.role) {
         throw new Error("Prompt-build agents must use model_slot only; direct model, thinking, or role is not allowed.");
@@ -1069,7 +1114,7 @@ export default function (pi: ExtensionAPI) {
       if (level.role !== "read") throw new Error(`Prompt-build requires a read-* intent tier configured via /agents-favorite-models, got ${level.slot}.`);
 
       if (!teams.teamExists(requestedTeamName)) {
-        teams.createTeam(requestedTeamName, getPiSessionId(sessionCtx) || "local-session", "lead-agent", payload?.description || "pi-prompt prompt-build", level.model);
+        teams.createTeam(requestedTeamName, getPiSessionId(launchContext) || "local-session", "lead-agent", payload?.description || "pi-prompt prompt-build", level.model);
       }
       // Prompt-build teams are private fanout jobs owned by pi-prompt. Do not
       // adopt them as the lead's current team, or normal session context and
@@ -1094,21 +1139,25 @@ export default function (pi: ExtensionAPI) {
           thinking: level.thinking,
           modelSlot: level.slot,
         };
+        if (executionClosing) break;
+        member.lifecycleRunId = generateLifecycleRunId();
         await teams.addMember(requestedTeamName, member);
+        if (executionClosing) { await shutdownTeammate(requestedTeamName, member); break; }
         observeReadAgentLaunch(
-          runInProcessAgentWithSleepAssertion(requestedTeamName, member, prompt, sessionCtx, readAgentOptions())
+          runInProcessAgentWithSleepAssertion(requestedTeamName, member, prompt, launchContext, readAgentOptions())
         );
         pi.events?.emit?.("pi-prompt:prompt-build:progress", { teamName: requestedTeamName, status: "spawned", started: i + 1, total: prompts.length, text: `building prompt — ${i + 1}/${prompts.length} branches started` });
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       pi.events?.emit?.("pi-prompt:prompt-build:error", { teamName: requestedTeamName, error: message });
-    }
+    } finally { settled(); }
   });
 
   function setSessionCtx(ctx: any): void {
+    if (host && !host.attached) return;
     extensionShuttingDown = false;
-    sessionCtx = ctx;
+    sessionCtx = host?.context ?? ctx;
     if (!isTeammate && !teamName) {
       const foundTeam = findLeadTeamForSession(getPiSessionId(ctx));
       if (foundTeam) adoptTeamAsLead(foundTeam, ctx);
@@ -1142,7 +1191,10 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
-  async function cleanupExtensionRuntime(ctx: any, reason: unknown): Promise<void> {
+  function detachPresentation(): void {
+    presentationGeneration++;
+    teamActivityRenderInFlight = false;
+    navigationRuntimeAgents.clear();
     extensionShuttingDown = true;
     sessionCtx = null;
     stopLeadWatchdog();
@@ -1158,13 +1210,20 @@ export default function (pi: ExtensionAPI) {
     readHelperQueueFallbackTimer = null;
     readHelperQueueWatcher = null;
     leadPollingStarted = false;
-    leadWakeNotifiedMessageKeys.clear();
     readHelperQueueFallbackStarted = false;
     readHelperQueueWatchedTeam = null;
-    lifecycleFenceClearUnsubscribe();
     teamActivityRenderDirty = false;
     settleTeamActivityRenderWaiters();
+    teamActivityStatusSnapshot = null;
+    teamActivityStatusSnapshotSignature = null;
+    teamActivityWidgetMounted = false;
+    teamActivityWidgetTui = null;
+  }
 
+  async function cleanupExtensionRuntime(ctx: any, reason: unknown): Promise<void> {
+    detachPresentation();
+    leadWakeNotifiedMessageKeys.clear();
+    lifecycleFenceClearUnsubscribe();
     try {
       await stopRunningAgentsForShutdown(reason);
     } finally {
@@ -1334,6 +1393,8 @@ export default function (pi: ExtensionAPI) {
     getSessionCtx: () => sessionCtx,
     setSessionCtx,
     pendingChildController,
+    isHostAttached: () => !host || host.ready,
+    waitForHost: () => host?.whenAttached() ?? Promise.resolve(),
   });
 
   if (isTeammate) {
@@ -1345,7 +1406,7 @@ export default function (pi: ExtensionAPI) {
     }));
   }
 
-  registerCoordinationTools(pi, {
+  const coordination: Parameters<typeof registerCoordinationTools>[1] = {
     agentName,
     isTeammate,
     terminal,
@@ -1360,9 +1421,10 @@ export default function (pi: ExtensionAPI) {
     resetLeadWakeNotifiedCount: () => { leadWakeNotifiedMessageKeys.clear(); },
     deliverMessageToActiveAgent,
     extensionInstanceId,
-  });
+  };
+  if (isTeammate) registerCoordinationTools(pi, coordination);
 
-  registerTaskRuntimeTools(pi, {
+  const taskTools: Parameters<typeof registerTaskRuntimeTools>[1] = {
     isTeammate,
     terminal,
     runningReadAgents,
@@ -1371,6 +1433,47 @@ export default function (pi: ExtensionAPI) {
     cancelQueuedAgent: (targetTeamName, targetAgentName) => teamToolsRuntime?.cancelQueuedAgent(targetTeamName, targetAgentName) ?? false,
     shutdownTeammate,
     getTeamName: () => teamName,
-  });
-
+  };
+  if (isTeammate) registerTaskRuntimeTools(pi, taskTools);
+
+  return {
+    host: host!, coordination, taskTools,
+    hasWork: () => runningReadAgents.size > 0 || activeWritersTabs.length > 0 || pendingRootAdmissions.size > 0 || teamToolsRuntime?.hasPendingWork() === true,
+    async attach(binding) {
+      host!.attach(binding);
+      const ctx = host!.snapshot(binding.ctx);
+      const costAttached = combinedSessionCost?.attach(binding.pi, ctx);
+      await host!.emit("session_start", binding.event, ctx);
+      if (!host!.attached) return;
+      if (!costAttached) combinedSessionCost?.attach(binding.pi, ctx);
+    },
+    activate() {
+      host!.flush();
+      teamToolsRuntime?.resumeQueues();
+      void drainReadHelperQueueOnce();
+      if (teamName) void notifyLeadOfInboxReports(teamName).catch(warnGroup);
+    },
+    detach() {
+      sessionCtx?.ui?.setWidget?.("01-pi-extended-teams-readers", undefined);
+      sessionCtx?.ui?.setWidget?.("01-pi-extended-teams-status", undefined);
+      detachPresentation();
+      combinedSessionCost?.detach();
+      host?.detach();
+    },
+    async close(reason) {
+      teamToolsRuntime.closeAdmission();
+      executionClosing = true;
+      sessionCtx?.ui?.setWidget?.("01-pi-extended-teams-readers", undefined);
+      sessionCtx?.ui?.setWidget?.("01-pi-extended-teams-status", undefined);
+      detachPresentation();
+      host?.close();
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const admissions = Promise.race([
+        Promise.all([...pendingRootAdmissions]),
+        new Promise<never>((_resolve, reject) => { timer = setTimeout(() => reject(new Error("Team admission cleanup is still pending.")), 2_500); }),
+      ]).finally(() => clearTimeout(timer));
+      await Promise.all([host!.emit("session_shutdown", { reason }, undefined), admissions]);
+      if (runningReadAgents.size) throw new Error("Team cleanup is still fenced by unsettled agents.");
+    },
+  };
 }

package/extensions/runtime/lead-attachment.ts

@@ -0,0 +1,91 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { TSchema } from "@sinclair/typebox";
+import { Key } from "@mariozechner/pi-tui";
+import { connectReloadOwner, type ReloadOwner } from "./reload-owner";
+import { createTeamHost, type TeamHostBinding } from "./team-host";
+import { registerAgentReportRenderer } from "../events/register-events";
+import { publicTeamToolMetadata } from "../tools/public-team-tools";
+import { registerCoordinationTools, type CoordinationToolsOptions } from "../tools/coordination-tools";
+import { registerTaskRuntimeTools, type TaskRuntimeToolsOptions } from "../tools/task-runtime-tools";
+import { registerFavoriteModelsCommand } from "../ui/favorite-models-command";
+import { registerExtensionsCommand } from "../ui/extensions-command";
+import { registerOnboardingCommand } from "../ui/onboarding-command";
+import { registerCheckpointsCommand } from "../ui/checkpoints-command";
+
+export interface TeamExecutionOwner extends ReloadOwner<TeamHostBinding> {
+  host: ReturnType<typeof createTeamHost>;
+  coordination: CoordinationToolsOptions;
+  taskTools: TaskRuntimeToolsOptions;
+  activate(): void;
+}
+
+export function registerLeadAttachment(pi: ExtensionAPI, createOwner: () => TeamExecutionOwner): void {
+  let connection: Awaited<ReturnType<typeof connectReloadOwner<TeamHostBinding>>> | undefined;
+  let attaching: Promise<void> | undefined;
+  const attach = (ctx: any, event: any): Promise<void> => {
+    if (connection) return Promise.resolve();
+    return attaching ??= connectReloadOwner(ctx.sessionManager, ctx.sessionManager.getSessionId(), { pi, ctx, event }, createOwner)
+      .then(value => { connection = value; execution().activate(); }).finally(() => { attaching = undefined; });
+  };
+  const execution = (): TeamExecutionOwner => {
+    if (!connection) throw new Error("Team execution is not attached to this session.");
+    return connection.owner as TeamExecutionOwner;
+  };
+
+  for (const metadata of Object.values(publicTeamToolMetadata)) {
+    pi.registerTool<TSchema>({ ...metadata, async execute(id, params, signal, update, ctx) {
+      await attach(ctx, { reason: "startup" });
+      const owner = execution();
+      return owner.host.tools.get(metadata.name).execute(id, params, signal, update, owner.host.snapshot(ctx));
+    } });
+  }
+  // These lead-only adapters carry no running task state. In-process child
+  // tools remain owned by the retained controller and its original imports.
+  registerCoordinationTools(pi, {
+    isTeammate: false, agentName: "team-lead",
+    get terminal() { return execution().coordination.terminal; },
+    getTeamName: () => execution().coordination.getTeamName(),
+    requireWriteAgentTeam: () => execution().coordination.requireWriteAgentTeam(),
+    requireTeamContext: name => execution().coordination.requireTeamContext(name),
+    releaseAllClaimsForAgent: (...args) => execution().coordination.releaseAllClaimsForAgent(...args),
+    drainWriteQueue: name => execution().coordination.drainWriteQueue(name),
+    resolveSkillFile: (...args) => execution().coordination.resolveSkillFile(...args),
+    adoptTeamAsLead: (name, ctx) => execution().coordination.adoptTeamAsLead(name, ctx && execution().host.snapshot(ctx)),
+    renderLeadInboxStatus: () => execution().coordination.renderLeadInboxStatus(),
+    resetLeadWakeNotifiedCount: () => execution().coordination.resetLeadWakeNotifiedCount(),
+    deliverMessageToActiveAgent: (...args) => execution().coordination.deliverMessageToActiveAgent!(...args),
+  });
+  registerTaskRuntimeTools(pi, {
+    isTeammate: false,
+    get terminal() { return execution().taskTools.terminal; },
+    get runningReadAgents() { return execution().taskTools.runningReadAgents; },
+    readAgentKey: (...args) => execution().taskTools.readAgentKey(...args),
+    getTeamName: () => execution().taskTools.getTeamName(),
+    interruptTeammate: name => execution().taskTools.interruptTeammate!(name),
+    cancelQueuedAgent: (...args) => execution().taskTools.cancelQueuedAgent!(...args),
+    shutdownTeammate: (...args) => execution().taskTools.shutdownTeammate(...args),
+  });
+  registerAgentReportRenderer(pi);
+  registerFavoriteModelsCommand(pi);
+  registerExtensionsCommand(pi);
+  registerOnboardingCommand(pi);
+  registerCheckpointsCommand(pi);
+  pi.registerShortcut(Key.alt("tab"), {
+    description: "Cycle active writer-agent tmux screens",
+    handler: ctx => execution().host.shortcuts.get(Key.alt("tab"))?.handler(execution().host.snapshot(ctx)),
+  });
+
+  pi.on("session_start", (event, ctx) => attach(ctx, event));
+  pi.on("session_shutdown", async event => {
+    const current = connection;
+    connection = undefined;
+    await current?.shutdown(event.reason ?? "quit");
+  });
+  for (const name of ["context", "turn_start", "tool_execution_start", "tool_execution_end", "message_end", "turn_end",
+    "before_agent_start", "agent_end", "agent_settled", "session_compact", "session_tree"] as const) {
+    (pi.on as any)(name, (event: unknown, ctx: unknown) => {
+      const owner = execution();
+      return owner.host.emit(name, event, owner.host.snapshot(ctx));
+    });
+  }
+}

package/extensions/runtime/reload-owner.ts

@@ -0,0 +1,107 @@
+export interface ReloadOwner<Attachment> {
+  attach(attachment: Attachment): void | Promise<void>;
+  detach(): void;
+  close(reason: string): Promise<void>;
+  hasWork(): boolean;
+}
+
+interface RetainedOwner {
+  owner: ReloadOwner<unknown>;
+  state: "attaching" | "attached" | "detached" | "closing";
+  generation: number;
+  deadline?: number;
+  timer?: ReturnType<typeof setTimeout>;
+  closing?: Promise<void>;
+}
+
+interface Registry {
+  version: 1;
+  sessions: WeakMap<object, Map<string, RetainedOwner>>;
+}
+
+const REGISTRY_KEY = Symbol.for("pi-extended-teams.reload-owners.v1");
+const RECOVERY_WINDOW_MS = 60_000;
+
+// Pi re-evaluates modules on reload, but keeps the Node realm and (in the
+// supported host) the root SessionManager. Session IDs alone can collide
+// between two independent hosts opening the same saved conversation.
+function registry(): Registry {
+  const globals = globalThis as typeof globalThis & { [REGISTRY_KEY]?: Registry };
+  return globals[REGISTRY_KEY] ??= { version: 1, sessions: new WeakMap() };
+}
+
+export async function connectReloadOwner<Attachment>(
+  manager: object,
+  sessionId: string,
+  attachment: Attachment,
+  createOwner: () => ReloadOwner<Attachment>,
+): Promise<{ owner: ReloadOwner<Attachment>; shutdown(reason: string): Promise<void> }> {
+  const sessions = registry().sessions;
+  let owners = sessions.get(manager);
+  if (!owners) sessions.set(manager, owners = new Map());
+  let record = owners.get(sessionId);
+  if (record && record.state !== "detached") {
+    throw new Error(`Team execution owner is ${record.state}; refusing a replacement.`);
+  }
+  if (!record) {
+    record = { owner: createOwner() as ReloadOwner<unknown>, state: "attaching", generation: 0 };
+    owners.set(sessionId, record);
+  }
+  const current = record;
+  const generation = ++current.generation;
+  current.state = "attaching";
+
+  const close = (reason: string): Promise<void> => {
+    if (current.closing) return current.closing;
+    current.state = "closing";
+    current.generation++;
+    clearTimeout(current.timer);
+    current.closing = Promise.resolve().then(() => current.owner.close(reason)).then(() => {
+      if (owners.get(sessionId) === current) owners.delete(sessionId);
+    });
+    return current.closing;
+  };
+  const armDeadline = (): void => {
+    clearTimeout(current.timer);
+    const epoch = current.generation;
+    current.timer = setTimeout(() => {
+      if (current.generation !== epoch || current.state === "attached") return;
+      // A failed cleanup remains in the registry as a fence. Durable lifecycle
+      // records retain the cleanup evidence; do not silently replace this owner.
+      void close("reload-timeout").catch(() => {});
+    }, Math.max(0, (current.deadline ?? Date.now()) - Date.now()));
+    current.timer.unref?.();
+  };
+
+  const isClosing = () => current.state === "closing";
+  if (current.deadline !== undefined) armDeadline();
+  try {
+    await current.owner.attach(attachment);
+    if (current.generation !== generation || current.state !== "attaching") {
+      throw new Error("Team reload attachment expired while reconnecting.");
+    }
+    clearTimeout(current.timer);
+    current.deadline = undefined;
+    current.state = "attached";
+  } catch (error) {
+    if (!isClosing()) {
+      current.owner.detach();
+      current.state = "detached";
+      current.deadline ??= Date.now() + RECOVERY_WINDOW_MS;
+      armDeadline();
+    }
+    throw error;
+  }
+
+  return {
+    owner: current.owner as ReloadOwner<Attachment>,
+    async shutdown(reason) {
+      if (current.generation !== generation || current.state !== "attached") return;
+      if (reason !== "reload" || !current.owner.hasWork()) return close(reason);
+      current.owner.detach();
+      current.state = "detached";
+      current.deadline = Date.now() + RECOVERY_WINDOW_MS;
+      armDeadline();
+    },
+  };
+}