@moxt-ai/mobius 0.0.12 → 0.0.14

package/dist/index.js

@@ -25,646 +25,6 @@ var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
 import { join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// src/agent-catalog/local-agent.ts
-import { realpathSync, statSync } from "node:fs";
-
-// src/process/executable.ts
-import { execFile, spawn } from "node:child_process";
-import { constants } from "node:fs";
-import { access, realpath, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
-var DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024;
-var PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS = 1e3;
-var PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS = 5e3;
-var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
-var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
-var PROCESS_EXIT_CHECK_ATTEMPTS = 8;
-var GRACEFUL_STOP_SIGNAL = 15;
-var FORCED_STOP_SIGNAL = 9;
-var ExecutableIdentity = class {
-  changedAtMilliseconds;
-  device;
-  inode;
-  realPath;
-  requestedPath;
-  size;
-  constructor(requestedPath, realPath_, device, inode, size, changedAtMilliseconds) {
-    this.changedAtMilliseconds = changedAtMilliseconds;
-    this.device = device;
-    this.inode = inode;
-    this.realPath = realPath_;
-    this.requestedPath = requestedPath;
-    this.size = size;
-  }
-  matches = (candidate) => this.requestedPath === candidate.requestedPath && this.realPath === candidate.realPath && this.device === candidate.device && this.inode === candidate.inode && this.size === candidate.size && this.changedAtMilliseconds === candidate.changedAtMilliseconds;
-};
-var ResolvedExecutable = class {
-  identity;
-  path;
-  constructor(identity2) {
-    this.identity = identity2;
-    this.path = identity2.realPath;
-  }
-};
-var ProcessExecutionError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "ProcessExecutionError";
-  }
-};
-var ProcessResult = class {
-  stderr;
-  stdout;
-  constructor(stdout, stderr) {
-    this.stderr = stderr;
-    this.stdout = stdout;
-  }
-};
-function executableExtensions(executableName, environment, platform) {
-  if (platform !== "win32") {
-    return [""];
-  }
-  if (/\.[a-zA-Z0-9]+$/.test(executableName)) {
-    return [""];
-  }
-  const configured = environment["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
-  const extensions = configured.split(";").map((extension) => extension.trim()).filter((extension) => extension.length > 0).map(
-    (extension) => extension.startsWith(".") ? extension : `.${extension}`
-  );
-  return extensions.length > 0 ? extensions : [".EXE"];
-}
-async function resolveExecutablePath(requestedPath, platform = process.platform) {
-  const absoluteRequestedPath = resolve(requestedPath);
-  try {
-    const resolvedPath = await realpath(absoluteRequestedPath);
-    const metadata = await stat(resolvedPath);
-    if (!metadata.isFile()) {
-      return null;
-    }
-    if (platform !== "win32") {
-      await access(resolvedPath, constants.X_OK);
-    }
-    return new ResolvedExecutable(
-      new ExecutableIdentity(
-        absoluteRequestedPath,
-        resolvedPath,
-        metadata.dev,
-        metadata.ino,
-        metadata.size,
-        metadata.ctimeMs
-      )
-    );
-  } catch {
-    return null;
-  }
-}
-async function findExecutableOnPath(executableName, environment, platform = process.platform) {
-  const encodedPath = environment["PATH"] ?? "";
-  const separator = platform === "win32" ? ";" : ":";
-  const extensions = executableExtensions(
-    executableName,
-    environment,
-    platform
-  );
-  for (const entry of encodedPath.split(separator)) {
-    if (entry.length === 0) {
-      continue;
-    }
-    for (const extension of extensions) {
-      const requestedPath = resolve(
-        join(entry, `${executableName}${extension}`)
-      );
-      const executable = await resolveExecutablePath(requestedPath, platform);
-      if (executable !== null) {
-        return executable;
-      }
-    }
-  }
-  return null;
-}
-async function revalidateExecutable(identity2, platform = process.platform) {
-  const current = await resolveExecutablePath(identity2.requestedPath, platform);
-  return current !== null && identity2.matches(current.identity);
-}
-function appendBounded(chunks, chunk, currentBytes, limitBytes) {
-  const nextBytes = currentBytes + chunk.byteLength;
-  if (nextBytes > limitBytes) {
-    throw new ProcessExecutionError(
-      "process_output_limit",
-      "The executable produced too much output"
-    );
-  }
-  chunks.push(chunk);
-  return nextBytes;
-}
-function parseProcessTable(output2) {
-  const entries = [];
-  for (const line of output2.split("\n")) {
-    const groups = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<pgid>\d+)\s*$/.exec(
-      line
-    )?.groups;
-    if (groups === void 0) {
-      continue;
-    }
-    const processId = Number(groups["pid"]);
-    const parentProcessId = Number(groups["ppid"]);
-    const processGroupId = Number(groups["pgid"]);
-    if (!Number.isSafeInteger(processId) || processId <= 0 || !Number.isSafeInteger(parentProcessId) || parentProcessId < 0 || !Number.isSafeInteger(processGroupId) || processGroupId <= 0) {
-      continue;
-    }
-    entries.push({ parentProcessId, processGroupId, processId });
-  }
-  return entries;
-}
-function readProcessTable() {
-  if (process.platform === "win32") {
-    return Promise.resolve([]);
-  }
-  const executable = process.platform === "darwin" ? "/bin/ps" : "/usr/bin/ps";
-  return new Promise((resolveTable) => {
-    execFile(
-      executable,
-      ["-axo", "pid=,ppid=,pgid="],
-      {
-        encoding: "utf8",
-        maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT_BYTES,
-        signal: AbortSignal.timeout(PROCESS_TABLE_TIMEOUT_MILLISECONDS),
-        timeout: PROCESS_TABLE_TIMEOUT_MILLISECONDS
-      },
-      (error61, stdout) => {
-        resolveTable(error61 === null ? parseProcessTable(stdout) : []);
-      }
-    );
-  });
-}
-function selectProcessTree(entries, rootProcessId) {
-  const processIds = /* @__PURE__ */ new Set([rootProcessId]);
-  let previousSize = 0;
-  while (previousSize !== processIds.size) {
-    previousSize = processIds.size;
-    for (const entry of entries) {
-      if (processIds.has(entry.parentProcessId)) {
-        processIds.add(entry.processId);
-      }
-    }
-  }
-  return entries.filter((entry) => processIds.has(entry.processId)).map((entry) => ({
-    processGroupId: entry.processGroupId,
-    processId: entry.processId
-  }));
-}
-function mergeProcessTrees(captured, current) {
-  const processes = /* @__PURE__ */ new Map();
-  for (const identity2 of captured) {
-    processes.set(identity2.processId, identity2);
-  }
-  for (const identity2 of current) {
-    processes.set(identity2.processId, identity2);
-  }
-  return [...processes.values()];
-}
-async function captureProcessTree(child) {
-  if (process.platform === "win32" || child.pid === void 0) {
-    return [];
-  }
-  return selectProcessTree(await readProcessTable(), child.pid);
-}
-function signalDetachedProcessGroups(processes, rootProcessId, signal) {
-  const processIds = new Set(processes.map((identity2) => identity2.processId));
-  const signalledGroups = /* @__PURE__ */ new Set();
-  for (const identity2 of processes) {
-    if (identity2.processGroupId === rootProcessId || !processIds.has(identity2.processGroupId) || signalledGroups.has(identity2.processGroupId)) {
-      continue;
-    }
-    try {
-      process.kill(-identity2.processGroupId, signal);
-      signalledGroups.add(identity2.processGroupId);
-    } catch {
-    }
-  }
-  for (const identity2 of processes) {
-    if (identity2.processId === rootProcessId || identity2.processGroupId === rootProcessId || signalledGroups.has(identity2.processGroupId)) {
-      continue;
-    }
-    try {
-      process.kill(identity2.processId, signal);
-    } catch {
-    }
-  }
-}
-function processExists(processId) {
-  try {
-    process.kill(processId, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function waitForCapturedProcessesExit(processes, rootProcessId) {
-  const processIds = processes.map((identity2) => identity2.processId).filter((processId) => processId !== rootProcessId);
-  for (let attempt = 0; attempt < PROCESS_EXIT_CHECK_ATTEMPTS; attempt += 1) {
-    if (processIds.every((processId) => !processExists(processId))) {
-      return true;
-    }
-    await readProcessTable();
-  }
-  return processIds.every((processId) => !processExists(processId));
-}
-function terminateProcess(child) {
-  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
-    return;
-  }
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-child.pid, "SIGTERM");
-      return;
-    } catch {
-    }
-  }
-  child.kill("SIGTERM");
-}
-function forceTerminateProcess(child) {
-  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
-    return;
-  }
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-child.pid, "SIGKILL");
-      return;
-    } catch {
-    }
-  }
-  child.kill("SIGKILL");
-}
-async function stopProcessTree(child, capturedProcesses = []) {
-  const childProcessId = child.pid;
-  if (childProcessId === void 0) {
-    return;
-  }
-  const childExited = child.exitCode !== null || child.signalCode !== null;
-  if (childExited && capturedProcesses.length === 0) {
-    return;
-  }
-  const processes = mergeProcessTrees(
-    capturedProcesses,
-    childExited ? [] : await captureProcessTree(child)
-  );
-  signalDetachedProcessGroups(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
-  terminateProcess(child);
-  const [exitedAfterTermination, descendantsExitedAfterTermination] = await Promise.all([
-    waitForProcessExit(child, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
-    waitForCapturedProcessesExit(processes, childProcessId)
-  ]);
-  if (exitedAfterTermination && descendantsExitedAfterTermination) {
-    return;
-  }
-  signalDetachedProcessGroups(processes, childProcessId, FORCED_STOP_SIGNAL);
-  forceTerminateProcess(child);
-  const [exitedAfterForce, descendantsExitedAfterForce] = await Promise.all([
-    waitForProcessExit(child, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
-    waitForCapturedProcessesExit(processes, childProcessId)
-  ]);
-  if (!exitedAfterForce || !descendantsExitedAfterForce) {
-    throw new ProcessExecutionError(
-      "process_termination_timeout",
-      "The executable process could not be stopped"
-    );
-  }
-}
-function waitForProcessExit(child, timeoutMilliseconds) {
-  if (child.exitCode !== null || child.signalCode !== null) {
-    return Promise.resolve(true);
-  }
-  return new Promise((resolveExit) => {
-    let settled = false;
-    const finish = (exited) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      child.removeListener("exit", handleExit);
-      resolveExit(exited);
-    };
-    const handleExit = () => finish(true);
-    const timeout = setTimeout(() => finish(false), timeoutMilliseconds);
-    child.once("exit", handleExit);
-    if (child.exitCode !== null || child.signalCode !== null) {
-      finish(true);
-    }
-  });
-}
-async function runBoundedProcess(options) {
-  options.signal.throwIfAborted();
-  const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
-  const child = spawn(options.command, [...options.arguments], {
-    cwd: options.cwd,
-    detached: process.platform !== "win32",
-    env: { ...options.environment },
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  const stdout = [];
-  const stderr = [];
-  let stdoutBytes = 0;
-  let stderrBytes = 0;
-  let interruptionFailure = null;
-  let interruptionCleanupFailure = null;
-  let stopping = false;
-  const interrupted = Promise.withResolvers();
-  const interrupt = (failure) => {
-    if (stopping) {
-      return;
-    }
-    stopping = true;
-    interruptionFailure = failure;
-    const stop = async () => {
-      try {
-        await stopProcessTree(child);
-      } catch (error61) {
-        interruptionCleanupFailure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
-          "process_termination_failed",
-          "The executable process could not be stopped",
-          { cause: error61 }
-        );
-      } finally {
-        interrupted.resolve();
-      }
-    };
-    void stop();
-  };
-  const collectStdout = (chunk) => {
-    if (interruptionFailure !== null) {
-      return;
-    }
-    try {
-      stdoutBytes = appendBounded(stdout, chunk, stdoutBytes, outputLimitBytes);
-    } catch (error61) {
-      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
-        "process_output_limit",
-        "The executable produced too much output",
-        { cause: error61 }
-      );
-      interrupt(failure);
-    }
-  };
-  const collectStderr = (chunk) => {
-    if (interruptionFailure !== null) {
-      return;
-    }
-    try {
-      stderrBytes = appendBounded(stderr, chunk, stderrBytes, outputLimitBytes);
-    } catch (error61) {
-      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
-        "process_output_limit",
-        "The executable produced too much output",
-        { cause: error61 }
-      );
-      interrupt(failure);
-    }
-  };
-  child.stdout?.on("data", collectStdout);
-  child.stderr?.on("data", collectStderr);
-  const timeout = setTimeout(() => {
-    interrupt(
-      new ProcessExecutionError(
-        "process_timeout",
-        "The executable probe timed out"
-      )
-    );
-  }, options.timeoutMilliseconds);
-  const abort = () => interrupt(
-    new ProcessExecutionError(
-      "process_cancelled",
-      "The executable probe was cancelled",
-      { cause: options.signal.reason }
-    )
-  );
-  options.signal.addEventListener("abort", abort, { once: true });
-  if (options.signal.aborted) {
-    abort();
-  }
-  try {
-    const exit = new Promise((resolveExit, rejectExit) => {
-      child.once("error", rejectExit);
-      child.once("exit", (code) => resolveExit(code ?? 1));
-    });
-    const exitCode = await Promise.race([
-      exit,
-      interrupted.promise.then(() => -1)
-    ]);
-    if (interruptionCleanupFailure !== null) {
-      throw interruptionCleanupFailure;
-    }
-    if (interruptionFailure !== null) {
-      throw interruptionFailure;
-    }
-    if (exitCode !== 0) {
-      throw new ProcessExecutionError(
-        "process_exit_failed",
-        "The executable probe failed"
-      );
-    }
-    return new ProcessResult(
-      Buffer.concat(stdout).toString("utf8"),
-      Buffer.concat(stderr).toString("utf8")
-    );
-  } catch (error61) {
-    if (error61 instanceof ProcessExecutionError) {
-      throw error61;
-    }
-    throw new ProcessExecutionError(
-      "process_spawn_failed",
-      "The executable could not be started",
-      { cause: error61 }
-    );
-  } finally {
-    clearTimeout(timeout);
-    options.signal.removeEventListener("abort", abort);
-    child.stdout?.removeListener("data", collectStdout);
-    child.stderr?.removeListener("data", collectStderr);
-    if (stopping) {
-      await interrupted.promise;
-    } else {
-      await stopProcessTree(child);
-    }
-  }
-}
-
-// src/agent-catalog/local-agent.ts
-function readTrustedIdentity(path2) {
-  const resolvedPath = realpathSync(path2);
-  const metadata = statSync(resolvedPath);
-  return new ExecutableIdentity(
-    resolvedPath,
-    resolvedPath,
-    metadata.dev,
-    metadata.ino,
-    metadata.size,
-    metadata.ctimeMs
-  );
-}
-var LocalAgentDefinition = class {
-  adapterIdentity;
-  adapterPath;
-  adapterVersion;
-  agentIdentity;
-  agentVersion;
-  arguments;
-  command;
-  environment;
-  id;
-  label;
-  promptTimeoutMilliseconds;
-  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity, promptTimeoutMilliseconds = 30 * 60 * 1e3) {
-    if (!Number.isSafeInteger(promptTimeoutMilliseconds) || promptTimeoutMilliseconds < 1) {
-      throw new Error("The local Agent prompt deadline is invalid");
-    }
-    this.adapterIdentity = adapterIdentity;
-    this.adapterPath = adapterIdentity.realPath;
-    this.adapterVersion = adapterVersion;
-    this.agentIdentity = agentIdentity;
-    this.agentVersion = agentVersion;
-    this.id = id;
-    this.label = label;
-    this.promptTimeoutMilliseconds = promptTimeoutMilliseconds;
-    this.command = adapterIdentity.realPath;
-    this.arguments = Object.freeze([...arguments_]);
-    this.environment = Object.freeze({ ...environment });
-  }
-};
-var InstallableAgentDefinition = class {
-  id;
-  label;
-  requiresLocalApproval;
-  constructor(id, label, requiresLocalApproval = true) {
-    this.id = id;
-    this.label = label;
-    this.requiresLocalApproval = requiresLocalApproval;
-  }
-};
-var LocalAgentCatalogSnapshot = class {
-  agents;
-  installableAgents;
-  constructor(agents, installableAgents) {
-    this.agents = Object.freeze([...agents]);
-    this.installableAgents = Object.freeze([...installableAgents]);
-  }
-};
-var LocalAgentCatalogError = class extends Error {
-  code = "agent_not_ready";
-  constructor() {
-    super("The requested local Agent is not ready");
-    this.name = "LocalAgentCatalogError";
-  }
-};
-var LocalAgentCatalog = class {
-  #snapshot;
-  constructor(agents, installableAgents) {
-    this.#snapshot = this.validate(agents, installableAgents);
-  }
-  find = (agentId) => {
-    for (const agent of this.#snapshot.agents) {
-      if (agent.id === agentId) {
-        return agent;
-      }
-    }
-    throw new LocalAgentCatalogError();
-  };
-  read = () => this.#snapshot;
-  transition = (agents, installableAgents) => {
-    const next = this.validate(agents, installableAgents);
-    this.#snapshot = next;
-    return next;
-  };
-  validate = (agents, installableAgents) => {
-    const identifiers = /* @__PURE__ */ new Set();
-    for (const agent of agents) {
-      if (identifiers.has(agent.id)) {
-        throw new Error("The local Agent catalog contains duplicate entries");
-      }
-      identifiers.add(agent.id);
-    }
-    for (const agent of installableAgents) {
-      if (identifiers.has(agent.id)) {
-        throw new Error("A local Agent cannot be ready and installable");
-      }
-      identifiers.add(agent.id);
-    }
-    return new LocalAgentCatalogSnapshot(agents, installableAgents);
-  };
-};
-
-// src/storage/state-directory.ts
-import { homedir } from "node:os";
-import { join as join2, resolve as resolve2 } from "node:path";
-function readStateDirectory(environment = process.env) {
-  const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
-  if (configured !== void 0 && configured.length > 0) {
-    return resolve2(configured);
-  }
-  return join2(homedir(), ".mobius");
-}
-
-// src/config.ts
-function loadDefaultWorkspace() {
-  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
-  return configuredWorkspace ?? join3(readStateDirectory(), "workspace");
-}
-function createDaemonConfig(connection, agents = [], installableAgents = []) {
-  return {
-    agents,
-    defaultWorkspace: connection.defaultWorkspace,
-    auditDatabasePath: connection.auditDatabasePath,
-    bindingId: "workspace",
-    catalog: new LocalAgentCatalog(agents, installableAgents),
-    channelId: connection.channelId,
-    installableAgents,
-    relayUrl: connection.relayUrl
-  };
-}
-function loadDaemonConfig() {
-  const relayUrl = new URL(
-    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-    process.env["MOBIUS_RELAY_URL"] ?? "ws://127.0.0.1:8787/mobius/api/channels/local/daemon"
-  );
-  relayUrl.searchParams.set(
-    "token",
-    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-    process.env["MOBIUS_RELAY_TOKEN"] ?? "local-development-token"
-  );
-  if (relayUrl.protocol !== "ws:" && relayUrl.protocol !== "wss:") {
-    throw new Error("MOBIUS_RELAY_URL must use ws or wss");
-  }
-  return createDaemonConfig(
-    {
-      defaultWorkspace: loadDefaultWorkspace(),
-      auditDatabasePath: (
-        // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-        process.env["MOBIUS_AUDIT_DATABASE"] ?? fileURLToPath(
-          new URL("../../../.mobius/daemon.sqlite", import.meta.url)
-        )
-      ),
-      // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-      channelId: process.env["MOBIUS_CHANNEL_ID"] ?? "local",
-      relayUrl
-    },
-    [],
-    []
-  );
-}
-
-// src/acp/session-manager.ts
-import { spawn as spawn2 } from "node:child_process";
-import {
-  methods as methods2,
-  ndJsonStream,
-  PROTOCOL_VERSION,
-  RequestError
-} from "@agentclientprotocol/sdk";
-
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -20393,6 +19753,29 @@ function encodeSessionFailedEvent(message) {
   return JSON.stringify(decodeSessionFailedEvent(JSON.stringify(message)));
 }
 
