@melihmucuk/pi-crew 1.0.15 → 1.0.17

package/extension/runtime/{delivery-coordinator.ts → owner-session-coordinator.ts}

@@ -1,8 +1,8 @@
+import type { SendMessageFn } from "../message-delivery-policy.js";
 import {
 	type SteeringPayload,
 	sendRemainingNote,
 	sendSteeringMessage,
-	type SendMessageFn,
 } from "../subagent-messages.js";
 
 export interface ActiveRuntimeBinding {
@@ -17,25 +17,43 @@ interface PendingMessage {
 	queuedAt: number;
 }
 
-export class DeliveryCoordinator {
+interface OwnerSessionCoordinatorDeps {
+	countRunningForOwner: (ownerSessionId: string, excludeId: string) => number;
+	onRefreshOwnerSession: (ownerSessionId: string) => void;
+	now?: () => number;
+	scheduleFlush?: (callback: () => void) => void;
+}
+
+const PENDING_MESSAGE_TTL_MS = 86_400_000;
+
+export class OwnerSessionCoordinator {
 	private binding: ActiveRuntimeBinding | undefined;
 	private pendingMessages: PendingMessage[] = [];
 	private flushScheduled = false;
+	private readonly countRunningForOwner: (ownerSessionId: string, excludeId: string) => number;
+	private readonly onRefreshOwnerSession: (ownerSessionId: string) => void;
+	private readonly now: () => number;
+	private readonly scheduleFlush: (callback: () => void) => void;
+
+	constructor(deps: OwnerSessionCoordinatorDeps) {
+		this.countRunningForOwner = deps.countRunningForOwner;
+		this.onRefreshOwnerSession = deps.onRefreshOwnerSession;
+		this.now = deps.now ?? Date.now;
+		this.scheduleFlush = deps.scheduleFlush ?? ((callback) => setTimeout(callback, 0));
+	}
 
-	activateSession(
-		binding: ActiveRuntimeBinding,
-		countRunningForOwner: (ownerSessionId: string, excludeId: string) => number,
-	): void {
+	activateSession(binding: ActiveRuntimeBinding): 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.scheduleFlush(() => {
 				this.flushScheduled = false;
-				this.flushPending(countRunningForOwner);
-			}, 0);
+				this.flushPending();
+			});
 		}
 	}
 
@@ -45,38 +63,34 @@ export class DeliveryCoordinator {
 		}
 	}
 
