@melihmucuk/pi-crew 1.0.7 → 1.0.9

package/dist/integration/tools/crew-list.js

@@ -2,18 +2,18 @@ import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { discoverAgents } from "../../agent-discovery.js";
 import { STATUS_ICON } from "../../subagent-messages.js";
-export function registerCrewListTool({ pi, crewManager, notifyDiscoveryWarnings, }) {
+export function registerCrewListTool({ pi, crew, notifyDiscoveryWarnings, }) {
     pi.registerTool({
         name: "crew_list",
         label: "List Crew",
-        description: "List available subagent definitions (from <cwd>/.pi/agents/, ~/.pi/agent/agents/, and bundled agents, with optional global/project pi-crew.json overrides) and currently running subagents with their status.",
+        description: "List available subagent definitions and currently running subagents with their status.",
         parameters: Type.Object({}),
         promptSnippet: "List subagent definitions and active subagents",
         async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
             const { agents, warnings } = discoverAgents(ctx.cwd);
             notifyDiscoveryWarnings(ctx, warnings);
             const callerSessionId = ctx.sessionManager.getSessionId();
-            const running = crewManager.getActiveSummariesForOwner(callerSessionId);
+            const running = crew.getActiveSummariesForOwner(callerSessionId);
             const lines = [];
             lines.push("## Available subagents");
             if (agents.length === 0) {

package/dist/integration/tools/crew-respond.d.ts

@@ -1,2 +1,2 @@
 import type { CrewToolDeps } from "./tool-deps.js";
-export declare function registerCrewRespondTool({ pi, crewManager }: CrewToolDeps): void;
+export declare function registerCrewRespondTool({ pi, crew }: CrewToolDeps): void;

package/dist/integration/tools/crew-respond.js

@@ -1,10 +1,10 @@
 import { Type } from "@sinclair/typebox";
-import { renderCrewCall, renderCrewResult, toolError, toolSuccess, truncatePreview, } from "../tool-presentation.js";
-export function registerCrewRespondTool({ pi, crewManager }) {
+import { renderCrewCall, renderCrewResult, toolError, toolSuccess, } from "../tool-presentation.js";
+export function registerCrewRespondTool({ pi, crew }) {
     pi.registerTool({
         name: "crew_respond",
         label: "Respond to Crew",
-        description: "Send a follow-up message to an interactive subagent that is waiting for a response. Use crew_list to see waiting subagents.",
+        description: "Send a follow-up message to an interactive subagent that is waiting for a response.",
         parameters: Type.Object({
             subagent_id: Type.String({
                 description: "ID of the waiting subagent (from crew_list or crew_spawn result)",
@@ -14,14 +14,13 @@ export function registerCrewRespondTool({ pi, crewManager }) {
         promptSnippet: "Send a follow-up message to a waiting interactive subagent.",
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const callerSessionId = ctx.sessionManager.getSessionId();
-            const { error } = crewManager.respond(params.subagent_id, params.message, pi, callerSessionId);
+            const { error } = crew.respond(params.subagent_id, params.message, callerSessionId);
             if (error)
                 return toolError(error);
-            return toolSuccess(`Message sent to subagent ${params.subagent_id}. Response will be delivered as a steering message.`, { id: params.subagent_id });
+            return toolSuccess(`Message sent to subagent ${params.subagent_id}. Response will be delivered as a steering message.`, { id: params.subagent_id, message: params.message });
         },
         renderCall(args, theme, _context) {
-            const preview = args.message ? truncatePreview(args.message, 60) : "...";
-            return renderCrewCall(theme, "crew_respond", args.subagent_id || "...", preview);
+            return renderCrewCall(theme, "crew_respond", args.subagent_id || "...", args.message);
         },
         renderResult(result, _options, theme, _context) {
             return renderCrewResult(result, theme);

package/dist/integration/tools/crew-spawn.d.ts

@@ -1,2 +1,2 @@
 import type { CrewToolDeps } from "./tool-deps.js";
-export declare function registerCrewSpawnTool({ pi, crewManager, notifyDiscoveryWarnings, }: CrewToolDeps): void;
+export declare function registerCrewSpawnTool({ pi, crew, extensionDir, notifyDiscoveryWarnings, }: CrewToolDeps): void;

package/dist/integration/tools/crew-spawn.js

@@ -1,24 +1,23 @@
 import { Type } from "@sinclair/typebox";
 import { discoverAgents } from "../../agent-discovery.js";
-import { renderCrewCall, renderCrewResult, toolError, toolSuccess, truncatePreview, } from "../tool-presentation.js";
-export function registerCrewSpawnTool({ pi, crewManager, notifyDiscoveryWarnings, }) {
+import { renderCrewCall, renderCrewResult, toolError, toolSuccess, } from "../tool-presentation.js";
+export function registerCrewSpawnTool({ pi, crew, extensionDir, notifyDiscoveryWarnings, }) {
     pi.registerTool({
         name: "crew_spawn",
         label: "Spawn Crew",
-        description: "Spawn a non-blocking subagent that runs in an isolated session. The subagent works independently while your session stays interactive. Results are delivered back to your session as steering messages when done. NEVER PREDICT or FABRICATE results for subagents that have not yet reported back to you. Use crew_list first to see available subagents.",
+        description: "Spawn a non-blocking subagent that runs in an isolated session. The subagent works independently while your session stays interactive. Results are delivered back to your session as steering messages.",
         parameters: Type.Object({
             subagent: Type.String({ description: "Subagent name from crew_list" }),
             task: Type.String({ description: "Task to delegate to the subagent" }),
         }),
         promptSnippet: "Spawn a non-blocking subagent. Use crew_list first to see available subagents.",
         promptGuidelines: [
-            "Use crew_* tools to delegate parallelizable, independent tasks to specialized subagents. For interactive multi-turn workflows, use crew_respond/crew_done. Avoid spawning for trivial, single-turn tasks.",
-            "crew_spawn: Always call crew_list first to see which subagents are available before spawning.",
-            "crew_spawn: The spawned subagent runs in a separate context window with no access to your session. Include all relevant context (file paths, requirements, prior findings) directly in the task parameter.",
-            "crew_spawn: Results are delivered asynchronously as steering messages. Do not block or poll for completion. If there are other independent tasks to handle, continue with those; otherwise wait for the user's next instruction or the subagent result.",
-            "crew_spawn: NEVER perform the same work you delegated to a subagent. Once a task is spawned, trust the subagent to do it. Do not run the same searches, reads, or analysis yourself while waiting. You may only gather context BEFORE spawning to prepare the task description. After spawning, move on to other independent work or simply wait for the result.",
-            "crew_spawn: When multiple subagents are spawned, each result arrives as a separate steering message. NEVER PREDICT or FABRICATE results for subagents that have not yet reported back to you. Wait for ALL crew-result messages.",
-            "crew_spawn: Interactive subagents (marked with 'interactive' in crew_list) stay alive after responding. Use crew_respond to continue the conversation and crew_done to close when finished.",
+            "Use crew_list first to see available subagents before spawning.",
+            "crew_spawn: The subagent runs in isolation with no access to your session. Include file paths, requirements, and known locations directly in the task parameter.",
+            "crew_spawn: DELEGATE means STOP. After spawning, either work on an UNRELATED task or end your turn. Never continue the delegated task yourself.",
+            "crew_spawn: To avoid duplication, gather only enough context to write a useful task (key files, entry points). Do not pre-investigate the full problem.",
+            "crew_spawn: Results arrive asynchronously as steering messages. Do not predict or fabricate results. Wait for all crew-result messages before acting on them.",
+            "crew_spawn: Interactive subagents stay alive after responding. Use crew_respond to continue and crew_done to close when finished.",
         ],
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const { agents, warnings } = discoverAgents(ctx.cwd);
@@ -29,12 +28,16 @@ export function registerCrewSpawnTool({ pi, crewManager, notifyDiscoveryWarnings
                 return toolError(`Unknown subagent: "${params.subagent}". Available: ${available}`);
             }
             const ownerSessionId = ctx.sessionManager.getSessionId();
-            const id = crewManager.spawn(subagent, params.task, ctx.cwd, ownerSessionId, ctx, pi);
-            return toolSuccess(`Subagent '${subagent.name}' spawned as ${id}. Result will be delivered as a steering message when done.`, { id });
+            const id = crew.spawn(subagent, params.task, ctx.cwd, ownerSessionId, {
+                model: ctx.model,
+                modelRegistry: ctx.modelRegistry,
+                parentSessionFile: ctx.sessionManager.getSessionFile(),
+                onWarning: (msg) => ctx.ui.notify(msg, "warning"),
+            }, extensionDir);
+            return toolSuccess(`Subagent '${subagent.name}' spawned as ${id}. Result will be delivered as a steering message when done.`, { id, agentName: subagent.name, task: params.task });
         },
         renderCall(args, theme, _context) {
-            const preview = args.task ? truncatePreview(args.task, 60) : "...";
-            return renderCrewCall(theme, "crew_spawn", args.subagent || "...", preview);
+            return renderCrewCall(theme, "crew_spawn", args.subagent || "...", args.task);
         },
         renderResult(result, _options, theme, _context) {
             return renderCrewResult(result, theme);

package/dist/integration/tools/tool-deps.d.ts

@@ -1,8 +1,9 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { AgentDiscoveryWarning } from "../../agent-discovery.js";
-import type { CrewManager } from "../../crew-manager.js";
+import type { CrewRuntime } from "../../runtime/crew-runtime.js";
 export interface CrewToolDeps {
     pi: ExtensionAPI;
-    crewManager: CrewManager;
+    crew: CrewRuntime;
+    extensionDir: string;
     notifyDiscoveryWarnings: (ctx: ExtensionContext, warnings: AgentDiscoveryWarning[]) => void;
 }

package/dist/integration.d.ts

@@ -1,3 +1,3 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import type { CrewManager } from "./crew-manager.js";
-export declare function registerCrewIntegration(pi: ExtensionAPI, crewManager: CrewManager): void;
+import type { CrewRuntime } from "./runtime/crew-runtime.js";
+export declare function registerCrewIntegration(pi: ExtensionAPI, crew: CrewRuntime, extensionDir: string): void;

package/dist/integration.js

@@ -1,8 +1,8 @@
 import { registerCrewCommand } from "./integration/register-command.js";
 import { registerCrewMessageRenderers } from "./integration/register-renderers.js";
 import { registerCrewTools } from "./integration/register-tools.js";
-export function registerCrewIntegration(pi, crewManager) {
-    registerCrewTools(pi, crewManager);
-    registerCrewCommand(pi, crewManager);
+export function registerCrewIntegration(pi, crew, extensionDir) {
+    registerCrewTools(pi, crew, extensionDir);
+    registerCrewCommand(pi, crew);
     registerCrewMessageRenderers(pi);
 }

package/dist/runtime/crew-runtime.d.ts

@@ -0,0 +1,61 @@
+import type { Api, Model } from "@mariozechner/pi-ai";
+import type { ModelRegistry } from "@mariozechner/pi-coding-agent";
+import type { AgentConfig } from "../agent-discovery.js";
+import { type ActiveRuntimeBinding } from "./delivery-coordinator.js";
+import { type AbortableAgentSummary, type ActiveAgentSummary } from "./subagent-state.js";
+export type { AbortableAgentSummary, ActiveAgentSummary, } from "./subagent-state.js";
+export interface AbortOwnedResult {
+    abortedIds: string[];
+    missingIds: string[];
+    foreignIds: string[];
+}
+interface AbortOptions {
+    reason: string;
+}
+export interface SpawnContext {
+    model: Model<Api> | undefined;
+    modelRegistry: ModelRegistry;
+    parentSessionFile?: string;
+    onWarning?: (message: string) => void;
+}
+/**
+ * Process-level singleton that owns all durable subagent state.
+ *
+ * This survives extension instance replacement caused by runtime
+ * teardown/recreation on /resume, /new, /fork (pi 0.65.0+).
+ * Each new extension instance rebinds delivery and widget hooks
+ * via activateSession/deactivateSession.
+ */
+declare class CrewRuntime {
+    private readonly registry;
+    private readonly delivery;
+    private readonly refreshCallbacks;
+    private refreshWidgetFor;
+    activateSession(binding: ActiveRuntimeBinding, refreshWidget?: () => void): void;
+    deactivateSession(sessionId: string): void;
+    spawn(agentConfig: AgentConfig, task: string, cwd: string, ownerSessionId: string, ctx: SpawnContext, extensionResolvedPath: string): string;
+    private attachSessionListeners;
+    private attachSpawnedSession;
+    private settleAgent;
+    private disposeAgent;
+    private runPromptCycle;
+    private spawnSession;
+    respond(id: string, message: string, callerSessionId: string): {
+        error?: string;
+    };
+    done(id: string, callerSessionId: string): {
+        error?: string;
+    };
+    abort(id: string, opts: AbortOptions): boolean;
+    abortOwned(ids: string[], callerSessionId: string, opts: AbortOptions): AbortOwnedResult;
+    abortAllOwned(callerSessionId: string, opts: AbortOptions): string[];
+    /**
+     * Abort all running subagents (process-level cleanup).
+     * Called from process exit hooks.
+     */
+    abortAll(): void;
+    getAbortableAgents(): AbortableAgentSummary[];
+    getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[];
+}
+export declare const crewRuntime: CrewRuntime;
+export type { CrewRuntime };

package/dist/{crew-manager.js → runtime/crew-runtime.js}

@@ -1,8 +1,15 @@
-import { bootstrapSession } from "./bootstrap-session.js";
-import { DeliveryCoordinator } from "./runtime/delivery-coordinator.js";
-import { runPromptWithOverflowRecovery } from "./runtime/overflow-recovery.js";
-import { SubagentRegistry } from "./runtime/subagent-registry.js";
-import { isAbortableStatus, isAborted, } from "./runtime/subagent-state.js";
+import { bootstrapSession } from "../bootstrap-session.js";
+import { DeliveryCoordinator } from "./delivery-coordinator.js";
+import { runPromptWithOverflowRecovery } from "./overflow-recovery.js";
+import { SubagentRegistry } from "./subagent-registry.js";
+import { isAbortableStatus, isAborted, } from "./subagent-state.js";
+function toBootstrapContext(ctx) {
+    return {
+        model: ctx.model,
+        modelRegistry: ctx.modelRegistry,
+        parentSessionFile: ctx.parentSessionFile,
+    };
+}
 function getLastAssistantMessage(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
@@ -43,26 +50,41 @@ function getPromptOutcome(state) {
         result: text ?? "(no output)",
     };
 }
-export class CrewManager {
-    extensionResolvedPath;
+/**
+ * Process-level singleton that owns all durable subagent state.
+ *
+ * This survives extension instance replacement caused by runtime
+ * teardown/recreation on /resume, /new, /fork (pi 0.65.0+).
+ * Each new extension instance rebinds delivery and widget hooks
+ * via activateSession/deactivateSession.
+ */
+class CrewRuntime {
     registry = new SubagentRegistry();
     delivery = new DeliveryCoordinator();
-    overflowAbortControllers = new Map();
-    onWidgetUpdate;
-    constructor(extensionResolvedPath) {
-        this.extensionResolvedPath = extensionResolvedPath;
+    // Per-session refresh callbacks, keyed by ownerSessionId
+    refreshCallbacks = new Map();
+    refreshWidgetFor(sessionId) {
+        this.refreshCallbacks.get(sessionId)?.();
     }
-    activateSession(sessionId, isIdle, pi) {
-        this.delivery.activateSession(sessionId, isIdle, pi, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
+    activateSession(binding, refreshWidget) {
+        if (refreshWidget) {
+            this.refreshCallbacks.set(binding.sessionId, refreshWidget);
+        }
+        this.delivery.activateSession(binding, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
+        refreshWidget?.();
+    }
+    deactivateSession(sessionId) {
+        this.delivery.deactivateSession(sessionId);
+        this.refreshCallbacks.delete(sessionId);
     }
-    spawn(agentConfig, task, cwd, ownerSessionId, ctx, pi) {
+    spawn(agentConfig, task, cwd, ownerSessionId, ctx, extensionResolvedPath) {
         const state = this.registry.create(agentConfig, task, ownerSessionId);
-        this.onWidgetUpdate?.();
-        void this.spawnSession(state, cwd, ctx.sessionManager.getSessionFile(), ctx, pi);
+        this.refreshWidgetFor(ownerSessionId);
+        void this.spawnSession(state, cwd, ctx, extensionResolvedPath);
         return state.id;
     }
     attachSessionListeners(state, session) {
-        session.subscribe((event) => {
+        state.unsubscribe = session.subscribe((event) => {
             if (event.type !== "turn_end")
                 return;
             state.turns++;
@@ -72,7 +94,7 @@ export class CrewManager {
                 state.contextTokens = assistantMsg.usage.totalTokens;
                 state.model = assistantMsg.model;
             }
-            this.onWidgetUpdate?.();
+            this.refreshWidgetFor(state.ownerSessionId);
         });
     }
     attachSpawnedSession(state, session) {
@@ -83,90 +105,89 @@ export class CrewManager {
         state.session = session;
         return true;
     }
-    /**
-     * Single owner for post-prompt and terminal state transitions.
-     * Publishes the outcome, updates state, and disposes finished subagents.
-     */
-    settleAgent(state, nextStatus, opts, pi) {
+    settleAgent(state, nextStatus, opts) {
         state.status = nextStatus;
         state.result = opts.result;
         state.error = opts.error;
         this.delivery.deliver(state.ownerSessionId, {
             id: state.id,
             agentName: state.agentConfig.name,
+            sessionFile: state.session?.sessionFile,
             status: state.status,
             result: state.result,
             error: state.error,
-        }, pi, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
+        }, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
         if (state.status !== "waiting") {
             this.disposeAgent(state);
         }
         else {
-            this.onWidgetUpdate?.();
+            this.refreshWidgetFor(state.ownerSessionId);
         }
     }
     disposeAgent(state) {
+        state.unsubscribe?.();
+        state.promptAbortController = undefined;
         state.session?.dispose();
         this.registry.delete(state.id);
-        this.onWidgetUpdate?.();
+        this.refreshWidgetFor(state.ownerSessionId);
     }
-    async runPromptCycle(state, prompt, pi) {
+    async runPromptCycle(state, prompt) {
         if (isAborted(state))
             return;
         const abortController = new AbortController();
-        this.overflowAbortControllers.set(state.id, abortController);
+        state.promptAbortController = abortController;
         try {
             const recovery = await runPromptWithOverflowRecovery(state.session, prompt, abortController.signal);
             if (isAborted(state))
                 return;
             const outcome = getPromptOutcome(state);
-            // If overflow recovery ran but failed, keep the error from outcome.
-            // If it recovered, outcome now reflects the retry turn's result.
             if (recovery === "failed" && outcome.status !== "error") {
                 this.settleAgent(state, "error", {
                     error: "Context overflow recovery failed",
-                }, pi);
+                });
                 return;
             }
-            this.settleAgent(state, outcome.status, outcome, pi);
+            this.settleAgent(state, outcome.status, outcome);
         }
         catch (err) {
             if (isAborted(state))
                 return;
             const error = err instanceof Error ? err.message : String(err);
-            this.settleAgent(state, "error", { error }, pi);
+            this.settleAgent(state, "error", { error });
         }
         finally {
-            this.overflowAbortControllers.delete(state.id);
+            state.promptAbortController = undefined;
         }
     }
-    async spawnSession(state, cwd, parentSessionFile, ctx, pi) {
+    async spawnSession(state, cwd, ctx, extensionResolvedPath) {
         try {
             if (isAborted(state))
                 return;
-            const { session } = await bootstrapSession({
+            const { session, warnings } = await bootstrapSession({
                 agentConfig: state.agentConfig,
                 cwd,
-                ctx,
-                extensionResolvedPath: this.extensionResolvedPath,
-                parentSessionFile,
+                ctx: toBootstrapContext(ctx),
+                extensionResolvedPath,
             });
+            // Emit bootstrap warnings to UI
+            for (const warning of warnings) {
+                ctx.onWarning?.(warning);
+            }
             if (!this.attachSpawnedSession(state, session))
                 return;
             this.attachSessionListeners(state, session);
-            await this.runPromptCycle(state, state.task, pi);
+            await this.runPromptCycle(state, state.task);
         }
         catch (err) {
             if (isAborted(state))
                 return;
-            // Only bootstrap errors reach here; runPromptCycle handles its own errors
             if (state.status === "running") {
                 const error = err instanceof Error ? err.message : String(err);
-                this.settleAgent(state, "error", { error }, pi);
+                this.settleAgent(state, "error", { error });
             }
         }
     }
-    respond(id, message, pi, callerSessionId) {
+    respond(id, message, callerSessionId) {
         const state = this.registry.get(id);
         if (!state)
             return { error: `No subagent with id "${id}"` };
@@ -181,8 +202,8 @@ export class CrewManager {
         if (!state.session)
             return { error: `Subagent "${id}" has no active session` };
         state.status = "running";
-        this.onWidgetUpdate?.();
-        void this.runPromptCycle(state, message, pi);
+        this.refreshWidgetFor(state.ownerSessionId);
+        void this.runPromptCycle(state, message);
         return {};
     }
     done(id, callerSessionId) {
@@ -198,19 +219,19 @@ export class CrewManager {
         this.disposeAgent(state);
         return {};
     }
-    abort(id, pi, opts) {
+    abort(id, opts) {
         const state = this.registry.get(id);
         if (!state || !isAbortableStatus(state.status))
             return false;
-        this.overflowAbortControllers.get(id)?.abort();
-        this.overflowAbortControllers.delete(id);
+        state.promptAbortController?.abort();
+        state.promptAbortController = undefined;
         state.session?.abortCompaction();
         state.session?.abortRetry();
         state.session?.abort().catch(() => { });
-        this.settleAgent(state, "aborted", { error: opts.reason }, pi);
+        this.settleAgent(state, "aborted", { error: opts.reason });
         return true;
     }
-    abortOwned(ids, callerSessionId, pi, opts) {
+    abortOwned(ids, callerSessionId, opts) {
         const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
         const result = {
             abortedIds: [],
@@ -227,7 +248,7 @@ export class CrewManager {
                 result.foreignIds.push(id);
                 continue;
             }
-            if (this.abort(id, pi, opts)) {
+            if (this.abort(id, opts)) {
                 result.abortedIds.push(id);
             }
             else {
@@ -236,18 +257,22 @@ export class CrewManager {
         }
         return result;
     }
-    abortAllOwned(callerSessionId, pi, opts) {
+    abortAllOwned(callerSessionId, opts) {
         const ids = this.registry.getOwnedAbortableIds(callerSessionId);
         for (const id of ids) {
-            this.abort(id, pi, opts);
+            this.abort(id, opts);
         }
         return ids;
     }
-    abortForOwner(ownerSessionId, pi) {
-        this.abortAllOwned(ownerSessionId, pi, {
-            reason: "Aborted on session shutdown",
-        });
-        this.delivery.clearPendingForOwner(ownerSessionId);
+    /**
+     * Abort all running subagents (process-level cleanup).
+     * Called from process exit hooks.
+     */
+    abortAll() {
+        const allAgents = this.registry.getAllRunning();
+        for (const state of allAgents) {
+            this.abort(state.id, { reason: "Aborted on process exit" });
+        }
     }
     getAbortableAgents() {
         return this.registry.getAbortableAgents();
@@ -256,3 +281,4 @@ export class CrewManager {
         return this.registry.getActiveSummariesForOwner(ownerSessionId);
     }
 }
+export const crewRuntime = new CrewRuntime();

package/dist/runtime/delivery-coordinator.d.ts

@@ -1,12 +1,21 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { type SteeringPayload } from "../subagent-messages.js";
+import { type SteeringPayload, type SendMessageFn } from "../subagent-messages.js";
+export interface ActiveRuntimeBinding {
+    sessionId: string;
+    isIdle: () => boolean;
+    sendMessage: SendMessageFn;
+}
 export declare class DeliveryCoordinator {
-    private currentSessionId;
-    private currentIsIdle;
+    private binding;
     private pendingMessages;
-    activateSession(sessionId: string, isIdle: () => boolean, pi: ExtensionAPI, countRunningForOwner: (ownerSessionId: string, excludeId: string) => number): void;
-    deliver(ownerSessionId: string, payload: SteeringPayload, pi: ExtensionAPI, countRunningForOwner: (ownerSessionId: string, excludeId: string) => number): void;
-    clearPendingForOwner(ownerSessionId: string): void;
+    private flushScheduled;
+    activateSession(binding: ActiveRuntimeBinding, countRunningForOwner: (ownerSessionId: string, excludeId: string) => number): void;
+    deactivateSession(sessionId: string): void;
+    deliver(ownerSessionId: string, payload: SteeringPayload, countRunningForOwner: (ownerSessionId: string, excludeId: string) => number): void;
+    /**
+     * Remove pending messages older than the TTL.
+     * Called during activateSession to prevent unbounded memory growth.
+     */
+    private cleanStaleMessages;
     private flushPending;
     /**
      * Result messages always go first. If more subagents are still running and the

package/dist/runtime/delivery-coordinator.js

@@ -1,42 +1,64 @@
 import { sendRemainingNote, sendSteeringMessage, } from "../subagent-messages.js";
 export class DeliveryCoordinator {
-    currentSessionId;
-    currentIsIdle = () => true;
+    binding;
     pendingMessages = [];
-    activateSession(sessionId, isIdle, pi, countRunningForOwner) {
-        this.currentSessionId = sessionId;
-        this.currentIsIdle = isIdle;
+    flushScheduled = false;
+    activateSession(binding, countRunningForOwner) {
+        this.binding = binding;
         // Delay flush to next macrotask. session_start fires before pi-core
         // calls _reconnectToAgent(), so synchronous delivery would emit agent
         // events while the session listener is disconnected, losing JSONL persistence.
-        if (this.pendingMessages.some((entry) => entry.ownerSessionId === sessionId)) {
-            setTimeout(() => this.flushPending(pi, countRunningForOwner), 0);
+        if (this.pendingMessages.some((entry) => entry.ownerSessionId === binding.sessionId)) {
+            this.flushScheduled = true;
+            setTimeout(() => {
+                this.flushScheduled = false;
+                this.flushPending(countRunningForOwner);
+            }, 0);
         }
     }
-    deliver(ownerSessionId, payload, pi, countRunningForOwner) {
-        if (ownerSessionId !== this.currentSessionId) {
-            this.pendingMessages.push({ ownerSessionId, payload });
+    deactivateSession(sessionId) {
+        if (this.binding?.sessionId === sessionId) {
+            this.binding = undefined;
+        }
+    }
+    deliver(ownerSessionId, payload, countRunningForOwner) {
+        if (!this.binding || ownerSessionId !== this.binding.sessionId || this.flushScheduled) {
+            this.pendingMessages.push({ ownerSessionId, payload, queuedAt: Date.now() });
             return;
         }
-        this.send(ownerSessionId, payload, pi, countRunningForOwner);
+        this.send(ownerSessionId, payload, countRunningForOwner);
     }
-    clearPendingForOwner(ownerSessionId) {
-        this.pendingMessages = this.pendingMessages.filter((entry) => entry.ownerSessionId !== ownerSessionId);
+    /**
+     * Remove pending messages older than the TTL.
+     * Called during activateSession to prevent unbounded memory growth.
+     */
+    cleanStaleMessages() {
+        const maxAgeMs = 86_400_000; // 24 hours
+        const cutoff = Date.now() - maxAgeMs;
+        this.pendingMessages = this.pendingMessages.filter((entry) => entry.queuedAt >= cutoff);
     }
-    flushPending(pi, countRunningForOwner) {
+    flushPending(countRunningForOwner) {
+        if (!this.binding)
+            return;
+        const targetSessionId = this.binding.sessionId;
+        // Clean up stale messages first (older than TTL)
+        this.cleanStaleMessages();
         const toDeliver = [];
         const remaining = [];
         for (const entry of this.pendingMessages) {
-            if (entry.ownerSessionId === this.currentSessionId) {
+            if (entry.ownerSessionId === targetSessionId) {
                 toDeliver.push(entry);
             }
             else {
+                // Keep all other messages - they may be for sessions that will be reactivated later
                 remaining.push(entry);
             }
         }
+        // Keep messages for other sessions
         this.pendingMessages = remaining;
+        // Deliver messages for the active session
         for (const entry of toDeliver) {
-            this.send(entry.ownerSessionId, entry.payload, pi, countRunningForOwner);
+            this.send(entry.ownerSessionId, entry.payload, countRunningForOwner);
         }
     }
     /**
@@ -44,15 +66,19 @@ export class DeliveryCoordinator {
      * owner is idle, queue the result without triggering, then queue the separate
      * remaining note with triggerTurn so the next turn sees both in order.
      */
-    send(ownerSessionId, payload, pi, countRunningForOwner) {
+    send(ownerSessionId, payload, countRunningForOwner) {
+        if (!this.binding || this.binding.sessionId !== ownerSessionId) {
+            this.pendingMessages.push({ ownerSessionId, payload, queuedAt: Date.now() });
+            return;
+        }
         const remaining = countRunningForOwner(ownerSessionId, payload.id);
-        const isIdle = this.currentIsIdle();
+        const isIdle = this.binding.isIdle();
         const triggerResultTurn = !(isIdle && remaining > 0);
-        sendSteeringMessage(payload, pi, {
+        sendSteeringMessage(payload, this.binding.sendMessage, {
             isIdle,
             triggerTurn: triggerResultTurn,
         });
-        sendRemainingNote(remaining, pi, {
+        sendRemainingNote(remaining, this.binding.sendMessage, {
             isIdle,
             triggerTurn: isIdle && remaining > 0,
         });

package/dist/runtime/subagent-registry.d.ts

@@ -10,4 +10,5 @@ export declare class SubagentRegistry {
     getAbortableAgents(): AbortableAgentSummary[];
     getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[];
     getOwnedAbortableIds(ownerSessionId: string): string[];
+    getAllRunning(): SubagentState[];
 }