+// ../protocol/src/mobius-api.ts
+var MOBIUS_API_PREFIX = "/mobius/api";
+var API_PREFIX_PATTERN = /^\/[a-zA-Z0-9._~-]+(?:\/[a-zA-Z0-9._~-]+)*$/;
+var MobiusApiConfigurationError = class extends Error {
+  code = "invalid_api_prefix";
+  constructor() {
+    super("The Mobius API prefix must be an absolute path without parameters");
+    this.name = "MobiusApiConfigurationError";
+  }
+};
+function parseMobiusApiPrefix(value) {
+  if (typeof value !== "string" || !API_PREFIX_PATTERN.test(value)) {
+    throw new MobiusApiConfigurationError();
+  }
+  return value;
+}
+function mobiusApiPath(resourcePath, apiPrefix = MOBIUS_API_PREFIX) {
+  return `${parseMobiusApiPrefix(apiPrefix)}${resourcePath}`;
+}
+function mobiusApiUrl(origin, resourcePath, apiPrefix = MOBIUS_API_PREFIX) {
+  return new URL(mobiusApiPath(resourcePath, apiPrefix), origin);
+}
+
 // ../protocol/src/session-history.ts
 var SESSION_HISTORY_CHARACTER_LIMIT = 256e3;
 var SESSION_HISTORY_MESSAGE_LIMIT = 1e3;
