@moxt-ai/mobius 0.0.24 → 0.0.26

package/dist/cli.js

@@ -11,7 +11,7 @@ import { mkdir as mkdir5 } from "node:fs/promises";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.24",
+  version: "0.0.26",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -21,6 +21,10 @@ var package_default = {
     ".": {
       types: "./dist/index.d.ts",
       import: "./dist/index.js"
+    },
+    "./runtime": {
+      types: "./dist/runtime.d.ts",
+      import: "./dist/runtime.js"
     }
   },
   files: [
@@ -38,7 +42,7 @@ var package_default = {
     directory: "packages/cli"
   },
   scripts: {
-    build: "tsc --project tsconfig.build.json && esbuild src/cli.ts src/index.ts --bundle --platform=node --format=esm --sourcemap --outdir=dist --external:@agentclientprotocol/* --external:undici",
+    build: "tsc --project tsconfig.build.json && esbuild src/cli.ts src/index.ts src/runtime.ts --bundle --platform=node --format=esm --sourcemap --outdir=dist --external:@agentclientprotocol/* --external:undici",
     dev: "node --watch src/cli.ts",
     prepack: "pnpm build",
     start: "node dist/cli.js",
@@ -1574,7 +1578,53 @@ import { fetch } from "undici";
 
 // src/network/environment-proxy.ts
 import { EnvHttpProxyAgent } from "undici";
+var configuredHttpProxy = process.env["http_proxy"] ?? process.env["HTTP_PROXY"] ?? "";
+var configuredHttpsProxy = process.env["https_proxy"] ?? process.env["HTTPS_PROXY"] ?? configuredHttpProxy;
 var environmentProxyDispatcher = new EnvHttpProxyAgent();
+function bypassesProxy(target) {
+  const noProxy = process.env["no_proxy"] ?? process.env["NO_PROXY"] ?? "";
+  if (noProxy === "*") {
+    return true;
+  }
+  const hostname4 = target.hostname.replace(/^\[|\]$/gu, "").toLowerCase();
+  const defaultPort = target.protocol === "wss:" || target.protocol === "https:" ? 443 : 80;
+  const port = Number.parseInt(target.port, 10) || defaultPort;
+  for (const rawEntry of noProxy.split(/[,\s]/u)) {
+    if (rawEntry.length === 0) {
+      continue;
+    }
+    const parsed = rawEntry.match(/^(.+):(\d+)$/u);
+    const entryHostname = (parsed?.[1] ?? rawEntry).replace(/^\*?\./u, "").toLowerCase();
+    const entryPort = parsed?.[2] === void 0 ? 0 : Number.parseInt(parsed[2], 10);
+    if (entryPort !== 0 && entryPort !== port) {
+      continue;
+    }
+    if (hostname4 === entryHostname || hostname4.endsWith(`.${entryHostname}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function sanitizedProxyOrigin(proxyUrl) {
+  try {
+    return new URL(proxyUrl).origin;
+  } catch {
+    return "configured-invalid-url";
+  }
+}
+function describeEnvironmentProxyRoute(target) {
+  if (bypassesProxy(target)) {
+    return { proxyRoute: "direct" };
+  }
+  const proxyUrl = target.protocol === "wss:" || target.protocol === "https:" ? configuredHttpsProxy : configuredHttpProxy;
+  if (proxyUrl.length === 0) {
+    return { proxyRoute: "direct" };
+  }
+  return {
+    proxyOrigin: sanitizedProxyOrigin(proxyUrl),
+    proxyRoute: "proxy"
+  };
+}
 
 // src/agent-installation/managed-agent-archive.ts
 var ARCHIVE_DOWNLOAD_LIMIT_BYTES = 128 * 1024 * 1024;
@@ -2578,54 +2628,6 @@ async function discoverLocalAgentInventory(options) {
   return new LocalAgentInventory(discoveries);
 }
 
-// src/audit/audit-store.ts
-import { mkdirSync } from "node:fs";
-import { dirname as dirname3 } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-var AuditStore = class {
-  database;
-  constructor(path2) {
-    mkdirSync(dirname3(path2), { recursive: true });
-    this.database = new DatabaseSync(path2);
-    this.database.exec(`
-      CREATE TABLE IF NOT EXISTS audit_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        recorded_at TEXT NOT NULL,
-        event TEXT NOT NULL,
-        command_id TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        details_json TEXT NOT NULL DEFAULT '{}'
-      ) STRICT
-    `);
-    const columns = this.database.prepare("PRAGMA table_info(audit_events)").all();
-    if (!columns.some((column) => Reflect.get(column, "name") === "details_json")) {
-      this.database.exec("ALTER TABLE audit_events ADD COLUMN details_json TEXT NOT NULL DEFAULT '{}'");
-    }
-  }
-  record(record2) {
-    this.database.prepare(
-      `
-          INSERT INTO audit_events (
-            recorded_at,
-            event,
-            command_id,
-            session_id,
-            details_json
-          ) VALUES (?, ?, ?, ?, ?)
-        `
-    ).run(
-      (/* @__PURE__ */ new Date()).toISOString(),
-      record2.event,
-      record2.commandId,
-      record2.sessionId,
-      JSON.stringify(record2.details ?? {})
-    );
-  }
-  close() {
-    this.database.close();
-  }
-};
-
 // src/bots/bot-message-command.ts
 import { randomUUID } from "node:crypto";
 import { createConnection } from "node:net";
@@ -23249,14 +23251,15 @@ var encode4 = (message, schema) => {
   }
   return JSON.stringify(decoded.data);
 };
+var decodeSessionEventEnvelope = (encoded) => decode5(encoded, eventEnvelopeSchema);
 var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
 var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
 var decodeSessionEventRejection = (encoded) => decode5(encoded, eventRejectionSchema);
 
 // src/config.ts
-function loadDefaultWorkspace() {
-  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
-  return configuredWorkspace ?? join13(readStateDirectory(), "workspace");
+function loadDefaultWorkspace(environment = process.env) {
+  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = environment;
+  return configuredWorkspace ?? join13(readStateDirectory(environment), "workspace");
 }
 function createDaemonConfig(connection, agents = [], installableAgents = []) {
   return {
@@ -23283,7 +23286,9 @@ var IDENTIFIER_PATTERN5 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
 var TOKEN_PATTERN2 = /^[a-zA-Z0-9_-]{32,256}$/;
 var MAX_CONNECTION_FILE_LENGTH = 16 * 1024;
 var CLAIM_RESPONSE_KEYS = ["channelId", "daemonToken", "runtimeId"];
-var SAVED_CONNECTION_KEYS = ["defaultWorkspace", "channelId", "daemonToken", "relayOrigin"];
+var REDEEM_RESPONSE_KEYS = ["channelId", "runtimeCredential", "runtimeId"];
+var LEGACY_SAVED_CONNECTION_KEYS = ["defaultWorkspace", "channelId", "daemonToken", "relayOrigin"];
+var SAVED_CONNECTION_KEYS = ["defaultWorkspace", "channelId", "relayOrigin", "runtimeCredential"];
 var PairingClientError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -23320,7 +23325,7 @@ function readSingleOption(arguments_, option2) {
 function assertKnownArguments(arguments_) {
   for (let index = 0; index < arguments_.length; index += 2) {
     const option2 = arguments_[index];
-    if (option2 !== "--url" && option2 !== "--code" && option2 !== "--workspace") {
+    if (option2 !== "--url" && option2 !== "--code" && option2 !== "--pairing" && option2 !== "--workspace") {
       throw new PairingClientError("invalid_arguments", `Unknown pairing option: ${option2 ?? "missing option"}`);
     }
   }
@@ -23360,10 +23365,17 @@ function parsePairCommand(arguments_) {
   assertKnownArguments(arguments_);
   return {
     code: parsePairingCode(readSingleOption(arguments_, "--code")),
+    pairingId: arguments_.includes("--pairing") ? validatePairingId(readSingleOption(arguments_, "--pairing")) : "",
     relayOrigin: parseRelayOrigin(readSingleOption(arguments_, "--url")),
     workspace: arguments_.includes("--workspace") ? readSingleOption(arguments_, "--workspace") : loadDefaultWorkspace()
   };
 }
+function validatePairingId(value) {
+  if (!IDENTIFIER_PATTERN5.test(value)) {
+    throw new PairingClientError("invalid_pairing_id", "The Runtime pairing ID is invalid");
+  }
+  return value;
+}
 function parseChannelArgument(arguments_) {
   if (arguments_.length !== 2 || arguments_[0] !== "--channel") {
     throw new PairingClientError("invalid_arguments", "Usage: mobius start --channel <channel-id>");
@@ -23420,17 +23432,17 @@ function readRelayError(value) {
   }
   return new PairingClientError("pairing_failed", "The relay could not pair this machine");
 }
-function decodeClaimResponse(value) {
-  if (!isRecord7(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+function decodePairingResponse(value, credentialField, expectedKeys) {
+  if (!isRecord7(value) || !hasExactKeys(value, expectedKeys)) {
     throw new PairingClientError("invalid_relay_response", "The relay returned an invalid pairing response");
   }
   const channelId = value["channelId"];
-  const daemonToken2 = value["daemonToken"];
+  const runtimeCredential = value[credentialField];
   const runtimeId = value["runtimeId"];
-  if (typeof channelId !== "string" || !IDENTIFIER_PATTERN5.test(channelId) || typeof daemonToken2 !== "string" || !TOKEN_PATTERN2.test(daemonToken2) || typeof runtimeId !== "string" || !IDENTIFIER_PATTERN5.test(runtimeId)) {
+  if (typeof channelId !== "string" || !IDENTIFIER_PATTERN5.test(channelId) || typeof runtimeCredential !== "string" || !TOKEN_PATTERN2.test(runtimeCredential) || typeof runtimeId !== "string" || !IDENTIFIER_PATTERN5.test(runtimeId)) {
     throw new PairingClientError("invalid_relay_response", "The relay returned an invalid pairing response");
   }
-  return { channelId, daemonToken: daemonToken2, runtimeId };
+  return { channelId, runtimeCredential, runtimeId };
 }
 async function claimPairing(options, defaultWorkspace, localAgents, installableAgents, signal) {
   const agents = localAgents.map((agent) => ({
@@ -23440,7 +23452,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
     id: agent.id,
     label: agent.label
   }));
-  const endpoint = mobiusApiUrl(options.relayOrigin, "/pairings/claim");
+  const endpoint = options.pairingId.length > 0 ? mobiusApiUrl(options.relayOrigin, `/v1/runtime-pairings/${encodeURIComponent(options.pairingId)}/redeem`) : mobiusApiUrl(options.relayOrigin, "/pairings/claim");
   let response;
   try {
     response = await fetch2(endpoint, {
@@ -23463,10 +23475,10 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   if (!response.ok) {
     throw readRelayError(value);
   }
-  return decodeClaimResponse(value);
+  return options.pairingId.length > 0 ? decodePairingResponse(value, "runtimeCredential", REDEEM_RESPONSE_KEYS) : decodePairingResponse(value, "daemonToken", CLAIM_RESPONSE_KEYS);
 }
-async function persistConnection(channelId, relayOrigin, daemonToken2, defaultWorkspace) {
-  const connectionsDirectory = join14(readStateDirectory(), "connections");
+async function persistConnection(channelId, relayOrigin, runtimeCredential, defaultWorkspace, environment) {
+  const connectionsDirectory = join14(readStateDirectory(environment), "connections");
   await mkdir3(connectionsDirectory, { mode: 448, recursive: true });
   const connectionPath = join14(connectionsDirectory, `${channelId}.json`);
   const temporaryPath = join14(connectionsDirectory, `.${channelId}.${randomUUID2()}.tmp`);
@@ -23476,8 +23488,8 @@ async function persistConnection(channelId, relayOrigin, daemonToken2, defaultWo
       {
         defaultWorkspace,
         channelId,
-        daemonToken: daemonToken2,
-        relayOrigin: relayOrigin.toString()
+        relayOrigin: relayOrigin.toString(),
+        runtimeCredential
       },
       null,
       2
@@ -23489,25 +23501,25 @@ async function persistConnection(channelId, relayOrigin, daemonToken2, defaultWo
   return connectionPath;
 }
 function decodeSavedConnection(value, expectedChannelId) {
-  if (!isRecord7(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+  if (!isRecord7(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS) && !hasExactKeys(value, LEGACY_SAVED_CONNECTION_KEYS)) {
     throw new PairingClientError("invalid_connection", "The saved connection is invalid");
   }
   const defaultWorkspace = value["defaultWorkspace"];
   const channelId = value["channelId"];
-  const daemonToken2 = value["daemonToken"];
+  const runtimeCredential = value["runtimeCredential"] ?? value["daemonToken"];
   const relayOrigin = value["relayOrigin"];
-  if (typeof defaultWorkspace !== "string" || typeof channelId !== "string" || channelId !== expectedChannelId || !IDENTIFIER_PATTERN5.test(channelId) || typeof daemonToken2 !== "string" || !TOKEN_PATTERN2.test(daemonToken2) || typeof relayOrigin !== "string") {
+  if (typeof defaultWorkspace !== "string" || typeof channelId !== "string" || channelId !== expectedChannelId || !IDENTIFIER_PATTERN5.test(channelId) || typeof runtimeCredential !== "string" || !TOKEN_PATTERN2.test(runtimeCredential) || typeof relayOrigin !== "string") {
     throw new PairingClientError("invalid_connection", "The saved connection is invalid");
   }
   return {
     defaultWorkspace,
     channelId,
-    daemonToken: daemonToken2,
-    relayOrigin: parseRelayOrigin(relayOrigin)
+    relayOrigin: parseRelayOrigin(relayOrigin),
+    runtimeCredential
   };
 }
-async function readSavedConnection(channelId) {
-  const connectionPath = join14(readStateDirectory(), "connections", `${channelId}.json`);
+async function readSavedConnection(channelId, environment) {
+  const connectionPath = join14(readStateDirectory(environment), "connections", `${channelId}.json`);
   let encoded = "";
   const handle = await open4(connectionPath, "r");
   try {
@@ -23529,8 +23541,8 @@ async function readSavedConnection(channelId) {
   return {
     defaultWorkspace: await resolveDefaultWorkspace(connection.defaultWorkspace),
     channelId: connection.channelId,
-    daemonToken: connection.daemonToken,
-    relayOrigin: connection.relayOrigin
+    relayOrigin: connection.relayOrigin,
+    runtimeCredential: connection.runtimeCredential
   };
 }
 function assertInventoryUsable(inventory) {
@@ -23538,15 +23550,12 @@ function assertInventoryUsable(inventory) {
     throw new PairingClientError("no_supported_agent", "No supported Agent is available for local discovery");
   }
 }
-function buildPairedDaemon(connection, connectionPath, inventory) {
+function buildPairedDaemon(connection, connectionPath, inventory, environment) {
   assertInventoryUsable(inventory);
-  const relayUrl = mobiusApiUrl(
-    connection.relayOrigin,
-    `/channels/${encodeURIComponent(connection.channelId)}/daemon`
-  );
+  const relayUrl = mobiusApiUrl(connection.relayOrigin, "/v1/runtimes/connect");
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
-  relayUrl.searchParams.set("token", connection.daemonToken);
-  const auditDatabasePath = join14(readStateDirectory(), "audit", `${connection.channelId}.sqlite`);
+  relayUrl.searchParams.set("token", connection.runtimeCredential);
+  const auditDatabasePath = join14(readStateDirectory(environment), "audit", `${connection.channelId}.sqlite`);
   return {
     channelUrl: new URL(`/channels/${encodeURIComponent(connection.channelId)}`, connection.relayOrigin).toString(),
     config: createDaemonConfig(
@@ -23562,12 +23571,11 @@ function buildPairedDaemon(connection, connectionPath, inventory) {
     connectionPath
   };
 }
-async function pairLocalMachine(arguments_, signal = new AbortController().signal) {
-  const options = parsePairCommand(arguments_);
+async function pairRuntime(options, signal, environment) {
   const defaultWorkspace = await resolveDefaultWorkspace(options.workspace);
   const inventory = await discoverLocalAgentInventory({
     defaultWorkspace,
-    environment: process.env,
+    environment,
     signal
   });
   assertInventoryUsable(inventory);
@@ -23576,32 +23584,88 @@ async function pairLocalMachine(arguments_, signal = new AbortController().signa
   const connectionPath = await persistConnection(
     claim2.channelId,
     options.relayOrigin,
-    claim2.daemonToken,
-    defaultWorkspace
+    claim2.runtimeCredential,
+    defaultWorkspace,
+    environment
   );
   return buildPairedDaemon(
     {
       defaultWorkspace,
       channelId: claim2.channelId,
-      daemonToken: claim2.daemonToken,
-      relayOrigin: options.relayOrigin
+      relayOrigin: options.relayOrigin,
+      runtimeCredential: claim2.runtimeCredential
     },
     connectionPath,
-    inventory
+    inventory,
+    environment
   );
 }
-async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
-  const channelId = parseChannelArgument(arguments_);
-  const connectionPath = join14(readStateDirectory(), "connections", `${channelId}.json`);
-  const connection = await readSavedConnection(channelId);
+async function pairLocalMachine(arguments_, signal = new AbortController().signal) {
+  return await pairRuntime(parsePairCommand(arguments_), signal, process.env);
+}
+async function resumeMobiusRuntime(channelId, signal, environment = process.env) {
+  const normalizedChannelId = validatePairingId(channelId);
+  const connectionPath = join14(readStateDirectory(environment), "connections", `${normalizedChannelId}.json`);
+  const connection = await readSavedConnection(normalizedChannelId, environment);
   const inventory = await discoverLocalAgentInventory({
     defaultWorkspace: connection.defaultWorkspace,
-    environment: process.env,
+    environment,
     signal
   });
-  return buildPairedDaemon(connection, connectionPath, inventory);
+  return buildPairedDaemon(connection, connectionPath, inventory, environment);
+}
+async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
+  return await resumeMobiusRuntime(parseChannelArgument(arguments_), signal, process.env);
 }
 
+// src/audit/audit-store.ts
+import { mkdirSync } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var AuditStore = class {
+  database;
+  constructor(path2) {
+    mkdirSync(dirname3(path2), { recursive: true });
+    this.database = new DatabaseSync(path2);
+    this.database.exec(`
+      CREATE TABLE IF NOT EXISTS audit_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        recorded_at TEXT NOT NULL,
+        event TEXT NOT NULL,
+        command_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        details_json TEXT NOT NULL DEFAULT '{}'
+      ) STRICT
+    `);
+    const columns = this.database.prepare("PRAGMA table_info(audit_events)").all();
+    if (!columns.some((column) => Reflect.get(column, "name") === "details_json")) {
+      this.database.exec("ALTER TABLE audit_events ADD COLUMN details_json TEXT NOT NULL DEFAULT '{}'");
+    }
+  }
+  record(record2) {
+    this.database.prepare(
+      `
+          INSERT INTO audit_events (
+            recorded_at,
+            event,
+            command_id,
+            session_id,
+            details_json
+          ) VALUES (?, ?, ?, ?, ?)
+        `
+    ).run(
+      (/* @__PURE__ */ new Date()).toISOString(),
+      record2.event,
+      record2.commandId,
+      record2.sessionId,
+      JSON.stringify(record2.details ?? {})
+    );
+  }
+  close() {
+    this.database.close();
+  }
+};
+
 // src/run-daemon.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { basename as basename4, join as join16 } from "node:path";
@@ -26992,14 +27056,19 @@ var AgentCatalogPublishError = class extends Error {
     this.name = "AgentCatalogPublishError";
   }
 };
-function catalogEndpoint(relayUrl) {
-  const endpoint = new URL(relayUrl);
+function catalogEndpoint(config2) {
+  const endpoint = new URL(config2.relayUrl);
   endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
-  if (!endpoint.pathname.endsWith("/daemon")) {
-    throw new AgentCatalogPublishError("The Relay URL is invalid");
+  if (endpoint.pathname.endsWith("/daemon")) {
+    endpoint.pathname = `${endpoint.pathname.slice(0, -"/daemon".length)}/catalog`;
+    return endpoint;
   }
-  endpoint.pathname = `${endpoint.pathname.slice(0, -"/daemon".length)}/catalog`;
-  return endpoint;
+  const runtimePath = "/v1/runtimes/connect";
+  if (endpoint.pathname.endsWith(runtimePath)) {
+    endpoint.pathname = `${endpoint.pathname.slice(0, -runtimePath.length)}/channels/${encodeURIComponent(config2.channelId)}/catalog`;
+    return endpoint;
+  }
+  throw new AgentCatalogPublishError("The Relay URL is invalid");
 }
 async function publishAgentCatalog(config2, signal) {
   signal.throwIfAborted();
@@ -27008,7 +27077,7 @@ async function publishAgentCatalog(config2, signal) {
   let response;
   const catalog = config2.catalog.read();
   try {
-    response = await fetch3(catalogEndpoint(config2.relayUrl), {
+    response = await fetch3(catalogEndpoint(config2), {
       body: JSON.stringify({
         agents: catalog.agents.map((agent) => ({
           agentPath: agent.agentIdentity.requestedPath,
@@ -29064,10 +29133,17 @@ function parseReference(resource) {
 function downloadUrl(config2, command, reference) {
   const url2 = new URL(config2.relayUrl);
   url2.protocol = url2.protocol === "wss:" ? "https:" : "http:";
-  if (!url2.pathname.endsWith("/daemon")) {
-    throw new PromptArtifactError("artifact_endpoint_invalid", "The Relay artifact endpoint is invalid");
+  let channelPath = "";
+  if (url2.pathname.endsWith("/daemon")) {
+    channelPath = url2.pathname.slice(0, -"/daemon".length);
+  } else {
+    const runtimePath = "/v1/runtimes/connect";
+    if (!url2.pathname.endsWith(runtimePath)) {
+      throw new PromptArtifactError("artifact_endpoint_invalid", "The Relay artifact endpoint is invalid");
+    }
+    channelPath = `${url2.pathname.slice(0, -runtimePath.length)}/channels/${encodeURIComponent(config2.channelId)}`;
   }
-  url2.pathname = `${url2.pathname.slice(0, -"/daemon".length)}/sessions/${encodeURIComponent(command.sessionId)}/commands/${encodeURIComponent(command.commandId)}/artifacts/${encodeURIComponent(reference.artifactId)}/content`;
+  url2.pathname = `${channelPath}/sessions/${encodeURIComponent(command.sessionId)}/commands/${encodeURIComponent(command.commandId)}/artifacts/${encodeURIComponent(reference.artifactId)}/content`;
   url2.searchParams.delete("liveness");
   return url2;
 }
@@ -29217,17 +29293,27 @@ import { WebSocket } from "undici";
 var CONNECTION_TIMEOUT_MILLISECONDS = 15e3;
 var RelayConnectionError = class extends Error {
   code;
-  constructor(code, message, options = {}) {
+  diagnosticDetails;
+  constructor(code, message, diagnosticDetails = {}, options = {}) {
     super(message, options);
     this.code = code;
+    this.diagnosticDetails = diagnosticDetails;
     this.name = "RelayConnectionError";
   }
 };
 function connectRelay(url2, signal) {
   signal.throwIfAborted();
   return new Promise((resolve5, reject) => {
-    const socket = new WebSocket(url2, {
-      dispatcher: environmentProxyDispatcher
+    const endpoint = new URL(url2);
+    const headers = {};
+    if (endpoint.pathname.endsWith("/v1/runtimes/connect")) {
+      const runtimeCredential = endpoint.searchParams.get("token") ?? "";
+      endpoint.searchParams.delete("token");
+      headers["authorization"] = `Bearer ${runtimeCredential}`;
+    }
+    const socket = new WebSocket(endpoint, {
+      dispatcher: environmentProxyDispatcher,
+      headers
     });
     let finished = false;
     const timeout = setTimeout(onTimeout, CONNECTION_TIMEOUT_MILLISECONDS);
@@ -29249,16 +29335,34 @@ function connectRelay(url2, signal) {
     };
     const onAbort = () => {
       fail(
-        new RelayConnectionError("relay_connection_cancelled", "Relay connection was cancelled", {
-          cause: signal.reason
-        })
+        new RelayConnectionError(
+          "relay_connection_cancelled",
+          "Relay connection was cancelled",
+          {
+            cancellation: "requested"
+          },
+          { cause: signal.reason }
+        )
       );
     };
-    const onClose = () => {
-      fail(new RelayConnectionError("relay_connection_closed", "Relay connection closed before it was ready"));
+    const onClose = (event) => {
+      fail(
+        new RelayConnectionError("relay_connection_closed", "Relay connection closed before it was ready", {
+          closeCode: event.code.toString(),
+          closeReason: event.reason
+        })
+      );
     };
-    const onError = () => {
-      fail(new RelayConnectionError("relay_connection_failed", "Relay connection failed"));
+    const onError = (event) => {
+      const cause = Reflect.get(event, "error");
+      fail(
+        new RelayConnectionError(
+          "relay_connection_failed",
+          "Relay connection failed",
+          {},
+          { cause: cause ?? event }
+        )
+      );
     };
     const onOpen = () => {
       if (finished) {
@@ -29269,7 +29373,11 @@ function connectRelay(url2, signal) {
       resolve5(socket);
     };
     function onTimeout() {
-      fail(new RelayConnectionError("relay_connection_timeout", "Relay connection timed out"));
+      fail(
+        new RelayConnectionError("relay_connection_timeout", "Relay connection timed out", {
+          timeoutMilliseconds: CONNECTION_TIMEOUT_MILLISECONDS.toString()
+        })
+      );
     }
     signal.addEventListener("abort", onAbort, { once: true });
     socket.addEventListener("close", onClose, { once: true });
@@ -29281,6 +29389,142 @@ function connectRelay(url2, signal) {
   });
 }
 
+// src/relay-connection/diagnostics.ts
+var MAX_DIAGNOSTIC_TEXT_LENGTH = 256;
+function sanitizeDiagnosticText(value) {
+  const printable = Array.from(value, (character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 || code === 127 ? " " : character;
+  }).join("");
+  const withoutSecrets = printable.replace(/([?&](?:access_token|authorization|credential|key|secret|token)=)[^&\s]*/giu, "$1[redacted]").replace(/(?:https?|wss?):\/\/[^\s)]+/giu, (encodedUrl) => {
+    try {
+      return new URL(encodedUrl).origin;
+    } catch {
+      return "[redacted-url]";
+    }
+  });
+  return withoutSecrets.slice(0, MAX_DIAGNOSTIC_TEXT_LENGTH);
+}
+function addFailureDetails(details, failure) {
+  let current = failure;
+  for (let depth = 0; depth < 3 && current instanceof Error; depth += 1) {
+    const prefix = depth === 0 ? "failure" : `cause${depth.toString()}`;
+    details[`${prefix}Name`] = current.name;
+    details[`${prefix}Message`] = sanitizeDiagnosticText(current.message);
+    const code = Reflect.get(current, "code");
+    if (typeof code === "string" || typeof code === "number") {
+      details[`${prefix}Code`] = String(code);
+    }
+    const statusCode = Reflect.get(current, "statusCode");
+    if (typeof statusCode === "string" || typeof statusCode === "number") {
+      details[`${prefix}StatusCode`] = String(statusCode);
+    }
+    const diagnosticDetails = Reflect.get(current, "diagnosticDetails");
+    if (typeof diagnosticDetails === "object" && diagnosticDetails !== null) {
+      for (const [key, value] of Object.entries(diagnosticDetails)) {
+        if (typeof value === "string") {
+          details[key] = sanitizeDiagnosticText(value);
+        }
+      }
+    }
+    current = current.cause;
+  }
+}
+var RelayConnectionDiagnostics = class {
+  #audit;
+  #channelId;
+  #lastClosedEpoch = 0;
+  #lastFailedEpoch = 0;
+  #relayOrigin;
+  #route;
+  constructor(audit, channelId, relayUrl) {
+    this.#audit = audit;
+    this.#channelId = channelId;
+    this.#relayOrigin = relayUrl.origin;
+    this.#route = describeEnvironmentProxyRoute(relayUrl);
+  }
+  catalogFailed = (failure) => {
+    const details = { ...this.#route, relayOrigin: this.#relayOrigin };
+    addFailureDetails(details, failure);
+    this.#record("agent_catalog_publish_failed", "catalog", details, true);
+  };
+  connectionClosed = (connectionEpoch, code, reason, source) => {
+    if (this.#lastClosedEpoch === connectionEpoch) {
+      return;
+    }
+    this.#lastClosedEpoch = connectionEpoch;
+    this.#record(
+      "relay_connection_closed",
+      connectionEpoch.toString(),
+      {
+        closeCode: code.toString(),
+        closeReason: sanitizeDiagnosticText(reason),
+        connectionEpoch: connectionEpoch.toString(),
+        relayOrigin: this.#relayOrigin,
+        source,
+        ...this.#route
+      },
+      true
+    );
+  };
+  connectionFailed = (connectionEpoch, failure, source) => {
+    if (this.#lastFailedEpoch === connectionEpoch) {
+      return;
+    }
+    this.#lastFailedEpoch = connectionEpoch;
+    const details = {
+      connectionEpoch: connectionEpoch.toString(),
+      relayOrigin: this.#relayOrigin,
+      source,
+      ...this.#route
+    };
+    addFailureDetails(details, failure);
+    this.#record("relay_connection_failed", connectionEpoch.toString(), details, true);
+  };
+  connectionOpened = (connectionEpoch) => {
+    this.#record(
+      "relay_connection_opened",
+      connectionEpoch.toString(),
+      {
+        connectionEpoch: connectionEpoch.toString(),
+        relayOrigin: this.#relayOrigin,
+        ...this.#route
+      },
+      false
+    );
+  };
+  heartbeatTimedOut = (connectionEpoch, heartbeatId, timeoutMilliseconds) => {
+    this.#record(
+      "relay_heartbeat_timed_out",
+      connectionEpoch.toString(),
+      {
+        connectionEpoch: connectionEpoch.toString(),
+        heartbeatId,
+        relayOrigin: this.#relayOrigin,
+        timeoutMilliseconds: timeoutMilliseconds.toString(),
+        ...this.#route
+      },
+      true
+    );
+  };
+  #record = (event, commandId, details, warning) => {
+    this.#audit.record({
+      commandId,
+      details,
+      event,
+      sessionId: this.#channelId
+    });
+    const encoded = JSON.stringify({ channelId: this.#channelId, event, ...details });
+    if (warning) {
+      process.stderr.write(`Mobius relay diagnostic ${encoded}
+`);
+      return;
+    }
+    process.stdout.write(`Mobius relay diagnostic ${encoded}
+`);
+  };
+};
+
 // src/relay-connection/liveness.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 var HEARTBEAT_ACK_TIMEOUT_MILLISECONDS = 1e4;
@@ -29357,9 +29601,10 @@ var RelayConnectionLiveness = class {
     if (!(this.#state instanceof AwaitingHeartbeatAckState)) {
       throw new Error("Heartbeat timeout occurred in an invalid state");
     }
+    const heartbeatId = this.#state.heartbeatId;
     this.#state.timeout.cancel();
     this.#state = new FinishedRelayLivenessState();
-    this.#transport.unresponsive();
+    this.#transport.unresponsive(heartbeatId, HEARTBEAT_ACK_TIMEOUT_MILLISECONDS);
   };
   #sendHeartbeat = () => {
     if (this.#state instanceof WaitingForHeartbeatState) {
@@ -29408,6 +29653,7 @@ var SessionEventOutbox = class {
         ordinal INTEGER PRIMARY KEY AUTOINCREMENT,
         event_id TEXT NOT NULL UNIQUE,
         session_id TEXT NOT NULL,
+        source_key TEXT NOT NULL,
         envelope_json TEXT NOT NULL
       ) STRICT;
       CREATE INDEX IF NOT EXISTS relay_session_event_outbox_order
@@ -29435,6 +29681,27 @@ var SessionEventOutbox = class {
         )
       ) STRICT;
     `);
+    const outboxColumns = this.#database.prepare("PRAGMA table_info(relay_session_event_outbox)").all();
+    const hasSourceKey = outboxColumns.some(
+      (column) => typeof column === "object" && column !== null && Reflect.get(column, "name") === "source_key"
+    );
+    if (!hasSourceKey) {
+      this.#database.exec(`
+        ALTER TABLE relay_session_event_outbox
+          ADD COLUMN source_key TEXT NOT NULL DEFAULT '';
+      `);
+    }
+    this.#database.exec(`
+      UPDATE relay_session_event_outbox
+      SET source_key = CASE json_extract(envelope_json, '$.source.kind')
+        WHEN 'attempt' THEN
+          'attempt:' || session_id || ':' || json_extract(envelope_json, '$.source.attemptId')
+        ELSE 'runtime:' || session_id
+      END
+      WHERE source_key = '';
+      CREATE INDEX IF NOT EXISTS relay_session_event_outbox_source_order
+        ON relay_session_event_outbox(source_key, ordinal);
+    `);
   }
   claimExecution = (commandId, sessionId, commandJson) => {
     this.#database.exec("BEGIN IMMEDIATE");
@@ -29492,12 +29759,10 @@ var SessionEventOutbox = class {
     const state = typeof row === "object" && row !== null ? Reflect.get(row, "state") : void 0;
     return state === "succeeded" || state === "failed" || state === "cancelled";
   };
-  acknowledge = (acknowledgement) => {
-    this.#database.prepare(
-      `DELETE FROM relay_session_event_outbox
+  acknowledge = (acknowledgement) => this.#database.prepare(
+    `DELETE FROM relay_session_event_outbox
          WHERE event_id = ? AND session_id = ?`
-    ).run(acknowledgement.eventId, acknowledgement.sessionId);
-  };
+  ).run(acknowledgement.eventId, acknowledgement.sessionId).changes === 1;
   quarantine = (rejection) => {
     this.#database.exec("BEGIN IMMEDIATE");
     try {
@@ -29564,9 +29829,9 @@ var SessionEventOutbox = class {
       ).run(sourceKey, nextSourceSeq + 1);
       this.#database.prepare(
         `INSERT INTO relay_session_event_outbox (
-             event_id, session_id, envelope_json
-           ) VALUES (?, ?, ?)`
-      ).run(envelope2.eventId, envelope2.sessionId, encoded);
+             event_id, session_id, source_key, envelope_json
+           ) VALUES (?, ?, ?, ?)`
+      ).run(envelope2.eventId, envelope2.sessionId, sourceKey, encoded);
       this.#database.exec("COMMIT");
       return encoded;
     } catch (error61) {
@@ -29579,6 +29844,27 @@ var SessionEventOutbox = class {
          FROM relay_session_event_outbox
          ORDER BY ordinal`
   ).all().map(readPendingEnvelope);
