@melihmucuk/pi-crew 1.0.17 → 1.0.19

package/extension/runtime/overflow-recovery.ts

@@ -1,211 +0,0 @@
-import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-
-const OVERFLOW_RECOVERY_TIMEOUT_MS = 120_000;
-
-/**
- * Short grace period for the first terminal agent_end after prompt() resolves.
- * If this window expires, we still wait the full recovery timeout.
- */
-const INITIAL_AGENT_END_WAIT_MS = 5_000;
-
-type PhaseWaitResult = "done" | "timeout" | "cancelled";
-
-export type OverflowRecoveryResult = "none" | "recovered" | "failed";
-
-interface DeferredPhase {
-	promise: Promise<void>;
-	resolve: () => void;
-	isDone: () => boolean;
-}
-
-function createDeferredPhase(): DeferredPhase {
-	let done = false;
-	let resolveFn: (() => void) | undefined;
-
-	const promise = new Promise<void>((resolve) => {
-		resolveFn = () => {
-			if (done) return;
-			done = true;
-			resolve();
-		};
-	});
-
-	return {
-		promise,
-		resolve: () => resolveFn?.(),
-		isDone: () => done,
-	};
-}
-
-class OverflowRecoveryTracker {
-	private overflowDetected = false;
-	private compactionWillRetry = false;
-
-	private autoRetryActive = false;
-	private readonly initialAgentEnd = createDeferredPhase();
-	private compactionEnd: DeferredPhase | undefined;
-	private retryAgentEnd: DeferredPhase | undefined;
-	private overflowAutoRetryEnd: DeferredPhase | undefined;
-	private timers: ReturnType<typeof setTimeout>[] = [];
-
-	handleEvent(event: AgentSessionEvent): void {
-		switch (event.type) {
-			case "agent_end":
-				this.onAgentEnd();
-				break;
-			case "compaction_start":
-				this.onCompactionStart(event.reason);
-				break;
-			case "compaction_end":
-				this.onCompactionEnd(event.reason, event.willRetry);
-				break;
-			case "auto_retry_start":
-				this.onAutoRetryStart();
-				break;
-			case "auto_retry_end":
-				this.onAutoRetryEnd();
-				break;
-			default:
-				break;
-		}
-	}
-
-	async awaitCompletion(signal: AbortSignal): Promise<OverflowRecoveryResult> {
-		const cancelPromise = new Promise<void>((resolve) => {
-			if (signal.aborted) {
-				resolve();
-				return;
-			}
-			signal.addEventListener("abort", () => resolve(), { once: true });
-		});
-
-		try {
-			let initialEnd = await this.waitForPhase(
-				this.initialAgentEnd.promise,
-				INITIAL_AGENT_END_WAIT_MS,
-				cancelPromise,
-			);
-
-			if (initialEnd === "timeout") {
-				initialEnd = await this.waitForPhase(
-					this.initialAgentEnd.promise,
-					OVERFLOW_RECOVERY_TIMEOUT_MS,
-					cancelPromise,
-				);
-			}
-
-			if (initialEnd !== "done") {
-				return this.overflowDetected ? "failed" : "none";
-			}
-
-			if (!this.overflowDetected) return "none";
-
-			if (this.compactionEnd) {
-				const compactionEnd = await this.waitForPhase(
-					this.compactionEnd.promise,
-					OVERFLOW_RECOVERY_TIMEOUT_MS,
-					cancelPromise,
-				);
-				if (compactionEnd !== "done") return "failed";
-			}
-
-			if (!this.compactionWillRetry) return "failed";
-
-			if (this.retryAgentEnd) {
-				const retryEnd = await this.waitForPhase(
-					this.retryAgentEnd.promise,
-					OVERFLOW_RECOVERY_TIMEOUT_MS,
-					cancelPromise,
-				);
-				if (retryEnd !== "done") return "failed";
-			}
-
-			if (this.overflowAutoRetryEnd) {
-				const autoRetryEnd = await this.waitForPhase(
-					this.overflowAutoRetryEnd.promise,
-					OVERFLOW_RECOVERY_TIMEOUT_MS,
-					cancelPromise,
-				);
-				if (autoRetryEnd !== "done") return "failed";
-			}
-
-			return "recovered";
-		} finally {
-			for (const timer of this.timers) clearTimeout(timer);
-		}
-	}
-
-	private async waitForPhase(
-		phasePromise: Promise<void>,
-		timeoutMs: number,
-		cancelPromise: Promise<void>,
-	): Promise<PhaseWaitResult> {
-		return Promise.race([
-			phasePromise.then(() => "done" as const),
-			cancelPromise.then(() => "cancelled" as const),
-			new Promise<"timeout">((resolve) => {
-				this.timers.push(setTimeout(() => resolve("timeout"), timeoutMs));
-			}),
-		]);
-	}
-
-	// agent_end can be followed immediately by auto_retry_start in the same
-	// _processAgentEvent tick. Resolve on microtask so we can ignore retrying
-	// attempts and only accept terminal agent_end events.
-	private onAgentEnd(): void {
-		queueMicrotask(() => {
-			if (this.autoRetryActive) return;
-
-			if (!this.initialAgentEnd.isDone()) {
-				this.initialAgentEnd.resolve();
-				return;
-			}
-
-			this.retryAgentEnd?.resolve();
-		});
-	}
-
-	private onCompactionStart(reason: "manual" | "threshold" | "overflow"): void {
-		if (reason !== "overflow") return;
-		this.overflowDetected = true;
-		this.compactionEnd ??= createDeferredPhase();
-	}
-
-	private onCompactionEnd(reason: "manual" | "threshold" | "overflow", willRetry: boolean): void {
-		if (reason !== "overflow") return;
-
-		this.compactionWillRetry = willRetry;
-		if (willRetry) {
-			this.retryAgentEnd ??= createDeferredPhase();
-		}
-		this.compactionEnd?.resolve();
-	}
-
-	private onAutoRetryStart(): void {
-		this.autoRetryActive = true;
-		if (this.overflowDetected) {
-			this.overflowAutoRetryEnd ??= createDeferredPhase();
-		}
-	}
-
-	private onAutoRetryEnd(): void {
-		this.autoRetryActive = false;
-		this.overflowAutoRetryEnd?.resolve();
-	}
-}
-
-export async function runPromptWithOverflowRecovery(
-	session: AgentSession,
-	text: string,
-	signal: AbortSignal,
-): Promise<OverflowRecoveryResult> {
-	const tracker = new OverflowRecoveryTracker();
-	const unsubscribe = session.subscribe((event) => tracker.handleEvent(event));
-
-	try {
-		await session.prompt(text);
-		return await tracker.awaitCompletion(signal);
-	} finally {
-		unsubscribe();
-	}
-}

