@moxt-ai/mobius 0.0.13 → 0.0.15

package/dist/index.js

@@ -9,6 +9,9 @@ import {
   client,
   methods
 } from "@agentclientprotocol/sdk";
+function discardExtensionParams(_params) {
+  return Object.freeze({});
+}
 var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
   methods.client.session.requestPermission,
   async (context) => await handler.onPermission(context.params, context.signal)
@@ -19,652 +22,31 @@ var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
   await handler.onUpdate(context.params);
 }).onNotification(methods.client.elicitation.complete, async (context) => {
   await handler.onElicitationComplete(context.params);
-});
+}).onRequest("cursor/ask_question", discardExtensionParams, async () => ({
+  outcome: {
+    outcome: "skipped",
+    reason: "Mobius does not expose Cursor question extensions"
+  }
+})).onRequest("cursor/create_plan", discardExtensionParams, async () => ({
+  outcome: { outcome: "cancelled" }
+})).onNotification(
+  "cursor/update_todos",
+  discardExtensionParams,
+  async () => Promise.resolve()
+).onNotification(
+  "cursor/task",
+  discardExtensionParams,
+  async () => Promise.resolve()
+).onNotification(
+  "cursor/generate_image",
+  discardExtensionParams,
+  async () => Promise.resolve()
+);
 
 // src/config.ts
 import { join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// src/agent-catalog/local-agent.ts
-import { realpathSync, statSync } from "node:fs";
-
-// src/process/executable.ts
-import { execFile, spawn } from "node:child_process";
-import { constants } from "node:fs";
-import { access, realpath, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
-var DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024;
-var PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS = 1e3;
-var PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS = 5e3;
-var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
-var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
-var PROCESS_EXIT_CHECK_ATTEMPTS = 8;
-var GRACEFUL_STOP_SIGNAL = 15;
-var FORCED_STOP_SIGNAL = 9;
-var ExecutableIdentity = class {
-  changedAtMilliseconds;
-  device;
-  inode;
-  realPath;
-  requestedPath;
-  size;
-  constructor(requestedPath, realPath_, device, inode, size, changedAtMilliseconds) {
-    this.changedAtMilliseconds = changedAtMilliseconds;
-    this.device = device;
-    this.inode = inode;
-    this.realPath = realPath_;
-    this.requestedPath = requestedPath;
-    this.size = size;
-  }
-  matches = (candidate) => this.requestedPath === candidate.requestedPath && this.realPath === candidate.realPath && this.device === candidate.device && this.inode === candidate.inode && this.size === candidate.size && this.changedAtMilliseconds === candidate.changedAtMilliseconds;
-};
-var ResolvedExecutable = class {
-  identity;
-  path;
-  constructor(identity2) {
-    this.identity = identity2;
-    this.path = identity2.realPath;
-  }
-};
-var ProcessExecutionError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "ProcessExecutionError";
-  }
-};
-var ProcessResult = class {
-  stderr;
-  stdout;
-  constructor(stdout, stderr) {
-    this.stderr = stderr;
-    this.stdout = stdout;
-  }
-};
-function executableExtensions(executableName, environment, platform) {
-  if (platform !== "win32") {
-    return [""];
-  }
-  if (/\.[a-zA-Z0-9]+$/.test(executableName)) {
-    return [""];
-  }
-  const configured = environment["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
-  const extensions = configured.split(";").map((extension) => extension.trim()).filter((extension) => extension.length > 0).map(
-    (extension) => extension.startsWith(".") ? extension : `.${extension}`
-  );
-  return extensions.length > 0 ? extensions : [".EXE"];
-}
-async function resolveExecutablePath(requestedPath, platform = process.platform) {
-  const absoluteRequestedPath = resolve(requestedPath);
-  try {
-    const resolvedPath = await realpath(absoluteRequestedPath);
-    const metadata = await stat(resolvedPath);
-    if (!metadata.isFile()) {
-      return null;
-    }
-    if (platform !== "win32") {
-      await access(resolvedPath, constants.X_OK);
-    }
-    return new ResolvedExecutable(
-      new ExecutableIdentity(
-        absoluteRequestedPath,
-        resolvedPath,
-        metadata.dev,
-        metadata.ino,
-        metadata.size,
-        metadata.ctimeMs
-      )
-    );
-  } catch {
-    return null;
-  }
-}
-async function findExecutableOnPath(executableName, environment, platform = process.platform) {
-  const encodedPath = environment["PATH"] ?? "";
-  const separator = platform === "win32" ? ";" : ":";
-  const extensions = executableExtensions(
-    executableName,
-    environment,
-    platform
-  );
-  for (const entry of encodedPath.split(separator)) {
-    if (entry.length === 0) {
-      continue;
-    }
-    for (const extension of extensions) {
-      const requestedPath = resolve(
-        join(entry, `${executableName}${extension}`)
-      );
-      const executable = await resolveExecutablePath(requestedPath, platform);
-      if (executable !== null) {
-        return executable;
-      }
-    }
-  }
-  return null;
-}
-async function revalidateExecutable(identity2, platform = process.platform) {
-  const current = await resolveExecutablePath(identity2.requestedPath, platform);
-  return current !== null && identity2.matches(current.identity);
-}
-function appendBounded(chunks, chunk, currentBytes, limitBytes) {
-  const nextBytes = currentBytes + chunk.byteLength;
-  if (nextBytes > limitBytes) {
-    throw new ProcessExecutionError(
-      "process_output_limit",
-      "The executable produced too much output"
-    );
-  }
-  chunks.push(chunk);
-  return nextBytes;
-}
-function parseProcessTable(output2) {
-  const entries = [];
-  for (const line of output2.split("\n")) {
-    const groups = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<pgid>\d+)\s*$/.exec(
-      line
-    )?.groups;
-    if (groups === void 0) {
-      continue;
-    }
-    const processId = Number(groups["pid"]);
-    const parentProcessId = Number(groups["ppid"]);
-    const processGroupId = Number(groups["pgid"]);
-    if (!Number.isSafeInteger(processId) || processId <= 0 || !Number.isSafeInteger(parentProcessId) || parentProcessId < 0 || !Number.isSafeInteger(processGroupId) || processGroupId <= 0) {
-      continue;
-    }
-    entries.push({ parentProcessId, processGroupId, processId });
-  }
-  return entries;
-}
-function readProcessTable() {
-  if (process.platform === "win32") {
-    return Promise.resolve([]);
-  }
-  const executable = process.platform === "darwin" ? "/bin/ps" : "/usr/bin/ps";
-  return new Promise((resolveTable) => {
-    execFile(
-      executable,
-      ["-axo", "pid=,ppid=,pgid="],
-      {
-        encoding: "utf8",
-        maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT_BYTES,
-        signal: AbortSignal.timeout(PROCESS_TABLE_TIMEOUT_MILLISECONDS),
-        timeout: PROCESS_TABLE_TIMEOUT_MILLISECONDS
-      },
-      (error61, stdout) => {
-        resolveTable(error61 === null ? parseProcessTable(stdout) : []);
-      }
-    );
-  });
-}
-function selectProcessTree(entries, rootProcessId) {
-  const processIds = /* @__PURE__ */ new Set([rootProcessId]);
-  let previousSize = 0;
-  while (previousSize !== processIds.size) {
-    previousSize = processIds.size;
-    for (const entry of entries) {
-      if (processIds.has(entry.parentProcessId)) {
-        processIds.add(entry.processId);
-      }
-    }
-  }
-  return entries.filter((entry) => processIds.has(entry.processId)).map((entry) => ({
-    processGroupId: entry.processGroupId,
-    processId: entry.processId
-  }));
-}
-function mergeProcessTrees(captured, current) {
-  const processes = /* @__PURE__ */ new Map();
-  for (const identity2 of captured) {
-    processes.set(identity2.processId, identity2);
-  }
-  for (const identity2 of current) {
-    processes.set(identity2.processId, identity2);
-  }
-  return [...processes.values()];
-}
-async function captureProcessTree(child) {
-  if (process.platform === "win32" || child.pid === void 0) {
-    return [];
-  }
-  return selectProcessTree(await readProcessTable(), child.pid);
-}
-function signalDetachedProcessGroups(processes, rootProcessId, signal) {
-  const processIds = new Set(processes.map((identity2) => identity2.processId));
-  const signalledGroups = /* @__PURE__ */ new Set();
-  for (const identity2 of processes) {
-    if (identity2.processGroupId === rootProcessId || !processIds.has(identity2.processGroupId) || signalledGroups.has(identity2.processGroupId)) {
-      continue;
-    }
-    try {
-      process.kill(-identity2.processGroupId, signal);
-      signalledGroups.add(identity2.processGroupId);
-    } catch {
-    }
-  }
-  for (const identity2 of processes) {
-    if (identity2.processId === rootProcessId || identity2.processGroupId === rootProcessId || signalledGroups.has(identity2.processGroupId)) {
-      continue;
-    }
-    try {
-      process.kill(identity2.processId, signal);
-    } catch {
-    }
-  }
-}
-function processExists(processId) {
-  try {
-    process.kill(processId, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function waitForCapturedProcessesExit(processes, rootProcessId) {
-  const processIds = processes.map((identity2) => identity2.processId).filter((processId) => processId !== rootProcessId);
-  for (let attempt = 0; attempt < PROCESS_EXIT_CHECK_ATTEMPTS; attempt += 1) {
-    if (processIds.every((processId) => !processExists(processId))) {
-      return true;
-    }
-    await readProcessTable();
-  }
-  return processIds.every((processId) => !processExists(processId));
-}
-function terminateProcess(child) {
-  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
-    return;
-  }
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-child.pid, "SIGTERM");
-      return;
-    } catch {
-    }
-  }
-  child.kill("SIGTERM");
-}
-function forceTerminateProcess(child) {
-  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
-    return;
-  }
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-child.pid, "SIGKILL");
-      return;
-    } catch {
-    }
-  }
-  child.kill("SIGKILL");
-}
-async function stopProcessTree(child, capturedProcesses = []) {
-  const childProcessId = child.pid;
-  if (childProcessId === void 0) {
-    return;
-  }
-  const childExited = child.exitCode !== null || child.signalCode !== null;
-  if (childExited && capturedProcesses.length === 0) {
-    return;
-  }
-  const processes = mergeProcessTrees(
-    capturedProcesses,
-    childExited ? [] : await captureProcessTree(child)
-  );
-  signalDetachedProcessGroups(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
-  terminateProcess(child);
-  const [exitedAfterTermination, descendantsExitedAfterTermination] = await Promise.all([
-    waitForProcessExit(child, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
-    waitForCapturedProcessesExit(processes, childProcessId)
-  ]);
-  if (exitedAfterTermination && descendantsExitedAfterTermination) {
-    return;
-  }
-  signalDetachedProcessGroups(processes, childProcessId, FORCED_STOP_SIGNAL);
-  forceTerminateProcess(child);
-  const [exitedAfterForce, descendantsExitedAfterForce] = await Promise.all([
-    waitForProcessExit(child, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
-    waitForCapturedProcessesExit(processes, childProcessId)
-  ]);
-  if (!exitedAfterForce || !descendantsExitedAfterForce) {
-    throw new ProcessExecutionError(
-      "process_termination_timeout",
-      "The executable process could not be stopped"
-    );
-  }
-}
-function waitForProcessExit(child, timeoutMilliseconds) {
-  if (child.exitCode !== null || child.signalCode !== null) {
-    return Promise.resolve(true);
-  }
-  return new Promise((resolveExit) => {
-    let settled = false;
-    const finish = (exited) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      child.removeListener("exit", handleExit);
-      resolveExit(exited);
-    };
-    const handleExit = () => finish(true);
-    const timeout = setTimeout(() => finish(false), timeoutMilliseconds);
-    child.once("exit", handleExit);
-    if (child.exitCode !== null || child.signalCode !== null) {
-      finish(true);
-    }
-  });
-}
-async function runBoundedProcess(options) {
-  options.signal.throwIfAborted();
-  const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
-  const child = spawn(options.command, [...options.arguments], {
-    cwd: options.cwd,
-    detached: process.platform !== "win32",
-    env: { ...options.environment },
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  const stdout = [];
-  const stderr = [];
-  let stdoutBytes = 0;
-  let stderrBytes = 0;
-  let interruptionFailure = null;
-  let interruptionCleanupFailure = null;
-  let stopping = false;
-  const interrupted = Promise.withResolvers();
-  const interrupt = (failure) => {
-    if (stopping) {
-      return;
-    }
-    stopping = true;
-    interruptionFailure = failure;
-    const stop = async () => {
-      try {
-        await stopProcessTree(child);
-      } catch (error61) {
-        interruptionCleanupFailure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
-          "process_termination_failed",
-          "The executable process could not be stopped",
-          { cause: error61 }
-        );
-      } finally {
-        interrupted.resolve();
-      }
-    };
-    void stop();
-  };
-  const collectStdout = (chunk) => {
-    if (interruptionFailure !== null) {
-      return;
-    }
-    try {
-      stdoutBytes = appendBounded(stdout, chunk, stdoutBytes, outputLimitBytes);
-    } catch (error61) {
-      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
-        "process_output_limit",
-        "The executable produced too much output",
-        { cause: error61 }
-      );
-      interrupt(failure);
-    }
-  };
-  const collectStderr = (chunk) => {
-    if (interruptionFailure !== null) {
-      return;
-    }
-    try {
-      stderrBytes = appendBounded(stderr, chunk, stderrBytes, outputLimitBytes);
-    } catch (error61) {
-      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
-        "process_output_limit",
-        "The executable produced too much output",
-        { cause: error61 }
-      );
-      interrupt(failure);
-    }
-  };
-  child.stdout?.on("data", collectStdout);
-  child.stderr?.on("data", collectStderr);
-  const timeout = setTimeout(() => {
-    interrupt(
-      new ProcessExecutionError(
-        "process_timeout",
-        "The executable probe timed out"
-      )
-    );
-  }, options.timeoutMilliseconds);
-  const abort = () => interrupt(
-    new ProcessExecutionError(
-      "process_cancelled",
-      "The executable probe was cancelled",
-      { cause: options.signal.reason }
-    )
-  );
-  options.signal.addEventListener("abort", abort, { once: true });
-  if (options.signal.aborted) {
-    abort();
-  }
-  try {
-    const exit = new Promise((resolveExit, rejectExit) => {
-      child.once("error", rejectExit);
-      child.once("exit", (code) => resolveExit(code ?? 1));
-    });
-    const exitCode = await Promise.race([
-      exit,
-      interrupted.promise.then(() => -1)
-    ]);
-    if (interruptionCleanupFailure !== null) {
-      throw interruptionCleanupFailure;
-    }
-    if (interruptionFailure !== null) {
-      throw interruptionFailure;
-    }
-    if (exitCode !== 0) {
-      throw new ProcessExecutionError(
-        "process_exit_failed",
-        "The executable probe failed"
-      );
-    }
-    return new ProcessResult(
-      Buffer.concat(stdout).toString("utf8"),
-      Buffer.concat(stderr).toString("utf8")
-    );
-  } catch (error61) {
-    if (error61 instanceof ProcessExecutionError) {
-      throw error61;
-    }
-    throw new ProcessExecutionError(
-      "process_spawn_failed",
-      "The executable could not be started",
-      { cause: error61 }
-    );
-  } finally {
-    clearTimeout(timeout);
-    options.signal.removeEventListener("abort", abort);
-    child.stdout?.removeListener("data", collectStdout);
-    child.stderr?.removeListener("data", collectStderr);
-    if (stopping) {
-      await interrupted.promise;
-    } else {
-      await stopProcessTree(child);
-    }
-  }
-}
-
-// src/agent-catalog/local-agent.ts
-function readTrustedIdentity(path2) {
-  const resolvedPath = realpathSync(path2);
-  const metadata = statSync(resolvedPath);
-  return new ExecutableIdentity(
-    resolvedPath,
-    resolvedPath,
-    metadata.dev,
-    metadata.ino,
-    metadata.size,
-    metadata.ctimeMs
-  );
-}
-var LocalAgentDefinition = class {
-  adapterIdentity;
-  adapterPath;
-  adapterVersion;
-  agentIdentity;
-  agentVersion;
-  arguments;
-  command;
-  environment;
-  id;
-  label;
-  promptTimeoutMilliseconds;
-  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity, promptTimeoutMilliseconds = 30 * 60 * 1e3) {
-    if (!Number.isSafeInteger(promptTimeoutMilliseconds) || promptTimeoutMilliseconds < 1) {
-      throw new Error("The local Agent prompt deadline is invalid");
-    }
-    this.adapterIdentity = adapterIdentity;
-    this.adapterPath = adapterIdentity.realPath;
-    this.adapterVersion = adapterVersion;
-    this.agentIdentity = agentIdentity;
-    this.agentVersion = agentVersion;
-    this.id = id;
-    this.label = label;
-    this.promptTimeoutMilliseconds = promptTimeoutMilliseconds;
-    this.command = adapterIdentity.realPath;
-    this.arguments = Object.freeze([...arguments_]);
-    this.environment = Object.freeze({ ...environment });
-  }
-};
-var InstallableAgentDefinition = class {
-  id;
-  label;
-  requiresLocalApproval;
-  constructor(id, label, requiresLocalApproval = true) {
-    this.id = id;
-    this.label = label;
-    this.requiresLocalApproval = requiresLocalApproval;
-  }
-};
-var LocalAgentCatalogSnapshot = class {
-  agents;
-  installableAgents;
-  constructor(agents, installableAgents) {
-    this.agents = Object.freeze([...agents]);
-    this.installableAgents = Object.freeze([...installableAgents]);
-  }
-};
-var LocalAgentCatalogError = class extends Error {
-  code = "agent_not_ready";
-  constructor() {
-    super("The requested local Agent is not ready");
-    this.name = "LocalAgentCatalogError";
-  }
-};
-var LocalAgentCatalog = class {
-  #snapshot;
-  constructor(agents, installableAgents) {
-    this.#snapshot = this.validate(agents, installableAgents);
-  }
-  find = (agentId) => {
-    for (const agent of this.#snapshot.agents) {
-      if (agent.id === agentId) {
-        return agent;
-      }
-    }
-    throw new LocalAgentCatalogError();
-  };
-  read = () => this.#snapshot;
-  transition = (agents, installableAgents) => {
-    const next = this.validate(agents, installableAgents);
-    this.#snapshot = next;
-    return next;
-  };
-  validate = (agents, installableAgents) => {
-    const identifiers = /* @__PURE__ */ new Set();
-    for (const agent of agents) {
-      if (identifiers.has(agent.id)) {
-        throw new Error("The local Agent catalog contains duplicate entries");
-      }
-      identifiers.add(agent.id);
-    }
-    for (const agent of installableAgents) {
-      if (identifiers.has(agent.id)) {
-        throw new Error("A local Agent cannot be ready and installable");
-      }
-      identifiers.add(agent.id);
-    }
-    return new LocalAgentCatalogSnapshot(agents, installableAgents);
-  };
-};
-
-// src/storage/state-directory.ts
-import { homedir } from "node:os";
-import { join as join2, resolve as resolve2 } from "node:path";
-function readStateDirectory(environment = process.env) {
-  const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
-  if (configured !== void 0 && configured.length > 0) {
-    return resolve2(configured);
-  }
-  return join2(homedir(), ".mobius");
-}
-
-// src/config.ts
-function loadDefaultWorkspace() {
-  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
-  return configuredWorkspace ?? join3(readStateDirectory(), "workspace");
-}
-function createDaemonConfig(connection, agents = [], installableAgents = []) {
-  return {
-    agents,
-    defaultWorkspace: connection.defaultWorkspace,
-    auditDatabasePath: connection.auditDatabasePath,
-    bindingId: "workspace",
-    catalog: new LocalAgentCatalog(agents, installableAgents),
-    channelId: connection.channelId,
-    installableAgents,
-    relayUrl: connection.relayUrl
-  };
-}
-function loadDaemonConfig() {
-  const relayUrl = new URL(
-    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-    process.env["MOBIUS_RELAY_URL"] ?? "ws://127.0.0.1:8787/mobius/api/channels/local/daemon"
-  );
-  relayUrl.searchParams.set(
-    "token",
-    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-    process.env["MOBIUS_RELAY_TOKEN"] ?? "local-development-token"
-  );
-  if (relayUrl.protocol !== "ws:" && relayUrl.protocol !== "wss:") {
-    throw new Error("MOBIUS_RELAY_URL must use ws or wss");
-  }
-  return createDaemonConfig(
-    {
-      defaultWorkspace: loadDefaultWorkspace(),
-      auditDatabasePath: (
-        // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-        process.env["MOBIUS_AUDIT_DATABASE"] ?? fileURLToPath(
-          new URL("../../../.mobius/daemon.sqlite", import.meta.url)
-        )
-      ),
-      // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
-      channelId: process.env["MOBIUS_CHANNEL_ID"] ?? "local",
-      relayUrl
-    },
-    [],
-    []
-  );
-}
-
-// src/acp/session-manager.ts
-import { spawn as spawn2 } from "node:child_process";
-import {
-  methods as methods2,
-  ndJsonStream,
-  PROTOCOL_VERSION,
-  RequestError
-} from "@agentclientprotocol/sdk";
-
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -2625,8 +2007,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter2) => {
-  const escapedDelim = escapeRegex(delimiter2 ?? ":");
+var mac = (delimiter3) => {
+  const escapedDelim = escapeRegex(delimiter3 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -19601,7 +18983,6 @@ var SESSION_OPERATION_FAILED_KIND = "session.operation.failed";
 var AGENT_CONTENT_KIND = "agent.content";
 var AGENT_INSTALL_REQUEST_KIND = "agent.install.request";
 var AGENT_INSTALL_CANCEL_KIND = "agent.install.cancel";
-var AGENT_INSTALL_AWAITING_APPROVAL_KIND = "agent.install.awaiting_approval";
 var AGENT_INSTALL_STARTED_KIND = "agent.install.started";
 var AGENT_INSTALL_PROGRESS_KIND = "agent.install.progress";
 var AGENT_INSTALL_COMPLETED_KIND = "agent.install.completed";
@@ -19907,10 +19288,6 @@ var agentInstallCancelCommandSchema = external_exports.strictObject({
   kind: external_exports.literal(AGENT_INSTALL_CANCEL_KIND),
   requestId: IDENTIFIER
 }).readonly();
-var agentInstallAwaitingApprovalEventSchema = external_exports.strictObject({
-  ...agentInstallIdentityFields,
-  kind: external_exports.literal(AGENT_INSTALL_AWAITING_APPROVAL_KIND)
-}).readonly();
 var agentInstallStartedEventSchema = external_exports.strictObject({
   ...agentInstallIdentityFields,
   kind: external_exports.literal(AGENT_INSTALL_STARTED_KIND)
@@ -19993,7 +19370,6 @@ var encodeSessionOperationFailedEvent = (message) => encode3(message, sessionOpe
 var encodeAgentContentEvent = (message) => encode3(message, agentContentEventSchema);
 var decodeAgentInstallRequestCommand = (encoded) => decode3(encoded, agentInstallRequestCommandSchema);
 var decodeAgentInstallCancelCommand = (encoded) => decode3(encoded, agentInstallCancelCommandSchema);
-var encodeAgentInstallAwaitingApprovalEvent = (message) => encode3(message, agentInstallAwaitingApprovalEventSchema);
 var encodeAgentInstallStartedEvent = (message) => encode3(message, agentInstallStartedEventSchema);
 var encodeAgentInstallProgressEvent = (message) => encode3(message, agentInstallProgressEventSchema);
 var encodeAgentInstallCompletedEvent = (message) => encode3(message, agentInstallCompletedEventSchema);
@@ -20393,6 +19769,29 @@ function encodeSessionFailedEvent(message) {
   return JSON.stringify(decodeSessionFailedEvent(JSON.stringify(message)));
 }
 
+// ../protocol/src/mobius-api.ts
+var MOBIUS_API_PREFIX = "/mobius/api";
+var API_PREFIX_PATTERN = /^\/[a-zA-Z0-9._~-]+(?:\/[a-zA-Z0-9._~-]+)*$/;
+var MobiusApiConfigurationError = class extends Error {
+  code = "invalid_api_prefix";
+  constructor() {
+    super("The Mobius API prefix must be an absolute path without parameters");
+    this.name = "MobiusApiConfigurationError";
+  }
+};
+function parseMobiusApiPrefix(value) {
+  if (typeof value !== "string" || !API_PREFIX_PATTERN.test(value)) {
+    throw new MobiusApiConfigurationError();
+  }
+  return value;
+}
+function mobiusApiPath(resourcePath, apiPrefix = MOBIUS_API_PREFIX) {
+  return `${parseMobiusApiPrefix(apiPrefix)}${resourcePath}`;
+}
+function mobiusApiUrl(origin, resourcePath, apiPrefix = MOBIUS_API_PREFIX) {
+  return new URL(mobiusApiPath(resourcePath, apiPrefix), origin);
+}
+
 // ../protocol/src/session-history.ts
 var SESSION_HISTORY_CHARACTER_LIMIT = 256e3;
 var SESSION_HISTORY_MESSAGE_LIMIT = 1e3;
@@ -21084,29 +20483,667 @@ var eventAcknowledgementSchema = external_exports.strictObject({
 function decode5(encoded, schema) {
   let value;
   try {
-    value = JSON.parse(encoded);
-  } catch (cause) {
-    throw new ProtocolMessageError("Message is not valid JSON", { cause });
+    value = JSON.parse(encoded);
+  } catch (cause) {
+    throw new ProtocolMessageError("Message is not valid JSON", { cause });
+  }
+  const decoded = schema.safeParse(value);
+  if (!decoded.success) {
+    throw new ProtocolMessageError("Message does not match its schema", {
+      cause: decoded.error
+    });
+  }
+  return decoded.data;
+}
+var encode4 = (message, schema) => {
+  const decoded = schema.safeParse(message);
+  if (!decoded.success) {
+    throw new ProtocolMessageError("Message does not match its schema", {
+      cause: decoded.error
+    });
+  }
+  return JSON.stringify(decoded.data);
+};
+var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
+var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
+
+// src/agent-catalog/local-agent.ts
+import { realpathSync, statSync } from "node:fs";
+
+// src/process/executable.ts
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, realpath, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024;
+var PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS = 1e3;
+var PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS = 5e3;
+var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
+var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
+var PROCESS_EXIT_CHECK_ATTEMPTS = 8;
+var GRACEFUL_STOP_SIGNAL = 15;
+var FORCED_STOP_SIGNAL = 9;
+var ExecutableIdentity = class {
+  changedAtMilliseconds;
+  device;
+  inode;
+  realPath;
+  requestedPath;
+  size;
+  constructor(requestedPath, realPath_, device, inode, size, changedAtMilliseconds) {
+    this.changedAtMilliseconds = changedAtMilliseconds;
+    this.device = device;
+    this.inode = inode;
+    this.realPath = realPath_;
+    this.requestedPath = requestedPath;
+    this.size = size;
+  }
+  matches = (candidate) => this.requestedPath === candidate.requestedPath && this.realPath === candidate.realPath && this.device === candidate.device && this.inode === candidate.inode && this.size === candidate.size && this.changedAtMilliseconds === candidate.changedAtMilliseconds;
+};
+var ResolvedExecutable = class {
+  identity;
+  path;
+  constructor(identity2) {
+    this.identity = identity2;
+    this.path = identity2.realPath;
+  }
+};
+var ProcessExecutionError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "ProcessExecutionError";
+  }
+};
+var ProcessResult = class {
+  stderr;
+  stdout;
+  constructor(stdout, stderr) {
+    this.stderr = stderr;
+    this.stdout = stdout;
+  }
+};
+function executableExtensions(executableName, environment, platform) {
+  if (platform !== "win32") {
+    return [""];
+  }
+  if (/\.[a-zA-Z0-9]+$/.test(executableName)) {
+    return [""];
+  }
+  const configured = environment["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
+  const extensions = configured.split(";").map((extension) => extension.trim()).filter((extension) => extension.length > 0).map(
+    (extension) => extension.startsWith(".") ? extension : `.${extension}`
+  );
+  return extensions.length > 0 ? extensions : [".EXE"];
+}
+async function resolveExecutablePath(requestedPath, platform = process.platform) {
+  const absoluteRequestedPath = resolve(requestedPath);
+  try {
+    const resolvedPath = await realpath(absoluteRequestedPath);
+    const metadata = await stat(resolvedPath);
+    if (!metadata.isFile()) {
+      return null;
+    }
+    if (platform !== "win32") {
+      await access(resolvedPath, constants.X_OK);
+    }
+    return new ResolvedExecutable(
+      new ExecutableIdentity(
+        absoluteRequestedPath,
+        resolvedPath,
+        metadata.dev,
+        metadata.ino,
+        metadata.size,
+        metadata.ctimeMs
+      )
+    );
+  } catch {
+    return null;
+  }
+}
+async function findExecutableOnPath(executableName, environment, platform = process.platform) {
+  const encodedPath = environment["PATH"] ?? "";
+  const separator = platform === "win32" ? ";" : ":";
+  const extensions = executableExtensions(
+    executableName,
+    environment,
+    platform
+  );
+  for (const entry of encodedPath.split(separator)) {
+    if (entry.length === 0) {
+      continue;
+    }
+    for (const extension of extensions) {
+      const requestedPath = resolve(
+        join(entry, `${executableName}${extension}`)
+      );
+      const executable = await resolveExecutablePath(requestedPath, platform);
+      if (executable !== null) {
+        return executable;
+      }
+    }
+  }
+  return null;
+}
+async function revalidateExecutable(identity2, platform = process.platform) {
+  const current = await resolveExecutablePath(identity2.requestedPath, platform);
+  return current !== null && identity2.matches(current.identity);
+}
+function appendBounded(chunks, chunk, currentBytes, limitBytes) {
+  const nextBytes = currentBytes + chunk.byteLength;
+  if (nextBytes > limitBytes) {
+    throw new ProcessExecutionError(
+      "process_output_limit",
+      "The executable produced too much output"
+    );
+  }
+  chunks.push(chunk);
+  return nextBytes;
+}
+function parseProcessTable(output2) {
+  const entries = [];
+  for (const line of output2.split("\n")) {
+    const groups = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<pgid>\d+)\s*$/.exec(
+      line
+    )?.groups;
+    if (groups === void 0) {
+      continue;
+    }
+    const processId = Number(groups["pid"]);
+    const parentProcessId = Number(groups["ppid"]);
+    const processGroupId = Number(groups["pgid"]);
+    if (!Number.isSafeInteger(processId) || processId <= 0 || !Number.isSafeInteger(parentProcessId) || parentProcessId < 0 || !Number.isSafeInteger(processGroupId) || processGroupId <= 0) {
+      continue;
+    }
+    entries.push({ parentProcessId, processGroupId, processId });
+  }
+  return entries;
+}
+function readProcessTable() {
+  if (process.platform === "win32") {
+    return Promise.resolve([]);
+  }
+  const executable = process.platform === "darwin" ? "/bin/ps" : "/usr/bin/ps";
+  return new Promise((resolveTable) => {
+    execFile(
+      executable,
+      ["-axo", "pid=,ppid=,pgid="],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT_BYTES,
+        signal: AbortSignal.timeout(PROCESS_TABLE_TIMEOUT_MILLISECONDS),
+        timeout: PROCESS_TABLE_TIMEOUT_MILLISECONDS
+      },
+      (error61, stdout) => {
+        resolveTable(error61 === null ? parseProcessTable(stdout) : []);
+      }
+    );
+  });
+}
+function selectProcessTree(entries, rootProcessId) {
+  const processIds = /* @__PURE__ */ new Set([rootProcessId]);
+  let previousSize = 0;
+  while (previousSize !== processIds.size) {
+    previousSize = processIds.size;
+    for (const entry of entries) {
+      if (processIds.has(entry.parentProcessId)) {
+        processIds.add(entry.processId);
+      }
+    }
+  }
+  return entries.filter((entry) => processIds.has(entry.processId)).map((entry) => ({
+    processGroupId: entry.processGroupId,
+    processId: entry.processId
+  }));
+}
+function mergeProcessTrees(captured, current) {
+  const processes = /* @__PURE__ */ new Map();
+  for (const identity2 of captured) {
+    processes.set(identity2.processId, identity2);
+  }
+  for (const identity2 of current) {
+    processes.set(identity2.processId, identity2);
+  }
+  return [...processes.values()];
+}
+async function captureProcessTree(child) {
+  if (process.platform === "win32" || child.pid === void 0) {
+    return [];
+  }
+  return selectProcessTree(await readProcessTable(), child.pid);
+}
+function signalDetachedProcessGroups(processes, rootProcessId, signal) {
+  const processIds = new Set(processes.map((identity2) => identity2.processId));
+  const signalledGroups = /* @__PURE__ */ new Set();
+  for (const identity2 of processes) {
+    if (identity2.processGroupId === rootProcessId || !processIds.has(identity2.processGroupId) || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(-identity2.processGroupId, signal);
+      signalledGroups.add(identity2.processGroupId);
+    } catch {
+    }
+  }
+  for (const identity2 of processes) {
+    if (identity2.processId === rootProcessId || identity2.processGroupId === rootProcessId || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(identity2.processId, signal);
+    } catch {
+    }
+  }
+}
+function processExists(processId) {
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForCapturedProcessesExit(processes, rootProcessId) {
+  const processIds = processes.map((identity2) => identity2.processId).filter((processId) => processId !== rootProcessId);
+  for (let attempt = 0; attempt < PROCESS_EXIT_CHECK_ATTEMPTS; attempt += 1) {
+    if (processIds.every((processId) => !processExists(processId))) {
+      return true;
+    }
+    await readProcessTable();
+  }
+  return processIds.every((processId) => !processExists(processId));
+}
+function terminateProcess(child) {
+  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
+    return;
+  }
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+      return;
+    } catch {
+    }
+  }
+  child.kill("SIGTERM");
+}
+function forceTerminateProcess(child) {
+  if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
+    return;
+  }
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, "SIGKILL");
+      return;
+    } catch {
+    }
+  }
+  child.kill("SIGKILL");
+}
+async function stopProcessTree(child, capturedProcesses = []) {
+  const childProcessId = child.pid;
+  if (childProcessId === void 0) {
+    return;
+  }
+  const childExited = child.exitCode !== null || child.signalCode !== null;
+  if (childExited && capturedProcesses.length === 0) {
+    return;
+  }
+  const processes = mergeProcessTrees(
+    capturedProcesses,
+    childExited ? [] : await captureProcessTree(child)
+  );
+  signalDetachedProcessGroups(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
+  terminateProcess(child);
+  const [exitedAfterTermination, descendantsExitedAfterTermination] = await Promise.all([
+    waitForProcessExit(child, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
+    waitForCapturedProcessesExit(processes, childProcessId)
+  ]);
+  if (exitedAfterTermination && descendantsExitedAfterTermination) {
+    return;
+  }
+  signalDetachedProcessGroups(processes, childProcessId, FORCED_STOP_SIGNAL);
+  forceTerminateProcess(child);
+  const [exitedAfterForce, descendantsExitedAfterForce] = await Promise.all([
+    waitForProcessExit(child, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
+    waitForCapturedProcessesExit(processes, childProcessId)
+  ]);
+  if (!exitedAfterForce || !descendantsExitedAfterForce) {
+    throw new ProcessExecutionError(
+      "process_termination_timeout",
+      "The executable process could not be stopped"
+    );
+  }
+}
+function waitForProcessExit(child, timeoutMilliseconds) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolveExit) => {
+    let settled = false;
+    const finish = (exited) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      child.removeListener("exit", handleExit);
+      resolveExit(exited);
+    };
+    const handleExit = () => finish(true);
+    const timeout = setTimeout(() => finish(false), timeoutMilliseconds);
+    child.once("exit", handleExit);
+    if (child.exitCode !== null || child.signalCode !== null) {
+      finish(true);
+    }
+  });
+}
+async function runBoundedProcess(options) {
+  options.signal.throwIfAborted();
+  const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
+  const child = spawn(options.command, [...options.arguments], {
+    cwd: options.cwd,
+    detached: process.platform !== "win32",
+    env: { ...options.environment },
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const stdout = [];
+  const stderr = [];
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+  let interruptionFailure = null;
+  let interruptionCleanupFailure = null;
+  let stopping = false;
+  const interrupted = Promise.withResolvers();
+  const interrupt = (failure) => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    interruptionFailure = failure;
+    const stop = async () => {
+      try {
+        await stopProcessTree(child);
+      } catch (error61) {
+        interruptionCleanupFailure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
+          "process_termination_failed",
+          "The executable process could not be stopped",
+          { cause: error61 }
+        );
+      } finally {
+        interrupted.resolve();
+      }
+    };
+    void stop();
+  };
+  const collectStdout = (chunk) => {
+    if (interruptionFailure !== null) {
+      return;
+    }
+    try {
+      stdoutBytes = appendBounded(stdout, chunk, stdoutBytes, outputLimitBytes);
+    } catch (error61) {
+      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
+        "process_output_limit",
+        "The executable produced too much output",
+        { cause: error61 }
+      );
+      interrupt(failure);
+    }
+  };
+  const collectStderr = (chunk) => {
+    if (interruptionFailure !== null) {
+      return;
+    }
+    try {
+      stderrBytes = appendBounded(stderr, chunk, stderrBytes, outputLimitBytes);
+    } catch (error61) {
+      const failure = error61 instanceof ProcessExecutionError ? error61 : new ProcessExecutionError(
+        "process_output_limit",
+        "The executable produced too much output",
+        { cause: error61 }
+      );
+      interrupt(failure);
+    }
+  };
+  child.stdout?.on("data", collectStdout);
+  child.stderr?.on("data", collectStderr);
+  const timeout = setTimeout(() => {
+    interrupt(
+      new ProcessExecutionError(
+        "process_timeout",
+        "The executable probe timed out"
+      )
+    );
+  }, options.timeoutMilliseconds);
+  const abort = () => interrupt(
+    new ProcessExecutionError(
+      "process_cancelled",
+      "The executable probe was cancelled",
+      { cause: options.signal.reason }
+    )
+  );
+  options.signal.addEventListener("abort", abort, { once: true });
+  if (options.signal.aborted) {
+    abort();
   }
