@clinebot/core 0.0.34 → 0.0.36

package/src/{session/default-session-manager.ts → transports/local.ts}

@@ -1,4 +1,3 @@
-import { existsSync, readFileSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
@@ -19,68 +18,72 @@ import {
 import { setHomeDirIfUnset } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 import { createContextCompactionPrepareTurn } from "../extensions/context/compaction";
-import { enrichPromptWithMentions } from "../input";
-import { createCheckpointHooks } from "../runtime/checkpoint-hooks";
-import { mergeAgentHooks } from "../runtime/hook-file-hooks";
-import { DefaultRuntimeBuilder } from "../runtime/runtime-builder";
-import type { RuntimeBuilder } from "../runtime/session-runtime";
-import { ProviderSettingsManager } from "../storage/provider-settings-manager";
-import { createSpawnAgentTool, type TeamEvent } from "../team";
-import {
-	captureAgentCreated,
-	captureAgentTeamCreated,
-	captureConversationTurnEvent,
-	captureModeSwitch,
-	captureSubagentExecution,
-	captureTaskCompleted,
-} from "../telemetry/core-events";
-import { resolveCoreDistinctId } from "../telemetry/distinct-id";
 import {
 	createBuiltinTools,
 	resolveToolPresetName,
 	type ToolExecutors,
 	ToolPresets,
-} from "../tools";
-import { SessionSource, type SessionStatus } from "../types/common";
-import type { CoreSessionConfig } from "../types/config";
-import type { CoreSessionEvent } from "../types/events";
-import type { SessionRecord } from "../types/sessions";
-import type { FileSessionService } from "./file-session-service";
-import type { RpcCoreSessionService } from "./rpc-session-service";
+} from "../extensions/tools";
+import { createSpawnAgentTool, type TeamEvent } from "../extensions/tools/team";
+import type { HookEventPayload } from "../hooks";
+import { DefaultRuntimeBuilder } from "../runtime/runtime-builder";
+import type {
+	RuntimeHost,
+	RuntimeHostSubscribeOptions,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	StartSessionInput,
+	StartSessionResult,
+} from "../runtime/runtime-host";
 import {
 	OAuthReauthRequiredError,
 	type RuntimeOAuthResolution,
 	RuntimeOAuthTokenManager,
-} from "./runtime-oauth-token-manager";
+} from "../runtime/runtime-oauth-token-manager";
+import type { RuntimeBuilder } from "../runtime/session-runtime";
 import {
 	type AgentEventContext,
 	buildTelemetryAgentIdentity,
 	extractAgentEventMetadata,
 	handleAgentEvent,
-} from "./session-agent-events";
-import { nowIso } from "./session-artifacts";
+} from "../services/agent-events";
+import { resolveWorkspacePath } from "../services/config";
+import { filterDisabledTools } from "../services/global-settings";
+import { prepareLocalRuntimeBootstrap } from "../services/local-runtime-bootstrap";
+import { nowIso } from "../services/session-artifacts";
 import {
-	buildEffectiveConfig,
-	buildResolvedProviderConfig,
-	resolveReasoningSettings,
-	resolveWorkspacePath,
-} from "./session-config-builder";
-import type {
-	SendSessionInput,
-	SessionAccumulatedUsage,
-	SessionManager,
-	StartSessionInput,
-	StartSessionResult,
-} from "./session-manager";
+	toSessionRecord,
+	withLatestAssistantTurnMetadata,
+} from "../services/session-data";
+import {
+	emitMentionTelemetry,
+	emitSessionCreationTelemetry,
+} from "../services/session-telemetry";
+import { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import {
+	captureAgentCreated,
+	captureAgentTeamCreated,
+	captureConversationTurnEvent,
+	captureModeSwitch,
+	captureSubagentExecution,
+	captureTaskCompleted,
+} from "../services/telemetry/core-events";
+import { resolveCoreDistinctId } from "../services/telemetry/distinct-id";
+import {
+	accumulateUsageTotals,
+	createInitialAccumulatedUsage,
+} from "../services/usage";
+import { enrichPromptWithMentions } from "../services/workspace";
+import type { FileSessionService } from "../session/file-session-service";
 import {
 	type SessionManifest,
 	SessionManifestSchema,
-} from "./session-manifest";
+} from "../session/session-manifest";
+import type { SessionRow } from "../session/session-row";
 import type {
 	CoreSessionService,
 	RootSessionArtifacts,
-	SessionRow,
-} from "./session-service";
+} from "../session/session-service";
 import {
 	buildTeamRunContinuationPrompt,
 	dispatchTeamEventToBackend,
@@ -91,26 +94,20 @@ import {
 	shouldAutoContinueTeamRuns,
 	trackTeamRunState,
 	waitForTeamRunUpdates,
-} from "./session-team-coordination";
-import {
-	emitMentionTelemetry,
-	emitSessionCreationTelemetry,
-} from "./session-telemetry";
-import {
-	toSessionRecord,
-	withLatestAssistantTurnMetadata,
-} from "./utils/helpers";
-import type { ActiveSession, PreparedTurnInput } from "./utils/types";
+} from "../session/session-team-coordination";
+import { SessionSource, type SessionStatus } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession, PreparedTurnInput } from "../types/session";
+import type { SessionRecord } from "../types/sessions";
 import {
-	accumulateUsageTotals,
-	createInitialAccumulatedUsage,
-} from "./utils/usage";
-import { buildWorkspaceMetadata } from "./workspace-manifest";
+	cloneAccumulatedUsage,
+	RuntimeHostEventBus,
+	readPersistedMessagesFile,
+	replaySubagentHookEvent,
+} from "./runtime-host-support";
 
