@moxt-ai/mobius 0.0.24 → 0.0.25

package/dist/index.js

@@ -21107,9 +21107,9 @@ function readStateDirectory(environment = process.env) {
 }
 
 // src/config.ts
-function loadDefaultWorkspace() {
-  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
-  return configuredWorkspace ?? join3(readStateDirectory(), "workspace");
+function loadDefaultWorkspace(environment = process.env) {
+  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = environment;
+  return configuredWorkspace ?? join3(readStateDirectory(environment), "workspace");
 }
 function createDaemonConfig(connection, agents = [], installableAgents = []) {
   return {
@@ -22462,7 +22462,7 @@ function createWritableAcpStream(output2) {
       if (outputFailure !== void 0) {
         return Promise.reject(outputFailure);
       }
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         pendingWriteFailures.add(reject);
         output2.write(chunk, (error61) => {
           pendingWriteFailures.delete(reject);
@@ -22475,7 +22475,7 @@ function createWritableAcpStream(output2) {
             reject(outputFailure);
             return;
           }
-          resolve5();
+          resolve6();
         });
       });
     }
@@ -22882,9 +22882,9 @@ var AcpProcessSession = class _AcpProcessSession {
     stderr.on("data", (chunk) => {
       process.stderr.write(`[${agent.id}-acp] ${chunk}`);
     });
-    this.#processExit = new Promise((resolve5) => {
-      this.#child.once("error", resolve5);
-      this.#child.once("exit", resolve5);
+    this.#processExit = new Promise((resolve6) => {
+      this.#child.once("error", resolve6);
+      this.#child.once("exit", resolve6);
     });
     const stream = ndJsonStream(createWritableAcpStream(stdin), readableWebStream(stdout));
     this.#connection = createAcpClient(this).connect(stream);
@@ -25123,7 +25123,7 @@ function decodeResponse(encoded) {
 }
 async function requestLocalBotService(socketPath, payload, signal) {
   signal.throwIfAborted();
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve6, reject) => {
     const socket = createConnection(socketPath);
     const chunks = [];
     let length = 0;
@@ -25172,7 +25172,7 @@ async function requestLocalBotService(socketPath, payload, signal) {
       finished = true;
       signal.removeEventListener("abort", abort);
       try {
-        resolve5(decodeResponse(Buffer.concat(chunks).toString("utf8")));
+        resolve6(decodeResponse(Buffer.concat(chunks).toString("utf8")));
       } catch (error61) {
         reject(error61);
       } finally {
@@ -25326,12 +25326,12 @@ var BotOutboundIpcServer = class {
         }
       });
     }
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const fail = (error61) => reject(error61);
       this.#server.once("error", fail);
       this.#server.listen(this.#socketPath, () => {
         this.#server.removeListener("error", fail);
