@moxt-ai/mobius 0.0.24 → 0.0.26

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, 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, 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 { fetch, WebSocket } from "undici";
 import { AcpExecutionError, AcpSessionManager } from "./acp/session-manager.js";
 import { SqliteAcpSessionStore } from "./acp/session-store.js";
@@ -20,12 +20,13 @@ 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 { RelayConnectionDiagnostics } from "./relay-connection/diagnostics.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 { readStateDirectory } from "./storage/state-directory.js";
 const RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
-const RELAY_CONNECTION_REFRESH_MILLISECONDS = 20 * 60 * 1_000;
+const AGENT_ACTIVITY_COALESCING_MILLISECONDS = 100;
 const ACTIVE_TURN_RECONCILIATION_TIMEOUT_MILLISECONDS = 20_000;
 const ACTIVE_TURN_RECONCILIATION_CLOSE_CODE = 4009;
 function botIpcSocketPath() {
@@ -34,56 +35,6 @@ function botIpcSocketPath() {
     }
     return join("/tmp", `mobius-bot-${randomUUID()}.sock`);
 }
-class RelayConnectionRefreshState {
-}
-class ScheduledRelayConnectionRefreshState extends RelayConnectionRefreshState {
-}
-class DueRelayConnectionRefreshState extends RelayConnectionRefreshState {
-}
-class FinishedRelayConnectionRefreshState extends RelayConnectionRefreshState {
-}
-class RelayConnectionRefresh {
-    #isSafe;
-    #refresh;
-    #scheduledTask;
-    #state = new ScheduledRelayConnectionRefreshState();
-    constructor(timer, isSafe, refresh) {
-        this.#isSafe = isSafe;
-        this.#refresh = refresh;
-        this.#scheduledTask = timer.schedule(this.#request, RELAY_CONNECTION_REFRESH_MILLISECONDS);
-    }
-    afterTurnFinished = () => {
-        if (this.#state instanceof DueRelayConnectionRefreshState) {
-            this.#request();
-            return;
-        }
-        if (this.#state instanceof ScheduledRelayConnectionRefreshState ||
-            this.#state instanceof FinishedRelayConnectionRefreshState) {
-            return;
-        }
-        throw new Error("Unknown relay connection refresh state");
-    };
-    close = () => {
-        this.#scheduledTask.cancel();
-        this.#state = new FinishedRelayConnectionRefreshState();
-    };
-    #request = () => {
-        if (this.#state instanceof FinishedRelayConnectionRefreshState) {
-            return;
-        }
-        if (!(this.#state instanceof ScheduledRelayConnectionRefreshState) &&
-            !(this.#state instanceof DueRelayConnectionRefreshState)) {
-            throw new Error("Unknown relay connection refresh state");
-        }
-        if (!this.#isSafe()) {
-            this.#state = new DueRelayConnectionRefreshState();
-            return;
-        }
-        this.#state = new FinishedRelayConnectionRefreshState();
-        this.#scheduledTask.cancel();
-        this.#refresh();
-    };
-}
 class DaemonAcpObserver {
     #record;
     constructor(record) {
@@ -266,10 +217,18 @@ class ActiveTurnReconciliationError extends Error {
 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");
+    let channelPath = "";
+    if (endpoint.pathname.endsWith("/daemon")) {
+        channelPath = endpoint.pathname.slice(0, -"/daemon".length);
+    }
+    else {
+        const runtimePath = "/v1/runtimes/connect";
+        if (!endpoint.pathname.endsWith(runtimePath)) {
+            throw new ActiveTurnReconciliationError("The Relay URL is invalid");
+        }
+        channelPath = `${endpoint.pathname.slice(0, -runtimePath.length)}/channels/${encodeURIComponent(config.channelId)}`;
     }
-    endpoint.pathname = `${endpoint.pathname.slice(0, -"/daemon".length)}/sessions/${encodeURIComponent(turn.command.sessionId)}/attempts/${encodeURIComponent(turn.attemptId)}/reconciliation`;
+    endpoint.pathname = `${channelPath}/sessions/${encodeURIComponent(turn.command.sessionId)}/attempts/${encodeURIComponent(turn.attemptId)}/reconciliation`;
     endpoint.searchParams.delete("liveness");
     return endpoint;
 }
@@ -327,7 +286,8 @@ class DaemonSessionEventConnectionState {
 }
 class DisconnectedDaemonSessionEventState extends DaemonSessionEventConnectionState {
     disconnect = () => this;
-    send = () => undefined;
+    matches = () => false;
+    send = () => false;
 }
 class ConnectedDaemonSessionEventState extends DaemonSessionEventConnectionState {
     #socket;
@@ -336,40 +296,151 @@ class ConnectedDaemonSessionEventState extends DaemonSessionEventConnectionState
         this.#socket = socket;
     }
     disconnect = (socket) => socket === this.#socket ? new DisconnectedDaemonSessionEventState() : this;
+    matches = (socket) => socket === this.#socket;
     send = (message) => {
-        if (this.#socket.readyState === WebSocket.OPEN) {
-            try {
-                this.#socket.send(message);
-            }
-            catch {
-                // The durable outbox retains the event for the replacement connection.
-            }
+        if (this.#socket.readyState !== WebSocket.OPEN) {
+            return false;
+        }
+        try {
+            this.#socket.send(message);
+            return true;
+        }
+        catch {
+            // The durable outbox retains the event for the replacement connection.
+            return false;
         }
     };
 }
+const SESSION_EVENT_REPLAY_WINDOW = 4;
 class DaemonSessionEventPublisher {
     #outbox;
+    #inFlightEventIds = new Set();
     #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);
-        }
+        this.#connection = new ConnectedDaemonSessionEventState(socket);
+        this.#inFlightEventIds.clear();
+        this.#publishNextBatch();
     };
     disconnect = (socket) => {
+        if (!this.#connection.matches(socket)) {
+            return;
+        }
         this.#connection = this.#connection.disconnect(socket);
+        this.#inFlightEventIds.clear();
     };
     recordAttempt = (sessionId, payload, attemptId) => {
-        this.#connection.send(this.#outbox.enqueue(sessionId, payload, attemptId));
+        this.#outbox.enqueue(sessionId, payload, attemptId);
+        this.#publishNextBatch();
     };
     recordRuntime = (sessionId, payload) => {
-        this.#connection.send(this.#outbox.enqueue(sessionId, payload));
+        this.#outbox.enqueue(sessionId, payload);
+        this.#publishNextBatch();
+    };
+    acknowledge = (acknowledgement) => {
+        if (!this.#outbox.acknowledge(acknowledgement)) {
+            return;
+        }
+        this.#inFlightEventIds.delete(acknowledgement.eventId);
+        this.#publishNextBatch();
+    };
+    quarantine = (rejection) => {
+        const quarantined = this.#outbox.quarantine(rejection);
+        if (!quarantined) {
+            return false;
+        }
+        this.#inFlightEventIds.delete(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();
+                return;
+            }
+            this.#inFlightEventIds.add(envelope.eventId);
+        }
+    };
+}
+class CoalescingDaemonActivityPublisher {
+    #pending = new Map();
+    #publish;
+    #publishedActivityIds = new Set();
+    #scheduled = new Map();
+    #timer;
+    constructor(timer, publish) {
+        this.#publish = publish;
+        this.#timer = timer;
+    }
+    flush = () => {
+        const activities = [...this.#pending.values()].sort((left, right) => left.sequence - right.sequence);
+        for (const task of this.#scheduled.values()) {
+            task.cancel();
+        }
+        this.#pending.clear();
+        this.#scheduled.clear();
+        for (const activity of activities) {
+            this.#publish(activity);
+        }
+    };
+    record = (activity) => {
+        if (activity.status !== "pending" && activity.status !== "running") {
+            this.#discardPending(activity.activityId);
+            this.#publishedActivityIds.add(activity.activityId);
+            this.#publish(activity);
+            return Promise.resolve();
+        }
+        if (!this.#publishedActivityIds.has(activity.activityId)) {
+            this.#publishedActivityIds.add(activity.activityId);
+            this.#publish(activity);
+            return Promise.resolve();
+        }
+        this.#pending.set(activity.activityId, activity);
+        if (!this.#scheduled.has(activity.activityId)) {
+            this.#scheduled.set(activity.activityId, this.#timer.schedule(() => this.#flushActivity(activity.activityId), AGENT_ACTIVITY_COALESCING_MILLISECONDS));
+        }
+        return Promise.resolve();
+    };
+    #discardPending = (activityId) => {
+        this.#scheduled.get(activityId)?.cancel();
+        this.#scheduled.delete(activityId);
+        this.#pending.delete(activityId);
+    };
+    #flushActivity = (activityId) => {
+        const activity = this.#pending.get(activityId);
+        this.#discardPending(activityId);
+        if (activity !== undefined) {
+            this.#publish(activity);
+        }
     };
 }