package/extension/runtime/owner-session-coordinator.ts

@@ -1,138 +0,0 @@
-import type { SendMessageFn } from "../message-delivery-policy.js";
-import {
-	type SteeringPayload,
-	sendRemainingNote,
-	sendSteeringMessage,
-} from "../subagent-messages.js";
-
-export interface ActiveRuntimeBinding {
-	sessionId: string;
-	isIdle: () => boolean;
-	sendMessage: SendMessageFn;
-}
-
-interface PendingMessage {
-	ownerSessionId: string;
-	payload: SteeringPayload;
-	queuedAt: number;
-}
-
-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): 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;
-			this.scheduleFlush(() => {
-				this.flushScheduled = false;
-				this.flushPending();
-			});
-		}
-	}
-
-	deactivateSession(sessionId: string): void {
-		if (this.binding?.sessionId === sessionId) {
-			this.binding = undefined;
-		}
-	}
-
-	refresh(ownerSessionId: string): void {
-		this.onRefreshOwnerSession(ownerSessionId);
-	}
-
-	deliver(ownerSessionId: string, payload: SteeringPayload): void {
-		if (!this.binding || ownerSessionId !== this.binding.sessionId || this.flushScheduled) {
-			this.queue(ownerSessionId, payload);
-			return;
-		}
-
-		this.send(ownerSessionId, payload);
-	}
-
-	private queue(ownerSessionId: string, payload: SteeringPayload): void {
-		this.pendingMessages.push({ ownerSessionId, payload, queuedAt: this.now() });
-	}
-
-	private cleanStaleMessages(): void {
-		const cutoff = this.now() - PENDING_MESSAGE_TTL_MS;
-		this.pendingMessages = this.pendingMessages.filter(
-			(entry) => entry.queuedAt >= cutoff,
-		);
-	}
-
-	private flushPending(): void {
-		if (!this.binding) return;
-		const targetSessionId = this.binding.sessionId;
-
-		this.cleanStaleMessages();
-
-		const toDeliver: PendingMessage[] = [];
-		const remaining: PendingMessage[] = [];
-
-		for (const entry of this.pendingMessages) {
-			if (entry.ownerSessionId === targetSessionId) {
-				toDeliver.push(entry);
-			} else {
-				remaining.push(entry);
-			}
-		}
-
-		this.pendingMessages = remaining;
-
-		for (const entry of toDeliver) {
-			this.send(entry.ownerSessionId, entry.payload);
-		}
-	}
-
-	/**
-	 * 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): void {
-		if (!this.binding || this.binding.sessionId !== ownerSessionId) {
-			this.queue(ownerSessionId, payload);
-			return;
-		}
-
-		const remaining = this.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,
-		});
-	}
-}

package/extension/runtime/subagent-lifecycle.ts

@@ -1,203 +0,0 @@
-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,122 +0,0 @@
-import { randomBytes } from "node:crypto";
-import type { AgentSession } from "@earendil-works/pi-coding-agent";
-import type { AgentConfig } from "../agent-discovery.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>();
-
-	create(agentConfig: AgentConfig, task: string, ownerSessionId: string): SubagentState {
-		const id = generateId(agentConfig.name, new Set(this.activeAgents.keys()));
-		const state: SubagentState = {
-			id,
-			agentConfig,
-			task,
-			status: "running",
-			ownerSessionId,
-			session: null,
-			turns: 0,
-			contextTokens: 0,
-			model: undefined,
-		};
-
-		this.activeAgents.set(id, state);
-		return state;
-	}
-
-	get(id: string): SubagentState | undefined {
-		return this.activeAgents.get(id);
-	}
-
-	hasState(state: SubagentState): boolean {
-		return this.activeAgents.get(state.id) === state;
-	}
-
-	delete(id: string): void {
-		this.activeAgents.delete(id);
-	}
-
-	countRunningForOwner(ownerSessionId: string, excludeId: string): number {
-		let count = 0;
-		for (const state of this.activeAgents.values()) {
-			if (
-				state.id !== excludeId &&
-				state.ownerSessionId === ownerSessionId &&
-				state.status === "running"
-			) {
-				count++;
-			}
-		}
-		return count;
-	}
-
-	getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[] {
-		return Array.from(this.activeAgents.values())
-			.filter(
-				(state) => isAbortableStatus(state.status) && state.ownerSessionId === ownerSessionId,
-			)
-			.map(buildActiveAgentSummary);
-	}
-
-	getOwnedAbortableIds(ownerSessionId: string): string[] {
-		return Array.from(this.activeAgents.values())
-			.filter(
-				(state) =>
-					state.ownerSessionId === ownerSessionId && isAbortableStatus(state.status),
-			)
-			.map((state) => state.id);
-	}
-
-	getAllAbortable(): SubagentState[] {
-		return Array.from(this.activeAgents.values()).filter((state) =>
-			isAbortableStatus(state.status),
-		);
-	}
-}