@moxt-ai/mobius 0.0.193 → 0.0.194

package/dist/index.js

@@ -32,7 +32,7 @@ var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
 })).onNotification("cursor/update_todos", discardExtensionParams, async () => Promise.resolve()).onNotification("cursor/task", discardExtensionParams, async () => Promise.resolve()).onNotification("cursor/generate_image", discardExtensionParams, async () => Promise.resolve());
 
 // src/config.ts
-import { join as join3, resolve as resolve3 } from "node:path";
+import { join as join5, resolve as resolve3 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -21822,15 +21822,266 @@ function normalizeAcpCapabilities(initialized) {
 }
 
 // src/process/executable.ts
-import { execFile, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
+import { constants as constants2 } from "node:fs";
+import { access as access2, realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { join as join3, resolve } from "node:path";
+
+// src/platform/linux.ts
 import { constants, readdirSync, readFileSync } from "node:fs";
 import { access, readdir, readFile, realpath, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
+
+// src/platform/posix.ts
+import { execFile } from "node:child_process";
+var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
+var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
+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 readProcessTableWithPs(executable) {
+  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
+      },
+      (error62, stdout) => {
+        resolveTable(error62 === null ? parseProcessTable(stdout) : []);
+      }
+    );
+  });
+}
+function processExists(processId) {
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/platform/linux.ts
+function appendLinuxProcessTableEntry(entries, processId, encoded) {
+  const closingParenthesis = encoded.lastIndexOf(")");
+  if (!encoded.startsWith(`${processId.toString()} (`) || closingParenthesis < 0) {
+    return;
+  }
+  const fields = encoded.slice(closingParenthesis + 1).trim().split(/\s+/);
+  const parentProcessId = Number(fields[1]);
+  const processGroupId = Number(fields[2]);
+  if (!Number.isSafeInteger(parentProcessId) || parentProcessId < 0 || !Number.isSafeInteger(processGroupId) || processGroupId <= 0) {
+    return;
+  }
+  entries.push({ parentProcessId, processGroupId, processId });
+}
+async function readLinuxProcessTable() {
+  const entries = [];
+  try {
+    const directories = await readdir("/proc", { withFileTypes: true });
+    for (const directory of directories) {
+      if (!directory.isDirectory() || !/^\d+$/.test(directory.name)) {
+        continue;
+      }
+      const processId = Number(directory.name);
+      if (!Number.isSafeInteger(processId) || processId <= 0) {
+        continue;
+      }
+      try {
+        appendLinuxProcessTableEntry(
+          entries,
+          processId,
+          await readFile(join("/proc", directory.name, "stat"), "utf8")
+        );
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return entries;
+}
+function readLinuxProcessTableSynchronously() {
+  const entries = [];
+  try {
+    const directories = readdirSync("/proc", { withFileTypes: true });
+    for (const directory of directories) {
+      if (!directory.isDirectory() || !/^\d+$/.test(directory.name)) {
+        continue;
+      }
+      const processId = Number(directory.name);
+      if (!Number.isSafeInteger(processId) || processId <= 0) {
+        continue;
+      }
+      try {
+        appendLinuxProcessTableEntry(
+          entries,
+          processId,
+          readFileSync(join("/proc", directory.name, "stat"), "utf8")
+        );
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return entries;
+}
+async function readLinuxProcessTableWithFallback() {
+  const procfsEntries = await readLinuxProcessTable();
+  if (procfsEntries.length > 0) {
+    return procfsEntries;
+  }
+  for (const candidate of ["/usr/bin/ps", "/bin/ps", "/run/current-system/sw/bin/ps"]) {
+    try {
+      const resolvedPath = await realpath(candidate);
+      if (!(await stat(resolvedPath)).isFile()) {
+        continue;
+      }
+      await access(resolvedPath, constants.X_OK);
+    } catch {
+      continue;
+    }
+    const entries = await readProcessTableWithPs(candidate);
+    if (entries.length > 0) {
+      return entries;
+    }
+  }
+  return [];
+}
+function processExists2(processId) {
+  try {
+    const encoded = readFileSync(join("/proc", processId.toString(), "stat"), "utf8");
+    const closingParenthesis = encoded.lastIndexOf(")");
+    if (closingParenthesis >= 0) {
+      const processState = encoded.slice(closingParenthesis + 1).trimStart().charAt(0);
+      if (processState === "Z" || processState === "X") {
+        return false;
+      }
+    }
+  } catch {
+  }
+  return processExists(processId);
+}
+var linuxPlatform = {
+  readProcessTable: readLinuxProcessTableWithFallback,
+  readProcessTableSynchronously: readLinuxProcessTableSynchronously,
+  processExists: processExists2,
+  workBuddyExecutablePaths: () => [],
+  openCodeArchives: {
+    arm64: {
+      asset: "opencode-linux-arm64.tar.gz",
+      sha256: "70baf769395ca4e7a68924026530c390eace194f3b7e4919d4efcb2aa2eed3c0",
+      format: "tar.gz"
+    },
+    x64: {
+      asset: "opencode-linux-x64.tar.gz",
+      sha256: "ea800b7ff56226b70952126c9fc1e2517ca4c4b5682fd9d3f9e87449697a1194",
+      format: "tar.gz"
+    }
+  },
+  grokDependencies: {
+    arm64: {
+      name: "@xai-official/grok-linux-arm64",
+      integrity: "sha512-Jlwz9XtZPNKz/V/ydifC8OVu3hIZz7pmoStt8c4KCqkSWjWiZ/PBIC0iJiq8rvByhx5Z0EdSyq8ZXVwtocceGA==",
+      tarballUrl: "https://registry.npmjs.org/@xai-official/grok-linux-arm64/-/grok-linux-arm64-1.0.21.tgz"
+    },
+    x64: {
+      name: "@xai-official/grok-linux-x64",
+      integrity: "sha512-AjDV5ifEz5LFG2Jt5IlhAeEkJati/wOvCchVbR4eIj2ogjvmXoXlzBrYRXuAJpXBy5q0se/Yuez5FxDU9Ju81w==",
+      tarballUrl: "https://registry.npmjs.org/@xai-official/grok-linux-x64/-/grok-linux-x64-1.0.21.tgz"
+    }
+  }
+};
+
+// src/platform/macos.ts
+import { isAbsolute, join as join2 } from "node:path";
+var WORKBUDDY_MACOS_EXECUTABLE_PATH = Object.freeze([
+  "WorkBuddy.app",
+  "Contents",
+  "Resources",
+  "app.asar.unpacked",
+  "cli",
+  "bin",
+  "codebuddy"
+]);
+var macosPlatform = {
+  readProcessTable: () => readProcessTableWithPs("/bin/ps"),
+  readProcessTableSynchronously: () => [],
+  processExists,
+  workBuddyExecutablePaths: (environment) => {
+    const paths = [join2("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
+    const homeDirectory = environment["HOME"];
+    if (homeDirectory !== void 0 && isAbsolute(homeDirectory)) {
+      paths.unshift(join2(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
+    }
+    return paths;
+  },
+  openCodeArchives: {
+    arm64: {
+      asset: "opencode-darwin-arm64.zip",
+      sha256: "fe764f7f360c584a83e18dd5f23fb1a6b2725f5ee8854b0252fe558f7798e946",
+      format: "zip"
+    },
+    x64: {
+      asset: "opencode-darwin-x64.zip",
+      sha256: "9858853e7bacdbbd22c2d70c377e009dc4b354dd04f5588705411e7afb89fd2d",
+      format: "zip"
+    }
+  },
+  grokDependencies: {
+    arm64: {
+      name: "@xai-official/grok-darwin-arm64",
+      integrity: "sha512-I4pKZGnR6Mv4MJOJsB9B/i2o0ODF4eZtp4jHN5feoTqKIeAUVg38OzBtE8aN/wZa7Xg+qhnf6Jd1tcAFvMoFtQ==",
+      tarballUrl: "https://registry.npmjs.org/@xai-official/grok-darwin-arm64/-/grok-darwin-arm64-1.0.21.tgz"
+    },
+    x64: {
+      name: "@xai-official/grok-darwin-x64",
+      integrity: "sha512-h0nFj3NZ9Kz8w6fQ6UDxxeSIhC1WjwwoRE92iNbG//tZy6YGkppR3s7oRVtt4Xl0CJANKUt0EusyIYnnAvKLzw==",
+      tarballUrl: "https://registry.npmjs.org/@xai-official/grok-darwin-x64/-/grok-darwin-x64-1.0.21.tgz"
+    }
+  }
+};
+
+// src/platform/index.ts
+var fallbackPlatform = {
+  readProcessTable: () => readProcessTableWithPs("/usr/bin/ps"),
+  readProcessTableSynchronously: () => [],
+  processExists,
+  workBuddyExecutablePaths: () => [],
+  openCodeArchives: {},
+  grokDependencies: {}
+};
+var platforms = /* @__PURE__ */ new Map([
+  ["linux", linuxPlatform],
+  ["darwin", macosPlatform],
+  ["win32", { ...fallbackPlatform, readProcessTable: () => Promise.resolve([]) }]
+]);
+function platformSupportFor(platform) {
+  return platforms.get(platform) ?? fallbackPlatform;
+}
+
+// src/process/executable.ts
+var hostPlatform = platformSupportFor(process.platform);
 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 = 16;
 var GRACEFUL_STOP_SIGNAL = 15;
 var FORCED_STOP_SIGNAL = 9;
@@ -21889,13 +22140,13 @@ function executableExtensions(executableName, environment, platform) {
 async function resolveExecutablePath(requestedPath2, platform = process.platform) {
   const absoluteRequestedPath = resolve(requestedPath2);
   try {
-    const resolvedPath = await realpath(absoluteRequestedPath);
-    const metadata = await stat(resolvedPath);
+    const resolvedPath = await realpath2(absoluteRequestedPath);
+    const metadata = await stat2(resolvedPath);
     if (!metadata.isFile()) {
       return null;
     }
     if (platform !== "win32") {
-      await access(resolvedPath, constants.X_OK);
+      await access2(resolvedPath, constants2.X_OK);
     }
     return new ResolvedExecutable(
       new ExecutableIdentity(
@@ -21920,7 +22171,7 @@ async function findExecutableOnPath(executableName, environment, platform = proc
       continue;
     }
     for (const extension of extensions) {
-      const requestedPath2 = resolve(join(entry, `${executableName}${extension}`));
+      const requestedPath2 = resolve(join3(entry, `${executableName}${extension}`));
       const executable = await resolveExecutablePath(requestedPath2, platform);
       if (executable !== null) {
         return executable;
@@ -21941,128 +22192,8 @@ function appendBounded(chunks, chunk, currentBytes, limitBytes) {
   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 appendLinuxProcessTableEntry(entries, processId, encoded) {
-  const closingParenthesis = encoded.lastIndexOf(")");
-  if (!encoded.startsWith(`${processId.toString()} (`) || closingParenthesis < 0) {
-    return;
-  }
-  const fields = encoded.slice(closingParenthesis + 1).trim().split(/\s+/);
-  const parentProcessId = Number(fields[1]);
-  const processGroupId = Number(fields[2]);
-  if (!Number.isSafeInteger(parentProcessId) || parentProcessId < 0 || !Number.isSafeInteger(processGroupId) || processGroupId <= 0) {
-    return;
-  }
-  entries.push({ parentProcessId, processGroupId, processId });
-}
-async function readLinuxProcessTable() {
-  const entries = [];
-  try {
-    const directories = await readdir("/proc", { withFileTypes: true });
-    for (const directory of directories) {
-      if (!directory.isDirectory() || !/^\d+$/.test(directory.name)) {
-        continue;
-      }
-      const processId = Number(directory.name);
-      if (!Number.isSafeInteger(processId) || processId <= 0) {
-        continue;
-      }
-      try {
-        appendLinuxProcessTableEntry(
-          entries,
-          processId,
-          await readFile(join("/proc", directory.name, "stat"), "utf8")
-        );
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return entries;
-}
-function readLinuxProcessTableSynchronously() {
-  const entries = [];
-  try {
-    const directories = readdirSync("/proc", { withFileTypes: true });
-    for (const directory of directories) {
-      if (!directory.isDirectory() || !/^\d+$/.test(directory.name)) {
-        continue;
-      }
-      const processId = Number(directory.name);
-      if (!Number.isSafeInteger(processId) || processId <= 0) {
-        continue;
-      }
-      try {
-        appendLinuxProcessTableEntry(
-          entries,
-          processId,
-          readFileSync(join("/proc", directory.name, "stat"), "utf8")
-        );
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return entries;
-}
-function readProcessTableWithPs(executable) {
-  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
-      },
-      (error62, stdout) => {
-        resolveTable(error62 === null ? parseProcessTable(stdout) : []);
-      }
-    );
-  });
-}
-async function readLinuxProcessTableWithFallback() {
-  const procfsEntries = await readLinuxProcessTable();
-  if (procfsEntries.length > 0) {
-    return procfsEntries;
-  }
-  for (const candidate of ["/usr/bin/ps", "/bin/ps", "/run/current-system/sw/bin/ps"]) {
-    const executable = await resolveExecutablePath(candidate);
-    if (executable === null) {
-      continue;
-    }
-    const entries = await readProcessTableWithPs(executable.identity.requestedPath);
-    if (entries.length > 0) {
-      return entries;
-    }
-  }
-  return [];
-}
 function readProcessTable() {
-  if (process.platform === "win32") {
-    return Promise.resolve([]);
-  }
-  if (process.platform === "linux") {
-    return readLinuxProcessTableWithFallback();
-  }
-  return readProcessTableWithPs(process.platform === "darwin" ? "/bin/ps" : "/usr/bin/ps");
+  return hostPlatform.readProcessTable();
 }
 function selectProcessTree(entries, rootProcessId) {
   const processIds = /* @__PURE__ */ new Set([rootProcessId]);
@@ -22099,11 +22230,9 @@ async function captureProcessTree(child2) {
   if (process.platform === "win32" || child2.pid === void 0) {
     return [];
   }
-  if (process.platform === "linux") {
-    const procfsEntries = readLinuxProcessTableSynchronously();
-    if (procfsEntries.length > 0) {
-      return selectProcessTree(procfsEntries, child2.pid);
-    }
+  const entries = hostPlatform.readProcessTableSynchronously();
+  if (entries.length > 0) {
+    return selectProcessTree(entries, child2.pid);
   }
   return selectProcessTree(await readProcessTable(), child2.pid);
 }
@@ -22131,36 +22260,15 @@ function signalCapturedProcessGroups(processes, rootProcessId, signal) {
     }
   }
 }
-function processExists(processId) {
-  if (process.platform === "linux") {
-    try {
-      const encoded = readFileSync(join("/proc", processId.toString(), "stat"), "utf8");
-      const closingParenthesis = encoded.lastIndexOf(")");
-      if (closingParenthesis >= 0) {
-        const processState = encoded.slice(closingParenthesis + 1).trimStart().charAt(0);
-        if (processState === "Z" || processState === "X") {
-          return false;
-        }
-      }
-    } catch {
-    }
-  }
-  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))) {
+    if (processIds.every((processId) => !hostPlatform.processExists(processId))) {
       return true;
     }
     await readProcessTable();
   }
-  return processIds.every((processId) => !processExists(processId));
+  return processIds.every((processId) => !hostPlatform.processExists(processId));
 }
 function terminateProcess(child2) {
   if (child2.exitCode !== null || child2.signalCode !== null || child2.pid === void 0) {
@@ -22508,19 +22616,19 @@ var LocalAgentCatalog = class {
 
 // src/storage/state-directory.ts
 import { homedir } from "node:os";
-import { join as join2, resolve as resolve2 } from "node:path";
+import { join as join4, 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");
+  return join4(homedir(), ".mobius");
 }
 
 // src/config.ts
 function loadDefaultWorkspace(environment = process.env) {
   const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = environment;
-  return configuredWorkspace ?? join3(readStateDirectory(environment), "workspace");
+  return configuredWorkspace ?? join5(readStateDirectory(environment), "workspace");
 }
 var DaemonLocalContext = class {
   environment;
@@ -22550,7 +22658,7 @@ var OpaqueDaemonReconnectTarget = class extends DaemonReconnectTarget {
     this.commandArgument = `--connection ${connectionId2}`;
   }
 };
-function createDaemonConfig(connection, agents = [], installableAgents = [], localContext = new DaemonLocalContext(readStateDirectory(), process.env), reconnectTarget = null) {
+function createDaemonConfig(connection, agents = [], installableAgents = [], localContext = new DaemonLocalContext(readStateDirectory(), process.env), reconnectTarget = null, resolveAgent) {
   const daemonAgents = agents.map((agent) => withDaemonEnvironment(agent, localContext.environment));
   return {
     agents: daemonAgents,
@@ -22561,7 +22669,8 @@ function createDaemonConfig(connection, agents = [], installableAgents = [], loc
     installableAgents,
     localContext,
     reconnectTarget,
-    relayUrl: connection.relayUrl
+    relayUrl: connection.relayUrl,
+    ...resolveAgent === void 0 ? {} : { resolveAgent }
   };
 }
 function loadDaemonConfig() {
@@ -22695,8 +22804,8 @@ import {
 } from "@agentclientprotocol/sdk";
 
 // src/authorization/local-raster.ts
-import { open as open2, readFile as readFile2, realpath as realpath2, stat as stat2 } from "node:fs/promises";
-import { basename, isAbsolute, normalize } from "node:path";
+import { open as open2, readFile as readFile2, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { basename, isAbsolute as isAbsolute2, normalize } from "node:path";
 import { fileURLToPath } from "node:url";
 var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
 var MAX_INLINE_RASTER_BYTES = 3e6;
@@ -22762,13 +22871,13 @@ function readInlineRaster(data, name2 = "Image") {
 }
 async function resolveCanonicalPath(requested, signal) {
   signal.throwIfAborted();
-  if (!isAbsolute(requested) || requested.includes("\0") || normalize(requested) !== requested) {
+  if (!isAbsolute2(requested) || requested.includes("\0") || normalize(requested) !== requested) {
     return null;
   }
   try {
-    const target = await realpath2(requested);
+    const target = await realpath3(requested);
     signal.throwIfAborted();
-    if (!isAbsolute(target) || normalize(target) !== target) {
+    if (!isAbsolute2(target) || normalize(target) !== target) {
       return null;
     }
     return target;
@@ -22814,7 +22923,7 @@ async function readLocalRaster(uri, signal) {
   if (target === null) {
     return null;
   }
-  const targetMetadata = await stat2(target);
+  const targetMetadata = await stat3(target);
   signal.throwIfAborted();
   if (!targetMetadata.isFile() || targetMetadata.size < 1 || targetMetadata.size > MAX_LOCAL_RASTER_BYTES) {
     return null;
@@ -25646,7 +25755,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   _sql.raw = raw;
-  function join20(chunks, separator) {
+  function join22(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) result.push(separator);
@@ -25654,7 +25763,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  _sql.join = join20;
+  _sql.join = join22;
   function identifier2(value) {
     return new Name(value);
   }
@@ -27799,7 +27908,7 @@ var SQLiteSelectBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join20) => join20.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins?.some((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       if (!this.isPartialSelect) {
         if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
         if (typeof tableName === "string" && !is(table, SQL)) {
@@ -28638,7 +28747,7 @@ var SQLiteDialect = class {
       if (!joins2) return;
       const withEntries = Object.entries(joins2).filter(([_, v]) => v);
       if (!withEntries.length) return;
-      return sql.join(withEntries.map(([k, join20]) => {
+      return sql.join(withEntries.map(([k, join22]) => {
         const relation = tableConfig.relations[k];
         const isSingle2 = is(relation, One);
         const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -28649,7 +28758,7 @@ var SQLiteDialect = class {
           table: targetTable,
           mode: isSingle2 ? "first" : "many",
           schema,
-          queryConfig: join20,
+          queryConfig: join22,
           tableConfig: schema[relation.targetTableName],
           relationWhere: filter,
           isNested: true,
@@ -28663,7 +28772,7 @@ var SQLiteDialect = class {
           key: k,
           selection: innerQuery.selection,
           isArray: !isSingle2,
-          isOptional: (relation.optional ?? false) || join20 !== true && !!join20.where
+          isOptional: (relation.optional ?? false) || join22 !== true && !!join22.where
         });
         const jsonColumns = sql.join(innerQuery.selection.map((s) => {
           return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -29279,7 +29388,7 @@ var SQLiteUpdateBase = class {
   createJoin(joinType) {
     return ((table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join20) => join20.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins.some((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       if (typeof on === "function") {
         const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
         on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -30685,7 +30794,7 @@ var AgentSession = class _AgentSession {
     );
   }
   initialize = async (signal, recovery, origin) => {
-    if (origin?.kind === "fork") {
+    if (origin !== void 0) {
       this.#sessionTitle = origin.title;
     }
     await this.#initializeAgent(signal);
@@ -30699,7 +30808,7 @@ var AgentSession = class _AgentSession {
           this.#cwd,
           this.#additionalDirectories,
           true,
-          ""
+          origin.title
         )
       ) : this.#store.read(this.#mobiusSessionId)
     );
@@ -31938,8 +32047,8 @@ var AcpContentExternalizer = class {
 
 // src/external-content/local-external-content-store.ts
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, mkdir, readdir as readdir2, realpath as realpath3, rename, rm, stat as stat3, utimes, writeFile } from "node:fs/promises";
-import { dirname, join as join4 } from "node:path";
+import { lstat, mkdir, readdir as readdir2, realpath as realpath4, rename, rm, stat as stat4, utimes, writeFile } from "node:fs/promises";
+import { dirname, join as join6 } from "node:path";
 var contentRequest = /^mobius-content:(image|audio|resource):([a-f0-9]{64})$/u;
 var CONTENT_LIFETIME_MILLISECONDS = 24 * 60 * 60 * 1e3;
 var metadataSchema2 = external_exports.strictObject({
@@ -31975,7 +32084,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join4(stateDirectory, "tmp", "session-content", randomUUID2());
+    this.#root = join6(stateDirectory, "tmp", "session-content", randomUUID2());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -31990,11 +32099,11 @@ var LocalExternalContentStore = class {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path2 = join4(dirname(this.#root), directory.name);
+        const path2 = join6(dirname(this.#root), directory.name);
         if (path2 === this.#root) {
           continue;
         }
-        const modified = await stat3(path2).then(
+        const modified = await stat4(path2).then(
           (entry) => entry.mtimeMs,
           () => Date.now()
         );
@@ -32040,10 +32149,10 @@ var LocalExternalContentStore = class {
     }
     await this.#expire();
     active.throwIfAborted();
-    const directory = join4(this.#root, kind);
+    const directory = join6(this.#root, kind);
     await mkdir(directory, { mode: 448, recursive: true });
     active.throwIfAborted();
-    const path2 = join4(directory, key);
+    const path2 = join6(directory, key);
     const write = atomicWrite(path2, bytes, active);
     await write;
     active.throwIfAborted();
@@ -32076,8 +32185,8 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath3(dirname(entry.path)),
-        realpath3(entry.path),
+        realpath4(dirname(entry.path)),
+        realpath4(entry.path),
         lstat(entry.path)
       ]);
       signal.throwIfAborted();
@@ -32515,7 +32624,7 @@ var AgentRuntimeManager = class {
       return await this.#startRetainedSessionProcess(
         options,
         async () => await AgentSession.start(
-          options.origin === void 0 && this.#sessionIdentity === "native" && isNativeChatSessionId(options.agent.id, options.sessionId) && this.#store.read(options.sessionId) instanceof MissingAcpStoredSession ? { ...options, origin: { kind: "import", nativeSessionId: options.sessionId } } : options,
+          options.origin === void 0 && this.#sessionIdentity === "native" && isNativeChatSessionId(options.agent.id, options.sessionId) && this.#store.read(options.sessionId) instanceof MissingAcpStoredSession ? { ...options, origin: { kind: "import", nativeSessionId: options.sessionId, title: "" } } : options,
           recovery,
           () => this.#observer,
           this.#store,
@@ -33174,10 +33283,10 @@ var LocalAuthorizationError = class extends Error {
 };
 
 // src/pairing/pair-local-machine.ts
-import { mkdir as mkdir6, realpath as realpath8, stat as stat7 } from "node:fs/promises";
+import { mkdir as mkdir6, realpath as realpath9, stat as stat8 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
 import { basename as basename3, resolve as resolve5 } from "node:path";
-import { fetch as fetch2 } from "undici";
+import { fetch as fetch3 } from "undici";
 
 // src/agent-catalog/agent-discovery.ts
 var AgentDiscovery = class {
@@ -33319,8 +33428,8 @@ var LocalAgentInventory = class {
 };
 
 // src/agent-installation/managed-npm-package.ts
-import { mkdir as mkdir2, mkdtemp, open as open3, realpath as realpath4, rename as rename2, rm as rm2, stat as stat4 } from "node:fs/promises";
-import { delimiter, dirname as dirname2, isAbsolute as isAbsolute2, join as join5, relative, sep } from "node:path";
+import { mkdir as mkdir2, mkdtemp, open as open3, realpath as realpath5, rename as rename2, rm as rm2, stat as stat5 } from "node:fs/promises";
+import { delimiter, dirname as dirname2, isAbsolute as isAbsolute3, join as join7, relative, sep } from "node:path";
 var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
 var PACKAGE_LOCK_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -33371,11 +33480,11 @@ function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
-  return join5(root, "node_modules", ...packageName.split("/"));
+  return join7(root, "node_modules", ...packageName.split("/"));
 }
 function isContainedPath(root, candidate) {
   const difference = relative(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep}`) && !isAbsolute2(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep}`) && !isAbsolute3(difference);
 }
 async function readJsonRecord(path2, maximumBytes) {
   try {
@@ -33476,14 +33585,14 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
   }
 }
 async function verifyRequiredDependency(rootPath, lock, definition) {
-  const dependencyRoot = await realpath4(packagePath(rootPath, definition.packageName));
+  const dependencyRoot = await realpath5(packagePath(rootPath, definition.packageName));
   if (!isContainedPath(rootPath, dependencyRoot)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The required managed npm dependency escaped its private cache"
     );
   }
-  const metadata = await readJsonRecord(join5(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join7(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33505,15 +33614,15 @@ async function validateManagedNpmPackage(root, definition) {
   }
 }
 async function validateManagedNpmPackageContents(root, definition) {
-  const rootPath = await realpath4(root);
-  const packageRoot = await realpath4(packagePath(rootPath, definition.packageName));
+  const rootPath = await realpath5(root);
+  const packageRoot = await realpath5(packagePath(rootPath, definition.packageName));
   if (!isContainedPath(rootPath, packageRoot)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package escaped its private cache"
     );
   }
-  const metadata = await readJsonRecord(join5(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join7(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33521,14 +33630,14 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   if (definition instanceof SriManagedNpmPackageDefinition) {
-    const lock = await readJsonRecord(join5(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
+    const lock = await readJsonRecord(join7(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
     verifyPackageLockEntry(lock, definition, definition.verifyDependencyClosure);
     for (const dependency of definition.requiredDependencies) {
       await verifyRequiredDependency(rootPath, lock, dependency);
     }
   }
   const declaredBin = readBinPath(metadata, definition.executableName);
-  const executable = await resolveExecutablePath(join5(packageRoot, declaredBin));
+  const executable = await resolveExecutablePath(join7(packageRoot, declaredBin));
   if (executable === null || !isContainedPath(rootPath, executable.path)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33541,7 +33650,7 @@ var ManagedNpmPackageInstaller = class {
   install = async (root, definition, environment, signal) => {
     signal.throwIfAborted();
     try {
-      const metadata = await stat4(root);
+      const metadata = await stat5(root);
       if (metadata.isDirectory()) {
         return await validateManagedNpmPackage(root, definition);
       }
@@ -33552,7 +33661,7 @@ var ManagedNpmPackageInstaller = class {
     }
     const parent = dirname2(root);
     await mkdir2(parent, { mode: 448, recursive: true });
-    const staging = await mkdtemp(join5(parent, `.${definition.version}.staging-`));
+    const staging = await mkdtemp(join7(parent, `.${definition.version}.staging-`));
     try {
       const npm = await findExecutableOnPath(process.platform === "win32" ? "npm.cmd" : "npm", environment);
       if (npm === null) {
@@ -33578,9 +33687,9 @@ var ManagedNpmPackageInstaller = class {
         `${definition.packageName}@${definition.version}`
       );
       const installEnvironment = {
-        HOME: join5(staging, "home"),
+        HOME: join7(staging, "home"),
         NPM_CONFIG_AUDIT: "false",
-        NPM_CONFIG_CACHE: join5(staging, ".npm-cache"),
+        NPM_CONFIG_CACHE: join7(staging, ".npm-cache"),
         NPM_CONFIG_FUND: "false",
         NPM_CONFIG_IGNORE_SCRIPTS: "true",
         NPM_CONFIG_PACKAGE_LOCK: "true",
@@ -33602,8 +33711,8 @@ var ManagedNpmPackageInstaller = class {
         timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
       await Promise.all([
-        rm2(join5(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm2(join5(staging, "home"), { force: true, recursive: true })
+        rm2(join7(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm2(join7(staging, "home"), { force: true, recursive: true })
       ]);
       await validateManagedNpmPackage(staging, definition);
       try {
@@ -33639,7 +33748,7 @@ var ManagedNpmPackageInstaller = class {
 };
 
 // src/agent-catalog/agent-specification.ts
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/agent-catalog/version-output.ts
 function normalizeVersionOutput(output2) {
@@ -33662,7 +33771,7 @@ var LocalAgentSpecification = class {
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
     const executable = await resolveExecutablePath(
-      join6(stateDirectory, ...this.managedAgentExecutablePath),
+      join8(stateDirectory, ...this.managedAgentExecutablePath),
       platform
     );
     signal.throwIfAborted();
@@ -33760,7 +33869,7 @@ import {
 import { spawn as spawn3 } from "node:child_process";
 
 // src/acp/codex/app-server-protocol.ts
-import { isAbsolute as isAbsolute3 } from "node:path";
+import { isAbsolute as isAbsolute4 } from "node:path";
 var boundedText = (maximum) => external_exports.string().max(maximum);
 var jsonValue = external_exports.lazy(() => external_exports.unknown());
 var requestIdSchema = external_exports.union([external_exports.number(), external_exports.string()]).refine((value) => typeof value === "number" || value.length <= 256);
@@ -33831,7 +33940,7 @@ var imageGenerationItemSchema = external_exports.object({
 });
 var threadItemSchema = external_exports.discriminatedUnion("type", [
   imageGenerationItemSchema,
-  external_exports.object({ type: external_exports.literal("imageView"), id: boundedText(256), path: boundedText(32768).refine(isAbsolute3) }),
+  external_exports.object({ type: external_exports.literal("imageView"), id: boundedText(256), path: boundedText(32768).refine(isAbsolute4) }),
   external_exports.object({
     id: boundedText(256),
     text: boundedText(1e6),
@@ -35697,15 +35806,15 @@ var AgentProbeError = class extends Error {
 };
 
 // src/agent-catalog/agents/resolve-user-local-executable.ts
-import { isAbsolute as isAbsolute4, join as join7 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join9 } from "node:path";
 async function resolveUserLocalExecutable(executableName, context) {
   context.signal.throwIfAborted();
   const platform = context.platform ?? process.platform;
   const homeDirectory = context.environment["HOME"];
-  if (platform === "win32" || homeDirectory === void 0 || !isAbsolute4(homeDirectory)) {
+  if (platform === "win32" || homeDirectory === void 0 || !isAbsolute5(homeDirectory)) {
     return [];
   }
-  const executable = await resolveExecutablePath(join7(homeDirectory, ".local", "bin", executableName), platform);
+  const executable = await resolveExecutablePath(join9(homeDirectory, ".local", "bin", executableName), platform);
   context.signal.throwIfAborted();
   return executable === null ? [] : [executable];
 }
@@ -35794,8 +35903,8 @@ var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
-import { mkdir as mkdir3, realpath as realpath5, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, join as join8, normalize as normalize2 } from "node:path";
+import { mkdir as mkdir3, realpath as realpath6, stat as stat6, writeFile as writeFile2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute6, join as join10, normalize as normalize2 } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -35819,20 +35928,20 @@ var DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH = `# Managed by Mobius: pin the ACP brid
     model: deepseek-v4-flash-vision-exp
 `;
 async function prepareAgentHome(path2, imagePrompts) {
-  if (!isAbsolute5(path2) || normalize2(path2) !== path2) {
+  if (!isAbsolute6(path2) || normalize2(path2) !== path2) {
     throw new AgentProbeError("agent_environment_invalid", "The configured Agent home is invalid");
   }
   try {
     if (imagePrompts) {
       await mkdir3(path2, { mode: 448, recursive: true });
     }
-    const resolved = await realpath5(path2);
-    const metadata = await stat5(resolved);
+    const resolved = await realpath6(path2);
+    const metadata = await stat6(resolved);
     if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
       throw new Error("Agent home is not a user-owned directory");
     }
     if (imagePrompts) {
-      await writeFile2(join8(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
+      await writeFile2(join10(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
         mode: 384
       });
     }
@@ -35880,7 +35989,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join8(readStateDirectory(context.environment), "agents", this.id, "home");
+        selectedHome = join10(readStateDirectory(context.environment), "agents", this.id, "home");
         managedHome = true;
       }
     } catch {
@@ -35896,7 +36005,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join8(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join10(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -35950,8 +36059,8 @@ var GeminiCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/grok-build-agent.ts
-import { realpath as realpath6 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, join as join9, relative as relative2, sep as sep2 } from "node:path";
+import { realpath as realpath7 } from "node:fs/promises";
+import { isAbsolute as isAbsolute7, join as join11, relative as relative2, sep as sep2 } from "node:path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
@@ -35974,50 +36083,25 @@ var GrokBuildManagedPackage = class extends SriManagedNpmPackageDefinition {
     this.requiredDependencies = Object.freeze([requiredDependency]);
   }
 };
-var GROK_DARWIN_ARM64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-darwin-arm64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-I4pKZGnR6Mv4MJOJsB9B/i2o0ODF4eZtp4jHN5feoTqKIeAUVg38OzBtE8aN/wZa7Xg+qhnf6Jd1tcAFvMoFtQ==",
-  "https://registry.npmjs.org/@xai-official/grok-darwin-arm64/-/grok-darwin-arm64-1.0.21.tgz"
-);
-var GROK_DARWIN_X64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-darwin-x64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-h0nFj3NZ9Kz8w6fQ6UDxxeSIhC1WjwwoRE92iNbG//tZy6YGkppR3s7oRVtt4Xl0CJANKUt0EusyIYnnAvKLzw==",
-  "https://registry.npmjs.org/@xai-official/grok-darwin-x64/-/grok-darwin-x64-1.0.21.tgz"
-);
-var GROK_LINUX_ARM64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-linux-arm64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-Jlwz9XtZPNKz/V/ydifC8OVu3hIZz7pmoStt8c4KCqkSWjWiZ/PBIC0iJiq8rvByhx5Z0EdSyq8ZXVwtocceGA==",
-  "https://registry.npmjs.org/@xai-official/grok-linux-arm64/-/grok-linux-arm64-1.0.21.tgz"
-);
-var GROK_LINUX_X64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-linux-x64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-AjDV5ifEz5LFG2Jt5IlhAeEkJati/wOvCchVbR4eIj2ogjvmXoXlzBrYRXuAJpXBy5q0se/Yuez5FxDU9Ju81w==",
-  "https://registry.npmjs.org/@xai-official/grok-linux-x64/-/grok-linux-x64-1.0.21.tgz"
-);
 function grokBuildManagedPackage(platform, architecture) {
-  if (platform === "darwin" && architecture === "arm64") {
-    return new GrokBuildManagedPackage(GROK_DARWIN_ARM64_PACKAGE);
-  }
-  if (platform === "darwin" && architecture === "x64") {
-    return new GrokBuildManagedPackage(GROK_DARWIN_X64_PACKAGE);
-  }
-  if (platform === "linux" && architecture === "arm64") {
-    return new GrokBuildManagedPackage(GROK_LINUX_ARM64_PACKAGE);
-  }
-  if (platform === "linux" && architecture === "x64") {
-    return new GrokBuildManagedPackage(GROK_LINUX_X64_PACKAGE);
+  const release = platformSupportFor(platform).grokDependencies[architecture];
+  if (release === void 0) {
+    throw new Error("Grok Build does not publish a package for this platform");
   }
-  throw new Error("Grok Build does not publish a package for this platform");
+  return new GrokBuildManagedPackage(
+    new SriManagedNpmDependencyDefinition(
+      release.name,
+      GROK_BUILD_MANAGED_VERSION,
+      release.integrity,
+      release.tarballUrl
+    )
+  );
 }
 
 // src/agent-catalog/agents/grok-build-agent.ts
 function isContainedPath2(root, candidate) {
   const difference = relative2(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep2}`) && !isAbsolute6(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep2}`) && !isAbsolute7(difference);
 }
 var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   adapterVersion = GROK_BUILD_MANAGED_VERSION;
@@ -36046,8 +36130,8 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
       );
       if (managed.path === agent.path) {
         return Object.freeze({
-          GROK_HOME: await realpath6(
-            join9(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
+          GROK_HOME: await realpath7(
+            join11(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
           )
         });
       }
@@ -36058,9 +36142,9 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
-    const versionRoot = await realpath6(join9(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
-    await validateManagedNpmPackage(join9(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
-    const executable = await resolveExecutablePath(join9(versionRoot, "home", "bin", "grok"), platform);
+    const versionRoot = await realpath7(join11(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
+    await validateManagedNpmPackage(join11(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
+    const executable = await resolveExecutablePath(join11(versionRoot, "home", "bin", "grok"), platform);
     signal.throwIfAborted();
     if (executable === null || !isContainedPath2(versionRoot, executable.path)) {
       throw new AgentProbeError("managed_agent_invalid", "The managed Grok Build executable is invalid");
@@ -36160,13 +36244,13 @@ var OhMyPiAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/opencode-agent.ts
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { chmod, copyFile, mkdir as mkdir4, mkdtemp as mkdtemp2, open as open4, realpath as realpath7, rename as rename3, rm as rm3, stat as stat6, writeFile as writeFile3 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname3, isAbsolute as isAbsolute7, join as join10, relative as relative3, sep as sep3 } from "node:path";
+import { chmod, copyFile, mkdir as mkdir4, mkdtemp as mkdtemp2, open as open4, realpath as realpath8, rename as rename3, rm as rm3, stat as stat7, writeFile as writeFile3 } from "node:fs/promises";
+import { delimiter as delimiter2, dirname as dirname3, isAbsolute as isAbsolute8, join as join12, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { fetch } from "undici";
@@ -36272,7 +36356,7 @@ function isRecord8(value) {
 }
 function isContainedPath3(root, candidate) {
   const difference = relative3(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute7(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute8(difference);
 }
 async function hashFile(path2, signal) {
   signal.throwIfAborted();
@@ -36346,16 +36430,16 @@ async function readManifest(path2) {
 }
 async function validateManagedAgentArchive(root, definition, signal) {
   try {
-    const rootPath = await realpath7(root);
-    const rootMetadata = await stat6(rootPath);
+    const rootPath = await realpath8(root);
+    const rootMetadata = await stat7(rootPath);
     if (!rootMetadata.isDirectory() || typeof process.getuid === "function" && rootMetadata.uid !== process.getuid()) {
       throw new Error("Managed Agent root is not user-owned");
     }
-    const manifest = await readManifest(join10(rootPath, "archive.json"));
+    const manifest = await readManifest(join12(rootPath, "archive.json"));
     if (manifest["archiveSha256"] !== definition.archiveSha256 || manifest["archiveUrl"] !== definition.archiveUrl.toString() || manifest["version"] !== definition.version || typeof manifest["executableSha256"] !== "string") {
       throw new Error("Managed Agent archive identity is invalid");
     }
-    const executable = await resolveExecutablePath(join10(rootPath, "bin", definition.executableName));
+    const executable = await resolveExecutablePath(join12(rootPath, "bin", definition.executableName));
     if (executable === null || !isContainedPath3(rootPath, executable.path) || await hashFile(executable.path, signal) !== manifest["executableSha256"]) {
       throw new Error("Managed Agent executable is invalid");
     }
@@ -36381,47 +36465,21 @@ function releaseUrl(asset) {
   return new URL(`https://github.com/anomalyco/opencode/releases/download/v${OPENCODE_MANAGED_VERSION}/${asset}`);
 }
 function openCodeManagedArchive(platform, architecture) {
-  if (platform === "darwin" && architecture === "arm64") {
-    const asset = "opencode-darwin-arm64.zip";
-    return new ZipManagedAgentArchiveDefinition(
-      OPENCODE_MANAGED_VERSION,
-      asset,
-      releaseUrl(asset),
-      "fe764f7f360c584a83e18dd5f23fb1a6b2725f5ee8854b0252fe558f7798e946",
-      "opencode"
-    );
-  }
-  if (platform === "darwin" && architecture === "x64") {
-    const asset = "opencode-darwin-x64.zip";
-    return new ZipManagedAgentArchiveDefinition(
-      OPENCODE_MANAGED_VERSION,
-      asset,
-      releaseUrl(asset),
-      "9858853e7bacdbbd22c2d70c377e009dc4b354dd04f5588705411e7afb89fd2d",
-      "opencode"
-    );
-  }
-  if (platform === "linux" && architecture === "arm64") {
-    const asset = "opencode-linux-arm64.tar.gz";
-    return new TarGzipManagedAgentArchiveDefinition(
-      OPENCODE_MANAGED_VERSION,
-      asset,
-      releaseUrl(asset),
-      "70baf769395ca4e7a68924026530c390eace194f3b7e4919d4efcb2aa2eed3c0",
-      "opencode"
-    );
-  }
-  if (platform === "linux" && architecture === "x64") {
-    const asset = "opencode-linux-x64.tar.gz";
-    return new TarGzipManagedAgentArchiveDefinition(
-      OPENCODE_MANAGED_VERSION,
-      asset,
-      releaseUrl(asset),
-      "ea800b7ff56226b70952126c9fc1e2517ca4c4b5682fd9d3f9e87449697a1194",
-      "opencode"
-    );
-  }
-  throw new Error("OpenCode does not publish an approved archive for this platform");
+  const release = platformSupportFor(platform).openCodeArchives[architecture];
+  if (release === void 0) {
+    throw new Error("OpenCode does not publish an approved archive for this platform");
+  }
+  const Definition = {
+    zip: ZipManagedAgentArchiveDefinition,
+    "tar.gz": TarGzipManagedAgentArchiveDefinition
+  }[release.format];
+  return new Definition(
+    OPENCODE_MANAGED_VERSION,
+    release.asset,
+    releaseUrl(release.asset),
+    release.sha256,
+    "opencode"
+  );
 }
 
 // src/agent-catalog/agents/opencode-agent.ts
@@ -36547,7 +36605,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
     return Object.freeze(environment);
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => await validateManagedAgentArchive(
-    join11(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    join13(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
     openCodeManagedArchive(platform, process.arch),
     signal
   );
@@ -36565,7 +36623,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/pi-agent.ts
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 import {
   methods as methods7
 } from "@agentclientprotocol/sdk";
@@ -36624,7 +36682,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join12(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+      join14(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
       PI_AGENT_PACKAGE
     );
     signal.throwIfAborted();
@@ -36662,7 +36720,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/workbuddy-agent.ts
-import { isAbsolute as isAbsolute8, join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/agent-installation/workbuddy-managed-package.ts
 var WORKBUDDY_MANAGED_VERSION = "2.146.0";
@@ -36680,15 +36738,6 @@ var WORKBUDDY_MANAGED_PACKAGE = new WorkBuddyManagedPackage(
 );
 
 // src/agent-catalog/agents/workbuddy-agent.ts
-var WORKBUDDY_MACOS_EXECUTABLE_PATH = Object.freeze([
-  "WorkBuddy.app",
-  "Contents",
-  "Resources",
-  "app.asar.unpacked",
-  "cli",
-  "bin",
-  "codebuddy"
-]);
 var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   adapterVersion = WORKBUDDY_MANAGED_VERSION;
   authenticationCommand = () => "codebuddy";
@@ -36717,7 +36766,7 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join13(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
+      join15(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
       WORKBUDDY_MANAGED_PACKAGE
     );
     signal.throwIfAborted();
@@ -36725,17 +36774,11 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveInstalledAgentExecutables = async (context) => {
     context.signal.throwIfAborted();
-    if ((context.platform ?? process.platform) !== "darwin") {
-      return [];
-    }
-    const requestedPaths = [join13("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
-    const homeDirectory = context.environment["HOME"];
-    if (homeDirectory !== void 0 && isAbsolute8(homeDirectory)) {
-      requestedPaths.unshift(join13(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
-    }
+    const platform = context.platform ?? process.platform;
+    const requestedPaths = platformSupportFor(platform).workBuddyExecutablePaths(context.environment);
     const executables = [];
     for (const requestedPath2 of requestedPaths) {
-      const executable = await resolveExecutablePath(requestedPath2, "darwin");
+      const executable = await resolveExecutablePath(requestedPath2, platform);
       context.signal.throwIfAborted();
       if (executable !== null) {
         executables.push(executable);
@@ -37066,10 +37109,10 @@ function isAgentVersionSupported(reportedVersion, minimumSupportedVersion) {
 }
 
 // src/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute9, join as join15 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join17 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -37126,7 +37169,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join14(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
+    const root = join16(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
     try {
       return await this.#npmInstaller.install(
         root,
@@ -37160,7 +37203,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join15(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
+      join17(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
       specification
     );
   } catch {
@@ -37473,10 +37516,176 @@ async function discoverLocalAgentInventory(options) {
   return new LocalAgentInventory(results);
 }
 
+// src/agent-catalog/publish-agent-catalog.ts
+import { fetch as fetch2 } from "undici";
+
+// src/relay-connection/runtime-authentication.ts
+function runtimeCredential(relayUrl) {
+  return relayUrl.searchParams.get("token") ?? "";
+}
+function runtimeAuthorization(relayUrl) {
+  const credential = runtimeCredential(relayUrl);
+  return credential.length === 0 ? {} : { authorization: `Bearer ${credential}` };
+}
+function relayHttpEndpoint(relayUrl) {
+  const endpoint = new URL(relayUrl);
+  endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
+  endpoint.search = "";
+  return endpoint;
+}
+
+// src/agent-catalog/publish-agent-catalog.ts
+var CATALOG_UPDATE_TIMEOUT_MILLISECONDS = 2e4;
+var AgentCatalogPublishError = class extends Error {
+  code = "agent_catalog_update_failed";
+  diagnosticDetails;
+  constructor(message, options = {}, diagnosticDetails = {}) {
+    super(message, options);
+    this.diagnosticDetails = diagnosticDetails;
+    this.name = "AgentCatalogPublishError";
+  }
+};
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeRelayErrorMessage(value) {
+  return value.length > 0 && value.length <= 512 && Array.from(value).every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127);
+}
+async function rejectedCatalogError(response) {
+  let value;
+  try {
+    value = await response.json();
+  } catch {
+    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
+  }
+  if (!isRecord9(value) || !isRecord9(value["error"])) {
+    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
+  }
+  const code = value["error"]["code"];
+  const message = value["error"]["message"];
+  if (typeof code !== "string" || !/^[a-z][a-z0-9_]{0,63}$/.test(code) || typeof message !== "string" || !isSafeRelayErrorMessage(message)) {
+    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
+  }
+  return new AgentCatalogPublishError(
+    `The Relay rejected the Agent catalog update (${code}): ${message}`,
+    {},
+    {
+      relayErrorCode: code
+    }
+  );
+}
+function catalogEndpoint(config2) {
+  const endpoint = relayHttpEndpoint(config2.relayUrl);
+  if (endpoint.pathname.endsWith("/daemon")) {
+    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();
+  const timeoutSignal = AbortSignal.timeout(CATALOG_UPDATE_TIMEOUT_MILLISECONDS);
+  const requestSignal = AbortSignal.any([signal, timeoutSignal]);
+  let response;
+  const catalog = config2.catalog.read();
+  try {
+    response = await fetch2(catalogEndpoint(config2), {
+      body: JSON.stringify({
+        agents: catalog.agents.map((agent) => ({
+          agentPath: agent.agentIdentity.requestedPath,
+          agentVersion: agent.agentVersion,
+          agentSettingsDiscovery: true,
+          capabilities: agent.capabilities,
+          id: agent.id,
+          label: agent.label,
+          sessionTurnConfiguration: true
+        })),
+        installableAgents: catalog.installableAgents
+      }),
+      dispatcher: environmentProxyDispatcher,
+      headers: { ...runtimeAuthorization(config2.relayUrl), "content-type": "application/json" },
+      method: "PUT",
+      signal: requestSignal
+    });
+  } catch (error62) {
+    if (signal.aborted) {
+      signal.throwIfAborted();
+    }
+    throw new AgentCatalogPublishError(
+      timeoutSignal.aborted ? "The Agent catalog update timed out" : "The Agent catalog could not be updated",
+      { cause: error62 }
+    );
+  }
+  if (!response.ok) {
+    throw await rejectedCatalogError(response);
+  }
+  await response.body?.cancel();
+}
+
+// src/agent-catalog/resolve-catalog-agent.ts
+function createCatalogAgentResolver(discover, readConfig, publish) {
+  const swaps = /* @__PURE__ */ new Map();
+  return async (agent, signal) => {
+    const config2 = readConfig();
+    const pending = swaps.get(agent.id);
+    if (pending !== void 0) {
+      await pending;
+      return config2.catalog.find(agent.id);
+    }
+    let release = () => void 0;
+    const gate = new Promise((resolveGate) => {
+      release = resolveGate;
+    });
+    swaps.set(agent.id, gate);
+    try {
+      if (await unchangedIdentity(agent, signal)) {
+        return agent;
+      }
+      signal.throwIfAborted();
+      const inventory = await discover(signal);
+      signal.throwIfAborted();
+      const previous = config2.catalog.read();
+      const previousAgent = previous.agents.find((entry) => entry.id === agent.id);
+      if (previousAgent === void 0) {
+        throw new Error(`The local Agent ${agent.id} left the catalog before its refresh completed`);
+      }
+      config2.catalog.transition(
+        [
+          ...previous.agents.filter((entry) => entry.id !== agent.id),
+          ...inventory.readyAgents().map((ready) => withDaemonEnvironment(ready, config2.localContext.environment))
+        ],
+        [...previous.installableAgents.filter((entry) => entry.id !== agent.id), ...inventory.installable]
+      );
+      try {
+        await publish(config2, signal);
+      } catch (error62) {
+        config2.catalog.transition(previous.agents, previous.installableAgents);
+        throw error62;
+      }
+      return config2.catalog.find(agent.id);
+    } finally {
+      swaps.delete(agent.id);
+      release();
+    }
+  };
+}
+async function unchangedIdentity(agent, signal) {
+  if (!await revalidateExecutable(agent.agentIdentity)) {
+    return false;
+  }
+  signal.throwIfAborted();
+  return agent.kind !== "acp-adapter-process" || await revalidateExecutable(agent.adapterIdentity);
+}
+
 // src/storage/runtime-installation-store.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir5, open as open5, readdir as readdir3, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname4, join as join16, resolve as resolve4 } from "node:path";
+import { dirname as dirname4, join as join18, resolve as resolve4 } from "node:path";
 var APPLICATION_ID_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){1,31}$/;
 var CONNECTION_ID_PATTERN = /^mcn_[a-f0-9]{32}$/;
 var INSTALLATION_ID_PATTERN = /^min_[a-f0-9]{32}$/;
@@ -37540,7 +37749,7 @@ var VerifiedRuntimeConnection = class {
     this.runtimeId = runtimeId;
   }
 };
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -37613,7 +37822,7 @@ function channelIndexFileName(channelId) {
   return `mci_${createHash4("sha256").update(channelId).digest("hex")}.json`;
 }
 function decodeInstallationPointer(value) {
-  if (!isRecord9(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {
+  if (!isRecord10(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {
     throw new RuntimeInstallationStoreError("invalid_installation", "The local installation record is invalid");
   }
   const storedInstallationId = value["installationId"];
@@ -37623,7 +37832,7 @@ function decodeInstallationPointer(value) {
   return { installationId: validateInstallationId(storedInstallationId) };
 }
 function decodeChannelIndex(value) {
-  if (!isRecord9(value) || !hasExactKeys(value, CHANNEL_INDEX_KEYS) || value["version"] !== 1) {
+  if (!isRecord10(value) || !hasExactKeys(value, CHANNEL_INDEX_KEYS) || value["version"] !== 1) {
     throw new RuntimeInstallationStoreError("invalid_connection", "The saved Runtime connection is invalid");
   }
   const applicationId = value["applicationId"];
@@ -37673,7 +37882,7 @@ function decodeVerifiedConnection(value) {
   );
 }
 function decodeConnection(value) {
-  if (!isRecord9(value)) {
+  if (!isRecord10(value)) {
     throw new RuntimeInstallationStoreError("invalid_connection", "The saved Runtime connection is invalid");
   }
   return decodeVerifiedConnection(value);
@@ -37719,7 +37928,7 @@ async function readJsonFile(path2, signal, missingCode) {
 async function writeJsonAtomically(path2, value, signal) {
   signal.throwIfAborted();
   const directory = dirname4(path2);
-  const temporaryPath = join16(directory, `.${randomUUID3()}.tmp`);
+  const temporaryPath = join18(directory, `.${randomUUID3()}.tmp`);
   try {
     await mkdir5(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -37745,14 +37954,14 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     this.applicationId = applicationId;
     this.installationId = installationId2;
     this.stateDirectory = stateDirectory;
-    this.#channelDirectory = join16(stateDirectory, "channels");
-    this.#connectionDirectory = join16(stateDirectory, "connections");
+    this.#channelDirectory = join18(stateDirectory, "channels");
+    this.#connectionDirectory = join18(stateDirectory, "connections");
   }
   static open = async (options, signal) => {
     signal.throwIfAborted();
     const applicationId = validateApplicationId(options.applicationId);
     const rootDirectory = resolve4(options.stateDirectory);
-    const applicationDirectory = join16(rootDirectory, "installations", applicationId);
+    const applicationDirectory = join18(rootDirectory, "installations", applicationId);
     try {
       await mkdir5(applicationDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -37765,7 +37974,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
       );
     }
     const storedInstallationId = await readOrCreateInstallationId(applicationDirectory, signal);
-    const stateDirectory = join16(applicationDirectory, storedInstallationId);
+    const stateDirectory = join18(applicationDirectory, storedInstallationId);
     try {
       await mkdir5(stateDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -37780,8 +37989,8 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     return new _RuntimeInstallationStore(applicationId, storedInstallationId, stateDirectory);
   };
-  connectionPath = (connectionId2) => join16(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
-  channelIndexPath = (channelId) => join16(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
+  connectionPath = (connectionId2) => join18(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
+  channelIndexPath = (channelId) => join18(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
   readConnection = async (connectionId2, signal) => {
     const stored = decodeConnection(
       await readJsonFile(this.connectionPath(connectionId2), signal, "connection_not_found")
@@ -37943,7 +38152,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
 };
 async function readOrCreateInstallationId(applicationDirectory, signal) {
-  const pointerPath = join16(applicationDirectory, "current.json");
+  const pointerPath = join18(applicationDirectory, "current.json");
   try {
     return decodeInstallationPointer(await readJsonFile(pointerPath, signal, "installation_not_found")).installationId;
   } catch (cause) {
@@ -37991,7 +38200,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys2(value, expectedKeys) {
@@ -38084,8 +38293,8 @@ async function resolveDefaultWorkspace(path2) {
   const requestedWorkspace = resolve5(path2);
   try {
     await mkdir6(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath8(requestedWorkspace);
-    const metadata = await stat7(defaultWorkspace);
+    const defaultWorkspace = await realpath9(requestedWorkspace);
+    const metadata = await stat8(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError("invalid_workspace", "The default workspace is not a directory");
     }
@@ -38114,9 +38323,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord10(value)) {
+  if (isRecord11(value)) {
     const error62 = value["error"];
-    if (isRecord10(error62)) {
+    if (isRecord11(error62)) {
       const code = error62["code"];
       const message = error62["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -38127,7 +38336,7 @@ function readRelayError(value) {
   return new PairingClientError("pairing_failed", "The relay could not pair this machine");
 }
 function decodePairingResponse(value, credentialField, expectedKeys) {
-  if (!isRecord10(value) || !hasExactKeys2(value, expectedKeys)) {
+  if (!isRecord11(value) || !hasExactKeys2(value, expectedKeys)) {
     throw new PairingClientError("invalid_relay_response", "The relay returned an invalid pairing response");
   }
   const appId = value["appId"];
@@ -38152,7 +38361,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   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, {
+    response = await fetch3(endpoint, {
       body: JSON.stringify({
         agents,
         installableAgents,
@@ -38184,20 +38393,30 @@ function buildPairedDaemon(installation, connection, defaultWorkspace, inventory
   const relayUrl = mobiusApiUrl(connection.relayOrigin, "/v1/runtimes/connect");
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.runtimeCredential);
+  const config2 = createDaemonConfig(
+    {
+      defaultWorkspace,
+      channelId: connection.channelId,
+      relayUrl
+    },
+    inventory.readyAgents(),
+    inventory.installable,
+    localContext,
+    new OpaqueDaemonReconnectTarget(connection.connectionId),
+    createCatalogAgentResolver(
+      (refreshSignal) => discoverLocalAgentInventory({
+        defaultWorkspace,
+        environment: localContext.environment,
+        signal: refreshSignal
+      }),
+      () => config2,
+      publishAgentCatalog
+    )
+  );
   return {
     channelUrl: new URL(`/channels/${encodeURIComponent(connection.channelId)}`, connection.relayOrigin).toString(),
     connectionId: connection.connectionId,
-    config: createDaemonConfig(
-      {
-        defaultWorkspace,
-        channelId: connection.channelId,
-        relayUrl
-      },
-      inventory.readyAgents(),
-      inventory.installable,
-      localContext,
-      new OpaqueDaemonReconnectTarget(connection.connectionId)
-    ),
+    config: config2,
     connectionPath: installation.connectionPath(connection.connectionId)
   };
 }
@@ -38310,120 +38529,9 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 
 // src/run-daemon.ts
 import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
-import { join as join19 } from "node:path";
+import { join as join21 } from "node:path";
 import { styleText } from "node:util";
 
-// src/agent-catalog/publish-agent-catalog.ts
-import { fetch as fetch3 } from "undici";
-
-// src/relay-connection/runtime-authentication.ts
-function runtimeCredential(relayUrl) {
-  return relayUrl.searchParams.get("token") ?? "";
-}
-function runtimeAuthorization(relayUrl) {
-  const credential = runtimeCredential(relayUrl);
-  return credential.length === 0 ? {} : { authorization: `Bearer ${credential}` };
-}
-function relayHttpEndpoint(relayUrl) {
-  const endpoint = new URL(relayUrl);
-  endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
-  endpoint.search = "";
-  return endpoint;
-}
-
-// src/agent-catalog/publish-agent-catalog.ts
-var CATALOG_UPDATE_TIMEOUT_MILLISECONDS = 2e4;
-var AgentCatalogPublishError = class extends Error {
-  code = "agent_catalog_update_failed";
-  diagnosticDetails;
-  constructor(message, options = {}, diagnosticDetails = {}) {
-    super(message, options);
-    this.diagnosticDetails = diagnosticDetails;
-    this.name = "AgentCatalogPublishError";
-  }
-};
-function isRecord11(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isSafeRelayErrorMessage(value) {
-  return value.length > 0 && value.length <= 512 && Array.from(value).every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127);
-}
-async function rejectedCatalogError(response) {
-  let value;
-  try {
-    value = await response.json();
-  } catch {
-    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
-  }
-  if (!isRecord11(value) || !isRecord11(value["error"])) {
-    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
-  }
-  const code = value["error"]["code"];
-  const message = value["error"]["message"];
-  if (typeof code !== "string" || !/^[a-z][a-z0-9_]{0,63}$/.test(code) || typeof message !== "string" || !isSafeRelayErrorMessage(message)) {
-    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
-  }
-  return new AgentCatalogPublishError(
-    `The Relay rejected the Agent catalog update (${code}): ${message}`,
-    {},
-    {
-      relayErrorCode: code
-    }
-  );
-}
-function catalogEndpoint(config2) {
-  const endpoint = relayHttpEndpoint(config2.relayUrl);
-  if (endpoint.pathname.endsWith("/daemon")) {
-    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();
-  const timeoutSignal = AbortSignal.timeout(CATALOG_UPDATE_TIMEOUT_MILLISECONDS);
-  const requestSignal = AbortSignal.any([signal, timeoutSignal]);
-  let response;
-  const catalog = config2.catalog.read();
-  try {
-    response = await fetch3(catalogEndpoint(config2), {
-      body: JSON.stringify({
-        agents: catalog.agents.map((agent) => ({
-          agentPath: agent.agentIdentity.requestedPath,
-          agentVersion: agent.agentVersion,
-          agentSettingsDiscovery: true,
-          capabilities: agent.capabilities,
-          id: agent.id,
-          label: agent.label,
-          sessionTurnConfiguration: true
-        })),
-        installableAgents: catalog.installableAgents
-      }),
-      dispatcher: environmentProxyDispatcher,
-      headers: { ...runtimeAuthorization(config2.relayUrl), "content-type": "application/json" },
-      method: "PUT",
-      signal: requestSignal
-    });
-  } catch (error62) {
-    if (signal.aborted) {
-      signal.throwIfAborted();
-    }
-    throw new AgentCatalogPublishError(
-      timeoutSignal.aborted ? "The Agent catalog update timed out" : "The Agent catalog could not be updated",
-      { cause: error62 }
-    );
-  }
-  if (!response.ok) {
-    throw await rejectedCatalogError(response);
-  }
-  await response.body?.cancel();
-}
-
 // src/agent-installation/agent-installation-manager.ts
 var INSTALLATION_DEADLINE_MILLISECONDS = 10 * 60 * 1e3;
 var AgentInstallation = class {
@@ -38886,9 +38994,9 @@ var FixedInstallationExecutor = class {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir as readdir4, realpath as realpath9, stat as stat8 } from "node:fs/promises";
+import { readdir as readdir4, realpath as realpath10, stat as stat9 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute10, join as join17, normalize as normalize3, relative as relative4 } from "node:path";
+import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute10, join as join19, normalize as normalize3, relative as relative4 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
   directoryLabel;
@@ -38956,9 +39064,9 @@ var WorkspaceDirectoryService = class {
       throw new LocalAuthorizationError("The local directory path is invalid");
     }
     try {
-      const target = await realpath9(requested);
+      const target = await realpath10(requested);
       signal.throwIfAborted();
-      const metadata = await stat8(target);
+      const metadata = await stat9(target);
       signal.throwIfAborted();
       if (!isAbsolute10(target) || normalize3(target) !== target || !metadata.isDirectory()) {
         throw new LocalAuthorizationError("The selected location is not a directory");
@@ -39006,7 +39114,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join17(target, child2.name), signal);
+          const path2 = await this.resolvePath(join19(target, child2.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -39042,15 +39150,15 @@ var WorkspaceDirectoryService = class {
 
 // src/daemon-diagnostic-log.ts
 import { appendFileSync, mkdirSync, readFileSync as readFileSync2, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 var MAXIMUM_DAEMON_LOG_BYTES = 1 * 1024 * 1024;
 var DaemonDiagnosticLog = class {
   #directory;
   #path;
   #maximumBytes;
   constructor(stateDirectory, maximumBytes = MAXIMUM_DAEMON_LOG_BYTES) {
-    this.#directory = join18(stateDirectory, "logs");
-    this.#path = join18(this.#directory, "daemon.log");
+    this.#directory = join20(stateDirectory, "logs");
+    this.#path = join20(this.#directory, "daemon.log");
     this.#maximumBytes = maximumBytes;
   }
   // Export only correlation and failure metadata. Local messages and paths stay local.
@@ -40995,9 +41103,10 @@ var NativeSessionService = class {
       signal
     );
     signal.throwIfAborted();
+    const cataloged = this.#config.catalog.find(command.agentId);
     const options = {
       additionalDirectories,
-      agent: this.#config.catalog.find(command.agentId),
+      agent: this.#config.resolveAgent === void 0 ? cataloged : await this.#config.resolveAgent(cataloged, signal),
       cwd,
       sessionId: command.sessionId,
       signal
@@ -41175,7 +41284,7 @@ var NativeSessionService = class {
         sessionId: command.targetSessionId,
         additionalDirectories: target.additionalDirectories
       },
-      action === "fork" ? { kind: "fork", nativeSessionId: target.info.sessionId, title: title2 } : { kind: "import", nativeSessionId: target.info.sessionId }
+      action === "fork" ? { kind: "fork", nativeSessionId: target.info.sessionId, title: title2 } : { kind: "import", nativeSessionId: target.info.sessionId, title: title2 }
     );
     signal.throwIfAborted();
     const ready = {
@@ -41549,7 +41658,7 @@ import { WebSocket as WebSocket5 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.193",
+  version: "0.0.194",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -41852,7 +41961,8 @@ function unsupportedModelIds(unsupportedModels) {
   return [...new Set(unsupportedModels.map((item) => item.requestedValue))];
 }
 async function discoverAgentSettings(command, config2, directories, sessions, signal) {
-  const agent = config2.catalog.find(command.agentId);
+  const cataloged = config2.catalog.find(command.agentId);
+  const agent = config2.resolveAgent === void 0 ? cataloged : await config2.resolveAgent(cataloged, signal);
   const cwd = await directories.resolve(config2.bindingId, "default", signal);
   const inspectedBaseSnapshot = await sessions.inspectAgentSettings({
     additionalDirectories: [],
@@ -42246,7 +42356,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
-import { realpath as realpath10, stat as stat9 } from "node:fs/promises";
+import { realpath as realpath11, stat as stat10 } from "node:fs/promises";
 import { basename as basename5, extname, isAbsolute as isAbsolute11, normalize as normalize4, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
@@ -42274,7 +42384,7 @@ async function resolveFile(value, workingDirectory, signal) {
     return null;
   }
   try {
-    const target = await realpath10(requested);
+    const target = await realpath11(requested);
     signal.throwIfAborted();
     return isAbsolute11(target) && normalize4(target) === target ? target : null;
   } catch {
@@ -42288,7 +42398,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
   if (target === null) {
     throw new Error("The local file is unavailable");
   }
-  const before = await stat9(target);
+  const before = await stat10(target);
   signal.throwIfAborted();
   if (!before.isFile() || before.size < 1 || before.size > command.maxBytes) {
     throw new Error("The local file is too large to read");
@@ -42316,7 +42426,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
     });
     sequence += 1;
   }
-  const after = await stat9(target);
+  const after = await stat10(target);
   signal.throwIfAborted();
   if (after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
     throw new Error("The local file changed during transfer");
@@ -42360,6 +42470,232 @@ async function resolveSessionDirectories(directories, bindingId, directoryId2, a
   return new ResolvedSessionDirectories(cwd, additionalDirectories, additionalDirectoryEntries);
 }
 
+// src/daemon-session-commands.ts
+async function resolveCatalogAgent(config2, agentId, signal) {
+  const agent = config2.catalog.find(agentId);
+  return config2.resolveAgent === void 0 ? agent : await config2.resolveAgent(agent, signal);
+}
+async function prepareSession(command, recovery, config2, directories, audit, sessions, metrics, signal) {
+  return await metrics.measure("prepare-total", async () => {
+    const resolved = await metrics.measure(
+      "workspace-resolve",
+      async () => await resolveSessionDirectories(
+        directories,
+        config2.bindingId,
+        command.directoryId,
+        command.additionalDirectoryIds,
+        signal
+      )
+    );
+    const agent = await resolveCatalogAgent(config2, command.agentId, signal);
+    const preparation = {
+      additionalDirectories: resolved.additionalDirectories,
+      agent,
+      cwd: resolved.cwd,
+      sessionId: command.sessionId,
+      signal
+    };
+    const prepared = command.transient === true ? await sessions.inspectSession(preparation, metrics) : recovery.kind === "history-required" ? await sessions.restoreSession(preparation, metrics) : await sessions.prepareSession(preparation, metrics);
+    const configuration = command.configuration;
+    const configOptions = configuration === void 0 ? prepared.configOptions : await metrics.measure(
+      "configuration",
+      async () => await sessions.configureSession({
+        ...preparation,
+        booleanValue: configuration.booleanValue,
+        configId: configuration.configId,
+        requestId: command.requestId,
+        value: configuration.value,
+        valueType: configuration.valueType
+      })
+    );
+    const listing = await metrics.measure(
+      "workspace-list",
+      async () => await directories.list(config2.bindingId, command.directoryId, signal)
+    );
+    audit.record({
+      commandId: command.requestId,
+      event: "session_prepared",
+      sessionId: command.sessionId
+    });
+    if (command.configuration !== void 0) {
+      audit.record({
+        commandId: command.requestId,
+        event: "session_configured",
+        sessionId: command.sessionId
+      });
+    }
+    return {
+      additionalDirectories: resolved.additionalDirectoryEntries,
+      agentId: command.agentId,
+      agentName: prepared.agentName,
+      agentVersion: prepared.agentVersion,
+      capabilities: prepared.capabilities,
+      commands: prepared.commands,
+      configOptions,
+      directoryId: command.directoryId,
+      directoryLabel: listing.directoryLabel,
+      kind: "session.ready",
+      requestId: command.requestId,
+      restored: prepared.restored,
+      sessionId: command.sessionId
+    };
+  });
+}
+async function executeWorkspaceList(socket, command, directories, audit, signal) {
+  try {
+    const listing = await directories.list(command.bindingId, command.directoryId, signal);
+    audit.record({
+      commandId: command.requestId,
+      event: "workspace_list_authorized",
+      sessionId: "workspace-browser"
+    });
+    send(socket, {
+      bindingId: command.bindingId,
+      directoryId: listing.directoryId,
+      directoryLabel: listing.directoryLabel,
+      entries: listing.entries,
+      kind: "workspace.entries",
+      parentDirectoryId: listing.parentDirectoryId,
+      requestId: command.requestId
+    });
+  } catch (error62) {
+    reportOperationFailure(socket, command.requestId, "", error62);
+  }
+}
+async function executeSessionPrepare(socket, command, config2, directories, audit, sessions, diagnostics, signal) {
+  const metrics = new AccumulatingOperationMetrics();
+  try {
+    const readyEvent = await prepareSession(
+      command,
+      { kind: "interactive-only" },
+      config2,
+      directories,
+      audit,
+      sessions,
+      metrics,
+      signal
+    );
+    send(socket, {
+      ...readyEvent,
+      runtimeTimings: metrics.snapshot()
+    });
+  } catch (error62) {
+    diagnostics.daemonDiagnostic(
+      "session_prepare_failed",
+      command.requestId,
+      {
+        agentId: command.agentId,
+        code: operationErrorCode(error62),
+        sessionId: command.sessionId
+      },
+      error62
+    );
+    audit.record({
+      commandId: command.requestId,
+      details: {
+        agentId: command.agentId,
+        code: operationErrorCode(error62)
+      },
+      event: "session_prepare_failed",
+      sessionId: command.sessionId
+    });
+    reportOperationFailure(socket, command.requestId, command.sessionId, error62, metrics.snapshot());
+  }
+}
+async function executeSessionRestore(socket, command, config2, directories, audit, sessions, nativeSessions, diagnostics, signal) {
+  const metrics = new AccumulatingOperationMetrics();
+  try {
+    const entry = await metrics.measure("session-lookup", async () => {
+      const [found] = await nativeSessions.querySessions([command.sessionId], signal);
+      if (found === void 0) {
+        throw new AcpExecutionError("The Session was not found", {}, "session_not_found");
+      }
+      return found;
+    });
+    const ready = await prepareSession(
+      {
+        additionalDirectoryIds: entry.additionalDirectories.map((directory) => directory.directoryId),
+        agentId: entry.agentId,
+        bindingId: config2.bindingId,
+        directoryId: entry.directoryId,
+        kind: "session.prepare",
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        sessionState: "provisioned"
+      },
+      { kind: "history-required" },
+      config2,
+      directories,
+      audit,
+      sessions,
+      metrics,
+      signal
+    );
+    send(socket, {
+      entry,
+      kind: "session.restored",
+      ready: { ...ready, runtimeTimings: metrics.snapshot() },
+      requestId: command.requestId
+    });
+  } catch (error62) {
+    diagnostics.daemonDiagnostic(
+      "session_restore_failed",
+      command.requestId,
+      {
+        code: operationErrorCode(error62),
+        sessionId: command.sessionId
+      },
+      error62
+    );
+    audit.record({
+      commandId: command.requestId,
+      details: { code: operationErrorCode(error62) },
+      event: "session_restore_failed",
+      sessionId: command.sessionId
+    });
+    reportOperationFailure(socket, command.requestId, command.sessionId, error62, metrics.snapshot());
+  }
+}
+async function executeSessionConfigure(socket, command, config2, directories, audit, sessions, signal) {
+  try {
+    const resolved = await resolveSessionDirectories(
+      directories,
+      config2.bindingId,
+      command.directoryId,
+      command.additionalDirectoryIds,
+      signal
+    );
+    const configOptions = await sessions.configureSession({
+      additionalDirectories: resolved.additionalDirectories,
+      agent: await resolveCatalogAgent(config2, command.agentId, signal),
+      booleanValue: command.booleanValue,
+      configId: command.configId,
+      cwd: resolved.cwd,
+      requestId: command.requestId,
+      sessionId: command.sessionId,
+      signal,
+      value: command.value,
+      valueType: command.valueType
+    });
+    audit.record({
+      commandId: command.requestId,
+      event: "session_configured",
+      sessionId: command.sessionId
+    });
+    send(socket, {
+      configOptions,
+      kind: "session.config.updated",
+      requestId: command.requestId,
+      sessionId: command.sessionId
+    });
+  } catch (error62) {
+    if (signal.aborted) {
+      signal.throwIfAborted();
+    }
+    reportOperationFailure(socket, command.requestId, command.sessionId, error62);
+  }
+}
+
 // src/daemon-history-commands.ts
 async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, directories, audit, diagnostics, sessions, nativeSessions, eventLogV2, signal) {
   let agentId;
@@ -42378,7 +42714,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
     );
     const loadOptions = {
       additionalDirectories: resolved.additionalDirectories,
-      agent: config2.catalog.find(entry.agentId),
+      agent: await resolveCatalogAgent(config2, entry.agentId, signal),
       cwd: resolved.cwd,
       sessionId: command.sessionId,
       signal
@@ -42454,7 +42790,7 @@ async function executeSessionPreviewHistoryPageLoad(socket, command, config2, di
     const replay = await sessions.previewNativeSessionEventsV2(
       {
         additionalDirectories: resolved.additionalDirectories,
-        agent: config2.catalog.find(command.agentId),
+        agent: await resolveCatalogAgent(config2, command.agentId, signal),
         cwd: resolved.cwd,
         sessionId: command.sessionId,
         signal
@@ -42746,7 +43082,7 @@ async function executePrompt({
       command.additionalDirectoryIds,
       signal
     );
-    const agent = config2.catalog.find(command.agentId);
+    const agent = await resolveCatalogAgent(config2, command.agentId, signal);
     const availability = await waitForSessionAvailability(signal);
     if (availability.kind === "busy") {
       throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
@@ -42891,228 +43227,6 @@ async function executePrompt({
   }
 }
 
-// src/daemon-session-commands.ts
-async function prepareSession(command, recovery, config2, directories, audit, sessions, metrics, signal) {
-  return await metrics.measure("prepare-total", async () => {
-    const resolved = await metrics.measure(
-      "workspace-resolve",
-      async () => await resolveSessionDirectories(
-        directories,
-        config2.bindingId,
-        command.directoryId,
-        command.additionalDirectoryIds,
-        signal
-      )
-    );
-    const agent = config2.catalog.find(command.agentId);
-    const preparation = {
-      additionalDirectories: resolved.additionalDirectories,
-      agent,
-      cwd: resolved.cwd,
-      sessionId: command.sessionId,
-      signal
-    };
-    const prepared = command.transient === true ? await sessions.inspectSession(preparation, metrics) : recovery.kind === "history-required" ? await sessions.restoreSession(preparation, metrics) : await sessions.prepareSession(preparation, metrics);
-    const configuration = command.configuration;
-    const configOptions = configuration === void 0 ? prepared.configOptions : await metrics.measure(
-      "configuration",
-      async () => await sessions.configureSession({
-        ...preparation,
-        booleanValue: configuration.booleanValue,
-        configId: configuration.configId,
-        requestId: command.requestId,
-        value: configuration.value,
-        valueType: configuration.valueType
-      })
-    );
-    const listing = await metrics.measure(
-      "workspace-list",
-      async () => await directories.list(config2.bindingId, command.directoryId, signal)
-    );
-    audit.record({
-      commandId: command.requestId,
-      event: "session_prepared",
-      sessionId: command.sessionId
-    });
-    if (command.configuration !== void 0) {
-      audit.record({
-        commandId: command.requestId,
-        event: "session_configured",
-        sessionId: command.sessionId
-      });
-    }
-    return {
-      additionalDirectories: resolved.additionalDirectoryEntries,
-      agentId: command.agentId,
-      agentName: prepared.agentName,
-      agentVersion: prepared.agentVersion,
-      capabilities: prepared.capabilities,
-      commands: prepared.commands,
-      configOptions,
-      directoryId: command.directoryId,
-      directoryLabel: listing.directoryLabel,
-      kind: "session.ready",
-      requestId: command.requestId,
-      restored: prepared.restored,
-      sessionId: command.sessionId
-    };
-  });
-}
-async function executeWorkspaceList(socket, command, directories, audit, signal) {
-  try {
-    const listing = await directories.list(command.bindingId, command.directoryId, signal);
-    audit.record({
-      commandId: command.requestId,
-      event: "workspace_list_authorized",
-      sessionId: "workspace-browser"
-    });
-    send(socket, {
-      bindingId: command.bindingId,
-      directoryId: listing.directoryId,
-      directoryLabel: listing.directoryLabel,
-      entries: listing.entries,
-      kind: "workspace.entries",
-      parentDirectoryId: listing.parentDirectoryId,
-      requestId: command.requestId
-    });
-  } catch (error62) {
-    reportOperationFailure(socket, command.requestId, "", error62);
-  }
-}
-async function executeSessionPrepare(socket, command, config2, directories, audit, sessions, diagnostics, signal) {
-  const metrics = new AccumulatingOperationMetrics();
-  try {
-    const readyEvent = await prepareSession(
-      command,
-      { kind: "interactive-only" },
-      config2,
-      directories,
-      audit,
-      sessions,
-      metrics,
-      signal
-    );
-    send(socket, {
-      ...readyEvent,
-      runtimeTimings: metrics.snapshot()
-    });
-  } catch (error62) {
-    diagnostics.daemonDiagnostic(
-      "session_prepare_failed",
-      command.requestId,
-      {
-        agentId: command.agentId,
-        code: operationErrorCode(error62),
-        sessionId: command.sessionId
-      },
-      error62
-    );
-    audit.record({
-      commandId: command.requestId,
-      details: {
-        agentId: command.agentId,
-        code: operationErrorCode(error62)
-      },
-      event: "session_prepare_failed",
-      sessionId: command.sessionId
-    });
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62, metrics.snapshot());
-  }
-}
-async function executeSessionRestore(socket, command, config2, directories, audit, sessions, nativeSessions, diagnostics, signal) {
-  const metrics = new AccumulatingOperationMetrics();
-  try {
-    const entry = await metrics.measure("session-lookup", async () => {
-      const [found] = await nativeSessions.querySessions([command.sessionId], signal);
-      if (found === void 0) {
-        throw new AcpExecutionError("The Session was not found", {}, "session_not_found");
-      }
-      return found;
-    });
-    const ready = await prepareSession(
-      {
-        additionalDirectoryIds: entry.additionalDirectories.map((directory) => directory.directoryId),
-        agentId: entry.agentId,
-        bindingId: config2.bindingId,
-        directoryId: entry.directoryId,
-        kind: "session.prepare",
-        requestId: command.requestId,
-        sessionId: command.sessionId,
-        sessionState: "provisioned"
-      },
-      { kind: "history-required" },
-      config2,
-      directories,
-      audit,
-      sessions,
-      metrics,
-      signal
-    );
-    send(socket, {
-      entry,
-      kind: "session.restored",
-      ready: { ...ready, runtimeTimings: metrics.snapshot() },
-      requestId: command.requestId
-    });
-  } catch (error62) {
-    diagnostics.daemonDiagnostic(
-      "session_restore_failed",
-      command.requestId,
-      {
-        code: operationErrorCode(error62),
-        sessionId: command.sessionId
-      },
-      error62
-    );
-    audit.record({
-      commandId: command.requestId,
-      details: { code: operationErrorCode(error62) },
-      event: "session_restore_failed",
-      sessionId: command.sessionId
-    });
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62, metrics.snapshot());
-  }
-}
-async function executeSessionConfigure(socket, command, config2, directories, audit, sessions, signal) {
-  try {
-    const resolved = await resolveSessionDirectories(
-      directories,
-      config2.bindingId,
-      command.directoryId,
-      command.additionalDirectoryIds,
-      signal
-    );
-    const configOptions = await sessions.configureSession({
-      additionalDirectories: resolved.additionalDirectories,
-      agent: config2.catalog.find(command.agentId),
-      booleanValue: command.booleanValue,
-      configId: command.configId,
-      cwd: resolved.cwd,
-      requestId: command.requestId,
-      sessionId: command.sessionId,
-      signal,
-      value: command.value,
-      valueType: command.valueType
-    });
-    audit.record({
-      commandId: command.requestId,
-      event: "session_configured",
-      sessionId: command.sessionId
-    });
-    send(socket, {
-      configOptions,
-      kind: "session.config.updated",
-      requestId: command.requestId,
-      sessionId: command.sessionId
-    });
-  } catch (error62) {
-    if (signal.aborted) {
-      signal.throwIfAborted();
-    }
-    reportOperationFailure(socket, command.requestId, command.sessionId, error62);
-  }
-}
-
 // src/native-sessions/handle-native-requests.ts
 import { WebSocket as WebSocket4 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
@@ -44285,11 +44399,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     stateDirectory
   });
   const channelHash = createHash8("sha256").update(config2.channelId).digest("hex");
-  const sessionDatabase = openAcpSessionDatabase(join19(stateDirectory, "sessions", `${channelHash}.sqlite`));
+  const sessionDatabase = openAcpSessionDatabase(join21(stateDirectory, "sessions", `${channelHash}.sqlite`));
   let eventsV2;
   try {
     eventsV2 = new CachedAcpSessionEventStoreV2(
-      openSessionEventCacheV2Database(join19(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
+      openSessionEventCacheV2Database(join21(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
     );
   } catch (error62) {
     sessionDatabase.close();
@@ -44492,7 +44606,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
 }
 
 // src/runtime.ts
-import { mkdir as mkdir7, realpath as realpath11, stat as stat10 } from "node:fs/promises";
+import { mkdir as mkdir7, realpath as realpath12, stat as stat11 } from "node:fs/promises";
 import { resolve as resolve8 } from "node:path";
 var RUNTIME_CREDENTIAL_PATTERN2 = /^[a-zA-Z0-9_-]{32,256}$/;
 var MobiusRuntimeConfigurationError = class extends Error {
@@ -44559,8 +44673,8 @@ async function resolveWorkspace(path2) {
   const requested = resolve8(path2);
   try {
     await mkdir7(requested, { recursive: true, mode: 448 });
-    const resolved = await realpath11(requested);
-    const metadata = await stat10(resolved);
+    const resolved = await realpath12(requested);
+    const metadata = await stat11(resolved);
     if (!metadata.isDirectory()) {
       throw new MobiusRuntimeConfigurationError("The Runtime workspace is not a directory");
     }
@@ -44577,26 +44691,35 @@ async function createMobiusRuntimeEngine(connection, signal, environment = proce
   const localContext = new DaemonLocalContext(readStateDirectory(environment), environment);
   const relayUrl = relayUrlFromConnection(connection);
   const defaultWorkspace = await resolveWorkspace(connection.defaultWorkspace);
-  const inventory = await discoverLocalAgentInventory({
+  const specifications = supportedLocalAgentSpecifications();
+  const discoveryEnvironment = localContext.environment;
+  const discover = async (refreshSignal) => await discoverLocalAgentInventory({
     defaultWorkspace,
-    environment: localContext.environment,
-    signal
+    environment: discoveryEnvironment,
+    signal: refreshSignal,
+    specifications
   });
+  const inventory = await discover(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(
-      {
-        channelId: connection.channelId,
-        defaultWorkspace,
-        relayUrl
-      },
-      inventory.readyAgents(),
-      inventory.installable,
-      localContext
+  const config2 = createDaemonConfig(
+    {
+      channelId: connection.channelId,
+      defaultWorkspace,
+      relayUrl
+    },
+    inventory.readyAgents(),
+    inventory.installable,
+    localContext,
+    null,
+    createCatalogAgentResolver(
+      (refreshSignal) => discover(refreshSignal),
+      () => config2,
+      publishAgentCatalog
     )
   );
+  return new MobiusRuntimeEngine(config2);
 }
 var MobiusRuntimeEngine = class {
   #config;