@@ -21084,29 +20467,669 @@ var eventAcknowledgementSchema = external_exports.strictObject({
 function decode5(encoded, schema) {
   let value;
   try {
-    value = JSON.parse(encoded);
-  } catch (cause) {
-    throw new ProtocolMessageError("Message is not valid JSON", { cause });
+    value = JSON.parse(encoded);
+  } catch (cause) {
+    throw new ProtocolMessageError("Message is not valid JSON", { cause });
+  }
+  const decoded = schema.safeParse(value);
+  if (!decoded.success) {
+    throw new ProtocolMessageError("Message does not match its schema", {
+      cause: decoded.error
+    });
+  }
+  return decoded.data;
+}
+var encode4 = (message, schema) => {
+  const decoded = schema.safeParse(message);
+  if (!decoded.success) {
+    throw new ProtocolMessageError("Message does not match its schema", {
+      cause: decoded.error
+    });
+  }
+  return JSON.stringify(decoded.data);
+};
+var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
+var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
+
+// src/agent-catalog/local-agent.ts
+import { realpathSync, statSync } from "node:fs";
+
+// src/process/executable.ts
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, realpath, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024;
+var PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS = 1e3;
+var PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS = 5e3;
+var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
+var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
+var PROCESS_EXIT_CHECK_ATTEMPTS = 8;
+var GRACEFUL_STOP_SIGNAL = 15;
+var FORCED_STOP_SIGNAL = 9;
+var ExecutableIdentity = class {
+  changedAtMilliseconds;
+  device;
+  inode;
+  realPath;
+  requestedPath;
+  size;
+  constructor(requestedPath, realPath_, device, inode, size, changedAtMilliseconds) {
+    this.changedAtMilliseconds = changedAtMilliseconds;
+    this.device = device;
+    this.inode = inode;
+    this.realPath = realPath_;
+    this.requestedPath = requestedPath;
+    this.size = size;
+  }
+  matches = (candidate) => this.requestedPath === candidate.requestedPath && this.realPath === candidate.realPath && this.device === candidate.device && this.inode === candidate.inode && this.size === candidate.size && this.changedAtMilliseconds === candidate.changedAtMilliseconds;
+};
+var ResolvedExecutable = class {
+  identity;
+  path;
+  constructor(identity2) {
+    this.identity = identity2;
+    this.path = identity2.realPath;
+  }
+};
+var ProcessExecutionError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "ProcessExecutionError";
+  }
+};
+var ProcessResult = class {
+  stderr;
+  stdout;
+  constructor(stdout, stderr) {
+    this.stderr = stderr;
+    this.stdout = stdout;
+  }
+};
+function executableExtensions(executableName, environment, platform) {
+  if (platform !== "win32") {
+    return [""];
+  }
+  if (/\.[a-zA-Z0-9]+$/.test(executableName)) {
+    return [""];
+  }
+  const configured = environment["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
+  const extensions = configured.split(";").map((extension) => extension.trim()).filter((extension) => extension.length > 0).map(
+    (extension) => extension.startsWith(".") ? extension : `.${extension}`
+  );
+  return extensions.length > 0 ? extensions : [".EXE"];
+}
+async function resolveExecutablePath(requestedPath, platform = process.platform) {
+  const absoluteRequestedPath = resolve(requestedPath);
+  try {
+    const resolvedPath = await realpath(absoluteRequestedPath);
+    const metadata = await stat(resolvedPath);
+    if (!metadata.isFile()) {
+      return null;
+    }
+    if (platform !== "win32") {
+      await access(resolvedPath, constants.X_OK);
+    }
+    return new ResolvedExecutable(
+      new ExecutableIdentity(
+        absoluteRequestedPath,
+        resolvedPath,
+        metadata.dev,
+        metadata.ino,
+        metadata.size,
+        metadata.ctimeMs
+      )
+    );
+  } catch {
+    return null;
+  }
+}
+async function findExecutableOnPath(executableName, environment, platform = process.platform) {
+  const encodedPath = environment["PATH"] ?? "";
+  const separator = platform === "win32" ? ";" : ":";
+  const extensions = executableExtensions(
+    executableName,
+    environment,
+    platform
+  );
+  for (const entry of encodedPath.split(separator)) {
+    if (entry.length === 0) {
+      continue;
+    }
+    for (const extension of extensions) {
+      const requestedPath = resolve(
+        join(entry, `${executableName}${extension}`)
+      );
+      const executable = await resolveExecutablePath(requestedPath, platform);
+      if (executable !== null) {
+        return executable;
+      }
+    }
+  }
+  return null;
+}
+async function revalidateExecutable(identity2, platform = process.platform) {
+  const current = await resolveExecutablePath(identity2.requestedPath, platform);
+  return current !== null && identity2.matches(current.identity);
+}
+function appendBounded(chunks, chunk, currentBytes, limitBytes) {
+  const nextBytes = currentBytes + chunk.byteLength;
+  if (nextBytes > limitBytes) {
+    throw new ProcessExecutionError(
+      "process_output_limit",
+      "The executable produced too much output"
+    );
+  }
+  chunks.push(chunk);
+  return nextBytes;
+}
+function parseProcessTable(output2) {
+  const entries = [];
+  for (const line of output2.split("\n")) {
+    const groups = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<pgid>\d+)\s*$/.exec(
+      line
+    )?.groups;
+    if (groups === void 0) {
+      continue;
+    }
+    const processId = Number(groups["pid"]);
+    const parentProcessId = Number(groups["ppid"]);
+    const processGroupId = Number(groups["pgid"]);
+    if (!Number.isSafeInteger(processId) || processId <= 0 || !Number.isSafeInteger(parentProcessId) || parentProcessId < 0 || !Number.isSafeInteger(processGroupId) || processGroupId <= 0) {
+      continue;
+    }
+    entries.push({ parentProcessId, processGroupId, processId });
+  }
+  return entries;
+}
+function readProcessTable() {
+  if (process.platform === "win32") {
+    return Promise.resolve([]);
+  }
+  const executable = process.platform === "darwin" ? "/bin/ps" : "/usr/bin/ps";
+  return new Promise((resolveTable) => {
+    execFile(
+      executable,
+      ["-axo", "pid=,ppid=,pgid="],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT_BYTES,
+        signal: AbortSignal.timeout(PROCESS_TABLE_TIMEOUT_MILLISECONDS),
+        timeout: PROCESS_TABLE_TIMEOUT_MILLISECONDS
+      },
+      (error61, stdout) => {
+        resolveTable(error61 === null ? parseProcessTable(stdout) : []);
+      }
+    );
+  });
+}
+function selectProcessTree(entries, rootProcessId) {
+  const processIds = /* @__PURE__ */ new Set([rootProcessId]);
+  let previousSize = 0;
+  while (previousSize !== processIds.size) {
+    previousSize = processIds.size;
+    for (const entry of entries) {
+      if (processIds.has(entry.parentProcessId)) {
+        processIds.add(entry.processId);
+      }
+    }
+  }
+  return entries.filter((entry) => processIds.has(entry.processId)).map((entry) => ({
+    processGroupId: entry.processGroupId,
+    processId: entry.processId
+  }));
+}
+function mergeProcessTrees(captured, current) {
+  const processes = /* @__PURE__ */ new Map();
+  for (const identity2 of captured) {
+    processes.set(identity2.processId, identity2);
+  }
+  for (const identity2 of current) {
+    processes.set(identity2.processId, identity2);
+  }
+  return [...processes.values()];
+}
+async function captureProcessTree(child) {
+  if (process.platform === "win32" || child.pid === void 0) {
+    return [];
+  }
+  return selectProcessTree(await readProcessTable(), child.pid);
+}
+function signalDetachedProcessGroups(processes, rootProcessId, signal) {
+  const processIds = new Set(processes.map((identity2) => identity2.processId));
+  const signalledGroups = /* @__PURE__ */ new Set();
+  for (const identity2 of processes) {
+    if (identity2.processGroupId === rootProcessId || !processIds.has(identity2.processGroupId) || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(-identity2.processGroupId, signal);
+      signalledGroups.add(identity2.processGroupId);
+    } catch {
+    }
+  }
+  for (const identity2 of processes) {
+    if (identity2.processId === rootProcessId || identity2.processGroupId === rootProcessId || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(identity2.processId, signal);
+    } catch {
+    }
+  }
+}
+function processExists(processId) {
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForCapturedProcessesExit(processes, rootProcessId) {
+  const processIds = processes.map((identity2) => identity2.processId).filter((processId) => processId !== rootProcessId);
+  for (let attempt = 0; attempt < PROCESS_EXIT_CHECK_ATTEMPTS; attempt += 1) {
+    if (processIds.every((processId) => !processExists(processId))) {
+      return true;
+    }
+    await readProcessTable();
+  }
+  return processIds.every((processId) => !processExists(processId));
+}
+function terminateProcess(child) {
+  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
+    return;
+  }
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+      return;
+    } catch {
+    }
+  }
+  child.kill("SIGTERM");
+}
+function forceTerminateProcess(child) {
+  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
+    return;
+  }
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, "SIGKILL");
+      return;
+    } catch {
+    }
+  }
+  child.kill("SIGKILL");
+}
+async function stopProcessTree(child, capturedProcesses = []) {
+  const childProcessId = child.pid;
+  if (childProcessId === void 0) {
+    return;
+  }
+  const childExited = child.exitCode !== null || child.signalCode !== null;
+  if (childExited && capturedProcesses.length === 0) {
+    return;
+  }
+  const processes = mergeProcessTrees(
+    capturedProcesses,
+    childExited ? [] : await captureProcessTree(child)
+  );
+  signalDetachedProcessGroups(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
+  terminateProcess(child);
+  const [exitedAfterTermination, descendantsExitedAfterTermination] = await Promise.all([
+    waitForProcessExit(child, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
+    waitForCapturedProcessesExit(processes, childProcessId)
+  ]);
+  if (exitedAfterTermination && descendantsExitedAfterTermination) {
+    return;
+  }
+  signalDetachedProcessGroups(processes, childProcessId, FORCED_STOP_SIGNAL);
+  forceTerminateProcess(child);
+  const [exitedAfterForce, descendantsExitedAfterForce] = await Promise.all([
+    waitForProcessExit(child, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
+    waitForCapturedProcessesExit(processes, childProcessId)
+  ]);
+  if (!exitedAfterForce || !descendantsExitedAfterForce) {
+    throw new ProcessExecutionError(
+      "process_termination_timeout",
+      "The executable process could not be stopped"
+    );
+  }
+}
+function waitForProcessExit(child, timeoutMilliseconds) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolveExit) => {
+    let settled = false;
+    const finish = (exited) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      child.removeListener("exit", handleExit);
+      resolveExit(exited);
+    };
+    const handleExit = () => finish(true);
+    const timeout = setTimeout(() => finish(false), timeoutMilliseconds);
+    child.once("exit", handleExit);
+    if (child.exitCode !== null || child.signalCode !== null) {
+      finish(true);
+    }
+  });
+}
+async function runBoundedProcess(options) {
+  options.signal.throwIfAborted();
+  const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
+  const child = spawn(options.command, [...options.arguments], {
+    cwd: options.cwd,
+    detached: process.platform !== "win32",
+    env: { ...options.environment },
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const stdout = [];
+  const stderr = [];
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+  let interruptionFailure = null;
+  let interruptionCleanupFailure = null;
+  let stopping = false;
+  const interrupted = Promise.withResolvers();
+  const interrupt = (failure) => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    interruptionFailure = failure;
+    const stop = async () => {
+      try {
+        await stopProcessTree(child);
+      } catch (error61) {
+        interruptionCleanupFailure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
+          "process_termination_failed",
+          "The executable process could not be stopped",
+          { cause: error61 }
+        );
+      } finally {
+        interrupted.resolve();
+      }
+    };
+    void stop();
+  };
+  const collectStdout = (chunk) => {
+    if (interruptionFailure !== null) {
+      return;
+    }
+    try {
+      stdoutBytes = appendBounded(stdout, chunk, stdoutBytes, outputLimitBytes);
+    } catch (error61) {
+      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
+        "process_output_limit",
+        "The executable produced too much output",
+        { cause: error61 }
+      );
+      interrupt(failure);
+    }
+  };
+  const collectStderr = (chunk) => {
+    if (interruptionFailure !== null) {
+      return;
+    }
+    try {
+      stderrBytes = appendBounded(stderr, chunk, stderrBytes, outputLimitBytes);
+    } catch (error61) {
+      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
+        "process_output_limit",
+        "The executable produced too much output",
+        { cause: error61 }
+      );
+      interrupt(failure);
+    }
+  };
+  child.stdout?.on("data", collectStdout);
+  child.stderr?.on("data", collectStderr);
+  const timeout = setTimeout(() => {
+    interrupt(
+      new ProcessExecutionError(
+        "process_timeout",
+        "The executable probe timed out"
+      )
+    );
+  }, options.timeoutMilliseconds);
+  const abort = () => interrupt(
+    new ProcessExecutionError(
+      "process_cancelled",
+      "The executable probe was cancelled",
+      { cause: options.signal.reason }
+    )
+  );
+  options.signal.addEventListener("abort", abort, { once: true });
+  if (options.signal.aborted) {
+    abort();
   }
