@moxt-ai/mobius 0.0.14 → 0.0.15

package/dist/cli.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { mkdir as mkdir5 } from "node:fs/promises";
+import { mkdir as mkdir6 } from "node:fs/promises";
 
 // src/agent-catalog/local-agent.ts
 import { realpathSync, statSync } from "node:fs";
@@ -521,11 +521,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 {
@@ -644,7 +642,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) {
@@ -667,8 +665,7 @@ var LocalAgentInventory = class {
       ).map(
         (discovery) => new InstallableAgentDefinition(
           discovery.specification.id,
-          discovery.specification.label,
-          !grantedAgents.has(discovery.specification.id)
+          discovery.specification.label
         )
       )
     );
@@ -752,70 +749,17 @@ function formatAgentDiagnostics(inventory, json2) {
 `;
 }
 
-// src/agent-installation/installation-grants.ts
-import { open } from "node:fs/promises";
-import { join as join2 } 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 isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function readGrantedAgents(stateDirectory) {
-  const path2 = join2(stateDirectory, "installation-grants.json");
-  let handle;
-  try {
-    handle = await open(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 (!isRecord(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/storage/state-directory.ts
-import { homedir } from "node:os";
-import { join as join3, 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 join3(homedir(), ".mobius");
-}
-
 // src/agent-installation/managed-npm-package.ts
 import {
   mkdir,
   mkdtemp,
-  open as open2,
+  open,
   realpath as realpath2,
   rename,
   rm,
   stat as stat2
 } from "node:fs/promises";
-import { delimiter, dirname, isAbsolute, join as join4, relative, sep } from "node:path";
+import { delimiter, dirname, isAbsolute, join as join2, 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;
@@ -834,6 +778,7 @@ var ManagedNpmPackageDefinition = class {
 };
 var SriManagedNpmPackageDefinition = class extends ManagedNpmPackageDefinition {
   integrity;
+  requiredDependencies = Object.freeze([]);
   tarballUrl;
   constructor(packageName, version2, executableName, integrity, tarballUrl) {
     super(packageName, version2, executableName);
@@ -841,6 +786,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 = {}) {
@@ -849,11 +806,11 @@ var ManagedNpmPackageError = class extends Error {
     this.name = "ManagedNpmPackageError";
   }
 };
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
-  return join4(root, "node_modules", ...packageName.split("/"));
+  return join2(root, "node_modules", ...packageName.split("/"));
 }
 function isContainedPath(root, candidate) {
   const difference = relative(root, candidate);
@@ -861,7 +818,7 @@ function isContainedPath(root, candidate) {
 }
 async function readJsonRecord(path2, maximumBytes) {
   try {
-    const handle = await open2(path2, "r");
+    const handle = await open(path2, "r");
     try {
       const metadata = await handle.stat();
       if (!metadata.isFile() || metadata.size > maximumBytes) {
@@ -873,7 +830,7 @@ async function readJsonRecord(path2, maximumBytes) {
       const value = JSON.parse(
         await handle.readFile({ encoding: "utf8" })
       );
-      if (!isRecord2(value)) {
+      if (!isRecord(value)) {
         throw new ManagedNpmPackageError(
           "managed_package_verification_failed",
           "The managed npm package metadata is invalid"
@@ -899,7 +856,7 @@ function readBinPath(packageMetadata, executableName) {
   if (typeof bin === "string") {
     return bin;
   }
-  if (isRecord2(bin) && typeof bin[executableName] === "string") {
+  if (isRecord(bin) && typeof bin[executableName] === "string") {
     return bin[executableName];
   }
   throw new ManagedNpmPackageError(
@@ -907,7 +864,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",
@@ -915,7 +872,7 @@ function verifyPackageLock(lock, definition) {
     );
   }
   const packages = lock["packages"];
-  if (!isRecord2(packages)) {
+  if (!isRecord(packages)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package lockfile is invalid"
@@ -926,10 +883,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") || !isRecord2(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") || !isRecord(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"]);
@@ -952,13 +909,35 @@ function verifyPackageLock(lock, definition) {
       matches += 1;
     }
   }
-  if (matches !== 1 || !isRecord2(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
+  if (matches !== 1 || !isRecord(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(
+    join2(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);
@@ -985,7 +964,7 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   const metadata = await readJsonRecord(
-    join4(packageRoot, "package.json"),
+    join2(packageRoot, "package.json"),
     PACKAGE_METADATA_LIMIT_BYTES
   );
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
@@ -995,17 +974,22 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   if (definition instanceof SriManagedNpmPackageDefinition) {
-    verifyPackageLock(
-      await readJsonRecord(
-        join4(rootPath, "package-lock.json"),
-        PACKAGE_LOCK_LIMIT_BYTES
-      ),
-      definition
+    const lock = await readJsonRecord(
+      join2(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(
-    join4(packageRoot, declaredBin)
+    join2(packageRoot, declaredBin)
   );
   if (executable === null || !isContainedPath(rootPath, executable.path)) {
     throw new ManagedNpmPackageError(
@@ -1031,7 +1015,7 @@ var ManagedNpmPackageInstaller = class {
     const parent = dirname(root);
     await mkdir(parent, { mode: 448, recursive: true });
     const staging = await mkdtemp(
-      join4(parent, `.${definition.version}.staging-`)
+      join2(parent, `.${definition.version}.staging-`)
     );
     try {
       const npm = await findExecutableOnPath(
@@ -1061,9 +1045,9 @@ var ManagedNpmPackageInstaller = class {
         `${definition.packageName}@${definition.version}`
       );
       const installEnvironment = {
-        HOME: join4(staging, "home"),
+        HOME: join2(staging, "home"),
         NPM_CONFIG_AUDIT: "false",
-        NPM_CONFIG_CACHE: join4(staging, ".npm-cache"),
+        NPM_CONFIG_CACHE: join2(staging, ".npm-cache"),
         NPM_CONFIG_FUND: "false",
         NPM_CONFIG_IGNORE_SCRIPTS: "true",
         NPM_CONFIG_PACKAGE_LOCK: "true",
@@ -1085,8 +1069,8 @@ var ManagedNpmPackageInstaller = class {
         timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
       await Promise.all([
-        rm(join4(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm(join4(staging, "home"), { force: true, recursive: true })
+        rm(join2(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm(join2(staging, "home"), { force: true, recursive: true })
       ]);
       await validateManagedNpmPackage(staging, definition);
       try {
@@ -1122,7 +1106,7 @@ var ManagedNpmPackageInstaller = class {
 };
 
 // src/agent-catalog/agent-specification.ts
-import { join as join5 } from "node:path";
+import { join as join3 } from "node:path";
 var VERSION_PROBE_TIMEOUT_MILLISECONDS = 3e3;
 var ACP_PROBE_TIMEOUT_MILLISECONDS = 5e3;
 var DEFAULT_PROMPT_TIMEOUT_MILLISECONDS = 30 * 60 * 1e3;
@@ -1136,7 +1120,7 @@ var LocalAgentSpecification = class {
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
     const executable = await resolveExecutablePath(
-      join5(stateDirectory, ...this.managedAgentExecutablePath),
+      join3(stateDirectory, ...this.managedAgentExecutablePath),
       platform
     );
     signal.throwIfAborted();
@@ -1241,9 +1225,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
+} from "@agentclientprotocol/sdk";
+async function verifySessionCreation(connection, capabilities, defaultWorkspace, signal, label) {
+  const session = await connection.agent.request(
+    methods.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(
+      methods.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 join6, normalize } from "node:path";
+import { isAbsolute as isAbsolute2, join as join5, normalize } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -1261,15 +1320,16 @@ 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/storage/state-directory.ts
+import { homedir } from "node:os";
+import { join as join4, resolve as resolve2 } from "node:path";
+function readStateDirectory(environment = process.env) {
+  const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
+  if (configured !== void 0 && configured.length > 0) {
+    return resolve2(configured);
   }
-};
+  return join4(homedir(), ".mobius");
+}
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
 async function validateAgentHome(path2) {
@@ -1328,7 +1388,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join6(
+        selectedHome = join5(
           readStateDirectory(context.environment),
           "agents",
           this.id,
@@ -1349,7 +1409,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join6(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join5(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -1369,6 +1429,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 join6, 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(
+            join6(
+              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(
+      join6(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION)
+    );
+    await validateManagedNpmPackage(
+      join6(versionRoot, "package"),
+      grokBuildManagedPackage(platform, process.arch)
+    );
+    const executable = await resolveExecutablePath(
+      join6(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 join8 } from "node:path";
 
@@ -1380,18 +1600,18 @@ import {
   copyFile,
   mkdir as mkdir2,
   mkdtemp as mkdtemp2,
-  open as open4,
-  realpath as realpath4,
+  open as open3,
+  realpath as realpath5,
   rename as rename2,
   rm as rm2,
   stat as stat4,
   writeFile
 } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute3, join as join7, relative as relative2, sep as sep2 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute4, join as join7, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { createHash } from "node:crypto";
-import { open as open3, unlink } from "node:fs/promises";
+import { open as open2, unlink } from "node:fs/promises";
 import { fetch } from "undici";
 
 // src/network/environment-proxy.ts
@@ -1523,7 +1743,7 @@ async function downloadVerifiedFile(options, transport = new UndiciInstallerDown
         );
       }
     }
-    handle = await open3(options.destination, "wx", 384);
+    handle = await open2(options.destination, "wx", 384);
     const digest = createHash("sha256");
     const reader = fetched.response.body.getReader();
     let bytes = 0;
@@ -1633,12 +1853,12 @@ var ManagedAgentArchiveError = class extends Error {
 var ManagedAgentArchiveDownloader = class {
   download = async (options) => await downloadVerifiedFile(options);
 };
-function isRecord3(value) {
+function isRecord2(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();
@@ -1673,7 +1893,7 @@ async function hashFile(path2, signal) {
 async function readManifest(path2) {
   let handle;
   try {
-    handle = await open4(path2, "r");
+    handle = await open3(path2, "r");
   } catch (error61) {
     throw new ManagedAgentArchiveError(
       "managed_archive_verification_failed",
@@ -1692,7 +1912,7 @@ async function readManifest(path2) {
     const parsed = JSON.parse(
       await handle.readFile({ encoding: "utf8" })
     );
-    if (!isRecord3(parsed)) {
+    if (!isRecord2(parsed)) {
       throw new ManagedAgentArchiveError(
         "managed_archive_verification_failed",
         "The managed Agent archive manifest is invalid"
@@ -1714,7 +1934,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");
@@ -1726,7 +1946,7 @@ async function validateManagedAgentArchive(root, definition, signal) {
     const executable = await resolveExecutablePath(
       join7(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;
@@ -1782,7 +2002,7 @@ var ManagedAgentArchiveInstaller = class {
       const archivePath = join7(working, definition.archiveName);
       const extractionRoot = join7(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",
@@ -1820,11 +2040,11 @@ var ManagedAgentArchiveInstaller = class {
         signal,
         timeoutMilliseconds: ARCHIVE_EXTRACTION_TIMEOUT_MILLISECONDS
       });
-      const extracted = await realpath4(
+      const extracted = await realpath5(
         join7(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"
@@ -1979,7 +2199,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 // src/agent-catalog/agents/pi-agent.ts
 import { join as join9 } from "node:path";
 import {
-  methods
+  methods as methods2
 } from "@agentclientprotocol/sdk";
 
 // src/agent-installation/pi-managed-packages.ts
@@ -2051,7 +2271,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const session = await connection.agent.request(
-      methods.agent.session.new,
+      methods2.agent.session.new,
       {
         additionalDirectories: [],
         cwd: defaultWorkspace,
@@ -2066,7 +2286,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const prompt = await connection.agent.request(
-      methods.agent.session.prompt,
+      methods2.agent.session.prompt,
       {
         prompt: [{ text: "/session", type: "text" }],
         sessionId: session.sessionId
@@ -2082,6 +2302,77 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   };
 };
 
+// src/agent-catalog/agents/workbuddy-agent.ts
+import { join as join10 } 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(
+      join10(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([
@@ -2089,14 +2380,17 @@ 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 spawn2 } from "node:child_process";
 import {
-  methods as methods3,
+  methods as methods4,
   ndJsonStream,
   PROTOCOL_VERSION,
   RequestError
@@ -2105,25 +2399,47 @@ import {
 // src/acp/create-client.ts
 import {
   client,
-  methods as methods2
+  methods as methods3
 } from "@agentclientprotocol/sdk";
+function discardExtensionParams(_params) {
+  return Object.freeze({});
+}
 var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
-  methods2.client.session.requestPermission,
+  methods3.client.session.requestPermission,
   async (context) => await handler.onPermission(context.params, context.signal)
 ).onRequest(
-  methods2.client.elicitation.create,
+  methods3.client.elicitation.create,
   async (context) => await handler.onElicitation(context.params, context.signal)
-).onNotification(methods2.client.session.update, async (context) => {
+).onNotification(methods3.client.session.update, async (context) => {
   await handler.onUpdate(context.params);
-}).onNotification(methods2.client.elicitation.complete, async (context) => {
+}).onNotification(methods3.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/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute4, join as join11 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join12 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -2185,7 +2501,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join10(
+    const root = join11(
       this.#stateDirectory,
       "adapters",
       specification.id,
@@ -2224,7 +2540,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join11(
+      join12(
         readStateDirectory(context.environment),
         "adapters",
         specification.id,
@@ -2240,7 +2556,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);
@@ -2351,41 +2667,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;
     }
   });
 }
@@ -2454,7 +2770,7 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
   try {
     const initialized = await Promise.race([
       connection.agent.request(
-        methods3.agent.initialize,
+        methods4.agent.initialize,
         {
           clientCapabilities: {},
           clientInfo: { name: "mobius", version: "0.0.3" },
@@ -2665,16 +2981,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
   );
@@ -2731,7 +3039,7 @@ var AuditStore = class {
 };
 
 // src/config.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -4693,8 +5001,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])$/;
@@ -7751,7 +8059,7 @@ function bucketFor(state, inst) {
   return bucket;
 }
 var handoff;
-var open5 = [];
+var open4 = [];
 var memo = {
   alloc(_inst, payload, empty) {
     const bucket = handoff;
@@ -7760,7 +8068,7 @@ var memo = {
     handoff = void 0;
     const entry = { value: empty, issues: null };
     bucket.set(payload.value, entry);
-    open5.push(entry);
+    open4.push(entry);
     return empty;
   },
   guard(inst) {
@@ -7826,10 +8134,10 @@ var memo = {
           return payload;
         }
         handoff = bucket;
-        const depth = open5.length;
+        const depth = open4.length;
         const result = base(payload, ctx);
         handoff = void 0;
-        const entry = open5.length > depth ? open5.pop() : void 0;
+        const entry = open4.length > depth ? open4.pop() : void 0;
         if (result instanceof Promise) {
           return result.then((r) => {
             if (entry)
@@ -21669,7 +21977,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";
@@ -21975,10 +22282,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)
@@ -22061,7 +22364,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);
@@ -22118,7 +22420,7 @@ var ProtocolMessageError = class extends Error {
     this.name = "ProtocolMessageError";
   }
 };
-function isRecord4(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseJson2(encoded) {
@@ -22130,7 +22432,7 @@ function parseJson2(encoded) {
       cause: error61
     });
   }
-  if (!isRecord4(value)) {
+  if (!isRecord3(value)) {
     throw new ProtocolMessageError("Message must be a JSON object");
   }
   return value;
@@ -22214,7 +22516,7 @@ function readActivityContent(value) {
 }
 function readActivityDetail(value) {
   const field = value["detail"];
-  if (!isRecord4(field)) {
+  if (!isRecord3(field)) {
     throw new ProtocolMessageError("Invalid activity detail field");
   }
   const kind = readString(field, "kind", 32);
@@ -23202,7 +23504,7 @@ var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAckno
 // src/config.ts
 function loadDefaultWorkspace() {
   const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
-  return configuredWorkspace ?? join12(readStateDirectory(), "workspace");
+  return configuredWorkspace ?? join13(readStateDirectory(), "workspace");
 }
 function createDaemonConfig(connection, agents = [], installableAgents = []) {
   return {
@@ -23221,14 +23523,14 @@ function createDaemonConfig(connection, agents = [], installableAgents = []) {
 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";
 var PAIRING_TIMEOUT_MILLISECONDS = 2e4;
 var PAIRING_CODE_PATTERN = /^[A-HJ-NP-Z2-9]{4}(?:-[A-HJ-NP-Z2-9]{4}){4}$/;
@@ -23254,7 +23556,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord5(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -23368,7 +23670,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(
@@ -23407,9 +23709,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord5(value)) {
+  if (isRecord4(value)) {
     const error61 = value["error"];
-    if (isRecord5(error61)) {
+    if (isRecord4(error61)) {
       const code = error61["code"];
       const message = error61["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -23423,7 +23725,7 @@ function readRelayError(value) {
   );
 }
 function decodeClaimResponse(value) {
-  if (!isRecord5(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+  if (!isRecord4(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
     throw new PairingClientError(
       "invalid_relay_response",
       "The relay returned an invalid pairing response"
@@ -23453,8 +23755,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,
@@ -23482,10 +23783,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`
   );
