@moxt-ai/mobius 0.0.13 → 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,470 +3039,7 @@ var AuditStore = class {
 };
 
 // src/config.ts
-import { join as join12 } from "node:path";
-function loadDefaultWorkspace() {
-  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
-  return configuredWorkspace ?? join12(readStateDirectory(), "workspace");
-}
-function createDaemonConfig(connection, agents = [], installableAgents = []) {
-  return {
-    agents,
-    defaultWorkspace: connection.defaultWorkspace,
-    auditDatabasePath: connection.auditDatabasePath,
-    bindingId: "workspace",
-    catalog: new LocalAgentCatalog(agents, installableAgents),
-    channelId: connection.channelId,
-    installableAgents,
-    relayUrl: connection.relayUrl
-  };
-}
-
-// src/pairing/pair-local-machine.ts
-import { randomUUID } from "node:crypto";
-import {
-  mkdir as mkdir3,
-  open as open5,
-  realpath as realpath5,
-  rename as rename3,
-  stat as stat5,
-  writeFile as writeFile2
-} from "node:fs/promises";
-import { hostname } from "node:os";
-import { basename, join as join13, 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}$/;
-var IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
-var TOKEN_PATTERN = /^[a-zA-Z0-9_-]{32,256}$/;
-var MAX_CONNECTION_FILE_LENGTH = 16 * 1024;
-var CLAIM_RESPONSE_KEYS = [
-  "channelId",
-  "daemonToken",
-  "runtimeId"
-];
-var SAVED_CONNECTION_KEYS = [
-  "defaultWorkspace",
-  "channelId",
-  "daemonToken",
-  "relayOrigin"
-];
-var PairingClientError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "PairingClientError";
-  }
-};
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function hasExactKeys(value, expectedKeys) {
-  const keys = Object.keys(value);
-  return keys.length === expectedKeys.length && expectedKeys.every((key) => Object.hasOwn(value, key));
-}
-function readSingleOption(arguments_, option) {
-  const values = [];
-  for (let index = 0; index < arguments_.length; index += 1) {
-    if (arguments_[index] !== option) {
-      continue;
-    }
-    const value = arguments_[index + 1];
-    if (value === void 0 || value.startsWith("--")) {
-      throw new PairingClientError(
-        "invalid_arguments",
-        `${option} requires a value`
-      );
-    }
-    values.push(value);
-    index += 1;
-  }
-  if (values.length !== 1) {
-    throw new PairingClientError(
-      "invalid_arguments",
-      `${option} must be provided exactly once`
-    );
-  }
-  return values[0] ?? "";
-}
-function assertKnownArguments(arguments_) {
-  for (let index = 0; index < arguments_.length; index += 2) {
-    const option = arguments_[index];
-    if (option !== "--url" && option !== "--code" && option !== "--workspace") {
-      throw new PairingClientError(
-        "invalid_arguments",
-        `Unknown pairing option: ${option ?? "missing option"}`
-      );
-    }
-  }
-}
-function parseRelayOrigin(value) {
-  let url2;
-  try {
-    url2 = new URL(value);
-  } catch (error61) {
-    throw new PairingClientError(
-      "invalid_relay_url",
-      "The relay URL is invalid",
-      { cause: error61 }
-    );
-  }
-  if (url2.protocol !== "https:" && url2.protocol !== "http:") {
-    throw new PairingClientError(
-      "invalid_relay_url",
-      "The relay URL must use http or https"
-    );
-  }
-  if (url2.username.length > 0 || url2.password.length > 0) {
-    throw new PairingClientError(
-      "invalid_relay_url",
-      "The relay URL cannot contain credentials"
-    );
-  }
-  if (url2.protocol === "http:" && url2.hostname !== "127.0.0.1" && url2.hostname !== "localhost") {
-    throw new PairingClientError(
-      "invalid_relay_url",
-      "A remote relay must use https"
-    );
-  }
-  url2.hash = "";
-  url2.pathname = "/";
-  url2.search = "";
-  return url2;
-}
-function parsePairingCode(value) {
-  const code = value.trim().toUpperCase();
-  if (!PAIRING_CODE_PATTERN.test(code)) {
-    throw new PairingClientError(
-      "invalid_pairing_code",
-      "The pairing code must match the code shown in the browser"
-    );
-  }
-  return code;
-}
-function parsePairCommand(arguments_) {
-  assertKnownArguments(arguments_);
-  return {
-    code: parsePairingCode(readSingleOption(arguments_, "--code")),
-    relayOrigin: parseRelayOrigin(readSingleOption(arguments_, "--url")),
-    workspace: arguments_.includes("--workspace") ? readSingleOption(arguments_, "--workspace") : loadDefaultWorkspace()
-  };
-}
-function parseChannelArgument(arguments_) {
-  if (arguments_.length !== 2 || arguments_[0] !== "--channel") {
-    throw new PairingClientError(
-      "invalid_arguments",
-      "Usage: mobius start --channel <channel-id>"
-    );
-  }
-  const channelId = arguments_[1] ?? "";
-  if (!IDENTIFIER_PATTERN.test(channelId)) {
-    throw new PairingClientError(
-      "invalid_channel_id",
-      "The saved channel ID is invalid"
-    );
-  }
-  return channelId;
-}
-async function resolveDefaultWorkspace(path2) {
-  const requestedWorkspace = resolve3(path2);
-  try {
-    await mkdir3(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath5(requestedWorkspace);
-    const metadata = await stat5(defaultWorkspace);
-    if (!metadata.isDirectory()) {
-      throw new PairingClientError(
-        "invalid_workspace",
-        "The default workspace is not a directory"
-      );
-    }
-    return defaultWorkspace;
-  } catch (error61) {
-    if (error61 instanceof PairingClientError) {
-      throw error61;
-    }
-    throw new PairingClientError(
-      "invalid_workspace",
-      "The default workspace cannot be resolved",
-      { cause: error61 }
-    );
-  }
-}
-async function readJsonResponse(response) {
-  if (response.headers.get("cf-mitigated") === "challenge") {
-    throw new PairingClientError(
-      "relay_challenge",
-      "Cloudflare is protecting this temporary preview. Claim the deployment or use an authenticated deployment, then pair again"
-    );
-  }
-  const encoded = await response.text();
-  try {
-    return JSON.parse(encoded);
-  } catch (error61) {
-    throw new PairingClientError(
-      "invalid_relay_response",
-      "The relay returned an invalid response",
-      { cause: error61 }
-    );
-  }
-}
-function readRelayError(value) {
-  if (isRecord4(value)) {
-    const error61 = value["error"];
-    if (isRecord4(error61)) {
-      const code = error61["code"];
-      const message = error61["message"];
-      if (typeof code === "string" && typeof message === "string") {
-        return new PairingClientError(code, message);
-      }
-    }
-  }
-  return new PairingClientError(
-    "pairing_failed",
-    "The relay could not pair this machine"
-  );
-}
-function decodeClaimResponse(value) {
-  if (!isRecord4(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
-    throw new PairingClientError(
-      "invalid_relay_response",
-      "The relay returned an invalid pairing response"
-    );
-  }
-  const channelId = value["channelId"];
-  const daemonToken = value["daemonToken"];
-  const runtimeId = value["runtimeId"];
-  if (typeof channelId !== "string" || !IDENTIFIER_PATTERN.test(channelId) || typeof daemonToken !== "string" || !TOKEN_PATTERN.test(daemonToken) || typeof runtimeId !== "string" || !IDENTIFIER_PATTERN.test(runtimeId)) {
-    throw new PairingClientError(
-      "invalid_relay_response",
-      "The relay returned an invalid pairing response"
-    );
-  }
-  return { channelId, daemonToken, runtimeId };
-}
-async function claimPairing(options, defaultWorkspace, localAgents, installableAgents, signal) {
-  const agents = localAgents.map((agent) => ({
-    id: agent.id,
-    label: agent.label
-  }));
-  const endpoint = new URL("/mobius/api/pairings/claim", options.relayOrigin);
-  let response;
-  try {
-    response = await fetch2(endpoint, {
-      body: JSON.stringify({
-        agents,
-        installableAgents: installableAgents.map((agent) => ({
-          id: agent.id,
-          label: agent.label,
-          requiresLocalApproval: agent.requiresLocalApproval
-        })),
-        machineName: hostname(),
-        pairingCode: options.code,
-        workspaceName: basename(defaultWorkspace) || "Local workspace"
-      }),
-      dispatcher: environmentProxyDispatcher,
-      headers: { "content-type": "application/json" },
-      method: "POST",
-      signal: AbortSignal.any([
-        signal,
-        AbortSignal.timeout(PAIRING_TIMEOUT_MILLISECONDS)
-      ])
-    });
-  } catch (error61) {
-    throw new PairingClientError(
-      "relay_unavailable",
-      "The pairing relay could not be reached",
-      { cause: error61 }
-    );
-  }
-  const value = await readJsonResponse(response);
-  if (!response.ok) {
-    throw readRelayError(value);
-  }
-  return decodeClaimResponse(value);
-}
-async function persistConnection(channelId, relayOrigin, daemonToken, defaultWorkspace) {
-  const connectionsDirectory = join13(readStateDirectory(), "connections");
-  await mkdir3(connectionsDirectory, { mode: 448, recursive: true });
-  const connectionPath = join13(connectionsDirectory, `${channelId}.json`);
-  const temporaryPath = join13(
-    connectionsDirectory,
-    `.${channelId}.${randomUUID()}.tmp`
-  );
-  await writeFile2(
-    temporaryPath,
-    `${JSON.stringify(
-      {
-        defaultWorkspace,
-        channelId,
-        daemonToken,
-        relayOrigin: relayOrigin.toString()
-      },
-      null,
-      2
-    )}
-`,
-    { flag: "wx", mode: 384 }
-  );
-  await rename3(temporaryPath, connectionPath);
-  return connectionPath;
-}
-function decodeSavedConnection(value, expectedChannelId) {
-  if (!isRecord4(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
-    throw new PairingClientError(
-      "invalid_connection",
-      "The saved connection is invalid"
-    );
-  }
-  const defaultWorkspace = value["defaultWorkspace"];
-  const channelId = value["channelId"];
-  const daemonToken = value["daemonToken"];
-  const relayOrigin = value["relayOrigin"];
-  if (typeof defaultWorkspace !== "string" || typeof channelId !== "string" || channelId !== expectedChannelId || !IDENTIFIER_PATTERN.test(channelId) || typeof daemonToken !== "string" || !TOKEN_PATTERN.test(daemonToken) || typeof relayOrigin !== "string") {
-    throw new PairingClientError(
-      "invalid_connection",
-      "The saved connection is invalid"
-    );
-  }
-  return {
-    defaultWorkspace,
-    channelId,
-    daemonToken,
-    relayOrigin: parseRelayOrigin(relayOrigin)
-  };
-}
-async function readSavedConnection(channelId) {
-  const connectionPath = join13(
-    readStateDirectory(),
-    "connections",
-    `${channelId}.json`
-  );
-  let encoded = "";
-  const handle = await open5(connectionPath, "r");
-  try {
-    const metadata = await handle.stat();
-    if (!metadata.isFile() || metadata.size > MAX_CONNECTION_FILE_LENGTH) {
-      throw new PairingClientError(
-        "invalid_connection",
-        "The saved connection is invalid"
-      );
-    }
-    encoded = await handle.readFile({ encoding: "utf8" });
-  } finally {
-    await handle.close();
-  }
-  let value;
-  try {
-    value = JSON.parse(encoded);
-  } catch (error61) {
-    throw new PairingClientError(
-      "invalid_connection",
-      "The saved connection is invalid",
-      { cause: error61 }
-    );
-  }
-  const connection = decodeSavedConnection(value, channelId);
-  return {
-    defaultWorkspace: await resolveDefaultWorkspace(
-      connection.defaultWorkspace
-    ),
-    channelId: connection.channelId,
-    daemonToken: connection.daemonToken,
-    relayOrigin: connection.relayOrigin
-  };
-}
-function assertInventoryUsable(inventory) {
-  if (inventory.available.length + inventory.installable.length === 0) {
-    throw new PairingClientError(
-      "no_supported_agent",
-      "No supported Agent is ready or safely installable on this machine"
-    );
-  }
-}
-function buildPairedDaemon(connection, connectionPath, inventory) {
-  assertInventoryUsable(inventory);
-  const relayUrl = new URL(
-    `/mobius/api/channels/${encodeURIComponent(connection.channelId)}/daemon`,
-    connection.relayOrigin
-  );
-  relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
-  relayUrl.searchParams.set("token", connection.daemonToken);
-  const auditDatabasePath = join13(
-    readStateDirectory(),
-    "audit",
-    `${connection.channelId}.sqlite`
-  );
-  return {
-    channelUrl: new URL(
-      `/channels/${encodeURIComponent(connection.channelId)}`,
-      connection.relayOrigin
-    ).toString(),
-    config: createDaemonConfig(
-      {
-        defaultWorkspace: connection.defaultWorkspace,
-        auditDatabasePath,
-        channelId: connection.channelId,
-        relayUrl
-      },
-      inventory.readyAgents(),
-      inventory.installable
-    ),
-    connectionPath
-  };
-}
-async function pairLocalMachine(arguments_, signal = new AbortController().signal) {
-  const options = parsePairCommand(arguments_);
-  const defaultWorkspace = await resolveDefaultWorkspace(options.workspace);
-  const inventory = await discoverLocalAgentInventory({
-    defaultWorkspace,
-    environment: process.env,
-    signal
-  });
-  assertInventoryUsable(inventory);
-  const agents = inventory.readyAgents();
-  const claim2 = await claimPairing(
-    options,
-    defaultWorkspace,
-    agents,
-    inventory.installable,
-    signal
-  );
-  const connectionPath = await persistConnection(
-    claim2.channelId,
-    options.relayOrigin,
-    claim2.daemonToken,
-    defaultWorkspace
-  );
-  return buildPairedDaemon(
-    {
-      defaultWorkspace,
-      channelId: claim2.channelId,
-      daemonToken: claim2.daemonToken,
-      relayOrigin: options.relayOrigin
-    },
-    connectionPath,
-    inventory
-  );
-}
-async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
-  const channelId = parseChannelArgument(arguments_);
-  const connectionPath = join13(
-    readStateDirectory(),
-    "connections",
-    `${channelId}.json`
-  );
-  const connection = await readSavedConnection(channelId);
-  const inventory = await discoverLocalAgentInventory({
-    defaultWorkspace: connection.defaultWorkspace,
-    environment: process.env,
-    signal
-  });
-  return buildPairedDaemon(connection, connectionPath, inventory);
-}
-
-// src/run-daemon.ts
-import { basename as basename3 } from "node:path";
-import { styleText } from "node:util";
+import { join as join13 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -3336,7 +3181,7 @@ __export(external_exports, {
   guid: () => guid2,
   hash: () => hash,
   hex: () => hex2,
-  hostname: () => hostname3,
+  hostname: () => hostname2,
   httpUrl: () => httpUrl,
   includes: () => _includes,
   input: () => input,
@@ -5082,7 +4927,7 @@ __export(regexes_exports, {
   extendedDuration: () => extendedDuration,
   guid: () => guid,
   hex: () => hex,
-  hostname: () => hostname2,
+  hostname: () => hostname,
   html5Email: () => html5Email,
   httpProtocol: () => httpProtocol,
   idnEmail: () => idnEmail,
@@ -5156,15 +5001,15 @@ 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])$/;
 var cidrv6 = /^(([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}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
-var hostname2 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 var domain = /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
 var httpProtocol = /^https?$/;
 var e164 = /^\+[1-9]\d{6,14}$/;
@@ -8214,7 +8059,7 @@ function bucketFor(state, inst) {
   return bucket;
 }
 var handoff;
-var open6 = [];
+var open4 = [];
 var memo = {
   alloc(_inst, payload, empty) {
     const bucket = handoff;
@@ -8223,7 +8068,7 @@ var memo = {
     handoff = void 0;
     const entry = { value: empty, issues: null };
     bucket.set(payload.value, entry);
-    open6.push(entry);
+    open4.push(entry);
     return empty;
   },
   guard(inst) {
@@ -8289,10 +8134,10 @@ var memo = {
           return payload;
         }
         handoff = bucket;
-        const depth = open6.length;
+        const depth = open4.length;
         const result = base(payload, ctx);
         handoff = void 0;
-        const entry = open6.length > depth ? open6.pop() : void 0;
+        const entry = open4.length > depth ? open4.pop() : void 0;
         if (result instanceof Promise) {
           return result.then((r) => {
             if (entry)
@@ -19676,7 +19521,7 @@ __export(schemas_exports2, {
   guid: () => guid2,
   hash: () => hash,
   hex: () => hex2,
-  hostname: () => hostname3,
+  hostname: () => hostname2,
   httpUrl: () => httpUrl,
   instanceof: () => _instanceof,
   int: () => int,
@@ -20347,7 +20192,7 @@ var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat"
 function stringFormat(format, fnOrRegex, _params = {}) {
   return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
-function hostname3(_params) {
+function hostname2(_params) {
   return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
 }
 function hex2(_params) {
@@ -22132,15 +21977,14 @@ 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";
 var AGENT_INSTALL_FAILED_KIND = "agent.install.failed";
 var AGENT_INSTALL_CANCELLED_KIND = "agent.install.cancelled";
-var IDENTIFIER_PATTERN2 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+var IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
 var DIRECTORY_IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,2047}$/;
-var IDENTIFIER = external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN2);
+var IDENTIFIER = external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN);
 var DIRECTORY_IDENTIFIER = external_exports.string().min(1).max(2048).regex(DIRECTORY_IDENTIFIER_PATTERN);
 var SHORT_TEXT = external_exports.string().max(500);
 var LONG_TEXT = external_exports.string().max(1e5);
@@ -22438,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)
@@ -22524,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);
@@ -22549,7 +22388,7 @@ var SESSION_COMPLETED_KIND = "session.completed";
 var SESSION_FAILED_KIND = "session.failed";
 
 // ../protocol/src/codecs/messages.ts
-var IDENTIFIER_PATTERN3 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+var IDENTIFIER_PATTERN2 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
 var DIRECTORY_IDENTIFIER_PATTERN2 = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,2047}$/;
 var MAX_PROMPT_LENGTH = 1e4;
 var MAX_PROMPT_ATTACHMENT_LENGTH = 6e6;
@@ -22581,7 +22420,7 @@ var ProtocolMessageError = class extends Error {
     this.name = "ProtocolMessageError";
   }
 };
-function isRecord5(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseJson2(encoded) {
@@ -22593,7 +22432,7 @@ function parseJson2(encoded) {
       cause: error61
     });
   }
-  if (!isRecord5(value)) {
+  if (!isRecord3(value)) {
     throw new ProtocolMessageError("Message must be a JSON object");
   }
   return value;
@@ -22677,7 +22516,7 @@ function readActivityContent(value) {
 }
 function readActivityDetail(value) {
   const field = value["detail"];
-  if (!isRecord5(field)) {
+  if (!isRecord3(field)) {
     throw new ProtocolMessageError("Invalid activity detail field");
   }
   const kind = readString(field, "kind", 32);
@@ -22724,7 +22563,7 @@ function readActivityDetail(value) {
 }
 function readIdentifier(value, key) {
   const field = readString(value, key, 128);
-  if (!IDENTIFIER_PATTERN3.test(field)) {
+  if (!IDENTIFIER_PATTERN2.test(field)) {
     throw new ProtocolMessageError(`Invalid identifier field: ${key}`);
   }
   return field;
@@ -22924,6 +22763,29 @@ function encodeSessionFailedEvent(message) {
   return JSON.stringify(decodeSessionFailedEvent(JSON.stringify(message)));
 }
 
+// ../protocol/src/mobius-api.ts
+var MOBIUS_API_PREFIX = "/mobius/api";
+var API_PREFIX_PATTERN = /^\/[a-zA-Z0-9._~-]+(?:\/[a-zA-Z0-9._~-]+)*$/;
+var MobiusApiConfigurationError = class extends Error {
+  code = "invalid_api_prefix";
+  constructor() {
+    super("The Mobius API prefix must be an absolute path without parameters");
+    this.name = "MobiusApiConfigurationError";
+  }
+};
+function parseMobiusApiPrefix(value) {
+  if (typeof value !== "string" || !API_PREFIX_PATTERN.test(value)) {
+    throw new MobiusApiConfigurationError();
+  }
+  return value;
+}
+function mobiusApiPath(resourcePath, apiPrefix = MOBIUS_API_PREFIX) {
+  return `${parseMobiusApiPrefix(apiPrefix)}${resourcePath}`;
+}
+function mobiusApiUrl(origin, resourcePath, apiPrefix = MOBIUS_API_PREFIX) {
+  return new URL(mobiusApiPath(resourcePath, apiPrefix), origin);
+}
+
 // ../protocol/src/session-history.ts
 var SESSION_HISTORY_CHARACTER_LIMIT = 256e3;
 var SESSION_HISTORY_MESSAGE_LIMIT = 1e3;
@@ -23083,10 +22945,10 @@ var encodeNativeSessionResult = (value) => JSON.stringify(nativeSessionResultSch
 var decodeNativeSessionCancel = (encoded) => decode4(nativeSessionCancelSchema, encoded);
 
 // ../protocol/src/resource-model.ts
-var IDENTIFIER_PATTERN4 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+var IDENTIFIER_PATTERN3 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
 var DECIMAL_SEQUENCE_PATTERN = /^(?:0|[1-9][0-9]*)$/;
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
-var identifierSchema = external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4);
+var identifierSchema = external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN3);
 var timestampSchema = external_exports.string().datetime({ offset: true });
 var decimalSequenceSchema = external_exports.string().min(1).max(40).regex(DECIMAL_SEQUENCE_PATTERN);
 var digestSchema = external_exports.string().length(64).regex(SHA256_PATTERN);
@@ -23572,13 +23434,13 @@ var commandReceiptSchema = external_exports.strictObject({
 var SESSION_EVENT_KIND = "session.event";
 var SESSION_EVENT_ACK_KIND = "session.event.ack";
 var SESSION_EVENT_COMMITTED_KIND = "session.event.committed";
-var IDENTIFIER_PATTERN5 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+var IDENTIFIER_PATTERN4 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
 var CURSOR_PATTERN = /^[A-Za-z0-9_-]{1,512}$/;
 var MAX_RECORDED_EVENT_LENGTH = 8 * 1024 * 1024;
 var DECIMAL_SEQUENCE_PATTERN2 = /^(?:0|[1-9][0-9]*)$/;
 var eventSourceSchema = external_exports.discriminatedUnion("kind", [
   external_exports.strictObject({
-    attemptId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN5),
+    attemptId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4),
     kind: external_exports.literal("attempt"),
     sourceSeq: external_exports.string().min(1).max(40).regex(DECIMAL_SEQUENCE_PATTERN2)
   }).readonly(),
@@ -23588,64 +23450,526 @@ var eventSourceSchema = external_exports.discriminatedUnion("kind", [
   }).readonly()
 ]);
 var eventEnvelopeSchema = external_exports.strictObject({
-  eventId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN5),
+  eventId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4),
   kind: external_exports.literal(SESSION_EVENT_KIND),
   payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
-  sessionId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN5),
+  sessionId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4),
   source: eventSourceSchema
 }).readonly();
 var committedEventSchema = external_exports.strictObject({
   cursor: external_exports.string().min(1).max(512).regex(CURSOR_PATTERN),
-  eventId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN5),
+  eventId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4),
   kind: external_exports.literal(SESSION_EVENT_COMMITTED_KIND),
   payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
   recordedAt: external_exports.string().datetime({ offset: true }),
   sequence: external_exports.string().min(1).max(40).regex(DECIMAL_SEQUENCE_PATTERN2),
-  sessionId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN5),
+  sessionId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4),
   source: eventSourceSchema
 }).readonly();
 var eventAcknowledgementSchema = external_exports.strictObject({
   cursor: external_exports.string().min(1).max(512).regex(CURSOR_PATTERN),
   duplicate: external_exports.boolean(),
-  eventId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN5),
+  eventId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4),
   kind: external_exports.literal(SESSION_EVENT_ACK_KIND),
   sequence: external_exports.string().min(1).max(40).regex(DECIMAL_SEQUENCE_PATTERN2),
-  sessionId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN5)
+  sessionId: external_exports.string().min(1).max(128).regex(IDENTIFIER_PATTERN4)
 }).readonly();
 function decode5(encoded, schema) {
   let value;
   try {
     value = JSON.parse(encoded);
-  } catch (cause) {
-    throw new ProtocolMessageError("Message is not valid JSON", { cause });
+  } catch (cause) {
+    throw new ProtocolMessageError("Message is not valid JSON", { cause });
+  }
+  const decoded = schema.safeParse(value);
+  if (!decoded.success) {
+    throw new ProtocolMessageError("Message does not match its schema", {
+      cause: decoded.error
+    });
+  }
+  return decoded.data;
+}
+var encode4 = (message, schema) => {
+  const decoded = schema.safeParse(message);
+  if (!decoded.success) {
+    throw new ProtocolMessageError("Message does not match its schema", {
+      cause: decoded.error
+    });
+  }
+  return JSON.stringify(decoded.data);
+};
+var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
+var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
+
+// src/config.ts
+function loadDefaultWorkspace() {
+  const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
+  return configuredWorkspace ?? join13(readStateDirectory(), "workspace");
+}
+function createDaemonConfig(connection, agents = [], installableAgents = []) {
+  return {
+    agents,
+    defaultWorkspace: connection.defaultWorkspace,
+    auditDatabasePath: connection.auditDatabasePath,
+    bindingId: "workspace",
+    catalog: new LocalAgentCatalog(agents, installableAgents),
+    channelId: connection.channelId,
+    installableAgents,
+    relayUrl: connection.relayUrl
+  };
+}
+
+// src/pairing/pair-local-machine.ts
+import { randomUUID } from "node:crypto";
+import {
+  mkdir as mkdir3,
+  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 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}$/;
+var IDENTIFIER_PATTERN5 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+var TOKEN_PATTERN = /^[a-zA-Z0-9_-]{32,256}$/;
+var MAX_CONNECTION_FILE_LENGTH = 16 * 1024;
+var CLAIM_RESPONSE_KEYS = [
+  "channelId",
+  "daemonToken",
+  "runtimeId"
+];
+var SAVED_CONNECTION_KEYS = [
+  "defaultWorkspace",
+  "channelId",
+  "daemonToken",
+  "relayOrigin"
+];
+var PairingClientError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "PairingClientError";
+  }
+};
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, expectedKeys) {
+  const keys = Object.keys(value);
+  return keys.length === expectedKeys.length && expectedKeys.every((key) => Object.hasOwn(value, key));
+}
+function readSingleOption(arguments_, option) {
+  const values = [];
+  for (let index = 0; index < arguments_.length; index += 1) {
+    if (arguments_[index] !== option) {
+      continue;
+    }
+    const value = arguments_[index + 1];
+    if (value === void 0 || value.startsWith("--")) {
+      throw new PairingClientError(
+        "invalid_arguments",
+        `${option} requires a value`
+      );
+    }
+    values.push(value);
+    index += 1;
+  }
+  if (values.length !== 1) {
+    throw new PairingClientError(
+      "invalid_arguments",
+      `${option} must be provided exactly once`
+    );
+  }
+  return values[0] ?? "";
+}
+function assertKnownArguments(arguments_) {
+  for (let index = 0; index < arguments_.length; index += 2) {
+    const option = arguments_[index];
+    if (option !== "--url" && option !== "--code" && option !== "--workspace") {
+      throw new PairingClientError(
+        "invalid_arguments",
+        `Unknown pairing option: ${option ?? "missing option"}`
+      );
+    }
+  }
+}
+function parseRelayOrigin(value) {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch (error61) {
+    throw new PairingClientError(
+      "invalid_relay_url",
+      "The relay URL is invalid",
+      { cause: error61 }
+    );
+  }
+  if (url2.protocol !== "https:" && url2.protocol !== "http:") {
+    throw new PairingClientError(
+      "invalid_relay_url",
+      "The relay URL must use http or https"
+    );
+  }
+  if (url2.username.length > 0 || url2.password.length > 0) {
+    throw new PairingClientError(
+      "invalid_relay_url",
+      "The relay URL cannot contain credentials"
+    );
+  }
+  if (url2.protocol === "http:" && url2.hostname !== "127.0.0.1" && url2.hostname !== "localhost") {
+    throw new PairingClientError(
+      "invalid_relay_url",
+      "A remote relay must use https"
+    );
+  }
+  url2.hash = "";
+  url2.pathname = "/";
+  url2.search = "";
+  return url2;
+}
+function parsePairingCode(value) {
+  const code = value.trim().toUpperCase();
+  if (!PAIRING_CODE_PATTERN.test(code)) {
+    throw new PairingClientError(
+      "invalid_pairing_code",
+      "The pairing code must match the code shown in the browser"
+    );
+  }
+  return code;
+}
+function parsePairCommand(arguments_) {
+  assertKnownArguments(arguments_);
+  return {
+    code: parsePairingCode(readSingleOption(arguments_, "--code")),
+    relayOrigin: parseRelayOrigin(readSingleOption(arguments_, "--url")),
+    workspace: arguments_.includes("--workspace") ? readSingleOption(arguments_, "--workspace") : loadDefaultWorkspace()
+  };
+}
+function parseChannelArgument(arguments_) {
+  if (arguments_.length !== 2 || arguments_[0] !== "--channel") {
+    throw new PairingClientError(
+      "invalid_arguments",
+      "Usage: mobius start --channel <channel-id>"
+    );
+  }
+  const channelId = arguments_[1] ?? "";
+  if (!IDENTIFIER_PATTERN5.test(channelId)) {
+    throw new PairingClientError(
+      "invalid_channel_id",
+      "The saved channel ID is invalid"
+    );
+  }
+  return channelId;
+}
+async function resolveDefaultWorkspace(path2) {
+  const requestedWorkspace = resolve3(path2);
+  try {
+    await mkdir3(requestedWorkspace, { recursive: true, mode: 448 });
+    const defaultWorkspace = await realpath6(requestedWorkspace);
+    const metadata = await stat5(defaultWorkspace);
+    if (!metadata.isDirectory()) {
+      throw new PairingClientError(
+        "invalid_workspace",
+        "The default workspace is not a directory"
+      );
+    }
+    return defaultWorkspace;
+  } catch (error61) {
+    if (error61 instanceof PairingClientError) {
+      throw error61;
+    }
+    throw new PairingClientError(
+      "invalid_workspace",
+      "The default workspace cannot be resolved",
+      { cause: error61 }
+    );
+  }
+}
+async function readJsonResponse(response) {
+  if (response.headers.get("cf-mitigated") === "challenge") {
+    throw new PairingClientError(
+      "relay_challenge",
+      "Cloudflare is protecting this temporary preview. Claim the deployment or use an authenticated deployment, then pair again"
+    );
+  }
+  const encoded = await response.text();
+  try {
+    return JSON.parse(encoded);
+  } catch (error61) {
+    throw new PairingClientError(
+      "invalid_relay_response",
+      "The relay returned an invalid response",
+      { cause: error61 }
+    );
+  }
+}
+function readRelayError(value) {
+  if (isRecord4(value)) {
+    const error61 = value["error"];
+    if (isRecord4(error61)) {
+      const code = error61["code"];
+      const message = error61["message"];
+      if (typeof code === "string" && typeof message === "string") {
+        return new PairingClientError(code, message);
+      }
+    }
+  }
+  return new PairingClientError(
+    "pairing_failed",
+    "The relay could not pair this machine"
+  );
+}
+function decodeClaimResponse(value) {
+  if (!isRecord4(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+    throw new PairingClientError(
+      "invalid_relay_response",
+      "The relay returned an invalid pairing response"
+    );
+  }
+  const channelId = value["channelId"];
+  const daemonToken = value["daemonToken"];
+  const runtimeId = value["runtimeId"];
+  if (typeof channelId !== "string" || !IDENTIFIER_PATTERN5.test(channelId) || typeof daemonToken !== "string" || !TOKEN_PATTERN.test(daemonToken) || typeof runtimeId !== "string" || !IDENTIFIER_PATTERN5.test(runtimeId)) {
+    throw new PairingClientError(
+      "invalid_relay_response",
+      "The relay returned an invalid pairing response"
+    );
+  }
+  return { channelId, daemonToken, runtimeId };
+}
+async function claimPairing(options, defaultWorkspace, localAgents, installableAgents, signal) {
+  const agents = localAgents.map((agent) => ({
+    id: agent.id,
+    label: agent.label
+  }));
+  const endpoint = mobiusApiUrl(options.relayOrigin, "/pairings/claim");
+  let response;
+  try {
+    response = await fetch2(endpoint, {
+      body: JSON.stringify({
+        agents,
+        installableAgents: installableAgents.map((agent) => ({
+          id: agent.id,
+          label: agent.label
+        })),
+        machineName: hostname3(),
+        pairingCode: options.code,
+        workspaceName: basename(defaultWorkspace) || "Local workspace"
+      }),
+      dispatcher: environmentProxyDispatcher,
+      headers: { "content-type": "application/json" },
+      method: "POST",
+      signal: AbortSignal.any([
+        signal,
+        AbortSignal.timeout(PAIRING_TIMEOUT_MILLISECONDS)
+      ])
+    });
+  } catch (error61) {
+    throw new PairingClientError(
+      "relay_unavailable",
+      "The pairing relay could not be reached",
+      { cause: error61 }
+    );
+  }
+  const value = await readJsonResponse(response);
+  if (!response.ok) {
+    throw readRelayError(value);
+  }
+  return decodeClaimResponse(value);
+}
+async function persistConnection(channelId, relayOrigin, daemonToken, defaultWorkspace) {
+  const connectionsDirectory = join14(readStateDirectory(), "connections");
+  await mkdir3(connectionsDirectory, { mode: 448, recursive: true });
+  const connectionPath = join14(connectionsDirectory, `${channelId}.json`);
+  const temporaryPath = join14(
+    connectionsDirectory,
+    `.${channelId}.${randomUUID()}.tmp`
+  );
+  await writeFile2(
+    temporaryPath,
+    `${JSON.stringify(
+      {
+        defaultWorkspace,
+        channelId,
+        daemonToken,
+        relayOrigin: relayOrigin.toString()
+      },
+      null,
+      2
+    )}
+`,
+    { flag: "wx", mode: 384 }
+  );
+  await rename3(temporaryPath, connectionPath);
+  return connectionPath;
+}
+function decodeSavedConnection(value, expectedChannelId) {
+  if (!isRecord4(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+    throw new PairingClientError(
+      "invalid_connection",
+      "The saved connection is invalid"
+    );
+  }
+  const defaultWorkspace = value["defaultWorkspace"];
+  const channelId = value["channelId"];
+  const daemonToken = value["daemonToken"];
+  const relayOrigin = value["relayOrigin"];
+  if (typeof defaultWorkspace !== "string" || typeof channelId !== "string" || channelId !== expectedChannelId || !IDENTIFIER_PATTERN5.test(channelId) || typeof daemonToken !== "string" || !TOKEN_PATTERN.test(daemonToken) || typeof relayOrigin !== "string") {
+    throw new PairingClientError(
+      "invalid_connection",
+      "The saved connection is invalid"
+    );
+  }
+  return {
+    defaultWorkspace,
+    channelId,
+    daemonToken,
+    relayOrigin: parseRelayOrigin(relayOrigin)
+  };
+}
+async function readSavedConnection(channelId) {
+  const connectionPath = join14(
+    readStateDirectory(),
+    "connections",
+    `${channelId}.json`
+  );
+  let encoded = "";
+  const handle = await open5(connectionPath, "r");
+  try {
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.size > MAX_CONNECTION_FILE_LENGTH) {
+      throw new PairingClientError(
+        "invalid_connection",
+        "The saved connection is invalid"
+      );
+    }
+    encoded = await handle.readFile({ encoding: "utf8" });
+  } finally {
+    await handle.close();
+  }
+  let value;
+  try {
+    value = JSON.parse(encoded);
+  } catch (error61) {
+    throw new PairingClientError(
+      "invalid_connection",
+      "The saved connection is invalid",
+      { cause: error61 }
+    );
   }
-  const decoded = schema.safeParse(value);
-  if (!decoded.success) {
-    throw new ProtocolMessageError("Message does not match its schema", {
-      cause: decoded.error
-    });
+  const connection = decodeSavedConnection(value, channelId);
+  return {
+    defaultWorkspace: await resolveDefaultWorkspace(
+      connection.defaultWorkspace
+    ),
+    channelId: connection.channelId,
+    daemonToken: connection.daemonToken,
+    relayOrigin: connection.relayOrigin
+  };
+}
+function assertInventoryUsable(inventory) {
+  if (inventory.available.length + inventory.installable.length === 0) {
+    throw new PairingClientError(
+      "no_supported_agent",
+      "No supported Agent is ready or safely installable on this machine"
+    );
   }
-  return decoded.data;
 }
-var encode4 = (message, schema) => {
-  const decoded = schema.safeParse(message);
-  if (!decoded.success) {
-    throw new ProtocolMessageError("Message does not match its schema", {
-      cause: decoded.error
-    });
-  }
-  return JSON.stringify(decoded.data);
-};
-var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
-var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
+function buildPairedDaemon(connection, connectionPath, inventory) {
+  assertInventoryUsable(inventory);
+  const relayUrl = mobiusApiUrl(
+    connection.relayOrigin,
+    `/channels/${encodeURIComponent(connection.channelId)}/daemon`
+  );
+  relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
+  relayUrl.searchParams.set("token", connection.daemonToken);
+  const auditDatabasePath = join14(
+    readStateDirectory(),
+    "audit",
+    `${connection.channelId}.sqlite`
+  );
+  return {
+    channelUrl: new URL(
+      `/channels/${encodeURIComponent(connection.channelId)}`,
+      connection.relayOrigin
+    ).toString(),
+    config: createDaemonConfig(
+      {
+        defaultWorkspace: connection.defaultWorkspace,
+        auditDatabasePath,
+        channelId: connection.channelId,
+        relayUrl
+      },
+      inventory.readyAgents(),
+      inventory.installable
+    ),
+    connectionPath
+  };
+}
+async function pairLocalMachine(arguments_, signal = new AbortController().signal) {
+  const options = parsePairCommand(arguments_);
+  const defaultWorkspace = await resolveDefaultWorkspace(options.workspace);
+  const inventory = await discoverLocalAgentInventory({
+    defaultWorkspace,
+    environment: process.env,
+    signal
+  });
+  assertInventoryUsable(inventory);
+  const agents = inventory.readyAgents();
+  const claim2 = await claimPairing(
+    options,
+    defaultWorkspace,
+    agents,
+    inventory.installable,
+    signal
+  );
+  const connectionPath = await persistConnection(
+    claim2.channelId,
+    options.relayOrigin,
+    claim2.daemonToken,
+    defaultWorkspace
+  );
+  return buildPairedDaemon(
+    {
+      defaultWorkspace,
+      channelId: claim2.channelId,
+      daemonToken: claim2.daemonToken,
+      relayOrigin: options.relayOrigin
+    },
+    connectionPath,
+    inventory
+  );
+}
+async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
+  const channelId = parseChannelArgument(arguments_);
+  const connectionPath = join14(
+    readStateDirectory(),
+    "connections",
+    `${channelId}.json`
+  );
+  const connection = await readSavedConnection(channelId);
+  const inventory = await discoverLocalAgentInventory({
+    defaultWorkspace: connection.defaultWorkspace,
+    environment: process.env,
+    signal
+  });
+  return buildPairedDaemon(connection, connectionPath, inventory);
+}
 
 // src/run-daemon.ts
+import { basename as basename3 } from "node:path";
+import { styleText } from "node:util";
 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
@@ -23653,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 {
@@ -23927,7 +24251,7 @@ function contentPhase(content) {
     return "";
   }
   const codex = metadata["codex"];
-  if (!isRecord6(codex)) {
+  if (!isRecord5(codex)) {
     return "";
   }
   const phase = codex["phase"];
@@ -24561,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 = "") {
@@ -24591,7 +24915,7 @@ function normalizeConfigValues(value) {
   }
   const normalized = [];
   for (const entry of value) {
-    if (!isRecord7(entry)) {
+    if (!isRecord6(entry)) {
       continue;
     }
     const groupedOptions = entry["options"];
@@ -24599,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)
           );
@@ -24615,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);
@@ -24654,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);
@@ -24737,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),
@@ -24757,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"];
@@ -24770,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"];
@@ -24780,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"]);
@@ -24875,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",
       {},
@@ -24899,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`,
         {},
@@ -25190,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,
@@ -25212,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: {} },
@@ -25280,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,
@@ -25313,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,
@@ -25330,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,
@@ -25366,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,
@@ -25380,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"]
@@ -25409,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 }
       ),
@@ -25434,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 }
       ),
@@ -25465,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 }
           ),
@@ -25478,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,
@@ -25497,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,
@@ -25596,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 }
         ),
@@ -25643,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
         });
       }
@@ -25999,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(
@@ -26636,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,
@@ -26678,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";
@@ -26738,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;
     }
   }
@@ -26759,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]);
@@ -26797,7 +27112,7 @@ var AgentInstallationManager = class {
       command.requestId,
       command.agentId
     );
-    const specification = specificationFor(
+    const specification = authorizedSpecificationFor(
       this.#specifications,
       command.agentId
     );
@@ -26900,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();
@@ -27208,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") {
@@ -27234,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({
@@ -27295,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) {
@@ -27319,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({
@@ -27366,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) {
@@ -27400,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,
@@ -27467,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,
@@ -27550,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,
@@ -27609,7 +28106,9 @@ function fixedAgentInstallRecipes() {
     new ClaudeCodeInstallRecipe(),
     new PiInstallRecipe(),
     new DeepSeekHarnessInstallRecipe(),
-    new OpenCodeInstallRecipe()
+    new OpenCodeInstallRecipe(),
+    new GrokBuildInstallRecipe(),
+    new WorkBuddyInstallRecipe()
   ]);
 }
 
@@ -27850,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";
@@ -27895,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;
@@ -27953,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"
         );
@@ -27981,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);
@@ -28010,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();
@@ -28018,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),
@@ -28811,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)) {
@@ -28826,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 (
@@ -29118,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);
@@ -30025,7 +30478,6 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
   );
   const installations = new AgentInstallationManager(
     specifications,
-    new ConsoleInstallationAuthorizer(stateDirectory),
     installationExecutor,
     installationObserver,
     installationAudit
@@ -30133,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,