+  pendingBatch = (limit) => {
+    if (!Number.isSafeInteger(limit) || limit < 1) {
+      throw new Error("Session event replay batch limit must be a positive integer");
+    }
+    return this.#database.prepare(
+      `WITH ranked_events AS (
+                   SELECT ordinal,
+                          ROW_NUMBER() OVER (
+                            PARTITION BY source_key
+                            ORDER BY ordinal
+                          ) AS source_position
+                   FROM relay_session_event_outbox
+                 )
+                 SELECT outbox.envelope_json
+                 FROM ranked_events AS ranked
+                 INNER JOIN relay_session_event_outbox AS outbox
+                   ON outbox.ordinal = ranked.ordinal
+                 ORDER BY ranked.source_position, outbox.ordinal
+                 LIMIT ?`
+    ).all(limit).map(readPendingEnvelope);
+  };
 };
 function isDaemonExecutionState(value) {
   return value === "cancelled" || value === "dispatching" || value === "failed" || value === "running" || value === "succeeded";
@@ -29595,7 +29881,7 @@ var systemDaemonTimer = new SystemDaemonTimer();
 
 // src/run-daemon.ts
 var RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
-var RELAY_CONNECTION_REFRESH_MILLISECONDS = 20 * 60 * 1e3;
+var AGENT_ACTIVITY_COALESCING_MILLISECONDS = 100;
 var ACTIVE_TURN_RECONCILIATION_TIMEOUT_MILLISECONDS = 2e4;
 var ACTIVE_TURN_RECONCILIATION_CLOSE_CODE = 4009;
 function botIpcSocketPath() {
@@ -29604,54 +29890,6 @@ function botIpcSocketPath() {
   }
   return join16("/tmp", `mobius-bot-${randomUUID6()}.sock`);
 }
-var RelayConnectionRefreshState = class {
-};
-var ScheduledRelayConnectionRefreshState = class extends RelayConnectionRefreshState {
-};
-var DueRelayConnectionRefreshState = class extends RelayConnectionRefreshState {
-};
-var FinishedRelayConnectionRefreshState = class extends RelayConnectionRefreshState {
-};
-var RelayConnectionRefresh = class {
-  #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();
-  };
-};
 var DaemonAcpObserver = class {
   #record;
   constructor(record2) {
@@ -29848,10 +30086,17 @@ var ActiveTurnReconciliationError = class extends Error {
 function activeTurnReconciliationEndpoint(config2, turn) {
   const endpoint = new URL(config2.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(config2.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;
 }
@@ -29909,7 +30154,8 @@ var DaemonSessionEventConnectionState = class {
 };
 var DisconnectedDaemonSessionEventState = class extends DaemonSessionEventConnectionState {
   disconnect = () => this;
-  send = () => void 0;
+  matches = () => false;
+  send = () => false;
 };
 var ConnectedDaemonSessionEventState = class extends DaemonSessionEventConnectionState {
   #socket;
@@ -29918,38 +30164,155 @@ var ConnectedDaemonSessionEventState = class extends DaemonSessionEventConnectio
     this.#socket = socket;
   }
   disconnect = (socket) => socket === this.#socket ? new DisconnectedDaemonSessionEventState() : this;
+  matches = (socket) => socket === this.#socket;
   send = (message) => {
-    if (this.#socket.readyState === WebSocket2.OPEN) {
-      try {
-        this.#socket.send(message);
-      } catch {
-      }
+    if (this.#socket.readyState !== WebSocket2.OPEN) {
+      return false;
+    }
+    try {
+      this.#socket.send(message);
+      return true;
+    } catch {
+      return false;
     }
   };
 };
+var SESSION_EVENT_REPLAY_WINDOW = 4;
 var DaemonSessionEventPublisher = class {
   #outbox;
+  #inFlightEventIds = /* @__PURE__ */ 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 envelope2 = decodeSessionEventEnvelope(encoded);
+      if (!this.#connection.send(encoded)) {
+        this.#inFlightEventIds.clear();
+        return;
+      }
+      this.#inFlightEventIds.add(envelope2.eventId);
+    }
   };
 };
+var CoalescingDaemonActivityPublisher = class {
+  #pending = /* @__PURE__ */ new Map();
+  #publish;
+  #publishedActivityIds = /* @__PURE__ */ new Set();
+  #scheduled = /* @__PURE__ */ 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 !== void 0) {
+      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,
@@ -30126,7 +30489,10 @@ async function executeSessionConfigure(publisher, socket, command, config2, dire
     reportOperationFailure(socket, command.requestId, command.sessionId, error61);
   }
 }
-async function executePrompt(outbox, publisher, command, config2, directories, audit, sessions, attemptId, signal) {
+async function executePrompt(outbox, publisher, command, config2, 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,
@@ -30183,30 +30549,7 @@ async function executePrompt(outbox, publisher, command, config2, directories, a
         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,
@@ -30229,6 +30572,7 @@ async function executePrompt(outbox, publisher, command, config2, directories, a
       });
       stopReason = result.stopReason;
     }
+    activities.flush();
     publisher.recordAttempt(
       command.sessionId,
       encodeSessionCompletedEvent({
@@ -30246,6 +30590,7 @@ async function executePrompt(outbox, publisher, command, config2, directories, a
       sessionId: command.sessionId
     });
   } catch (error61) {
+    activities.flush();
     audit.record({
       commandId: command.commandId,
       event: "session_failed",
@@ -30284,7 +30629,10 @@ function botExecutionAgent(agent, contextHandle, socketPath) {
     agent.capabilities
   );
 }
-async function executeBotPrompt(outbox, publisher, command, config2, directories, audit, sessions, grants, contexts, applicator, ipc, attemptId, signal) {
+async function executeBotPrompt(outbox, publisher, command, config2, 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();
@@ -30368,30 +30716,7 @@ async function executeBotPrompt(outbox, publisher, command, config2, 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,
@@ -30411,6 +30736,7 @@ async function executeBotPrompt(outbox, publisher, command, config2, directories
         sessionId: command.sessionId,
         signal: executionSignal
       });
+      activities.flush();
       publisher.recordAttempt(
         command.sessionId,
         encodeSessionCompletedEvent({
@@ -30435,6 +30761,7 @@ async function executeBotPrompt(outbox, publisher, command, config2, directories
       lease.release();
     }
   } catch (error61) {
+    activities.flush();
     const failure = Date.parse(command.executionDeadlineAt) <= Date.now() ? new LocalBotAuthorizationError("turn_expired", "The Bot execution deadline has expired", {
       cause: error61
     }) : error61;
@@ -30474,15 +30801,15 @@ function waitForRelayRetry(signal, timer) {
     signal.addEventListener("abort", finish, { once: true });
   });
 }
-async function publishAgentCatalogUntilAvailable(config2, signal, timer) {
+async function publishAgentCatalogUntilAvailable(config2, diagnostics, signal, timer) {
   try {
     await publishAgentCatalog(config2, signal);
     return;
-  } catch {
+  } catch (error61) {
     if (signal.aborted) {
       return;
     }
-    console.warn("Mobius daemon is waiting to publish its Agent catalog");
+    diagnostics.catalogFailed(error61);
   }
   while (!signal.aborted) {
     await waitForRelayRetry(signal, timer);
@@ -30496,11 +30823,12 @@ async function publishAgentCatalogUntilAvailable(config2, signal, timer) {
     }
   }
 }
-async function runRelayConnection(config2, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, grants, contexts, applicator, ipc, activeTurns, activeAttemptIds, onConnected, signal, timer) {
+async function runRelayConnection(config2, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, grants, contexts, applicator, ipc, activeTurns, activeAttemptIds, connectionEpoch, diagnostics, onConnected, signal, timer) {
   const relayUrl = new URL(config2.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 = /* @__PURE__ */ new Map();
@@ -30509,7 +30837,6 @@ async function runRelayConnection(config2, directories, audit, sessions, install
     await new Promise((resolve5, reject) => {
       let finished = false;
       const cleanup = () => {
-        connectionRefresh.close();
         connectionLiveness.close();
         signal.removeEventListener("abort", stop);
         socket.removeEventListener("close", handleClose);
@@ -30527,61 +30854,70 @@ async function runRelayConnection(config2, directories, audit, sessions, install
         cleanup();
         resolve5();
       };
-      const rejectConnection = () => {
+      const rejectConnection = (failure) => {
         if (finished) {
           return;
         }
         finished = true;
         cleanup();
-        reject(new Error("Relay WebSocket failed"));
+        reject(failure);
       };
       const stop = () => {
+        diagnostics.connectionClosed(connectionEpoch, 1e3, "Daemon stopped", "daemon_stop");
         closeRelaySocket(socket, 1e3, "Daemon stopped");
         resolveConnection();
       };
-      const refreshConnection = () => {
-        closeRelaySocket(socket, 1e3, "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 },
@@ -30960,6 +31296,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
               applicator,
               ipc,
               receipt2.attemptId,
+              timer,
               turn2.signal
             ).catch((error61) => {
               console.error("Mobius daemon Bot turn failed", error61);
@@ -30969,7 +31306,6 @@ async function runRelayConnection(config2, directories, audit, sessions, install
                 activeAttemptIds.delete(command2.sessionId);
               }
               turn2.finish();
-              connectionRefresh.afterTurnFinished();
             });
             return;
           }
@@ -30998,6 +31334,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
             audit,
             sessions,
             receipt.attemptId,
+            timer,
             turn.signal
           ).catch((error61) => {
             console.error("Mobius daemon turn failed", error61);
@@ -31007,12 +31344,15 @@ async function runRelayConnection(config2, directories, audit, sessions, install
               activeAttemptIds.delete(command.sessionId);
             }
             turn.finish();
-            connectionRefresh.afterTurnFinished();
           });
         } catch (error61) {
           console.error("Mobius daemon rejected a message", error61);
-          closeRelaySocket(socket, 4008, "Invalid protocol message");
-          rejectConnection();
+          failAndClose(
+            new Error("Relay sent an invalid protocol message", { cause: error61 }),
+            4008,
+            "Invalid protocol message",
+            "protocol"
+          );
         }
       };
       socket.addEventListener("close", handleClose);
@@ -31024,21 +31364,18 @@ async function runRelayConnection(config2, directories, audit, sessions, install
             return;
           }
           publisher.connect(socket);
-          void Promise.all(reconnectingTurns.map((turn) => turn.completion)).then(
-            connectionRefresh.afterTurnFinished
-          );
         },
         (error61) => {
           if (finished) {
             return;
           }
           console.error("Mobius daemon could not reconcile active Agent turns", error61);
-          closeRelaySocket(
-            socket,
+          failAndClose(
+            new Error("Active Agent turn reconciliation failed", { cause: error61 }),
             ACTIVE_TURN_RECONCILIATION_CLOSE_CODE,
-            "Active Agent turn reconciliation failed"
+            "Active Agent turn reconciliation failed",
+            "reconciliation"
           );
-          rejectConnection();
         }
       );
       if (signal.aborted) {
@@ -31082,6 +31419,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
   const sessions = new AcpSessionManager(new DaemonAcpObserver(recordSessionEvent), sessionStore);
   const directories = new WorkspaceDirectoryService(config2.bindingId, config2.defaultWorkspace);
   const installationObserver = new DaemonInstallationObserver();
+  const diagnostics = new RelayConnectionDiagnostics(audit, config2.channelId, config2.relayUrl);
   const nativeSessions = new NativeSessionService(config2, directories, sessions, audit);
   const installations = new AgentInstallationManager(
     specifications,
@@ -31089,7 +31427,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
     installationObserver,
     installationAudit
   );
-  let retryAnnounced = false;
+  let connectionEpoch = 0;
   let connectionAnnounced = false;
   const announceConnection = () => {
     if (connectionAnnounced) {
@@ -31105,10 +31443,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
 `
     );
   };
-  const catalogPublication = publishAgentCatalogUntilAvailable(config2, signal, timer);
+  const catalogPublication = publishAgentCatalogUntilAvailable(config2, diagnostics, signal, timer);
   try {
     await ipc.listen(signal);
     while (!signal.aborted) {
+      connectionEpoch += 1;
       try {
         await runRelayConnection(
           config2,
@@ -31126,19 +31465,17 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
           ipc,
           activeTurns,
           activeAttemptIds,
+          connectionEpoch,
+          diagnostics,
           announceConnection,
           signal,
           timer
         );
-        retryAnnounced = false;
-      } catch {
+      } catch (error61) {
         if (signal.aborted) {
           return;
         }
-        if (!retryAnnounced) {
-          console.warn("Mobius daemon is waiting for the relay");
-          retryAnnounced = true;
-        }
+        diagnostics.connectionFailed(connectionEpoch, error61, "connection");
       }
       await waitForRelayRetry(signal, timer);
     }
@@ -31176,6 +31513,69 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
   }
 }
 
+// src/runtime.ts
+var APP_CREDENTIAL_PATTERN = /^mapp_[a-zA-Z0-9_-]{22}_[a-zA-Z0-9_-]{43}$/;
+var CONVERSATION_CREDENTIAL_PATTERN = /^mconv_[a-zA-Z0-9_-]{22}_[a-zA-Z0-9_-]{43}$/;
+var RUNTIME_CREDENTIAL_PATTERN = /^[a-zA-Z0-9_-]{32,256}$/;
+var MobiusRuntimeConfigurationError = class extends Error {
+  code = "runtime_configuration_invalid";
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "MobiusRuntimeConfigurationError";
+  }
+};
+var MobiusRuntimeState = class {
+};
+var IdleMobiusRuntimeState = class extends MobiusRuntimeState {
+};
+var RunningMobiusRuntimeState = class extends MobiusRuntimeState {
+};
+var FinishedMobiusRuntimeState = class extends MobiusRuntimeState {
+};
+function validateRuntimeRelay(relayUrl) {
+  if (relayUrl.protocol !== "ws:" && relayUrl.protocol !== "wss:") {
+    throw new MobiusRuntimeConfigurationError("The Runtime relay URL must use WebSocket transport");
+  }
+  const credential = relayUrl.searchParams.get("token") ?? "";
+  if (credential.length === 0) {
+    throw new MobiusRuntimeConfigurationError("The Runtime relay credential is required");
+  }
+  if (APP_CREDENTIAL_PATTERN.test(credential)) {
+    throw new MobiusRuntimeConfigurationError("An AppCredential cannot be held by a local Runtime");
+  }
+  if (CONVERSATION_CREDENTIAL_PATTERN.test(credential)) {
+    throw new MobiusRuntimeConfigurationError("A ConversationAccessToken cannot be held by a local Runtime");
+  }
+  if (!RUNTIME_CREDENTIAL_PATTERN.test(credential)) {
+    throw new MobiusRuntimeConfigurationError("The Runtime relay credential is invalid");
+  }
+}
+function validateRuntimeConfiguration(config2) {
+  validateRuntimeRelay(config2.relayUrl);
+}
+var MobiusRuntimeEngine = class {
+  #config;
+  #state = new IdleMobiusRuntimeState();
+  constructor(config2) {
+    validateRuntimeConfiguration(config2);
+    this.#config = config2;
+  }
+  run = async (signal) => {
+    if (!(this.#state instanceof IdleMobiusRuntimeState)) {
+      throw new MobiusRuntimeConfigurationError("A Mobius Runtime engine can only be started once");
+    }
+    signal.throwIfAborted();
+    this.#state = new RunningMobiusRuntimeState();
+    const audit = new AuditStore(this.#config.auditDatabasePath);
+    try {
+      await runDaemon(this.#config, audit, signal);
+    } finally {
+      audit.close();
+      this.#state = new FinishedMobiusRuntimeState();
+    }
+  };
+};
+
 // src/cli.ts
 var shutdown = new AbortController();
 process.once("SIGINT", () => shutdown.abort());
@@ -31183,7 +31583,7 @@ process.once("SIGTERM", () => shutdown.abort());
 var USAGE = `Mobius CLI
 
 Usage:
-  mobius pair --url <relay-url> --code <pairing-code> [--workspace <directory>]
+  mobius pair --url <relay-url> --pairing <runtime-pairing-id> --code <pairing-code> [--workspace <directory>]
   mobius start --channel <channel-id>
   mobius agents [--json]
   mobius bot message send --target <current|alias> --text <message>
@@ -31256,12 +31656,7 @@ async function main() {
   process.stdout.write(`Default workspace: ${config2.defaultWorkspace}
 
 `);
-  const audit = new AuditStore(config2.auditDatabasePath);
-  try {
-    await runDaemon(config2, audit, shutdown.signal);
-  } finally {
-    audit.close();
-  }
+  await new MobiusRuntimeEngine(config2).run(shutdown.signal);
 }
 try {
   await main();