@clinebot/core 0.0.35 → 0.0.37

package/src/transports/local.ts

@@ -1,12 +1,14 @@
 import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { Agent } from "@clinebot/agents";
 import type * as LlmsProviders from "@clinebot/llms";
 import {
 	type AgentConfig,
 	type AgentEvent,
 	type AgentResult,
+	type AutomationEventEnvelope,
+	type BasicLogger,
+	type BasicLogMetadata,
 	createSessionId,
 	type ITelemetryService,
 	isLikelyAuthError,
@@ -28,7 +30,13 @@ import { createSpawnAgentTool, type TeamEvent } from "../extensions/tools/team";
 import type { HookEventPayload } from "../hooks";
 import { DefaultRuntimeBuilder } from "../runtime/runtime-builder";
 import type {
+	PendingPromptMutationResult,
+	PendingPromptsAction,
+	PendingPromptsDeleteInput,
+	PendingPromptsListInput,
+	PendingPromptsUpdateInput,
 	RuntimeHost,
+	RuntimeHostSubscribeOptions,
 	SendSessionInput,
 	SessionAccumulatedUsage,
 	StartSessionInput,
@@ -40,6 +48,7 @@ import {
 	RuntimeOAuthTokenManager,
 } from "../runtime/runtime-oauth-token-manager";
 import type { RuntimeBuilder } from "../runtime/session-runtime";
+import { SessionRuntime } from "../runtime/session-runtime-orchestrator";
 import {
 	type AgentEventContext,
 	buildTelemetryAgentIdentity,
@@ -47,6 +56,7 @@ import {
 	handleAgentEvent,
 } 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 {
@@ -73,15 +83,14 @@ import {
 } from "../services/usage";
 import { enrichPromptWithMentions } from "../services/workspace";
 import type { FileSessionService } from "../session/file-session-service";
-import type { RpcCoreSessionService } from "../session/rpc-session-service";
 import {
 	type SessionManifest,
 	SessionManifestSchema,
 } from "../session/session-manifest";
+import type { SessionRow } from "../session/session-row";
 import type {
 	CoreSessionService,
 	RootSessionArtifacts,
-	SessionRow,
 } from "../session/session-service";
 import {
 	buildTeamRunContinuationPrompt,
@@ -96,8 +105,12 @@ import {
 } 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 { CoreSessionEvent, SessionPendingPrompt } from "../types/events";
+import type {
+	ActiveSession,
+	PendingPrompt,
+	PreparedTurnInput,
+} from "../types/session";
 import type { SessionRecord } from "../types/sessions";
 import {
 	cloneAccumulatedUsage,
@@ -106,10 +119,7 @@ import {
 	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;
@@ -129,13 +139,57 @@ async function loadUserFileContent(path: string): Promise<string> {
 	return content;
 }
 
+function toActiveSessionRecord(session: ActiveSession): SessionRecord {
+	return {
+		sessionId: session.sessionId,
+		source: session.source,
+		pid: process.pid,
+		startedAt: session.startedAt,
+		endedAt: session.endedAt ?? null,
+		exitCode: session.exitCode ?? null,
+		status: session.status,
+		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;
-	createAgent?: (config: AgentConfig) => Agent;
+	createAgent?: (config: AgentConfig) => SessionRuntime;
 	defaultToolExecutors?: Partial<ToolExecutors>;
-	teamToolsFactory?: import("../runtime/session-runtime").TeamToolsFactory;
 	toolPolicies?: AgentConfig["toolPolicies"];
 	providerSettingsManager?: ProviderSettingsManager;
 	oauthTokenManager?: RuntimeOAuthTokenManager;
@@ -143,19 +197,25 @@ export interface LocalRuntimeHostOptions {
 	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 LocalRuntimeHost implements RuntimeHost {
 	public readonly runtimeAddress = undefined;
 	private readonly sessionService: SessionBackend;
 	private readonly runtimeBuilder: RuntimeBuilder;
-	private readonly createAgentInstance: (config: AgentConfig) => Agent;
+	private readonly createAgentInstance: (config: AgentConfig) => SessionRuntime;
 	private readonly defaultToolExecutors?: Partial<ToolExecutors>;
-	private readonly teamToolsFactory?: import("../runtime/session-runtime").TeamToolsFactory;
 	private readonly defaultToolPolicies?: AgentConfig["toolPolicies"];
 	private readonly providerSettingsManager: ProviderSettingsManager;
 	private readonly oauthTokenManager: RuntimeOAuthTokenManager;
 	private readonly defaultTelemetry?: ITelemetryService;
+	private readonly defaultFetch?: typeof fetch;
 	private readonly defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
@@ -174,9 +234,8 @@ export class LocalRuntimeHost implements RuntimeHost {
 		this.sessionService = options.sessionService;
 		this.runtimeBuilder = options.runtimeBuilder ?? new DefaultRuntimeBuilder();
 		this.createAgentInstance =
-			options.createAgent ?? ((config) => new Agent(config));
+			options.createAgent ?? ((config) => new SessionRuntime(config));
 		this.defaultToolExecutors = options.defaultToolExecutors;
-		this.teamToolsFactory = options.teamToolsFactory;
 		this.defaultToolPolicies = options.toolPolicies;
 		this.providerSettingsManager =
 			options.providerSettingsManager ?? new ProviderSettingsManager();
@@ -188,6 +247,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 			});
 		this.defaultTelemetry = options.telemetry;
 		this.defaultTelemetry?.setDistinctId(distinctId);
+		this.defaultFetch = options.fetch;
 		this.defaultRequestToolApproval = options.requestToolApproval;
 	}
 
@@ -198,21 +258,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 		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 =
@@ -250,6 +296,15 @@ export class LocalRuntimeHost implements RuntimeHost {
 			messages_path: messagesPath,
 		});
 
+		const sessionToolExecutors =
+			input.localRuntime?.defaultToolExecutors ?? this.defaultToolExecutors;
+		const inputLocalConfig = input.localRuntime?.configOverrides as
+			| Partial<CoreSessionConfig>
+			| undefined;
+		const pluginEventFallbackLogger =
+			inputLocalConfig?.extensionContext?.logger ?? inputLocalConfig?.logger;
+		const pluginEventFallbackAutomation =
+			inputLocalConfig?.extensionContext?.automation;
 		let bootstrap!: Awaited<ReturnType<typeof prepareLocalRuntimeBootstrap>>;
 		bootstrap = await prepareLocalRuntimeBootstrap({
 			input: startInput,
@@ -257,16 +312,31 @@ export class LocalRuntimeHost implements RuntimeHost {
 			sessionId,
 			providerSettingsManager: this.providerSettingsManager,
 			defaultTelemetry: this.defaultTelemetry,
-			defaultToolExecutors: this.defaultToolExecutors,
-			teamToolsFactory: this.teamToolsFactory,
+			defaultToolExecutors: sessionToolExecutors,
 			defaultToolPolicies: this.defaultToolPolicies,
 			defaultRequestToolApproval: this.defaultRequestToolApproval,
-			onPluginEvent: (event) => void this.handlePluginEvent(sessionId, event),
+			defaultFetch: this.defaultFetch,
+			onPluginEvent: (event) => {
+				if (event.name === "plugin_log") {
+					this.handlePluginLog(
+						sessionId,
+						event.payload,
+						pluginEventFallbackLogger,
+					);
+					return;
+				}
+				void this.handlePluginEvent(
+					sessionId,
+					event,
+					pluginEventFallbackAutomation,
+				);
+			},
 			onTeamEvent: (event: TeamEvent) => {
 				void this.handleTeamEvent(sessionId, event);
 				bootstrap.config.onTeamEvent?.(event);
 			},
-			createSpawnTool: () => this.createSpawnTool(bootstrap.config, sessionId),
+			createSpawnTool: () =>
+				this.createSpawnTool(bootstrap.config, sessionId, sessionToolExecutors),
 			readSessionMetadata: async () =>
 				(await this.get(sessionId))?.metadata as
 					| Record<string, unknown>
@@ -287,6 +357,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 		const tools = [...runtime.tools, ...(configWithProvider.extraTools ?? [])];
 
 		const agentConfig = {
+			sessionId,
 			providerId: providerConfig.providerId,
 			modelId: providerConfig.modelId,
 			apiKey: providerConfig.apiKey,
@@ -319,10 +390,13 @@ export class LocalRuntimeHost implements RuntimeHost {
 				this.onAgentEvent(sessionId, configWithProvider, event),
 		} as AgentConfig;
 		const agent = this.createAgentInstance(agentConfig);
+		if (agentConfig.onEvent) {
+			agent.subscribeEvents(agentConfig.onEvent);
+		}
 		runtime.registerLeadAgent?.(agent);
 		const rootAgentIdentity = buildTelemetryAgentIdentity({
-			agentId: this.readAgentId(agent),
-			conversationId: this.readAgentConversationId(agent),
+			agentId: agent.getAgentId(),
+			conversationId: agent.getConversationId(),
 			teamId: runtime.teamRuntime?.getTeamId(),
 			teamName: runtime.teamRuntime?.getTeamName(),
 			teamRole: runtime.teamRuntime ? "lead" : undefined,
@@ -330,7 +404,6 @@ export class LocalRuntimeHost implements RuntimeHost {
 		emitSessionCreationTelemetry(
 			configWithProvider,
 			sessionId,
-			source,
 			requestedSessionId.length > 0,
 			workspacePath,
 			rootAgentIdentity,
@@ -348,7 +421,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 				ulid: sessionId,
 				teamId: runtime.teamRuntime.getTeamId(),
 				teamName: runtime.teamRuntime.getTeamName(),
-				leadAgentId: this.readAgentId(agent),
+				leadAgentId: agent.getAgentId(),
 				restoredFromPersistence: runtime.teamRestoredFromPersistence === true,
 			});
 		}
@@ -363,6 +436,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 			runtime,
 			agent,
 			started: false,
+			status: "running",
 			aborting: false,
 			interactive: input.interactive === true,
 			persistedMessages: startInput.initialMessages,
@@ -375,6 +449,18 @@ export class LocalRuntimeHost implements RuntimeHost {
 		};
 		this.sessions.set(sessionId, active);
 		this.emitStatus(sessionId, "running");
+		if ((startInput.initialMessages?.length ?? 0) > 0) {
+			await this.ensureSessionPersisted(active);
+			await this.invoke<void>(
+				"persistSessionMessages",
+				active.sessionId,
+				startInput.initialMessages,
+				active.config.systemPrompt,
+			);
+			if (!startInput.prompt?.trim()) {
+				await this.updateStatus(active, "completed", 0);
+			}
+		}
 
 		let result: AgentResult | undefined;
 		try {
@@ -404,6 +490,10 @@ export class LocalRuntimeHost implements RuntimeHost {
 
 	async send(input: SendSessionInput): Promise<AgentResult | undefined> {
 		const session = this.getSessionOrThrow(input.sessionId);
+		const canStartRun = session.agent.canStartRun();
+		const delivery =
+			input.delivery ??
+			(session.interactive && !canStartRun ? ("queue" as const) : undefined);
 		session.config.telemetry?.capture({
 			event: "session.input_sent",
 			properties: {
@@ -411,13 +501,13 @@ export class LocalRuntimeHost implements RuntimeHost {
 				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,
 			});
@@ -442,6 +532,122 @@ export class LocalRuntimeHost implements RuntimeHost {
 		}
 	}
 
+	async pendingPrompts(
+		action: "list",
+		input: PendingPromptsListInput,
+	): Promise<SessionPendingPrompt[]>;
+	async pendingPrompts(
+		action: "update",
+		input: PendingPromptsUpdateInput,
+	): Promise<PendingPromptMutationResult>;
+	async pendingPrompts(
+		action: "delete",
+		input: PendingPromptsDeleteInput,
+	): Promise<PendingPromptMutationResult>;
+	async pendingPrompts(
+		action: PendingPromptsAction,
+		input:
+			| PendingPromptsListInput
+			| PendingPromptsUpdateInput
+			| PendingPromptsDeleteInput,
+	): Promise<SessionPendingPrompt[] | PendingPromptMutationResult> {
+		switch (action) {
+			case "list":
+				return this.listPendingPromptEntries(input.sessionId);
+			case "update":
+				return this.editPendingPromptEntry(input as PendingPromptsUpdateInput);
+			case "delete":
+				return this.deletePendingPromptEntry(
+					input as PendingPromptsDeleteInput,
+				);
+		}
+	}
+
+	private listPendingPromptEntries(sessionId: string): SessionPendingPrompt[] {
+		const session = this.sessions.get(sessionId);
+		return session ? this.snapshotPendingPrompts(session) : [];
+	}
+
+	private editPendingPromptEntry(
+		input: PendingPromptsUpdateInput,
+	): PendingPromptMutationResult {
+		const session = this.sessions.get(input.sessionId);
+		if (!session || session.aborting) {
+			return { sessionId: input.sessionId, prompts: [], updated: false };
+		}
+		const promptId = input.promptId.trim();
+		const index = session.pendingPrompts.findIndex(
+			(entry) => entry.id === promptId,
+		);
+		if (index < 0) {
+			return {
+				sessionId: input.sessionId,
+				prompts: this.snapshotPendingPrompts(session),
+				updated: false,
+			};
+		}
+
+		const existing = session.pendingPrompts[index]!;
+		const prompt =
+			input.prompt === undefined
+				? existing.prompt
+				: normalizeUserInput(input.prompt).trim();
+		if (!prompt) {
+			throw new Error("prompt cannot be empty");
+		}
+		const delivery = input.delivery ?? existing.delivery;
+		const next: PendingPrompt = {
+			...existing,
+			prompt,
+			delivery,
+		};
+		session.pendingPrompts.splice(index, 1);
+		if (delivery === "steer") {
+			session.pendingPrompts.unshift(next);
+		} else if (existing.delivery === "steer") {
+			session.pendingPrompts.push(next);
+		} else {
+			session.pendingPrompts.splice(index, 0, next);
+		}
+		this.emitPendingPrompts(session);
+		this.schedulePendingPromptDrain(input.sessionId, session);
+		return {
+			sessionId: input.sessionId,
+			prompts: this.snapshotPendingPrompts(session),
+			prompt: this.snapshotPendingPrompt(next),
+			updated: true,
+		};
+	}
+
+	private deletePendingPromptEntry(
+		input: PendingPromptsDeleteInput,
+	): PendingPromptMutationResult {
+		const session = this.sessions.get(input.sessionId);
+		if (!session || session.aborting) {
+			return { sessionId: input.sessionId, prompts: [], removed: false };
+		}
+		const promptId = input.promptId.trim();
+		const index = session.pendingPrompts.findIndex(
+			(entry) => entry.id === promptId,
+		);
+		if (index < 0) {
+			return {
+				sessionId: input.sessionId,
+				prompts: this.snapshotPendingPrompts(session),
+				removed: false,
+			};
+		}
+		const [removed] = session.pendingPrompts.splice(index, 1);
+		this.emitPendingPrompts(session);
+		this.schedulePendingPromptDrain(input.sessionId, session);
+		return {
+			sessionId: input.sessionId,
+			prompts: this.snapshotPendingPrompts(session),
+			prompt: removed ? this.snapshotPendingPrompt(removed) : undefined,
+			removed: true,
+		};
+	}
+
 	async getAccumulatedUsage(
 		sessionId: string,
 	): Promise<SessionAccumulatedUsage | undefined> {
@@ -460,11 +666,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 			session.pendingPrompts.length = 0;
 			this.emitPendingPrompts(session);
 		}
-		(
-			session.agent as Agent & {
-				abort: (abortReason?: unknown) => void;
-			}
-		).abort(reason);
+		session.agent.abort(reason);
 	}
 
 	async stop(sessionId: string): Promise<void> {
@@ -476,11 +678,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 		});
 		// Abort the agent first if it's running, so shutdown can proceed
 		session.aborting = true;
-		(
-			session.agent as Agent & {
-				abort: (abortReason?: unknown) => void;
-			}
-		).abort(new Error("session_stop"));
+		session.agent.abort(new Error("session_stop"));
 		await this.shutdownSession(session, {
 			status: "cancelled",
 			exitCode: 0,
@@ -506,13 +704,25 @@ export class LocalRuntimeHost implements RuntimeHost {
 	}
 
 	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> {
@@ -570,8 +780,11 @@ export class LocalRuntimeHost implements RuntimeHost {
 		});
 	}
 
-	subscribe(listener: (event: CoreSessionEvent) => void): () => void {
-		return this.events.subscribe(listener);
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		return this.events.subscribe(listener, options);
 	}
 
 	async updateSessionModel(sessionId: string, modelId: string): Promise<void> {
@@ -806,10 +1019,11 @@ export class LocalRuntimeHost implements RuntimeHost {
 	): Promise<void> {
 		if (hasPendingTeamRunWork(session)) return;
 		const isAborted = finishReason === "aborted" || session.aborting;
+		const isError = finishReason === "error";
 		await this.shutdownSession(session, {
-			status: isAborted ? "cancelled" : "completed",
-			exitCode: 0,
-			shutdownReason: "session_complete",
+			status: isAborted ? "cancelled" : isError ? "failed" : "completed",
+			exitCode: isError ? 1 : 0,
+			shutdownReason: isError ? "session_error" : "session_complete",
 			endReason: finishReason,
 		});
 	}
@@ -844,12 +1058,39 @@ export class LocalRuntimeHost implements RuntimeHost {
 		}
 		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",
@@ -859,6 +1100,9 @@ export class LocalRuntimeHost implements RuntimeHost {
 				ts: Date.now(),
 			},
 		});
+		if (cleanupErrors.length > 0 && input.status === "failed") {
+			throw cleanupErrors[0];
+		}
 	}
 
 	private async updateStatus(
@@ -883,6 +1127,9 @@ export class LocalRuntimeHost implements RuntimeHost {
 		latestManifest.ended_at = result.endedAt ?? nowIso();
 		latestManifest.exit_code = typeof exitCode === "number" ? exitCode : null;
 		session.artifacts.manifest = latestManifest;
+		session.status = status;
+		session.endedAt = latestManifest.ended_at;
+		session.exitCode = latestManifest.exit_code;
 		await this.invoke<void>(
 			"writeSessionManifest",
 			session.artifacts.manifestPath,
@@ -894,7 +1141,31 @@ export class LocalRuntimeHost implements RuntimeHost {
 	private async handlePluginEvent(
 		rootSessionId: string,
 		event: { name: string; payload?: unknown },
+		fallbackAutomation?: NonNullable<
+			CoreSessionConfig["extensionContext"]
+		>["automation"],
 	): Promise<void> {
+		if (event.name === "plugin_log") {
+			this.handlePluginLog(rootSessionId, event.payload);
+			return;
+		}
+		if (event.name === "automation_event") {
+			const session = this.sessions.get(rootSessionId);
+			const automation =
+				session?.config.extensionContext?.automation ?? fallbackAutomation;
+			if (!automation) {
+				return;
+			}
+			const payload =
+				event.payload && typeof event.payload === "object"
+					? (event.payload as AutomationEventEnvelope)
+					: undefined;
+			if (!payload) {
+				return;
+			}
+			await automation.ingestEvent(payload);
+			return;
+		}
 		if (
 			event.name !== "steer_message" &&
 			event.name !== "queue_message" &&
@@ -930,6 +1201,49 @@ export class LocalRuntimeHost implements RuntimeHost {
 		});
 	}
 
+	private handlePluginLog(
+		rootSessionId: string,
+		payload: unknown,
+		fallbackLogger?: BasicLogger,
+	): void {
+		const session = this.sessions.get(rootSessionId);
+		const logger =
+			fallbackLogger ??
+			session?.config.extensionContext?.logger ??
+			session?.config.logger;
+		if (!logger || !payload || typeof payload !== "object") {
+			return;
+		}
+		const record = payload as Record<string, unknown>;
+		const message = typeof record.message === "string" ? record.message : "";
+		if (!message) {
+			return;
+		}
+		const metadata =
+			record.metadata && typeof record.metadata === "object"
+				? ({
+						...(record.metadata as Record<string, unknown>),
+					} as BasicLogMetadata)
+				: {};
+		metadata.sessionId ??= rootSessionId;
+		if (typeof record.pluginName === "string" && record.pluginName) {
+			metadata.pluginName = record.pluginName;
+		}
+		if (record.level === "debug") {
+			logger.debug(message, metadata);
+			return;
+		}
+		if (record.level === "error") {
+			if (logger.error) {
+				logger.error(message, metadata);
+			} else {
+				logger.log(message, { ...metadata, severity: "error" });
+			}
+			return;
+		}
+		logger.log(message, metadata);
+	}
+
 	/**
 	 * Consume the first steer-delivery pending prompt for injection into the
 	 * running agent loop. Called synchronously by the agent between iterations.
@@ -1003,6 +1317,21 @@ export class LocalRuntimeHost implements RuntimeHost {
 			});
 		}
 		this.emitPendingPrompts(session);
+		this.schedulePendingPromptDrain(sessionId, session);
+	}
+
+	private schedulePendingPromptDrain(
+		sessionId: string,
+		session: ActiveSession,
+	): void {
+		if (
+			session.pendingPrompts.length === 0 ||
+			session.aborting ||
+			session.drainingPendingPrompts ||
+			!session.agent.canStartRun()
+		) {
+			return;
+		}
 		queueMicrotask(() => {
 			void this.drainPendingPrompts(sessionId);
 		});
@@ -1013,15 +1342,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 		if (!session || session.aborting || session.drainingPendingPrompts) {
 			return;
 		}
-		const canStartRun =
-			typeof (session.agent as Agent & { canStartRun?: () => boolean })
-				.canStartRun === "function"
-				? (
-						session.agent as Agent & {
-							canStartRun: () => boolean;
-						}
-					).canStartRun()
-				: true;
+		const canStartRun = session.agent.canStartRun();
 		if (!canStartRun) {
 			return;
 		}
@@ -1103,17 +1424,29 @@ export class LocalRuntimeHost implements RuntimeHost {
 			type: "pending_prompts",
 			payload: {
 				sessionId: session.sessionId,
-				prompts: session.pendingPrompts.map((entry) => ({
-					id: entry.id,
-					prompt: entry.prompt,
-					delivery: entry.delivery,
-					attachmentCount:
-						(entry.userImages?.length ?? 0) + (entry.userFiles?.length ?? 0),
-				})),
+				prompts: this.snapshotPendingPrompts(session),
 			},
 		});
 	}
 
+	private snapshotPendingPrompt(entry: PendingPrompt): SessionPendingPrompt {
+		return {
+			id: entry.id,
+			prompt: entry.prompt,
+			delivery: entry.delivery,
+			attachmentCount:
+				(entry.userImages?.length ?? 0) + (entry.userFiles?.length ?? 0),
+		};
+	}
+
+	private snapshotPendingPrompts(
+		session: ActiveSession,
+	): SessionPendingPrompt[] {
+		return session.pendingPrompts.map((entry) =>
+			this.snapshotPendingPrompt(entry),
+		);
+	}
+
 	private emitPendingPromptSubmitted(
 		session: ActiveSession,
 		entry: {
@@ -1142,6 +1475,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 	private createSpawnTool(
 		config: CoreSessionConfig,
 		rootSessionId: string,
+		toolExecutors?: Partial<ToolExecutors>,
 	): Tool {
 		const createSubAgentTools = () => {
 			const tools: Tool[] = config.enableTools
@@ -1152,13 +1486,13 @@ export class LocalRuntimeHost implements RuntimeHost {
 								mode: config.mode,
 							})
 						],
-						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({
@@ -1395,13 +1729,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 		session: ActiveSession,
 		overrides: { apiKey?: string; modelId?: string },
 	): void {
-		const agentWithConnection = session.agent as Agent & {
-			updateConnection?: (overrides: {
-				apiKey?: string;
-				modelId?: string;
-			}) => void;
-		};
-		agentWithConnection.updateConnection?.(overrides);
+		session.agent.updateConnection(overrides);
 	}
 
 	private getSessionAgentTelemetryIdentity(session: ActiveSession) {
@@ -1414,14 +1742,12 @@ export class LocalRuntimeHost implements RuntimeHost {
 		});
 	}
 
-	private readAgentId(agent: Agent): string | undefined {
-		return (agent as Agent & { getAgentId?: () => string }).getAgentId?.();
+	private readAgentId(agent: SessionRuntime): string {
+		return agent.getAgentId();
 	}
 
-	private readAgentConversationId(agent: Agent): string | undefined {
-		return (
-			agent as Agent & { getConversationId?: () => string }
-		).getConversationId?.();
+	private readAgentConversationId(agent: SessionRuntime): string {
+		return agent.getConversationId();
 	}
 
 	private emitStatus(sessionId: string, status: string): void {