@moxt-ai/mobius 0.0.193 → 0.0.195

package/dist/runtime.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/runtime.ts
-import { mkdir as mkdir7, realpath as realpath11, stat as stat10 } from "node:fs/promises";
+import { mkdir as mkdir7, realpath as realpath12, stat as stat11 } from "node:fs/promises";
 import { resolve as resolve8 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
@@ -21327,6 +21327,7 @@ var provenanceSchema = external_exports.discriminatedUnion("kind", [
 ]);
 var sessionEventFieldsV2 = {
   eventId: identifierStringSchema,
+  mobiusMetadata: external_exports.object({ omitted: external_exports.literal(true).optional() }).readonly().optional(),
   position: positionSchema,
   provenance: provenanceSchema,
   recordedAt: external_exports.iso.datetime({ offset: true }),
@@ -21393,7 +21394,12 @@ var sessionEventLogPageV2Schema = external_exports.object({
   truncated: external_exports.boolean(),
   version: external_exports.literal(2)
 }).readonly();
-var nativeEventPageRequestV2Schema = external_exports.object({ cursor: external_exports.string().min(1).max(512).nullable(), eventLimit: external_exports.number().int().min(1).max(1e4) }).readonly();
+var sessionEventOmissionV2Schema = external_exports.literal("agent-reasoning");
+var nativeEventPageRequestV2Schema = external_exports.object({
+  cursor: external_exports.string().min(1).max(512).nullable(),
+  eventLimit: external_exports.number().int().min(1).max(1e4),
+  omit: external_exports.array(sessionEventOmissionV2Schema).max(1).readonly().optional()
+}).readonly();
 var queuedPromptRequestEventLogV2Schema = external_exports.object({
   commandId: identifierStringSchema,
   content: external_exports.array(contentBlockV2Schema).min(1).max(100).readonly(),
@@ -21440,6 +21446,7 @@ var directoryIdentifier = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-
 var pageRequestFields = {
   cursor: external_exports.string().min(1).max(512).nullable(),
   eventLimit: external_exports.number().int().min(1).max(1e4),
+  omit: external_exports.array(sessionEventOmissionV2Schema).max(1).readonly().optional(),
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
 };
@@ -21796,15 +21803,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;
@@ -21863,13 +22121,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(
@@ -21894,7 +22152,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;
@@ -21915,128 +22173,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]);
@@ -22073,11 +22211,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);
 }
@@ -22105,36 +22241,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) {
@@ -22620,8 +22735,8 @@ var LocalAgentInventory = class {
 };
 
 // src/agent-installation/managed-npm-package.ts
-import { mkdir, mkdtemp, open as open2, 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 as open2, 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;
@@ -22672,11 +22787,11 @@ function isRecord3(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(path2, maximumBytes) {
   try {
@@ -22777,14 +22892,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",
@@ -22806,15 +22921,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",
@@ -22822,14 +22937,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",
@@ -22842,7 +22957,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);
       }
@@ -22853,7 +22968,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) {
@@ -22879,9 +22994,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",
@@ -22903,8 +23018,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 {
@@ -22940,7 +23055,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) {
@@ -22963,7 +23078,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();
@@ -23167,7 +23282,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";
 var boundedText = (maximum) => external_exports.string().max(maximum);
 var jsonValue = external_exports.lazy(() => external_exports.unknown());
 var requestIdSchema = external_exports.union([external_exports.number(), external_exports.string()]).refine((value) => typeof value === "number" || value.length <= 256);
@@ -23238,7 +23353,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),
@@ -25104,15 +25219,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];
 }
@@ -25201,8 +25316,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 {
@@ -25220,13 +25335,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
@@ -25237,20 +25352,20 @@ var DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH = `# Managed by Mobius: pin the ACP brid
     model: deepseek-v4-flash-vision-exp
 `;
 async function prepareAgentHome(path2, imagePrompts) {
-  if (!isAbsolute4(path2) || normalize(path2) !== path2) {
+  if (!isAbsolute5(path2) || normalize(path2) !== path2) {
     throw new AgentProbeError("agent_environment_invalid", "The configured Agent home is invalid");
   }
   try {
     if (imagePrompts) {
       await mkdir2(path2, { mode: 448, recursive: true });
     }
-    const resolved = await realpath3(path2);
-    const metadata = await stat3(resolved);
+    const resolved = await realpath4(path2);
+    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
       });
     }
@@ -25298,7 +25413,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 {
@@ -25314,7 +25429,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();
@@ -25368,8 +25483,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";
@@ -25392,50 +25507,25 @@ var GrokBuildManagedPackage = class extends SriManagedNpmPackageDefinition {
     this.requiredDependencies = Object.freeze([requiredDependency]);
   }
 };
-var GROK_DARWIN_ARM64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-darwin-arm64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-I4pKZGnR6Mv4MJOJsB9B/i2o0ODF4eZtp4jHN5feoTqKIeAUVg38OzBtE8aN/wZa7Xg+qhnf6Jd1tcAFvMoFtQ==",
-  "https://registry.npmjs.org/@xai-official/grok-darwin-arm64/-/grok-darwin-arm64-1.0.21.tgz"
-);
-var GROK_DARWIN_X64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-darwin-x64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-h0nFj3NZ9Kz8w6fQ6UDxxeSIhC1WjwwoRE92iNbG//tZy6YGkppR3s7oRVtt4Xl0CJANKUt0EusyIYnnAvKLzw==",
-  "https://registry.npmjs.org/@xai-official/grok-darwin-x64/-/grok-darwin-x64-1.0.21.tgz"
-);
-var GROK_LINUX_ARM64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-linux-arm64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-Jlwz9XtZPNKz/V/ydifC8OVu3hIZz7pmoStt8c4KCqkSWjWiZ/PBIC0iJiq8rvByhx5Z0EdSyq8ZXVwtocceGA==",
-  "https://registry.npmjs.org/@xai-official/grok-linux-arm64/-/grok-linux-arm64-1.0.21.tgz"
-);
-var GROK_LINUX_X64_PACKAGE = new SriManagedNpmDependencyDefinition(
-  "@xai-official/grok-linux-x64",
-  GROK_BUILD_MANAGED_VERSION,
-  "sha512-AjDV5ifEz5LFG2Jt5IlhAeEkJati/wOvCchVbR4eIj2ogjvmXoXlzBrYRXuAJpXBy5q0se/Yuez5FxDU9Ju81w==",
-  "https://registry.npmjs.org/@xai-official/grok-linux-x64/-/grok-linux-x64-1.0.21.tgz"
-);
 function grokBuildManagedPackage(platform, architecture) {
-  if (platform === "darwin" && architecture === "arm64") {
-    return new GrokBuildManagedPackage(GROK_DARWIN_ARM64_PACKAGE);
-  }
-  if (platform === "darwin" && architecture === "x64") {
-    return new GrokBuildManagedPackage(GROK_DARWIN_X64_PACKAGE);
-  }
-  if (platform === "linux" && architecture === "arm64") {
-    return new GrokBuildManagedPackage(GROK_LINUX_ARM64_PACKAGE);
+  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 === "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;
@@ -25464,8 +25554,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")
           )
         });
       }
