@melihmucuk/pi-crew 1.0.0

package/dist/bootstrap-session.d.ts

@@ -0,0 +1,11 @@
+import { type CreateAgentSessionResult, type ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AgentConfig } from "./agent-discovery.js";
+interface BootstrapOptions {
+    agentConfig: AgentConfig;
+    cwd: string;
+    ctx: ExtensionContext;
+    extensionResolvedPath: string;
+    parentSessionFile?: string;
+}
+export declare function bootstrapSession(opts: BootstrapOptions): Promise<CreateAgentSessionResult>;
+export {};

package/dist/bootstrap-session.js

@@ -0,0 +1,63 @@
+import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
+import { createSupportedTools, SUPPORTED_TOOL_NAMES } from "./tool-registry.js";
+function resolveTools(agentConfig, cwd) {
+    return createSupportedTools(agentConfig.tools ?? SUPPORTED_TOOL_NAMES, cwd);
+}
+function resolveModel(agentConfig, ctx) {
+    const model = ctx.model;
+    if (!agentConfig.parsedModel)
+        return model;
+    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;
+}
+function warnUnknownSkills(agentConfig, resourceLoader) {
+    if (!agentConfig.skills)
+        return;
+    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`);
+}
+export async function bootstrapSession(opts) {
+    const { agentConfig, cwd, ctx, extensionResolvedPath, parentSessionFile } = opts;
+    const authStorage = ctx.modelRegistry.authStorage;
+    const modelRegistry = ctx.modelRegistry;
+    const model = resolveModel(agentConfig, ctx);
+    const tools = resolveTools(agentConfig, cwd);
+    const resourceLoader = new DefaultResourceLoader({
+        cwd,
+        extensionsOverride: (base) => ({
+            ...base,
+            extensions: base.extensions.filter((ext) => !ext.resolvedPath.startsWith(extensionResolvedPath)),
+        }),
+        skillsOverride: agentConfig.skills
+            ? (base) => ({
+                skills: base.skills.filter((skill) => agentConfig.skills.includes(skill.name)),
+                diagnostics: base.diagnostics,
+            })
+            : undefined,
+        appendSystemPromptOverride: (base) => agentConfig.systemPrompt.trim() ? [...base, agentConfig.systemPrompt] : base,
+    });
+    await resourceLoader.reload();
+    warnUnknownSkills(agentConfig, resourceLoader);
+    const settingsManager = SettingsManager.inMemory({
+        compaction: { enabled: agentConfig.compaction ?? true },
+    });
+    const sessionManager = SessionManager.create(cwd);
+    sessionManager.newSession({ parentSession: parentSessionFile });
+    return createAgentSession({
+        cwd,
+        model,
+        thinkingLevel: agentConfig.thinking,
+        tools,
+        resourceLoader,
+        sessionManager,
+        settingsManager,
+        authStorage,
+        modelRegistry,
+    });
+}

package/dist/crew-manager.d.ts

@@ -0,0 +1,43 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AgentConfig } from "./agent-discovery.js";
+import { type AbortableAgentSummary, type ActiveAgentSummary } from "./runtime/subagent-state.js";
+export type { AbortableAgentSummary, ActiveAgentSummary } from "./runtime/subagent-state.js";
+export interface AbortOwnedResult {
+    abortedIds: string[];
+    missingIds: string[];
+    foreignIds: string[];
+}
+interface AbortOptions {
+    reason: string;
+}
+export declare class CrewManager {
+    private extensionResolvedPath;
+    private registry;
+    private delivery;
+    onWidgetUpdate: (() => void) | undefined;
+    constructor(extensionResolvedPath: string);
+    activateSession(sessionId: string, isIdle: () => boolean, pi: ExtensionAPI): void;
+    spawn(agentConfig: AgentConfig, task: string, cwd: string, ownerSessionId: string, ctx: ExtensionContext, pi: ExtensionAPI): string;
+    private attachSessionListeners;
+    private attachSpawnedSession;
+    /**
+     * Single owner for post-prompt and terminal state transitions.
+     * Publishes the outcome, updates state, and disposes finished subagents.
+     */
+    private settleAgent;
+    private disposeAgent;
+    private runPromptCycle;
+    private spawnSession;
+    respond(id: string, message: string, pi: ExtensionAPI, callerSessionId: string): {
+        error?: string;
+    };
+    done(id: string, callerSessionId: string): {
+        error?: string;
+    };
+    abort(id: string, pi: ExtensionAPI, opts: AbortOptions): boolean;
+    abortOwned(ids: string[], callerSessionId: string, pi: ExtensionAPI, opts: AbortOptions): AbortOwnedResult;
+    abortAllOwned(callerSessionId: string, pi: ExtensionAPI, opts: AbortOptions): string[];
+    abortForOwner(ownerSessionId: string, pi: ExtensionAPI): void;
+    getAbortableAgents(): AbortableAgentSummary[];
+    getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[];
+}

package/dist/crew-manager.js

@@ -0,0 +1,235 @@
+import { bootstrapSession } from "./bootstrap-session.js";
+import { DeliveryCoordinator } from "./runtime/delivery-coordinator.js";
+import { SubagentRegistry } from "./runtime/subagent-registry.js";
+import { isAbortableStatus, isAborted, } from "./runtime/subagent-state.js";
+function getLastAssistantMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "assistant") {
+            return msg;
+        }
+    }
+    return undefined;
+}
+function getAssistantText(message) {
+    if (!message)
+        return undefined;
+    const texts = [];
+    for (const part of message.content) {
+        if (part.type === "text") {
+            texts.push(part.text);
+        }
+    }
+    return texts.length > 0 ? texts.join("\n") : undefined;
+}
+function getPromptOutcome(state) {
+    const lastAssistant = getLastAssistantMessage(state.session.messages);
+    const text = getAssistantText(lastAssistant);
+    if (lastAssistant?.stopReason === "error") {
+        return {
+            status: "error",
+            error: lastAssistant.errorMessage ?? text ?? "(no output)",
+        };
+    }
+    if (lastAssistant?.stopReason === "aborted") {
+        return {
+            status: "aborted",
+            error: lastAssistant.errorMessage ?? text ?? "(no output)",
+        };
+    }
+    return {
+        status: state.agentConfig.interactive ? "waiting" : "done",
+        result: text ?? "(no output)",
+    };
+}
+export class CrewManager {
+    extensionResolvedPath;
+    registry = new SubagentRegistry();
+    delivery = new DeliveryCoordinator();
+    onWidgetUpdate;
+    constructor(extensionResolvedPath) {
+        this.extensionResolvedPath = extensionResolvedPath;
+    }
+    activateSession(sessionId, isIdle, pi) {
+        this.delivery.activateSession(sessionId, isIdle, pi, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
+    }
+    spawn(agentConfig, task, cwd, ownerSessionId, ctx, pi) {
+        const state = this.registry.create(agentConfig, task, ownerSessionId);
+        this.onWidgetUpdate?.();
+        void this.spawnSession(state, cwd, ctx.sessionManager.getSessionFile(), ctx, pi);
+        return state.id;
+    }
+    attachSessionListeners(state, session) {
+        session.subscribe((event) => {
+            if (event.type !== "turn_end")
+                return;
+            state.turns++;
+            const msg = event.message;
+            if (msg.role === "assistant") {
+                const assistantMsg = msg;
+                state.contextTokens = assistantMsg.usage.totalTokens;
+                state.model = assistantMsg.model;
+            }
+            this.onWidgetUpdate?.();
+        });
+    }
+    attachSpawnedSession(state, session) {
+        if (!this.registry.hasState(state)) {
+            session.dispose();
+            return false;
+        }
+        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) {
+        state.status = nextStatus;
+        state.result = opts.result;
+        state.error = opts.error;
+        this.delivery.deliver(state.ownerSessionId, {
+            id: state.id,
+            agentName: state.agentConfig.name,
+            status: state.status,
+            result: state.result,
+            error: state.error,
+        }, pi, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
+        if (state.status !== "waiting") {
+            this.disposeAgent(state);
+        }
+        else {
+            this.onWidgetUpdate?.();
+        }
+    }
+    disposeAgent(state) {
+        state.session?.dispose();
+        this.registry.delete(state.id);
+        this.onWidgetUpdate?.();
+    }
+    async runPromptCycle(state, prompt, pi) {
+        if (isAborted(state))
+            return;
+        try {
+            await state.session.prompt(prompt);
+            if (isAborted(state))
+                return;
+            const outcome = getPromptOutcome(state);
+            this.settleAgent(state, outcome.status, outcome, pi);
+        }
+        catch (err) {
+            if (isAborted(state))
+                return;
+            const error = err instanceof Error ? err.message : String(err);
+            this.settleAgent(state, "error", { error }, pi);
+        }
+    }
+    async spawnSession(state, cwd, parentSessionFile, ctx, pi) {
+        try {
+            if (isAborted(state))
+                return;
+            const { session } = await bootstrapSession({
+                agentConfig: state.agentConfig,
+                cwd,
+                ctx,
+                extensionResolvedPath: this.extensionResolvedPath,
+                parentSessionFile,
+            });
+            if (!this.attachSpawnedSession(state, session))
+                return;
+            this.attachSessionListeners(state, session);
+            await this.runPromptCycle(state, state.task, pi);
+        }
+        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);
+            }
+        }
+    }
+    respond(id, message, pi, callerSessionId) {
+        const state = this.registry.get(id);
+        if (!state)
+            return { error: `No subagent with id "${id}"` };
+        if (state.ownerSessionId !== callerSessionId) {
+            return { error: `Subagent "${id}" belongs to a different session` };
+        }
+        if (state.status !== "waiting") {
+            return { error: `Subagent "${id}" is not waiting for a response (status: ${state.status})` };
+        }
+        if (!state.session)
+            return { error: `Subagent "${id}" has no active session` };
+        state.status = "running";
+        this.onWidgetUpdate?.();
+        void this.runPromptCycle(state, message, pi);
+        return {};
+    }
+    done(id, callerSessionId) {
+        const state = this.registry.get(id);
+        if (!state)
+            return { error: `No active subagent with id "${id}"` };
+        if (state.ownerSessionId !== callerSessionId) {
+            return { error: `Subagent "${id}" belongs to a different session` };
+        }
+        if (state.status !== "waiting") {
+            return { error: `Subagent "${id}" is not in waiting state` };
+        }
+        this.disposeAgent(state);
+        return {};
+    }
+    abort(id, pi, opts) {
+        const state = this.registry.get(id);
+        if (!state || !isAbortableStatus(state.status))
+            return false;
+        state.session?.abort().catch(() => { });
+        this.settleAgent(state, "aborted", { error: opts.reason }, pi);
+        return true;
+    }
+    abortOwned(ids, callerSessionId, pi, opts) {
+        const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+        const result = {
+            abortedIds: [],
+            missingIds: [],
+            foreignIds: [],
+        };
+        for (const id of uniqueIds) {
+            const state = this.registry.get(id);
+            if (!state || !isAbortableStatus(state.status)) {
+                result.missingIds.push(id);
+                continue;
+            }
+            if (state.ownerSessionId !== callerSessionId) {
+                result.foreignIds.push(id);
+                continue;
+            }
+            if (this.abort(id, pi, opts)) {
+                result.abortedIds.push(id);
+            }
+            else {
+                result.missingIds.push(id);
+            }
+        }
+        return result;
+    }
+    abortAllOwned(callerSessionId, pi, opts) {
+        const ids = this.registry.getOwnedAbortableIds(callerSessionId);
+        for (const id of ids) {
+            this.abort(id, pi, opts);
+        }
+        return ids;
+    }
+    abortForOwner(ownerSessionId, pi) {
+        this.abortAllOwned(ownerSessionId, pi, { reason: "Aborted on session shutdown" });
+        this.delivery.clearPendingForOwner(ownerSessionId);
+    }
+    getAbortableAgents() {
+        return this.registry.getAbortableAgents();
+    }
+    getActiveSummariesForOwner(ownerSessionId) {
+        return this.registry.getActiveSummariesForOwner(ownerSessionId);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+export default function (pi: ExtensionAPI): void;

package/dist/index.js

@@ -0,0 +1,27 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CrewManager } from "./crew-manager.js";
+import { registerCrewIntegration } from "./integration.js";
+import { updateWidget } from "./status-widget.js";
+const extensionDir = dirname(fileURLToPath(import.meta.url));
+export default function (pi) {
+    const crewManager = new CrewManager(extensionDir);
+    let currentCtx;
+    const refreshWidget = () => {
+        if (currentCtx)
+            updateWidget(currentCtx, crewManager);
+    };
+    const activateSession = (ctx) => {
+        currentCtx = ctx;
+        crewManager.activateSession(ctx.sessionManager.getSessionId(), () => ctx.isIdle(), pi);
+        refreshWidget();
+    };
+    crewManager.onWidgetUpdate = refreshWidget;
+    pi.on("session_start", (_event, ctx) => activateSession(ctx));
+    pi.on("session_switch", (_event, ctx) => activateSession(ctx));
+    pi.on("session_fork", (_event, ctx) => activateSession(ctx));
+    pi.on("session_shutdown", (_event, ctx) => {
+        crewManager.abortForOwner(ctx.sessionManager.getSessionId(), pi);
+    });
+    registerCrewIntegration(pi, crewManager);
+}

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

@@ -0,0 +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;

package/dist/integration/register-command.js

@@ -0,0 +1,51 @@
+export function registerCrewCommand(pi, crewManager) {
+    pi.registerCommand("pi-crew:abort", {
+        description: "Abort an active subagent",
+        getArgumentCompletions(argumentPrefix) {
+            const activeAgents = crewManager.getAbortableAgents();
+            if (activeAgents.length === 0)
+                return null;
+            return activeAgents
+                .filter((agent) => agent.id.startsWith(argumentPrefix))
+                .map((agent) => ({
+                value: agent.id,
+                label: `${agent.id} (${agent.agentName})`,
+            }));
+        },
+        async handler(args, ctx) {
+            const trimmed = args.trim();
+            if (trimmed) {
+                const success = crewManager.abort(trimmed, pi, { reason: "Aborted by user command" });
+                if (!success) {
+                    ctx.ui.notify(`No active subagent with id "${trimmed}"`, "error");
+                }
+                else {
+                    ctx.ui.notify(`Subagent ${trimmed} aborted`, "info");
+                }
+                return;
+            }
+            const activeAgents = crewManager.getAbortableAgents();
+            if (activeAgents.length === 0) {
+                ctx.ui.notify("No active subagents", "info");
+                return;
+            }
+            const options = activeAgents.map((agent) => ({
+                id: agent.id,
+                label: `${agent.id} (${agent.agentName})`,
+            }));
+            const selected = await ctx.ui.select("Select subagent to abort", options.map((option) => option.label));
+            if (!selected)
+                return;
+            const selectedOption = options.find((option) => option.label === selected);
+            if (!selectedOption)
+                return;
+            const success = crewManager.abort(selectedOption.id, pi, { reason: "Aborted by user command" });
+            if (success) {
+                ctx.ui.notify(`Subagent ${selectedOption.id} aborted`, "info");
+            }
+            else {
+                ctx.ui.notify(`Subagent ${selectedOption.id} already finished`, "error");
+            }
+        },
+    });
+}

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

@@ -0,0 +1,2 @@
+import { type ExtensionAPI } from "@mariozechner/pi-coding-agent";
+export declare function registerCrewMessageRenderers(pi: ExtensionAPI): void;

package/dist/integration/register-renderers.js

@@ -0,0 +1,50 @@
+import { getMarkdownTheme, } from "@mariozechner/pi-coding-agent";
+import { Box, Markdown, Text } from "@mariozechner/pi-tui";
+import { STATUS_ICON, getCrewResultTitle, } from "../subagent-messages.js";
+function getStatusColor(status) {
+    switch (status) {
+        case "done":
+            return "success";
+        case "error":
+        case "aborted":
+            return "error";
+        case "running":
+        case "waiting":
+            return "warning";
+        default:
+            return "muted";
+    }
+}
+export function registerCrewMessageRenderers(pi) {
+    pi.registerMessageRenderer("crew-result", (message, { expanded }, theme) => {
+        const details = message.details;
+        const title = details ? getCrewResultTitle(details) : "Subagent update";
+        const icon = details
+            ? theme.fg(getStatusColor(details.status), STATUS_ICON[details.status])
+            : theme.fg("muted", "ℹ");
+        const header = `${icon} ${theme.fg("toolTitle", theme.bold(title))}`;
+        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 (body) {
+            if (expanded) {
+                box.addChild(new Text("", 0, 0));
+                box.addChild(new Markdown(body, 0, 0, getMarkdownTheme()));
+            }
+            else {
+                const lines = body.split("\n");
+                const preview = lines.slice(0, 5).join("\n");
+                box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+                if (lines.length > 5) {
+                    box.addChild(new Text(theme.fg("muted", "(Ctrl+O to expand)"), 0, 0));
+                }
+            }
+        }
+        return box;
+    });
+    pi.registerMessageRenderer("crew-remaining", (message, _options, theme) => {
+        const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+        box.addChild(new Text(theme.fg("warning", String(message.content ?? "")), 0, 0));
+        return box;
+    });
+}

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

@@ -0,0 +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;

package/dist/integration/register-tools.js

@@ -0,0 +1,25 @@
+import { registerCrewAbortTool } from "./tools/crew-abort.js";
+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) {
+    const shownDiscoveryWarnings = new Set();
+    const notifyDiscoveryWarnings = (ctx, warnings) => {
+        if (!ctx.hasUI)
+            return;
+        for (const warning of warnings) {
+            const key = `${warning.filePath}:${warning.message}`;
+            if (shownDiscoveryWarnings.has(key))
+                continue;
+            shownDiscoveryWarnings.add(key);
+            ctx.ui.notify(`${warning.message} (${warning.filePath})`, "error");
+        }
+    };
+    const deps = { pi, crewManager, notifyDiscoveryWarnings };
+    registerCrewListTool(deps);
+    registerCrewSpawnTool(deps);
+    registerCrewAbortTool(deps);
+    registerCrewRespondTool(deps);
+    registerCrewDoneTool(deps);
+}

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

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+export type ToolTheme = Parameters<Exclude<Parameters<ExtensionAPI["registerTool"]>[0]["renderCall"], undefined>>[1];
+export type ToolResult = {
+    content: {
+        type: string;
+        text?: string;
+    }[];
+    details: unknown;
+};
+export declare function toolError(text: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+    details: {
+        error: boolean;
+    };
+};
+export declare function toolSuccess(text: string, details?: Record<string, unknown>): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    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 renderCrewResult(result: ToolResult, theme: ToolTheme): Text;

package/dist/integration/tool-presentation.js

@@ -0,0 +1,29 @@
+import { Text } from "@mariozechner/pi-tui";
+export function toolError(text) {
+    return {
+        content: [{ type: "text", text }],
+        isError: true,
+        details: { error: true },
+    };
+}
+export function toolSuccess(text, details = {}) {
+    return {
+        content: [{ type: "text", text }],
+        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);
+}
+export function renderCrewResult(result, theme) {
+    const text = result.content[0];
+    const details = result.details;
+    const content = text?.type === "text" && text.text ? text.text : "(no output)";
+    return new Text(details?.error ? theme.fg("error", content) : theme.fg("success", content), 0, 0);
+}

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

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

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

@@ -0,0 +1,79 @@
+import { Type } from "@sinclair/typebox";
+import { renderCrewCall, renderCrewResult, toolError, toolSuccess, } from "../tool-presentation.js";
+function formatAbortToolMessage(result) {
+    const parts = [];
+    if (result.abortedIds.length > 0) {
+        parts.push(`Aborted ${result.abortedIds.length} subagent(s): ${result.abortedIds.join(", ")}`);
+    }
+    if (result.missingIds.length > 0) {
+        parts.push(`Not found or already finished: ${result.missingIds.join(", ")}`);
+    }
+    if (result.foreignIds.length > 0) {
+        parts.push(`Belong to a different session: ${result.foreignIds.join(", ")}`);
+    }
+    return parts.join("\n");
+}
+export function registerCrewAbortTool({ pi, crewManager }) {
+    pi.registerTool({
+        name: "crew_abort",
+        label: "Abort Crew",
+        description: "Abort one, many, or all active subagents owned by the current session.",
+        parameters: Type.Object({
+            subagent_id: Type.Optional(Type.String({ description: "Single subagent ID to abort" })),
+            subagent_ids: Type.Optional(Type.Array(Type.String(), {
+                minItems: 1,
+                description: "Multiple subagent IDs to abort",
+            })),
+            all: Type.Optional(Type.Boolean({
+                description: "Abort all active subagents owned by the current session",
+            })),
+        }),
+        promptSnippet: "Abort one, many, or all active subagents from this session.",
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const callerSessionId = ctx.sessionManager.getSessionId();
+            const modeCount = Number(Boolean(params.subagent_id))
+                + Number(Boolean(params.subagent_ids?.length))
+                + Number(params.all === true);
+            if (modeCount !== 1) {
+                return toolError("Provide exactly one of: subagent_id, subagent_ids, or all=true.");
+            }
+            if (params.all) {
+                const abortedIds = crewManager.abortAllOwned(callerSessionId, pi, {
+                    reason: "Aborted by tool request",
+                });
+                if (abortedIds.length === 0) {
+                    return toolError("No active subagents in the current session.");
+                }
+                return toolSuccess(`Aborted ${abortedIds.length} subagent(s): ${abortedIds.join(", ")}`, { ids: abortedIds });
+            }
+            const ids = params.subagent_id
+                ? [params.subagent_id]
+                : (params.subagent_ids ?? []);
+            const result = crewManager.abortOwned(ids, callerSessionId, pi, {
+                reason: "Aborted by tool request",
+            });
+            const message = formatAbortToolMessage(result);
+            if (result.abortedIds.length === 0) {
+                return toolError(message || "No subagents were aborted.");
+            }
+            return toolSuccess(message, {
+                ids: result.abortedIds,
+                missing_ids: result.missingIds,
+                foreign_ids: result.foreignIds,
+            });
+        },
+        renderCall(args, theme, _context) {
+            if (args.all) {
+                return renderCrewCall(theme, "crew_abort", "all");
+            }
+            if (args.subagent_id) {
+                return renderCrewCall(theme, "crew_abort", args.subagent_id);
+            }
+            const count = Array.isArray(args.subagent_ids) ? args.subagent_ids.length : 0;
+            return renderCrewCall(theme, "crew_abort", `${count} ids`);
+        },
+        renderResult(result, _options, theme, _context) {
+            return renderCrewResult(result, theme);
+        },
+    });
+}