@melihmucuk/pi-crew 1.0.13 → 1.0.15

package/extension/integration/tools/crew-spawn.ts

@@ -0,0 +1,87 @@
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+import { discoverAgents } from "../../agent-discovery.js";
+import {
+	renderCrewCall,
+	renderCrewResult,
+	toolError,
+	toolSuccess,
+} from "../tool-presentation.js";
+import type { CrewToolDeps } from "./tool-deps.js";
+
+export function registerCrewSpawnTool({
+	pi,
+	crew,
+	extensionDir,
+	notifyDiscoveryWarnings,
+}: CrewToolDeps): void {
+	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.",
+		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: [
+			"crew_spawn: Spawn a discovered subagent for one clearly delegated, self-contained task.",
+			"crew_spawn: Include only needed context: constraints, relevant files, acceptance criteria, and expected output.",
+			"crew_spawn: After spawning, ownership transfers to the subagent; do not work on that task yourself.",
+			"crew_spawn: Results arrive as steering messages; do not poll crew_list or fabricate results.",
+			"crew_spawn: Use the bundled pi-crew skill for detailed delegation patterns.",
+		],
+
+		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 = crew.spawn(
+				subagent,
+				params.task,
+				ctx.cwd,
+				ownerSessionId,
+				{
+					model: ctx.model,
+					modelRegistry: ctx.modelRegistry,
+					agentDir: getAgentDir(),
+					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) {
+			return renderCrewCall(
+				theme,
+				"crew_spawn",
+				args.subagent || "...",
+				args.task,
+			);
+		},
+
+		renderResult(result, _options, theme, _context) {
+			return renderCrewResult(result, theme);
+		},
+	});
+}

package/extension/integration/tools/tool-deps.ts

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

package/extension/integration.ts

@@ -0,0 +1,13 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { CrewRuntime } from "./runtime/crew-runtime.js";
+import { registerCrewMessageRenderers } from "./integration/register-renderers.js";
+import { registerCrewTools } from "./integration/register-tools.js";
+
+export function registerCrewIntegration(
+	pi: ExtensionAPI,
+	crew: CrewRuntime,
+	extensionDir: string,
+): void {
+	registerCrewTools(pi, crew, extensionDir);
+	registerCrewMessageRenderers(pi);
+}

package/extension/runtime/crew-runtime.ts