@@ -23508,7 +23809,7 @@ async function persistConnection(channelId, relayOrigin, daemonToken, defaultWor
   return connectionPath;
 }
 function decodeSavedConnection(value, expectedChannelId) {
-  if (!isRecord5(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+  if (!isRecord4(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
     throw new PairingClientError(
       "invalid_connection",
       "The saved connection is invalid"
@@ -23532,13 +23833,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) {
@@ -23587,7 +23888,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`
@@ -23646,7 +23947,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`
@@ -23668,7 +23969,7 @@ import { WebSocket as WebSocket2 } from "undici";
 // src/acp/session-manager.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
@@ -23676,7 +23977,7 @@ import {
 
 // src/acp/activity.ts
 var TRUNCATION_MARKER = "\n\u2026 output truncated by Mobius";
-function isRecord6(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var AcpActivity = class _AcpActivity {
@@ -23950,7 +24251,7 @@ function contentPhase(content) {
     return "";
   }
   const codex = metadata["codex"];
-  if (!isRecord6(codex)) {
+  if (!isRecord5(codex)) {
     return "";
   }
   const phase = codex["phase"];
@@ -24584,7 +24885,7 @@ function createWritableAcpStream(output2) {
 function truncate2(value, maximumLength) {
   return value.length <= maximumLength ? value : `${value.slice(0, Math.max(0, maximumLength - 1))}\u2026`;
 }
-function isRecord7(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString3(value, fallback = "") {
@@ -24614,7 +24915,7 @@ function normalizeConfigValues(value) {
   }
   const normalized = [];
   for (const entry of value) {
-    if (!isRecord7(entry)) {
+    if (!isRecord6(entry)) {
       continue;
     }
     const groupedOptions = entry["options"];
@@ -24622,7 +24923,7 @@ function normalizeConfigValues(value) {
       const groupId = readString3(entry["group"]);
       const groupName = readString3(entry["name"]);
       for (const groupedOption of groupedOptions) {
-        if (isRecord7(groupedOption)) {
+        if (isRecord6(groupedOption)) {
           normalized.push(
             normalizeConfigValue(groupedOption, groupId, groupName)
           );
@@ -24638,7 +24939,7 @@ function normalizeConfigOptions(value, modes) {
   const normalized = [];
   if (Array.isArray(value)) {
     for (const option of value) {
-      if (!isRecord7(option)) {
+      if (!isRecord6(option)) {
         continue;
       }
       const id = truncate2(readString3(option["id"]), 128);
@@ -24677,12 +24978,12 @@ function normalizeConfigOptions(value, modes) {
       }
     }
   }
-  if (isRecord7(modes)) {
+  if (isRecord6(modes)) {
     const values = [];
     const availableModes = modes["availableModes"];
     if (Array.isArray(availableModes)) {
       for (const mode of availableModes) {
-        if (!isRecord7(mode)) {
+        if (!isRecord6(mode)) {
           continue;
         }
         const id = truncate2(readString3(mode["id"]), 500);
@@ -24760,7 +25061,7 @@ function normalizeElicitationOptions(schema) {
   const oneOf = schema["oneOf"];
   if (Array.isArray(oneOf)) {
     for (const option of oneOf) {
-      if (isRecord7(option) && typeof option["const"] === "string") {
+      if (isRecord6(option) && typeof option["const"] === "string") {
         normalized.push({
           description: truncate2(readString3(option["description"]), 500),
           label: truncate2(readString3(option["title"], option["const"]), 255),
@@ -24780,7 +25081,7 @@ function normalizeElicitationOptions(schema) {
     return normalized.slice(0, 200);
   }
   const items = schema["items"];
-  if (!isRecord7(items)) {
+  if (!isRecord6(items)) {
     return normalized;
   }
   const anyOf = items["anyOf"];
@@ -24793,7 +25094,7 @@ function numericString(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toString() : "";
 }
 function normalizeElicitationFields(requestedSchema) {
-  if (!isRecord7(requestedSchema) || !isRecord7(requestedSchema["properties"])) {
+  if (!isRecord6(requestedSchema) || !isRecord6(requestedSchema["properties"])) {
     return [];
   }
   const properties = requestedSchema["properties"];
@@ -24803,7 +25104,7 @@ function normalizeElicitationFields(requestedSchema) {
   );
   const normalized = [];
   for (const [name, property] of Object.entries(properties)) {
-    if (!isRecord7(property)) {
+    if (!isRecord6(property)) {
       continue;
     }
     const type = elicitationFieldType(property["type"]);
@@ -24898,7 +25199,7 @@ function validateElicitationContent(encoded, requestedSchema) {
       "invalid_elicitation_response"
     );
   }
-  if (!isRecord7(decoded) || !isRecord7(requestedSchema) || !isRecord7(requestedSchema["properties"])) {
+  if (!isRecord6(decoded) || !isRecord6(requestedSchema) || !isRecord6(requestedSchema["properties"])) {
     throw new AcpExecutionError(
       "Elicitation response does not match the requested form",
       {},
@@ -24922,7 +25223,7 @@ function validateElicitationContent(encoded, requestedSchema) {
   const validated = {};
   for (const [name, value] of Object.entries(decoded)) {
     const property = properties[name];
-    if (!isRecord7(property)) {
+    if (!isRecord6(property)) {
       throw new AcpExecutionError(
         `Elicitation field ${name} was not requested`,
         {},
@@ -25213,7 +25514,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       await this.race(
         this.#connection.agent.request(
-          methods4.agent.session.load,
+          methods5.agent.session.load,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -25235,7 +25536,7 @@ var AcpProcessSession = class _AcpProcessSession {
   async #initializeAgent(signal) {
     const initialized = await this.race(
       this.#connection.agent.request(
-        methods4.agent.initialize,
+        methods5.agent.initialize,
         {
           clientCapabilities: {
             elicitation: { form: {}, url: {} },
@@ -25303,7 +25604,7 @@ var AcpProcessSession = class _AcpProcessSession {
         );
       const forked = await this.race(
         this.#connection.agent.request(
-          methods4.agent.session.fork,
+          methods5.agent.session.fork,
           {
             sessionId: nativeSessionIdSchema.parse(origin.nativeSessionId),
             cwd: this.#cwd,
@@ -25336,7 +25637,7 @@ var AcpProcessSession = class _AcpProcessSession {
       if (this.#capabilities.resumeSession) {
         lifecycleResponse = await this.race(
           this.#connection.agent.request(
-            methods4.agent.session.resume,
+            methods5.agent.session.resume,
             {
               additionalDirectories: [...this.#additionalDirectories],
               cwd: this.#cwd,
@@ -25353,7 +25654,7 @@ var AcpProcessSession = class _AcpProcessSession {
         try {
           lifecycleResponse = await this.race(
             this.#connection.agent.request(
-              methods4.agent.session.load,
+              methods5.agent.session.load,
               {
                 additionalDirectories: [...this.#additionalDirectories],
                 cwd: this.#cwd,
@@ -25389,7 +25690,7 @@ var AcpProcessSession = class _AcpProcessSession {
       }
       const created = await this.race(
         this.#connection.agent.request(
-          methods4.agent.session.new,
+          methods5.agent.session.new,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -25403,7 +25704,7 @@ var AcpProcessSession = class _AcpProcessSession {
       this.selectNativeSession(created.sessionId);
       lifecycleResponse = created;
     }
-    const lifecycleRecord = isRecord7(lifecycleResponse) ? lifecycleResponse : {};
+    const lifecycleRecord = isRecord6(lifecycleResponse) ? lifecycleResponse : {};
     this.#configOptions = normalizeConfigOptions(
       lifecycleRecord["configOptions"],
       lifecycleRecord["modes"]
@@ -25432,7 +25733,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     const response = await this.race(
       this.#connection.agent.request(
-        methods4.agent.session.list,
+        methods5.agent.session.list,
         cursor === null ? {} : { cursor },
         { cancellationSignal: signal }
       ),
@@ -25457,7 +25758,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     await this.race(
       this.#connection.agent.request(
-        methods4.agent.session.delete,
+        methods5.agent.session.delete,
         { sessionId: nativeSessionIdSchema.parse(nativeSessionId) },
         { cancellationSignal: signal }
       ),
@@ -25488,7 +25789,7 @@ var AcpProcessSession = class _AcpProcessSession {
       if (existing.category === "mode") {
         await this.race(
           this.#connection.agent.request(
-            methods4.agent.session.setMode,
+            methods5.agent.session.setMode,
             { modeId: options.value, sessionId: this.#nativeSessionId },
             { cancellationSignal: options.signal }
           ),
@@ -25501,7 +25802,7 @@ var AcpProcessSession = class _AcpProcessSession {
       } else {
         const response = await this.race(
           this.#connection.agent.request(
-            methods4.agent.session.setConfigOption,
+            methods5.agent.session.setConfigOption,
             {
               configId: existing.id,
               sessionId: this.#nativeSessionId,
@@ -25520,7 +25821,7 @@ var AcpProcessSession = class _AcpProcessSession {
     } else {
       const response = await this.race(
         this.#connection.agent.request(
-          methods4.agent.session.setConfigOption,
+          methods5.agent.session.setConfigOption,
           {
             configId: existing.id,
             sessionId: this.#nativeSessionId,
@@ -25619,7 +25920,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       const response = await this.race(
         this.#connection.agent.request(
-          methods4.agent.session.prompt,
+          methods5.agent.session.prompt,
           { prompt, sessionId: this.#nativeSessionId },
           { cancellationSignal: options.signal }
         ),
@@ -25666,7 +25967,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       await this.cancelPendingInteractions();
       if (this.#turn.running) {
-        await this.#connection.agent.notify(methods4.agent.session.cancel, {
+        await this.#connection.agent.notify(methods5.agent.session.cancel, {
           sessionId: this.#nativeSessionId
         });
       }
@@ -26022,7 +26323,7 @@ var AcpProcessSession = class _AcpProcessSession {
     if (this.#capabilities.closeSession && this.#nativeSessionId.length > 0) {
       try {
         await this.#connection.agent.request(
-          methods4.agent.session.close,
+          methods5.agent.session.close,
           { sessionId: this.#nativeSessionId },
           {
             cancellationSignal: AbortSignal.timeout(
@@ -26659,8 +26960,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,
@@ -26701,12 +27001,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";
@@ -26761,9 +27055,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;
     }
   }
@@ -26782,14 +27076,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]);
@@ -26820,7 +27112,7 @@ var AgentInstallationManager = class {
       command.requestId,
       command.agentId
     );
-    const specification = specificationFor(
+    const specification = authorizedSpecificationFor(
       this.#specifications,
       command.agentId
     );
@@ -26923,45 +27215,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();
@@ -27231,12 +27492,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") {
@@ -27257,28 +27516,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({
@@ -27318,7 +27792,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) {
@@ -27342,17 +27816,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({
@@ -27389,7 +27863,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) {
@@ -27423,7 +27897,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,
@@ -27490,18 +27964,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,
@@ -27573,7 +28047,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,
@@ -27632,7 +28106,9 @@ function fixedAgentInstallRecipes() {
     new ClaudeCodeInstallRecipe(),
     new PiInstallRecipe(),
     new DeepSeekHarnessInstallRecipe(),
-    new OpenCodeInstallRecipe()
+    new OpenCodeInstallRecipe(),
+    new GrokBuildInstallRecipe(),
+    new WorkBuddyInstallRecipe()
   ]);
 }
 
@@ -27873,41 +28349,6 @@ 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/local-authorization-error.ts
 var LocalAuthorizationError = class extends Error {
   code = "local_authorization_failed";
@@ -27918,15 +28359,15 @@ var LocalAuthorizationError = class extends Error {
 };
 
 // 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;
@@ -27976,20 +28417,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"
         );
@@ -28004,8 +28445,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);
@@ -28033,7 +28474,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();
@@ -28041,7 +28482,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),
@@ -28834,7 +29275,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)) {
@@ -28849,7 +29290,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 (
@@ -29141,17 +29582,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);
@@ -30048,7 +30478,6 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
   );
   const installations = new AgentInstallationManager(
     specifications,
-    new ConsoleInstallationAuthorizer(stateDirectory),
     installationExecutor,
     installationObserver,
     installationAudit
@@ -30156,7 +30585,7 @@ async function main() {
     if (arguments_.length > 1 || arguments_.length === 1 && arguments_[0] !== "--json") {
       throw new Error("Usage: mobius agents [--json]");
     }
-    await mkdir5(loadDefaultWorkspace(), { recursive: true, mode: 448 });
+    await mkdir6(loadDefaultWorkspace(), { recursive: true, mode: 448 });
     const inventory = await discoverLocalAgentInventory({
       defaultWorkspace: loadDefaultWorkspace(),
       environment: process.env,