-        resolve5();
+        resolve6();
       });
     });
     if (this.#usesFilesystemSocket) {
@@ -25344,10 +25344,10 @@ var BotOutboundIpcServer = class {
   };
   close = async () => {
     if (this.#server.listening) {
-      await new Promise((resolve5, reject) => {
+      await new Promise((resolve6, reject) => {
         this.#server.close((error61) => {
           if (error61 === void 0) {
-            resolve5();
+            resolve6();
             return;
           }
           reject(error61);
@@ -27270,7 +27270,9 @@ var IDENTIFIER_PATTERN6 = /^[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 = {}) {
@@ -27307,7 +27309,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"}`);
     }
   }
@@ -27347,10 +27349,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_PATTERN6.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>");
@@ -27407,17 +27416,17 @@ function readRelayError(value) {
   }
   return new PairingClientError("pairing_failed", "The relay could not pair this machine");
 }
-function decodeClaimResponse(value) {
-  if (!isRecord11(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+function decodePairingResponse(value, credentialField, expectedKeys) {
+  if (!isRecord11(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_PATTERN6.test(channelId) || typeof daemonToken2 !== "string" || !TOKEN_PATTERN2.test(daemonToken2) || typeof runtimeId !== "string" || !IDENTIFIER_PATTERN6.test(runtimeId)) {
+  if (typeof channelId !== "string" || !IDENTIFIER_PATTERN6.test(channelId) || typeof runtimeCredential !== "string" || !TOKEN_PATTERN2.test(runtimeCredential) || typeof runtimeId !== "string" || !IDENTIFIER_PATTERN6.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) => ({
@@ -27427,7 +27436,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 fetch3(endpoint, {
@@ -27450,10 +27459,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 mkdir4(connectionsDirectory, { mode: 448, recursive: true });
   const connectionPath = join14(connectionsDirectory, `${channelId}.json`);
   const temporaryPath = join14(connectionsDirectory, `.${channelId}.${randomUUID3()}.tmp`);
@@ -27463,8 +27472,8 @@ async function persistConnection(channelId, relayOrigin, daemonToken2, defaultWo
       {
         defaultWorkspace,
         channelId,
-        daemonToken: daemonToken2,
-        relayOrigin: relayOrigin.toString()
+        relayOrigin: relayOrigin.toString(),
+        runtimeCredential
       },
       null,
       2
@@ -27476,25 +27485,25 @@ async function persistConnection(channelId, relayOrigin, daemonToken2, defaultWo
   return connectionPath;
 }
 function decodeSavedConnection(value, expectedChannelId) {
-  if (!isRecord11(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+  if (!isRecord11(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_PATTERN6.test(channelId) || typeof daemonToken2 !== "string" || !TOKEN_PATTERN2.test(daemonToken2) || typeof relayOrigin !== "string") {
+  if (typeof defaultWorkspace !== "string" || typeof channelId !== "string" || channelId !== expectedChannelId || !IDENTIFIER_PATTERN6.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 {
@@ -27516,8 +27525,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) {
@@ -27525,15 +27534,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(
@@ -27549,12 +27555,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);
@@ -27563,30 +27568,50 @@ 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 pairMobiusRuntime(options, signal, environment = process.env) {
+  return await pairRuntime(
+    {
+      code: parsePairingCode(options.pairingCode),
+      pairingId: validatePairingId(options.pairingId),
+      relayOrigin: parseRelayOrigin(options.relayOrigin),
+      workspace: options.defaultWorkspace
+    },
+    signal,
+    environment
+  );
+}
+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/run-daemon.ts
@@ -27605,14 +27630,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();
@@ -27621,7 +27651,7 @@ async function publishAgentCatalog(config2, signal) {
   let response;
   const catalog = config2.catalog.read();
   try {
-    response = await fetch4(catalogEndpoint(config2.relayUrl), {
+    response = await fetch4(catalogEndpoint(config2), {
       body: JSON.stringify({
         agents: catalog.agents.map((agent) => ({
           agentPath: agent.agentIdentity.requestedPath,
@@ -28991,10 +29021,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;
 }
@@ -29152,9 +29189,17 @@ var RelayConnectionError = class extends Error {
 };
 function connectRelay(url2, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve5, reject) => {
-    const socket = new WebSocket(url2, {
-      dispatcher: environmentProxyDispatcher
+  return new Promise((resolve6, reject) => {
+    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);
@@ -29193,7 +29238,7 @@ function connectRelay(url2, signal) {
       }
       finished = true;
       cleanup();
-      resolve5(socket);
+      resolve6(socket);
     };
     function onTimeout() {
       fail(new RelayConnectionError("relay_connection_timeout", "Relay connection timed out"));
@@ -29775,10 +29820,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;
 }
@@ -30391,12 +30443,12 @@ function waitForRelayRetry(signal, timer) {
   if (signal.aborted) {
     return Promise.resolve();
   }
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const retry = timer.schedule(finish, RELAY_RECONNECT_DELAY_MILLISECONDS);
     function finish() {
       retry.cancel();
       signal.removeEventListener("abort", finish);
-      resolve5();
+      resolve6();
     }
     signal.addEventListener("abort", finish, { once: true });
   });
@@ -30433,7 +30485,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
   const nativeRequests = /* @__PURE__ */ new Map();
   installationObserver.connect(socket);
   try {
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       let finished = false;
       const cleanup = () => {
         connectionRefresh.close();
@@ -30452,7 +30504,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
         }
         finished = true;
         cleanup();
-        resolve5();
+        resolve6();
       };
       const rejectConnection = () => {
         if (finished) {
@@ -30632,7 +30684,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
               try {
                 operationSignal.throwIfAborted();
                 if (previous.length > 0) {
-                  await new Promise((resolve6, reject2) => {
+                  await new Promise((resolve7, reject2) => {
                     const cancel = () => reject2(operationSignal.reason);
                     operationSignal.addEventListener("abort", cancel, {
                       once: true
@@ -30640,7 +30692,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
                     void Promise.all(previous.map((request) => request.completion)).then(
                       () => {
                         operationSignal.removeEventListener("abort", cancel);
-                        resolve6();
+                        resolve7();
                       },
                       (error61) => {
                         operationSignal.removeEventListener("abort", cancel);
@@ -30714,13 +30766,13 @@ async function runRelayConnection(config2, directories, audit, sessions, install
               try {
                 operationSignal.throwIfAborted();
                 if (previous.length > 0) {
-                  await new Promise((resolve6, reject2) => {
+                  await new Promise((resolve7, reject2) => {
                     const cancel = () => reject2(operationSignal.reason);
                     operationSignal.addEventListener("abort", cancel, { once: true });
                     void Promise.all(previous.map((request) => request.completion)).then(
                       () => {
                         operationSignal.removeEventListener("abort", cancel);
-                        resolve6();
+                        resolve7();
                       },
                       (error61) => {
                         operationSignal.removeEventListener("abort", cancel);
@@ -31102,6 +31154,147 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
     }
   }
 }
+
+// src/runtime.ts
+import { mkdir as mkdir5, realpath as realpath8, stat as stat8 } from "node:fs/promises";
+import { dirname as dirname8, join as join17, resolve as resolve5 } from "node:path";
+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 IDENTIFIER_PATTERN8 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+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);
+}
+function requiredEnvironmentValue(environment, name) {
+  const value = environment[name]?.trim();
+  if (value === void 0 || value.length === 0) {
+    throw new MobiusRuntimeConfigurationError(`${name} is required`);
+  }
+  return value;
+}
+function relayUrlFromConnection(connection) {
+  let relayUrl;
+  try {
+    relayUrl = new URL(connection.relayUrl);
+  } catch (error61) {
+    throw new MobiusRuntimeConfigurationError("The Runtime relay URL is invalid", { cause: error61 });
+  }
+  relayUrl.searchParams.set("token", connection.runtimeCredential);
+  validateRuntimeRelay(relayUrl);
+  return relayUrl;
+}
+function loadMobiusRuntimeConnection(environment = process.env) {
+  const channelId = requiredEnvironmentValue(environment, "MOBIUS_CHANNEL_ID");
+  if (!IDENTIFIER_PATTERN8.test(channelId)) {
+    throw new MobiusRuntimeConfigurationError("MOBIUS_CHANNEL_ID is invalid");
+  }
+  return Object.freeze({
+    auditDatabasePath: environment["MOBIUS_AUDIT_DATABASE"]?.trim() || join17(readStateDirectory(environment), "audit", `${channelId}.sqlite`),
+    channelId,
+    defaultWorkspace: loadDefaultWorkspace(environment),
+    relayUrl: requiredEnvironmentValue(environment, "MOBIUS_RELAY_URL"),
+    runtimeCredential: requiredEnvironmentValue(environment, "MOBIUS_RELAY_TOKEN")
+  });
+}
+async function resolveWorkspace(path2) {
+  const requested = resolve5(path2);
+  try {
+    await mkdir5(requested, { recursive: true, mode: 448 });
+    const resolved = await realpath8(requested);
+    const metadata = await stat8(resolved);
+    if (!metadata.isDirectory()) {
+      throw new MobiusRuntimeConfigurationError("The Runtime workspace is not a directory");
+    }
+    return resolved;
+  } catch (error61) {
+    if (error61 instanceof MobiusRuntimeConfigurationError) {
+      throw error61;
+    }
+    throw new MobiusRuntimeConfigurationError("The Runtime workspace cannot be resolved", { cause: error61 });
+  }
+}
+async function createMobiusRuntimeEngine(connection, signal, environment = process.env) {
+  signal.throwIfAborted();
+  const relayUrl = relayUrlFromConnection(connection);
+  const defaultWorkspace = await resolveWorkspace(connection.defaultWorkspace);
+  const auditDatabasePath = resolve5(connection.auditDatabasePath);
+  await mkdir5(dirname8(auditDatabasePath), { recursive: true, mode: 448 });
+  const inventory = await discoverLocalAgentInventory({
+    defaultWorkspace,
+    environment,
+    signal
+  });
+  if (inventory.available.length + inventory.installable.length === 0) {
+    throw new MobiusRuntimeConfigurationError("No supported Agent is available for the local Runtime");
+  }
+  return new MobiusRuntimeEngine(
+    createDaemonConfig(
+      {
+        auditDatabasePath,
+        channelId: connection.channelId,
+        defaultWorkspace,
+        relayUrl
+      },
+      inventory.readyAgents(),
+      inventory.installable
+    )
+  );
+}
+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();
+    }
+  };
+};
 export {
   AcpExecutionError,
   AuditStore,
@@ -31109,12 +31302,18 @@ export {
   BotMessageCommandError,
   BotOutboundIpcServer,
   LocalAuthorizationError,
+  MobiusRuntimeConfigurationError,
+  MobiusRuntimeEngine,
   PairingClientError,
   createAcpClient,
+  createMobiusRuntimeEngine,
   executeBotMessageCommand,
   loadDaemonConfig,
+  loadMobiusRuntimeConnection,
   pairLocalMachine,
+  pairMobiusRuntime,
   resumeLocalMachine,
+  resumeMobiusRuntime,
   runAcpPrompt,
   runDaemon
 };