@melihmucuk/pi-crew 1.0.0

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

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

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

@@ -0,0 +1,28 @@
+import { Type } from "@sinclair/typebox";
+import { renderCrewCall, renderCrewResult, toolError, toolSuccess, } from "../tool-presentation.js";
+export function registerCrewDoneTool({ pi, crewManager }) {
+    pi.registerTool({
+        name: "crew_done",
+        label: "Done with Crew",
+        description: "Close an interactive subagent session. Use when you no longer need to interact with the subagent.",
+        parameters: Type.Object({
+            subagent_id: Type.String({ description: "ID of the subagent to close" }),
+        }),
+        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);
+            if (error)
+                return toolError(error);
+            return toolSuccess(`Subagent ${params.subagent_id} closed.`, {
+                id: params.subagent_id,
+            });
+        },
+        renderCall(args, theme, _context) {
+            return renderCrewCall(theme, "crew_done", args.subagent_id || "...");
+        },
+        renderResult(result, _options, theme, _context) {
+            return renderCrewResult(result, theme);
+        },
+    });
+}

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

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

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

@@ -0,0 +1,72 @@
+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, }) {
+    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.",
+        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 lines = [];
+            lines.push("## Available subagents");
+            if (agents.length === 0) {
+                lines.push("No valid subagent definitions found. Add `.md` files to `<cwd>/.pi/agents/` or `~/.pi/agent/agents/`.");
+            }
+            else {
+                for (const agent of agents) {
+                    lines.push("");
+                    lines.push(`**${agent.name}**`);
+                    if (agent.description)
+                        lines.push(`  ${agent.description}`);
+                    if (agent.model)
+                        lines.push(`  model: ${agent.model}`);
+                    if (agent.interactive)
+                        lines.push("  interactive: true");
+                    if (agent.tools !== undefined) {
+                        lines.push(`  tools: ${agent.tools.length > 0 ? agent.tools.join(", ") : "none"}`);
+                    }
+                    if (agent.skills !== undefined) {
+                        lines.push(`  skills: ${agent.skills.length > 0 ? agent.skills.join(", ") : "none"}`);
+                    }
+                }
+            }
+            if (warnings.length > 0) {
+                lines.push("");
+                lines.push("## Ignored subagent definitions");
+                for (const warning of warnings) {
+                    lines.push(`- ${warning.message} (${warning.filePath})`);
+                }
+            }
+            lines.push("");
+            lines.push("## Active subagents");
+            if (running.length === 0) {
+                lines.push("No subagents currently active.");
+            }
+            else {
+                for (const agent of running) {
+                    const icon = STATUS_ICON[agent.status] ?? "❓";
+                    lines.push("");
+                    lines.push(`**${agent.id}** (${agent.agentName}) — ${icon} ${agent.status}`);
+                    lines.push(`  task: ${agent.taskPreview}`);
+                    lines.push(`  turns: ${agent.turns}`);
+                }
+            }
+            const text = lines.join("\n");
+            return { content: [{ type: "text", text }], details: {} };
+        },
+        renderCall(_args, theme, _context) {
+            return new Text(theme.fg("toolTitle", theme.bold("crew_list")), 0, 0);
+        },
+        renderResult(result, _options, _theme, _context) {
+            const text = result.content[0];
+            return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+        },
+    });
+}

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

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

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

@@ -0,0 +1,30 @@
+import { Type } from "@sinclair/typebox";
+import { renderCrewCall, renderCrewResult, toolError, toolSuccess, truncatePreview, } from "../tool-presentation.js";
+export function registerCrewRespondTool({ pi, crewManager }) {
+    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.",
+        parameters: Type.Object({
+            subagent_id: Type.String({
+                description: "ID of the waiting subagent (from crew_list or crew_spawn result)",
+            }),
+            message: Type.String({ description: "Message to send to the subagent" }),
+        }),
+        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);
+            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 });
+        },
+        renderCall(args, theme, _context) {
+            const preview = args.message ? truncatePreview(args.message, 60) : "...";
+            return renderCrewCall(theme, "crew_respond", args.subagent_id || "...", preview);
+        },
+        renderResult(result, _options, theme, _context) {
+            return renderCrewResult(result, theme);
+        },
+    });
+}

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

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

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

@@ -0,0 +1,42 @@
+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, }) {
+    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 the current session stays interactive. Results are delivered back to the spawning session as steering messages when done. Use crew_list first to see available subagents.",
+        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 the current conversation. 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; continue working on other tasks.",
+            "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.",
+            "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. Wait for ALL crew-result messages.",
+        ],
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const { agents, warnings } = discoverAgents(ctx.cwd);
+            notifyDiscoveryWarnings(ctx, warnings);
+            const subagent = agents.find((candidate) => candidate.name === params.subagent);
+            if (!subagent) {
+                const available = agents.map((candidate) => candidate.name).join(", ") || "none";
+                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 });
+        },
+        renderCall(args, theme, _context) {
+            const preview = args.task ? truncatePreview(args.task, 60) : "...";
+            return renderCrewCall(theme, "crew_spawn", args.subagent || "...", preview);
+        },
+        renderResult(result, _options, theme, _context) {
+            return renderCrewResult(result, theme);
+        },
+    });
+}

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

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

