@melihmucuk/pi-crew 1.0.13 → 1.0.14

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

@@ -0,0 +1,57 @@
+import { Type } from "typebox";
+import {
+	renderCrewCall,
+	renderCrewResult,
+	toolError,
+	toolSuccess,
+} from "../tool-presentation.js";
+import type { CrewToolDeps } from "./tool-deps.js";
+
+export function registerCrewRespondTool({ pi, crew }: CrewToolDeps): void {
+	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.",
+		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.",
+		promptGuidelines: [
+			"crew_respond: Response is delivered asynchronously as a steering message. Do not poll crew_list. Continue with unrelated work or end your turn and wait for the steering message.",
+		],
+
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const callerSessionId = ctx.sessionManager.getSessionId();
+			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, message: params.message },
+			);
+		},
+
+		renderCall(args, theme, _context) {
+			return renderCrewCall(
+				theme,
+				"crew_respond",
+				args.subagent_id || "...",
+				args.message,
+			);
+		},
+
+		renderResult(result, _options, theme, _context) {
+			return renderCrewResult(result, theme);
+		},
+	});
+}

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

@@ -0,0 +1,88 @@
+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: 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 OWNERSHIP TRANSFER. Once you spawn a subagent for a task, that task is exclusively theirs. If you also work on it, you waste the subagent's effort and create conflicting results. After spawning, work on an UNRELATED task or end your turn.",
+      "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: Never use crew_list as a completion polling loop. Results arrive as steering messages. Continue with unrelated work or end your turn and wait for the steering messages.",
+      "crew_spawn: Interactive subagents stay alive after responding. Use crew_respond to continue or crew_done to close when finished.",
+    ],
+
+    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,15 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { CrewRuntime } from "./runtime/crew-runtime.js";
+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: ExtensionAPI,
+	crew: CrewRuntime,
+	extensionDir: string,
+): void {
+	registerCrewTools(pi, crew, extensionDir);
+	registerCrewCommand(pi, crew);
+	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 AbortableAgentSummary,
+	type ActiveAgentSummary,
+	type SubagentState,
+	isAbortableStatus,
+	isAborted,
+} 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;
+	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 running subagents during shutdown cleanup.
+	 * Called from SIGINT, session_shutdown(reason="quit"), and beforeExit fallback paths.
+	 */
+	abortAll(): void {
+		const allAgents = this.registry.getAllRunning();
+		for (const state of allAgents) {
+			this.abort(state.id, { reason: "Aborted during shutdown" });
+		}
+	}
+
+	getAbortableAgents(): AbortableAgentSummary[] {
+		return this.registry.getAbortableAgents();
+	}
+
+	getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[] {
+		return this.registry.getActiveSummariesForOwner(ownerSessionId);
+	}
+}
+
+export const crewRuntime = new CrewRuntime();
+export type { CrewRuntime };