@moxt-ai/mobius 0.0.193 → 0.0.194

package/dist/cli.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { constants as constants2 } from "node:fs";
+import { constants as constants3 } from "node:fs";
 import { mkdir as mkdir7, open as open6 } from "node:fs/promises";
 import { resolve as resolve8 } from "node:path";
 
@@ -3381,7 +3381,7 @@ var program = new Command();
 // 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: {
@@ -3505,15 +3505,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;
@@ -3572,13 +3823,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(
@@ -3603,7 +3854,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;
@@ -3624,128 +3875,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]);
@@ -3782,11 +3913,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);
 }
@@ -3814,36 +3943,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) {
@@ -4429,8 +4537,8 @@ function formatAgentDiagnostics(inventory, json2, verbose = false) {
 }
 
 // src/agent-installation/managed-npm-package.ts
-import { mkdir, mkdtemp, open, realpath as realpath2, rename, rm, stat as stat2 } from "node:fs/promises";
-import { delimiter, dirname, isAbsolute, join as join2, relative, sep } from "node:path";
+import { mkdir, mkdtemp, open, realpath as realpath3, rename, rm, stat as stat3 } from "node:fs/promises";
+import { delimiter, dirname, isAbsolute as isAbsolute2, join as join4, 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;
@@ -4481,11 +4589,11 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
-  return join2(root, "node_modules", ...packageName.split("/"));
+  return join4(root, "node_modules", ...packageName.split("/"));
 }
 function isContainedPath(root, candidate) {
   const difference = relative(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep}`) && !isAbsolute(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep}`) && !isAbsolute2(difference);
 }
 async function readJsonRecord(path3, maximumBytes) {
   try {
@@ -4586,14 +4694,14 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
   }
 }
 async function verifyRequiredDependency(rootPath, lock, definition) {
-  const dependencyRoot = await realpath2(packagePath(rootPath, definition.packageName));
+  const dependencyRoot = await realpath3(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(join2(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join4(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -4615,15 +4723,15 @@ async function validateManagedNpmPackage(root, definition) {
   }
 }
 async function validateManagedNpmPackageContents(root, definition) {
-  const rootPath = await realpath2(root);
-  const packageRoot = await realpath2(packagePath(rootPath, definition.packageName));
+  const rootPath = await realpath3(root);
+  const packageRoot = await realpath3(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(join2(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join4(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -4631,14 +4739,14 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   if (definition instanceof SriManagedNpmPackageDefinition) {
-    const lock = await readJsonRecord(join2(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
+    const lock = await readJsonRecord(join4(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(join2(packageRoot, declaredBin));
+  const executable = await resolveExecutablePath(join4(packageRoot, declaredBin));
   if (executable === null || !isContainedPath(rootPath, executable.path)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -4651,7 +4759,7 @@ var ManagedNpmPackageInstaller = class {
   install = async (root, definition, environment, signal) => {
     signal.throwIfAborted();
     try {
-      const metadata = await stat2(root);
+      const metadata = await stat3(root);
       if (metadata.isDirectory()) {
         return await validateManagedNpmPackage(root, definition);
       }
@@ -4662,7 +4770,7 @@ var ManagedNpmPackageInstaller = class {
     }
     const parent = dirname(root);
     await mkdir(parent, { mode: 448, recursive: true });
-    const staging = await mkdtemp(join2(parent, `.${definition.version}.staging-`));
+    const staging = await mkdtemp(join4(parent, `.${definition.version}.staging-`));
     try {
       const npm = await findExecutableOnPath(process.platform === "win32" ? "npm.cmd" : "npm", environment);
       if (npm === null) {
@@ -4688,9 +4796,9 @@ var ManagedNpmPackageInstaller = class {
         `${definition.packageName}@${definition.version}`
       );
       const installEnvironment = {
-        HOME: join2(staging, "home"),
+        HOME: join4(staging, "home"),
         NPM_CONFIG_AUDIT: "false",
-        NPM_CONFIG_CACHE: join2(staging, ".npm-cache"),
+        NPM_CONFIG_CACHE: join4(staging, ".npm-cache"),
         NPM_CONFIG_FUND: "false",
         NPM_CONFIG_IGNORE_SCRIPTS: "true",
         NPM_CONFIG_PACKAGE_LOCK: "true",
@@ -4712,8 +4820,8 @@ var ManagedNpmPackageInstaller = class {
         timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
       await Promise.all([
-        rm(join2(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm(join2(staging, "home"), { force: true, recursive: true })
+        rm(join4(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm(join4(staging, "home"), { force: true, recursive: true })
       ]);
       await validateManagedNpmPackage(staging, definition);
       try {
@@ -4749,7 +4857,7 @@ var ManagedNpmPackageInstaller = class {
 };
 
 // src/agent-catalog/agent-specification.ts
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/agent-catalog/version-output.ts
 function normalizeVersionOutput(output2) {
@@ -4772,7 +4880,7 @@ var LocalAgentSpecification = class {
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
     const executable = await resolveExecutablePath(
-      join3(stateDirectory, ...this.managedAgentExecutablePath),
+      join5(stateDirectory, ...this.managedAgentExecutablePath),
       platform
     );
     signal.throwIfAborted();
@@ -4976,7 +5084,7 @@ function sessionFailureMeta(failure2) {
 import { spawn as spawn2 } from "node:child_process";
 
 // src/acp/codex/app-server-protocol.ts
-import { isAbsolute as isAbsolute2 } from "node:path";
+import { isAbsolute as isAbsolute3 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -24717,7 +24825,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(isAbsolute2) }),
+  external_exports.object({ type: external_exports.literal("imageView"), id: boundedText(256), path: boundedText(32768).refine(isAbsolute3) }),
   external_exports.object({
     id: boundedText(256),
     text: boundedText(1e6),
@@ -28652,15 +28760,15 @@ var AgentProbeError = class extends Error {
 };
 
 // src/agent-catalog/agents/resolve-user-local-executable.ts
-import { isAbsolute as isAbsolute3, join as join4 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join6 } 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 || !isAbsolute3(homeDirectory)) {
+  if (platform === "win32" || homeDirectory === void 0 || !isAbsolute4(homeDirectory)) {
     return [];
   }
-  const executable = await resolveExecutablePath(join4(homeDirectory, ".local", "bin", executableName), platform);
+  const executable = await resolveExecutablePath(join6(homeDirectory, ".local", "bin", executableName), platform);
   context.signal.throwIfAborted();
   return executable === null ? [] : [executable];
 }
@@ -28749,8 +28857,8 @@ var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
-import { mkdir as mkdir2, realpath as realpath3, stat as stat3, writeFile } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join6, normalize } from "node:path";
+import { mkdir as mkdir2, realpath as realpath4, stat as stat4, writeFile } from "node:fs/promises";
+import { isAbsolute as isAbsolute5, join as join8, normalize } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -28768,13 +28876,13 @@ var DEEPSEEK_HARNESS_PACKAGE = new DeepSeekHarnessManagedPackage(
 
 // src/storage/state-directory.ts
 import { homedir } from "node:os";
-import { join as join5, resolve as resolve2 } from "node:path";
+import { join as join7, 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 join5(homedir(), ".mobius");
+  return join7(homedir(), ".mobius");
 }
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
@@ -28785,20 +28893,20 @@ var DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH = `# Managed by Mobius: pin the ACP brid
     model: deepseek-v4-flash-vision-exp
 `;
 async function prepareAgentHome(path3, imagePrompts) {
-  if (!isAbsolute4(path3) || normalize(path3) !== path3) {
+  if (!isAbsolute5(path3) || normalize(path3) !== path3) {
     throw new AgentProbeError("agent_environment_invalid", "The configured Agent home is invalid");
   }
   try {
     if (imagePrompts) {
       await mkdir2(path3, { mode: 448, recursive: true });
     }
-    const resolved = await realpath3(path3);
-    const metadata = await stat3(resolved);
+    const resolved = await realpath4(path3);
+    const metadata = await stat4(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 writeFile(join6(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
+      await writeFile(join8(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
         mode: 384
       });
     }
@@ -28846,7 +28954,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join6(readStateDirectory(context.environment), "agents", this.id, "home");
+        selectedHome = join8(readStateDirectory(context.environment), "agents", this.id, "home");
         managedHome = true;
       }
     } catch {
@@ -28862,7 +28970,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join6(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join8(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -28916,8 +29024,8 @@ var GeminiCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/grok-build-agent.ts
-import { realpath as realpath4 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, join as join7, relative as relative2, sep as sep2 } from "node:path";
+import { realpath as realpath5 } from "node:fs/promises";
+import { isAbsolute as isAbsolute6, join as join9, relative as relative2, sep as sep2 } from "node:path";
 import {
   RequestError
 } from "@agentclientprotocol/sdk";
@@ -28940,50 +29048,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);
+  const release = platformSupportFor(platform).grokDependencies[architecture];
+  if (release === void 0) {
+    throw new Error("Grok Build does not publish a package for this platform");
   }
-  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);
-  }
-  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}`) && !isAbsolute5(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep2}`) && !isAbsolute6(difference);
 }
 var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   adapterVersion = GROK_BUILD_MANAGED_VERSION;
@@ -29012,8 +29095,8 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
       );
       if (managed.path === agent.path) {
         return Object.freeze({
-          GROK_HOME: await realpath4(
-            join7(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
+          GROK_HOME: await realpath5(
+            join9(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
           )
         });
       }
@@ -29024,9 +29107,9 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
-    const versionRoot = await realpath4(join7(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
-    await validateManagedNpmPackage(join7(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
-    const executable = await resolveExecutablePath(join7(versionRoot, "home", "bin", "grok"), platform);
+    const versionRoot = await realpath5(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);
     signal.throwIfAborted();
     if (executable === null || !isContainedPath2(versionRoot, executable.path)) {
       throw new AgentProbeError("managed_agent_invalid", "The managed Grok Build executable is invalid");
@@ -29126,13 +29209,13 @@ var OhMyPiAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/opencode-agent.ts
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { chmod, copyFile, mkdir as mkdir3, mkdtemp as mkdtemp2, open as open3, realpath as realpath5, rename as rename2, rm as rm2, stat as stat4, writeFile as writeFile2 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname2, isAbsolute as isAbsolute6, join as join8, relative as relative3, sep as sep3 } from "node:path";
+import { chmod, copyFile, mkdir as mkdir3, mkdtemp as mkdtemp2, open as open3, realpath as realpath6, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
+import { delimiter as delimiter2, dirname as dirname2, isAbsolute as isAbsolute7, join as join10, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { fetch } from "undici";
@@ -29238,7 +29321,7 @@ function isRecord5(value) {
 }
 function isContainedPath3(root, candidate) {
   const difference = relative3(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute6(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute7(difference);
 }
 async function hashFile(path3, signal) {
   signal.throwIfAborted();
@@ -29312,16 +29395,16 @@ async function readManifest(path3) {
 }
 async function validateManagedAgentArchive(root, definition, signal) {
   try {
-    const rootPath = await realpath5(root);
-    const rootMetadata = await stat4(rootPath);
+    const rootPath = await realpath6(root);
+    const rootMetadata = await stat5(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(join8(rootPath, "archive.json"));
+    const manifest = await readManifest(join10(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(join8(rootPath, "bin", definition.executableName));
+    const executable = await resolveExecutablePath(join10(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");
     }
@@ -29347,47 +29430,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
@@ -29513,7 +29570,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
     return Object.freeze(environment);
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => await validateManagedAgentArchive(
-    join9(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    join11(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
     openCodeManagedArchive(platform, process.arch),
     signal
   );
@@ -29531,7 +29588,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/pi-agent.ts
-import { join as join10 } from "node:path";
+import { join as join12 } from "node:path";
 import {
   methods as methods4
 } from "@agentclientprotocol/sdk";
@@ -29590,7 +29647,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join10(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+      join12(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
       PI_AGENT_PACKAGE
     );
     signal.throwIfAborted();
@@ -29628,7 +29685,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/workbuddy-agent.ts
-import { isAbsolute as isAbsolute7, join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/agent-installation/workbuddy-managed-package.ts
 var WORKBUDDY_MANAGED_VERSION = "2.146.0";
@@ -29646,15 +29703,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";
@@ -29683,7 +29731,7 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join11(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
+      join13(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
       WORKBUDDY_MANAGED_PACKAGE
     );
     signal.throwIfAborted();
@@ -29691,17 +29739,11 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveInstalledAgentExecutables = async (context) => {
     context.signal.throwIfAborted();
-    if ((context.platform ?? process.platform) !== "darwin") {
-      return [];
-    }
-    const requestedPaths = [join11("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
-    const homeDirectory = context.environment["HOME"];
-    if (homeDirectory !== void 0 && isAbsolute7(homeDirectory)) {
-      requestedPaths.unshift(join11(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);
@@ -30061,10 +30103,10 @@ function isAgentVersionSupported(reportedVersion, minimumSupportedVersion) {
 }
 
 // src/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute8, join as join13 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join15 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -30121,7 +30163,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join12(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
+    const root = join14(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
     try {
       return await this.#npmInstaller.install(
         root,
@@ -30155,7 +30197,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join13(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
+      join15(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
       specification
     );
   } catch {
@@ -30469,10 +30511,10 @@ async function discoverLocalAgentInventory(options) {
 }
 
 // src/config.ts
-import { join as join14, resolve as resolve3 } from "node:path";
+import { join as join16, resolve as resolve3 } from "node:path";
 function loadDefaultWorkspace(environment = process.env) {
   const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = environment;
-  return configuredWorkspace ?? join14(readStateDirectory(environment), "workspace");
+  return configuredWorkspace ?? join16(readStateDirectory(environment), "workspace");
 }
 var DaemonLocalContext = class {
   environment;
@@ -30502,7 +30544,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,
@@ -30513,7 +30555,8 @@ function createDaemonConfig(connection, agents = [], installableAgents = [], loc
     installableAgents,
     localContext,
     reconnectTarget,
-    relayUrl: connection.relayUrl
+    relayUrl: connection.relayUrl,
+    ...resolveAgent === void 0 ? {} : { resolveAgent }
   };
 }
 
@@ -30523,18 +30566,184 @@ import { createHash as createHash9, randomBytes } from "node:crypto";
 import { readFile as readFile3, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
 import { tmpdir } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 
 // src/pairing/pair-local-machine.ts
-import { mkdir as mkdir5, realpath as realpath6, stat as stat5 } from "node:fs/promises";
+import { mkdir as mkdir5, realpath as realpath7, stat as stat6 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
 import { basename, resolve as resolve5 } from "node:path";
+import { fetch as fetch3 } from "undici";
+
+// 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 isRecord6(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 (!isRecord6(value) || !isRecord6(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 createHash2, randomUUID } from "node:crypto";
 import { mkdir as mkdir4, open as open4, readdir as readdir2, rename as rename3, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join15, resolve as resolve4 } from "node:path";
+import { dirname as dirname3, join as join17, 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}$/;
@@ -30598,7 +30807,7 @@ var VerifiedRuntimeConnection = class {
     this.runtimeId = runtimeId;
   }
 };
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -30671,7 +30880,7 @@ function channelIndexFileName(channelId) {
   return `mci_${createHash2("sha256").update(channelId).digest("hex")}.json`;
 }
 function decodeInstallationPointer(value) {
-  if (!isRecord6(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {
+  if (!isRecord7(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {
     throw new RuntimeInstallationStoreError("invalid_installation", "The local installation record is invalid");
   }
   const storedInstallationId = value["installationId"];
@@ -30681,7 +30890,7 @@ function decodeInstallationPointer(value) {
   return { installationId: validateInstallationId(storedInstallationId) };
 }
 function decodeChannelIndex(value) {
-  if (!isRecord6(value) || !hasExactKeys(value, CHANNEL_INDEX_KEYS) || value["version"] !== 1) {
+  if (!isRecord7(value) || !hasExactKeys(value, CHANNEL_INDEX_KEYS) || value["version"] !== 1) {
     throw new RuntimeInstallationStoreError("invalid_connection", "The saved Runtime connection is invalid");
   }
   const applicationId = value["applicationId"];
@@ -30731,7 +30940,7 @@ function decodeVerifiedConnection(value) {
   );
 }
 function decodeConnection(value) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     throw new RuntimeInstallationStoreError("invalid_connection", "The saved Runtime connection is invalid");
   }
   return decodeVerifiedConnection(value);
@@ -30777,7 +30986,7 @@ async function readJsonFile(path3, signal, missingCode) {
 async function writeJsonAtomically(path3, value, signal) {
   signal.throwIfAborted();
   const directory = dirname3(path3);
-  const temporaryPath = join15(directory, `.${randomUUID()}.tmp`);
+  const temporaryPath = join17(directory, `.${randomUUID()}.tmp`);
   try {
     await mkdir4(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -30803,14 +31012,14 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     this.applicationId = applicationId;
     this.installationId = installationId2;
     this.stateDirectory = stateDirectory;
-    this.#channelDirectory = join15(stateDirectory, "channels");
-    this.#connectionDirectory = join15(stateDirectory, "connections");
+    this.#channelDirectory = join17(stateDirectory, "channels");
+    this.#connectionDirectory = join17(stateDirectory, "connections");
   }
   static open = async (options, signal) => {
     signal.throwIfAborted();
     const applicationId = validateApplicationId(options.applicationId);
     const rootDirectory = resolve4(options.stateDirectory);
-    const applicationDirectory = join15(rootDirectory, "installations", applicationId);
+    const applicationDirectory = join17(rootDirectory, "installations", applicationId);
     try {
       await mkdir4(applicationDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -30823,7 +31032,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
       );
     }
     const storedInstallationId = await readOrCreateInstallationId(applicationDirectory, signal);
-    const stateDirectory = join15(applicationDirectory, storedInstallationId);
+    const stateDirectory = join17(applicationDirectory, storedInstallationId);
     try {
       await mkdir4(stateDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -30838,8 +31047,8 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     return new _RuntimeInstallationStore(applicationId, storedInstallationId, stateDirectory);
   };
-  connectionPath = (connectionId2) => join15(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
-  channelIndexPath = (channelId) => join15(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
+  connectionPath = (connectionId2) => join17(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
+  channelIndexPath = (channelId) => join17(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
   readConnection = async (connectionId2, signal) => {
     const stored = decodeConnection(
       await readJsonFile(this.connectionPath(connectionId2), signal, "connection_not_found")
@@ -31001,7 +31210,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
 };
 async function readOrCreateInstallationId(applicationDirectory, signal) {
-  const pointerPath = join15(applicationDirectory, "current.json");
+  const pointerPath = join17(applicationDirectory, "current.json");
   try {
     return decodeInstallationPointer(await readJsonFile(pointerPath, signal, "installation_not_found")).installationId;
   } catch (cause) {
@@ -31049,7 +31258,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys2(value, expectedKeys) {
@@ -31142,8 +31351,8 @@ async function resolveDefaultWorkspace(path3) {
   const requestedWorkspace = resolve5(path3);
   try {
     await mkdir5(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath6(requestedWorkspace);
-    const metadata = await stat5(defaultWorkspace);
+    const defaultWorkspace = await realpath7(requestedWorkspace);
+    const metadata = await stat6(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError("invalid_workspace", "The default workspace is not a directory");
     }
@@ -31172,9 +31381,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord7(value)) {
+  if (isRecord8(value)) {
     const error62 = value["error"];
-    if (isRecord7(error62)) {
+    if (isRecord8(error62)) {
       const code = error62["code"];
       const message = error62["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -31185,7 +31394,7 @@ function readRelayError(value) {
   return new PairingClientError("pairing_failed", "The relay could not pair this machine");
 }
 function decodePairingResponse(value, credentialField, expectedKeys) {
-  if (!isRecord7(value) || !hasExactKeys2(value, expectedKeys)) {
+  if (!isRecord8(value) || !hasExactKeys2(value, expectedKeys)) {
     throw new PairingClientError("invalid_relay_response", "The relay returned an invalid pairing response");
   }
   const appId = value["appId"];
@@ -31210,7 +31419,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,
@@ -31242,20 +31451,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)
   };
 }
@@ -31354,7 +31573,7 @@ var AuditStore = class {
 
 // 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/acp/active-executions.ts
@@ -31445,7 +31664,7 @@ import {
 } from "@agentclientprotocol/sdk";
 
 // src/authorization/local-raster.ts
-import { open as open5, readFile as readFile2, realpath as realpath7, stat as stat6 } from "node:fs/promises";
+import { open as open5, readFile as readFile2, realpath as realpath8, stat as stat7 } from "node:fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute9, normalize as normalize2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
@@ -31516,7 +31735,7 @@ async function resolveCanonicalPath(requested, signal) {
     return null;
   }
   try {
-    const target = await realpath7(requested);
+    const target = await realpath8(requested);
     signal.throwIfAborted();
     if (!isAbsolute9(target) || normalize2(target) !== target) {
       return null;
@@ -31564,7 +31783,7 @@ async function readLocalRaster(uri, signal) {
   if (target === null) {
     return null;
   }
-  const targetMetadata = await stat6(target);
+  const targetMetadata = await stat7(target);
   signal.throwIfAborted();
   if (!targetMetadata.isFile() || targetMetadata.size < 1 || targetMetadata.size > MAX_LOCAL_RASTER_BYTES) {
     return null;
@@ -31743,7 +31962,7 @@ async function replaceImageMarkers(text2, replace) {
 
 // src/acp/activity-content.ts
 var TRUNCATION_MARKER = "\n\u2026 output truncated by Mobius";
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function truncate3(value, maximumLength) {
@@ -31927,16 +32146,16 @@ async function normalizeToolContent(content, prepareContent) {
   return normalized;
 }
 function rawMcpToolContent(rawOutput) {
-  if (!isRecord8(rawOutput)) {
+  if (!isRecord9(rawOutput)) {
     return [];
   }
-  const result = isRecord8(rawOutput["result"]) ? rawOutput["result"] : rawOutput;
+  const result = isRecord9(rawOutput["result"]) ? rawOutput["result"] : rawOutput;
   const content = result["content"];
   if (!Array.isArray(content)) {
     return [];
   }
   return content.flatMap((item) => {
-    if (!isRecord8(item) || item["type"] !== "image" || typeof item["data"] !== "string" || typeof item["mimeType"] !== "string") {
+    if (!isRecord9(item) || item["type"] !== "image" || typeof item["data"] !== "string" || typeof item["mimeType"] !== "string") {
       return [];
     }
     const uri = item["uri"];
@@ -32013,7 +32232,7 @@ function contentPhase(content) {
     return "";
   }
   const codex = metadata["codex"];
-  if (!isRecord8(codex)) {
+  if (!isRecord9(codex)) {
     return "";
   }
   const phase = codex["phase"];
@@ -32720,7 +32939,7 @@ var SessionConfigProtocolError = class extends Error {
     this.name = "SessionConfigProtocolError";
   }
 };
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString3(value, fallback = "") {
@@ -32751,7 +32970,7 @@ function normalizeConfigValues(value) {
   }
   const normalized = [];
   for (const entry of value) {
-    if (!isRecord9(entry)) {
+    if (!isRecord10(entry)) {
       continue;
     }
     const groupedOptions = entry["options"];
@@ -32759,7 +32978,7 @@ function normalizeConfigValues(value) {
       const groupId = readString3(entry["group"]);
       const groupName = readString3(entry["name"]);
       for (const groupedOption of groupedOptions) {
-        if (isRecord9(groupedOption)) {
+        if (isRecord10(groupedOption)) {
           const normalizedValue = normalizeConfigValue(groupedOption, groupId, groupName);
           if (normalizedValue !== void 0) {
             normalized.push(normalizedValue);
@@ -32779,7 +32998,7 @@ function normalizeConfigOptions(value, modes) {
   const normalized = [];
   if (Array.isArray(value)) {
     for (const option of value) {
-      if (!isRecord9(option)) {
+      if (!isRecord10(option)) {
         continue;
       }
       const id = truncate4(readString3(option["id"]), 128);
@@ -32819,12 +33038,12 @@ function normalizeConfigOptions(value, modes) {
       }
     }
   }
-  if (isRecord9(modes)) {
+  if (isRecord10(modes)) {
     const values = [];
     const availableModes = modes["availableModes"];
     if (Array.isArray(availableModes)) {
       for (const mode of availableModes) {
-        if (!isRecord9(mode)) {
+        if (!isRecord10(mode)) {
           continue;
         }
         const id = truncate4(readString3(mode["id"]), 500);
@@ -32857,7 +33076,7 @@ function normalizeConfigOptions(value, modes) {
   return normalized.slice(0, MAXIMUM_CONFIG_OPTIONS);
 }
 function normalizeStandardLifecycle(response) {
-  const lifecycle = isRecord9(response) ? response : {};
+  const lifecycle = isRecord10(response) ? response : {};
   return normalizeConfigOptions(lifecycle["configOptions"], lifecycle["modes"]);
 }
 function replaceStandardConfigOptions(current, value) {
@@ -32899,7 +33118,7 @@ var StandardSessionConfigProtocol = class {
       "ACP agent exited while changing session configuration",
       change.signal
     );
-    if (!isRecord9(response) || !Array.isArray(response["configOptions"])) {
+    if (!isRecord10(response) || !Array.isArray(response["configOptions"])) {
       throw new SessionConfigProtocolError("The Agent returned an invalid session configuration response");
     }
     return replaceStandardConfigOptions(current, response["configOptions"]);
@@ -34312,7 +34531,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   _sql.raw = raw;
-  function join21(chunks, separator) {
+  function join23(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) result.push(separator);
@@ -34320,7 +34539,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  _sql.join = join21;
+  _sql.join = join23;
   function identifier2(value) {
     return new Name(value);
   }
@@ -36465,7 +36684,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((join21) => join21.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins?.some((join23) => join23.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)) {
@@ -37304,7 +37523,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, join21]) => {
+      return sql.join(withEntries.map(([k, join23]) => {
         const relation = tableConfig.relations[k];
         const isSingle2 = is(relation, One);
         const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -37315,7 +37534,7 @@ var SQLiteDialect = class {
           table: targetTable,
           mode: isSingle2 ? "first" : "many",
           schema,
-          queryConfig: join21,
+          queryConfig: join23,
           tableConfig: schema[relation.targetTableName],
           relationWhere: filter,
           isNested: true,
@@ -37329,7 +37548,7 @@ var SQLiteDialect = class {
           key: k,
           selection: innerQuery.selection,
           isArray: !isSingle2,
-          isOptional: (relation.optional ?? false) || join21 !== true && !!join21.where
+          isOptional: (relation.optional ?? false) || join23 !== true && !!join23.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)}`;
@@ -37945,7 +38164,7 @@ var SQLiteUpdateBase = class {
   createJoin(joinType) {
     return ((table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join21) => join21.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins.some((join23) => join23.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({
@@ -39351,7 +39570,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);
@@ -39365,7 +39584,7 @@ var AgentSession = class _AgentSession {
           this.#cwd,
           this.#additionalDirectories,
           true,
-          ""
+          origin.title
         )
       ) : this.#store.read(this.#mobiusSessionId)
     );
@@ -40393,7 +40612,7 @@ var toolImageSchema = external_exports.union([
     file: external_exports.object({ base64: external_exports.string(), type: external_exports.string() })
   }).transform(({ file: file2 }) => ({ type: "image", data: file2.base64, mimeType: file2.type }))
 ]);
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var AcpContentExternalizer = class {
@@ -40509,13 +40728,13 @@ var AcpContentExternalizer = class {
       }
       return result2;
     }
-    if (!isRecord10(value)) {
+    if (!isRecord11(value)) {
       return value;
     }
     const image = toolImageSchema.safeParse(value);
     if (image.success && image.data.data.length > 0) {
       const prepared = await this.#content(sessionId, image.data, signal);
-      if (isRecord10(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+      if (isRecord11(prepared.event) && typeof prepared.event["imageKey"] === "string") {
         images.set(prepared.event["imageKey"], prepared);
       } else {
         images.set(`unavailable:${images.size}`, prepared);
@@ -40546,7 +40765,7 @@ var AcpContentExternalizer = class {
       const prepared = await this.#content(sessionId, content, signal);
       agentContent.push({ ...item, content: prepared.agent });
       eventContent.push({ ...item, content: prepared.event });
-      if (isRecord10(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+      if (isRecord11(prepared.event) && typeof prepared.event["imageKey"] === "string") {
         images.delete(prepared.event["imageKey"]);
       }
     }
@@ -40604,8 +40823,8 @@ var AcpContentExternalizer = class {
 
 // src/external-content/local-external-content-store.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
-import { lstat, mkdir as mkdir6, readdir as readdir3, realpath as realpath8, rename as rename4, rm as rm3, stat as stat7, utimes, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname4, join as join16 } from "node:path";
+import { lstat, mkdir as mkdir6, readdir as readdir3, realpath as realpath9, rename as rename4, rm as rm3, stat as stat8, utimes, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname4, join as join18 } 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({
@@ -40641,7 +40860,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join16(stateDirectory, "tmp", "session-content", randomUUID3());
+    this.#root = join18(stateDirectory, "tmp", "session-content", randomUUID3());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -40656,11 +40875,11 @@ var LocalExternalContentStore = class {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path3 = join16(dirname4(this.#root), directory.name);
+        const path3 = join18(dirname4(this.#root), directory.name);
         if (path3 === this.#root) {
           continue;
         }
-        const modified = await stat7(path3).then(
+        const modified = await stat8(path3).then(
           (entry) => entry.mtimeMs,
           () => Date.now()
         );
@@ -40706,10 +40925,10 @@ var LocalExternalContentStore = class {
     }
     await this.#expire();
     active.throwIfAborted();
-    const directory = join16(this.#root, kind);
+    const directory = join18(this.#root, kind);
     await mkdir6(directory, { mode: 448, recursive: true });
     active.throwIfAborted();
-    const path3 = join16(directory, key);
+    const path3 = join18(directory, key);
     const write = atomicWrite(path3, bytes, active);
     await write;
     active.throwIfAborted();
@@ -40742,8 +40961,8 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath8(dirname4(entry.path)),
-        realpath8(entry.path),
+        realpath9(dirname4(entry.path)),
+        realpath9(entry.path),
         lstat(entry.path)
       ]);
       signal.throwIfAborted();
@@ -41181,7 +41400,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,
@@ -41784,117 +42003,6 @@ var AgentRuntimeManager = class {
   });
 };
 
-// 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 {
@@ -42357,9 +42465,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";
 
 // src/authorization/local-authorization-error.ts
 var LocalAuthorizationError = class extends Error {
@@ -42438,9 +42546,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");
@@ -42488,7 +42596,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path3 = await this.resolvePath(join17(target, child2.name), signal);
+          const path3 = await this.resolvePath(join19(target, child2.name), signal);
           entries.push({ directoryId: encodePath(path3), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -42524,15 +42632,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.
@@ -44477,9 +44585,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
@@ -44657,7 +44766,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 = {
@@ -45258,7 +45367,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: [],
@@ -45652,7 +45762,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;
@@ -45680,7 +45790,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 {
@@ -45694,7 +45804,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");
@@ -45722,7 +45832,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");
@@ -45766,6 +45876,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;
@@ -45784,7 +46120,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
@@ -45860,7 +46196,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
@@ -46152,7 +46488,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");
@@ -46297,228 +46633,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) {
@@ -47711,11 +47825,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();
@@ -47982,7 +48096,7 @@ var START_TIMEOUT_MILLISECONDS = 12e4;
 var MAXIMUM_MESSAGE_BYTES = 64 * 1024;
 var CONNECTION_ID_PATTERN2 = /^mcn_[a-f0-9]{32}$/;
 async function acquireManagerLock(stateDirectory) {
-  const path3 = join20(stateDirectory, "manager.lock");
+  const path3 = join22(stateDirectory, "manager.lock");
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
       await writeFile5(path3, `${process.pid.toString()}
@@ -48014,10 +48128,10 @@ function isRecord12(value) {
 }
 function controlSocketPath(stateDirectory) {
   const installationHash = createHash9("sha256").update(stateDirectory).digest("hex").slice(0, 32);
-  return process.platform === "win32" ? `\\\\.\\pipe\\mobius-${installationHash}` : join20(tmpdir(), `mobius-${installationHash}.sock`);
+  return process.platform === "win32" ? `\\\\.\\pipe\\mobius-${installationHash}` : join22(tmpdir(), `mobius-${installationHash}.sock`);
 }
 function controlTokenPath(stateDirectory) {
-  return join20(stateDirectory, "manager.token");
+  return join22(stateDirectory, "manager.token");
 }
 async function readOrCreateControlToken(stateDirectory) {
   const path3 = controlTokenPath(stateDirectory);
@@ -48349,7 +48463,7 @@ async function waitForManagerExit(stateDirectory, signal) {
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(1e4)]);
   while (!deadline.aborted) {
     try {
-      await readFile3(join20(stateDirectory, "manager.lock"), "utf8");
+      await readFile3(join22(stateDirectory, "manager.lock"), "utf8");
     } catch (cause) {
       if (isNodeError2(cause, "ENOENT")) {
         return;
@@ -48586,7 +48700,7 @@ async function writePairList(path3, pairs) {
   shutdown.signal.throwIfAborted();
   let file2;
   try {
-    file2 = await open6(path3, constants2.O_WRONLY | constants2.O_NOFOLLOW);
+    file2 = await open6(path3, constants3.O_WRONLY | constants3.O_NOFOLLOW);
   } catch (cause) {
     if (typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT") {
       throw new Error("The JSON output file does not exist", { cause });