-	deliver(
-		ownerSessionId: string,
-		payload: SteeringPayload,
-		countRunningForOwner: (ownerSessionId: string, excludeId: string) => number,
-	): void {
+	refresh(ownerSessionId: string): void {
+		this.onRefreshOwnerSession(ownerSessionId);
+	}
+
+	deliver(ownerSessionId: string, payload: SteeringPayload): void {
 		if (!this.binding || ownerSessionId !== this.binding.sessionId || this.flushScheduled) {
-			this.pendingMessages.push({ ownerSessionId, payload, queuedAt: Date.now() });
+			this.queue(ownerSessionId, payload);
 			return;
 		}
 
-		this.send(ownerSessionId, payload, countRunningForOwner);
+		this.send(ownerSessionId, payload);
+	}
+
+	private queue(ownerSessionId: string, payload: SteeringPayload): void {
+		this.pendingMessages.push({ ownerSessionId, payload, queuedAt: this.now() });
 	}
 
-	/**
-	 * 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;
+		const cutoff = this.now() - PENDING_MESSAGE_TTL_MS;
 		this.pendingMessages = this.pendingMessages.filter(
 			(entry) => entry.queuedAt >= cutoff,
 		);
 	}
 
-	private flushPending(
-		countRunningForOwner: (ownerSessionId: string, excludeId: string) => number,
-	): void {
+	private flushPending(): void {
 		if (!this.binding) return;
 		const targetSessionId = this.binding.sessionId;
 
-		// Clean up stale messages first (older than TTL)
 		this.cleanStaleMessages();
 
 		const toDeliver: PendingMessage[] = [];
@@ -86,17 +100,14 @@ export class DeliveryCoordinator {
 			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);
+			this.send(entry.ownerSessionId, entry.payload);
 		}
 	}
 
@@ -105,17 +116,13 @@ export class DeliveryCoordinator {
 	 * 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 {
+	private send(ownerSessionId: string, payload: SteeringPayload): void {
 		if (!this.binding || this.binding.sessionId !== ownerSessionId) {
-			this.pendingMessages.push({ ownerSessionId, payload, queuedAt: Date.now() });
+			this.queue(ownerSessionId, payload);
 			return;
 		}
 
-		const remaining = countRunningForOwner(ownerSessionId, payload.id);
+		const remaining = this.countRunningForOwner(ownerSessionId, payload.id);
 		const isIdle = this.binding.isIdle();
 		const triggerResultTurn = !(isIdle && remaining > 0);
 

package/extension/runtime/subagent-lifecycle.ts

@@ -0,0 +1,203 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { BootstrapContext } from "../bootstrap-session.js";
+import { bootstrapSession } from "../bootstrap-session.js";
+import type { SubagentStatus } from "../subagent-messages.js";
+import { runPromptWithOverflowRecovery } from "./overflow-recovery.js";
+import type { SubagentState } from "./subagent-registry.js";
+import { isAborted } from "./subagent-transitions.js";
+
+interface PromptOutcome {
+	status: Extract<SubagentStatus, "done" | "waiting" | "error" | "aborted">;
+	result?: string;
+	error?: string;
+}
+
+interface StartOptions {
+	cwd: string;
+	ctx: BootstrapContext;
+	extensionResolvedPath: string;
+	onWarning?: (message: string) => void;
+}
+
+interface SubagentLifecycleCallbacks {
+	isCurrent: (state: SubagentState) => boolean;
+	onProgress: (ownerSessionId: string) => void;
+	onSettled: (
+		state: SubagentState,
+		status: Extract<SubagentStatus, "done" | "waiting" | "error" | "aborted">,
+		outcome: { result?: string; error?: string },
+	) => void;
+}
+
+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)",
+	};
+}
+
+export class SubagentLifecycle {
+	constructor(private readonly callbacks: SubagentLifecycleCallbacks) {}
+
+	start(state: SubagentState, opts: StartOptions): void {
+		void this.spawnSession(state, opts);
+	}
+
+	respond(state: SubagentState, message: string): void {
+		void this.runPromptCycle(state, message);
+	}
+
+	abortPrompt(state: SubagentState): void {
+		state.promptAbortController?.abort();
+		state.promptAbortController = undefined;
+		state.session?.abortCompaction();
+		state.session?.abortRetry();
+		state.session?.abort().catch(() => {});
+	}
+
+	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.callbacks.onProgress(state.ownerSessionId);
+		});
+	}
+
+	private attachSpawnedSession(
+		state: SubagentState,
+		session: AgentSession,
+	): boolean {
+		if (!this.callbacks.isCurrent(state)) {
+			session.dispose();
+			return false;
+		}
+
+		state.session = session;
+		return true;
+	}
+
+	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.callbacks.onSettled(state, "error", {
+					error: "Context overflow recovery failed",
+				});
+				return;
+			}
+
+			this.callbacks.onSettled(state, outcome.status, outcome);
+		} catch (err) {
+			if (isAborted(state)) return;
+
+			const error = err instanceof Error ? err.message : String(err);
+			this.callbacks.onSettled(state, "error", { error });
+		} finally {
+			state.promptAbortController = undefined;
+		}
+	}
+
+	private async spawnSession(
+		state: SubagentState,
+		opts: StartOptions,
+	): Promise<void> {
+		try {
+			if (isAborted(state)) return;
+
+			const { session, warnings } = await bootstrapSession({
+				agentConfig: state.agentConfig,
+				cwd: opts.cwd,
+				ctx: opts.ctx,
+				extensionResolvedPath: opts.extensionResolvedPath,
+			});
+
+			for (const warning of warnings) {
+				opts.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.callbacks.onSettled(state, "error", { error });
+			}
+		}
+	}
+}

package/extension/runtime/subagent-registry.ts

@@ -1,10 +1,54 @@
+import { randomBytes } from "node:crypto";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import type { AgentConfig } from "../agent-discovery.js";
-import type { ActiveAgentSummary, SubagentState } from "./subagent-state.js";
-import {
-	buildActiveAgentSummary,
-	generateId,
-	isAbortableStatus,
-} from "./subagent-state.js";
+import type { SubagentStatus } from "../subagent-messages.js";
+import { isAbortableStatus } from "./subagent-transitions.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;
+	promptAbortController?: AbortController;
+	unsubscribe?: () => void;
+}
+
+export interface ActiveAgentSummary {
+	id: string;
+	agentName: string;
+	status: SubagentStatus;
+	turns: number;
+	contextTokens: number;
+	model: string | undefined;
+}
+
+function generateId(name: string, existingIds: Set<string>): string {
+	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")}`;
+}
+
+function buildActiveAgentSummary(
+	state: SubagentState,
+): ActiveAgentSummary {
+	return {
+		id: state.id,
+		agentName: state.agentConfig.name,
+		status: state.status,
+		turns: state.turns,
+		contextTokens: state.contextTokens,
+		model: state.model,
+	};
+}
 
 export class SubagentRegistry {
 	private activeAgents = new Map<string, SubagentState>();

package/extension/runtime/subagent-transitions.ts

@@ -0,0 +1,100 @@
+import type { SubagentStatus } from "../subagent-messages.js";
+import type { SubagentState } from "./subagent-registry.js";
+
+export type SettledSubagentStatus = Extract<
+	SubagentStatus,
+	"done" | "waiting" | "error" | "aborted"
+>;
+
+export interface SubagentTransitionOutcome {
+	result?: string;
+	error?: string;
+}
+
+type SubagentTransitionResult =
+	| { ok: true; state: SubagentState }
+	| { ok: false; error: string };
+
+export function isAborted(state: SubagentState): boolean {
+	return state.status === "aborted";
+}
+
+export function isAbortableStatus(status: SubagentStatus): boolean {
+	return status === "running" || status === "waiting";
+}
+
+export function canAbortSubagent(
+	state: SubagentState | undefined,
+): state is SubagentState {
+	return Boolean(state && isAbortableStatus(state.status));
+}
+
+function validateOwnedSubagent(
+	state: SubagentState | undefined,
+	id: string,
+	callerSessionId: string,
+	missingMessage: string,
+): SubagentTransitionResult {
+	if (!state) return { ok: false, error: missingMessage };
+	if (state.ownerSessionId !== callerSessionId) {
+		return { ok: false, error: `Subagent "${id}" belongs to a different session` };
+	}
+	return { ok: true, state };
+}
+
+export function startSubagentResponse(
+	state: SubagentState | undefined,
+	id: string,
+	callerSessionId: string,
+): SubagentTransitionResult {
+	const owned = validateOwnedSubagent(
+		state,
+		id,
+		callerSessionId,
+		`No subagent with id "${id}"`,
+	);
+	if (!owned.ok) return owned;
+
+	if (owned.state.status !== "waiting") {
+		return {
+			ok: false,
+			error: `Subagent "${id}" is not waiting for a response (status: ${owned.state.status})`,
+		};
+	}
+	if (!owned.state.session) {
+		return { ok: false, error: `Subagent "${id}" has no active session` };
+	}
+
+	owned.state.status = "running";
+	return owned;
+}
+
+export function validateSubagentDone(
+	state: SubagentState | undefined,
+	id: string,
+	callerSessionId: string,
+): SubagentTransitionResult {
+	const owned = validateOwnedSubagent(
+		state,
+		id,
+		callerSessionId,
+		`No active subagent with id "${id}"`,
+	);
+	if (!owned.ok) return owned;
+
+	if (owned.state.status !== "waiting") {
+		return { ok: false, error: `Subagent "${id}" is not in waiting state` };
+	}
+
+	return owned;
+}
+
+export function settleSubagent(
+	state: SubagentState,
+	status: SettledSubagentStatus,
+	outcome: SubagentTransitionOutcome,
+): void {
+	state.status = status;
+	state.result = outcome.result;
+	state.error = outcome.error;
+}

package/extension/status-widget.ts

@@ -1,5 +1,5 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import type { ActiveAgentSummary } from "./runtime/crew-runtime.js";
 import type { CrewRuntime } from "./runtime/crew-runtime.js";
 

package/extension/subagent-messages.ts

@@ -1,9 +1,8 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { sendWithDeliveryPolicy, type SendMessageFn } from "./message-delivery-policy.js";
 
+export type { SendMessageFn } from "./message-delivery-policy.js";
 export type SubagentStatus = "running" | "waiting" | "done" | "error" | "aborted";
 
-export type SendMessageFn = ExtensionAPI["sendMessage"];
-
 export const STATUS_ICON: Record<SubagentStatus, string> = {
 	running: "⏳",
 	waiting: "⏳",
@@ -79,12 +78,7 @@ export function sendSteeringMessage(
 		} satisfies CrewResultMessageDetails,
 	};
 
-	sendMessage(
-		message,
-		opts.isIdle
-			? { triggerTurn: opts.triggerTurn }
-			: { deliverAs: "steer", triggerTurn: opts.triggerTurn },
-	);
+	sendWithDeliveryPolicy(message, sendMessage, opts);
 }
 
 export function sendRemainingNote(
@@ -94,15 +88,14 @@ export function sendRemainingNote(
 ): void {
 	if (remainingCount <= 0) return;
 
-	sendMessage(
+	sendWithDeliveryPolicy(
 		{
 			customType: "crew-remaining",
 			content: `⏳ ${remainingCount} subagent(s) still running`,
 			display: true,
 		},
-		opts.isIdle
-			? { triggerTurn: opts.triggerTurn }
-			: { deliverAs: "steer", triggerTurn: opts.triggerTurn },
+		sendMessage,
+		opts,
 	);
 }
 
@@ -110,15 +103,14 @@ export function sendCrewListActiveWarning(
 	sendMessage: SendMessageFn,
 	opts: { isIdle: boolean; triggerTurn: boolean },
 ): void {
-	sendMessage(
+	sendWithDeliveryPolicy(
 		{
 			customType: "crew-list-warning",
 			content:
 				"⚠ Active subagents detected. Do not poll crew_list for completion — results arrive as steering messages. Continue with unrelated work or end your turn and wait for the steering messages.",
 			display: true,
 		},
-		opts.isIdle
-			? { triggerTurn: opts.triggerTurn }
-			: { deliverAs: "steer", triggerTurn: opts.triggerTurn },
+		sendMessage,
+		opts,
 	);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melihmucuk/pi-crew",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "type": "module",
   "description": "Non-blocking subagent orchestration for pi coding agent",
   "files": [
@@ -32,22 +32,24 @@
     "video": "https://monkeys-team.ams3.cdn.digitaloceanspaces.com/pi-crew-demo.mp4"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/**/*.test.ts"
   },
   "peerDependencies": {
-    "@mariozechner/pi-agent-core": "*",
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
   "devDependencies": {
-    "@mariozechner/pi-agent-core": "^0.73.0",
-    "@mariozechner/pi-ai": "^0.73.0",
-    "@mariozechner/pi-coding-agent": "^0.73.0",
-    "@mariozechner/pi-tui": "^0.73.0",
+    "@earendil-works/pi-agent-core": "^0.75.4",
+    "@earendil-works/pi-ai": "^0.75.4",
+    "@earendil-works/pi-coding-agent": "^0.75.4",
+    "@earendil-works/pi-tui": "^0.75.4",
     "@types/node": "^22.19.17",
-    "typebox": "^1.1.37",
+    "tsx": "^4.22.3",
+    "typebox": "^1.1.38",
     "typescript": "^5.9.3"
   }
 }