@moxt-ai/mobius 0.0.14 → 0.0.16

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,7 +22,26 @@ 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";
@@ -1985,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])$/;
@@ -18961,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";
@@ -19267,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)
@@ -19353,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);
@@ -21004,11 +21020,9 @@ var LocalAgentDefinition = class {
 var InstallableAgentDefinition = class {
   id;
   label;
-  requiresLocalApproval;
-  constructor(id, label, requiresLocalApproval = true) {
+  constructor(id, label) {
     this.id = id;
     this.label = label;
-    this.requiresLocalApproval = requiresLocalApproval;
   }
 };
 var LocalAgentCatalogSnapshot = class {
@@ -24170,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;
@@ -24286,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) {
@@ -24309,8 +24281,7 @@ var LocalAgentInventory = class {
       ).map(
         (discovery) => new InstallableAgentDefinition(
           discovery.specification.id,
-          discovery.specification.label,
-          !grantedAgents.has(discovery.specification.id)
+          discovery.specification.label
         )
       )
     );
@@ -24323,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;
@@ -24348,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);
@@ -24355,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 = {}) {
@@ -24363,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);
@@ -24375,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) {
@@ -24387,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"
@@ -24413,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(
@@ -24421,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",
@@ -24429,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"
@@ -24440,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"]);
@@ -24466,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);
@@ -24499,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) {
@@ -24509,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(
@@ -24545,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(
@@ -24575,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",
@@ -24599,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 {
@@ -24636,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;
@@ -24650,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();
@@ -24661,6 +24672,7 @@ var LocalAgentSpecification = class {
   };
   createLaunchEnvironment = async (_agent, _context) => Object.freeze({});
   recoveryCommand = () => "";
+  resolveInstalledAgentExecutables = (_context) => Promise.resolve([]);
   supportsInstallation = (platform, architecture) => (platform === "darwin" || platform === "linux") && (architecture === "arm64" || architecture === "x64");
   verifyAcp = (_connection, _initialized, _defaultWorkspace, _signal) => Promise.resolve();
 };
@@ -24755,9 +24767,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 {
@@ -24775,16 +24862,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) {
@@ -24842,7 +24919,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join7(
+        selectedHome = join6(
           readStateDirectory(context.environment),
           "agents",
           this.id,
@@ -24863,7 +24940,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();
@@ -24883,6 +24960,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";
 
@@ -24894,18 +25131,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
@@ -25037,7 +25274,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;
@@ -25147,12 +25384,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();
@@ -25187,7 +25424,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",
@@ -25206,7 +25443,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"
@@ -25228,7 +25465,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");
@@ -25240,7 +25477,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;
@@ -25296,7 +25533,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",
@@ -25334,11 +25571,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"
@@ -25493,7 +25730,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
@@ -25565,7 +25802,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const session = await connection.agent.request(
-      methods3.agent.session.new,
+      methods4.agent.session.new,
       {
         additionalDirectories: [],
         cwd: defaultWorkspace,
@@ -25580,7 +25817,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
@@ -25596,6 +25833,110 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   };
 };
 
+// src/agent-catalog/agents/workbuddy-agent.ts
+import { isAbsolute as isAbsolute5, 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 WORKBUDDY_MACOS_EXECUTABLE_PATH = Object.freeze([
+  "WorkBuddy.app",
+  "Contents",
+  "Resources",
+  "app.asar.unpacked",
+  "cli",
+  "bin",
+  "codebuddy"
+]);
+var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
+  adapterVersion = WORKBUDDY_MANAGED_VERSION;
+  authenticationCommand = () => "codebuddy";
+  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;
+  };
+  resolveInstalledAgentExecutables = async (context) => {
+    context.signal.throwIfAborted();
+    if ((context.platform ?? process.platform) !== "darwin") {
+      return [];
+    }
+    const requestedPaths = [
+      join11("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)
+    ];
+    const homeDirectory = context.environment["HOME"];
+    if (homeDirectory !== void 0 && isAbsolute5(homeDirectory)) {
+      requestedPaths.unshift(
+        join11(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)
+      );
+    }
+    const executables = [];
+    for (const requestedPath of requestedPaths) {
+      const executable = await resolveExecutablePath(requestedPath, "darwin");
+      context.signal.throwIfAborted();
+      if (executable !== null) {
+        executables.push(executable);
+      }
+    }
+    return executables;
+  };
+  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([
@@ -25603,24 +25944,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 isAbsolute6, 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 = {}) {
@@ -25682,7 +26026,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join11(
+    const root = join12(
       this.#stateDirectory,
       "adapters",
       specification.id,
@@ -25721,7 +26065,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join12(
+      join13(
         readStateDirectory(context.environment),
         "adapters",
         specification.id,
@@ -25734,10 +26078,10 @@ async function resolveManagedAdapterExecutable(specification, context) {
   }
   return managed;
 }
-async function resolveSpecificationExecutables(executableName, overrideVariable, resolveManaged, context) {
+async function resolveSpecificationExecutables(executableName, overrideVariable, resolveInstalled, resolveManaged, context) {
   const override = context.environment[overrideVariable];
   if (override !== void 0) {
-    if (override.length === 0 || !isAbsolute4(override)) {
+    if (override.length === 0 || !isAbsolute6(override)) {
       return [];
     }
     const executable = await resolveExecutablePath(override, context.platform);
@@ -25748,19 +26092,30 @@ async function resolveSpecificationExecutables(executableName, overrideVariable,
     context.environment,
     context.platform
   );
+  const installed = await resolveInstalled();
   const managed = await resolveManaged();
-  if (external === null) {
-    return managed === null ? [] : [managed];
+  const executables = [];
+  const paths = /* @__PURE__ */ new Set();
+  if (external !== null) {
+    executables.push(external);
+    paths.add(external.path);
   }
-  if (managed === null || managed.path === external.path) {
-    return [external];
+  for (const executable of installed) {
+    if (!paths.has(executable.path)) {
+      executables.push(executable);
+      paths.add(executable.path);
+    }
+  }
+  if (managed !== null && !paths.has(managed.path)) {
+    executables.push(managed);
   }
-  return [external, managed];
+  return executables;
 }
 async function resolveAgentExecutables(specification, context) {
   return await resolveSpecificationExecutables(
     specification.agentExecutable,
     specification.agentOverrideVariable,
+    async () => await specification.resolveInstalledAgentExecutables(context),
     async () => await resolveManagedExecutable(specification, context),
     context
   );
@@ -25775,6 +26130,7 @@ async function resolveAdapterExecutables(specification, context) {
   return await resolveSpecificationExecutables(
     specification.adapterExecutable,
     specification.adapterOverrideVariable,
+    () => Promise.resolve([]),
     async () => await resolveManagedAdapterExecutable(specification, context),
     context
   );
@@ -25848,41 +26204,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;
     }
   });
 }
@@ -25951,7 +26307,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" },
@@ -26162,16 +26518,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
   );
@@ -26202,7 +26550,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) {
@@ -26316,7 +26664,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(
@@ -26355,9 +26703,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") {
@@ -26371,7 +26719,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"
@@ -26401,8 +26749,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,
@@ -26430,10 +26777,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`
   );
@@ -26456,7 +26803,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"
@@ -26480,13 +26827,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) {
@@ -26535,7 +26882,7 @@ function buildPairedDaemon(connection, connectionPath, inventory) {
   );
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.daemonToken);
-  const auditDatabasePath = join13(
+  const auditDatabasePath = join14(
     readStateDirectory(),
     "audit",
     `${connection.channelId}.sqlite`
@@ -26594,7 +26941,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`
@@ -26649,8 +26996,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,
@@ -26691,12 +27037,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";
@@ -26751,9 +27091,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;
     }
   }
@@ -26772,14 +27112,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]);
@@ -26810,7 +27148,7 @@ var AgentInstallationManager = class {
       command.requestId,
       command.agentId
     );
-    const specification = specificationFor(
+    const specification = authorizedSpecificationFor(
       this.#specifications,
       command.agentId
     );
@@ -26913,45 +27251,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();
@@ -27221,12 +27528,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") {
@@ -27247,28 +27552,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 isAbsolute7, 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}`) && !isAbsolute7(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({
@@ -27308,7 +27828,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) {
@@ -27332,17 +27852,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({
@@ -27379,7 +27899,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) {
@@ -27413,7 +27933,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,
@@ -27480,18 +28000,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,
@@ -27563,7 +28083,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,
@@ -27622,7 +28142,9 @@ function fixedAgentInstallRecipes() {
     new ClaudeCodeInstallRecipe(),
     new PiInstallRecipe(),
     new DeepSeekHarnessInstallRecipe(),
-    new OpenCodeInstallRecipe()
+    new OpenCodeInstallRecipe(),
+    new GrokBuildInstallRecipe(),
+    new WorkBuddyInstallRecipe()
   ]);
 }
 
@@ -27863,51 +28385,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 isAbsolute8,
+  join as join18,
   normalize as normalize2,
-  relative as relative3
+  relative as relative5
 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
@@ -27957,20 +28444,20 @@ var WorkspaceDirectoryService = class {
     if (id === "home") return homedir2();
     if (id.startsWith("path-")) {
       const path2 = decodePath(id, "path-");
-      if (isAbsolute5(path2)) return path2;
+      if (isAbsolute8(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 (!isAbsolute8(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 (!isAbsolute8(target) || normalize2(target) !== target || !metadata.isDirectory())
         throw new LocalAuthorizationError(
           "The selected location is not a directory"
         );
@@ -27985,8 +28472,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 === "" ? "~" : !isAbsolute8(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
   };
   identify = async (bindingId, requestedPath, signal) => {
     this.authorizeMachine(bindingId);
@@ -28014,7 +28501,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();
@@ -28022,7 +28509,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),
@@ -28815,7 +29302,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)) {
@@ -28830,7 +29317,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 (
@@ -29122,17 +29609,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);
@@ -30029,7 +30505,6 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
   );
   const installations = new AgentInstallationManager(
     specifications,
-    new ConsoleInstallationAuthorizer(stateDirectory),
     installationExecutor,
     installationObserver,
     installationAudit