@moxt-ai/mobius 0.0.17 → 0.0.19

package/dist/run-daemon.js

@@ -1,26 +1,28 @@
 import { basename } 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, decodeAgentInstallCancelCommand, decodeAgentInstallRequestCommand, decodeMessageKind, decodeNativeSessionCancel, decodeNativeSessionCommand, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionEventAcknowledgement, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallStartedEvent, encodeAgentMessageDeltaEvent, encodeNativeSessionResult, encodeSessionCommandsUpdatedEvent, encodeSessionCompletedEvent, encodeSessionConfigUpdatedEvent, encodeSessionElicitationRequestedEvent, encodeSessionElicitationResolvedEvent, encodeSessionFailedEvent, encodeSessionInfoUpdatedEvent, encodeSessionOperationFailedEvent, encodeSessionPermissionRequestedEvent, encodeSessionPermissionResolvedEvent, encodeSessionReadyEvent, encodeSessionStartedEvent, encodeSessionUsageUpdatedEvent, encodeWorkspaceEntriesEvent, NATIVE_SESSION_CANCEL_KIND, NATIVE_SESSION_REQUEST_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_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
-import { WebSocket } from "undici";
-import { AcpExecutionError, AcpSessionManager, NullAcpSessionObserver, } from "./acp/session-manager.js";
+import { fetch, WebSocket } from "undici";
+import { AcpExecutionError, AcpSessionManager } from "./acp/session-manager.js";
 import { SqliteAcpSessionStore } from "./acp/session-store.js";
 import { supportedLocalAgentSpecifications } from "./agent-catalog/discover-local-agents.js";
 import { LocalAgentCatalogError } from "./agent-catalog/local-agent.js";
 import { publishAgentCatalog } from "./agent-catalog/publish-agent-catalog.js";
 import { AgentInstallationManager, CancelledInstallation, FailedInstallation, RequestedInstallation, RunningInstallation, SucceededInstallation, } from "./agent-installation/agent-installation-manager.js";
-import { AutomaticAdapterProvisioner } from "./agent-installation/automatic-adapter-provisioner.js";
 import { FixedInstallationExecutor } from "./agent-installation/fixed-installation-executor.js";
-import { ManagedAdapterInstaller } from "./agent-installation/managed-adapter-installer.js";
 import { LocalAuthorizationError } from "./authorization/local-authorization-error.js";
 import { WorkspaceDirectoryService } from "./authorization/workspace-directory.js";
 import { NativeSessionService } from "./native-sessions/service.js";
+import { environmentProxyDispatcher } from "./network/environment-proxy.js";
+import { PromptArtifactError, resolvePromptArtifacts } from "./prompt-artifact-resolver.js";
 import { connectRelay } from "./relay-connection/connect.js";
 import { RelayConnectionLiveness } from "./relay-connection/liveness.js";
 import { SessionEventOutbox } from "./relay-connection/session-event-outbox.js";
-import { systemDaemonTimer, } from "./relay-connection/timer.js";
+import { systemDaemonTimer } from "./relay-connection/timer.js";
 import { readStateDirectory } from "./storage/state-directory.js";
 const RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
 const RELAY_CONNECTION_REFRESH_MILLISECONDS = 20 * 60 * 1_000;
+const ACTIVE_TURN_RECONCILIATION_TIMEOUT_MILLISECONDS = 20_000;
+const ACTIVE_TURN_RECONCILIATION_CLOSE_CODE = 4009;
 class RelayConnectionRefreshState {
 }
 class ScheduledRelayConnectionRefreshState extends RelayConnectionRefreshState {
@@ -200,7 +202,7 @@ class DaemonInstallationObserver {
             }));
             return Promise.resolve();
         }
