@melihmucuk/pi-crew 1.0.15 → 1.0.17

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

@@ -1,13 +1,11 @@
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { discoverAgents } from "../../agent-discovery.js";
-import { STATUS_ICON, sendCrewListActiveWarning } from "../../subagent-messages.js";
-import type { CrewToolDeps } from "./tool-deps.js";
+import type { CrewToolDeps } from "../crew-tool-executor.js";
 
 export function registerCrewListTool({
 	pi,
-	crew,
-	notifyDiscoveryWarnings,
+	actions,
+	executor,
 }: CrewToolDeps): void {
 	pi.registerTool({
 		name: "crew_list",
@@ -23,61 +21,7 @@ export function registerCrewListTool({
 		],
 
 		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-			const { agents, warnings } = discoverAgents(ctx.cwd);
-			notifyDiscoveryWarnings(ctx, warnings);
-			const callerSessionId = ctx.sessionManager.getSessionId();
-			const running = crew.getActiveSummariesForOwner(callerSessionId);
-
-			const lines: string[] = [];
-
-			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(`name: ${agent.name}`);
-					lines.push(`description: ${agent.description}`);
-					lines.push(`interactive: ${agent.interactive ? "true" : "false"}`);
-				}
-			}
-
-			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(`id: ${agent.id}`);
-					lines.push(`name: ${agent.agentName}`);
-					lines.push(`status: ${icon} ${agent.status}`);
-				}
-			}
-
-			const text = lines.join("\n");
-
-			if (running.length > 0) {
-				Promise.resolve().then(() => {
-					sendCrewListActiveWarning(pi.sendMessage.bind(pi), {
-						isIdle: ctx.isIdle(),
-						triggerTurn: true,
-					});
-				});
-			}
-
-			return { content: [{ type: "text", text }], details: {} };
+			return executor.execute(ctx, (actionCtx) => actions.list(actionCtx));
 		},
 
 		renderCall(_args, theme, _context) {

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

@@ -1,14 +1,12 @@
 import { Type } from "typebox";
+import { renderCrewCall } from "../tool-presentation.js";
 import {
-	renderCrewCall,
-	renderCrewResult,
-	toolError,
-	toolSuccess,
-} from "../tool-presentation.js";
-import type { CrewToolDeps } from "./tool-deps.js";
+	registerCrewActionTool,
+	type CrewToolDeps,
+} from "../crew-tool-executor.js";
 
-export function registerCrewRespondTool({ pi, crew }: CrewToolDeps): void {
-	pi.registerTool({
+export function registerCrewRespondTool(deps: CrewToolDeps): void {
+	registerCrewActionTool<{ subagent_id: string; message: string }>(deps, {
 		name: "crew_respond",
 		label: "Respond to Crew",
 		description:
@@ -27,22 +25,7 @@ export function registerCrewRespondTool({ pi, crew }: CrewToolDeps): void {
 			"crew_respond: Use the waiting subagent ID from crew_spawn results or crew_list.",
 			"crew_respond: The response arrives as a steering message; do not poll crew_list.",
 		],
-
-		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 },
-			);
-		},
-
+		action: (params, actionCtx) => deps.actions.respond(params, actionCtx),
 		renderCall(args, theme, _context) {
 			return renderCrewCall(
 				theme,
@@ -51,9 +34,5 @@ export function registerCrewRespondTool({ pi, crew }: CrewToolDeps): void {
 				args.message,
 			);
 		},
-
-		renderResult(result, _options, theme, _context) {
-			return renderCrewResult(result, theme);
-		},
 	});
-}
+}

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

@@ -1,21 +1,13 @@
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { discoverAgents } from "../../agent-discovery.js";
+import { renderCrewCall } from "../tool-presentation.js";
 import {
-	renderCrewCall,
-	renderCrewResult,
-	toolError,
-	toolSuccess,
-} from "../tool-presentation.js";
-import type { CrewToolDeps } from "./tool-deps.js";
+	registerCrewActionTool,
+	type CrewToolDeps,
+} from "../crew-tool-executor.js";
 