@@ -25476,9 +25566,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");
@@ -25578,13 +25668,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";
@@ -25690,7 +25780,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(path2, signal) {
   signal.throwIfAborted();
@@ -25764,16 +25854,16 @@ async function readManifest(path2) {
 }
 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");
     }
@@ -25799,47 +25889,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
@@ -25965,7 +26029,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
   );
@@ -25983,7 +26047,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";
@@ -26042,7 +26106,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();
@@ -26080,7 +26144,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";
@@ -26098,15 +26162,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";
@@ -26135,7 +26190,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();
@@ -26143,17 +26198,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);
@@ -26513,10 +26562,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 = {}) {
@@ -26573,7 +26622,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,
@@ -26607,7 +26656,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 {
@@ -26920,28 +26969,122 @@ async function discoverLocalAgentInventory(options) {
   return new LocalAgentInventory(results);
 }
 
-// src/audit/audit-store.ts
-var MAX_AUDIT_RECORDS = 1024;
-var AuditStore = class {
-  #records = [];
-  record = (record2) => {
-    if (this.#records.length === MAX_AUDIT_RECORDS) {
-      this.#records.shift();
+// 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
     }
-    this.#records.push(
-      record2.details === void 0 ? { ...record2 } : { ...record2, details: { ...record2.details } }
+  );
+}
+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 }
     );
-  };
-  close = () => {
-    this.#records.length = 0;
-  };
-};
+  }
+  if (!response.ok) {
+    throw await rejectedCatalogError(response);
+  }
+  await response.body?.cancel();
+}
 
 // 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;
@@ -26971,7 +27114,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,
@@ -26982,13 +27125,86 @@ function createDaemonConfig(connection, agents = [], installableAgents = [], loc
     installableAgents,
     localContext,
     reconnectTarget,
-    relayUrl: connection.relayUrl
+    relayUrl: connection.relayUrl,
+    ...resolveAgent === void 0 ? {} : { resolveAgent }
   };
 }
 
+// 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/audit/audit-store.ts
+var MAX_AUDIT_RECORDS = 1024;
+var AuditStore = class {
+  #records = [];
+  record = (record2) => {
+    if (this.#records.length === MAX_AUDIT_RECORDS) {
+      this.#records.shift();
+    }
+    this.#records.push(
+      record2.details === void 0 ? { ...record2 } : { ...record2, details: { ...record2.details } }
+    );
+  };
+  close = () => {
+    this.#records.length = 0;
+  };
+};
+
 // src/run-daemon.ts
 import { createHash as createHash7, randomUUID as randomUUID8 } from "node:crypto";
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 import { styleText } from "node:util";
 
 // src/acp/active-executions.ts
@@ -27079,7 +27295,7 @@ import {
 } from "@agentclientprotocol/sdk";
 
 // src/authorization/local-raster.ts