@@ -0,0 +1,426 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { Api, AssistantMessage, Model } from "@mariozechner/pi-ai";
+import type { AgentSession, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import type { AgentConfig } from "../agent-discovery.js";
+import type { BootstrapContext } from "../bootstrap-session.js";
+import { bootstrapSession } from "../bootstrap-session.js";
+import type { SubagentStatus } from "../subagent-messages.js";
+import { type ActiveRuntimeBinding, DeliveryCoordinator } from "./delivery-coordinator.js";
+import { runPromptWithOverflowRecovery } from "./overflow-recovery.js";
+import { SubagentRegistry } from "./subagent-registry.js";
+import {
+	type ActiveAgentSummary,
+	type SubagentState,
+	isAbortableStatus,
+	isAborted,
+} from "./subagent-state.js";
+
+export type {
+	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;
+	agentDir: string;
+	parentSessionFile?: string;
+	onWarning?: (message: string) => void;
+}
+
+function toBootstrapContext(ctx: SpawnContext): BootstrapContext {
+	return {
+		model: ctx.model,
+		modelRegistry: ctx.modelRegistry,
+		agentDir: ctx.agentDir,
+		parentSessionFile: ctx.parentSessionFile,
+	};
+}
+
+interface PromptOutcome {
+	status: Extract<SubagentStatus, "done" | "waiting" | "error" | "aborted">;
+	result?: string;
+	error?: string;
+}
+
+function getLastAssistantMessage(
+	messages: AgentMessage[],
+): AssistantMessage | undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "assistant") {
+			return msg as AssistantMessage;
+		}
+	}
+	return undefined;
+}
+
+function getAssistantText(
+	message: AssistantMessage | undefined,
+): string | undefined {
+	if (!message) return undefined;
+
+	const texts: string[] = [];
+	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: SubagentState): PromptOutcome {
+	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)",
+	};
+}
+
+/**
+ * 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 {
+	private readonly registry = new SubagentRegistry();
+	private readonly delivery = new DeliveryCoordinator();
+
+	// Per-session refresh callbacks, keyed by ownerSessionId
+	private readonly refreshCallbacks = new Map<string, () => void>();
+
+	private refreshWidgetFor(sessionId: string): void {
+		this.refreshCallbacks.get(sessionId)?.();
+	}
+
+	activateSession(
+		binding: ActiveRuntimeBinding,
+		refreshWidget?: () => void,
+	): void {
+		if (refreshWidget) {
+			this.refreshCallbacks.set(binding.sessionId, refreshWidget);
+		}
+		this.delivery.activateSession(
+			binding,
+			(ownerSessionId, excludeId) =>
+				this.registry.countRunningForOwner(ownerSessionId, excludeId),
+		);
+		refreshWidget?.();
+	}
+
+	deactivateSession(sessionId: string): void {
+		this.delivery.deactivateSession(sessionId);
+		this.refreshCallbacks.delete(sessionId);
+	}
+
+	spawn(
+		agentConfig: AgentConfig,
+		task: string,
+		cwd: string,
+		ownerSessionId: string,
+		ctx: SpawnContext,
+		extensionResolvedPath: string,
+	): string {
+		const state = this.registry.create(agentConfig, task, ownerSessionId);
+		this.refreshWidgetFor(ownerSessionId);
+		void this.spawnSession(
+			state,
+			cwd,
+			ctx,
+			extensionResolvedPath,
+		);
+		return state.id;
+	}
+
+	private attachSessionListeners(
+		state: SubagentState,
+		session: AgentSession,
+	): void {
+		state.unsubscribe = session.subscribe((event) => {
+			if (event.type !== "turn_end") return;
+
+			state.turns++;
+			const msg = event.message;
+			if (msg.role === "assistant") {
+				const assistantMsg = msg as AssistantMessage;
+				state.contextTokens = assistantMsg.usage.totalTokens;
+				state.model = assistantMsg.model;
+			}
+			this.refreshWidgetFor(state.ownerSessionId);
+		});
+	}
+
+	private attachSpawnedSession(
+		state: SubagentState,
+		session: AgentSession,
+	): boolean {
+		if (!this.registry.hasState(state)) {
+			session.dispose();
+			return false;
+		}
+
+		state.session = session;
+		return true;
+	}
+
+	private settleAgent(
+		state: SubagentState,
+		nextStatus: SubagentStatus,
+		opts: { result?: string; error?: string },
+	): void {
+		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,
+			},
+			(ownerSessionId, excludeId) =>
+				this.registry.countRunningForOwner(ownerSessionId, excludeId),
+		);
+
+		if (state.status !== "waiting") {
+			this.disposeAgent(state);
+		} else {
+			this.refreshWidgetFor(state.ownerSessionId);
+		}
+	}
+
+	private disposeAgent(state: SubagentState): void {
+		state.unsubscribe?.();
+		state.promptAbortController = undefined;
+		state.session?.dispose();
+		this.registry.delete(state.id);
+		this.refreshWidgetFor(state.ownerSessionId);
+	}
+
+	private async runPromptCycle(
+		state: SubagentState,
+		prompt: string,
+	): Promise<void> {
+		if (isAborted(state)) return;
+
+		const abortController = new AbortController();
+		state.promptAbortController = abortController;
+
+		try {
+			const recovery = await runPromptWithOverflowRecovery(
+				state.session!,
+				prompt,
+				abortController.signal,
+			);
+			if (isAborted(state)) return;
+
+			const outcome = getPromptOutcome(state);
+
+			if (recovery === "failed" && outcome.status !== "error") {
+				this.settleAgent(state, "error", {
+					error: "Context overflow recovery failed",
+				});
+				return;
+			}
+
+			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 });
+		} finally {
+			state.promptAbortController = undefined;
+		}
+	}
+
+	private async spawnSession(
+		state: SubagentState,
+		cwd: string,
+		ctx: SpawnContext,
+		extensionResolvedPath: string,
+	): Promise<void> {
+		try {
+			if (isAborted(state)) return;
+
+			const { session, warnings } = await bootstrapSession({
+				agentConfig: state.agentConfig,
+				cwd,
+				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);
+		} catch (err) {
+			if (isAborted(state)) return;
+
+			if (state.status === "running") {
+				const error = err instanceof Error ? err.message : String(err);
+				this.settleAgent(state, "error", { error });
+			}
+		}
+	}
+
+	respond(
+		id: string,
+		message: string,
+		callerSessionId: string,
+	): { error?: string } {
+		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.refreshWidgetFor(state.ownerSessionId);
+		void this.runPromptCycle(state, message);
+		return {};
+	}
+
+	done(id: string, callerSessionId: string): { error?: string } {
+		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: string, opts: AbortOptions): boolean {
+		const state = this.registry.get(id);
+		if (!state || !isAbortableStatus(state.status)) return false;
+
+		state.promptAbortController?.abort();
+		state.promptAbortController = undefined;
+		state.session?.abortCompaction();
+		state.session?.abortRetry();
+		state.session?.abort().catch(() => {});
+		this.settleAgent(state, "aborted", { error: opts.reason });
+		return true;
+	}
+
+	abortOwned(
+		ids: string[],
+		callerSessionId: string,
+		opts: AbortOptions,
+	): AbortOwnedResult {
+		const uniqueIds = Array.from(
+			new Set(ids.map((id) => id.trim()).filter(Boolean)),
+		);
+		const result: AbortOwnedResult = {
+			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, opts)) {
+				result.abortedIds.push(id);
+			} else {
+				result.missingIds.push(id);
+			}
+		}
+
+		return result;
+	}
+
+	abortAllOwned(
+		callerSessionId: string,
+		opts: AbortOptions,
+	): string[] {
+		const ids = this.registry.getOwnedAbortableIds(callerSessionId);
+
+		for (const id of ids) {
+			this.abort(id, opts);
+		}
+
+		return ids;
+	}
+
+	/**
+	 * Abort all abortable subagents during shutdown cleanup.
+	 * Called from SIGINT, session_shutdown(reason="quit"), and beforeExit fallback paths.
+	 */
+	abortAll(): void {
+		const allAgents = this.registry.getAllAbortable();
+		for (const state of allAgents) {
+			this.abort(state.id, { reason: "Aborted during shutdown" });
+		}
+	}
+
+	getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[] {
+		return this.registry.getActiveSummariesForOwner(ownerSessionId);
+	}
+}
+
+const crewRuntimeKey = Symbol.for("pi-crew.runtime");
+const globalWithCrewRuntime = globalThis as typeof globalThis & Record<
+	symbol,
+	CrewRuntime | undefined
+>;
+
+export const crewRuntime = globalWithCrewRuntime[crewRuntimeKey] ??= new CrewRuntime();
+export type { CrewRuntime };