-  const decoded = schema.safeParse(value);
-  if (!decoded.success) {
-    throw new ProtocolMessageError("Message does not match its schema", {
-      cause: decoded.error
+  try {
+    const exit = new Promise((resolveExit, rejectExit) => {
+      child.once("error", rejectExit);
+      child.once("exit", (code) => resolveExit(code ?? 1));
     });
+    const exitCode = await Promise.race([
+      exit,
+      interrupted.promise.then(() => -1)
+    ]);
+    if (interruptionCleanupFailure !== null) {
+      throw interruptionCleanupFailure;
+    }
+    if (interruptionFailure !== null) {
+      throw interruptionFailure;
+    }
+    if (exitCode !== 0) {
+      throw new ProcessExecutionError(
+        "process_exit_failed",
+        "The executable probe failed"
+      );
+    }
+    return new ProcessResult(
+      Buffer.concat(stdout).toString("utf8"),
+      Buffer.concat(stderr).toString("utf8")
+    );
+  } catch (error61) {
+    if (error61 instanceof ProcessExecutionError) {
+      throw error61;
+    }
+    throw new ProcessExecutionError(
+      "process_spawn_failed",
+      "The executable could not be started",
+      { cause: error61 }
+    );
+  } finally {
+    clearTimeout(timeout);
+    options.signal.removeEventListener("abort", abort);
+    child.stdout?.removeListener("data", collectStdout);
+    child.stderr?.removeListener("data", collectStderr);
+    if (stopping) {
+      await interrupted.promise;
+    } else {
+      await stopProcessTree(child);
+    }
+  }
+}
+
+// src/agent-catalog/local-agent.ts
+function readTrustedIdentity(path2) {
+  const resolvedPath = realpathSync(path2);
+  const metadata = statSync(resolvedPath);
+  return new ExecutableIdentity(
+    resolvedPath,
+    resolvedPath,
+    metadata.dev,
+    metadata.ino,
+    metadata.size,
+    metadata.ctimeMs
+  );
+}
+var LocalAgentDefinition = class {
+  adapterIdentity;
+  adapterPath;
+  adapterVersion;
+  agentIdentity;
+  agentVersion;
+  arguments;
+  command;
+  environment;
+  id;
+  label;
+  promptTimeoutMilliseconds;
+  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity, promptTimeoutMilliseconds = 30 * 60 * 1e3) {
+    if (!Number.isSafeInteger(promptTimeoutMilliseconds) || promptTimeoutMilliseconds < 1) {
+      throw new Error("The local Agent prompt deadline is invalid");
+    }
+    this.adapterIdentity = adapterIdentity;
+    this.adapterPath = adapterIdentity.realPath;
+    this.adapterVersion = adapterVersion;
+    this.agentIdentity = agentIdentity;
+    this.agentVersion = agentVersion;
+    this.id = id;
+    this.label = label;
+    this.promptTimeoutMilliseconds = promptTimeoutMilliseconds;
+    this.command = adapterIdentity.realPath;
+    this.arguments = Object.freeze([...arguments_]);
+    this.environment = Object.freeze({ ...environment });
+  }
+};
+var InstallableAgentDefinition = class {
+  id;
+  label;
+  constructor(id, label) {
+    this.id = id;
+    this.label = label;
+  }
+};
+var LocalAgentCatalogSnapshot = class {
+  agents;
+  installableAgents;
+  constructor(agents, installableAgents) {
+    this.agents = Object.freeze([...agents]);
+    this.installableAgents = Object.freeze([...installableAgents]);
+  }
+};
+var LocalAgentCatalogError = class extends Error {
+  code = "agent_not_ready";
+  constructor() {
+    super("The requested local Agent is not ready");
+    this.name = "LocalAgentCatalogError";
+  }
+};
+var LocalAgentCatalog = class {
+  #snapshot;
+  constructor(agents, installableAgents) {
+    this.#snapshot = this.validate(agents, installableAgents);
+  }
+  find = (agentId) => {
+    for (const agent of this.#snapshot.agents) {
+      if (agent.id === agentId) {
+        return agent;
+      }
+    }
+    throw new LocalAgentCatalogError();
+  };
+  read = () => this.#snapshot;
+  transition = (agents, installableAgents) => {
+    const next = this.validate(agents, installableAgents);
+    this.#snapshot = next;
+    return next;
+  };
+  validate = (agents, installableAgents) => {
+    const identifiers = /* @__PURE__ */ new Set();
+    for (const agent of agents) {
+      if (identifiers.has(agent.id)) {
+        throw new Error("The local Agent catalog contains duplicate entries");
+      }
+      identifiers.add(agent.id);
+    }
+    for (const agent of installableAgents) {
+      if (identifiers.has(agent.id)) {
+        throw new Error("A local Agent cannot be ready and installable");
+      }
+      identifiers.add(agent.id);
+    }
+    return new LocalAgentCatalogSnapshot(agents, installableAgents);
+  };
+};
+
+// src/storage/state-directory.ts
+import { homedir } from "node:os";
+import { join as join2, resolve as resolve2 } from "node:path";
+function readStateDirectory(environment = process.env) {
+  const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
+  if (configured !== void 0 && configured.length > 0) {
+    return resolve2(configured);
   }
-  return decoded.data;
+  return join2(homedir(), ".mobius");
 }
-var encode4 = (message, schema) => {
-  const decoded = schema.safeParse(message);
-  if (!decoded.success) {
-    throw new ProtocolMessageError("Message does not match its schema", {
-      cause: decoded.error
-    });
+
+// src/config.ts
+function loadDefaultWorkspace() {
+  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
+  return configuredWorkspace ?? join3(readStateDirectory(), "workspace");
+}
+function createDaemonConfig(connection, agents = [], installableAgents = []) {
+  return {
+    agents,
+    defaultWorkspace: connection.defaultWorkspace,
+    auditDatabasePath: connection.auditDatabasePath,
+    bindingId: "workspace",
+    catalog: new LocalAgentCatalog(agents, installableAgents),
+    channelId: connection.channelId,
+    installableAgents,
+    relayUrl: connection.relayUrl
+  };
+}
+function loadDaemonConfig() {
+  const relayUrl = new URL(
+    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+    process.env["MOBIUS_RELAY_URL"] ?? `ws://127.0.0.1:8787${mobiusApiPath("/channels/local/daemon")}`
+  );
+  relayUrl.searchParams.set(
+    "token",
+    // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+    process.env["MOBIUS_RELAY_TOKEN"] ?? "local-development-token"
+  );
+  if (relayUrl.protocol !== "ws:" && relayUrl.protocol !== "wss:") {
+    throw new Error("MOBIUS_RELAY_URL must use ws or wss");
   }
-  return JSON.stringify(decoded.data);
-};
-var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
-var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
+  return createDaemonConfig(
+    {
+      defaultWorkspace: loadDefaultWorkspace(),
+      auditDatabasePath: (
+        // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+        process.env["MOBIUS_AUDIT_DATABASE"] ?? fileURLToPath(
+          new URL("../../../.mobius/daemon.sqlite", import.meta.url)
+        )
+      ),
+      // biome-ignore lint/complexity/useLiteralKeys: Environment variables use an index signature.
+      channelId: process.env["MOBIUS_CHANNEL_ID"] ?? "local",
+      relayUrl
+    },
+    [],
+    []
+  );
+}
+
+// src/acp/session-manager.ts
+import { spawn as spawn2 } from "node:child_process";
+import {
+  methods as methods2,
+  ndJsonStream,
+  PROTOCOL_VERSION,
+  RequestError
+} from "@agentclientprotocol/sdk";
 
 // src/acp/activity.ts
 var TRUNCATION_MARKER = "\n\u2026 output truncated by Mobius";
@@ -24147,58 +24184,16 @@ var LocalAuthorizationError = class extends Error {
 import { randomUUID } from "node:crypto";
 import {
   mkdir as mkdir3,
-  open as open6,
-  realpath as realpath5,
+  open as open5,
+  realpath as realpath6,
   rename as rename3,
   stat as stat5,
   writeFile as writeFile2
 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename, join as join13, resolve as resolve3 } from "node:path";
+import { basename, join as join14, resolve as resolve3 } from "node:path";
 import { fetch as fetch2 } from "undici";
 
-// src/agent-installation/installation-grants.ts
-import { open as open2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
-var MAX_GRANT_FILE_LENGTH = 16 * 1024;
-var AGENT_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function readGrantedAgents(stateDirectory) {
-  const path2 = join4(stateDirectory, "installation-grants.json");
-  let handle;
-  try {
-    handle = await open2(path2, "r");
-  } catch (error61) {
-    if (error61 instanceof Error && "code" in error61 && error61.code === "ENOENT") {
-      return /* @__PURE__ */ new Set();
-    }
-    throw error61;
-  }
-  try {
-    const metadata = await handle.stat();
-    if (!metadata.isFile() || metadata.size > MAX_GRANT_FILE_LENGTH || typeof process.getuid === "function" && metadata.uid !== process.getuid() || process.platform !== "win32" && (metadata.mode & 63) !== 0) {
-      throw new Error("The local installation grant file is not private");
-    }
-    const encoded = await handle.readFile({ encoding: "utf8" });
-    const value = JSON.parse(encoded);
-    if (!isRecord4(value) || Object.keys(value).length !== 1 || !Array.isArray(value["agents"])) {
-      throw new Error("The local installation grant file is invalid");
-    }
-    const agents = /* @__PURE__ */ new Set();
-    for (const candidate of value["agents"]) {
-      if (typeof candidate !== "string" || !AGENT_ID_PATTERN.test(candidate) || agents.has(candidate)) {
-        throw new Error("The local installation grant file is invalid");
-      }
-      agents.add(candidate);
-    }
-    return agents;
-  } finally {
-    await handle.close();
-  }
-}
-
 // src/agent-catalog/agent-discovery.ts
 var AgentDiscovery = class {
   specification;
@@ -24263,7 +24258,7 @@ var LocalAgentInventory = class {
   discoveries;
   installable;
   unavailable;
-  constructor(discoveries, grantedAgents = /* @__PURE__ */ new Set(), platform = process.platform, architecture = process.arch) {
+  constructor(discoveries, platform = process.platform, architecture = process.arch) {
     const available = [];
     const unavailable = [];
     for (const discovery of discoveries) {
@@ -24286,8 +24281,7 @@ var LocalAgentInventory = class {
       ).map(
         (discovery) => new InstallableAgentDefinition(
           discovery.specification.id,
-          discovery.specification.label,
-          !grantedAgents.has(discovery.specification.id)
+          discovery.specification.label
         )
       )
     );
@@ -24300,13 +24294,13 @@ var LocalAgentInventory = class {
 import {
   mkdir,
   mkdtemp,
-  open as open3,
+  open as open2,
   realpath as realpath2,
   rename,
   rm,
   stat as stat2
 } from "node:fs/promises";
-import { delimiter, dirname as dirname3, isAbsolute, join as join5, relative, sep } from "node:path";
+import { delimiter, dirname as dirname3, isAbsolute, 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;
@@ -24325,6 +24319,7 @@ var ManagedNpmPackageDefinition = class {
 };
 var SriManagedNpmPackageDefinition = class extends ManagedNpmPackageDefinition {
   integrity;
+  requiredDependencies = Object.freeze([]);
   tarballUrl;
   constructor(packageName, version2, executableName, integrity, tarballUrl) {
     super(packageName, version2, executableName);
@@ -24332,6 +24327,18 @@ var SriManagedNpmPackageDefinition = class extends ManagedNpmPackageDefinition {
     this.tarballUrl = tarballUrl;
   }
 };
+var SriManagedNpmDependencyDefinition = class {
+  integrity;
+  packageName;
+  tarballUrl;
+  version;
+  constructor(packageName, version2, integrity, tarballUrl) {
+    this.integrity = integrity;
+    this.packageName = packageName;
+    this.tarballUrl = tarballUrl;
+    this.version = version2;
+  }
+};
 var ManagedNpmPackageError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -24340,11 +24347,11 @@ var ManagedNpmPackageError = class extends Error {
     this.name = "ManagedNpmPackageError";
   }
 };
-function isRecord5(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
-  return join5(root, "node_modules", ...packageName.split("/"));
+  return join4(root, "node_modules", ...packageName.split("/"));
 }
 function isContainedPath(root, candidate) {
   const difference = relative(root, candidate);
@@ -24352,7 +24359,7 @@ function isContainedPath(root, candidate) {
 }
 async function readJsonRecord(path2, maximumBytes) {
   try {
-    const handle = await open3(path2, "r");
+    const handle = await open2(path2, "r");
     try {
       const metadata = await handle.stat();
       if (!metadata.isFile() || metadata.size > maximumBytes) {
@@ -24364,7 +24371,7 @@ async function readJsonRecord(path2, maximumBytes) {
       const value = JSON.parse(
         await handle.readFile({ encoding: "utf8" })
       );
-      if (!isRecord5(value)) {
+      if (!isRecord4(value)) {
         throw new ManagedNpmPackageError(
           "managed_package_verification_failed",
           "The managed npm package metadata is invalid"
@@ -24390,7 +24397,7 @@ function readBinPath(packageMetadata, executableName) {
   if (typeof bin === "string") {
     return bin;
   }
-  if (isRecord5(bin) && typeof bin[executableName] === "string") {
+  if (isRecord4(bin) && typeof bin[executableName] === "string") {
     return bin[executableName];
   }
   throw new ManagedNpmPackageError(
@@ -24398,7 +24405,7 @@ function readBinPath(packageMetadata, executableName) {
     "The managed npm package executable declaration is invalid"
   );
 }
-function verifyPackageLock(lock, definition) {
+function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
   if (lock["lockfileVersion"] !== 3) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -24406,7 +24413,7 @@ function verifyPackageLock(lock, definition) {
     );
   }
   const packages = lock["packages"];
-  if (!isRecord5(packages)) {
+  if (!isRecord4(packages)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package lockfile is invalid"
@@ -24417,10 +24424,10 @@ function verifyPackageLock(lock, definition) {
   let matches = 0;
   for (const [key, candidate] of Object.entries(packages)) {
     const normalizedKey = key.replaceAll("\\", "/");
-    if (definition.verifyDependencyClosure && normalizedKey.length > 0) {
+    if (verifyDependencyClosure && normalizedKey.length > 0) {
       let resolved;
       try {
-        if (!normalizedKey.split("/").includes("node_modules") || !isRecord5(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
+        if (!normalizedKey.split("/").includes("node_modules") || !isRecord4(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
           throw new Error("Invalid locked dependency");
         }
         resolved = new URL(candidate["resolved"]);
@@ -24443,13 +24450,35 @@ function verifyPackageLock(lock, definition) {
       matches += 1;
     }
   }
-  if (matches !== 1 || !isRecord5(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
+  if (matches !== 1 || !isRecord4(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package lockfile does not match the pinned artifact"
     );
   }
 }
+async function verifyRequiredDependency(rootPath, lock, definition) {
+  const dependencyRoot = await realpath2(
+    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(
+    join4(dependencyRoot, "package.json"),
+    PACKAGE_METADATA_LIMIT_BYTES
+  );
+  if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The required managed npm dependency identity is invalid"
+    );
+  }
+  verifyPackageLockEntry(lock, definition, false);
+}
 async function validateManagedNpmPackage(root, definition) {
   try {
     return await validateManagedNpmPackageContents(root, definition);
@@ -24476,7 +24505,7 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   const metadata = await readJsonRecord(
-    join5(packageRoot, "package.json"),
+    join4(packageRoot, "package.json"),
     PACKAGE_METADATA_LIMIT_BYTES
   );
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
@@ -24486,17 +24515,22 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   if (definition instanceof SriManagedNpmPackageDefinition) {
-    verifyPackageLock(
-      await readJsonRecord(
-        join5(rootPath, "package-lock.json"),
-        PACKAGE_LOCK_LIMIT_BYTES
-      ),
-      definition
+    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(
-    join5(packageRoot, declaredBin)
+    join4(packageRoot, declaredBin)
   );
   if (executable === null || !isContainedPath(rootPath, executable.path)) {
     throw new ManagedNpmPackageError(
@@ -24522,7 +24556,7 @@ var ManagedNpmPackageInstaller = class {
     const parent = dirname3(root);
     await mkdir(parent, { mode: 448, recursive: true });
     const staging = await mkdtemp(
-      join5(parent, `.${definition.version}.staging-`)
+      join4(parent, `.${definition.version}.staging-`)
     );
     try {
       const npm = await findExecutableOnPath(
@@ -24552,9 +24586,9 @@ var ManagedNpmPackageInstaller = class {
         `${definition.packageName}@${definition.version}`
       );
       const installEnvironment = {
-        HOME: join5(staging, "home"),
+        HOME: join4(staging, "home"),
         NPM_CONFIG_AUDIT: "false",
-        NPM_CONFIG_CACHE: join5(staging, ".npm-cache"),
+        NPM_CONFIG_CACHE: join4(staging, ".npm-cache"),
         NPM_CONFIG_FUND: "false",
         NPM_CONFIG_IGNORE_SCRIPTS: "true",
         NPM_CONFIG_PACKAGE_LOCK: "true",
@@ -24576,8 +24610,8 @@ var ManagedNpmPackageInstaller = class {
         timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
       await Promise.all([
-        rm(join5(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm(join5(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 {
@@ -24613,7 +24647,7 @@ var ManagedNpmPackageInstaller = class {
 };
 
 // src/agent-catalog/agent-specification.ts
-import { join as join6 } from "node:path";
+import { join as join5 } from "node:path";
 var VERSION_PROBE_TIMEOUT_MILLISECONDS = 3e3;
 var ACP_PROBE_TIMEOUT_MILLISECONDS = 5e3;
 var DEFAULT_PROMPT_TIMEOUT_MILLISECONDS = 30 * 60 * 1e3;
@@ -24627,7 +24661,7 @@ var LocalAgentSpecification = class {
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
     const executable = await resolveExecutablePath(
-      join6(stateDirectory, ...this.managedAgentExecutablePath),
+      join5(stateDirectory, ...this.managedAgentExecutablePath),
       platform
     );
     signal.throwIfAborted();
@@ -24732,9 +24766,84 @@ var CodexAgentSpecification = class extends BridgedAcpAgentDefinition {
   managedAgentExecutablePath = ["agents", "codex", "bin", "codex"];
 };
 
+// src/agent-catalog/agent-probe-error.ts
+var AgentProbeError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "AgentProbeError";
+  }
+};
+
+// src/agent-catalog/agents/verify-session-creation.ts
+import {
+  methods as methods3
+} from "@agentclientprotocol/sdk";
+async function verifySessionCreation(connection, capabilities, defaultWorkspace, signal, label) {
+  const session = await connection.agent.request(
+    methods3.agent.session.new,
+    {
+      additionalDirectories: [],
+      cwd: defaultWorkspace,
+      mcpServers: []
+    },
+    { cancellationSignal: signal }
+  );
+  if (session.sessionId.length === 0) {
+    throw new AgentProbeError(
+      "acp_incompatible",
+      `${label} returned an invalid ACP session`
+    );
+  }
+  if (capabilities.sessionCapabilities?.close != null) {
+    await connection.agent.request(
+      methods3.agent.session.close,
+      { sessionId: session.sessionId },
+      { cancellationSignal: signal }
+    );
+  }
+}
+
+// src/agent-catalog/agents/cursor-cli-agent.ts
+var CURSOR_CLI_TESTED_VERSION = "2026.09.02-c22c1a3";
+var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
+  adapterVersion = CURSOR_CLI_TESTED_VERSION;
+  authenticationCommand = () => "cursor-agent login";
+  agentExecutable = "cursor-agent";
+  id = "cursor";
+  label = "Cursor CLI";
+  constructor() {
+    super(
+      "MOBIUS_CURSOR_PATH",
+      ["--disable-auto-update", "acp"],
+      ["agents", "cursor", CURSOR_CLI_TESTED_VERSION, "bin", "cursor-agent"]
+    );
+  }
+  supportsInstallation = (_platform, _architecture) => false;
+  verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    if (capabilities.loadSession !== true || capabilities.sessionCapabilities?.list == null || !(initialized.authMethods ?? []).some(
+      (method) => method.id === "cursor_login"
+    )) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Cursor CLI reported an unsupported ACP capability set"
+      );
+    }
+    await verifySessionCreation(
+      connection,
+      capabilities,
+      defaultWorkspace,
+      signal,
+      this.label
+    );
+  };
+};
+
 // src/agent-catalog/agents/deepseek-harness-agent.ts
 import { realpath as realpath3, stat as stat3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join7, normalize } from "node:path";
+import { isAbsolute as isAbsolute2, join as join6, normalize } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -24752,16 +24861,6 @@ var DEEPSEEK_HARNESS_PACKAGE = new DeepSeekHarnessManagedPackage(
   "https://registry.npmjs.org/@deepseek-ai/dsh/-/dsh-0.1.2-rc.1.tgz"
 );
 
-// src/agent-catalog/agent-probe-error.ts
-var AgentProbeError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "AgentProbeError";
-  }
-};
-
 // src/agent-catalog/agents/deepseek-harness-agent.ts
 async function validateAgentHome(path2) {
   if (!isAbsolute2(path2) || normalize(path2) !== path2) {
@@ -24819,7 +24918,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join7(
+        selectedHome = join6(
           readStateDirectory(context.environment),
           "agents",
           this.id,
@@ -24840,7 +24939,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join7(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join6(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -24860,6 +24959,166 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   };
 };
 
+// src/agent-catalog/agents/grok-build-agent.ts
+import { realpath as realpath4 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join7, relative as relative2, sep as sep2 } from "node:path";
+
+// src/agent-installation/grok-managed-package.ts
+var GROK_BUILD_MANAGED_VERSION = "1.0.21";
+var GrokBuildManagedPackage = class extends SriManagedNpmPackageDefinition {
+  dependencyResolutionArguments = Object.freeze([
+    "--before=2026-09-04T19:51:47.325Z"
+  ]);
+  includeOptionalDependencies = true;
+  requiredDependencies;
+  verifyDependencyClosure = true;
+  constructor(requiredDependency) {
+    super(
+      "@xai-official/grok",
+      GROK_BUILD_MANAGED_VERSION,
+      "grok",
+      "sha512-6yQqC+h1o+ObaqCxImK23dhkrOX1DEBMOKaH6fCK+B4gX0/8XIKZp0n7iKyBdK8KZa5vhMn7pS45kjX49Tps5g==",
+      "https://registry.npmjs.org/@xai-official/grok/-/grok-1.0.21.tgz"
+    );
+    this.requiredDependencies = Object.freeze([requiredDependency]);
+  }
+};
+var GROK_DARWIN_ARM64_PACKAGE = new SriManagedNpmDependencyDefinition(
+  "@xai-official/grok-darwin-arm64",
+  GROK_BUILD_MANAGED_VERSION,
+  "sha512-I4pKZGnR6Mv4MJOJsB9B/i2o0ODF4eZtp4jHN5feoTqKIeAUVg38OzBtE8aN/wZa7Xg+qhnf6Jd1tcAFvMoFtQ==",
+  "https://registry.npmjs.org/@xai-official/grok-darwin-arm64/-/grok-darwin-arm64-1.0.21.tgz"
+);
+var GROK_DARWIN_X64_PACKAGE = new SriManagedNpmDependencyDefinition(
+  "@xai-official/grok-darwin-x64",
+  GROK_BUILD_MANAGED_VERSION,
+  "sha512-h0nFj3NZ9Kz8w6fQ6UDxxeSIhC1WjwwoRE92iNbG//tZy6YGkppR3s7oRVtt4Xl0CJANKUt0EusyIYnnAvKLzw==",
+  "https://registry.npmjs.org/@xai-official/grok-darwin-x64/-/grok-darwin-x64-1.0.21.tgz"
+);
+var GROK_LINUX_ARM64_PACKAGE = new SriManagedNpmDependencyDefinition(
+  "@xai-official/grok-linux-arm64",
+  GROK_BUILD_MANAGED_VERSION,
+  "sha512-Jlwz9XtZPNKz/V/ydifC8OVu3hIZz7pmoStt8c4KCqkSWjWiZ/PBIC0iJiq8rvByhx5Z0EdSyq8ZXVwtocceGA==",
+  "https://registry.npmjs.org/@xai-official/grok-linux-arm64/-/grok-linux-arm64-1.0.21.tgz"
+);
+var GROK_LINUX_X64_PACKAGE = new SriManagedNpmDependencyDefinition(
+  "@xai-official/grok-linux-x64",
+  GROK_BUILD_MANAGED_VERSION,
+  "sha512-AjDV5ifEz5LFG2Jt5IlhAeEkJati/wOvCchVbR4eIj2ogjvmXoXlzBrYRXuAJpXBy5q0se/Yuez5FxDU9Ju81w==",
+  "https://registry.npmjs.org/@xai-official/grok-linux-x64/-/grok-linux-x64-1.0.21.tgz"
+);
+function grokBuildManagedPackage(platform, architecture) {
+  if (platform === "darwin" && architecture === "arm64") {
+    return new GrokBuildManagedPackage(GROK_DARWIN_ARM64_PACKAGE);
+  }
+  if (platform === "darwin" && architecture === "x64") {
+    return new GrokBuildManagedPackage(GROK_DARWIN_X64_PACKAGE);
+  }
+  if (platform === "linux" && architecture === "arm64") {
+    return new GrokBuildManagedPackage(GROK_LINUX_ARM64_PACKAGE);
+  }
+  if (platform === "linux" && architecture === "x64") {
+    return new GrokBuildManagedPackage(GROK_LINUX_X64_PACKAGE);
+  }
+  throw new Error("Grok Build does not publish a package for this platform");
+}
+
+// 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}`) && !isAbsolute3(difference);
+}
+var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
+  adapterVersion = GROK_BUILD_MANAGED_VERSION;
+  authenticationCommand = () => "grok login";
+  agentExecutable = "grok";
+  agentVersionArguments = ["version"];
+  adapterVersionArguments = ["version"];
+  id = "grok-build";
+  label = "Grok Build";
+  constructor() {
+    super(
+      "MOBIUS_GROK_BUILD_PATH",
+      ["--no-auto-update", "agent", "stdio"],
+      [
+        "agents",
+        "grok-build",
+        GROK_BUILD_MANAGED_VERSION,
+        "home",
+        "bin",
+        "grok"
+      ]
+    );
+  }
+  createLaunchEnvironment = async (agent, context) => {
+    const stateDirectory = readStateDirectory(context.environment);
+    try {
+      const managed = await this.resolveManagedAgent(
+        stateDirectory,
+        context.platform ?? process.platform,
+        context.signal
+      );
+      if (managed.path === agent.path) {
+        return Object.freeze({
+          GROK_HOME: await realpath4(
+            join7(
+              stateDirectory,
+              "agents",
+              this.id,
+              GROK_BUILD_MANAGED_VERSION,
+              "home"
+            )
+          )
+        });
+      }
+    } catch {
+      context.signal.throwIfAborted();
+    }
+    return Object.freeze({});
+  };
+  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
+    );
+    signal.throwIfAborted();
+    if (executable === null || !isContainedPath2(versionRoot, executable.path)) {
+      throw new AgentProbeError(
+        "managed_agent_invalid",
+        "The managed Grok Build executable is invalid"
+      );
+    }
+    return executable;
+  };
+  verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    const session = capabilities.sessionCapabilities;
+    if (capabilities.loadSession !== true || session?.close == null || session.list == null || session.resume == null || !(initialized.authMethods ?? []).some(
+      (method) => method.id === "xai.api_key" || method.id === "grok.com"
+    )) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Grok Build reported an unsupported ACP capability set"
+      );
+    }
+    await verifySessionCreation(
+      connection,
+      capabilities,
+      defaultWorkspace,
+      signal,
+      this.label
+    );
+  };
+};
+
 // src/agent-catalog/agents/opencode-agent.ts
 import { join as join9 } from "node:path";
 
@@ -24871,18 +25130,18 @@ import {
   copyFile,
   mkdir as mkdir2,
   mkdtemp as mkdtemp2,
-  open as open5,
-  realpath as realpath4,
+  open as open4,
+  realpath as realpath5,
   rename as rename2,
   rm as rm2,
   stat as stat4,
   writeFile
 } from "node:fs/promises";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join8, relative as relative2, sep as sep2 } from "node:path";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join8, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { createHash } from "node:crypto";
-import { open as open4, unlink } from "node:fs/promises";
+import { open as open3, unlink } from "node:fs/promises";
 import { fetch } from "undici";
 
 // src/network/environment-proxy.ts
@@ -25014,7 +25273,7 @@ async function downloadVerifiedFile(options, transport = new UndiciInstallerDown
         );
       }
     }
-    handle = await open4(options.destination, "wx", 384);
+    handle = await open3(options.destination, "wx", 384);
     const digest = createHash("sha256");
     const reader = fetched.response.body.getReader();
     let bytes = 0;
@@ -25124,12 +25383,12 @@ var ManagedAgentArchiveError = class extends Error {
 var ManagedAgentArchiveDownloader = class {
   download = async (options) => await downloadVerifiedFile(options);
 };
-function isRecord6(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isContainedPath2(root, candidate) {
-  const difference = relative2(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep2}`) && !isAbsolute3(difference);
+function isContainedPath3(root, candidate) {
+  const difference = relative3(root, candidate);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute4(difference);
 }
 async function hashFile(path2, signal) {
   signal.throwIfAborted();
@@ -25164,7 +25423,7 @@ async function hashFile(path2, signal) {
 async function readManifest(path2) {
   let handle;
   try {
-    handle = await open5(path2, "r");
+    handle = await open4(path2, "r");
   } catch (error61) {
     throw new ManagedAgentArchiveError(
       "managed_archive_verification_failed",
@@ -25183,7 +25442,7 @@ async function readManifest(path2) {
     const parsed = JSON.parse(
       await handle.readFile({ encoding: "utf8" })
     );
-    if (!isRecord6(parsed)) {
+    if (!isRecord5(parsed)) {
       throw new ManagedAgentArchiveError(
         "managed_archive_verification_failed",
         "The managed Agent archive manifest is invalid"
@@ -25205,7 +25464,7 @@ async function readManifest(path2) {
 }
 async function validateManagedAgentArchive(root, definition, signal) {
   try {
-    const rootPath = await realpath4(root);
+    const rootPath = await realpath5(root);
     const rootMetadata = await stat4(rootPath);
     if (!rootMetadata.isDirectory() || typeof process.getuid === "function" && rootMetadata.uid !== process.getuid()) {
       throw new Error("Managed Agent root is not user-owned");
@@ -25217,7 +25476,7 @@ async function validateManagedAgentArchive(root, definition, signal) {
     const executable = await resolveExecutablePath(
       join8(rootPath, "bin", definition.executableName)
     );
-    if (executable === null || !isContainedPath2(rootPath, executable.path) || await hashFile(executable.path, signal) !== manifest["executableSha256"]) {
+    if (executable === null || !isContainedPath3(rootPath, executable.path) || await hashFile(executable.path, signal) !== manifest["executableSha256"]) {
       throw new Error("Managed Agent executable is invalid");
     }
     return executable;
@@ -25273,7 +25532,7 @@ var ManagedAgentArchiveInstaller = class {
       const archivePath = join8(working, definition.archiveName);
       const extractionRoot = join8(working, "extracted");
       await mkdir2(extractionRoot, { mode: 448 });
-      const canonicalExtractionRoot = await realpath4(extractionRoot);
+      const canonicalExtractionRoot = await realpath5(extractionRoot);
       const download = await this.#downloader.download({
         allowedHosts: /* @__PURE__ */ new Set([
           "github.com",
@@ -25311,11 +25570,11 @@ var ManagedAgentArchiveInstaller = class {
         signal,
         timeoutMilliseconds: ARCHIVE_EXTRACTION_TIMEOUT_MILLISECONDS
       });
-      const extracted = await realpath4(
+      const extracted = await realpath5(
         join8(canonicalExtractionRoot, definition.executableName)
       );
       const extractedMetadata = await stat4(extracted);
-      if (!isContainedPath2(canonicalExtractionRoot, extracted) || !extractedMetadata.isFile()) {
+      if (!isContainedPath3(canonicalExtractionRoot, extracted) || !extractedMetadata.isFile()) {
         throw new ManagedAgentArchiveError(
           "managed_archive_verification_failed",
           "The managed Agent archive executable is invalid"
@@ -25470,7 +25729,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 // src/agent-catalog/agents/pi-agent.ts
 import { join as join10 } from "node:path";
 import {
-  methods as methods3
+  methods as methods4
 } from "@agentclientprotocol/sdk";
 
 // src/agent-installation/pi-managed-packages.ts
@@ -25542,7 +25801,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const session = await connection.agent.request(
-      methods3.agent.session.new,
+      methods4.agent.session.new,
       {
         additionalDirectories: [],
         cwd: defaultWorkspace,
@@ -25557,7 +25816,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const prompt = await connection.agent.request(
-      methods3.agent.session.prompt,
+      methods4.agent.session.prompt,
       {
         prompt: [{ text: "/session", type: "text" }],
         sessionId: session.sessionId
@@ -25573,6 +25832,77 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   };
 };
 
+// src/agent-catalog/agents/workbuddy-agent.ts
+import { join as join11 } from "node:path";
+
+// src/agent-installation/workbuddy-managed-package.ts
+var WORKBUDDY_MANAGED_VERSION = "2.146.0";
+var WorkBuddyManagedPackage = class extends SriManagedNpmPackageDefinition {
+  dependencyResolutionArguments = Object.freeze([
+    "--before=2026-09-05T12:39:25.295Z"
+  ]);
+  includeOptionalDependencies = true;
+  verifyDependencyClosure = true;
+};
+var WORKBUDDY_MANAGED_PACKAGE = new WorkBuddyManagedPackage(
+  "@tencent-ai/codebuddy-code",
+  WORKBUDDY_MANAGED_VERSION,
+  "codebuddy",
+  "sha512-81V+8rzYJY8PezHZMs4VZN2nvoijrsRWIuCERTr6hELotcxaZaAcqbQQSbHJcN8eTlFE5TRPlzMI4oEkLCat4A==",
+  "https://registry.npmjs.org/@tencent-ai/codebuddy-code/-/codebuddy-code-2.146.0.tgz"
+);
+
+// src/agent-catalog/agents/workbuddy-agent.ts
+var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
+  adapterVersion = WORKBUDDY_MANAGED_VERSION;
+  authenticationCommand = () => "codebuddy";
+  agentExecutable = "codebuddy";
+  id = "workbuddy";
+  label = "WorkBuddy";
+  constructor() {
+    super(
+      "MOBIUS_WORKBUDDY_PATH",
+      ["--acp"],
+      [
+        "agents",
+        "workbuddy",
+        WORKBUDDY_MANAGED_VERSION,
+        "node_modules",
+        "@tencent-ai",
+        "codebuddy-code",
+        "bin",
+        "codebuddy"
+      ]
+    );
+  }
+  createLaunchEnvironment = () => Promise.resolve(Object.freeze({ DISABLE_AUTOUPDATER: "1" }));
+  resolveManagedAgent = async (stateDirectory, _platform, signal) => {
+    signal.throwIfAborted();
+    const executable = await validateManagedNpmPackage(
+      join11(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
+      WORKBUDDY_MANAGED_PACKAGE
+    );
+    signal.throwIfAborted();
+    return executable;
+  };
+  verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    if (capabilities.loadSession !== true || (initialized.authMethods ?? []).length === 0) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "WorkBuddy reported an unsupported ACP capability set"
+      );
+    }
+    await verifySessionCreation(
+      connection,
+      capabilities,
+      defaultWorkspace,
+      signal,
+      this.label
+    );
+  };
+};
+
 // src/agent-catalog/agents/supported-agent-specifications.ts
 function supportedLocalAgentSpecifications() {
   return Object.freeze([
@@ -25580,24 +25910,27 @@ function supportedLocalAgentSpecifications() {
     new ClaudeCodeAgentSpecification(),
     new PiAgentSpecification(),
     new DeepSeekHarnessAgentSpecification(),
-    new OpenCodeAgentSpecification()
+    new OpenCodeAgentSpecification(),
+    new CursorCliAgentSpecification(),
+    new GrokBuildAgentSpecification(),
+    new WorkBuddyAgentSpecification()
   ]);
 }
 
 // src/agent-catalog/acp-readiness-probe.ts
 import { spawn as spawn3 } from "node:child_process";
 import {
-  methods as methods4,
+  methods as methods5,
   ndJsonStream as ndJsonStream2,
   PROTOCOL_VERSION as PROTOCOL_VERSION2,
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
 
 // src/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute4, join as join12 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join13 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -25659,7 +25992,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join11(
+    const root = join12(
       this.#stateDirectory,
       "adapters",
       specification.id,
@@ -25698,7 +26031,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join12(
+      join13(
         readStateDirectory(context.environment),
         "adapters",
         specification.id,
@@ -25714,7 +26047,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
 async function resolveSpecificationExecutables(executableName, overrideVariable, resolveManaged, context) {
   const override = context.environment[overrideVariable];
   if (override !== void 0) {
-    if (override.length === 0 || !isAbsolute4(override)) {
+    if (override.length === 0 || !isAbsolute5(override)) {
       return [];
     }
     const executable = await resolveExecutablePath(override, context.platform);
@@ -25825,41 +26158,41 @@ var DiscoveryAcpHandler = class {
 };
 function readableAcpStream(input2) {
   let byteLength = 0;
-  let open7 = true;
+  let open6 = true;
   return new ReadableStream({
     start(controller) {
       input2.on("data", (chunk) => {
-        if (!open7) {
+        if (!open6) {
           return;
         }
         if (!(chunk instanceof Uint8Array)) {
-          open7 = false;
+          open6 = false;
           controller.error(new Error("ACP adapter produced invalid output"));
           return;
         }
         byteLength += chunk.byteLength;
         if (byteLength > ACP_OUTPUT_LIMIT_BYTES) {
-          open7 = false;
+          open6 = false;
           controller.error(new Error("ACP adapter output limit exceeded"));
           return;
         }
         controller.enqueue(new Uint8Array(chunk));
       });
       input2.once("end", () => {
-        if (open7) {
-          open7 = false;
+        if (open6) {
+          open6 = false;
           controller.close();
         }
       });
       input2.once("error", (error61) => {
-        if (open7) {
-          open7 = false;
+        if (open6) {
+          open6 = false;
           controller.error(error61);
         }
       });
     },
     cancel() {
-      open7 = false;
+      open6 = false;
     }
   });
 }
@@ -25928,7 +26261,7 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
   try {
     const initialized = await Promise.race([
       connection.agent.request(
-        methods4.agent.initialize,
+        methods5.agent.initialize,
         {
           clientCapabilities: {},
           clientInfo: { name: "mobius", version: "0.0.3" },
@@ -26139,16 +26472,8 @@ async function discoverLocalAgentInventory(options) {
       async (specification) => await discoverAgent(specification, options)
     )
   );
-  let grantedAgents = /* @__PURE__ */ new Set();
-  try {
-    grantedAgents = await readGrantedAgents(
-      readStateDirectory(options.environment)
-    );
-  } catch {
-  }
   return new LocalAgentInventory(
     discoveries,
-    grantedAgents,
     options.platform,
     options.architecture
   );
@@ -26179,7 +26504,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord7(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -26293,7 +26618,7 @@ async function resolveDefaultWorkspace(path2) {
   const requestedWorkspace = resolve3(path2);
   try {
     await mkdir3(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath5(requestedWorkspace);
+    const defaultWorkspace = await realpath6(requestedWorkspace);
     const metadata = await stat5(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError(
@@ -26332,9 +26657,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord7(value)) {
+  if (isRecord6(value)) {
     const error61 = value["error"];
-    if (isRecord7(error61)) {
+    if (isRecord6(error61)) {
       const code = error61["code"];
       const message = error61["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -26348,7 +26673,7 @@ function readRelayError(value) {
   );
 }
 function decodeClaimResponse(value) {
-  if (!isRecord7(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+  if (!isRecord6(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
     throw new PairingClientError(
       "invalid_relay_response",
       "The relay returned an invalid pairing response"
@@ -26370,7 +26695,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
     id: agent.id,
     label: agent.label
   }));
-  const endpoint = new URL("/mobius/api/pairings/claim", options.relayOrigin);
+  const endpoint = mobiusApiUrl(options.relayOrigin, "/pairings/claim");
   let response;
   try {
     response = await fetch2(endpoint, {
@@ -26378,8 +26703,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
         agents,
         installableAgents: installableAgents.map((agent) => ({
           id: agent.id,
-          label: agent.label,
-          requiresLocalApproval: agent.requiresLocalApproval
+          label: agent.label
         })),
         machineName: hostname3(),
         pairingCode: options.code,
@@ -26407,10 +26731,10 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   return decodeClaimResponse(value);
 }
 async function persistConnection(channelId, relayOrigin, daemonToken, defaultWorkspace) {
-  const connectionsDirectory = join13(readStateDirectory(), "connections");
+  const connectionsDirectory = join14(readStateDirectory(), "connections");
   await mkdir3(connectionsDirectory, { mode: 448, recursive: true });
-  const connectionPath = join13(connectionsDirectory, `${channelId}.json`);
-  const temporaryPath = join13(
+  const connectionPath = join14(connectionsDirectory, `${channelId}.json`);
+  const temporaryPath = join14(
     connectionsDirectory,
     `.${channelId}.${randomUUID()}.tmp`
   );
@@ -26433,7 +26757,7 @@ async function persistConnection(channelId, relayOrigin, daemonToken, defaultWor
   return connectionPath;
 }
 function decodeSavedConnection(value, expectedChannelId) {
-  if (!isRecord7(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+  if (!isRecord6(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
     throw new PairingClientError(
       "invalid_connection",
       "The saved connection is invalid"
@@ -26457,13 +26781,13 @@ function decodeSavedConnection(value, expectedChannelId) {
   };
 }
 async function readSavedConnection(channelId) {
-  const connectionPath = join13(
+  const connectionPath = join14(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
   );
   let encoded = "";
-  const handle = await open6(connectionPath, "r");
+  const handle = await open5(connectionPath, "r");
   try {
     const metadata = await handle.stat();
     if (!metadata.isFile() || metadata.size > MAX_CONNECTION_FILE_LENGTH) {
@@ -26506,13 +26830,13 @@ function assertInventoryUsable(inventory) {
 }
 function buildPairedDaemon(connection, connectionPath, inventory) {
   assertInventoryUsable(inventory);
-  const relayUrl = new URL(
-    `/mobius/api/channels/${encodeURIComponent(connection.channelId)}/daemon`,
-    connection.relayOrigin
+  const relayUrl = mobiusApiUrl(
+    connection.relayOrigin,
+    `/channels/${encodeURIComponent(connection.channelId)}/daemon`
   );
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.daemonToken);
-  const auditDatabasePath = join13(
+  const auditDatabasePath = join14(
     readStateDirectory(),
     "audit",
     `${connection.channelId}.sqlite`
@@ -26571,7 +26895,7 @@ async function pairLocalMachine(arguments_, signal = new AbortController().signa
 }
 async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
   const channelId = parseChannelArgument(arguments_);
-  const connectionPath = join13(
+  const connectionPath = join14(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
@@ -26626,8 +26950,7 @@ async function publishAgentCatalog(config2, signal) {
         })),
         installableAgents: catalog.installableAgents.map((agent) => ({
           id: agent.id,
-          label: agent.label,
-          requiresLocalApproval: agent.requiresLocalApproval
+          label: agent.label
         }))
       }),
       dispatcher: environmentProxyDispatcher,
@@ -26668,12 +26991,6 @@ var RequestedInstallation = class extends AgentInstallation {
     super(requestId, agentId);
   }
 };
-var AwaitingLocalApproval = class extends AgentInstallation {
-  status = "awaiting_local_approval";
-  constructor(requestId, agentId) {
-    super(requestId, agentId);
-  }
-};
 var RunningInstallation = class extends AgentInstallation {
   stage;
   status = "running";
@@ -26728,9 +27045,9 @@ var InstallationJob = class {
     this.state = new RequestedInstallation(requestId, agentId);
   }
 };
-function specificationFor(specifications, agentId) {
+function authorizedSpecificationFor(specifications, agentId) {
   for (const specification of specifications) {
-    if (specification.id === agentId) {
+    if (specification.id === agentId && specification.supportsInstallation(process.platform, process.arch)) {
       return specification;
     }
   }
@@ -26749,14 +27066,12 @@ function executionFailure(error61) {
 var AgentInstallationManager = class {
   #activeAgents = /* @__PURE__ */ new Map();
   #audit;
-  #authorizer;
   #executor;
   #jobs = /* @__PURE__ */ new Map();
   #observer;
   #specifications;
-  constructor(specifications, authorizer, executor, observer, audit = new NullInstallationAudit()) {
+  constructor(specifications, executor, observer, audit = new NullInstallationAudit()) {
     this.#audit = audit;
-    this.#authorizer = authorizer;
     this.#executor = executor;
     this.#observer = observer;
     this.#specifications = Object.freeze([...specifications]);
@@ -26787,7 +27102,7 @@ var AgentInstallationManager = class {
       command.requestId,
       command.agentId
     );
-    const specification = specificationFor(
+    const specification = authorizedSpecificationFor(
       this.#specifications,
       command.agentId
     );
@@ -26890,45 +27205,14 @@ var AgentInstallationManager = class {
     }, INSTALLATION_DEADLINE_MILLISECONDS);
     const signal = job.controller.signal;
     try {
-      await this.#transition(
-        job,
-        new AwaitingLocalApproval(job.requestId, job.agentId)
-      );
-      this.#audit.record(
-        "agent_installation_awaiting_approval",
-        job.requestId,
-        job.agentId
-      );
-      const approved = await this.#authorizer.authorize(
-        specification.id,
-        specification.label,
-        job.requestId,
-        signal
-      );
       signal.throwIfAborted();
-      if (!approved) {
-        const denied = new FailedInstallation(
-          job.requestId,
-          job.agentId,
-          "installation_not_authorized",
-          "Installation was not approved on the local machine"
-        );
-        await this.#transition(job, denied);
-        this.#audit.record(
-          "agent_installation_denied",
-          job.requestId,
-          job.agentId
-        );
-        job.completion.resolve(denied);
-        return;
-      }
       this.#audit.record(
         "agent_installation_authorized",
         job.requestId,
-        job.agentId
+        specification.id
       );
       await this.#executor.execute(
-        job.agentId,
+        specification.id,
         job.requestId,
         async (stage) => {
           signal.throwIfAborted();
@@ -27198,12 +27482,10 @@ import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 
 // src/agent-installation/fixed-agent-install-recipes.ts
-import { mkdir as mkdir4, mkdtemp as mkdtemp3, rm as rm3 } from "node:fs/promises";
-import { join as join14 } from "node:path";
-var INSTALLER_DOWNLOAD_LIMIT_BYTES = 1024 * 1024;
-var INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS = 6e4;
-var AGENT_INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
-var MINIMAL_PATH2 = "/usr/bin:/bin";
+import { mkdir as mkdir5, mkdtemp as mkdtemp3, rm as rm3 } from "node:fs/promises";
+import { join as join17 } from "node:path";
+
+// src/agent-installation/fixed-agent-install-recipe.ts
 var FixedAgentInstallRecipe = class {
   assertSupportedPlatform = () => {
     if (process.platform !== "darwin" && process.platform !== "linux" || process.arch !== "arm64" && process.arch !== "x64") {
@@ -27224,28 +27506,243 @@ var FixedAgentInstallRecipe = class {
     return executable;
   };
 };
+
+// src/agent-installation/grok-build-install-recipe.ts
+import { mkdir as mkdir4, realpath as realpath7, stat as stat6 } from "node:fs/promises";
+import { delimiter as delimiter2, dirname as dirname5, isAbsolute as isAbsolute6, join as join15, relative as relative4, sep as sep4 } from "node:path";
+var INSTALL_TIMEOUT_MILLISECONDS2 = 5 * 60 * 1e3;
+function isContainedPath4(root, candidate) {
+  const difference = relative4(root, candidate);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep4}`) && !isAbsolute6(difference);
+}
+async function resolveLifecycleScript(packageRoot) {
+  try {
+    const canonicalPackageRoot = await realpath7(packageRoot);
+    const script = await realpath7(
+      join15(canonicalPackageRoot, "bin", "postinstall.js")
+    );
+    const metadata = await stat6(script);
+    if (!metadata.isFile() || !isContainedPath4(canonicalPackageRoot, script)) {
+      throw new Error("Invalid Grok Build lifecycle script");
+    }
+    return script;
+  } catch (error61) {
+    throw new InstallationManagerError(
+      "agent_verification_failed",
+      "The managed Grok Build lifecycle script is invalid",
+      { cause: error61 }
+    );
+  }
+}
+var GrokBuildInstallRecipe = class extends FixedAgentInstallRecipe {
+  #npmInstaller;
+  id = "grok-build";
+  label = "Grok Build";
+  releaseChannel = GROK_BUILD_MANAGED_VERSION;
+  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
+    super();
+    this.#npmInstaller = npmInstaller;
+  }
+  install = async (options) => {
+    this.assertSupportedPlatform();
+    const definition = grokBuildManagedPackage(process.platform, process.arch);
+    const versionRoot = join15(
+      options.stateDirectory,
+      "agents",
+      this.id,
+      GROK_BUILD_MANAGED_VERSION
+    );
+    const packageRoot = join15(versionRoot, "package");
+    const managedHome = join15(versionRoot, "home");
+    try {
+      await mkdir4(managedHome, { mode: 448, recursive: true });
+      const canonicalHome = await realpath7(managedHome);
+      await options.report("downloading");
+      await options.report("verifying");
+      await options.report("installing_agent");
+      await this.#npmInstaller.install(
+        packageRoot,
+        definition,
+        options.environment,
+        options.signal
+      );
+      options.audit.record(
+        "agent_npm_package_verified",
+        options.requestId,
+        this.id,
+        {
+          integrity: definition.integrity,
+          package: definition.packageName,
+          version: definition.version
+        }
+      );
+      const script = await resolveLifecycleScript(
+        join15(packageRoot, "node_modules", "@xai-official", "grok")
+      );
+      await runBoundedProcess({
+        arguments: [script],
+        command: process.execPath,
+        cwd: dirname5(script),
+        environment: {
+          GROK_HOME: canonicalHome,
+          GROK_INSTALL_COMPLETIONS: "0",
+          GROK_NPM_REGISTRY: "https://registry.npmjs.org/",
+          HOME: canonicalHome,
+          PATH: `${dirname5(process.execPath)}${delimiter2}/usr/bin${delimiter2}/bin`
+        },
+        outputLimitBytes: 64 * 1024,
+        signal: options.signal,
+        timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS2
+      });
+      options.audit.record(
+        "agent_lifecycle_step_completed",
+        options.requestId,
+        this.id,
+        {
+          lifecycle: "postinstall",
+          package: definition.packageName,
+          version: definition.version
+        }
+      );
+      return await this.requireInstalledExecutable(
+        join15(canonicalHome, "bin", "grok")
+      );
+    } catch (error61) {
+      if (options.signal.aborted) {
+        options.signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedNpmPackageError) {
+        if (error61.code === "managed_package_verification_failed") {
+          throw new InstallationManagerError(
+            "agent_verification_failed",
+            "The managed Grok Build packages did not match their pinned artifacts",
+            { cause: error61 }
+          );
+        }
+        if (error61.code === "managed_package_publish_failed") {
+          throw new InstallationManagerError(
+            "agent_publish_failed",
+            "The managed Grok Build package could not be published",
+            { cause: error61 }
+          );
+        }
+        throw new InstallationManagerError(error61.code, error61.message, {
+          cause: error61
+        });
+      }
+      if (error61 instanceof InstallationManagerError) {
+        throw error61;
+      }
+      throw new InstallationManagerError(
+        "agent_install_failed",
+        "The fixed Grok Build installation recipe failed",
+        { cause: error61 }
+      );
+    }
+  };
+};
+
+// src/agent-installation/workbuddy-install-recipe.ts
+import { join as join16 } from "node:path";
+var WorkBuddyInstallRecipe = class extends FixedAgentInstallRecipe {
+  #npmInstaller;
+  id = "workbuddy";
+  label = "WorkBuddy";
+  releaseChannel = WORKBUDDY_MANAGED_VERSION;
+  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
+    super();
+    this.#npmInstaller = npmInstaller;
+  }
+  install = async (options) => {
+    this.assertSupportedPlatform();
+    try {
+      await options.report("downloading");
+      await options.report("verifying");
+      await options.report("installing_agent");
+      const executable = await this.#npmInstaller.install(
+        join16(
+          options.stateDirectory,
+          "agents",
+          this.id,
+          WORKBUDDY_MANAGED_VERSION
+        ),
+        WORKBUDDY_MANAGED_PACKAGE,
+        options.environment,
+        options.signal
+      );
+      options.audit.record(
+        "agent_npm_package_verified",
+        options.requestId,
+        this.id,
+        {
+          integrity: WORKBUDDY_MANAGED_PACKAGE.integrity,
+          package: WORKBUDDY_MANAGED_PACKAGE.packageName,
+          version: WORKBUDDY_MANAGED_PACKAGE.version
+        }
+      );
+      return executable;
+    } catch (error61) {
+      if (options.signal.aborted) {
+        options.signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedNpmPackageError) {
+        if (error61.code === "managed_package_verification_failed") {
+          throw new InstallationManagerError(
+            "agent_verification_failed",
+            "The managed WorkBuddy package did not match its pinned artifact",
+            { cause: error61 }
+          );
+        }
+        if (error61.code === "managed_package_publish_failed") {
+          throw new InstallationManagerError(
+            "agent_publish_failed",
+            "The managed WorkBuddy package could not be published",
+            { cause: error61 }
+          );
+        }
+        throw new InstallationManagerError(error61.code, error61.message, {
+          cause: error61
+        });
+      }
+      if (error61 instanceof InstallationManagerError) {
+        throw error61;
+      }
+      throw new InstallationManagerError(
+        "agent_install_failed",
+        "The fixed WorkBuddy installation recipe failed",
+        { cause: error61 }
+      );
+    }
+  };
+};
+
+// src/agent-installation/fixed-agent-install-recipes.ts
+var INSTALLER_DOWNLOAD_LIMIT_BYTES = 1024 * 1024;
+var INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS = 6e4;
+var AGENT_INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
+var MINIMAL_PATH2 = "/usr/bin:/bin";
 var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
   id = "codex";
   label = "Codex";
   releaseChannel = "latest";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join14(options.stateDirectory, "agents", this.id);
-    const temporaryRoot = join14(options.stateDirectory, "temporary");
+    const root = join17(options.stateDirectory, "agents", this.id);
+    const temporaryRoot = join17(options.stateDirectory, "temporary");
     await Promise.all([
-      mkdir4(root, { mode: 448, recursive: true }),
-      mkdir4(temporaryRoot, { mode: 448, recursive: true })
+      mkdir5(root, { mode: 448, recursive: true }),
+      mkdir5(temporaryRoot, { mode: 448, recursive: true })
     ]);
     const temporaryDirectory = await mkdtemp3(
-      join14(temporaryRoot, ".codex-install-")
+      join17(temporaryRoot, ".codex-install-")
     );
-    const installerPath = join14(temporaryDirectory, "install.sh");
-    const installDirectory = join14(root, "bin");
-    const codexHome = join14(root, "home");
+    const installerPath = join17(temporaryDirectory, "install.sh");
+    const installDirectory = join17(root, "bin");
+    const codexHome = join17(root, "home");
     try {
       await Promise.all([
-        mkdir4(installDirectory, { mode: 448, recursive: true }),
-        mkdir4(codexHome, { mode: 448, recursive: true })
+        mkdir5(installDirectory, { mode: 448, recursive: true }),
+        mkdir5(codexHome, { mode: 448, recursive: true })
       ]);
       await options.report("downloading");
       const download = await downloadVerifiedFile({
@@ -27285,7 +27782,7 @@ var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
         timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
       });
       return await this.requireInstalledExecutable(
-        join14(installDirectory, "codex")
+        join17(installDirectory, "codex")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -27309,17 +27806,17 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
   releaseChannel = "stable";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join14(options.stateDirectory, "agents", this.id);
-    const managedHome = join14(root, "home");
-    const temporaryRoot = join14(options.stateDirectory, "temporary");
+    const root = join17(options.stateDirectory, "agents", this.id);
+    const managedHome = join17(root, "home");
+    const temporaryRoot = join17(options.stateDirectory, "temporary");
     await Promise.all([
-      mkdir4(managedHome, { mode: 448, recursive: true }),
-      mkdir4(temporaryRoot, { mode: 448, recursive: true })
+      mkdir5(managedHome, { mode: 448, recursive: true }),
+      mkdir5(temporaryRoot, { mode: 448, recursive: true })
     ]);
     const temporaryDirectory = await mkdtemp3(
-      join14(temporaryRoot, ".claude-install-")
+      join17(temporaryRoot, ".claude-install-")
     );
-    const installerPath = join14(temporaryDirectory, "install.sh");
+    const installerPath = join17(temporaryDirectory, "install.sh");
     try {
       await options.report("downloading");
       const download = await downloadVerifiedFile({
@@ -27356,7 +27853,7 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
         timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
       });
       return await this.requireInstalledExecutable(
-        join14(managedHome, ".local", "bin", "claude")
+        join17(managedHome, ".local", "bin", "claude")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -27390,7 +27887,7 @@ var PiInstallRecipe = class extends FixedAgentInstallRecipe {
       await options.report("verifying");
       await options.report("installing_agent");
       const executable = await this.#npmInstaller.install(
-        join14(
+        join17(
           options.stateDirectory,
           "agents",
           this.id,
@@ -27457,18 +27954,18 @@ var DeepSeekHarnessInstallRecipe = class extends FixedAgentInstallRecipe {
   install = async (options) => {
     this.assertSupportedPlatform();
     try {
-      const managedHome = join14(
+      const managedHome = join17(
         options.stateDirectory,
         "agents",
         this.id,
         "home"
       );
-      await mkdir4(managedHome, { mode: 448, recursive: true });
+      await mkdir5(managedHome, { mode: 448, recursive: true });
       await options.report("downloading");
       await options.report("verifying");
       await options.report("installing_agent");
       const executable = await this.#npmInstaller.install(
-        join14(
+        join17(
           options.stateDirectory,
           "agents",
           this.id,
@@ -27540,7 +28037,7 @@ var OpenCodeInstallRecipe = class extends FixedAgentInstallRecipe {
       await options.report("verifying");
       await options.report("installing_agent");
       const executable = await this.#archiveInstaller.install(
-        join14(
+        join17(
           options.stateDirectory,
           "agents",
           this.id,
@@ -27599,7 +28096,9 @@ function fixedAgentInstallRecipes() {
     new ClaudeCodeInstallRecipe(),
     new PiInstallRecipe(),
     new DeepSeekHarnessInstallRecipe(),
-    new OpenCodeInstallRecipe()
+    new OpenCodeInstallRecipe(),
+    new GrokBuildInstallRecipe(),
+    new WorkBuddyInstallRecipe()
   ]);
 }
 
@@ -27840,51 +28339,16 @@ var FixedInstallationExecutor = class {
   };
 };
 
-// src/agent-installation/local-installation-authorizer.ts
-import { createInterface } from "node:readline/promises";
-var ConsoleInstallationAuthorizer = class {
-  #stateDirectory;
-  constructor(stateDirectory) {
-    this.#stateDirectory = stateDirectory;
-  }
-  authorize = async (agentId, label, requestId, signal) => {
-    signal.throwIfAborted();
-    const grants = await readGrantedAgents(this.#stateDirectory);
-    signal.throwIfAborted();
-    if (grants.has(agentId)) {
-      return true;
-    }
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-      return false;
-    }
-    const prompt = createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    try {
-      const answer = await prompt.question(
-        `
-Mobius Web requested installation of ${label} (${requestId}). Allow this fixed user-level recipe? [y/N] `,
-        { signal }
-      );
-      const normalized = answer.trim().toLowerCase();
-      return normalized === "y" || normalized === "yes";
-    } finally {
-      prompt.close();
-    }
-  };
-};
-
 // src/authorization/workspace-directory.ts
-import { readdir, realpath as realpath6, stat as stat6 } from "node:fs/promises";
+import { readdir, realpath as realpath8, stat as stat7 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import {
   basename as basename2,
-  dirname as dirname5,
-  isAbsolute as isAbsolute5,
-  join as join15,
+  dirname as dirname6,
+  isAbsolute as isAbsolute7,
+  join as join18,
   normalize as normalize2,
-  relative as relative3
+  relative as relative5
 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
@@ -27934,20 +28398,20 @@ var WorkspaceDirectoryService = class {
     if (id === "home") return homedir2();
     if (id.startsWith("path-")) {
       const path2 = decodePath(id, "path-");
-      if (isAbsolute5(path2)) return path2;
+      if (isAbsolute7(path2)) return path2;
     }
     throw new LocalAuthorizationError("The directory identifier is invalid");
   };
   resolvePath = async (requested, signal) => {
     signal.throwIfAborted();
-    if (!isAbsolute5(requested) || requested.includes("\0") || normalize2(requested) !== requested)
+    if (!isAbsolute7(requested) || requested.includes("\0") || normalize2(requested) !== requested)
       throw new LocalAuthorizationError("The local directory path is invalid");
     try {
-      const target = await realpath6(requested);
+      const target = await realpath8(requested);
       signal.throwIfAborted();
-      const metadata = await stat6(target);
+      const metadata = await stat7(target);
       signal.throwIfAborted();
-      if (!isAbsolute5(target) || normalize2(target) !== target || !metadata.isDirectory())
+      if (!isAbsolute7(target) || normalize2(target) !== target || !metadata.isDirectory())
         throw new LocalAuthorizationError(
           "The selected location is not a directory"
         );
@@ -27962,8 +28426,8 @@ var WorkspaceDirectoryService = class {
     }
   };
   label = (path2) => {
-    const suffix = relative3(homedir2(), path2);
-    return suffix === "" ? "~" : !isAbsolute5(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
+    const suffix = relative5(homedir2(), path2);
+    return suffix === "" ? "~" : !isAbsolute7(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
   };
   identify = async (bindingId, requestedPath, signal) => {
     this.authorizeMachine(bindingId);
@@ -27991,7 +28455,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join15(target, child.name), signal);
+          const path2 = await this.resolvePath(join18(target, child.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -27999,7 +28463,7 @@ var WorkspaceDirectoryService = class {
         }
       }
       entries.sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname5(target);
+      const parent = dirname6(target);
       return new WorkspaceDirectoryListing(
         id,
         this.label(target),
@@ -28792,7 +29256,7 @@ var RelayConnectionLiveness = class {
 
 // src/relay-connection/session-event-outbox.ts
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 function readPendingEnvelope(row) {
   if (typeof row !== "object" || row === null || Array.isArray(row)) {
@@ -28807,7 +29271,7 @@ function readPendingEnvelope(row) {
 var SessionEventOutbox = class {
   #database;
   constructor(path2) {
-    mkdirSync3(dirname6(path2), { recursive: true });
+    mkdirSync3(dirname7(path2), { recursive: true });
     this.#database = new DatabaseSync3(path2);
     this.#database.exec(`
       CREATE TABLE IF NOT EXISTS relay_session_event_outbox (
@@ -29099,17 +29563,6 @@ var DaemonInstallationObserver = class {
     if (state instanceof RequestedInstallation) {
       return Promise.resolve();
     }
-    if (state instanceof AwaitingLocalApproval) {
-      this.#send(
-        socket,
-        encodeAgentInstallAwaitingApprovalEvent({
-          agentId: state.agentId,
-          kind: AGENT_INSTALL_AWAITING_APPROVAL_KIND,
-          requestId: state.requestId
-        })
-      );
-      return Promise.resolve();
-    }
     if (state instanceof RunningInstallation) {
       if (!this.#started.has(state.requestId)) {
         this.#started.add(state.requestId);
@@ -30006,7 +30459,6 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
   );
   const installations = new AgentInstallationManager(
     specifications,
-    new ConsoleInstallationAuthorizer(stateDirectory),
     installationExecutor,
     installationObserver,
     installationAudit