-import { open as open4, readFile as readFile2, realpath as realpath6, stat as stat5 } from "node:fs/promises";
+import { open as open4, readFile as readFile2, realpath as realpath7, stat as stat6 } from "node:fs/promises";
 import { basename, isAbsolute as isAbsolute9, normalize as normalize2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
@@ -27150,7 +27366,7 @@ async function resolveCanonicalPath(requested, signal) {
     return null;
   }
   try {
-    const target = await realpath6(requested);
+    const target = await realpath7(requested);
     signal.throwIfAborted();
     if (!isAbsolute9(target) || normalize2(target) !== target) {
       return null;
@@ -27198,7 +27414,7 @@ async function readLocalRaster(uri, signal) {
   if (target === null) {
     return null;
   }
-  const targetMetadata = await stat5(target);
+  const targetMetadata = await stat6(target);
   signal.throwIfAborted();
   if (!targetMetadata.isFile() || targetMetadata.size < 1 || targetMetadata.size > MAX_LOCAL_RASTER_BYTES) {
     return null;
@@ -27377,7 +27593,7 @@ async function replaceImageMarkers(text2, replace) {
 
 // src/acp/activity-content.ts
 var TRUNCATION_MARKER = "\n\u2026 output truncated by Mobius";
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function truncate3(value, maximumLength) {
@@ -27561,16 +27777,16 @@ async function normalizeToolContent(content, prepareContent) {
   return normalized;
 }
 function rawMcpToolContent(rawOutput) {
-  if (!isRecord6(rawOutput)) {
+  if (!isRecord7(rawOutput)) {
     return [];
   }
-  const result = isRecord6(rawOutput["result"]) ? rawOutput["result"] : rawOutput;
+  const result = isRecord7(rawOutput["result"]) ? rawOutput["result"] : rawOutput;
   const content = result["content"];
   if (!Array.isArray(content)) {
     return [];
   }
   return content.flatMap((item) => {
-    if (!isRecord6(item) || item["type"] !== "image" || typeof item["data"] !== "string" || typeof item["mimeType"] !== "string") {
+    if (!isRecord7(item) || item["type"] !== "image" || typeof item["data"] !== "string" || typeof item["mimeType"] !== "string") {
       return [];
     }
     const uri = item["uri"];
@@ -27647,7 +27863,7 @@ function contentPhase(content) {
     return "";
   }
   const codex = metadata["codex"];
-  if (!isRecord6(codex)) {
+  if (!isRecord7(codex)) {
     return "";
   }
   const phase = codex["phase"];
@@ -28354,7 +28570,7 @@ var SessionConfigProtocolError = class extends Error {
     this.name = "SessionConfigProtocolError";
   }
 };
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString3(value, fallback = "") {
@@ -28385,7 +28601,7 @@ function normalizeConfigValues(value) {
   }
   const normalized = [];
   for (const entry of value) {
-    if (!isRecord7(entry)) {
+    if (!isRecord8(entry)) {
       continue;
     }
     const groupedOptions = entry["options"];
@@ -28393,7 +28609,7 @@ function normalizeConfigValues(value) {
       const groupId = readString3(entry["group"]);
       const groupName = readString3(entry["name"]);
       for (const groupedOption of groupedOptions) {
-        if (isRecord7(groupedOption)) {
+        if (isRecord8(groupedOption)) {
           const normalizedValue = normalizeConfigValue(groupedOption, groupId, groupName);
           if (normalizedValue !== void 0) {
             normalized.push(normalizedValue);
@@ -28413,7 +28629,7 @@ function normalizeConfigOptions(value, modes) {
   const normalized = [];
   if (Array.isArray(value)) {
     for (const option of value) {
-      if (!isRecord7(option)) {
+      if (!isRecord8(option)) {
         continue;
       }
       const id = truncate4(readString3(option["id"]), 128);
@@ -28453,12 +28669,12 @@ function normalizeConfigOptions(value, modes) {
       }
     }
   }
-  if (isRecord7(modes)) {
+  if (isRecord8(modes)) {
     const values = [];
     const availableModes = modes["availableModes"];
     if (Array.isArray(availableModes)) {
       for (const mode of availableModes) {
-        if (!isRecord7(mode)) {
+        if (!isRecord8(mode)) {
           continue;
         }
         const id = truncate4(readString3(mode["id"]), 500);
@@ -28491,7 +28707,7 @@ function normalizeConfigOptions(value, modes) {
   return normalized.slice(0, MAXIMUM_CONFIG_OPTIONS);
 }
 function normalizeStandardLifecycle(response) {
-  const lifecycle = isRecord7(response) ? response : {};
+  const lifecycle = isRecord8(response) ? response : {};
   return normalizeConfigOptions(lifecycle["configOptions"], lifecycle["modes"]);
 }
 function replaceStandardConfigOptions(current, value) {
@@ -28533,7 +28749,7 @@ var StandardSessionConfigProtocol = class {
       "ACP agent exited while changing session configuration",
       change.signal
     );
-    if (!isRecord7(response) || !Array.isArray(response["configOptions"])) {
+    if (!isRecord8(response) || !Array.isArray(response["configOptions"])) {
       throw new SessionConfigProtocolError("The Agent returned an invalid session configuration response");
     }
     return replaceStandardConfigOptions(current, response["configOptions"]);
@@ -29946,7 +30162,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   _sql.raw = raw;
-  function join20(chunks, separator) {
+  function join22(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) result.push(separator);
@@ -29954,7 +30170,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  _sql.join = join20;
+  _sql.join = join22;
   function identifier2(value) {
     return new Name(value);
   }
@@ -32099,7 +32315,7 @@ var SQLiteSelectBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join20) => join20.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins?.some((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       if (!this.isPartialSelect) {
         if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
         if (typeof tableName === "string" && !is(table, SQL)) {
@@ -32938,7 +33154,7 @@ var SQLiteDialect = class {
       if (!joins2) return;
       const withEntries = Object.entries(joins2).filter(([_, v]) => v);
       if (!withEntries.length) return;
-      return sql.join(withEntries.map(([k, join20]) => {
+      return sql.join(withEntries.map(([k, join22]) => {
         const relation = tableConfig.relations[k];
         const isSingle2 = is(relation, One);
         const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -32949,7 +33165,7 @@ var SQLiteDialect = class {
           table: targetTable,
           mode: isSingle2 ? "first" : "many",
           schema,
-          queryConfig: join20,
+          queryConfig: join22,
           tableConfig: schema[relation.targetTableName],
           relationWhere: filter,
           isNested: true,
@@ -32963,7 +33179,7 @@ var SQLiteDialect = class {
           key: k,
           selection: innerQuery.selection,
           isArray: !isSingle2,
-          isOptional: (relation.optional ?? false) || join20 !== true && !!join20.where
+          isOptional: (relation.optional ?? false) || join22 !== true && !!join22.where
         });
         const jsonColumns = sql.join(innerQuery.selection.map((s) => {
           return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -33579,7 +33795,7 @@ var SQLiteUpdateBase = class {
   createJoin(joinType) {
     return ((table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join20) => join20.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins.some((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       if (typeof on === "function") {
         const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
         on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -34985,7 +35201,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);
@@ -34999,7 +35215,7 @@ var AgentSession = class _AgentSession {
           this.#cwd,
           this.#additionalDirectories,
           true,
-          ""
+          origin.title
         )
       ) : this.#store.read(this.#mobiusSessionId)
     );
@@ -36027,7 +36243,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 isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var AcpContentExternalizer = class {
@@ -36143,13 +36359,13 @@ var AcpContentExternalizer = class {
       }
       return result2;
     }
-    if (!isRecord8(value)) {
+    if (!isRecord9(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 (isRecord8(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+      if (isRecord9(prepared.event) && typeof prepared.event["imageKey"] === "string") {
         images.set(prepared.event["imageKey"], prepared);
       } else {
         images.set(`unavailable:${images.size}`, prepared);
@@ -36180,7 +36396,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 (isRecord8(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+      if (isRecord9(prepared.event) && typeof prepared.event["imageKey"] === "string") {
         images.delete(prepared.event["imageKey"]);
       }
     }
@@ -36238,8 +36454,8 @@ var AcpContentExternalizer = class {
 
 // src/external-content/local-external-content-store.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, mkdir as mkdir4, readdir as readdir2, realpath as realpath7, rename as rename3, rm as rm3, stat as stat6, utimes, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join15 } from "node:path";
+import { lstat, mkdir as mkdir4, readdir as readdir2, realpath as realpath8, rename as rename3, rm as rm3, stat as stat7, utimes, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, join as join17 } 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({
@@ -36275,7 +36491,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join15(stateDirectory, "tmp", "session-content", randomUUID2());
+    this.#root = join17(stateDirectory, "tmp", "session-content", randomUUID2());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -36290,11 +36506,11 @@ var LocalExternalContentStore = class {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path2 = join15(dirname3(this.#root), directory.name);
+        const path2 = join17(dirname3(this.#root), directory.name);
         if (path2 === this.#root) {
           continue;
         }
-        const modified = await stat6(path2).then(
+        const modified = await stat7(path2).then(
           (entry) => entry.mtimeMs,
           () => Date.now()
         );
@@ -36340,10 +36556,10 @@ var LocalExternalContentStore = class {
     }
     await this.#expire();
     active.throwIfAborted();
-    const directory = join15(this.#root, kind);
+    const directory = join17(this.#root, kind);
     await mkdir4(directory, { mode: 448, recursive: true });
     active.throwIfAborted();
-    const path2 = join15(directory, key);
+    const path2 = join17(directory, key);
     const write = atomicWrite(path2, bytes, active);
     await write;
     active.throwIfAborted();
@@ -36376,8 +36592,8 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath7(dirname3(entry.path)),
-        realpath7(entry.path),
+        realpath8(dirname3(entry.path)),
+        realpath8(entry.path),
         lstat(entry.path)
       ]);
       signal.throwIfAborted();
@@ -36815,7 +37031,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,
@@ -37418,117 +37634,6 @@ var AgentRuntimeManager = class {
   });
 };
 
-// src/agent-catalog/publish-agent-catalog.ts
-import { fetch as fetch2 } from "undici";
-
-// src/relay-connection/runtime-authentication.ts
-function runtimeCredential(relayUrl) {
-  return relayUrl.searchParams.get("token") ?? "";
-}
-function runtimeAuthorization(relayUrl) {
-  const credential = runtimeCredential(relayUrl);
-  return credential.length === 0 ? {} : { authorization: `Bearer ${credential}` };
-}
-function relayHttpEndpoint(relayUrl) {
-  const endpoint = new URL(relayUrl);
-  endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
-  endpoint.search = "";
-  return endpoint;
-}
-
-// src/agent-catalog/publish-agent-catalog.ts
-var CATALOG_UPDATE_TIMEOUT_MILLISECONDS = 2e4;
-var AgentCatalogPublishError = class extends Error {
-  code = "agent_catalog_update_failed";
-  diagnosticDetails;
-  constructor(message, options = {}, diagnosticDetails = {}) {
-    super(message, options);
-    this.diagnosticDetails = diagnosticDetails;
-    this.name = "AgentCatalogPublishError";
-  }
-};
-function isRecord9(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isSafeRelayErrorMessage(value) {
-  return value.length > 0 && value.length <= 512 && Array.from(value).every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127);
-}
-async function rejectedCatalogError(response) {
-  let value;
-  try {
-    value = await response.json();
-  } catch {
-    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
-  }
-  if (!isRecord9(value) || !isRecord9(value["error"])) {
-    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
-  }
-  const code = value["error"]["code"];
-  const message = value["error"]["message"];
-  if (typeof code !== "string" || !/^[a-z][a-z0-9_]{0,63}$/.test(code) || typeof message !== "string" || !isSafeRelayErrorMessage(message)) {
-    return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
-  }
-  return new AgentCatalogPublishError(
-    `The Relay rejected the Agent catalog update (${code}): ${message}`,
-    {},
-    {
-      relayErrorCode: code
-    }
-  );
-}
-function catalogEndpoint(config2) {
-  const endpoint = relayHttpEndpoint(config2.relayUrl);
-  if (endpoint.pathname.endsWith("/daemon")) {
-    endpoint.pathname = `${endpoint.pathname.slice(0, -"/daemon".length)}/catalog`;
-    return endpoint;
-  }
-  const runtimePath = "/v1/runtimes/connect";
-  if (endpoint.pathname.endsWith(runtimePath)) {
-    endpoint.pathname = `${endpoint.pathname.slice(0, -runtimePath.length)}/channels/${encodeURIComponent(config2.channelId)}/catalog`;
-    return endpoint;
-  }
-  throw new AgentCatalogPublishError("The Relay URL is invalid");
-}
-async function publishAgentCatalog(config2, signal) {
-  signal.throwIfAborted();
-  const timeoutSignal = AbortSignal.timeout(CATALOG_UPDATE_TIMEOUT_MILLISECONDS);
-  const requestSignal = AbortSignal.any([signal, timeoutSignal]);
-  let response;
-  const catalog = config2.catalog.read();
-  try {
-    response = await fetch2(catalogEndpoint(config2), {
-      body: JSON.stringify({
-        agents: catalog.agents.map((agent) => ({
-          agentPath: agent.agentIdentity.requestedPath,
-          agentVersion: agent.agentVersion,
-          agentSettingsDiscovery: true,
-          capabilities: agent.capabilities,
-          id: agent.id,
-          label: agent.label,
-          sessionTurnConfiguration: true
-        })),
-        installableAgents: catalog.installableAgents
-      }),
-      dispatcher: environmentProxyDispatcher,
-      headers: { ...runtimeAuthorization(config2.relayUrl), "content-type": "application/json" },
-      method: "PUT",
-      signal: requestSignal
-    });
-  } catch (error62) {
-    if (signal.aborted) {
-      signal.throwIfAborted();
-    }
-    throw new AgentCatalogPublishError(
-      timeoutSignal.aborted ? "The Agent catalog update timed out" : "The Agent catalog could not be updated",
-      { cause: error62 }
-    );
-  }
-  if (!response.ok) {
-    throw await rejectedCatalogError(response);
-  }
-  await response.body?.cancel();
-}
-
 // src/agent-installation/agent-installation-manager.ts
 var INSTALLATION_DEADLINE_MILLISECONDS = 10 * 60 * 1e3;
 var AgentInstallation = class {
@@ -37991,9 +38096,9 @@ var FixedInstallationExecutor = class {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir as readdir3, realpath as realpath8, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir3, realpath as realpath9, stat as stat8 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute10, join as join16, normalize as normalize3, relative as relative4 } from "node:path";
+import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute10, join as join18, normalize as normalize3, relative as relative4 } from "node:path";
 
 // src/authorization/local-authorization-error.ts
 var LocalAuthorizationError = class extends Error {
@@ -38072,9 +38177,9 @@ var WorkspaceDirectoryService = class {
       throw new LocalAuthorizationError("The local directory path is invalid");
     }
     try {
-      const target = await realpath8(requested);
+      const target = await realpath9(requested);
       signal.throwIfAborted();
-      const metadata = await stat7(target);
+      const metadata = await stat8(target);
       signal.throwIfAborted();
       if (!isAbsolute10(target) || normalize3(target) !== target || !metadata.isDirectory()) {
         throw new LocalAuthorizationError("The selected location is not a directory");
@@ -38122,7 +38227,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join16(target, child2.name), signal);
+          const path2 = await this.resolvePath(join18(target, child2.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -38158,15 +38263,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 join17 } from "node:path";
+import { join as join19 } 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 = join17(stateDirectory, "logs");
-    this.#path = join17(this.#directory, "daemon.log");
+    this.#directory = join19(stateDirectory, "logs");
+    this.#path = join19(this.#directory, "daemon.log");
     this.#maximumBytes = maximumBytes;
   }
   // Export only correlation and failure metadata. Local messages and paths stay local.
@@ -40111,9 +40216,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
@@ -40291,7 +40397,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 = {
@@ -40665,7 +40771,7 @@ import { WebSocket as WebSocket5 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.193",
+  version: "0.0.195",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -40968,7 +41074,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: [],
@@ -41362,7 +41469,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
-import { realpath as realpath9, stat as stat8 } from "node:fs/promises";
+import { realpath as realpath10, stat as stat9 } from "node:fs/promises";
 import { basename as basename4, extname, isAbsolute as isAbsolute11, normalize as normalize4, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
@@ -41390,7 +41497,7 @@ async function resolveFile(value, workingDirectory, signal) {
     return null;
   }
   try {
-    const target = await realpath9(requested);
+    const target = await realpath10(requested);
     signal.throwIfAborted();
     return isAbsolute11(target) && normalize4(target) === target ? target : null;
   } catch {
@@ -41404,7 +41511,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
   if (target === null) {
     throw new Error("The local file is unavailable");
   }
-  const before = await stat8(target);
+  const before = await stat9(target);
   signal.throwIfAborted();
   if (!before.isFile() || before.size < 1 || before.size > command.maxBytes) {
     throw new Error("The local file is too large to read");
@@ -41432,7 +41539,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
     });
     sequence += 1;
   }
-  const after = await stat8(target);
+  const after = await stat9(target);
   signal.throwIfAborted();
   if (after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
     throw new Error("The local file changed during transfer");
@@ -41476,7 +41583,305 @@ 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
+function isAgentReasoning(event) {
+  return event?.type === "acp" && event.payload.sessionUpdate === "agent_thought_chunk";
+}
+function omitAgentReasoning(events) {
+  const retained = [];
+  let previousReasoningMessageId;
+  for (const event of events) {
+    if (event.type !== "acp" || event.payload.sessionUpdate !== "agent_thought_chunk") {
+      previousReasoningMessageId = void 0;
+      retained.push(event);
+      continue;
+    }
+    const messageId = event.payload.messageId ?? null;
+    if (previousReasoningMessageId === void 0 || previousReasoningMessageId !== messageId) {
+      retained.push({
+        ...event,
+        mobiusMetadata: { omitted: true },
+        payload: { ...event.payload, content: { text: "", type: "text" } }
+      });
+    }
+    previousReasoningMessageId = messageId;
+  }
+  return retained;
+}
+async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoning, queuedPromptRequests, load, eventLogV2) {
+  let cursor = initialCursor;
+  let loaded = [];
+  let sessionGenerationId = null;
+  let sourceNextCursor = null;
+  do {
+    const replay = await load(eventLimit, cursor);
+    if (sessionGenerationId !== null && replay.sessionGenerationId !== sessionGenerationId) {
+      throw new AcpExecutionError("The Session reloaded while history was loading", {}, "session_reloaded");
+    }
+    sessionGenerationId = replay.sessionGenerationId;
+    const events2 = replay.events.map(
+      (event, index2) => eventLogV2.event(
+        sessionId,
+        replay.sessionGenerationId,
+        replay.startPosition + index2,
+        event,
+        "1970-01-01T00:00:00.000Z"
+      )
+    );
+    loaded = [...events2, ...loaded];
+    sourceNextCursor = replay.nextCursor;
+    const visible2 = omitReasoning ? omitAgentReasoning(loaded) : loaded;
+    const reasoningContinuesBeforePage = sourceNextCursor !== null && isAgentReasoning(loaded[0]);
+    if (visible2.length >= eventLimit && !reasoningContinuesBeforePage) {
+      break;
+    }
+    cursor = sourceNextCursor;
+  } while (cursor !== null);
+  if (sessionGenerationId === null) {
+    throw new AcpExecutionError("The Session history is unavailable", {}, "session_history_unavailable");
+  }
+  const visible = omitReasoning ? omitAgentReasoning(loaded) : loaded;
+  const events = visible.slice(-eventLimit);
+  const firstPosition = events[0] === void 0 ? 0 : Number(events[0].position);
+  const nextCursor = firstPosition <= 1 ? null : (firstPosition - 1).toString();
+  return {
+    events: {
+      events,
+      nextCursor,
+      sessionGenerationId,
+      tailCursor: events.at(-1)?.eventId ?? "",
+      truncated: nextCursor !== null,
+      version: 2
+    },
+    queuedPromptRequests
+  };
+}
 async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, directories, audit, diagnostics, sessions, nativeSessions, eventLogV2, signal) {
   let agentId;
   try {
@@ -41494,41 +41899,29 @@ 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
     };
     const recovery = eventLogV2.promptRequestRecovery(command.sessionId);
-    const replay = await sessions.loadSessionEventsV2(loadOptions, command.eventLimit, command.cursor);
-    signal.throwIfAborted();
-    const events = replay.events.map(
-      (event, index2) => eventLogV2.event(
-        command.sessionId,
-        replay.sessionGenerationId,
-        replay.startPosition + index2,
-        event,
-        "1970-01-01T00:00:00.000Z"
-      )
+    const events = await loadHistoryPage(
+      command.sessionId,
+      command.eventLimit,
+      command.cursor,
+      command.omit?.includes("agent-reasoning") === true,
+      recovery.queuedPromptRequests,
+      async (eventLimit, cursor) => await sessions.loadSessionEventsV2(loadOptions, eventLimit, cursor),
+      eventLogV2
     );
-    const tailCursor = events.at(-1)?.eventId ?? "";
+    signal.throwIfAborted();
     audit.record({
       commandId: command.requestId,
       event: "session_event_log_v2_loaded",
       sessionId: command.sessionId
     });
     send(socket, {
-      events: {
-        events: {
-          events,
-          nextCursor: replay.nextCursor,
-          sessionGenerationId: replay.sessionGenerationId,
-          tailCursor,
-          truncated: replay.truncated,
-          version: 2
-        },
-        queuedPromptRequests: recovery.queuedPromptRequests
-      },
+      events,
       kind: SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND,
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -41567,46 +41960,30 @@ async function executeSessionPreviewHistoryPageLoad(socket, command, config2, di
       command.additionalDirectoryIds,
       signal
     );
-    const replay = await sessions.previewNativeSessionEventsV2(
-      {
-        additionalDirectories: resolved.additionalDirectories,
-        agent: config2.catalog.find(command.agentId),
-        cwd: resolved.cwd,
-        sessionId: command.sessionId,
-        signal
-      },
+    const loadOptions = {
+      additionalDirectories: resolved.additionalDirectories,
+      agent: await resolveCatalogAgent(config2, command.agentId, signal),
+      cwd: resolved.cwd,
+      sessionId: command.sessionId,
+      signal
+    };
+    const events = await loadHistoryPage(
       command.sessionId,
       command.eventLimit,
-      command.cursor
+      command.cursor,
+      command.omit?.includes("agent-reasoning") === true,
+      [],
+      async (eventLimit, cursor) => await sessions.previewNativeSessionEventsV2(loadOptions, command.sessionId, eventLimit, cursor),
+      eventLogV2
     );
     signal.throwIfAborted();
-    const events = replay.events.map(
-      (event, index2) => eventLogV2.event(
-        command.sessionId,
-        replay.sessionGenerationId,
-        replay.startPosition + index2,
-        event,
-        "1970-01-01T00:00:00.000Z"
-      )
-    );
-    const tailCursor = events.at(-1)?.eventId ?? "";
     audit.record({
       commandId: command.requestId,
       event: "session_event_log_v2_loaded",
       sessionId: command.sessionId
     });
     send(socket, {
-      events: {
-        events: {
-          events,
-          nextCursor: replay.nextCursor,
-          sessionGenerationId: replay.sessionGenerationId,
-          tailCursor,
-          truncated: replay.truncated,
-          version: 2
-        },
-        queuedPromptRequests: []
-      },
+      events,
       kind: SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND,
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -41862,7 +42239,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");
@@ -42007,228 +42384,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) {
@@ -43421,11 +43576,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     stateDirectory
   });
   const channelHash = createHash7("sha256").update(config2.channelId).digest("hex");
-  const sessionDatabase = openAcpSessionDatabase(join18(stateDirectory, "sessions", `${channelHash}.sqlite`));
+  const sessionDatabase = openAcpSessionDatabase(join20(stateDirectory, "sessions", `${channelHash}.sqlite`));
   let eventsV2;
   try {
     eventsV2 = new CachedAcpSessionEventStoreV2(
-      openSessionEventCacheV2Database(join18(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
+      openSessionEventCacheV2Database(join20(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
     );
   } catch (error62) {
     sessionDatabase.close();
@@ -43628,7 +43783,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
 }
 
 // src/pairing/pair-local-machine.ts
-import { mkdir as mkdir6, realpath as realpath10, stat as stat9 } from "node:fs/promises";
+import { mkdir as mkdir6, realpath as realpath11, stat as stat10 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
 import { basename as basename6, resolve as resolve7 } from "node:path";
 import { fetch as fetch4 } from "undici";
@@ -43636,7 +43791,7 @@ import { fetch as fetch4 } from "undici";
 // src/storage/runtime-installation-store.ts
 import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir5, open as open5, readdir as readdir4, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname6, join as join19, resolve as resolve6 } from "node:path";
+import { dirname as dirname6, join as join21, resolve as resolve6 } 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}$/;
@@ -43879,7 +44034,7 @@ async function readJsonFile(path2, signal, missingCode) {
 async function writeJsonAtomically(path2, value, signal) {
   signal.throwIfAborted();
   const directory = dirname6(path2);
-  const temporaryPath = join19(directory, `.${randomUUID9()}.tmp`);
+  const temporaryPath = join21(directory, `.${randomUUID9()}.tmp`);
   try {
     await mkdir5(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -43905,14 +44060,14 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     this.applicationId = applicationId;
     this.installationId = installationId2;
     this.stateDirectory = stateDirectory;
-    this.#channelDirectory = join19(stateDirectory, "channels");
-    this.#connectionDirectory = join19(stateDirectory, "connections");
+    this.#channelDirectory = join21(stateDirectory, "channels");
+    this.#connectionDirectory = join21(stateDirectory, "connections");
   }
   static open = async (options, signal) => {
     signal.throwIfAborted();
     const applicationId = validateApplicationId(options.applicationId);
     const rootDirectory = resolve6(options.stateDirectory);
-    const applicationDirectory = join19(rootDirectory, "installations", applicationId);
+    const applicationDirectory = join21(rootDirectory, "installations", applicationId);
     try {
       await mkdir5(applicationDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -43925,7 +44080,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
       );
     }
     const storedInstallationId = await readOrCreateInstallationId(applicationDirectory, signal);
-    const stateDirectory = join19(applicationDirectory, storedInstallationId);
+    const stateDirectory = join21(applicationDirectory, storedInstallationId);
     try {
       await mkdir5(stateDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -43940,8 +44095,8 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     return new _RuntimeInstallationStore(applicationId, storedInstallationId, stateDirectory);
   };
-  connectionPath = (connectionId2) => join19(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
-  channelIndexPath = (channelId) => join19(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
+  connectionPath = (connectionId2) => join21(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
+  channelIndexPath = (channelId) => join21(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
   readConnection = async (connectionId2, signal) => {
     const stored = decodeConnection(
       await readJsonFile(this.connectionPath(connectionId2), signal, "connection_not_found")
@@ -44103,7 +44258,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
 };
 async function readOrCreateInstallationId(applicationDirectory, signal) {
-  const pointerPath = join19(applicationDirectory, "current.json");
+  const pointerPath = join21(applicationDirectory, "current.json");
   try {
     return decodeInstallationPointer(await readJsonFile(pointerPath, signal, "installation_not_found")).installationId;
   } catch (cause) {
@@ -44198,8 +44353,8 @@ async function resolveDefaultWorkspace2(path2) {
   const requestedWorkspace = resolve7(path2);
   try {
     await mkdir6(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath10(requestedWorkspace);
-    const metadata = await stat9(defaultWorkspace);
+    const defaultWorkspace = await realpath11(requestedWorkspace);
+    const metadata = await stat10(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError("invalid_workspace", "The default workspace is not a directory");
     }
@@ -44298,20 +44453,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)
   };
 }
@@ -44434,8 +44599,8 @@ async function resolveWorkspace(path2) {
   const requested = resolve8(path2);
   try {
     await mkdir7(requested, { recursive: true, mode: 448 });
-    const resolved = await realpath11(requested);
-    const metadata = await stat10(resolved);
+    const resolved = await realpath12(requested);
+    const metadata = await stat11(resolved);
     if (!metadata.isDirectory()) {
       throw new MobiusRuntimeConfigurationError("The Runtime workspace is not a directory");
     }
@@ -44452,26 +44617,35 @@ async function createMobiusRuntimeEngine(connection, signal, environment = proce
   const localContext = new DaemonLocalContext(readStateDirectory(environment), environment);
   const relayUrl = relayUrlFromConnection(connection);
   const defaultWorkspace = await resolveWorkspace(connection.defaultWorkspace);
-  const inventory = await discoverLocalAgentInventory({
+  const specifications = supportedLocalAgentSpecifications();
+  const discoveryEnvironment = localContext.environment;
+  const discover = async (refreshSignal) => await discoverLocalAgentInventory({
     defaultWorkspace,
-    environment: localContext.environment,
-    signal
+    environment: discoveryEnvironment,
+    signal: refreshSignal,
+    specifications
   });
+  const inventory = await discover(signal);
   if (inventory.available.length + inventory.installable.length === 0) {
     throw new MobiusRuntimeConfigurationError("No supported Agent is available for the local Runtime");
   }
-  return new MobiusRuntimeEngine(
-    createDaemonConfig(
-      {
-        channelId: connection.channelId,
-        defaultWorkspace,
-        relayUrl
-      },
-      inventory.readyAgents(),
-      inventory.installable,
-      localContext
+  const config2 = createDaemonConfig(
+    {
+      channelId: connection.channelId,
+      defaultWorkspace,
+      relayUrl
+    },
+    inventory.readyAgents(),
+    inventory.installable,
+    localContext,
+    null,
+    createCatalogAgentResolver(
+      (refreshSignal) => discover(refreshSignal),
+      () => config2,
+      publishAgentCatalog
     )
   );
+  return new MobiusRuntimeEngine(config2);
 }
 var MobiusRuntimeEngine = class {
   #config;