package/extension/runtime/delivery-coordinator.ts

@@ -0,0 +1,131 @@
+import {
+	type SteeringPayload,
+	sendRemainingNote,
+	sendSteeringMessage,
+	type SendMessageFn,
+} from "../subagent-messages.js";
+
+export interface ActiveRuntimeBinding {
+	sessionId: string;
+	isIdle: () => boolean;
+	sendMessage: SendMessageFn;
+}
+
+interface PendingMessage {
+	ownerSessionId: string;
+	payload: SteeringPayload;
+	queuedAt: number;
+}
+
+export class DeliveryCoordinator {
+	private binding: ActiveRuntimeBinding | undefined;
+	private pendingMessages: PendingMessage[] = [];
+	private flushScheduled = false;
+
+	activateSession(
+		binding: ActiveRuntimeBinding,
+		countRunningForOwner: (ownerSessionId: string, excludeId: string) => number,
+	): void {
+		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 === binding.sessionId)) {
+			this.flushScheduled = true;
+			setTimeout(() => {
+				this.flushScheduled = false;
+				this.flushPending(countRunningForOwner);
+			}, 0);
+		}
+	}
+
+	deactivateSession(sessionId: string): void {
+		if (this.binding?.sessionId === sessionId) {
+			this.binding = undefined;
+		}
+	}
+
+	deliver(
+		ownerSessionId: string,
+		payload: SteeringPayload,
+		countRunningForOwner: (ownerSessionId: string, excludeId: string) => number,
+	): void {
+		if (!this.binding || ownerSessionId !== this.binding.sessionId || this.flushScheduled) {
+			this.pendingMessages.push({ ownerSessionId, payload, queuedAt: Date.now() });
+			return;
+		}
+
+		this.send(ownerSessionId, payload, countRunningForOwner);
+	}
+
+	/**
+	 * Remove pending messages older than the TTL.
+	 * Called during activateSession to prevent unbounded memory growth.
+	 */
+	private cleanStaleMessages(): void {
+		const maxAgeMs = 86_400_000; // 24 hours
+		const cutoff = Date.now() - maxAgeMs;
+		this.pendingMessages = this.pendingMessages.filter(
+			(entry) => entry.queuedAt >= cutoff,
+		);
+	}
+
+	private flushPending(
+		countRunningForOwner: (ownerSessionId: string, excludeId: string) => number,
+	): void {
+		if (!this.binding) return;
+		const targetSessionId = this.binding.sessionId;
+
+		// Clean up stale messages first (older than TTL)
+		this.cleanStaleMessages();
+
+		const toDeliver: PendingMessage[] = [];
+		const remaining: PendingMessage[] = [];
+
+		for (const entry of this.pendingMessages) {
+			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, 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.
+	 */
+	private send(
+		ownerSessionId: string,
+		payload: SteeringPayload,
+		countRunningForOwner: (ownerSessionId: string, excludeId: string) => number,
+	): void {
+		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.binding.isIdle();
+		const triggerResultTurn = !(isIdle && remaining > 0);
+
+		sendSteeringMessage(payload, this.binding.sendMessage, {
+			isIdle,
+			triggerTurn: triggerResultTurn,
+		});
+		sendRemainingNote(remaining, this.binding.sendMessage, {
+			isIdle,
+			triggerTurn: isIdle && remaining > 0,
+		});
+	}
+}