package/dist/integration/tools/tool-deps.js

@@ -0,0 +1 @@
+export {};

package/dist/integration.d.ts

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

package/dist/integration.js

@@ -0,0 +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);
+    registerCrewMessageRenderers(pi);
+}

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

@@ -0,0 +1,17 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { type SteeringPayload } from "../subagent-messages.js";
+export declare class DeliveryCoordinator {
+    private currentSessionId;
+    private currentIsIdle;
+    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 flushPending;
+    /**
+     * Result messages always go first. If more subagents are still running and the
+     * owner is idle, queue the result without triggering, then queue the separate
+     * remaining note with triggerTurn so the next turn sees both in order.
+     */
+    private send;
+}

package/dist/runtime/delivery-coordinator.js

@@ -0,0 +1,60 @@
+import { sendRemainingNote, sendSteeringMessage, } from "../subagent-messages.js";
+export class DeliveryCoordinator {
+    currentSessionId;
+    currentIsIdle = () => true;
+    pendingMessages = [];
+    activateSession(sessionId, isIdle, pi, countRunningForOwner) {
+        this.currentSessionId = sessionId;
+        this.currentIsIdle = isIdle;
+        // Delay flush to next macrotask. session_switch 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);
+        }
+    }
+    deliver(ownerSessionId, payload, pi, countRunningForOwner) {
+        if (ownerSessionId !== this.currentSessionId) {
+            this.pendingMessages.push({ ownerSessionId, payload });
+            return;
+        }
+        this.send(ownerSessionId, payload, pi, countRunningForOwner);
+    }
+    clearPendingForOwner(ownerSessionId) {
+        this.pendingMessages = this.pendingMessages.filter((entry) => entry.ownerSessionId !== ownerSessionId);
+    }
+    flushPending(pi, countRunningForOwner) {
+        const toDeliver = [];
+        const remaining = [];
+        for (const entry of this.pendingMessages) {
+            if (entry.ownerSessionId === this.currentSessionId) {
+                toDeliver.push(entry);
+            }
+            else {
+                remaining.push(entry);
+            }
+        }
+        this.pendingMessages = remaining;
+        for (const entry of toDeliver) {
+            this.send(entry.ownerSessionId, entry.payload, pi, countRunningForOwner);
+        }
+    }
+    /**
+     * Result messages always go first. If more subagents are still running and the
+     * 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) {
+        const remaining = countRunningForOwner(ownerSessionId, payload.id);
+        const isIdle = this.currentIsIdle();
+        const triggerResultTurn = !(isIdle && remaining > 0);
+        sendSteeringMessage(payload, pi, {
+            isIdle,
+            triggerTurn: triggerResultTurn,
+        });
+        sendRemainingNote(remaining, pi, {
+            isIdle,
+            triggerTurn: isIdle && remaining > 0,
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { AgentConfig } from "../agent-discovery.js";
+import type { AbortableAgentSummary, ActiveAgentSummary, SubagentState } from "./subagent-state.js";
+export declare class SubagentRegistry {
+    private activeAgents;
+    create(agentConfig: AgentConfig, task: string, ownerSessionId: string): SubagentState;
+    get(id: string): SubagentState | undefined;
+    hasState(state: SubagentState): boolean;
+    delete(id: string): void;
+    countRunningForOwner(ownerSessionId: string, excludeId: string): number;
+    getAbortableAgents(): AbortableAgentSummary[];
+    getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[];
+    getOwnedAbortableIds(ownerSessionId: string): string[];
+}

package/dist/runtime/subagent-registry.js

@@ -0,0 +1,55 @@
+import { buildAbortableAgentSummary, buildActiveAgentSummary, generateId, isAbortableStatus, } from "./subagent-state.js";
+export class SubagentRegistry {
+    activeAgents = new Map();
+    create(agentConfig, task, ownerSessionId) {
+        const id = generateId(agentConfig.name, new Set(this.activeAgents.keys()));
+        const state = {
+            id,
+            agentConfig,
+            task,
+            status: "running",
+            ownerSessionId,
+            session: null,
+            turns: 0,
+            contextTokens: 0,
+            model: undefined,
+        };
+        this.activeAgents.set(id, state);
+        return state;
+    }
+    get(id) {
+        return this.activeAgents.get(id);
+    }
+    hasState(state) {
+        return this.activeAgents.get(state.id) === state;
+    }
+    delete(id) {
+        this.activeAgents.delete(id);
+    }
+    countRunningForOwner(ownerSessionId, excludeId) {
+        let count = 0;
+        for (const state of this.activeAgents.values()) {
+            if (state.id !== excludeId &&
+                state.ownerSessionId === ownerSessionId &&
+                state.status === "running") {
+                count++;
+            }
+        }
+        return count;
+    }
+    getAbortableAgents() {
+        return Array.from(this.activeAgents.values())
+            .filter((state) => isAbortableStatus(state.status))
+            .map(buildAbortableAgentSummary);
+    }
+    getActiveSummariesForOwner(ownerSessionId) {
+        return Array.from(this.activeAgents.values())
+            .filter((state) => isAbortableStatus(state.status) && state.ownerSessionId === ownerSessionId)
+            .map(buildActiveAgentSummary);
+    }
+    getOwnedAbortableIds(ownerSessionId) {
+        return Array.from(this.activeAgents.values())
+            .filter((state) => state.ownerSessionId === ownerSessionId && isAbortableStatus(state.status))
+            .map((state) => state.id);
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { AgentConfig } from "../agent-discovery.js";
+import type { SubagentStatus } from "../subagent-messages.js";
+export interface SubagentState {
+    id: string;
+    agentConfig: AgentConfig;
+    task: string;
+    status: SubagentStatus;
+    ownerSessionId: string;
+    session: AgentSession | null;
+    turns: number;
+    contextTokens: number;
+    model: string | undefined;
+    error?: string;
+    result?: string;
+}
+export interface ActiveAgentSummary {
+    id: string;
+    agentName: string;
+    status: SubagentStatus;
+    taskPreview: string;
+    turns: number;
+    contextTokens: number;
+    model: string | undefined;
+}
+export interface AbortableAgentSummary {
+    id: string;
+    agentName: string;
+}
+export declare function generateId(name: string, existingIds: Set<string>): string;
+export declare function isAborted(state: SubagentState): boolean;
+export declare function isAbortableStatus(status: SubagentStatus): boolean;
+export declare function buildActiveAgentSummary(state: SubagentState): ActiveAgentSummary;
+export declare function buildAbortableAgentSummary(state: SubagentState): AbortableAgentSummary;

package/dist/runtime/subagent-state.js

@@ -0,0 +1,34 @@
+import { randomBytes } from "node:crypto";
+export function generateId(name, existingIds) {
+    for (let i = 0; i < 10; i++) {
+        const id = `${name}-${randomBytes(4).toString("hex")}`;
+        if (!existingIds.has(id))
+            return id;
+    }
+    return `${name}-${randomBytes(8).toString("hex")}`;
+}
+// Status may change externally via abort(). Standalone function avoids TS narrowing.
+export function isAborted(state) {
+    return state.status === "aborted";
+}
+export function isAbortableStatus(status) {
+    return status === "running" || status === "waiting";
+}
+export function buildActiveAgentSummary(state) {
+    const taskPreview = state.task.length > 80 ? `${state.task.slice(0, 80)}...` : state.task;
+    return {
+        id: state.id,
+        agentName: state.agentConfig.name,
+        status: state.status,
+        taskPreview,
+        turns: state.turns,
+        contextTokens: state.contextTokens,
+        model: state.model,
+    };
+}
+export function buildAbortableAgentSummary(state) {
+    return {
+        id: state.id,
+        agentName: state.agentConfig.name,
+    };
+}

package/dist/status-widget.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { CrewManager } from "./crew-manager.js";
+export declare function updateWidget(ctx: ExtensionContext, crewManager: CrewManager): void;

package/dist/status-widget.js

@@ -0,0 +1,84 @@
+import { Text } from "@mariozechner/pi-tui";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 80;
+function formatTokens(tokens) {
+    if (tokens >= 1_000_000)
+        return `${(tokens / 1_000_000).toFixed(1)}M`;
+    if (tokens >= 1_000)
+        return `${(tokens / 1_000).toFixed(1)}k`;
+    return String(tokens);
+}
+function buildLine(agent, frame) {
+    const model = agent.model ?? "…";
+    const icon = agent.status === "waiting" ? "⏳" : frame;
+    return `${icon} ${agent.id} (${model}) · turn ${agent.turns} · ${formatTokens(agent.contextTokens)} ctx`;
+}
+let widget;
+function disposeWidget(state) {
+    clearInterval(state.timer);
+    if (widget === state) {
+        widget = undefined;
+    }
+}
+function clearWidget() {
+    const current = widget;
+    if (!current)
+        return;
+    disposeWidget(current);
+    current.ctx.ui.setWidget("crew-status", undefined);
+}
+function hasRunningAgent(agents) {
+    return agents.some((agent) => agent.status === "running");
+}
+function syncWidgetText(state, agents) {
+    const frame = SPINNER_FRAMES[state.frameIndex % SPINNER_FRAMES.length];
+    const lines = agents.map((agent) => buildLine(agent, frame));
+    state.text.setText(lines.join("\n"));
+    state.tui.requestRender();
+}
+export function updateWidget(ctx, crewManager) {
+    if (!ctx.hasUI) {
+        clearWidget();
+        return;
+    }
+    const ownerSessionId = ctx.sessionManager.getSessionId();
+    const running = crewManager.getActiveSummariesForOwner(ownerSessionId);
+    if (running.length === 0) {
+        clearWidget();
+        return;
+    }
+    if (widget && widget.ctx !== ctx) {
+        clearWidget();
+    }
+    if (widget) {
+        syncWidgetText(widget, running);
+        return;
+    }
+    ctx.ui.setWidget("crew-status", (tui, _theme) => {
+        const text = new Text("", 1, 0);
+        const state = {
+            ctx,
+            text,
+            tui,
+            frameIndex: 0,
+            timer: setInterval(() => {
+                const agents = crewManager.getActiveSummariesForOwner(ownerSessionId);
+                if (agents.length === 0) {
+                    clearWidget();
+                    return;
+                }
+                if (!hasRunningAgent(agents))
+                    return;
+                state.frameIndex++;
+                syncWidgetText(state, agents);
+            }, SPINNER_INTERVAL_MS),
+        };
+        widget = state;
+        syncWidgetText(state, running);
+        return Object.assign(text, {
+            dispose() {
+                disposeWidget(state);
+            },
+        });
+    });
+}

package/dist/subagent-messages.d.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+export type SubagentStatus = "running" | "waiting" | "done" | "error" | "aborted";
+export declare const STATUS_ICON: Record<SubagentStatus, string>;
+export declare const STATUS_LABEL: Record<SubagentStatus, string>;
+export interface SteeringPayload {
+    id: string;
+    agentName: string;
+    status: SubagentStatus;
+    result?: string;
+    error?: string;
+}
+export interface CrewResultMessageDetails {
+    agentId: string;
+    agentName: string;
+    status: SubagentStatus;
+    body?: string;
+}
+export declare function getCrewResultTitle(details: {
+    agentId: string;
+    agentName: string;
+    status: SubagentStatus;
+}): string;
+export declare function sendSteeringMessage(payload: SteeringPayload, pi: ExtensionAPI, opts: {
+    isIdle: boolean;
+    triggerTurn: boolean;
+}): void;
+export declare function sendRemainingNote(remainingCount: number, pi: ExtensionAPI, opts: {
+    isIdle: boolean;
+    triggerTurn: boolean;
+}): void;

package/dist/subagent-messages.js

@@ -0,0 +1,58 @@
+export const STATUS_ICON = {
+    running: "⏳",
+    waiting: "⏳",
+    done: "✅",
+    error: "❌",
+    aborted: "⏹️",
+};
+export const STATUS_LABEL = {
+    running: "running",
+    waiting: "waiting for response",
+    done: "done",
+    error: "failed",
+    aborted: "aborted",
+};
+export function getCrewResultTitle(details) {
+    return `Subagent '${details.agentName}' (${details.agentId}) ${STATUS_LABEL[details.status]}`;
+}
+function getSteeringBody(payload) {
+    return (payload.status === "error" || payload.status === "aborted")
+        ? (payload.error ?? payload.result)
+        : (payload.result ?? payload.error);
+}
+export function sendSteeringMessage(payload, pi, opts) {
+    const body = getSteeringBody(payload);
+    const title = getCrewResultTitle({
+        agentId: payload.id,
+        agentName: payload.agentName,
+        status: payload.status,
+    });
+    const content = body
+        ? `**${STATUS_ICON[payload.status]} ${title}**\n\n${body}`
+        : `**${STATUS_ICON[payload.status]} ${title}**`;
+    const message = {
+        customType: "crew-result",
+        content,
+        display: true,
+        details: {
+            agentId: payload.id,
+            agentName: payload.agentName,
+            status: payload.status,
+            body,
+        },
+    };
+    pi.sendMessage(message, opts.isIdle
+        ? { triggerTurn: opts.triggerTurn }
+        : { deliverAs: "steer", triggerTurn: opts.triggerTurn });
+}
+export function sendRemainingNote(remainingCount, pi, opts) {
+    if (remainingCount <= 0)
+        return;
+    pi.sendMessage({
+        customType: "crew-remaining",
+        content: `⏳ ${remainingCount} subagent(s) still running`,
+        display: true,
+    }, opts.isIdle
+        ? { triggerTurn: opts.triggerTurn }
+        : { deliverAs: "steer", triggerTurn: opts.triggerTurn });
+}