@melihmucuk/pi-crew 1.0.17 → 1.0.18

package/extension/crew.ts

@@ -0,0 +1,383 @@
+import { randomBytes } from "node:crypto";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { AgentSession, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { AgentConfig } from "./catalog.js";
+import type { BootstrapContext, SubagentRunner, SubagentRunnerCallbacks } from "./subagent-session.js";
+import { SubagentSessionRunner } from "./subagent-session.js";
+import {
+	type SendMessageFn,
+	type SteeringPayload,
+	type SubagentStatus,
+	sendRemainingNote,
+	sendSteeringMessage,
+} from "./ui.js";
+
+export interface ActiveRuntimeBinding {
+	sessionId: string;
+	isIdle: () => boolean;
+	sendMessage: SendMessageFn;
+}
+
+interface PendingMessage {
+	ownerSessionId: string;
+	payload: SteeringPayload;
+	queuedAt: number;
+}
+
+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;
+}
+
+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;
+}
+
+type SettledSubagentStatus = Extract<SubagentStatus, "done" | "waiting" | "error" | "aborted">;
+
+const PENDING_MESSAGE_TTL_MS = 86_400_000;
+
+function toBootstrapContext(ctx: SpawnContext): BootstrapContext {
+	return {
+		model: ctx.model,
+		modelRegistry: ctx.modelRegistry,
+		agentDir: ctx.agentDir,
+		parentSessionFile: ctx.parentSessionFile,
+	};
+}
+
+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 isAbortableStatus(status: SubagentStatus): boolean {
+	return status === "running" || status === "waiting";
+}
+
+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,
+	};
+}
+
+/**
+ * Process-global coordinator for subagent state, ownership, delivery, and cleanup.
+ */
+export class CrewRuntime {
+	private readonly agents = new Map<string, SubagentState>();
+	private readonly runner: SubagentRunner;
+	private readonly refreshCallbacks = new Map<string, () => void>();
+	private activeBinding: ActiveRuntimeBinding | undefined;
+	private pendingMessages: PendingMessage[] = [];
+	private flushScheduled = false;
+	private readonly now: () => number;
+	private readonly scheduleFlush: (callback: () => void) => void;
+
+	constructor(opts: {
+		now?: () => number;
+		scheduleFlush?: (callback: () => void) => void;
+		createRunner?: (callbacks: SubagentRunnerCallbacks) => SubagentRunner;
+	} = {}) {
+		this.now = opts.now ?? Date.now;
+		this.scheduleFlush = opts.scheduleFlush ?? ((callback) => setTimeout(callback, 0));
+		const callbacks: SubagentRunnerCallbacks = {
+			isCurrent: (state) => this.agents.get(state.id) === state,
+			onProgress: (ownerSessionId) => this.refreshWidgetFor(ownerSessionId),
+			onSettled: (state, status, outcome) => this.settleAgent(state, status, outcome),
+		};
+		this.runner = opts.createRunner?.(callbacks) ?? new SubagentSessionRunner(callbacks);
+	}
+
+	activateSession(binding: ActiveRuntimeBinding, refreshWidget?: () => void): void {
+		if (refreshWidget) this.refreshCallbacks.set(binding.sessionId, refreshWidget);
+		this.activeBinding = binding;
+		this.schedulePendingFlushFor(binding.sessionId);
+		refreshWidget?.();
+	}
+
+	deactivateSession(sessionId: string): void {
+		if (this.activeBinding?.sessionId === sessionId) this.activeBinding = undefined;
+		this.refreshCallbacks.delete(sessionId);
+	}
+
+	spawn(
+		agentConfig: AgentConfig,
+		task: string,
+		cwd: string,
+		ownerSessionId: string,
+		ctx: SpawnContext,
+		extensionResolvedPath: string,
+	): string {
+		const state = this.createAgent(agentConfig, task, ownerSessionId);
+		this.refreshWidgetFor(ownerSessionId);
+		this.runner.start(state, {
+			cwd,
+			ctx: toBootstrapContext(ctx),
+			extensionResolvedPath,
+			onWarning: ctx.onWarning,
+		});
+		return state.id;
+	}
+
+	respond(id: string, message: string, callerSessionId: string): { error?: string } {
+		const transition = this.startSubagentResponse(id, callerSessionId);
+		if (!transition.ok) return { error: transition.error };
+
+		this.refreshWidgetFor(transition.state.ownerSessionId);
+		this.runner.respond(transition.state, message);
+		return {};
+	}
+
+	done(id: string, callerSessionId: string): { error?: string } {
+		const transition = this.validateSubagentDone(id, callerSessionId);
+		if (!transition.ok) return { error: transition.error };
+
+		this.disposeAgent(transition.state);
+		return {};
+	}
+
+	abort(id: string, opts: AbortOptions): boolean {
+		const state = this.agents.get(id);
+		if (!state || !isAbortableStatus(state.status)) return false;
+
+		this.runner.abort(state);
+		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.agents.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 = Array.from(this.agents.values())
+			.filter((state) => state.ownerSessionId === callerSessionId && isAbortableStatus(state.status))
+			.map((state) => state.id);
+		for (const id of ids) this.abort(id, opts);
+		return ids;
+	}
+
+	abortAll(): void {
+		const allAgents = Array.from(this.agents.values()).filter((state) => isAbortableStatus(state.status));
+		for (const state of allAgents) this.abort(state.id, { reason: "Aborted during shutdown" });
+	}
+
+	getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[] {
+		return Array.from(this.agents.values())
+			.filter((state) => isAbortableStatus(state.status) && state.ownerSessionId === ownerSessionId)
+			.map(buildActiveAgentSummary);
+	}
+
+	private createAgent(agentConfig: AgentConfig, task: string, ownerSessionId: string): SubagentState {
+		const id = generateId(agentConfig.name, new Set(this.agents.keys()));
+		const state: SubagentState = {
+			id,
+			agentConfig,
+			task,
+			status: "running",
+			ownerSessionId,
+			session: null,
+			turns: 0,
+			contextTokens: 0,
+			model: undefined,
+		};
+		this.agents.set(id, state);
+		return state;
+	}
+
+	private refreshWidgetFor(sessionId: string): void {
+		this.refreshCallbacks.get(sessionId)?.();
+	}
+
+	private settleAgent(state: SubagentState, nextStatus: SettledSubagentStatus, opts: { result?: string; error?: string }): void {
+		if (this.agents.get(state.id) !== state) return;
+
+		state.status = nextStatus;
+		state.result = opts.result;
+		state.error = opts.error;
+
+		this.deliver(state.ownerSessionId, {
+			id: state.id,
+			agentName: state.agentConfig.name,
+			sessionFile: state.session?.sessionFile,
+			status: state.status,
+			result: state.result,
+			error: state.error,
+		});
+
+		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.agents.delete(state.id);
+		this.refreshWidgetFor(state.ownerSessionId);
+	}
+
+	private validateOwnedSubagent(
+		id: string,
+		callerSessionId: string,
+		missingMessage: string,
+	): { ok: true; state: SubagentState } | { ok: false; error: string } {
+		const state = this.agents.get(id);
+		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 };
+	}
+
+	private startSubagentResponse(id: string, callerSessionId: string): { ok: true; state: SubagentState } | { ok: false; error: string } {
+		const owned = this.validateOwnedSubagent(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;
+	}
+
+	private validateSubagentDone(id: string, callerSessionId: string): { ok: true; state: SubagentState } | { ok: false; error: string } {
+		const owned = this.validateOwnedSubagent(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;
+	}
+
+	private countRunningForOwner(ownerSessionId: string, excludeId: string): number {
+		let count = 0;
+		for (const state of this.agents.values()) {
+			if (state.id !== excludeId && state.ownerSessionId === ownerSessionId && state.status === "running") count++;
+		}
+		return count;
+	}
+
+	private schedulePendingFlushFor(sessionId: string): void {
+		if (!this.pendingMessages.some((entry) => entry.ownerSessionId === sessionId)) return;
+
+		// Delay flush to next macrotask. session_start fires before pi-core reconnects the
+		// agent event listener; synchronous delivery can lose JSONL persistence.
+		this.flushScheduled = true;
+		this.scheduleFlush(() => {
+			this.flushScheduled = false;
+			this.flushPending();
+		});
+	}
+
+	private deliver(ownerSessionId: string, payload: SteeringPayload): void {
+		if (!this.activeBinding || ownerSessionId !== this.activeBinding.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.activeBinding) return;
+		const targetSessionId = this.activeBinding.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);
+	}
+
+	private send(ownerSessionId: string, payload: SteeringPayload): void {
+		if (!this.activeBinding || this.activeBinding.sessionId !== ownerSessionId) {
+			this.queue(ownerSessionId, payload);
+			return;
+		}
+
+		const remaining = this.countRunningForOwner(ownerSessionId, payload.id);
+		const isIdle = this.activeBinding.isIdle();
+		const triggerResultTurn = !(isIdle && remaining > 0);
+
+		sendSteeringMessage(payload, this.activeBinding.sendMessage, { isIdle, triggerTurn: triggerResultTurn });
+		sendRemainingNote(remaining, this.activeBinding.sendMessage, { isIdle, triggerTurn: isIdle && remaining > 0 });
+	}
+}
+
+const crewRuntimeKey = Symbol.for("pi-crew.runtime");
+const globalWithCrewRuntime = globalThis as typeof globalThis & Record<symbol, CrewRuntime | undefined>;
+
+export const crewRuntime = globalWithCrewRuntime[crewRuntimeKey] ??= new CrewRuntime();

