@xopcai/xopc 0.0.333 → 0.0.335

package/dist/src/gateway/hono/routes/sessions.js

@@ -1,13 +1,9 @@
 import { deleteBrowserTabBinding, init_browser_tab_binding_repository } from "../../../storage/sqlite/browser-tab-binding-repository.js";
-import { conversationIdSchema } from "../../../../packages/gateway-contract/src/conversation-identity.js";
 import { SessionDiscoveryQuerySchema } from "../../../../packages/gateway-contract/src/session-identity.js";
 import { init_src } from "../../../../packages/gateway-contract/src/index.js";
 import "../../../session/types.js";
-import { deleteSessionRecord, init_session_repository } from "../../../storage/sqlite/session-repository.js";
 import { SidebarLayoutConflictError, getSidebarLayout, init_sidebar_layout_repository, replaceSidebarLayout, sortBySidebarLayout } from "../../../storage/sqlite/sidebar-layout-repository.js";
-import { ConversationAlreadyExistsError, createConversation, init_conversation_repository } from "../../../storage/sqlite/conversation-repository.js";
-import { resolveProjectAgentId } from "../../../projects/project-agent.js";
-import "../../../projects/index.js";
+import { summarizeAiUsageByConversations } from "../../../storage/sqlite/ai-usage-repository.js";
 import { messagesToClientHistory } from "../../../session/client-history.js";
 import { evictEmbeddedSessionRunner } from "../../../agent/embedded/session-runner.js";
 import { SessionEnvironmentService } from "../../../execution-environments/session-environment-service.js";
@@ -17,11 +13,8 @@ import { createGatewayRouteLogger, logRouteError } from "../lib/route-logger.js"
 import { patchChatModelConfig } from "./chat-model-config.js";
 import { getSessionContextSummary } from "../../session-context-summary.js";
 import { respondStartupUnavailable } from "../lib/startup-unavailable.js";
-import { randomUUID } from "node:crypto";
 //#region src/gateway/hono/routes/sessions.ts
 init_src();
-init_conversation_repository();
-init_session_repository();
 init_browser_tab_binding_repository();
 init_sidebar_layout_repository();
 const log = createGatewayRouteLogger("Sessions");
@@ -36,9 +29,6 @@ const DEFAULT_SIDEBAR_STALE_DAYS = 60;
 function isSessionType(value) {
 	return SESSION_TYPES.has(value);
 }
-function parseExecutionMode(value) {
-	return value === "local_checkout" || value === "managed_worktree" ? value : void 0;
-}
 function ensureGatewayReadyForSessions(c, service, method) {
 	if (service.isGatewayReady()) return null;
 	return respondStartupUnavailable(c, method);
@@ -71,26 +61,6 @@ function isHistoryCursor(value) {
 	if (!/^(0|[1-9]\d*)$/.test(value)) return false;
 	return Number.isSafeInteger(Number(value));
 }
-function buildDirectSessionMetadata(params) {
-	return {
-		sourceChannel: params.source,
-		sourceChatId: [
-			params.accountId,
-			"direct",
-			params.peerId
-		].join(":"),
-		sessionType: "chat",
-		hiddenFromSessionList: true,
-		routing: {
-			agentId: params.agentId,
-			source: params.source,
-			accountId: params.accountId,
-			peerKind: "direct",
-			peerId: params.peerId
-		},
-		customData: { genericNewChatShell: params.source === "webchat" && params.peerId.startsWith("chat_") }
-	};
-}
 function registerSessionsRoutes(authenticated, deps) {
 	const { service } = deps;
 	const environments = new SessionEnvironmentService();
@@ -288,143 +258,6 @@ function registerSessionsRoutes(authenticated, deps) {
 			throw error;
 		}
 	});
