@moxt-ai/mobius 0.0.26 → 0.0.28

package/dist/run-daemon.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { basename, join } from "node:path";
 import { styleText } from "node:util";
-import { AGENT_ACTIVITY_KIND, AGENT_INSTALL_CANCEL_KIND, AGENT_INSTALL_CANCELLED_KIND, AGENT_INSTALL_COMPLETED_KIND, AGENT_INSTALL_FAILED_KIND, AGENT_INSTALL_PROGRESS_KIND, AGENT_INSTALL_REQUEST_KIND, AGENT_INSTALL_STARTED_KIND, AGENT_MESSAGE_DELTA_KIND, BOT_BINDING_APPROVAL_REQUEST_KIND, BOT_BINDING_APPROVED_KIND, BOT_BINDING_UNAVAILABLE_KIND, BOT_SESSION_PROMPT_KIND, BotExecutionBindingUnavailableEvent, decodeAgentInstallCancelCommand, decodeAgentInstallRequestCommand, decodeBotExecutionBindingApprovalRequest, decodeBotExecutionBindingApprovedEvent, decodeBotExecutionBindingUnavailableEvent, decodeBotSessionPromptCommand, decodeMessageKind, decodeNativeSessionCancel, decodeNativeSessionCommand, decodeNativeSessionTurnForkCommand, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionEventAcknowledgement, decodeSessionEventEnvelope, decodeSessionEventRejection, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallStartedEvent, encodeAgentMessageDeltaEvent, encodeBotExecutionBindingApprovedEvent, encodeBotExecutionBindingUnavailableEvent, encodeNativeSessionResult, encodeSessionCommandsUpdatedEvent, encodeSessionCompletedEvent, encodeSessionConfigUpdatedEvent, encodeSessionElicitationRequestedEvent, encodeSessionElicitationResolvedEvent, encodeSessionFailedEvent, encodeSessionInfoUpdatedEvent, encodeSessionOperationFailedEvent, encodeSessionPermissionRequestedEvent, encodeSessionPermissionResolvedEvent, encodeSessionReadyEvent, encodeSessionStartedEvent, encodeSessionUsageUpdatedEvent, encodeWorkspaceEntriesEvent, NATIVE_SESSION_CANCEL_KIND, NATIVE_SESSION_REQUEST_KIND, NATIVE_SESSION_TURN_FORK_KIND, OwnerBotReplyRoute, RUNTIME_HEARTBEAT_ACK_KIND, RUNTIME_LIVENESS_READY_KIND, SESSION_CANCEL_KIND, SESSION_COMPLETED_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_EVENT_ACK_KIND, SESSION_EVENT_REJECTED_KIND, SESSION_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, SessionPromptDisposition, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
+import { AGENT_ACTIVITY_KIND, AGENT_INSTALL_CANCEL_KIND, AGENT_INSTALL_CANCELLED_KIND, AGENT_INSTALL_COMPLETED_KIND, AGENT_INSTALL_FAILED_KIND, AGENT_INSTALL_PROGRESS_KIND, AGENT_INSTALL_REQUEST_KIND, AGENT_INSTALL_STARTED_KIND, AGENT_MESSAGE_DELTA_KIND, BOT_BINDING_APPROVAL_REQUEST_KIND, BOT_BINDING_APPROVED_KIND, BOT_BINDING_UNAVAILABLE_KIND, BOT_SESSION_PROMPT_KIND, BotExecutionBindingUnavailableEvent, decodeAgentInstallCancelCommand, decodeAgentInstallRequestCommand, decodeBotExecutionBindingApprovalRequest, decodeBotExecutionBindingApprovedEvent, decodeBotExecutionBindingUnavailableEvent, decodeBotSessionPromptCommand, decodeMessageKind, decodeNativeSessionCancel, decodeNativeSessionCommand, decodeNativeSessionTurnForkCommand, decodeRuntimeDelivery, decodeRuntimeDeliveryCommitted, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionEventAcknowledgement, decodeSessionEventEnvelope, decodeSessionEventRejection, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallStartedEvent, encodeAgentMessageDeltaEvent, encodeBotExecutionBindingApprovedEvent, encodeBotExecutionBindingUnavailableEvent, encodeNativeSessionResult, encodeRuntimeDeliveryReceived, encodeSessionCommandsUpdatedEvent, encodeSessionCompletedEvent, encodeSessionConfigUpdatedEvent, encodeSessionElicitationRequestedEvent, encodeSessionElicitationResolvedEvent, encodeSessionFailedEvent, encodeSessionInfoUpdatedEvent, encodeSessionOperationFailedEvent, encodeSessionPermissionRequestedEvent, encodeSessionPermissionResolvedEvent, encodeSessionReadyEvent, encodeSessionStartedEvent, encodeSessionUsageUpdatedEvent, encodeWorkspaceEntriesEvent, NATIVE_SESSION_CANCEL_KIND, NATIVE_SESSION_REQUEST_KIND, NATIVE_SESSION_TURN_FORK_KIND, OwnerBotReplyRoute, RUNTIME_DELIVERY_COMMITTED_KIND, RUNTIME_DELIVERY_KIND, RUNTIME_DELIVERY_RECEIVED_KIND, RUNTIME_HEARTBEAT_ACK_KIND, RUNTIME_LIVENESS_READY_KIND, SESSION_CANCEL_KIND, SESSION_COMPLETED_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_EVENT_ACK_KIND, SESSION_EVENT_REJECTED_KIND, SESSION_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, SessionPromptDisposition, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
 import { fetch, WebSocket } from "undici";
 import { AcpExecutionError, AcpSessionManager } from "./acp/session-manager.js";
 import { SqliteAcpSessionStore } from "./acp/session-store.js";
@@ -10,6 +10,7 @@ import { LocalAgentCatalogError, LocalAgentDefinition } from "./agent-catalog/lo
 import { publishAgentCatalog } from "./agent-catalog/publish-agent-catalog.js";
 import { AgentInstallationManager, CancelledInstallation, FailedInstallation, RequestedInstallation, RunningInstallation, SucceededInstallation, } from "./agent-installation/agent-installation-manager.js";
 import { FixedInstallationExecutor } from "./agent-installation/fixed-installation-executor.js";
+import { uploadRuntimeArtifact } from "./artifacts/runtime-artifact-uploader.js";
 import { LocalAuthorizationError } from "./authorization/local-authorization-error.js";
 import { WorkspaceDirectoryService } from "./authorization/workspace-directory.js";
 import { EmbeddedBotContextApplicator } from "./bots/bot-context-applicator.js";
@@ -22,7 +23,8 @@ import { PromptArtifactError, resolvePromptArtifacts } from "./prompt-artifact-r
 import { connectRelay } from "./relay-connection/connect.js";
 import { RelayConnectionDiagnostics } from "./relay-connection/diagnostics.js";
 import { RelayConnectionLiveness } from "./relay-connection/liveness.js";
-import { SessionEventOutbox } from "./relay-connection/session-event-outbox.js";
+import { relayHttpEndpoint, runtimeAuthorization } from "./relay-connection/runtime-authentication.js";
+import { RuntimeDeliveryInboxCapacityError, SessionEventOutbox } from "./relay-connection/session-event-outbox.js";
 import { systemDaemonTimer } from "./relay-connection/timer.js";
 import { readStateDirectory } from "./storage/state-directory.js";
 const RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
@@ -36,10 +38,24 @@ function botIpcSocketPath() {
     return join("/tmp", `mobius-bot-${randomUUID()}.sock`);
 }
 class DaemonAcpObserver {
+    #config;
     #record;
-    constructor(record) {
+    constructor(config, record) {
+        this.#config = config;
         this.#record = record;
     }
+    importLocalImage = async (sessionId, image, signal) => {
+        try {
+            return (await uploadRuntimeArtifact(this.#config, sessionId, image, signal)).artifactId;
+        }
+        catch (cause) {
+            signal.throwIfAborted();
+            if (cause instanceof Error && cause.name === "AbortError") {
+                throw cause;
+            }
+            return "";
+        }
+    };
     onCommands = (event) => {
         this.#record(event.sessionId, encodeSessionCommandsUpdatedEvent(event));
         return Promise.resolve();
@@ -215,8 +231,7 @@ class ActiveTurnReconciliationError extends Error {
     }
 }
 function activeTurnReconciliationEndpoint(config, turn) {
-    const endpoint = new URL(config.relayUrl);
-    endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
+    const endpoint = relayHttpEndpoint(config.relayUrl);
     let channelPath = "";
     if (endpoint.pathname.endsWith("/daemon")) {
         channelPath = endpoint.pathname.slice(0, -"/daemon".length);
@@ -229,7 +244,6 @@ function activeTurnReconciliationEndpoint(config, turn) {
         channelPath = `${endpoint.pathname.slice(0, -runtimePath.length)}/channels/${encodeURIComponent(config.channelId)}`;
     }
     endpoint.pathname = `${channelPath}/sessions/${encodeURIComponent(turn.command.sessionId)}/attempts/${encodeURIComponent(turn.attemptId)}/reconciliation`;
-    endpoint.searchParams.delete("liveness");
     return endpoint;
 }
 async function reconcileActiveTurn(config, turn, signal) {
@@ -241,7 +255,7 @@ async function reconcileActiveTurn(config, turn, signal) {
         response = await fetch(activeTurnReconciliationEndpoint(config, turn), {
             body: JSON.stringify({ outcome: { kind: "running" } }),
             dispatcher: environmentProxyDispatcher,
-            headers: { "content-type": "application/json" },
+            headers: { ...runtimeAuthorization(config.relayUrl), "content-type": "application/json" },
             method: "POST",
             signal: requestSignal,
         });
@@ -311,17 +325,33 @@ class ConnectedDaemonSessionEventState extends DaemonSessionEventConnectionState
         }
     };
 }
-const SESSION_EVENT_REPLAY_WINDOW = 4;
+const SESSION_EVENT_REPLAY_WINDOW = 16;
+const SESSION_EVENT_SOURCE_REPLAY_WINDOW = 4;
+const SESSION_EVENT_REPLAY_BYTE_LIMIT = 32 * 1024 * 1024;
+class InFlightSessionEvent {
+    byteLength;
+    sourceKey;
+    constructor(sourceKey, byteLength) {
+        this.byteLength = byteLength;
+        this.sourceKey = sourceKey;
+    }
+}
+function sessionEventSourceKey(envelope) {
+    return envelope.source.kind === "attempt"
+        ? `attempt:${envelope.sessionId}:${envelope.source.attemptId}`
+        : `runtime:${envelope.sessionId}`;
+}
 class DaemonSessionEventPublisher {
     #outbox;
-    #inFlightEventIds = new Set();
+    #inFlightEvents = new Map();
+    #inFlightBytes = 0;
     #connection = new DisconnectedDaemonSessionEventState();
     constructor(outbox) {
         this.#outbox = outbox;
     }
     connect = (socket) => {
         this.#connection = new ConnectedDaemonSessionEventState(socket);
-        this.#inFlightEventIds.clear();
+        this.#clearInFlight();
         this.#publishNextBatch();
     };
     disconnect = (socket) => {
@@ -329,10 +359,16 @@ class DaemonSessionEventPublisher {
             return;
         }
         this.#connection = this.#connection.disconnect(socket);
-        this.#inFlightEventIds.clear();
+        this.#clearInFlight();
     };
     recordAttempt = (sessionId, payload, attemptId) => {
-        this.#outbox.enqueue(sessionId, payload, attemptId);
+        const kind = decodeMessageKind(payload);
+        if (kind === SESSION_COMPLETED_KIND || kind === SESSION_FAILED_KIND) {
+            this.#outbox.enqueueCritical(sessionId, payload, attemptId);
+        }
+        else {
+            this.#outbox.enqueue(sessionId, payload, attemptId);
+        }
         this.#publishNextBatch();
     };
     recordRuntime = (sessionId, payload) => {
@@ -343,7 +379,7 @@ class DaemonSessionEventPublisher {
         if (!this.#outbox.acknowledge(acknowledgement)) {
             return;
         }
-        this.#inFlightEventIds.delete(acknowledgement.eventId);
+        this.#removeInFlight(acknowledgement.eventId);
         this.#publishNextBatch();
     };
     quarantine = (rejection) => {
@@ -351,24 +387,58 @@ class DaemonSessionEventPublisher {
         if (!quarantined) {
             return false;
         }
-        this.#inFlightEventIds.delete(rejection.eventId);
+        this.#removeInFlight(rejection.eventId);
         this.#publishNextBatch();
         return true;
     };
     #publishNextBatch = () => {
-        if (this.#inFlightEventIds.size > 0) {
-            return;
-        }
-        const batch = this.#outbox.pendingBatch(SESSION_EVENT_REPLAY_WINDOW);
-        for (const encoded of batch) {
-            const envelope = decodeSessionEventEnvelope(encoded);
-            if (!this.#connection.send(encoded)) {
-                this.#inFlightEventIds.clear();
+        while (this.#inFlightEvents.size < SESSION_EVENT_REPLAY_WINDOW) {
+            const sourceCounts = new Map();
+            for (const inFlight of this.#inFlightEvents.values()) {
+                sourceCounts.set(inFlight.sourceKey, (sourceCounts.get(inFlight.sourceKey) ?? 0) + 1);
+            }
+            const saturatedSources = [...sourceCounts.entries()]
+                .filter(([, count]) => count >= SESSION_EVENT_SOURCE_REPLAY_WINDOW)
+                .map(([sourceKey]) => sourceKey);
+            const batch = this.#outbox.pendingSourceHeads(SESSION_EVENT_REPLAY_WINDOW - this.#inFlightEvents.size, [...this.#inFlightEvents.keys()], saturatedSources);
+            let sent = 0;
+            for (const encoded of batch) {
+                const envelope = decodeSessionEventEnvelope(encoded);
+                const sourceKey = sessionEventSourceKey(envelope);
+                const sourceCount = sourceCounts.get(sourceKey) ?? 0;
+                if (sourceCount >= SESSION_EVENT_SOURCE_REPLAY_WINDOW) {
+                    continue;
+                }
+                const byteLength = new TextEncoder().encode(encoded).byteLength;
+                if (this.#inFlightBytes + byteLength > SESSION_EVENT_REPLAY_BYTE_LIMIT) {
+                    continue;
+                }
+                if (!this.#connection.send(encoded)) {
+                    this.#clearInFlight();
+                    return;
+                }
+                this.#inFlightEvents.set(envelope.eventId, new InFlightSessionEvent(sourceKey, byteLength));
+                this.#inFlightBytes += byteLength;
+                sourceCounts.set(sourceKey, sourceCount + 1);
+                sent += 1;
+            }
+            if (sent === 0) {
                 return;
             }
-            this.#inFlightEventIds.add(envelope.eventId);
         }
     };
+    #removeInFlight = (eventId) => {
+        const inFlight = this.#inFlightEvents.get(eventId);
+        if (inFlight === undefined) {
+            return;
+        }
+        this.#inFlightEvents.delete(eventId);
+        this.#inFlightBytes -= inFlight.byteLength;
+    };
+    #clearInFlight = () => {
+        this.#inFlightEvents.clear();
+        this.#inFlightBytes = 0;
+    };
 }
 class CoalescingDaemonActivityPublisher {
     #pending = new Map();
@@ -597,6 +667,9 @@ async function executeSessionConfigure(publisher, socket, command, config, direc
         }));
     }
     catch (error) {
+        if (signal.aborted) {
+            signal.throwIfAborted();
+        }
         reportOperationFailure(socket, command.requestId, command.sessionId, error);
     }
 }
@@ -865,6 +938,7 @@ async function publishAgentCatalogUntilAvailable(config, diagnostics, signal, ti
 }
 async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, grants, contexts, applicator, ipc, activeTurns, activeAttemptIds, connectionEpoch, diagnostics, onConnected, signal, timer) {
     const relayUrl = new URL(config.relayUrl);
+    relayUrl.searchParams.set("deliveryReceipts", "1");
     relayUrl.searchParams.set("liveness", "1");
     const socket = await connectRelay(relayUrl, signal);
     const reconnectingTurns = [...activeTurns.values()];
@@ -913,6 +987,189 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                 closeRelaySocket(socket, code, reason);
                 rejectConnection(failure);
             };
+            const processingDeliveryIds = new Set();
+            const processDeliveredPrompt = async (delivery, command, trackActiveAttempt, execute) => {
+                if (command.sessionId !== delivery.sessionId) {
+                    throw new Error("Runtime delivery Session identity does not match its payload");
+                }
+                const active = activeTurns.get(command.commandId);
+                if (active !== undefined) {
+                    await active.completion;
+                    return;
+                }
+                const receipt = outbox.claimExecution(command.commandId, command.sessionId, delivery.payload);
+                if (receipt.kind === "duplicate") {
+                    if (receipt.state === "running") {
+                        reportFailure(publisher, command, "agent_execution_interrupted", "The local Agent execution was interrupted before it completed", receipt.attemptId);
+                        outbox.transitionExecution(command.commandId, "failed");
+                        return;
+                    }
+                    if (receipt.state !== "dispatching") {
+                        return;
+                    }
+                }
+                const turn = new ActiveDaemonTurn(command, receipt.attemptId);
+                activeTurns.set(command.commandId, turn);
+                if (trackActiveAttempt) {
+                    activeAttemptIds.set(command.sessionId, receipt.attemptId);
+                }
+                try {
+                    await execute(receipt.attemptId, turn.signal);
+                }
+                finally {
+                    activeTurns.delete(command.commandId);
+                    if (activeAttemptIds.get(command.sessionId) === receipt.attemptId) {
+                        activeAttemptIds.delete(command.sessionId);
+                    }
+                    turn.finish();
+                }
+            };
+            const processDeliveredPayload = async (delivery) => {
+                const kind = decodeMessageKind(delivery.payload);
+                if (kind === SESSION_CANCEL_KIND) {
+                    const cancellation = decodeSessionCancelCommand(delivery.payload);
+                    if (cancellation.sessionId !== delivery.sessionId) {
+                        throw new Error("Runtime delivery Session identity does not match its payload");
+                    }
+                    const turn = activeTurns.get(cancellation.commandId);
+                    if (turn === undefined || !turn.matches(cancellation) || !turn.requestCancellation()) {
+                        return;
+                    }
+                    audit.record({
+                        commandId: cancellation.commandId,
+                        event: "session_cancellation_requested",
+                        sessionId: cancellation.sessionId,
+                    });
+                    await sessions.cancelPrompt(cancellation.sessionId);
+                    return;
+                }
+                if (kind === SESSION_CONFIGURE_KIND) {
+                    const command = decodeSessionConfigureCommand(delivery.payload);
+                    if (command.sessionId !== delivery.sessionId) {
+                        throw new Error("Runtime delivery Session identity does not match its payload");
+                    }
+                    await executeSessionConfigure(publisher, socket, command, config, directories, audit, sessions, connectionController.signal);
+                    return;
+                }
+                if (kind === SESSION_PERMISSION_RESPOND_KIND) {
+                    const command = decodeSessionPermissionRespondCommand(delivery.payload);
+                    if (command.sessionId !== delivery.sessionId) {
+                        throw new Error("Runtime delivery Session identity does not match its payload");
+                    }
+                    try {
+                        await sessions.respondPermission(command);
+                        audit.record({
+                            commandId: command.interactionId,
+                            event: "session_permission_resolved",
+                            sessionId: command.sessionId,
+                        });
+                    }
+                    catch (error) {
+                        reportOperationFailure(socket, command.interactionId, command.sessionId, error);
+                    }
+                    return;
+                }
+                if (kind === SESSION_ELICITATION_RESPOND_KIND) {
+                    const command = decodeSessionElicitationRespondCommand(delivery.payload);
+                    if (command.sessionId !== delivery.sessionId) {
+                        throw new Error("Runtime delivery Session identity does not match its payload");
+                    }
+                    try {
+                        await sessions.respondElicitation(command);
+                        audit.record({
+                            commandId: command.interactionId,
+                            event: "session_elicitation_resolved",
+                            sessionId: command.sessionId,
+                        });
+                    }
+                    catch (error) {
+                        reportOperationFailure(socket, command.interactionId, command.sessionId, error);
+                    }
+                    return;
+                }
+                if (kind === BOT_SESSION_PROMPT_KIND) {
+                    const command = decodeBotSessionPromptCommand(delivery.payload);
+                    await processDeliveredPrompt(delivery, command, true, (attemptId, executionSignal) => executeBotPrompt(outbox, publisher, command, config, directories, audit, sessions, grants, contexts, applicator, ipc, attemptId, timer, executionSignal));
+                    return;
+                }
+                if (kind === SESSION_PROMPT_KIND) {
+                    const command = decodeSessionPromptCommand(delivery.payload);
+                    await processDeliveredPrompt(delivery, command, command.disposition !== SessionPromptDisposition.Steer, (attemptId, executionSignal) => executePrompt(outbox, publisher, command, config, directories, audit, sessions, attemptId, timer, executionSignal));
+                    return;
+                }
+                throw new Error("Runtime delivery contains an unsupported protocol message");
+            };
+            const processRuntimeDelivery = (delivery, state) => {
+                if (state === "processed" || processingDeliveryIds.has(delivery.deliveryId)) {
+                    return;
+                }
+                processingDeliveryIds.add(delivery.deliveryId);
+                void processDeliveredPayload(delivery)
+                    .then(() => {
+                    outbox.markRuntimeDeliveryProcessed(delivery.deliveryId, delivery.sessionId);
+                })
+                    .catch((error) => {
+                    if (connectionController.signal.aborted) {
+                        return;
+                    }
+                    console.error("Mobius daemon could not process a durable Runtime delivery", error);
+                    failAndClose(new Error("Runtime delivery processing failed", { cause: error }), 4008, "Invalid Runtime delivery", "delivery");
+                })
+                    .finally(() => processingDeliveryIds.delete(delivery.deliveryId));
+            };
+            const receiveRuntimeDelivery = (delivery) => {
+                const payloadKind = decodeMessageKind(delivery.payload);
+                let payloadSessionId = "";
+                if (payloadKind === SESSION_CANCEL_KIND) {
+                    payloadSessionId = decodeSessionCancelCommand(delivery.payload).sessionId;
+                }
+                else if (payloadKind === SESSION_CONFIGURE_KIND) {
+                    payloadSessionId = decodeSessionConfigureCommand(delivery.payload).sessionId;
+                }
+                else if (payloadKind === SESSION_PERMISSION_RESPOND_KIND) {
+                    payloadSessionId = decodeSessionPermissionRespondCommand(delivery.payload).sessionId;
+                }
+                else if (payloadKind === SESSION_ELICITATION_RESPOND_KIND) {
+                    payloadSessionId = decodeSessionElicitationRespondCommand(delivery.payload).sessionId;
+                }
+                else if (payloadKind === SESSION_PROMPT_KIND) {
+                    payloadSessionId = decodeSessionPromptCommand(delivery.payload).sessionId;
+                }
+                else if (payloadKind === BOT_SESSION_PROMPT_KIND) {
+                    payloadSessionId = decodeBotSessionPromptCommand(delivery.payload).sessionId;
+                }
+                else {
+                    throw new Error("Runtime delivery contains an unsupported protocol message");
+                }
+                if (payloadSessionId !== delivery.sessionId) {
+                    throw new Error("Runtime delivery Session identity does not match its payload");
+                }
+                const stored = outbox.claimRuntimeDelivery(delivery);
+                send(socket, encodeRuntimeDeliveryReceived({
+                    deliveryId: delivery.deliveryId,
+                    kind: RUNTIME_DELIVERY_RECEIVED_KIND,
+                    sessionId: delivery.sessionId,
+                }));
+                processRuntimeDelivery(delivery, stored.state);
+            };
+            const resumeRuntimeDeliveries = () => {
+                for (const stored of outbox.runtimeDeliveries()) {
+                    const delivery = {
+                        deliveryId: stored.deliveryId,
+                        kind: RUNTIME_DELIVERY_KIND,
+                        payload: stored.payload,
+                        sessionId: stored.sessionId,
+                    };
+                    if (stored.state !== "relay_committed") {
+                        send(socket, encodeRuntimeDeliveryReceived({
+                            deliveryId: stored.deliveryId,
+                            kind: RUNTIME_DELIVERY_RECEIVED_KIND,
+                            sessionId: stored.sessionId,
+                        }));
+                    }
+                    processRuntimeDelivery(delivery, stored.state);
+                }
+            };
             const connectionLiveness = new RelayConnectionLiveness(timer, {
                 send: (message) => send(socket, message),
                 unresponsive: (heartbeatId, timeoutMilliseconds) => {
@@ -946,6 +1203,17 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                 }
                 try {
                     const kind = decodeMessageKind(encoded);
+                    if (kind === RUNTIME_DELIVERY_COMMITTED_KIND) {
+                        const committed = decodeRuntimeDeliveryCommitted(encoded);
+                        if (!outbox.markRuntimeDeliveryCommitted(committed.deliveryId, committed.sessionId)) {
+                            console.warn("Mobius daemon ignored confirmation for an unknown Runtime delivery");
+                        }
+                        return;
+                    }
+                    if (kind === RUNTIME_DELIVERY_KIND) {
+                        receiveRuntimeDelivery(decodeRuntimeDelivery(encoded));
+                        return;
+                    }
                     if (kind === SESSION_EVENT_ACK_KIND) {
                         publisher.acknowledge(decodeSessionEventAcknowledgement(encoded));
                         return;
@@ -1291,6 +1559,10 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                 }
                 catch (error) {
                     console.error("Mobius daemon rejected a message", error);
+                    if (error instanceof RuntimeDeliveryInboxCapacityError) {
+                        failAndClose(error, 4013, "Runtime delivery queue full", "delivery_backpressure");
+                        return;
+                    }
                     failAndClose(new Error("Relay sent an invalid protocol message", { cause: error }), 4008, "Invalid protocol message", "protocol");
                 }
             };
@@ -1302,6 +1574,7 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                     return;
                 }
                 publisher.connect(socket);
+                resumeRuntimeDeliveries();
             }, (error) => {
                 if (finished) {
                     return;
@@ -1348,7 +1621,7 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
         }
         publisher.recordAttempt(sessionId, payload, attemptId);
     };
-    const sessions = new AcpSessionManager(new DaemonAcpObserver(recordSessionEvent), sessionStore);
+    const sessions = new AcpSessionManager(new DaemonAcpObserver(config, recordSessionEvent), sessionStore);
     const directories = new WorkspaceDirectoryService(config.bindingId, config.defaultWorkspace);
     const installationObserver = new DaemonInstallationObserver();
     const diagnostics = new RelayConnectionDiagnostics(audit, config.channelId, config.relayUrl);