package/extension/index.ts

@@ -1,10 +1,9 @@
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { crewRuntime } from "./runtime/crew-runtime.js";
-import { registerCrewMessageRenderers } from "./integration/register-renderers.js";
-import { registerCrewTools } from "./integration/register-tools.js";
-import { updateWidget } from "./status-widget.js";
+import { crewRuntime } from "./crew.js";
+import { registerCrewTools } from "./tools.js";
+import { registerCrewMessageRenderers, updateWidget } from "./ui.js";
 
 const extensionDir = dirname(fileURLToPath(import.meta.url));
 
@@ -19,11 +18,11 @@ function setupProcessHooks() {
 	if (globalWithProcessHooks[processHooksSetupKey]) return;
 	globalWithProcessHooks[processHooksSetupKey] = true;
 
-	process.once('SIGINT', () => {
+	process.once("SIGINT", () => {
 		crewRuntime.abortAll();
 		process.exit(130);
 	});
-	process.on('beforeExit', () => crewRuntime.abortAll());
+	process.on("beforeExit", () => crewRuntime.abortAll());
 }
 
 export default function (pi: ExtensionAPI) {

package/extension/subagent-session.ts

@@ -0,0 +1,270 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Api, AssistantMessage, Model } from "@earendil-works/pi-ai";
+import {
+	type AgentSession,
+	createAgentSession,
+	DefaultResourceLoader,
+	type ModelRegistry,
+	SessionManager,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import type { AgentConfig } from "./catalog.js";
+import { SUPPORTED_TOOL_NAMES, type SupportedToolName } from "./catalog.js";
+import type { SubagentState } from "./crew.js";
+import type { SubagentStatus } from "./ui.js";
+import { runPromptWithOverflowRecovery } from "./overflow-recovery.js";
+
+export interface BootstrapContext {
+	model: Model<Api> | undefined;
+	modelRegistry: ModelRegistry;
+	agentDir: string;
+	parentSessionFile?: string;
+}
+
+interface BootstrapOptions {
+	agentConfig: AgentConfig;
+	cwd: string;
+	ctx: BootstrapContext;
+	extensionResolvedPath: string;
+}
+
+interface BootstrapResult {
+	session: AgentSession;
+	warnings: string[];
+}
+
+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;
+}
+
+export interface SubagentRunnerCallbacks {
+	isCurrent: (state: SubagentState) => boolean;
+	onProgress: (ownerSessionId: string) => void;
+	onSettled: (
+		state: SubagentState,
+		status: Extract<SubagentStatus, "done" | "waiting" | "error" | "aborted">,
+		outcome: { result?: string; error?: string },
+	) => void;
+}
+
+export interface SubagentRunner {
+	start(state: SubagentState, opts: StartOptions): void;
+	respond(state: SubagentState, message: string): void;
+	abort(state: SubagentState): void;
+}
+
+function resolveTools(agentConfig: AgentConfig): SupportedToolName[] {
+	return [...(agentConfig.tools ?? SUPPORTED_TOOL_NAMES)];
+}
+
+function resolveModel(agentConfig: AgentConfig, ctx: BootstrapContext): { model: Model<Api> | undefined; warnings: string[] } {
+	const warnings: string[] = [];
+	const model = ctx.model;
+	if (!agentConfig.parsedModel) return { model, warnings };
+
+	const found = ctx.modelRegistry.find(agentConfig.parsedModel.provider, agentConfig.parsedModel.modelId);
+	if (found) return { model: found, warnings };
+
+	warnings.push(`Model "${agentConfig.model}" not found, using current session model`);
+	return { model, warnings };
+}
+
+function getSkillWarnings(agentConfig: AgentConfig, resourceLoader: DefaultResourceLoader): string[] {
+	const warnings: string[] = [];
+	if (!agentConfig.skills) return warnings;
+
+	const availableSkillNames = new Set(resourceLoader.getSkills().skills.map((skill) => skill.name));
+	for (const skillName of agentConfig.skills) {
+		if (!availableSkillNames.has(skillName)) {
+			warnings.push(`Unknown skill "${skillName}" in subagent config, skipping`);
+		}
+	}
+	return warnings;
+}
+
+async function bootstrapSession(opts: BootstrapOptions): Promise<BootstrapResult> {
+	const warnings: string[] = [];
+	const { agentConfig, cwd, ctx, extensionResolvedPath } = opts;
+
+	const authStorage = ctx.modelRegistry.authStorage;
+	const modelRegistry = ctx.modelRegistry;
+	const { model, warnings: modelWarnings } = resolveModel(agentConfig, ctx);
+	warnings.push(...modelWarnings);
+	const tools = resolveTools(agentConfig);
+
+	const resourceLoader = new DefaultResourceLoader({
+		cwd,
+		agentDir: ctx.agentDir,
+		extensionsOverride: (base) => ({
+			...base,
+			extensions: base.extensions.filter((ext) => !ext.resolvedPath.startsWith(extensionResolvedPath)),
+		}),
+		skillsOverride: agentConfig.skills
+			? (base) => ({
+				skills: base.skills.filter((skill) => agentConfig.skills!.includes(skill.name)),
+				diagnostics: base.diagnostics,
+			})
+			: undefined,
+		appendSystemPromptOverride: (base) => agentConfig.systemPrompt.trim() ? [...base, agentConfig.systemPrompt] : base,
+	});
+	await resourceLoader.reload();
+	warnings.push(...getSkillWarnings(agentConfig, resourceLoader));
+
+	const settingsManager = SettingsManager.inMemory({
+		compaction: { enabled: agentConfig.compaction ?? true },
+	});
+
+	const sessionManager = SessionManager.create(cwd);
+	sessionManager.newSession({ parentSession: ctx.parentSessionFile });
+
+	const result = await createAgentSession({
+		cwd,
+		agentDir: ctx.agentDir,
+		model,
+		thinkingLevel: agentConfig.thinking,
+		tools,
+		resourceLoader,
+		sessionManager,
+		settingsManager,
+		authStorage,
+		modelRegistry,
+	});
+
+	return { session: result.session, warnings };
+}
+
+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)" };
+}
+
+function isAborted(state: SubagentState): boolean {
+	return state.status === "aborted";
+}
+
+export class SubagentSessionRunner implements SubagentRunner {
+	constructor(private readonly callbacks: SubagentRunnerCallbacks) {}
+
+	start(state: SubagentState, opts: StartOptions): void {
+		void this.spawnSession(state, opts);
+	}
+
+	respond(state: SubagentState, message: string): void {
+		void this.runPromptCycle(state, message);
+	}
+
+	abort(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 });
+			}
+		}
+	}
+}