+function encodeDaemonActivity(command, activity) {
+    return encodeAgentActivityEvent({
+        activityId: activity.activityId,
+        activityType: activity.activityType,
+        commandId: command.commandId,
+        content: activity.content,
+        detail: activity.detail,
+        input: activity.input,
+        kind: AGENT_ACTIVITY_KIND,
+        locations: activity.locations,
+        name: activity.name,
+        output: activity.output,
+        sequence: activity.sequence,
+        sessionId: command.sessionId,
+        status: activity.status,
+        title: activity.title,
+        toolKind: activity.toolKind,
+    });
+}
 function reportFailure(publisher, command, code, message, attemptId) {
     publisher.recordAttempt(command.sessionId, encodeSessionFailedEvent({
         code,
@@ -529,7 +600,10 @@ async function executeSessionConfigure(publisher, socket, command, config, direc
         reportOperationFailure(socket, command.requestId, command.sessionId, error);
     }
 }
-async function executePrompt(outbox, publisher, command, config, directories, audit, sessions, attemptId, signal) {
+async function executePrompt(outbox, publisher, command, config, directories, audit, sessions, attemptId, timer, signal) {
+    const activities = new CoalescingDaemonActivityPublisher(timer, (activity) => {
+        publisher.recordAttempt(command.sessionId, encodeDaemonActivity(command, activity), attemptId);
+    });
     try {
         const resolved = await resolveSessionDirectories(directories, config.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const agent = config.catalog.find(command.agentId);
@@ -574,26 +648,7 @@ async function executePrompt(outbox, publisher, command, config, directories, au
                 cwd: resolved.cwd,
                 disposition: command.disposition,
                 images: attachments.images,
-                onActivity: (activity) => {
-                    publisher.recordAttempt(command.sessionId, encodeAgentActivityEvent({
-                        activityId: activity.activityId,
-                        activityType: activity.activityType,
-                        commandId: command.commandId,
-                        content: activity.content,
-                        detail: activity.detail,
-                        input: activity.input,
-                        kind: AGENT_ACTIVITY_KIND,
-                        locations: activity.locations,
-                        name: activity.name,
-                        output: activity.output,
-                        sequence: activity.sequence,
-                        sessionId: command.sessionId,
-                        status: activity.status,
-                        title: activity.title,
-                        toolKind: activity.toolKind,
-                    }), attemptId);
-                    return Promise.resolve();
-                },
+                onActivity: activities.record,
                 onText: (text, messageId) => {
                     publisher.recordAttempt(command.sessionId, encodeAgentMessageDeltaEvent({
                         commandId: command.commandId,
@@ -612,6 +667,7 @@ async function executePrompt(outbox, publisher, command, config, directories, au
             });
             stopReason = result.stopReason;
         }
+        activities.flush();
         publisher.recordAttempt(command.sessionId, encodeSessionCompletedEvent({
             commandId: command.commandId,
             kind: SESSION_COMPLETED_KIND,
@@ -626,6 +682,7 @@ async function executePrompt(outbox, publisher, command, config, directories, au
         });
     }
     catch (error) {
+        activities.flush();
         audit.record({
             commandId: command.commandId,
             event: "session_failed",
@@ -648,7 +705,10 @@ function botExecutionAgent(agent, contextHandle, socketPath) {
         MOBIUS_RELAY_URL: "",
     }, agent.adapterVersion, agent.agentVersion, agent.adapterIdentity, agent.agentIdentity, agent.promptTimeoutMilliseconds, agent.capabilities);
 }
-async function executeBotPrompt(outbox, publisher, command, config, directories, audit, sessions, grants, contexts, applicator, ipc, attemptId, signal) {
+async function executeBotPrompt(outbox, publisher, command, config, directories, audit, sessions, grants, contexts, applicator, ipc, attemptId, timer, signal) {
+    const activities = new CoalescingDaemonActivityPublisher(timer, (activity) => {
+        publisher.recordAttempt(command.sessionId, encodeDaemonActivity(command, activity), attemptId);
+    });
     try {
         const deadline = Date.parse(command.executionDeadlineAt);
         const remaining = deadline - Date.now();
@@ -705,26 +765,7 @@ async function executeBotPrompt(outbox, publisher, command, config, directories,
                 commandId: command.commandId,
                 cwd: resolved.cwd,
                 images: attachments.images,
-                onActivity: (activity) => {
-                    publisher.recordAttempt(command.sessionId, encodeAgentActivityEvent({
-                        activityId: activity.activityId,
-                        activityType: activity.activityType,
-                        commandId: command.commandId,
-                        content: activity.content,
-                        detail: activity.detail,
-                        input: activity.input,
-                        kind: AGENT_ACTIVITY_KIND,
-                        locations: activity.locations,
-                        name: activity.name,
-                        output: activity.output,
-                        sequence: activity.sequence,
-                        sessionId: command.sessionId,
-                        status: activity.status,
-                        title: activity.title,
-                        toolKind: activity.toolKind,
-                    }), attemptId);
-                    return Promise.resolve();
-                },
+                onActivity: activities.record,
                 onText: (text, messageId) => {
                     publisher.recordAttempt(command.sessionId, encodeAgentMessageDeltaEvent({
                         commandId: command.commandId,
@@ -740,6 +781,7 @@ async function executeBotPrompt(outbox, publisher, command, config, directories,
                 sessionId: command.sessionId,
                 signal: executionSignal,
             });
+            activities.flush();
             publisher.recordAttempt(command.sessionId, encodeSessionCompletedEvent({
                 commandId: command.commandId,
                 kind: SESSION_COMPLETED_KIND,
@@ -759,6 +801,7 @@ async function executeBotPrompt(outbox, publisher, command, config, directories,
         }
     }
     catch (error) {
+        activities.flush();
         const failure = Date.parse(command.executionDeadlineAt) <= Date.now()
             ? new LocalBotAuthorizationError("turn_expired", "The Bot execution deadline has expired", {
                 cause: error,
@@ -796,16 +839,16 @@ function waitForRelayRetry(signal, timer) {
         signal.addEventListener("abort", finish, { once: true });
     });
 }
-async function publishAgentCatalogUntilAvailable(config, signal, timer) {
+async function publishAgentCatalogUntilAvailable(config, diagnostics, signal, timer) {
     try {
         await publishAgentCatalog(config, signal);
         return;
     }
-    catch {
+    catch (error) {
         if (signal.aborted) {
             return;
         }
-        console.warn("Mobius daemon is waiting to publish its Agent catalog");
+        diagnostics.catalogFailed(error);
     }
     while (!signal.aborted) {
         await waitForRelayRetry(signal, timer);
@@ -820,11 +863,12 @@ async function publishAgentCatalogUntilAvailable(config, signal, timer) {
         }
     }
 }
-async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, grants, contexts, applicator, ipc, activeTurns, activeAttemptIds, onConnected, signal, timer) {
+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("liveness", "1");
     const socket = await connectRelay(relayUrl, signal);
     const reconnectingTurns = [...activeTurns.values()];
+    diagnostics.connectionOpened(connectionEpoch);
     onConnected();
     const connectionController = new AbortController();
     const nativeRequests = new Map();
@@ -833,7 +877,6 @@ async function runRelayConnection(config, directories, audit, sessions, installa
         await new Promise((resolve, reject) => {
             let finished = false;
             const cleanup = () => {
-                connectionRefresh.close();
                 connectionLiveness.close();
                 signal.removeEventListener("abort", stop);
                 socket.removeEventListener("close", handleClose);
@@ -851,57 +894,65 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                 cleanup();
                 resolve();
             };
-            const rejectConnection = () => {
+            const rejectConnection = (failure) => {
                 if (finished) {
                     return;
                 }
                 finished = true;
                 cleanup();
-                reject(new Error("Relay WebSocket failed"));
+                reject(failure);
             };
             const stop = () => {
+                diagnostics.connectionClosed(connectionEpoch, 1000, "Daemon stopped", "daemon_stop");
                 closeRelaySocket(socket, 1000, "Daemon stopped");
                 resolveConnection();
             };
-            const refreshConnection = () => {
-                closeRelaySocket(socket, 1000, "Refreshing idle relay connection");
-                resolveConnection();
+            const failAndClose = (failure, code, reason, source) => {
+                diagnostics.connectionFailed(connectionEpoch, failure, source);
+                diagnostics.connectionClosed(connectionEpoch, code, reason, source);
+                closeRelaySocket(socket, code, reason);
+                rejectConnection(failure);
             };
             const connectionLiveness = new RelayConnectionLiveness(timer, {
                 send: (message) => send(socket, message),
-                unresponsive: () => {
+                unresponsive: (heartbeatId, timeoutMilliseconds) => {
+                    diagnostics.heartbeatTimedOut(connectionEpoch, heartbeatId, timeoutMilliseconds);
+                    diagnostics.connectionClosed(connectionEpoch, 4001, "Relay liveness check timed out", "heartbeat_timeout");
                     closeRelaySocket(socket, 4001, "Relay liveness check timed out");
                     resolveConnection();
                 },
             });
-            const connectionRefresh = new RelayConnectionRefresh(timer, () => activeTurns.size === 0, refreshConnection);
             signal.addEventListener("abort", stop, { once: true });
-            const handleClose = () => {
+            const handleClose = (event) => {
+                diagnostics.connectionClosed(connectionEpoch, event.code, event.reason, "relay");
                 resolveConnection();
             };
-            const handleError = () => {
+            const handleError = (event) => {
                 if (signal.aborted) {
                     resolveConnection();
                     return;
                 }
-                rejectConnection();
+                const cause = Reflect.get(event, "error");
+                const failure = new Error("Relay WebSocket emitted an error", { cause: cause ?? event });
+                diagnostics.connectionFailed(connectionEpoch, failure, "socket_error");
+                diagnostics.connectionClosed(connectionEpoch, 1006, "WebSocket error", "socket_error");
+                rejectConnection(failure);
             };
             const handleMessage = (event) => {
                 const encoded = event.data;
                 if (typeof encoded !== "string") {
-                    closeRelaySocket(socket, 4003, "Text message required");
-                    rejectConnection();
+                    failAndClose(new Error("Relay sent a non-text message"), 4003, "Text message required", "protocol");
                     return;
                 }
                 try {
                     const kind = decodeMessageKind(encoded);
                     if (kind === SESSION_EVENT_ACK_KIND) {
-                        outbox.acknowledge(decodeSessionEventAcknowledgement(encoded));
+                        publisher.acknowledge(decodeSessionEventAcknowledgement(encoded));
                         return;
                     }
                     if (kind === SESSION_EVENT_REJECTED_KIND) {
                         const rejection = decodeSessionEventRejection(encoded);
-                        if (outbox.quarantine(rejection)) {
+                        if (publisher.quarantine(rejection)) {
                             audit.record({
                                 commandId: rejection.eventId,
                                 details: { code: rejection.code },
@@ -1197,7 +1248,7 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                         const turn = new ActiveDaemonTurn(command, receipt.attemptId);
                         activeTurns.set(command.commandId, turn);
                         activeAttemptIds.set(command.sessionId, receipt.attemptId);
-                        void executeBotPrompt(outbox, publisher, command, config, directories, audit, sessions, grants, contexts, applicator, ipc, receipt.attemptId, turn.signal)
+                        void executeBotPrompt(outbox, publisher, command, config, directories, audit, sessions, grants, contexts, applicator, ipc, receipt.attemptId, timer, turn.signal)
                             .catch((error) => {
                             console.error("Mobius daemon Bot turn failed", error);
                         })
@@ -1207,7 +1258,6 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                                 activeAttemptIds.delete(command.sessionId);
                             }
                             turn.finish();
-                            connectionRefresh.afterTurnFinished();
                         });
                         return;
                     }
@@ -1227,7 +1277,7 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                     if (command.disposition !== SessionPromptDisposition.Steer) {
                         activeAttemptIds.set(command.sessionId, receipt.attemptId);
                     }
-                    void executePrompt(outbox, publisher, command, config, directories, audit, sessions, receipt.attemptId, turn.signal)
+                    void executePrompt(outbox, publisher, command, config, directories, audit, sessions, receipt.attemptId, timer, turn.signal)
                         .catch((error) => {
                         console.error("Mobius daemon turn failed", error);
                     })
@@ -1237,13 +1287,11 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                             activeAttemptIds.delete(command.sessionId);
                         }
                         turn.finish();
-                        connectionRefresh.afterTurnFinished();
                     });
                 }
                 catch (error) {
                     console.error("Mobius daemon rejected a message", error);
-                    closeRelaySocket(socket, 4008, "Invalid protocol message");
-                    rejectConnection();
+                    failAndClose(new Error("Relay sent an invalid protocol message", { cause: error }), 4008, "Invalid protocol message", "protocol");
                 }
             };
             socket.addEventListener("close", handleClose);
@@ -1254,14 +1302,12 @@ async function runRelayConnection(config, directories, audit, sessions, installa
                     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();
+                failAndClose(new Error("Active Agent turn reconciliation failed", { cause: error }), ACTIVE_TURN_RECONCILIATION_CLOSE_CODE, "Active Agent turn reconciliation failed", "reconciliation");
             });
             if (signal.aborted) {
                 stop();
@@ -1305,9 +1351,10 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
     const sessions = new AcpSessionManager(new DaemonAcpObserver(recordSessionEvent), sessionStore);
     const directories = new WorkspaceDirectoryService(config.bindingId, config.defaultWorkspace);
     const installationObserver = new DaemonInstallationObserver();
+    const diagnostics = new RelayConnectionDiagnostics(audit, config.channelId, config.relayUrl);
     const nativeSessions = new NativeSessionService(config, directories, sessions, audit);
     const installations = new AgentInstallationManager(specifications, installationExecutor, installationObserver, installationAudit);
-    let retryAnnounced = false;
+    let connectionEpoch = 0;
     let connectionAnnounced = false;
     const announceConnection = () => {
         if (connectionAnnounced) {
@@ -1318,22 +1365,19 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
         process.stdout.write("Mobius daemon connected to the relay.\n\n");
         process.stdout.write(`${styleText(["bold", "yellow"], `Reconnect this channel later:\n  ${reconnectCommand}`)}\n\n`);
     };
-    const catalogPublication = publishAgentCatalogUntilAvailable(config, signal, timer);
+    const catalogPublication = publishAgentCatalogUntilAvailable(config, diagnostics, signal, timer);
     try {
         await ipc.listen(signal);
         while (!signal.aborted) {
+            connectionEpoch += 1;
             try {
-                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, grants, contexts, applicator, ipc, activeTurns, activeAttemptIds, announceConnection, signal, timer);
-                retryAnnounced = false;
+                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, grants, contexts, applicator, ipc, activeTurns, activeAttemptIds, connectionEpoch, diagnostics, announceConnection, signal, timer);
             }
-            catch {
+            catch (error) {
                 if (signal.aborted) {
                     return;
                 }
-                if (!retryAnnounced) {
-                    console.warn("Mobius daemon is waiting for the relay");
-                    retryAnnounced = true;
-                }
+                diagnostics.connectionFailed(connectionEpoch, error, "connection");
             }
             await waitForRelayRetry(signal, timer);
         }