@clinebot/core 0.0.36 → 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,6 +30,11 @@ 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,
@@ -41,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,
@@ -97,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,
@@ -133,9 +145,9 @@ function toActiveSessionRecord(session: ActiveSession): SessionRecord {
 		source: session.source,
 		pid: process.pid,
 		startedAt: session.startedAt,
-		endedAt: null,
-		exitCode: null,
-		status: "running",
+		endedAt: session.endedAt ?? null,
+		exitCode: session.exitCode ?? null,
+		status: session.status,
 		interactive: session.interactive,
 		provider: session.config.providerId,
 		model: session.config.modelId,
@@ -176,7 +188,7 @@ export interface LocalRuntimeHostOptions {
 	distinctId?: string;
 	sessionService: SessionBackend;
 	runtimeBuilder?: RuntimeBuilder;
-	createAgent?: (config: AgentConfig) => Agent;
+	createAgent?: (config: AgentConfig) => SessionRuntime;
 	defaultToolExecutors?: Partial<ToolExecutors>;
 	toolPolicies?: AgentConfig["toolPolicies"];
 	providerSettingsManager?: ProviderSettingsManager;
@@ -197,7 +209,7 @@ 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 defaultToolPolicies?: AgentConfig["toolPolicies"];
 	private readonly providerSettingsManager: ProviderSettingsManager;
@@ -222,7 +234,7 @@ 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.defaultToolPolicies = options.toolPolicies;
 		this.providerSettingsManager =
@@ -286,6 +298,13 @@ export class LocalRuntimeHost implements RuntimeHost {
 
 		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,
@@ -297,7 +316,21 @@ export class LocalRuntimeHost implements RuntimeHost {
 			defaultToolPolicies: this.defaultToolPolicies,
 			defaultRequestToolApproval: this.defaultRequestToolApproval,
 			defaultFetch: this.defaultFetch,
-			onPluginEvent: (event) => void this.handlePluginEvent(sessionId, event),
+			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);
@@ -324,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,
@@ -356,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,
@@ -367,7 +404,6 @@ export class LocalRuntimeHost implements RuntimeHost {
 		emitSessionCreationTelemetry(
 			configWithProvider,
 			sessionId,
-			source,
 			requestedSessionId.length > 0,
 			workspacePath,
 			rootAgentIdentity,
@@ -385,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,
 			});
 		}
@@ -400,6 +436,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 			runtime,
 			agent,
 			started: false,
+			status: "running",
 			aborting: false,
 			interactive: input.interactive === true,
 			persistedMessages: startInput.initialMessages,
@@ -412,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 {
@@ -441,15 +490,7 @@ export class LocalRuntimeHost implements RuntimeHost {
 
 	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 canStartRun = session.agent.canStartRun();
 		const delivery =
 			input.delivery ??
 			(session.interactive && !canStartRun ? ("queue" as const) : undefined);
@@ -491,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> {
@@ -509,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> {
@@ -525,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,
@@ -870,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,
 		});
 	}
@@ -977,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,
@@ -988,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" &&
@@ -1024,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.
@@ -1097,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);
 		});
@@ -1107,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;
 		}
@@ -1197,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: {
@@ -1490,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) {
@@ -1509,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 {

package/src/transports/remote.ts

@@ -16,6 +16,7 @@ export class RemoteRuntimeHost extends HubRuntimeHost {
 				authToken: options.authToken,
 				clientType: options.clientType ?? "core-remote-runtime",
 				displayName: options.displayName ?? "core remote runtime",
+				requestToolApproval: options.requestToolApproval,
 			},
 			{
 				workspaceRoot: options.workspaceRoot,

package/src/types/config.ts

@@ -178,6 +178,15 @@ export interface CoreSessionConfig
 			| "missionLogIntervalMs"
 			| "maxConsecutiveMistakes"
 		> {
+	/**
+	 * Core/hub runtime session identifier.
+	 *
+	 * When provided, this becomes the host-owned id for persistence, hub
+	 * subscriptions, send/abort/stop commands, and approval routing. When
+	 * omitted, the runtime host creates one. This is distinct from the agent
+	 * conversation id, which is generated by the conversation store for
+	 * transcript/tool/hook context.
+	 */
 	sessionId?: string;
 	workspaceRoot?: string;
 	systemPrompt: string;

package/src/types/events.ts

@@ -36,14 +36,16 @@ export interface SessionTeamProgressEvent {
 	summary: import("@clinebot/shared").TeamProgressSummary;
 }
 
+export interface SessionPendingPrompt {
+	id: string;
+	prompt: string;
+	delivery: "queue" | "steer";
+	attachmentCount: number;
+}
+
 export interface SessionPendingPromptsEvent {
 	sessionId: string;
-	prompts: Array<{
-		id: string;
-		prompt: string;
-		delivery: "queue" | "steer";
-		attachmentCount: number;
-	}>;
+	prompts: SessionPendingPrompt[];
 }
 
 export interface SessionPendingPromptSubmittedEvent {

package/src/types/index.ts

@@ -9,6 +9,9 @@ export type {
 	CoreSessionEvent,
 	SessionChunkEvent,
 	SessionEndedEvent,
+	SessionPendingPrompt,
+	SessionPendingPromptSubmittedEvent,
+	SessionPendingPromptsEvent,
 	SessionTeamProgressEvent,
 	SessionToolEvent,
 } from "./events";

package/src/types/provider-settings.ts

@@ -1,12 +1,19 @@
 import { z } from "zod";
 import {
+	type ProviderClient,
 	type ProviderConfig,
+	type ProviderProtocol,
 	type ProviderSettings,
 	ProviderSettingsSchema,
 	toProviderConfig,
 } from "../llms/provider-settings";
 
-export type { ProviderConfig, ProviderSettings };
+export type {
+	ProviderClient,
+	ProviderConfig,
+	ProviderProtocol,
+	ProviderSettings,
+};
 export const ProviderSettingsSchemaTyped: z.ZodType<ProviderSettings> =
 	ProviderSettingsSchema;
 export { toProviderConfig };

package/src/types/session.ts

@@ -1,7 +1,7 @@
-import type { Agent } from "@clinebot/agents";
 import type * as LlmsProviders from "@clinebot/llms";
 import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
 import type { BuiltRuntime } from "../runtime/session-runtime";
+import type { SessionRuntime } from "../runtime/session-runtime-orchestrator";
 import type { SessionRow } from "../session/session-row";
 import type { RootSessionArtifacts } from "../session/session-service";
 import type { SessionSource, SessionStatus } from "./common";
@@ -14,9 +14,12 @@ export type ActiveSession = {
 	artifacts?: RootSessionArtifacts;
 	source: SessionSource;
 	startedAt: string;
+	status: SessionStatus;
+	endedAt?: string | null;
+	exitCode?: number | null;
 	pendingPrompt?: string;
 	runtime: BuiltRuntime;
-	agent: Agent;
+	agent: SessionRuntime;
 	started: boolean;
 	aborting: boolean;
 	interactive: boolean;