-  const decoded = schema.safeParse(value);
-  if (!decoded.success) {
-    throw new ProtocolMessageError("Message does not match its schema", {
-      cause: decoded.error
+  try {
+    const exit = new Promise((resolveExit, rejectExit) => {
+      child.once("error", rejectExit);
+      child.once("exit", (code) => resolveExit(code ?? 1));
     });
+    const exitCode = await Promise.race([
+      exit,
+      interrupted.promise.then(() => -1)
+    ]);
+    if (interruptionCleanupFailure !== null) {
+      throw interruptionCleanupFailure;
+    }
+    if (interruptionFailure !== null) {
+      throw interruptionFailure;
+    }
+    if (exitCode !== 0) {
+      throw new ProcessExecutionError(
+        "process_exit_failed",
+        "The executable probe failed"
+      );
+    }
+    return new ProcessResult(
+      Buffer.concat(stdout).toString("utf8"),
+      Buffer.concat(stderr).toString("utf8")
+    );
+  } catch (error61) {
+    if (error61 instanceof ProcessExecutionError) {
+      throw error61;
+    }
+    throw new ProcessExecutionError(
+      "process_spawn_failed",
+      "The executable could not be started",
+      { cause: error61 }
+    );
+  } finally {
+    clearTimeout(timeout);
+    options.signal.removeEventListener("abort", abort);
+    child.stdout?.removeListener("data", collectStdout);
+    child.stderr?.removeListener("data", collectStderr);
+    if (stopping) {
+      await interrupted.promise;
+    } else {
+      await stopProcessTree(child);
+    }
   }
-  return decoded.data;
 }
-var encode4 = (message, schema) => {
-  const decoded = schema.safeParse(message);
-  if (!decoded.success) {
-    throw new ProtocolMessageError("Message does not match its schema", {
-      cause: decoded.error
-    });
+
+// src/agent-catalog/local-agent.ts
+function readTrustedIdentity(path2) {
+  const resolvedPath = realpathSync(path2);
+  const metadata = statSync(resolvedPath);
+  return new ExecutableIdentity(
+    resolvedPath,
+    resolvedPath,
+    metadata.dev,
+    metadata.ino,
+    metadata.size,
+    metadata.ctimeMs
+  );
+}
+var LocalAgentDefinition = class {
+  adapterIdentity;
+  adapterPath;
+  adapterVersion;
+  agentIdentity;
+  agentVersion;
+  arguments;
+  command;
+  environment;
+  id;
+  label;
+  promptTimeoutMilliseconds;
+  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity, promptTimeoutMilliseconds = 30 * 60 * 1e3) {
+    if (!Number.isSafeInteger(promptTimeoutMilliseconds) || promptTimeoutMilliseconds < 1) {
+      throw new Error("The local Agent prompt deadline is invalid");
+    }
+    this.adapterIdentity = adapterIdentity;
+    this.adapterPath = adapterIdentity.realPath;
+    this.adapterVersion = adapterVersion;
+    this.agentIdentity = agentIdentity;
+    this.agentVersion = agentVersion;
+    this.id = id;
+    this.label = label;
+    this.promptTimeoutMilliseconds = promptTimeoutMilliseconds;
+    this.command = adapterIdentity.realPath;
+    this.arguments = Object.freeze([...arguments_]);
+    this.environment = Object.freeze({ ...environment });
   }
-  return JSON.stringify(decoded.data);
 };
-var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
-var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
+var InstallableAgentDefinition = class {
+  id;
+  label;
+  requiresLocalApproval;
+  constructor(id, label, requiresLocalApproval = true) {
+    this.id = id;
+    this.label = label;
+    this.requiresLocalApproval = requiresLocalApproval;
+  }
+};
+var LocalAgentCatalogSnapshot = class {
+  agents;
+  installableAgents;
+  constructor(agents, installableAgents) {
+    this.agents = Object.freeze([...agents]);
+    this.installableAgents = Object.freeze([...installableAgents]);
+  }
+};
+var LocalAgentCatalogError = class extends Error {
+  code = "agent_not_ready";
+  constructor() {
+    super("The requested local Agent is not ready");
+    this.name = "LocalAgentCatalogError";
+  }
+};
+var LocalAgentCatalog = class {
+  #snapshot;
+  constructor(agents, installableAgents) {
+    this.#snapshot = this.validate(agents, installableAgents);
+  }
+  find = (agentId) => {
+    for (const agent of this.#snapshot.agents) {
+      if (agent.id === agentId) {
+        return agent;
+      }
+    }
+    throw new LocalAgentCatalogError();
+  };
+  read = () => this.#snapshot;
+  transition = (agents, installableAgents) => {
+    const next = this.validate(agents, installableAgents);
+    this.#snapshot = next;
+    return next;
+  };
+  validate = (agents, installableAgents) => {
+    const identifiers = /* @__PURE__ */ new Set();
+    for (const agent of agents) {
+      if (identifiers.has(agent.id)) {
+        throw new Error("The local Agent catalog contains duplicate entries");
+      }
+      identifiers.add(agent.id);
+    }
+    for (const agent of installableAgents) {
+      if (identifiers.has(agent.id)) {
+        throw new Error("A local Agent cannot be ready and installable");
+      }
+      identifiers.add(agent.id);
+    }
+    return new LocalAgentCatalogSnapshot(agents, installableAgents);
+  };
+};
+
+// src/storage/state-directory.ts
+import { homedir } from "node:os";
+import { join as join2, resolve as resolve2 } from "node:path";
+function readStateDirectory(environment = process.env) {
+  const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
+  if (configured !== void 0 && configured.length > 0) {
+    return resolve2(configured);
+  }
+  return join2(homedir(), ".mobius");
+}
+
+// src/config.ts
+function loadDefaultWorkspace() {
+  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
+  return configuredWorkspace ?? join3(readStateDirectory(), "workspace");
+}
+function createDaemonConfig(connection, agents = [], installableAgents = []) {
+  return {
+    agents,
+    defaultWorkspace: connection.defaultWorkspace,
+    auditDatabasePath: connection.auditDatabasePath,
+    bindingId: "workspace",
+    catalog: new LocalAgentCatalog(agents, installableAgents),
+    channelId: connection.channelId,
+    installableAgents,
+    relayUrl: connection.relayUrl
+  };
+}
+function loadDaemonConfig() {
+  const relayUrl = new URL(
+    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+    process.env["MOBIUS_RELAY_URL"] ?? `ws://127.0.0.1:8787${mobiusApiPath("/channels/local/daemon")}`
+  );
+  relayUrl.searchParams.set(
+    "token",
+    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+    process.env["MOBIUS_RELAY_TOKEN"] ?? "local-development-token"
+  );
+  if (relayUrl.protocol !== "ws:" && relayUrl.protocol !== "wss:") {
+    throw new Error("MOBIUS_RELAY_URL must use ws or wss");
+  }
+  return createDaemonConfig(
+    {
+      defaultWorkspace: loadDefaultWorkspace(),
+      auditDatabasePath: (
+        // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+        process.env["MOBIUS_AUDIT_DATABASE"] ?? fileURLToPath(
+          new URL("../../../.mobius/daemon.sqlite", import.meta.url)
+        )
+      ),
+      // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+      channelId: process.env["MOBIUS_CHANNEL_ID"] ?? "local",
+      relayUrl
+    },
+    [],
+    []
+  );
+}
+
+// src/acp/session-manager.ts
+import { spawn as spawn2 } from "node:child_process";
+import {
+  methods as methods2,
+  ndJsonStream,
+  PROTOCOL_VERSION,
+  RequestError
+} from "@agentclientprotocol/sdk";
 
 // src/acp/activity.ts
 var TRUNCATION_MARKER = "\n\u2026 output truncated by Mobius";
@@ -26370,7 +26393,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
     id: agent.id,
     label: agent.label
   }));