-        throw new Error("Unsupported Agent installation state");
+        throw new Error("Unsupported Agent integration installation state");
     };
 }
 class ResolvedSessionDirectories {
@@ -214,18 +216,21 @@ class ResolvedSessionDirectories {
     }
 }
 class ActiveDaemonTurn {
+    attemptId;
     command;
-    #connectionController;
+    #controller;
+    #finished = Promise.withResolvers();
     #cancellationRequested = false;
-    constructor(command, connectionController) {
+    constructor(command, attemptId) {
+        this.attemptId = attemptId;
         this.command = command;
-        this.#connectionController = connectionController;
+        this.#controller = new AbortController();
     }
-    abortConnection = () => {
-        this.#connectionController.abort();
+    abortDaemon = () => {
+        this.#controller.abort();
     };
-    matches = (cancellation) => cancellation.commandId === this.command.commandId &&
-        cancellation.sessionId === this.command.sessionId;
+    finish = () => this.#finished.resolve();
+    matches = (cancellation) => cancellation.commandId === this.command.commandId && cancellation.sessionId === this.command.sessionId;
     requestCancellation = () => {
         if (this.#cancellationRequested) {
             return false;
@@ -234,23 +239,128 @@ class ActiveDaemonTurn {
         return true;
     };
     get signal() {
-        return this.#connectionController.signal;
+        return this.#controller.signal;
+    }
+    get completion() {
+        return this.#finished.promise;
+    }
+}
+class ActiveTurnReconciliationError extends Error {
+    code = "active_turn_reconciliation_failed";
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ActiveTurnReconciliationError";
+    }
+}
+function activeTurnReconciliationEndpoint(config, turn) {
+    const endpoint = new URL(config.relayUrl);
+    endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
+    if (!endpoint.pathname.endsWith("/daemon")) {
+        throw new ActiveTurnReconciliationError("The Relay URL is invalid");
+    }
+    endpoint.pathname = `${endpoint.pathname.slice(0, -"/daemon".length)}/sessions/${encodeURIComponent(turn.command.sessionId)}/attempts/${encodeURIComponent(turn.attemptId)}/reconciliation`;
+    endpoint.searchParams.delete("liveness");
+    return endpoint;
+}
+async function reconcileActiveTurn(config, turn, signal) {
+    signal.throwIfAborted();
+    const timeoutSignal = AbortSignal.timeout(ACTIVE_TURN_RECONCILIATION_TIMEOUT_MILLISECONDS);
+    const requestSignal = AbortSignal.any([signal, timeoutSignal]);
+    let response;
+    try {
+        response = await fetch(activeTurnReconciliationEndpoint(config, turn), {
+            body: JSON.stringify({ outcome: { kind: "running" } }),
+            dispatcher: environmentProxyDispatcher,
+            headers: { "content-type": "application/json" },
+            method: "POST",
+            signal: requestSignal,
+        });
+    }
+    catch (error) {
+        if (signal.aborted) {
+            signal.throwIfAborted();
+        }
+        throw new ActiveTurnReconciliationError(timeoutSignal.aborted
+            ? "The active Agent turn reconciliation timed out"
+            : "The active Agent turn could not be reconciled", { cause: error });
+    }
+    await response.body?.cancel();
+    if (!response.ok) {
+        throw new ActiveTurnReconciliationError(`The Relay rejected the active Agent turn reconciliation with status ${response.status.toString()}`);
     }
 }
+async function reconcileActiveTurns(config, turns, signal) {
+    await Promise.all(turns.map(async (turn) => await reconcileActiveTurn(config, turn, signal)));
+}
 function send(socket, message) {
     if (socket.readyState !== WebSocket.OPEN) {
         throw new Error("Relay connection is not open");
     }
     socket.send(message);
 }
-function recordSessionEvent(outbox, socket, sessionId, payload, attemptId = null) {
-    const envelope = outbox.enqueue(sessionId, payload, attemptId);
-    if (socket.readyState === WebSocket.OPEN) {
-        socket.send(envelope);
+function closeRelaySocket(socket, code, reason) {
+    try {
+        socket.close(code, reason);
+    }
+    catch (error) {
+        console.error("Mobius daemon could not close the Relay WebSocket", error);
+        try {
+            socket.close();
+        }
+        catch (fallbackError) {
+            console.error("Mobius daemon could not release the Relay WebSocket", fallbackError);
+        }
+    }
+}
+class DaemonSessionEventConnectionState {
+}
+class DisconnectedDaemonSessionEventState extends DaemonSessionEventConnectionState {
+    disconnect = () => this;
+    send = () => undefined;
+}
+class ConnectedDaemonSessionEventState extends DaemonSessionEventConnectionState {
+    #socket;
+    constructor(socket) {
+        super();
+        this.#socket = socket;
+    }
+    disconnect = (socket) => socket === this.#socket ? new DisconnectedDaemonSessionEventState() : this;
+    send = (message) => {
+        if (this.#socket.readyState === WebSocket.OPEN) {
+            try {
+                this.#socket.send(message);
+            }
+            catch {
+                // The durable outbox retains the event for the replacement connection.
+            }
+        }
+    };
+}
+class DaemonSessionEventPublisher {
+    #outbox;
+    #connection = new DisconnectedDaemonSessionEventState();
+    constructor(outbox) {
+        this.#outbox = outbox;
     }
+    connect = (socket) => {
+        const connection = new ConnectedDaemonSessionEventState(socket);
+        this.#connection = connection;
+        for (const pending of this.#outbox.pending()) {
+            connection.send(pending);
+        }
+    };
+    disconnect = (socket) => {
+        this.#connection = this.#connection.disconnect(socket);
+    };
+    recordAttempt = (sessionId, payload, attemptId) => {
+        this.#connection.send(this.#outbox.enqueue(sessionId, payload, attemptId));
+    };
+    recordRuntime = (sessionId, payload) => {
+        this.#connection.send(this.#outbox.enqueue(sessionId, payload));
+    };
 }
-function reportFailure(outbox, socket, command, code, message, attemptId = null) {
-    recordSessionEvent(outbox, socket, command.sessionId, encodeSessionFailedEvent({
+function reportFailure(publisher, command, code, message, attemptId) {
+    publisher.recordAttempt(command.sessionId, encodeSessionFailedEvent({
         code,
         commandId: command.commandId,
         kind: SESSION_FAILED_KIND,
@@ -261,7 +371,8 @@ function reportFailure(outbox, socket, command, code, message, attemptId = null)
 function operationErrorCode(error) {
     if (error instanceof AcpExecutionError ||
         error instanceof LocalAuthorizationError ||
-        error instanceof LocalAgentCatalogError) {
+        error instanceof LocalAgentCatalogError ||
+        error instanceof PromptArtifactError) {
         return error.code;
     }
     return "session_operation_failed";
@@ -269,7 +380,8 @@ function operationErrorCode(error) {
 function operationErrorMessage(error) {
     if (error instanceof AcpExecutionError ||
         error instanceof LocalAuthorizationError ||
-        error instanceof LocalAgentCatalogError) {
+        error instanceof LocalAgentCatalogError ||
+        error instanceof PromptArtifactError) {
         return error.message;
     }
     return "The local agent operation could not be completed";
@@ -327,7 +439,7 @@ async function executeWorkspaceList(socket, command, directories, audit, signal)
         reportOperationFailure(socket, command.requestId, "", error);
     }
 }
-async function executeSessionPrepare(outbox, socket, command, config, directories, audit, sessions, signal) {
+async function executeSessionPrepare(publisher, socket, command, config, directories, audit, sessions, signal) {
     try {
         const resolved = await resolveSessionDirectories(directories, config.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const agent = config.catalog.find(command.agentId);
@@ -344,7 +456,7 @@ async function executeSessionPrepare(outbox, socket, command, config, directorie
             event: "session_prepared",
             sessionId: command.sessionId,
         });
-        recordSessionEvent(outbox, socket, command.sessionId, encodeSessionReadyEvent({
+        publisher.recordRuntime(command.sessionId, encodeSessionReadyEvent({
             additionalDirectories: resolved.additionalDirectoryEntries,
             agentId: command.agentId,
             agentName: prepared.agentName,
@@ -373,7 +485,7 @@ async function executeSessionPrepare(outbox, socket, command, config, directorie
         reportOperationFailure(socket, command.requestId, command.sessionId, error);
     }
 }
-async function executeSessionConfigure(outbox, socket, command, config, directories, audit, sessions, signal) {
+async function executeSessionConfigure(publisher, socket, command, config, directories, audit, sessions, signal) {
     try {
         const resolved = await resolveSessionDirectories(directories, config.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const configOptions = await sessions.configureSession({
@@ -393,7 +505,7 @@ async function executeSessionConfigure(outbox, socket, command, config, director
             event: "session_configured",
             sessionId: command.sessionId,
         });
-        recordSessionEvent(outbox, socket, command.sessionId, encodeSessionConfigUpdatedEvent({
+        publisher.recordRuntime(command.sessionId, encodeSessionConfigUpdatedEvent({
             configOptions,
             kind: "session.config.updated",
             requestId: command.requestId,
@@ -404,7 +516,7 @@ async function executeSessionConfigure(outbox, socket, command, config, director
         reportOperationFailure(socket, command.requestId, command.sessionId, error);
     }
 }
-async function executePrompt(outbox, socket, command, config, directories, audit, sessions, attemptId, signal) {
+async function executePrompt(outbox, publisher, command, config, directories, audit, sessions, attemptId, signal) {
     try {
         const resolved = await resolveSessionDirectories(directories, config.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const agent = config.catalog.find(command.agentId);
@@ -414,20 +526,21 @@ async function executePrompt(outbox, socket, command, config, directories, audit
             sessionId: command.sessionId,
         });
         outbox.transitionExecution(command.commandId, "running");
-        recordSessionEvent(outbox, socket, command.sessionId, encodeSessionStartedEvent({
+        publisher.recordAttempt(command.sessionId, encodeSessionStartedEvent({
             commandId: command.commandId,
             kind: SESSION_STARTED_KIND,
             attemptId,
             sessionId: command.sessionId,
         }), attemptId);
+        const attachments = await resolvePromptArtifacts(config, command, signal);
         const result = await sessions.runPrompt({
             additionalDirectories: resolved.additionalDirectories,
             agent,
             commandId: command.commandId,
             cwd: resolved.cwd,
-            images: command.images,
+            images: attachments.images,
             onActivity: (activity) => {
-                recordSessionEvent(outbox, socket, command.sessionId, encodeAgentActivityEvent({
+                publisher.recordAttempt(command.sessionId, encodeAgentActivityEvent({
                     activityId: activity.activityId,
                     activityType: activity.activityType,
                     commandId: command.commandId,
@@ -447,7 +560,7 @@ async function executePrompt(outbox, socket, command, config, directories, audit
                 return Promise.resolve();
             },
             onText: (text) => {
-                recordSessionEvent(outbox, socket, command.sessionId, encodeAgentMessageDeltaEvent({
+                publisher.recordAttempt(command.sessionId, encodeAgentMessageDeltaEvent({
                     commandId: command.commandId,
                     kind: AGENT_MESSAGE_DELTA_KIND,
                     sessionId: command.sessionId,
@@ -456,11 +569,11 @@ async function executePrompt(outbox, socket, command, config, directories, audit
                 return Promise.resolve();
             },
             prompt: command.prompt,
-            resources: command.resources,
+            resources: attachments.resources,
             sessionId: command.sessionId,
             signal,
         });
-        recordSessionEvent(outbox, socket, command.sessionId, encodeSessionCompletedEvent({
+        publisher.recordAttempt(command.sessionId, encodeSessionCompletedEvent({
             commandId: command.commandId,
             kind: SESSION_COMPLETED_KIND,
             sessionId: command.sessionId,
@@ -469,9 +582,7 @@ async function executePrompt(outbox, socket, command, config, directories, audit
         outbox.transitionExecution(command.commandId, result.stopReason === "cancelled" ? "cancelled" : "succeeded");
         audit.record({
             commandId: command.commandId,
-            event: result.stopReason === "cancelled"
-                ? "session_cancelled"
-                : "session_completed",
+            event: result.stopReason === "cancelled" ? "session_cancelled" : "session_completed",
             sessionId: command.sessionId,
         });
     }
@@ -482,7 +593,7 @@ async function executePrompt(outbox, socket, command, config, directories, audit
             sessionId: command.sessionId,
         });
         const code = operationErrorCode(error);
-        reportFailure(outbox, socket, command, code === "session_operation_failed" ? "agent_execution_failed" : code, code === "session_operation_failed"
+        reportFailure(publisher, command, code === "session_operation_failed" ? "agent_execution_failed" : code, code === "session_operation_failed"
             ? "The local agent could not complete the request"
             : operationErrorMessage(error), attemptId);
         outbox.transitionExecution(command.commandId, "failed");
@@ -527,23 +638,15 @@ async function publishAgentCatalogUntilAvailable(config, signal, timer) {
         }
     }
 }
-async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, onConnected, signal, timer) {
+async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, activeTurns, activeAttemptIds, onConnected, signal, timer) {
     const relayUrl = new URL(config.relayUrl);
     relayUrl.searchParams.set("liveness", "1");
     const socket = await connectRelay(relayUrl, signal);
+    const reconnectingTurns = [...activeTurns.values()];
     onConnected();
-    const activeTurns = new Map();
-    const activeAttemptIds = new Map();
     const connectionController = new AbortController();
     const nativeRequests = new Map();
-    const record = (sessionId, payload) => {
-        recordSessionEvent(outbox, socket, sessionId, payload, activeAttemptIds.get(sessionId) ?? null);
-    };
-    sessions.setObserver(new DaemonAcpObserver(record));
     installationObserver.connect(socket);
-    for (const pending of outbox.pending()) {
-        send(socket, pending);
-    }
     try {
         await new Promise((resolve, reject) => {
             let finished = false;
@@ -555,11 +658,8 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                 socket.removeEventListener("error", handleError);
                 socket.removeEventListener("message", handleMessage);
                 installationObserver.disconnect(socket);
+                publisher.disconnect(socket);
                 connectionController.abort();
-                for (const turn of activeTurns.values()) {
-                    turn.abortConnection();
-                }
-                activeTurns.clear();
             };
             const resolveConnection = () => {
                 if (finished) {
@@ -578,17 +678,17 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                 reject(new Error("Relay WebSocket failed"));
             };
             const stop = () => {
-                socket.close(1000, "Daemon stopped");
+                closeRelaySocket(socket, 1000, "Daemon stopped");
                 resolveConnection();
             };
             const refreshConnection = () => {
-                socket.close(1000, "Refreshing idle relay connection");
+                closeRelaySocket(socket, 1000, "Refreshing idle relay connection");
                 resolveConnection();
             };
             const connectionLiveness = new RelayConnectionLiveness(timer, {
                 send: (message) => send(socket, message),
                 unresponsive: () => {
-                    socket.close(4001, "Relay liveness check timed out");
+                    closeRelaySocket(socket, 4001, "Relay liveness check timed out");
                     resolveConnection();
                 },
             });
@@ -607,7 +707,7 @@ async function runRelayConnection(config, directories, audit, sessions, installa
             const handleMessage = (event) => {
                 const encoded = event.data;
                 if (typeof encoded !== "string") {
-                    socket.close(4003, "Text message required");
+                    closeRelaySocket(socket, 4003, "Text message required");
                     rejectConnection();
                     return;
                 }
@@ -620,8 +720,9 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                     if (kind === NATIVE_SESSION_CANCEL_KIND) {
                         const command = decodeNativeSessionCancel(encoded);
                         const pending = nativeRequests.get(command.requestId);
-                        if (pending?.sessionId === command.sessionId)
+                        if (pending?.sessionId === command.sessionId) {
                             pending.controller.abort(new AcpExecutionError("Native session operation cancelled", {}, "native_session_cancelled"));
+                        }
                         return;
                     }
                     if (kind === NATIVE_SESSION_REQUEST_KIND) {
@@ -634,10 +735,7 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                             return;
                         }
                         const controller = new AbortController();
-                        const operationSignal = AbortSignal.any([
-                            connectionController.signal,
-                            controller.signal,
-                        ]);
+                        const operationSignal = AbortSignal.any([connectionController.signal, controller.signal]);
                         const timeout = timer.schedule(() => controller.abort(new AcpExecutionError("Native session operation timed out", {}, "native_session_timeout")), 90_000);
                         const completion = (async () => {
                             try {
@@ -659,8 +757,9 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                                 }
                                 operationSignal.throwIfAborted();
                                 const result = await nativeSessions.execute(command, operationSignal);
-                                if (socket.readyState === WebSocket.OPEN)
+                                if (socket.readyState === WebSocket.OPEN) {
                                     send(socket, encodeNativeSessionResult(result));
+                                }
                             }
                             catch (error) {
                                 const failure = operationSignal.aborted
@@ -712,9 +811,7 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                             event: "session_cancellation_requested",
                             sessionId: cancellation.sessionId,
                         });
-                        void sessions
-                            .cancelPrompt(cancellation.sessionId)
-                            .catch((error) => {
+                        void sessions.cancelPrompt(cancellation.sessionId).catch((error) => {
                             console.error("Mobius daemon could not cancel the agent turn", error);
                         });
                         return;
@@ -726,12 +823,12 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                     }
                     if (kind === SESSION_PREPARE_KIND) {
                         const command = decodeSessionPrepareCommand(encoded);
-                        void executeSessionPrepare(outbox, socket, command, config, directories, audit, sessions, connectionController.signal);
+                        void executeSessionPrepare(publisher, socket, command, config, directories, audit, sessions, connectionController.signal);
                         return;
                     }
                     if (kind === SESSION_CONFIGURE_KIND) {
                         const command = decodeSessionConfigureCommand(encoded);
-                        void executeSessionConfigure(outbox, socket, command, config, directories, audit, sessions, connectionController.signal);
+                        void executeSessionConfigure(publisher, socket, command, config, directories, audit, sessions, connectionController.signal);
                         return;
                     }
                     if (kind === SESSION_PERMISSION_RESPOND_KIND) {
@@ -768,18 +865,14 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                     }
                     if (kind === AGENT_INSTALL_REQUEST_KIND) {
                         const command = decodeAgentInstallRequestCommand(encoded);
-                        void installations
-                            .request(command, signal)
-                            .catch((error) => {
-                            console.error("Mobius Agent installation failed", error);
+                        void installations.request(command, signal).catch((error) => {
+                            console.error("Mobius Agent integration installation failed", error);
                         });
                         return;
                     }
                     if (kind === AGENT_INSTALL_CANCEL_KIND) {
                         const command = decodeAgentInstallCancelCommand(encoded);
-                        void installations
-                            .cancel(command.requestId)
-                            .catch((error) => {
+                        void installations.cancel(command.requestId).catch((error) => {
                             reportOperationFailure(socket, command.requestId, "", error);
                         });
                         return;
@@ -795,10 +888,10 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                     if (receipt.kind === "duplicate") {
                         return;
                     }
-                    const turn = new ActiveDaemonTurn(command, new AbortController());
+                    const turn = new ActiveDaemonTurn(command, receipt.attemptId);
                     activeTurns.set(command.commandId, turn);
                     activeAttemptIds.set(command.sessionId, receipt.attemptId);
-                    void executePrompt(outbox, socket, command, config, directories, audit, sessions, receipt.attemptId, turn.signal)
+                    void executePrompt(outbox, publisher, command, config, directories, audit, sessions, receipt.attemptId, turn.signal)
                         .catch((error) => {
                         console.error("Mobius daemon turn failed", error);
                     })
@@ -807,18 +900,33 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                         if (activeAttemptIds.get(command.sessionId) === receipt.attemptId) {
                             activeAttemptIds.delete(command.sessionId);
                         }
+                        turn.finish();
                         connectionRefresh.afterTurnFinished();
                     });
                 }
                 catch (error) {
                     console.error("Mobius daemon rejected a message", error);
-                    socket.close(4008, "Invalid protocol message");
+                    closeRelaySocket(socket, 4008, "Invalid protocol message");
                     rejectConnection();
                 }
             };
             socket.addEventListener("close", handleClose);
             socket.addEventListener("error", handleError);
             socket.addEventListener("message", handleMessage);
+            void reconcileActiveTurns(config, reconnectingTurns, connectionController.signal).then(() => {
+                if (finished) {
+                    return;
+                }
+                publisher.connect(socket);
+                void Promise.all(reconnectingTurns.map((turn) => turn.completion)).then(connectionRefresh.afterTurnFinished);
+            }, (error) => {
+                if (finished) {
+                    return;
+                }
+                console.error("Mobius daemon could not reconcile active Agent turns", error);
+                closeRelaySocket(socket, ACTIVE_TURN_RECONCILIATION_CLOSE_CODE, "Active Agent turn reconciliation failed");
+                rejectConnection();
+            });
             if (signal.aborted) {
                 stop();
             }
@@ -841,18 +949,20 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
         publishCatalog: async (installationSignal) => await publishAgentCatalog(config, installationSignal),
         stateDirectory,
     });
-    await new AutomaticAdapterProvisioner({
-        defaultWorkspace: config.defaultWorkspace,
-        audit: installationAudit,
-        catalog: config.catalog,
-        environment: process.env,
-    }, new ManagedAdapterInstaller({
-        environment: process.env,
-        stateDirectory,
-    }), specifications).prepare(signal);
     const sessionStore = new SqliteAcpSessionStore(config.auditDatabasePath);
     const outbox = new SessionEventOutbox(config.auditDatabasePath);
-    const sessions = new AcpSessionManager(new NullAcpSessionObserver(), sessionStore);
+    const publisher = new DaemonSessionEventPublisher(outbox);
+    const activeTurns = new Map();
+    const activeAttemptIds = new Map();
+    const recordSessionEvent = (sessionId, payload) => {
+        const attemptId = activeAttemptIds.get(sessionId);
+        if (attemptId === undefined) {
+            publisher.recordRuntime(sessionId, payload);
+            return;
+        }
+        publisher.recordAttempt(sessionId, payload, attemptId);
+    };
+    const sessions = new AcpSessionManager(new DaemonAcpObserver(recordSessionEvent), sessionStore);
     const directories = new WorkspaceDirectoryService(config.bindingId, config.defaultWorkspace);
     const installationObserver = new DaemonInstallationObserver();
     const nativeSessions = new NativeSessionService(config, directories, sessions, audit);
@@ -872,7 +982,7 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
     try {
         while (!signal.aborted) {
             try {
-                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, announceConnection, signal, timer);
+                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, activeTurns, activeAttemptIds, announceConnection, signal, timer);
                 retryAnnounced = false;
             }
             catch {
@@ -888,6 +998,11 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
         }
     }
     finally {
+        const turns = [...activeTurns.values()];
+        for (const turn of turns) {
+            turn.abortDaemon();
+        }
+        await Promise.all(turns.map((turn) => turn.completion));
         try {
             await catalogPublication;
         }