-export function registerCrewSpawnTool({
-	pi,
-	crew,
-	extensionDir,
-	notifyDiscoveryWarnings,
-}: CrewToolDeps): void {
-	pi.registerTool({
+export function registerCrewSpawnTool(deps: CrewToolDeps): void {
+	registerCrewActionTool<{ subagent: string; task: string }>(deps, {
 		name: "crew_spawn",
 		label: "Spawn Crew",
 		description:
@@ -33,44 +25,15 @@ export function registerCrewSpawnTool({
 			"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 },
-			);
-		},
-
+		action: (params, actionCtx, ctx) =>
+			deps.actions.spawn(params, {
+				...actionCtx,
+				model: ctx.model,
+				modelRegistry: ctx.modelRegistry,
+				agentDir: getAgentDir(),
+				parentSessionFile: ctx.sessionManager.getSessionFile(),
+				onWarning: (msg) => ctx.ui.notify(msg, "warning"),
+			}),
 		renderCall(args, theme, _context) {
 			return renderCrewCall(
 				theme,
@@ -79,9 +42,5 @@ export function registerCrewSpawnTool({
 				args.task,
 			);
 		},
-
-		renderResult(result, _options, theme, _context) {
-			return renderCrewResult(result, theme);
-		},
 	});
 }

package/extension/message-delivery-policy.ts

@@ -0,0 +1,22 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export type SendMessageFn = ExtensionAPI["sendMessage"];
+type Message = Parameters<SendMessageFn>[0];
+
+interface DeliveryOptions {
+	isIdle: boolean;
+	triggerTurn: boolean;
+}
+
+export function sendWithDeliveryPolicy(
+	message: Message,
+	sendMessage: SendMessageFn,
+	opts: DeliveryOptions,
+): void {
+	sendMessage(
+		message,
+		opts.isIdle
+			? { triggerTurn: opts.triggerTurn }
+			: { deliverAs: "steer", triggerTurn: opts.triggerTurn },
+	);
+}

package/extension/runtime/crew-runtime.ts

@@ -1,23 +1,25 @@
-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 { Api, Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/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 ActiveRuntimeBinding, OwnerSessionCoordinator } from "./owner-session-coordinator.js";
 import {
 	type ActiveAgentSummary,
+	SubagentRegistry,
 	type SubagentState,
-	isAbortableStatus,
-	isAborted,
-} from "./subagent-state.js";
+} from "./subagent-registry.js";
+import { SubagentLifecycle } from "./subagent-lifecycle.js";
+import {
+	type SettledSubagentStatus,
+	canAbortSubagent,
+	settleSubagent,
+	startSubagentResponse,
+	validateSubagentDone,
+} from "./subagent-transitions.js";
 
 export type {
 	ActiveAgentSummary,
-} from "./subagent-state.js";
+} from "./subagent-registry.js";
 
 export interface AbortOwnedResult {
 	abortedIds: string[];
@@ -46,63 +48,6 @@ function toBootstrapContext(ctx: SpawnContext): BootstrapContext {
 	};
 }
 
-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.
  *
@@ -113,11 +58,26 @@ function getPromptOutcome(state: SubagentState): PromptOutcome {
  */
 class CrewRuntime {
 	private readonly registry = new SubagentRegistry();
-	private readonly delivery = new DeliveryCoordinator();
+	private readonly ownerSessions: OwnerSessionCoordinator;
+	private readonly lifecycle: SubagentLifecycle;
 
 	// Per-session refresh callbacks, keyed by ownerSessionId
 	private readonly refreshCallbacks = new Map<string, () => void>();
 
+	constructor() {
+		this.ownerSessions = new OwnerSessionCoordinator({
+			countRunningForOwner: (ownerSessionId, excludeId) =>
+				this.registry.countRunningForOwner(ownerSessionId, excludeId),
+			onRefreshOwnerSession: (ownerSessionId) => this.refreshWidgetFor(ownerSessionId),
+		});
+		this.lifecycle = new SubagentLifecycle({
+			isCurrent: (state) => this.registry.hasState(state),
+			onProgress: (ownerSessionId) => this.ownerSessions.refresh(ownerSessionId),
+			onSettled: (state, status, outcome) =>
+				this.settleAgent(state, status, outcome),
+		});
+	}
+
 	private refreshWidgetFor(sessionId: string): void {
 		this.refreshCallbacks.get(sessionId)?.();
 	}
@@ -129,16 +89,12 @@ class CrewRuntime {
 		if (refreshWidget) {
 			this.refreshCallbacks.set(binding.sessionId, refreshWidget);
 		}
-		this.delivery.activateSession(
-			binding,
-			(ownerSessionId, excludeId) =>
-				this.registry.countRunningForOwner(ownerSessionId, excludeId),
-		);
+		this.ownerSessions.activateSession(binding);
 		refreshWidget?.();
 	}
 
 	deactivateSession(sessionId: string): void {
-		this.delivery.deactivateSession(sessionId);
+		this.ownerSessions.deactivateSession(sessionId);
 		this.refreshCallbacks.delete(sessionId);
 	}
 
@@ -151,57 +107,24 @@ class CrewRuntime {
 		extensionResolvedPath: string,
 	): string {
 		const state = this.registry.create(agentConfig, task, ownerSessionId);
-		this.refreshWidgetFor(ownerSessionId);
-		void this.spawnSession(
-			state,
+		this.ownerSessions.refresh(ownerSessionId);
+		this.lifecycle.start(state, {
 			cwd,
-			ctx,
+			ctx: toBootstrapContext(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);
+			onWarning: ctx.onWarning,
 		});
-	}
-
-	private attachSpawnedSession(
-		state: SubagentState,
-		session: AgentSession,
-	): boolean {
-		if (!this.registry.hasState(state)) {
-			session.dispose();
-			return false;
-		}
-
-		state.session = session;
-		return true;
+		return state.id;
 	}
 
 	private settleAgent(
 		state: SubagentState,
-		nextStatus: SubagentStatus,
+		nextStatus: SettledSubagentStatus,
 		opts: { result?: string; error?: string },
 	): void {
-		state.status = nextStatus;
-		state.result = opts.result;
-		state.error = opts.error;
+		settleSubagent(state, nextStatus, opts);
 
-		this.delivery.deliver(
+		this.ownerSessions.deliver(
 			state.ownerSessionId,
 			{
 				id: state.id,
@@ -211,14 +134,12 @@ class CrewRuntime {
 				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);
+			this.ownerSessions.refresh(state.ownerSessionId);
 		}
 	}
 
@@ -227,128 +148,44 @@ class CrewRuntime {
 		state.promptAbortController = undefined;
 		state.session?.dispose();
 		this.registry.delete(state.id);
-		this.refreshWidgetFor(state.ownerSessionId);
+		this.ownerSessions.refresh(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` };
+		const transition = startSubagentResponse(
+			this.registry.get(id),
+			id,
+			callerSessionId,
+		);
+		if (!transition.ok) return { error: transition.error };
 
-		state.status = "running";
-		this.refreshWidgetFor(state.ownerSessionId);
-		void this.runPromptCycle(state, message);
+		this.ownerSessions.refresh(transition.state.ownerSessionId);
+		this.lifecycle.respond(transition.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` };
-		}
+		const transition = validateSubagentDone(
+			this.registry.get(id),
+			id,
+			callerSessionId,
+		);
+		if (!transition.ok) return { error: transition.error };
 
-		this.disposeAgent(state);
+		this.disposeAgent(transition.state);
 		return {};
 	}
 
 	abort(id: string, opts: AbortOptions): boolean {
 		const state = this.registry.get(id);
-		if (!state || !isAbortableStatus(state.status)) return false;
+		if (!canAbortSubagent(state)) return false;
 
-		state.promptAbortController?.abort();
-		state.promptAbortController = undefined;
-		state.session?.abortCompaction();
-		state.session?.abortRetry();
-		state.session?.abort().catch(() => {});
+		this.lifecycle.abortPrompt(state);
 		this.settleAgent(state, "aborted", { error: opts.reason });
 		return true;
 	}
@@ -369,7 +206,7 @@ class CrewRuntime {
 
 		for (const id of uniqueIds) {
 			const state = this.registry.get(id);
-			if (!state || !isAbortableStatus(state.status)) {
+			if (!canAbortSubagent(state)) {
 				result.missingIds.push(id);
 				continue;
 			}

package/extension/runtime/overflow-recovery.ts

@@ -1,4 +1,4 @@
-import type { AgentSession, AgentSessionEvent } from "@mariozechner/pi-coding-agent";
+import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 
 const OVERFLOW_RECOVERY_TIMEOUT_MS = 120_000;