-type SessionBackend =
-	| CoreSessionService
-	| RpcCoreSessionService
-	| FileSessionService;
+type SessionBackend = CoreSessionService | FileSessionService;
 
 const MAX_SCAN_LIMIT = 5000;
 const MAX_USER_FILE_BYTES = 20 * 1_000 * 1_024;
@@ -130,7 +127,52 @@ async function loadUserFileContent(path: string): Promise<string> {
 	return content;
 }
 
-export interface DefaultSessionManagerOptions {
+function toActiveSessionRecord(session: ActiveSession): SessionRecord {
+	return {
+		sessionId: session.sessionId,
+		source: session.source,
+		pid: process.pid,
+		startedAt: session.startedAt,
+		endedAt: null,
+		exitCode: null,
+		status: "running",
+		interactive: session.interactive,
+		provider: session.config.providerId,
+		model: session.config.modelId,
+		cwd: session.config.cwd,
+		workspaceRoot: resolveWorkspacePath(session.config),
+		teamName: session.config.teamName?.trim() || undefined,
+		enableTools: session.config.enableTools,
+		enableSpawn: session.config.enableSpawnAgent,
+		enableTeams: session.config.enableAgentTeams,
+		parentSessionId:
+			typeof session.sessionMetadata?.parentSessionId === "string"
+				? session.sessionMetadata.parentSessionId
+				: undefined,
+		parentAgentId:
+			typeof session.sessionMetadata?.parentAgentId === "string"
+				? session.sessionMetadata.parentAgentId
+				: undefined,
+		agentId:
+			typeof session.sessionMetadata?.agentId === "string"
+				? session.sessionMetadata.agentId
+				: undefined,
+		conversationId:
+			typeof session.sessionMetadata?.conversationId === "string"
+				? session.sessionMetadata.conversationId
+				: undefined,
+		isSubagent:
+			typeof session.sessionMetadata?.isSubagent === "boolean"
+				? session.sessionMetadata.isSubagent
+				: false,
+		prompt: session.pendingPrompt,
+		metadata: session.sessionMetadata,
+		messagesPath: session.artifacts?.messagesPath,
+		updatedAt: session.startedAt,
+	};
+}
+
+export interface LocalRuntimeHostOptions {
 	distinctId?: string;
 	sessionService: SessionBackend;
 	runtimeBuilder?: RuntimeBuilder;
@@ -143,9 +185,16 @@ export interface DefaultSessionManagerOptions {
 	requestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
+	/**
+	 * Default custom `fetch` implementation threaded into every
+	 * `ProviderConfig.fetch` built during local session bootstrap. Used by
+	 * the AI gateway providers when issuing HTTP requests.
+	 */
+	fetch?: typeof fetch;
 }
 
-export class DefaultSessionManager implements SessionManager {
+export class LocalRuntimeHost implements RuntimeHost {
+	public readonly runtimeAddress = undefined;
 	private readonly sessionService: SessionBackend;
 	private readonly runtimeBuilder: RuntimeBuilder;
 	private readonly createAgentInstance: (config: AgentConfig) => Agent;
@@ -154,10 +203,11 @@ export class DefaultSessionManager implements SessionManager {
 	private readonly providerSettingsManager: ProviderSettingsManager;
 	private readonly oauthTokenManager: RuntimeOAuthTokenManager;
 	private readonly defaultTelemetry?: ITelemetryService;
+	private readonly defaultFetch?: typeof fetch;
 	private readonly defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
-	private readonly listeners = new Set<(event: CoreSessionEvent) => void>();
+	private readonly events = new RuntimeHostEventBus();
 	private readonly sessions = new Map<string, ActiveSession>();
 	private readonly usageBySession = new Map<string, SessionAccumulatedUsage>();
 	private readonly subAgentStarts = new Map<
@@ -165,7 +215,7 @@ export class DefaultSessionManager implements SessionManager {
 		{ startedAt: number; rootSessionId: string }
 	>();
 
-	constructor(options: DefaultSessionManagerOptions) {
+	constructor(options: LocalRuntimeHostOptions) {
 		const homeDir = homedir();
 		if (homeDir) setHomeDirIfUnset(homeDir);
 		const distinctId = resolveCoreDistinctId(options.distinctId);
@@ -185,6 +235,7 @@ export class DefaultSessionManager implements SessionManager {
 			});
 		this.defaultTelemetry = options.telemetry;
 		this.defaultTelemetry?.setDistinctId(distinctId);
+		this.defaultFetch = options.fetch;
 		this.defaultRequestToolApproval = options.requestToolApproval;
 	}
 
@@ -195,21 +246,7 @@ export class DefaultSessionManager implements SessionManager {
 		const startedAt = nowIso();
 		const requestedSessionId = input.config.sessionId?.trim() ?? "";
 		const sessionId = requestedSessionId || createSessionId();
-		const resumedRow = requestedSessionId
-			? await this.getRow(sessionId)
-			: undefined;
-		const startInput: StartSessionInput =
-			resumedRow &&
-			!input.config.teamName?.trim() &&
-			resumedRow.teamName?.trim()
-				? {
-						...input,
-						config: {
-							...input.config,
-							teamName: resumedRow.teamName,
-						},
-					}
-				: input;
+		const startInput: StartSessionInput = input;
 		this.usageBySession.set(sessionId, createInitialAccumulatedUsage());
 
 		const sessionsDir =
@@ -223,8 +260,6 @@ export class DefaultSessionManager implements SessionManager {
 		}
 
 		const sessionDir = join(sessionsDir, sessionId);
-		const transcriptPath = join(sessionDir, `${sessionId}.log`);
-		const hookPath = join(sessionDir, `${sessionId}.hooks.jsonl`);
 		const messagesPath = join(sessionDir, `${sessionId}.messages.json`);
 		const manifestPath = join(sessionDir, `${sessionId}.json`);
 		const workspacePath = resolveWorkspacePath(input.config);
@@ -249,64 +284,39 @@ export class DefaultSessionManager implements SessionManager {
 			messages_path: messagesPath,
 		});
 
-		const { config: effectiveConfig, pluginSandboxShutdown } =
-			await buildEffectiveConfig(
-				startInput,
-				hookPath,
-				sessionId,
-				this.defaultTelemetry,
-				(e) => void this.handlePluginEvent(sessionId, e),
-			);
-		const workspaceMetadata = await buildWorkspaceMetadata(
-			startInput.config.cwd,
-		);
-		const providerConfig = buildResolvedProviderConfig(
-			effectiveConfig,
-			this.providerSettingsManager,
-			resolveReasoningSettings,
-		);
-		const configWithProvider: CoreSessionConfig = {
-			...effectiveConfig,
-			providerConfig,
-			workspaceMetadata,
-		};
-		configWithProvider.hooks = mergeAgentHooks([
-			effectiveConfig.hooks,
-			effectiveConfig.checkpoint?.enabled === true
-				? createCheckpointHooks({
-						cwd: configWithProvider.cwd,
-						sessionId,
-						logger: configWithProvider.logger,
-						createCheckpoint: effectiveConfig.checkpoint?.createCheckpoint,
-						readSessionMetadata: async () =>
-							(await this.get(sessionId))?.metadata as
-								| Record<string, unknown>
-								| undefined,
-						writeSessionMetadata: async (metadata) => {
-							await this.persistSessionMetadata(sessionId, () => metadata);
-						},
-					})
-				: undefined,
-		]);
-
-		const runtime = await this.runtimeBuilder.build({
-			config: configWithProvider,
-			hooks: configWithProvider.hooks,
-			extensions: effectiveConfig.extensions,
-			logger: configWithProvider.logger,
-			telemetry: configWithProvider.telemetry,
+		const sessionToolExecutors =
+			input.localRuntime?.defaultToolExecutors ?? this.defaultToolExecutors;
+		let bootstrap!: Awaited<ReturnType<typeof prepareLocalRuntimeBootstrap>>;
+		bootstrap = await prepareLocalRuntimeBootstrap({
+			input: startInput,
+			localRuntime: input.localRuntime,
+			sessionId,
+			providerSettingsManager: this.providerSettingsManager,
+			defaultTelemetry: this.defaultTelemetry,
+			defaultToolExecutors: sessionToolExecutors,
+			defaultToolPolicies: this.defaultToolPolicies,
+			defaultRequestToolApproval: this.defaultRequestToolApproval,
+			defaultFetch: this.defaultFetch,
+			onPluginEvent: (event) => void this.handlePluginEvent(sessionId, event),
 			onTeamEvent: (event: TeamEvent) => {
 				void this.handleTeamEvent(sessionId, event);
-				configWithProvider.onTeamEvent?.(event);
+				bootstrap.config.onTeamEvent?.(event);
 			},
 			createSpawnTool: () =>
-				this.createSpawnTool(configWithProvider, sessionId),
-			onTeamRestored: input.onTeamRestored,
-			userInstructionWatcher: input.userInstructionWatcher,
-			defaultToolExecutors:
-				input.defaultToolExecutors ?? this.defaultToolExecutors,
-			teamToolsFactory: input.teamToolsFactory,
+				this.createSpawnTool(bootstrap.config, sessionId, sessionToolExecutors),
+			readSessionMetadata: async () =>
+				(await this.get(sessionId))?.metadata as
+					| Record<string, unknown>
+					| undefined,
+			writeSessionMetadata: async (metadata) => {
+				await this.persistSessionMetadata(sessionId, () => metadata);
+			},
 		});
+		const runtime = await this.runtimeBuilder.build(
+			bootstrap.runtimeBuilderInput,
+		);
+		const configWithProvider = bootstrap.config;
+		const providerConfig = bootstrap.providerConfig;
 		if (runtime.teamRuntime && !configWithProvider.teamName?.trim()) {
 			configWithProvider.teamName = runtime.teamRuntime.getTeamName();
 		}
@@ -329,14 +339,13 @@ export class DefaultSessionManager implements SessionManager {
 			execution: configWithProvider.execution,
 			prepareTurn: createContextCompactionPrepareTurn(configWithProvider),
 			tools,
-			hooks: configWithProvider.hooks,
-			extensions: effectiveConfig.extensions,
+			hooks: bootstrap.hooks,
+			extensions: bootstrap.extensions,
 			hookErrorMode: configWithProvider.hookErrorMode,
-			initialMessages: input.initialMessages,
+			initialMessages: bootstrap.effectiveInput.initialMessages,
 			userFileContentLoader: loadUserFileContent,
-			toolPolicies: input.toolPolicies ?? this.defaultToolPolicies,
-			requestToolApproval:
-				input.requestToolApproval ?? this.defaultRequestToolApproval,
+			toolPolicies: bootstrap.toolPolicies,
+			requestToolApproval: bootstrap.requestToolApproval,
 			onConsecutiveMistakeLimitReached:
 				configWithProvider.onConsecutiveMistakeLimitReached,
 			completionGuard: runtime.completionGuard,
@@ -384,6 +393,7 @@ export class DefaultSessionManager implements SessionManager {
 		const active: ActiveSession = {
 			sessionId,
 			config: configWithProvider,
+			sessionMetadata: startInput.sessionMetadata,
 			source,
 			startedAt,
 			pendingPrompt: manifest.prompt,
@@ -398,7 +408,7 @@ export class DefaultSessionManager implements SessionManager {
 			teamRunWaiters: [],
 			pendingPrompts: [],
 			drainingPendingPrompts: false,
-			pluginSandboxShutdown,
+			pluginSandboxShutdown: bootstrap.pluginSandboxShutdown,
 		};
 		this.sessions.set(sessionId, active);
 		this.emitStatus(sessionId, "running");
@@ -424,8 +434,6 @@ export class DefaultSessionManager implements SessionManager {
 			sessionId,
 			manifest,
 			manifestPath,
-			transcriptPath,
-			hookPath,
 			messagesPath,
 			result,
 		};
@@ -433,6 +441,18 @@ export class DefaultSessionManager implements SessionManager {
 
 	async send(input: SendSessionInput): Promise<AgentResult | undefined> {
 		const session = this.getSessionOrThrow(input.sessionId);
+		const canStartRun =
+			typeof (session.agent as Agent & { canStartRun?: () => boolean })
+				.canStartRun === "function"
+				? (
+						session.agent as Agent & {
+							canStartRun: () => boolean;
+						}
+					).canStartRun()
+				: true;
+		const delivery =
+			input.delivery ??
+			(session.interactive && !canStartRun ? ("queue" as const) : undefined);
 		session.config.telemetry?.capture({
 			event: "session.input_sent",
 			properties: {
@@ -440,13 +460,13 @@ export class DefaultSessionManager implements SessionManager {
 				promptLength: input.prompt.length,
 				userImageCount: input.userImages?.length ?? 0,
 				userFileCount: input.userFiles?.length ?? 0,
-				delivery: input.delivery ?? "immediate",
+				delivery: delivery ?? "immediate",
 			},
 		});
-		if (input.delivery === "queue" || input.delivery === "steer") {
+		if (delivery === "queue" || delivery === "steer") {
 			this.enqueuePendingPrompt(input.sessionId, {
 				prompt: input.prompt,
-				delivery: input.delivery,
+				delivery,
 				userImages: input.userImages,
 				userFiles: input.userFiles,
 			});
@@ -474,8 +494,7 @@ export class DefaultSessionManager implements SessionManager {
 	async getAccumulatedUsage(
 		sessionId: string,
 	): Promise<SessionAccumulatedUsage | undefined> {
-		const usage = this.usageBySession.get(sessionId);
-		return usage ? { ...usage } : undefined;
+		return cloneAccumulatedUsage(this.usageBySession.get(sessionId));
 	}
 
 	async abort(sessionId: string, reason?: unknown): Promise<void> {
@@ -486,6 +505,10 @@ export class DefaultSessionManager implements SessionManager {
 			properties: { sessionId },
 		});
 		session.aborting = true;
+		if (session.pendingPrompts.length > 0) {
+			session.pendingPrompts.length = 0;
+			this.emitPendingPrompts(session);
+		}
 		(
 			session.agent as Agent & {
 				abort: (abortReason?: unknown) => void;
@@ -532,13 +555,25 @@ export class DefaultSessionManager implements SessionManager {
 	}
 
 	async get(sessionId: string): Promise<SessionRecord | undefined> {
+		const active = this.sessions.get(sessionId);
+		if (active) {
+			return toActiveSessionRecord(active);
+		}
 		const row = await this.getRow(sessionId);
 		return row ? toSessionRecord(row) : undefined;
 	}
 
 	async list(limit = 200): Promise<SessionRecord[]> {
 		const rows = await this.listRows(limit);
-		return rows.map(toSessionRecord);
+		const persisted = rows.map(toSessionRecord);
+		const seen = new Set(persisted.map((row) => row.sessionId));
+		for (const active of this.sessions.values()) {
+			if (seen.has(active.sessionId)) {
+				continue;
+			}
+			persisted.unshift(toActiveSessionRecord(active));
+		}
+		return persisted.slice(0, limit);
 	}
 
 	async delete(sessionId: string): Promise<boolean> {
@@ -555,55 +590,52 @@ export class DefaultSessionManager implements SessionManager {
 		return result.deleted;
 	}
 
-	async readTranscript(sessionId: string, maxChars?: number): Promise<string> {
-		const row = await this.getRow(sessionId);
-		if (!row?.transcriptPath || !existsSync(row.transcriptPath)) return "";
-		const raw = readFileSync(row.transcriptPath, "utf8");
-		if (typeof maxChars === "number" && Number.isFinite(maxChars)) {
-			return raw.slice(-Math.max(0, Math.floor(maxChars)));
-		}
-		return raw;
+	async update(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }> {
+		const result = await this.invokeOptionalValue<{ updated?: boolean }>(
+			"updateSession",
+			{
+				sessionId,
+				prompt: updates.prompt,
+				metadata: updates.metadata,
+				title: updates.title,
+			},
+		);
+		return { updated: result?.updated === true };
 	}
 
 	async readMessages(sessionId: string): Promise<LlmsProviders.Message[]> {
 		const row = await this.getRow(sessionId);
-		const messagesPath = row?.messagesPath?.trim();
-		if (!messagesPath || !existsSync(messagesPath)) return [];
-		try {
-			const raw = readFileSync(messagesPath, "utf8").trim();
-			if (!raw) return [];
-			const parsed = JSON.parse(raw) as unknown;
-			if (Array.isArray(parsed)) return parsed as LlmsProviders.Message[];
-			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-				const messages = (parsed as { messages?: unknown }).messages;
-				if (Array.isArray(messages)) return messages as LlmsProviders.Message[];
-			}
-			return [];
-		} catch {
-			return [];
-		}
+		return readPersistedMessagesFile(row?.messagesPath);
 	}
 
-	async readHooks(sessionId: string, limit = 200): Promise<unknown[]> {
-		const row = await this.getRow(sessionId);
-		if (!row?.hookPath || !existsSync(row.hookPath)) return [];
-		const lines = readFileSync(row.hookPath, "utf8")
-			.split("\n")
-			.filter((line) => line.trim().length > 0);
-		return lines.slice(-Math.max(1, Math.floor(limit))).map((line) => {
-			try {
-				return JSON.parse(line) as unknown;
-			} catch {
-				return { raw: line };
-			}
+	async handleHookEvent(payload: HookEventPayload): Promise<void> {
+		await replaySubagentHookEvent(payload, {
+			queueSpawnRequest: (event: HookEventPayload) =>
+				this.invokeOptional("queueSpawnRequest", event),
+			upsertSubagentSessionFromHook: (event: HookEventPayload) =>
+				this.invokeOptionalValue<string | undefined>(
+					"upsertSubagentSessionFromHook",
+					event,
+				),
+			appendSubagentHookAudit: (sessionId: string, event: HookEventPayload) =>
+				this.invokeOptional("appendSubagentHookAudit", sessionId, event),
+			applySubagentStatus: (sessionId: string, event: HookEventPayload) =>
+				this.invokeOptional("applySubagentStatus", sessionId, event),
 		});
 	}
 
-	subscribe(listener: (event: CoreSessionEvent) => void): () => void {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		return this.events.subscribe(listener, options);
 	}
 
 	async updateSessionModel(sessionId: string, modelId: string): Promise<void> {
@@ -796,6 +828,7 @@ export class DefaultSessionManager implements SessionManager {
 			enableSpawn: session.config.enableSpawnAgent,
 			enableTeams: session.config.enableAgentTeams,
 			prompt: session.pendingPrompt,
+			metadata: session.sessionMetadata,
 			startedAt: session.startedAt,
 		})) as RootSessionArtifacts;
 	}
@@ -875,12 +908,39 @@ export class DefaultSessionManager implements SessionManager {
 		}
 		notifyTeamRunWaiters(session);
 
+		const cleanupErrors: unknown[] = [];
+		const recordCleanupError = (stage: string, error: unknown) => {
+			cleanupErrors.push(error);
+			session.config.logger?.log("Session shutdown cleanup failed", {
+				sessionId: session.sessionId,
+				stage,
+				error,
+				severity: "warn",
+			});
+		};
+
 		if (session.artifacts) {
-			await this.updateStatus(session, input.status, input.exitCode);
-			await session.agent.shutdown(input.shutdownReason);
+			try {
+				await this.updateStatus(session, input.status, input.exitCode);
+			} catch (error) {
+				recordCleanupError("update_status", error);
+			}
+			try {
+				await session.agent.shutdown(input.shutdownReason);
+			} catch (error) {
+				recordCleanupError("agent_shutdown", error);
+			}
+		}
+		try {
+			await Promise.resolve(session.runtime.shutdown(input.shutdownReason));
+		} catch (error) {
+			recordCleanupError("runtime_shutdown", error);
+		}
+		try {
+			await session.pluginSandboxShutdown?.();
+		} catch (error) {
+			recordCleanupError("plugin_sandbox_shutdown", error);
 		}
-		await Promise.resolve(session.runtime.shutdown(input.shutdownReason));
-		await session.pluginSandboxShutdown?.();
 		this.sessions.delete(session.sessionId);
 		this.emit({
 			type: "ended",
@@ -890,6 +950,9 @@ export class DefaultSessionManager implements SessionManager {
 				ts: Date.now(),
 			},
 		});
+		if (cleanupErrors.length > 0 && input.status === "failed") {
+			throw cleanupErrors[0];
+		}
 	}
 
 	private async updateStatus(
@@ -992,7 +1055,7 @@ export class DefaultSessionManager implements SessionManager {
 		},
 	): void {
 		const session = this.sessions.get(sessionId);
-		if (!session) {
+		if (!session || session.aborting) {
 			return;
 		}
 		const { prompt, delivery, userImages, userFiles } = entry;
@@ -1041,7 +1104,7 @@ export class DefaultSessionManager implements SessionManager {
 
 	private async drainPendingPrompts(sessionId: string): Promise<void> {
 		const session = this.sessions.get(sessionId);
-		if (!session || session.drainingPendingPrompts) {
+		if (!session || session.aborting || session.drainingPendingPrompts) {
 			return;
 		}
 		const canStartRun =
@@ -1173,6 +1236,7 @@ export class DefaultSessionManager implements SessionManager {
 	private createSpawnTool(
 		config: CoreSessionConfig,
 		rootSessionId: string,
+		toolExecutors?: Partial<ToolExecutors>,
 	): Tool {
 		const createSubAgentTools = () => {
 			const tools: Tool[] = config.enableTools
@@ -1181,16 +1245,15 @@ export class DefaultSessionManager implements SessionManager {
 						...ToolPresets[
 							resolveToolPresetName({
 								mode: config.mode,
-								yolo: config.yolo,
 							})
 						],
-						executors: this.defaultToolExecutors,
+						executors: toolExecutors,
 					})
 				: [];
 			if (config.enableSpawnAgent) {
-				tools.push(this.createSpawnTool(config, rootSessionId));
+				tools.push(this.createSpawnTool(config, rootSessionId, toolExecutors));
 			}
-			return tools;
+			return filterDisabledTools(tools);
 		};
 
 		return createSpawnAgentTool({
@@ -1464,7 +1527,7 @@ export class DefaultSessionManager implements SessionManager {
 	}
 
 	private emit(event: CoreSessionEvent): void {
-		for (const listener of this.listeners) listener(event);
+		this.events.emit(event);
 	}
 
 	private async listRows(limit: number): Promise<SessionRow[]> {