-	authenticated.post("/api/sessions", async (c) => {
-		const body = await c.req.json().catch(() => ({}));
-		if (body.conversationId !== void 0 && !conversationIdSchema.safeParse(body.conversationId).success) return c.json({
-			ok: false,
-			error: "conversationId must be a UUID"
-		}, 400);
-		const channel = typeof body.channel === "string" && body.channel.trim() ? body.channel.trim() : "webchat";
-		const projectId = typeof body.projectId === "string" && body.projectId.trim() ? body.projectId.trim() : void 0;
-		const routingCfg = service.currentConfig;
-		const project = projectId ? service.projects.get(projectId) : null;
-		if (projectId && !project) return c.json({
-			ok: false,
-			error: "Project not found"
-		}, 404);
-		const requestedExecutionMode = parseExecutionMode(body.executionMode);
-		if (body.executionMode !== void 0 && !requestedExecutionMode) return c.json({
-			ok: false,
-			error: "Invalid execution mode"
-		}, 400);
-		if (requestedExecutionMode && !project) return c.json({
-			ok: false,
-			error: "An execution mode requires a project"
-		}, 400);
-		let agentId;
-		try {
-			agentId = resolveProjectAgentId({
-				config: routingCfg,
-				projects: service.projects,
-				explicitAgentId: typeof body.agentId === "string" ? body.agentId : void 0,
-				projectId
-			});
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			}, 400);
-		}
-		const chatId = (typeof body.chat_id === "string" && body.chat_id.trim() ? body.chat_id.trim() : void 0) ?? `chat_${randomUUID()}`;
-		const metadata = {
-			agentId,
-			...buildDirectSessionMetadata({
-				agentId,
-				source: channel,
-				accountId: "default",
-				peerId: chatId
-			}),
-			...channel === "tui" ? {
-				hiddenFromSessionList: true,
-				customData: { genericNewChatShell: true }
-			} : {}
-		};
-		let conversationId;
-		try {
-			conversationId = createConversation(metadata, "", body.conversationId).key;
-		} catch (error) {
-			if (error instanceof ConversationAlreadyExistsError) return c.json({
-				ok: false,
-				error: error.message
-			}, 409);
-			throw error;
-		}
-		let environment;
-		if (project && (project.workspaceRoot?.trim() || requestedExecutionMode)) try {
-			environment = await environments.attach({
-				conversationId,
-				project,
-				mode: requestedExecutionMode,
-				baseRef: typeof body.baseRef === "string" ? body.baseRef : void 0
-			});
-		} catch (error) {
-			deleteSessionRecord(conversationId);
-			return c.json({
-				ok: false,
-				code: "execution_environment_unavailable",
-				error: error instanceof Error ? error.message : String(error)
-			}, 409);
-		}
-		try {
-			await service.sessionIndexInstance.saveMessages(conversationId, [], { metadata });
-			if (projectId) service.projects.attachSession(conversationId, projectId);
-		} catch (error) {
-			await service.sessions.delete(conversationId).catch(() => void 0);
-			await environments.release(conversationId).catch(() => void 0);
-			throw error;
-		}
-		const rawInitialConfig = body.initialAgentConfig && typeof body.initialAgentConfig === "object" ? body.initialAgentConfig : {};
-		const model = typeof rawInitialConfig.model === "string" && rawInitialConfig.model.trim() ? rawInitialConfig.model.trim() : void 0;
-		const thinkingLevel = typeof rawInitialConfig.thinkingLevel === "string" && rawInitialConfig.thinkingLevel.trim() ? rawInitialConfig.thinkingLevel.trim() : void 0;
-		const initialAgentConfig = {
-			...model ? { model } : {},
-			...thinkingLevel ? { thinkingLevel } : {},
-			...body.temporary === true ? { userContextMode: "temporary" } : {}
-		};
-		if (channel === "webchat" && model) {
-			const result = await service.sessions.initializeChatModel(conversationId, model, thinkingLevel);
-			if (!result.ok) {
-				await service.sessions.delete(conversationId).catch(() => void 0);
-				await environments.release(conversationId).catch((error) => {
-					log.warn({
-						err: error,
-						conversationId
-					}, "Invalid new session model and execution environment cleanup failed");
-				});
-				return c.json({
-					ok: false,
-					error: result.error
-				}, 400);
-			}
-			delete initialAgentConfig.model;
-			delete initialAgentConfig.thinkingLevel;
-		}
-		if (Object.keys(initialAgentConfig).length > 0) {
-			const result = await service.sessions.patchAgentConfig(conversationId, initialAgentConfig);
-			if (!result.ok) {
-				await service.sessions.delete(conversationId).catch(() => void 0);
-				await environments.release(conversationId).catch((error) => {
-					log.warn({
-						err: error,
-						conversationId
-					}, "Invalid new session config and execution environment cleanup failed");
-				});
-				return c.json({
-					ok: false,
-					error: result.error
-				}, 400);
-			}
-		}
-		if (body.createdSurface === "browser_extension") await service.sessions.patch(conversationId, { customData: { createdSurface: "browser_extension" } });
-		const session = await service.sessions.getSession(conversationId);
-		const agentConfig = channel === "webchat" ? await service.sessions.getFixedAgentConfig(conversationId) : void 0;
-		return c.json({
-			conversationId,
-			session,
-			agentConfig,
-			...environment ? { environment } : {}
-		}, 201);
-	});
 	authenticated.get("/api/sessions", async (c) => {
 		const blocked = ensureGatewayReadyForSessions(c, service, "sessions.list");
 		if (blocked) return blocked;
@@ -454,7 +287,20 @@ function registerSessionsRoutes(authenticated, deps) {
 			limit: query.limit ? parseInt(query.limit) : void 0,
 			offset: query.offset ? parseInt(query.offset) : void 0
 		});
-		return c.json(result);
+		const usageByConversation = summarizeAiUsageByConversations(result.items.map((item) => item.key));
+		return c.json({
+			...result,
+			items: result.items.map((item) => ({
+				...item,
+				usage: usageByConversation.get(item.key) ?? {
+					calls: 0,
+					unknownCostCalls: 0,
+					totalTokens: 0,
+					knownCostUsd: "0",
+					costCompleteness: "unknown"
+				}
+			}))
+		});
 	});
 	authenticated.get("/api/sessions/stats", async (c) => {
 		const result = await service.sessions.stats();

package/dist/src/gateway/hono/routes/tasks.js

@@ -5,9 +5,9 @@ import { init_src } from "../../../../packages/gateway-contract/src/index.js";
 import { enqueueTaskChangedEvent, init_task_change_events } from "../../../tasks/task-change-events.js";
 import { TaskRepository, init_task_repository } from "../../../tasks/task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../../../tasks/task-run-repository.js";
-import { TaskConversationRepository } from "../../../tasks/task-conversation-repository.js";
 import { CapabilityError } from "../../../capabilities/runtime/errors.js";
 import "../../../capabilities/runtime/dispatcher.js";
+import { TaskConversationRepository } from "../../../tasks/task-conversation-repository.js";
 import { TaskContextMutationOutputSchema } from "../../../tasks/capabilities/relations.js";
 import { TaskDeleteOutputSchema } from "../../../tasks/capabilities/management.js";
 import { TaskMutationOutputSchema } from "../../../tasks/capabilities/write.js";

package/dist/src/gateway/hono/routes/tui.js

@@ -3,7 +3,8 @@ import { collectTuiStartupResources } from "../../../tui/tui-startup-resources.j
 function registerTuiRoutes(authenticated, deps) {
 	authenticated.get("/api/tui/startup-resources", (c) => {
 		const conversationId = c.req.query("conversationId")?.trim() || void 0;
-		const payload = collectTuiStartupResources(deps.service.currentConfig, conversationId);
+		const agentId = conversationId ? void 0 : c.req.query("agentId")?.trim();
+		const payload = collectTuiStartupResources(deps.service.currentConfig, conversationId, { agentId });
 		return c.json({
 			ok: true,
 			payload

package/dist/src/gateway/hono/routes/voice.js

@@ -14,6 +14,7 @@ import { mergeTtsConfigFromAppConfig } from "../../../voice/tts/merge-config.js"
 import { listSttProvidersForApi } from "../../../voice/stt/list-providers.js";
 import "../../../voice/tts/index.js";
 import { withModelConfigLock } from "../../../session/model-config-lock.js";
+import { getSessionPreparation } from "../../../storage/sqlite/session-creation-repository.js";
 import { resolveOmniRoute } from "../../../voice/realtime/omniRoute.js";
 import { VoiceSessionCreationError, resolveStreamingStt, resolveStreamingTts } from "../../../voice/realtime/runtime.js";
 import { getGatewayPrincipal } from "../../security/gateway-principal.js";
@@ -268,6 +269,14 @@ function registerVoiceRoutes(authenticated, deps) {
 			}
 		}, 400);
 		try {
+			const preparation = parsed.data.conversationId ? getSessionPreparation(parsed.data.conversationId) : void 0;
+			if (preparation && preparation.state !== "ready") return c.json({
+				ok: false,
+				error: {
+					code: "SESSION_PREPARING",
+					message: "Session environment is not ready"
+				}
+			}, 409);
 			if (action === "preflight") {
 				await service.voiceRealtime.preflight(parsed.data);
 				return c.json({ ok: true });

package/dist/src/gateway/image-generation-setup.js

@@ -1,11 +1,11 @@
 import { normalizeAgentId } from "../agent-catalog/id.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { ConfigSchema, init_schema } from "../config/schema.js";
 import { init_agent_scope } from "../agent/agent-scope.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
+import { ConfigSchema, init_schema } from "../config/schema.js";
 import { resolveEffectiveAgentConfigForAgent } from "../config/agent-profile.js";
 import { fetchWithTimeoutGuarded } from "../media-shared/http/provider-http.js";
 import "../media-shared/http/index.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getImageGenerationProvider, listImageGenerationProvidersSummary } from "../agent/image/generation/provider-registry.js";
 //#region src/gateway/image-generation-setup.ts
 init_repository();

package/dist/src/gateway/lock.js

@@ -1,8 +1,8 @@
 import path from "node:path";
 import fs from "node:fs";
 import { createHash } from "node:crypto";
-import net from "node:net";
 import fs$1 from "node:fs/promises";
+import net from "node:net";
 import { homedir } from "os";
 //#region src/gateway/lock.ts
 /**

package/dist/src/gateway/resolve-webchat-session-key.d.ts

@@ -10,6 +10,6 @@ export type ResolveWebchatConversationIdResult = {
 };
 /**
  * Resolve the server-owned session key for webchat `/api/agent` requests.
- * Creation is intentionally out-of-band via `POST /api/sessions`.
+ * Ordinary creation is accepted atomically by a start input command.
  */
 export declare function resolveWebchatConversationId(input: ResolveWebchatConversationIdInput): ResolveWebchatConversationIdResult;

package/dist/src/gateway/resolve-webchat-session-key.js

@@ -1,13 +1,13 @@
 //#region src/gateway/resolve-webchat-session-key.ts
 /**
 * Resolve the server-owned session key for webchat `/api/agent` requests.
-* Creation is intentionally out-of-band via `POST /api/sessions`.
+* Ordinary creation is accepted atomically by a start input command.
 */
 function resolveWebchatConversationId(input) {
 	const raw = input.conversationId?.trim() ?? "";
 	if (!raw) return {
 		ok: false,
-		error: "Missing conversationId; create sessions via POST /api/sessions"
+		error: "Missing conversationId"
 	};
 	return {
 		ok: true,

package/dist/src/gateway/service/run-gateway-agent.js

@@ -51,7 +51,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 		if (resolved.ok === false) throw new Error(resolved.error);
 		webchatConversationId = resolved.conversationId;
 		const meta = await sessionIndex.getSessionMetadata(webchatConversationId);
-		if (!meta) throw new Error("Session not found; create sessions via POST /api/sessions");
+		if (!meta) throw new Error("Session not found; submit a start input command first");
 		webchatTranscriptId = meta?.transcriptId;
 		webchatMetadata = meta;
 		runAbortControllers.set(runId, new AbortController());

package/dist/src/gateway/service/session-command-service.d.ts

@@ -0,0 +1,34 @@
+import type { SessionInputCommand, SessionMaterializeCommand } from '@xopcai/gateway-contract';
+import type { AgentSourceContext } from '../../agent/source-context/types.js';
+import { type SessionInputReceipt } from '../../storage/sqlite/session-creation-repository.js';
+import type { GatewayService } from '../service.js';
+export declare function receiveSessionCommand(service: GatewayService, conversationId: string, principalId: string, command: SessionInputCommand | SessionMaterializeCommand, prepareSourceContexts?: () => Promise<AgentSourceContext[]>): Promise<{
+    receipt: {
+        lifecycle: import("@xopcai/gateway-contract").SessionPreparationState;
+        conversationId: string;
+        clientMessageId: string;
+        inputId: string | null;
+        transcriptId: string;
+        acceptedAt: number;
+    };
+    session: import("../../session/types.js").SessionDetail;
+    agentConfig: import("../../agent/session/session-inspector.js").SessionAgentConfigView;
+    inputState: import("../../storage/sqlite/session-input-repository.js").SessionInputState;
+    effectiveDelivery: import("../../storage/sqlite/session-input-repository.js").SessionInputDelivery;
+    preparation: import("../../storage/sqlite/session-creation-repository.js").SessionPreparation;
+}>;
+export declare function sessionCommandSnapshot(service: GatewayService, receipt: SessionInputReceipt): Promise<{
+    receipt: {
+        lifecycle: import("@xopcai/gateway-contract").SessionPreparationState;
+        conversationId: string;
+        clientMessageId: string;
+        inputId: string | null;
+        transcriptId: string;
+        acceptedAt: number;
+    };
+    session: import("../../session/types.js").SessionDetail;
+    agentConfig: import("../../agent/session/session-inspector.js").SessionAgentConfigView;
+    inputState: import("../../storage/sqlite/session-input-repository.js").SessionInputState;
+    effectiveDelivery: import("../../storage/sqlite/session-input-repository.js").SessionInputDelivery;
+    preparation: import("../../storage/sqlite/session-creation-repository.js").SessionPreparation;
+}>;

package/dist/src/gateway/service/session-command-service.js

@@ -0,0 +1,81 @@
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../../storage/sqlite/session-repository.js";
+import { init_providers, resolveModel } from "../../providers/index.js";
+import { resolveProjectAgentId } from "../../projects/project-agent.js";
+import "../../projects/index.js";
+import { getModelThinking } from "../../providers/model-thinking.js";
+import { withModelConfigLock } from "../../session/model-config-lock.js";
+import { SessionCommandError, acceptSessionCommand, getSessionPreparation, matchSessionInputReceipt, sessionCommandHash } from "../../storage/sqlite/session-creation-repository.js";
+//#region src/gateway/service/session-command-service.ts
+init_providers();
+init_session_repository();
+function validateCreation(service, creation) {
+	const project = creation.projectId ? service.projects.get(creation.projectId) : null;
+	if (creation.projectId && !project) throw new Error("Project not found");
+	if (resolveProjectAgentId({
+		config: service.currentConfig,
+		projects: service.projects,
+		explicitAgentId: creation.agentId,
+		projectId: creation.projectId ?? void 0
+	}) !== creation.agentId) throw new Error("Invalid agent identity");
+	if (project?.workspaceRoot?.trim() && !creation.execution) throw new Error("Select an execution environment");
+	if (creation.execution && !project?.workspaceRoot?.trim()) throw new Error("Project requires a workspace");
+	if (!getModelThinking(resolveModel(creation.model)).options.includes(creation.thinkingLevel)) throw new Error("Unsupported model thinking level");
+}
+async function receiveSessionCommand(service, conversationId, principalId, command, prepareSourceContexts = async () => []) {
+	return withModelConfigLock(conversationId, async () => {
+		const clientMessageId = "commandId" in command ? command.commandId : command.clientMessageId;
+		const existing = matchSessionInputReceipt(conversationId, clientMessageId, principalId, sessionCommandHash(command));
+		if (existing) return sessionCommandSnapshot(service, existing);
+		if ("kind" in command && command.kind === "append") {
+			const session = getSessionMetadata(conversationId);
+			if (!session) throw new SessionCommandError("NOT_FOUND", "Conversation not found");
+			if (session.transcriptId !== command.expectedTranscriptId) throw new SessionCommandError("SESSION_CHANGED", "Conversation transcript changed");
+		}
+		if (service.voiceRealtime?.hasConversation(conversationId)) throw new SessionCommandError("SESSION_BUSY", "End the voice call before sending text");
+		if ("creation" in command) try {
+			validateCreation(service, command.creation);
+		} catch (error) {
+			throw new SessionCommandError("BAD_REQUEST", error instanceof Error ? error.message : "Invalid creation configuration");
+		}
+		const receipt = acceptSessionCommand({
+			conversationId,
+			principalId,
+			command,
+			preparedInput: "input" in command ? await service.prepareSessionCommandInput({
+				conversationId,
+				clientMessageId,
+				delivery: command.kind === "start" ? "next" : command.delivery,
+				content: command.input.content,
+				attachments: command.input.attachments,
+				contextRefs: command.input.contextRefs,
+				sourceContexts: await prepareSourceContexts(),
+				thinking: command.kind === "start" ? command.creation.thinkingLevel : (await service.sessions.getAgentConfig(conversationId)).thinkingLevel,
+				origin: command.origin.type === "endpoint" ? {
+					type: "endpoint",
+					endpointId: command.origin.endpointId
+				} : command.origin
+			}) : void 0,
+			attachProject: (id, projectId) => service.projects.attachSession(id, projectId)
+		});
+		if ("kind" in command && command.kind === "append" && command.delivery === "steer" && receipt.inputId) await service.dispatchAcceptedSessionInput(conversationId, receipt.inputId);
+		return sessionCommandSnapshot(service, receipt);
+	});
+}
+async function sessionCommandSnapshot(service, receipt) {
+	const { principalId: _principal, requestHash: _hash, ...identity } = receipt;
+	const inputState = service.getSessionInputState(receipt.conversationId);
+	return {
+		receipt: {
+			...identity,
+			lifecycle: getSessionPreparation(receipt.conversationId)?.state ?? "ready"
+		},
+		session: await service.sessions.getSession(receipt.conversationId),
+		agentConfig: await service.sessions.getAgentConfig(receipt.conversationId),
+		inputState,
+		effectiveDelivery: inputState.inputs.find((input) => input.id === receipt.inputId)?.effectiveDelivery ?? "next",
+		preparation: getSessionPreparation(receipt.conversationId)
+	};
+}
+//#endregion
+export { receiveSessionCommand, sessionCommandSnapshot };

package/dist/src/gateway/service/session-input-coordinator.d.ts

@@ -44,6 +44,27 @@ export declare class SessionInputCoordinator {
         emit: (type: string, payload: unknown) => void;
     });
     snapshot(conversationId: string): SessionInputState;
+    prepareInput(input: SubmitSessionInput): Promise<{
+        status: "queued";
+        requestedDelivery: SessionInputDelivery;
+        effectiveDelivery: "next";
+        content: string;
+        attachments: UserTurnAttachment[];
+        contextRefs: import("../../agent/source-context/types.js").SourceContextRefSummary[];
+        contextSnapshots: AgentSourceContext[];
+        thinking: string;
+        origin: {
+            type: "endpoint";
+            endpointId: string;
+        } | {
+            type: "channel";
+            channel: string;
+        } | {
+            type: "system";
+            source: "automation" | "cli" | "workflow" | "heartbeat" | "internal";
+        };
+    }>;
+    dispatchAcceptedInput(conversationId: string, inputId: string): Promise<void>;
     private publish;
     private runSubmissionExclusive;
     submit(input: SubmitSessionInput): Promise<{

package/dist/src/gateway/service/session-input-coordinator.js

@@ -42,6 +42,47 @@ var SessionInputCoordinator = class {
 	snapshot(conversationId) {
 		return getSessionInputState(conversationId);
 	}
+	async prepareInput(input) {
+		const attachments = await this.deps.prepareAttachments(input.conversationId, input.attachments);
+		const contexts = fitSourceContextsToBudget([...await this.deps.prepareContexts(input.conversationId, input.contextRefs) ?? [], ...input.sourceContexts ?? []]);
+		return {
+			status: "queued",
+			requestedDelivery: input.delivery,
+			effectiveDelivery: "next",
+			content: input.content.trim(),
+			attachments,
+			contextRefs: contexts.map(summarizeSourceContext),
+			contextSnapshots: contexts,
+			thinking: input.thinking,
+			origin: input.origin
+		};
+	}
+	async dispatchAcceptedInput(conversationId, inputId) {
+		const input = getSessionInputById(conversationId, inputId);
+		if (!input) return;
+		await this.runSubmissionExclusive(input.conversationId, async () => {
+			const row = getSessionInputById(conversationId, inputId);
+			const state = this.snapshot(input.conversationId);
+			if (!row || row.status !== "queued" || row.origin.type === "endpoint" || row.requestedDelivery !== "steer" || !state.activeRunId || row.attachments?.length || row.contextSnapshots?.length || state.preparation && state.preparation.state !== "ready") return;
+			setSessionInputStatus(row.id, "injecting", {
+				effectiveDelivery: "steer",
+				targetRunId: state.activeRunId
+			});
+			try {
+				if (!await this.deps.steer(row.conversationId, row.content)) setSessionInputStatus(row.id, "queued", {
+					effectiveDelivery: "next",
+					targetRunId: null
+				});
+			} catch (error) {
+				log.warn({
+					err: error,
+					conversationId: row.conversationId,
+					inputId
+				}, "Accepted steering input awaits execution recovery");
+			}
+			this.publish(row.conversationId);
+		});
+	}
 	publish(conversationId) {
 		const state = this.snapshot(conversationId);
 		this.deps.emit("session.input-state", state);

package/dist/src/gateway/service/session-preparation-worker.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectService } from '../../projects/project-service.js';
+import type { SessionInputState } from '../../storage/sqlite/session-input-repository.js';
+export interface SessionPreparationWorkerService {
+    projects: Pick<ProjectService, 'get'>;
+    drainSessionInputs(conversationId: string): Promise<unknown>;
+    getSessionInputState(conversationId: string): SessionInputState;
+    emit(type: string, payload: unknown): void;
+}
+export declare class SessionPreparationWorker {
+    private readonly service;
+    private timer?;
+    private readonly active;
+    private cleaning;
+    private cleanupTask?;
+    private readonly environments;
+    constructor(service: SessionPreparationWorkerService);
+    start(): void;
+    stop(): Promise<void>;
+    wake(conversationId: string): void;
+    private cleanup;
+    private prepare;
+}