-  const endpoint = new URL("/mobius/api/pairings/claim", options.relayOrigin);
+  const endpoint = mobiusApiUrl(options.relayOrigin, "/pairings/claim");
   let response;
   try {
     response = await fetch2(endpoint, {
@@ -26506,9 +26529,9 @@ function assertInventoryUsable(inventory) {
 }
 function buildPairedDaemon(connection, connectionPath, inventory) {
   assertInventoryUsable(inventory);
-  const relayUrl = new URL(
-    `/mobius/api/channels/${encodeURIComponent(connection.channelId)}/daemon`,
-    connection.relayOrigin
+  const relayUrl = mobiusApiUrl(
+    connection.relayOrigin,
+    `/channels/${encodeURIComponent(connection.channelId)}/daemon`
   );
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.daemonToken);
@@ -29551,6 +29574,28 @@ function waitForRelayRetry(signal, timer) {
     signal.addEventListener("abort", finish, { once: true });
   });
 }
+async function publishAgentCatalogUntilAvailable(config2, signal, timer) {
+  try {
+    await publishAgentCatalog(config2, signal);
+    return;
+  } catch {
+    if (signal.aborted) {
+      return;
+    }
+    console.warn("Mobius daemon is waiting to publish its Agent catalog");
+  }
+  while (!signal.aborted) {
+    await waitForRelayRetry(signal, timer);
+    try {
+      await publishAgentCatalog(config2, signal);
+      return;
+    } catch {
+      if (signal.aborted) {
+        return;
+      }
+    }
+  }
+}
 async function runRelayConnection(config2, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, onConnected, signal, timer) {
   const relayUrl = new URL(config2.relayUrl);
   relayUrl.searchParams.set("liveness", "1");
@@ -30008,10 +30053,14 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
 `
     );
   };
+  const catalogPublication = publishAgentCatalogUntilAvailable(
+    config2,
+    signal,
+    timer
+  );
   try {
     while (!signal.aborted) {
       try {
-        await publishAgentCatalog(config2, signal);
         await runRelayConnection(
           config2,
           directories,
@@ -30039,15 +30088,19 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
     }
   } finally {
     try {
-      await installations.close();
+      await catalogPublication;
     } finally {
       try {
-        await sessions.close();
+        await installations.close();
       } finally {
         try {
-          sessionStore.close();
+          await sessions.close();
         } finally {
-          outbox.close();
+          try {
+            sessionStore.close();
+          } finally {
+            outbox.close();
+          }
         }
       }
     }