@melihmucuk/pi-crew 1.0.6 → 1.0.8

package/dist/agent-discovery.d.ts

@@ -25,10 +25,5 @@ interface AgentDiscoveryResult {
     agents: AgentConfig[];
     warnings: AgentDiscoveryWarning[];
 }
-interface ParseResult {
-    agent: AgentConfig | null;
-    warnings: AgentDiscoveryWarning[];
-}
-export declare function parseAgentDefinition(content: string, filePath: string): ParseResult;
 export declare function discoverAgents(cwd?: string): AgentDiscoveryResult;
 export {};

package/dist/agent-discovery.js

@@ -202,7 +202,7 @@ function parseSharedFields(record, options) {
         ],
     };
 }
-export function parseAgentDefinition(content, filePath) {
+function parseAgentDefinition(content, filePath) {
     const warnings = [];
     let frontmatter;
     let body;

package/dist/bootstrap-session.d.ts

@@ -1,11 +1,20 @@
-import { type CreateAgentSessionResult, type ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { type AgentSession, type ModelRegistry } from "@mariozechner/pi-coding-agent";
+import type { Api, Model } from "@mariozechner/pi-ai";
 import type { AgentConfig } from "./agent-discovery.js";
+export interface BootstrapContext {
+    model: Model<Api> | undefined;
+    modelRegistry: ModelRegistry;
+    parentSessionFile?: string;
+}
 interface BootstrapOptions {
     agentConfig: AgentConfig;
     cwd: string;
-    ctx: ExtensionContext;
+    ctx: BootstrapContext;
     extensionResolvedPath: string;
-    parentSessionFile?: string;
 }
-export declare function bootstrapSession(opts: BootstrapOptions): Promise<CreateAgentSessionResult>;
+export interface BootstrapResult {
+    session: AgentSession;
+    warnings: string[];
+}
+export declare function bootstrapSession(opts: BootstrapOptions): Promise<BootstrapResult>;
 export {};

package/dist/bootstrap-session.js

@@ -4,29 +4,35 @@ function resolveTools(agentConfig, cwd) {
     return createSupportedTools(agentConfig.tools ?? SUPPORTED_TOOL_NAMES, cwd);
 }
 function resolveModel(agentConfig, ctx) {
+    const warnings = [];
     const model = ctx.model;
     if (!agentConfig.parsedModel)
-        return model;
+        return { model, warnings };
     const found = ctx.modelRegistry.find(agentConfig.parsedModel.provider, agentConfig.parsedModel.modelId);
     if (found)
-        return found;
-    console.warn(`[pi-crew] Subagent "${agentConfig.name}": model "${agentConfig.model}" not found in registry, using default`);
-    return model;
+        return { model: found, warnings };
+    warnings.push(`Model "${agentConfig.model}" not found, using current session model`);
+    return { model, warnings };
 }
-function warnUnknownSkills(agentConfig, resourceLoader) {
+function getSkillWarnings(agentConfig, resourceLoader) {
+    const warnings = [];
     if (!agentConfig.skills)
-        return;
+        return warnings;
     const availableSkillNames = new Set(resourceLoader.getSkills().skills.map((skill) => skill.name));
-    const unknownSkills = agentConfig.skills.filter((skillName) => !availableSkillNames.has(skillName));
-    if (unknownSkills.length === 0)
-        return;
-    console.warn(`[pi-crew] Subagent "${agentConfig.name}": unknown skills ${unknownSkills.map((skillName) => `"${skillName}"`).join(", ")}, ignoring`);
+    for (const skillName of agentConfig.skills) {
+        if (!availableSkillNames.has(skillName)) {
+            warnings.push(`Unknown skill "${skillName}" in subagent config, skipping`);
+        }
+    }
+    return warnings;
 }
 export async function bootstrapSession(opts) {
-    const { agentConfig, cwd, ctx, extensionResolvedPath, parentSessionFile } = opts;
+    const warnings = [];
+    const { agentConfig, cwd, ctx, extensionResolvedPath } = opts;
     const authStorage = ctx.modelRegistry.authStorage;
     const modelRegistry = ctx.modelRegistry;
-    const model = resolveModel(agentConfig, ctx);
+    const { model, warnings: modelWarnings } = resolveModel(agentConfig, ctx);
+    warnings.push(...modelWarnings);
     const tools = resolveTools(agentConfig, cwd);
     const resourceLoader = new DefaultResourceLoader({
         cwd,
@@ -40,16 +46,18 @@ export async function bootstrapSession(opts) {
                 diagnostics: base.diagnostics,
             })
             : undefined,
-        appendSystemPromptOverride: (base) => agentConfig.systemPrompt.trim() ? [...base, agentConfig.systemPrompt] : base,
+        appendSystemPromptOverride: (base) => agentConfig.systemPrompt.trim()
+            ? [...base, agentConfig.systemPrompt]
+            : base,
     });
     await resourceLoader.reload();
-    warnUnknownSkills(agentConfig, resourceLoader);
+    warnings.push(...getSkillWarnings(agentConfig, resourceLoader));
     const settingsManager = SettingsManager.inMemory({
         compaction: { enabled: agentConfig.compaction ?? true },
     });
     const sessionManager = SessionManager.create(cwd);
-    sessionManager.newSession({ parentSession: parentSessionFile });
-    return createAgentSession({
+    sessionManager.newSession({ parentSession: ctx.parentSessionFile });
+    const result = await createAgentSession({
         cwd,
         model,
         thinkingLevel: agentConfig.thinking,
@@ -60,4 +68,5 @@ export async function bootstrapSession(opts) {
         authStorage,
         modelRegistry,
     });
+    return { session: result.session, warnings };
 }

package/dist/index.js

@@ -1,18 +1,33 @@
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { discoverAgents } from "./agent-discovery.js";
-import { CrewManager } from "./crew-manager.js";
+import { crewRuntime, } from "./runtime/crew-runtime.js";
 import { registerCrewIntegration } from "./integration.js";
 import { formatAgentsForPrompt } from "./prompt-injection.js";
 import { updateWidget } from "./status-widget.js";
 const extensionDir = dirname(fileURLToPath(import.meta.url));
+// Process-level cleanup for subagents on exit
+let processHooksSetup = false;
+function setupProcessHooks() {
+    if (processHooksSetup)
+        return;
+    processHooksSetup = true;
+    const abortAndExit = (signal) => {
+        crewRuntime.abortAll();
+        // Re-raise to restore default Node termination behavior
+        process.exit(128 + (signal === 'SIGINT' ? 2 : 15));
+    };
+    process.once('SIGINT', () => abortAndExit('SIGINT'));
+    process.once('SIGTERM', () => abortAndExit('SIGTERM'));
+    process.on('beforeExit', () => crewRuntime.abortAll());
+}
 export default function (pi) {
-    const crewManager = new CrewManager(extensionDir);
     let currentCtx;
     let cachedPromptSuffix = "";
+    setupProcessHooks();
     const refreshWidget = () => {
         if (currentCtx)
-            updateWidget(currentCtx, crewManager);
+            updateWidget(currentCtx, crewRuntime);
     };
     const rebuildPromptCache = (cwd) => {
         const { agents } = discoverAgents(cwd);
@@ -20,18 +35,31 @@ export default function (pi) {
     };
     const activateSession = (ctx) => {
         currentCtx = ctx;
-        crewManager.activateSession(ctx.sessionManager.getSessionId(), () => ctx.isIdle(), pi);
+        crewRuntime.activateSession({
+            sessionId: ctx.sessionManager.getSessionId(),
+            isIdle: () => ctx.isIdle(),
+            sendMessage: pi.sendMessage.bind(pi),
+        }, refreshWidget);
         refreshWidget();
     };
-    crewManager.onWidgetUpdate = refreshWidget;
     pi.on("session_start", (_event, ctx) => {
         rebuildPromptCache(ctx.cwd);
         activateSession(ctx);
     });
-    pi.on("session_switch", (_event, ctx) => activateSession(ctx));
-    pi.on("session_fork", (_event, ctx) => activateSession(ctx));
+    pi.on("session_before_switch", () => {
+        // Session is about to switch - no action needed here.
+        // Subagent cleanup is handled by process hooks, not session_shutdown.
+    });
+    pi.on("session_before_fork", () => {
+        // Session is about to fork - no action needed here.
+        // Subagent cleanup is handled by process hooks, not session_shutdown.
+    });
     pi.on("session_shutdown", (_event, ctx) => {
-        crewManager.abortForOwner(ctx.sessionManager.getSessionId(), pi);
+        const sessionId = ctx.sessionManager.getSessionId();
+        // Deactivate delivery to this session, but don't abort subagents.
+        // Subagents continue running and will complete normally.
+        // Real cleanup happens in process exit hooks.
+        crewRuntime.deactivateSession(sessionId);
     });
     pi.on("before_agent_start", (event) => {
         if (!cachedPromptSuffix)
@@ -45,5 +73,5 @@ export default function (pi) {
         const after = event.systemPrompt.slice(idx);
         return { systemPrompt: before + cachedPromptSuffix + after };
     });
-    registerCrewIntegration(pi, crewManager);
+    registerCrewIntegration(pi, crewRuntime, extensionDir);
 }

package/dist/integration/register-command.d.ts

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

package/dist/integration/register-command.js

@@ -1,8 +1,8 @@
-export function registerCrewCommand(pi, crewManager) {
+export function registerCrewCommand(pi, crew) {
     pi.registerCommand("pi-crew-abort", {
         description: "Abort an active subagent",
         getArgumentCompletions(argumentPrefix) {
-            const activeAgents = crewManager.getAbortableAgents();
+            const activeAgents = crew.getAbortableAgents();
             if (activeAgents.length === 0)
                 return null;
             return activeAgents
@@ -15,7 +15,7 @@ export function registerCrewCommand(pi, crewManager) {
         async handler(args, ctx) {
             const trimmed = args.trim();
             if (trimmed) {
-                const success = crewManager.abort(trimmed, pi, { reason: "Aborted by user command" });
+                const success = crew.abort(trimmed, { reason: "Aborted by user command" });
                 if (!success) {
                     ctx.ui.notify(`No active subagent with id "${trimmed}"`, "error");
                 }
@@ -24,7 +24,7 @@ export function registerCrewCommand(pi, crewManager) {
                 }
                 return;
             }
-            const activeAgents = crewManager.getAbortableAgents();
+            const activeAgents = crew.getAbortableAgents();
             if (activeAgents.length === 0) {
                 ctx.ui.notify("No active subagents", "info");
                 return;
@@ -39,7 +39,7 @@ export function registerCrewCommand(pi, crewManager) {
             const selectedOption = options.find((option) => option.label === selected);
             if (!selectedOption)
                 return;
-            const success = crewManager.abort(selectedOption.id, pi, { reason: "Aborted by user command" });
+            const success = crew.abort(selectedOption.id, { reason: "Aborted by user command" });
             if (success) {
                 ctx.ui.notify(`Subagent ${selectedOption.id} aborted`, "info");
             }

package/dist/integration/register-renderers.js

@@ -26,6 +26,9 @@ export function registerCrewMessageRenderers(pi) {
         const body = details?.body ?? (!details && message.content ? String(message.content) : undefined);
         const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
         box.addChild(new Text(header, 0, 0));
+        if (details?.sessionFile) {
+            box.addChild(new Text(theme.fg("muted", `📁 ${details.sessionFile}`), 0, 0));
+        }
         if (body) {
             if (expanded) {
                 box.addChild(new Text("", 0, 0));

package/dist/integration/register-tools.d.ts

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

package/dist/integration/register-tools.js

@@ -3,7 +3,7 @@ import { registerCrewDoneTool } from "./tools/crew-done.js";
 import { registerCrewListTool } from "./tools/crew-list.js";
 import { registerCrewRespondTool } from "./tools/crew-respond.js";
 import { registerCrewSpawnTool } from "./tools/crew-spawn.js";
-export function registerCrewTools(pi, crewManager) {
+export function registerCrewTools(pi, crew, extensionDir) {
     const shownDiscoveryWarnings = new Set();
     const notifyDiscoveryWarnings = (ctx, warnings) => {
         if (!ctx.hasUI)
@@ -16,7 +16,7 @@ export function registerCrewTools(pi, crewManager) {
             ctx.ui.notify(`${warning.message} (${warning.filePath})`, "error");
         }
     };
-    const deps = { pi, crewManager, notifyDiscoveryWarnings };
+    const deps = { pi, crew, extensionDir, notifyDiscoveryWarnings };
     registerCrewListTool(deps);
     registerCrewSpawnTool(deps);
     registerCrewAbortTool(deps);

package/dist/integration/tool-presentation.d.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
+import { Box, Text } from "@mariozechner/pi-tui";
 export type ToolTheme = Parameters<Exclude<Parameters<ExtensionAPI["registerTool"]>[0]["renderCall"], undefined>>[1];
 export type ToolResult = {
     content: {
@@ -25,6 +25,5 @@ export declare function toolSuccess(text: string, details?: Record<string, unkno
     }[];
     details: Record<string, unknown>;
 };
-export declare function truncatePreview(text: string, max: number): string;
-export declare function renderCrewCall(theme: ToolTheme, name: string, id: string, preview?: string): Text;
+export declare function renderCrewCall(theme: ToolTheme, name: string, id: string, preview?: string): Box;
 export declare function renderCrewResult(result: ToolResult, theme: ToolTheme): Text;

package/dist/integration/tool-presentation.js

@@ -1,4 +1,4 @@
-import { Text } from "@mariozechner/pi-tui";
+import { Box, Text } from "@mariozechner/pi-tui";
 export function toolError(text) {
     return {
         content: [{ type: "text", text }],
@@ -12,14 +12,13 @@ export function toolSuccess(text, details = {}) {
         details,
     };
 }
-export function truncatePreview(text, max) {
-    return text.length > max ? `${text.slice(0, max)}...` : text;
-}
 export function renderCrewCall(theme, name, id, preview) {
-    let text = theme.fg("toolTitle", theme.bold(`${name} `)) + theme.fg("accent", id);
-    if (preview)
-        text += theme.fg("dim", ` "${preview}"`);
-    return new Text(text, 0, 0);
+    const box = new Box(1, 1);
+    box.addChild(new Text(theme.fg("toolTitle", theme.bold(`${name} `)) + theme.fg("accent", id), 0, 0));
+    if (preview) {
+        box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+    }
+    return box;
 }
 export function renderCrewResult(result, theme) {
     const text = result.content[0];

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

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

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

@@ -13,7 +13,7 @@ function formatAbortToolMessage(result) {
     }
     return parts.join("\n");
 }
-export function registerCrewAbortTool({ pi, crewManager }) {
+export function registerCrewAbortTool({ pi, crew }) {
     pi.registerTool({
         name: "crew_abort",
         label: "Abort Crew",
@@ -38,7 +38,7 @@ export function registerCrewAbortTool({ pi, crewManager }) {
                 return toolError("Provide exactly one of: subagent_id, subagent_ids, or all=true.");
             }
             if (params.all) {
-                const abortedIds = crewManager.abortAllOwned(callerSessionId, pi, {
+                const abortedIds = crew.abortAllOwned(callerSessionId, {
                     reason: "Aborted by tool request",
                 });
                 if (abortedIds.length === 0) {
@@ -49,7 +49,7 @@ export function registerCrewAbortTool({ pi, crewManager }) {
             const ids = params.subagent_id
                 ? [params.subagent_id]
                 : (params.subagent_ids ?? []);
-            const result = crewManager.abortOwned(ids, callerSessionId, pi, {
+            const result = crew.abortOwned(ids, callerSessionId, {
                 reason: "Aborted by tool request",
             });
             const message = formatAbortToolMessage(result);

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

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

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

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import { renderCrewCall, renderCrewResult, toolError, toolSuccess, } from "../tool-presentation.js";
-export function registerCrewDoneTool({ pi, crewManager }) {
+export function registerCrewDoneTool({ pi, crew }) {
     pi.registerTool({
         name: "crew_done",
         label: "Done with Crew",
@@ -11,7 +11,7 @@ export function registerCrewDoneTool({ pi, crewManager }) {
         promptSnippet: "Close an interactive subagent session when done.",
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const callerSessionId = ctx.sessionManager.getSessionId();
-            const { error } = crewManager.done(params.subagent_id, callerSessionId);
+            const { error } = crew.done(params.subagent_id, callerSessionId);
             if (error)
                 return toolError(error);
             return toolSuccess(`Subagent ${params.subagent_id} closed.`, {

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

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

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