@moxt-ai/mobius 0.0.16 → 0.0.18

package/dist/cli.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { mkdir as mkdir6 } from "node:fs/promises";
+import { mkdir as mkdir4 } from "node:fs/promises";
 
 // src/agent-catalog/local-agent.ts
 import { realpathSync, statSync } from "node:fs";
@@ -526,6 +526,22 @@ var InstallableAgentDefinition = class {
     this.label = label;
   }
 };
+var MissingAgentDefinition = class extends InstallableAgentDefinition {
+  status = "agent_not_installed";
+  constructor(id, label) {
+    super(id, label);
+  }
+};
+var AgentIntegrationDefinition = class extends InstallableAgentDefinition {
+  agentPath;
+  agentVersion;
+  status = "integration_not_installed";
+  constructor(id, label, agentPath, agentVersion) {
+    super(id, label);
+    this.agentPath = agentPath;
+    this.agentVersion = agentVersion;
+  }
+};
 var LocalAgentCatalogSnapshot = class {
   agents;
   installableAgents;
@@ -595,12 +611,19 @@ var AvailableAgent = class extends AgentDiscovery {
 };
 var UnavailableAgent = class extends AgentDiscovery {
 };
-var MissingAdapter = class extends UnavailableAgent {
+var UnavailableInstalledAgent = class extends UnavailableAgent {
+  agent;
+  constructor(specification, agent) {
+    super(specification);
+    this.agent = agent;
+  }
+};
+var MissingAdapter = class extends UnavailableInstalledAgent {
   code = "adapter_not_found";
   message = "ACP adapter not found";
   status = "missing_adapter";
-  constructor(specification) {
-    super(specification);
+  constructor(specification, agent) {
+    super(specification, agent);
   }
 };
 var MissingAgent = class extends UnavailableAgent {
@@ -611,7 +634,7 @@ var MissingAgent = class extends UnavailableAgent {
     super(specification);
   }
 };
-var ProbeFailed = class extends UnavailableAgent {
+var AgentProbeFailed = class extends UnavailableAgent {
   code;
   message;
   status = "probe_failed";
@@ -621,20 +644,30 @@ var ProbeFailed = class extends UnavailableAgent {
     this.message = message;
   }
 };
-var IncompatibleAdapter = class extends UnavailableAgent {
+var IntegrationProbeFailed = class extends UnavailableInstalledAgent {
+  code;
+  message;
+  status = "probe_failed";
+  constructor(specification, agent, code, message) {
+    super(specification, agent);
+    this.code = code;
+    this.message = message;
+  }
+};
+var IncompatibleAdapter = class extends UnavailableInstalledAgent {
   code = "acp_incompatible";
   message = "ACP adapter is incompatible";
   status = "incompatible_adapter";
-  constructor(specification) {
-    super(specification);
+  constructor(specification, agent) {
+    super(specification, agent);
   }
 };
-var AuthenticationRequiredAgent = class extends UnavailableAgent {
+var AuthenticationRequiredAgent = class extends UnavailableInstalledAgent {
   code = "authentication_required";
   message = "Agent authentication is required";
   status = "authentication_required";
-  constructor(specification) {
-    super(specification);
+  constructor(specification, agent) {
+    super(specification, agent);
   }
 };
 var LocalAgentInventory = class {
@@ -642,7 +675,7 @@ var LocalAgentInventory = class {
   discoveries;
   installable;
   unavailable;
-  constructor(discoveries, platform = process.platform, architecture = process.arch) {
+  constructor(discoveries) {
     const available = [];
     const unavailable = [];
     for (const discovery of discoveries) {
@@ -657,13 +690,8 @@ var LocalAgentInventory = class {
     this.available = Object.freeze(available);
     this.discoveries = Object.freeze([...discoveries]);
     this.installable = Object.freeze(
-      unavailable.filter(
-        (discovery) => !(discovery instanceof AuthenticationRequiredAgent) && discovery.specification.supportsInstallation(
-          platform,
-          architecture
-        )
-      ).map(
-        (discovery) => new InstallableAgentDefinition(
+      unavailable.map(
+        (discovery) => discovery instanceof UnavailableInstalledAgent ? discovery.agent : new MissingAgentDefinition(
           discovery.specification.id,
           discovery.specification.label
         )
@@ -1132,7 +1160,6 @@ var LocalAgentSpecification = class {
   createLaunchEnvironment = async (_agent, _context) => Object.freeze({});
   recoveryCommand = () => "";
   resolveInstalledAgentExecutables = (_context) => Promise.resolve([]);
-  supportsInstallation = (platform, architecture) => (platform === "darwin" || platform === "linux") && (architecture === "arm64" || architecture === "x64");
   verifyAcp = (_connection, _initialized, _defaultWorkspace, _signal) => Promise.resolve();
 };
 var DirectAcpAgentDefinition = class extends LocalAgentSpecification {
@@ -1280,7 +1307,6 @@ var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
       ["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(
@@ -1594,14 +1620,14 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
 import { join as join8 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import {
   chmod,
   copyFile,
   mkdir as mkdir2,
   mkdtemp as mkdtemp2,
-  open as open3,
+  open as open2,
   realpath as realpath5,
   rename as rename2,
   rm as rm2,
@@ -1611,208 +1637,16 @@ import {
 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 open2, unlink } from "node:fs/promises";
 import { fetch } from "undici";
 
 // src/network/environment-proxy.ts
 import { EnvHttpProxyAgent } from "undici";
 var environmentProxyDispatcher = new EnvHttpProxyAgent();
 
-// src/agent-installation/verified-download.ts
-var MAX_REDIRECTS = 4;
-var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-var InstallerDownloadError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "InstallerDownloadError";
-  }
-};
-var VerifiedDownload = class {
-  bytes;
-  sha256;
-  url;
-  constructor(url2, bytes, sha256) {
-    this.bytes = bytes;
-    this.sha256 = sha256;
-    this.url = url2;
-  }
-};
-var UndiciInstallerDownloadTransport = class {
-  get = async (url2, signal) => await fetch(url2, {
-    dispatcher: environmentProxyDispatcher,
-    headers: {
-      accept: "text/plain, application/octet-stream;q=0.9",
-      "user-agent": "Mobius-Agent-Installer/0.0.3"
-    },
-    method: "GET",
-    redirect: "manual",
-    signal
-  });
-};
-function validateUrl(url2, allowedHosts) {
-  if (url2.protocol !== "https:" || url2.username.length > 0 || url2.password.length > 0 || url2.port.length > 0 || !allowedHosts.has(url2.hostname)) {
-    throw new InstallerDownloadError(
-      "installer_host_not_allowed",
-      "The installer download target is not allowed"
-    );
-  }
-}
-async function fetchInstaller(options, signal, transport) {
-  let url2 = new URL(options.url);
-  for (let redirectCount = 0; redirectCount <= MAX_REDIRECTS; redirectCount += 1) {
-    validateUrl(url2, options.allowedHosts);
-    const response = await transport.get(url2, signal);
-    if (!REDIRECT_STATUSES.has(response.status)) {
-      return { response, url: url2 };
-    }
-    await response.body?.cancel();
-    const location = response.headers.get("location");
-    if (location === null || redirectCount === MAX_REDIRECTS) {
-      throw new InstallerDownloadError(
-        "installer_redirect_invalid",
-        "The installer returned an invalid redirect"
-      );
-    }
-    let redirected;
-    try {
-      redirected = new URL(location, url2);
-    } catch (error61) {
-      throw new InstallerDownloadError(
-        "installer_redirect_invalid",
-        "The installer returned an invalid redirect",
-        { cause: error61 }
-      );
-    }
-    try {
-      validateUrl(redirected, options.allowedHosts);
-    } catch (error61) {
-      throw new InstallerDownloadError(
-        "installer_redirect_not_allowed",
-        "The installer redirect left the approved host allowlist",
-        { cause: error61 }
-      );
-    }
-    url2 = redirected;
-  }
-  throw new InstallerDownloadError(
-    "installer_redirect_invalid",
-    "The installer returned too many redirects"
-  );
-}
-async function writeCompleteChunk(handle, chunk) {
-  let offset = 0;
-  while (offset < chunk.byteLength) {
-    const written = await handle.write(
-      chunk,
-      offset,
-      chunk.byteLength - offset
-    );
-    if (written.bytesWritten < 1) {
-      throw new InstallerDownloadError(
-        "installer_write_failed",
-        "The verified installer could not be stored"
-      );
-    }
-    offset += written.bytesWritten;
-  }
-}
-async function downloadVerifiedFile(options, transport = new UndiciInstallerDownloadTransport()) {
-  options.signal.throwIfAborted();
-  const timeoutSignal = AbortSignal.timeout(options.timeoutMilliseconds);
-  const signal = AbortSignal.any([options.signal, timeoutSignal]);
-  let handle = null;
-  let responseBody = null;
-  try {
-    const fetched = await fetchInstaller(options, signal, transport);
-    responseBody = fetched.response.body;
-    if (!fetched.response.ok || fetched.response.body === null) {
-      throw new InstallerDownloadError(
-        "installer_download_failed",
-        "The approved installer could not be downloaded"
-      );
-    }
-    const contentLength = fetched.response.headers.get("content-length");
-    if (contentLength !== null) {
-      const declaredLength = Number(contentLength);
-      if (!Number.isSafeInteger(declaredLength) || declaredLength < 1 || declaredLength > options.maximumBytes) {
-        throw new InstallerDownloadError(
-          "installer_size_invalid",
-          "The installer size is outside the approved limit"
-        );
-      }
-    }
-    handle = await open2(options.destination, "wx", 384);
-    const digest = createHash("sha256");
-    const reader = fetched.response.body.getReader();
-    let bytes = 0;
-    try {
-      while (true) {
-        signal.throwIfAborted();
-        const chunk = await reader.read();
-        if (chunk.done) {
-          break;
-        }
-        bytes += chunk.value.byteLength;
-        if (bytes > options.maximumBytes) {
-          throw new InstallerDownloadError(
-            "installer_size_invalid",
-            "The installer exceeded the approved size limit"
-          );
-        }
-        digest.update(chunk.value);
-        await writeCompleteChunk(handle, chunk.value);
-      }
-    } finally {
-      await reader.cancel().catch(() => void 0);
-      reader.releaseLock();
-    }
-    if (bytes === 0) {
-      throw new InstallerDownloadError(
-        "installer_verification_failed",
-        "The downloaded installer is empty"
-      );
-    }
-    await handle.sync();
-    await handle.close();
-    handle = null;
-    return new VerifiedDownload(fetched.url, bytes, digest.digest("hex"));
-  } catch (error61) {
-    if (handle !== null) {
-      await handle.close().catch(() => void 0);
-    }
-    await unlink(options.destination).catch(() => void 0);
-    if (options.signal.aborted) {
-      options.signal.throwIfAborted();
-    }
-    if (timeoutSignal.aborted) {
-      throw new InstallerDownloadError(
-        "installer_download_timeout",
-        "The installer download timed out",
-        { cause: error61 }
-      );
-    }
-    if (error61 instanceof InstallerDownloadError) {
-      throw error61;
-    }
-    throw new InstallerDownloadError(
-      "installer_download_failed",
-      "The approved installer could not be downloaded",
-      { cause: error61 }
-    );
-  } finally {
-    await responseBody?.cancel().catch(() => void 0);
-  }
-}
-
 // src/agent-installation/managed-agent-archive.ts
 var ARCHIVE_DOWNLOAD_LIMIT_BYTES = 128 * 1024 * 1024;
 var ARCHIVE_DOWNLOAD_TIMEOUT_MILLISECONDS = 2 * 60 * 1e3;
-var ARCHIVE_EXTRACTION_TIMEOUT_MILLISECONDS = 6e4;
 var MANIFEST_LIMIT_BYTES = 16 * 1024;
-var MINIMAL_PATH = "/usr/bin:/bin";
 var ManagedAgentArchiveDefinition = class {
   archiveName;
   archiveSha256;
@@ -1851,9 +1685,6 @@ var ManagedAgentArchiveError = class extends Error {
     this.name = "ManagedAgentArchiveError";
   }
 };
-var ManagedAgentArchiveDownloader = class {
-  download = async (options) => await downloadVerifiedFile(options);
-};
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1863,7 +1694,7 @@ function isContainedPath3(root, candidate) {
 }
 async function hashFile(path2, signal) {
   signal.throwIfAborted();
-  const digest = createHash2("sha256");
+  const digest = createHash("sha256");
   const stream = createReadStream(path2, { signal });
   try {
     for await (const chunk of stream) {
@@ -1894,7 +1725,7 @@ async function hashFile(path2, signal) {
 async function readManifest(path2) {
   let handle;
   try {
-    handle = await open3(path2, "r");
+    handle = await open2(path2, "r");
   } catch (error61) {
     throw new ManagedAgentArchiveError(
       "managed_archive_verification_failed",
@@ -1965,144 +1796,6 @@ async function validateManagedAgentArchive(root, definition, signal) {
     );
   }
 }
-function validateArchiveEntries(output2, definition) {
-  const entries = output2.split(/\r?\n/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-  if (entries.length !== 1 || entries[0] !== definition.executableName && entries[0] !== `./${definition.executableName}`) {
-    throw new ManagedAgentArchiveError(
-      "managed_archive_verification_failed",
-      "The managed Agent archive contains unexpected entries"
-    );
-  }
-}
-var ManagedAgentArchiveInstaller = class {
-  #downloader;
-  constructor(downloader = new ManagedAgentArchiveDownloader()) {
-    this.#downloader = downloader;
-  }
-  install = async (root, definition, signal) => {
-    signal.throwIfAborted();
-    try {
-      const metadata = await stat4(root);
-      if (metadata.isDirectory()) {
-        return await validateManagedAgentArchive(root, definition, signal);
-      }
-    } catch (error61) {
-      if (error61 instanceof ManagedAgentArchiveError || !(error61 instanceof Error) || !("code" in error61) || error61.code !== "ENOENT") {
-        throw error61;
-      }
-    }
-    const parent = dirname2(root);
-    await mkdir2(parent, { mode: 448, recursive: true });
-    const working = await mkdtemp2(
-      join7(parent, `.${definition.version}.archive-`)
-    );
-    const staging = await mkdtemp2(
-      join7(parent, `.${definition.version}.staging-`)
-    );
-    try {
-      const archivePath = join7(working, definition.archiveName);
-      const extractionRoot = join7(working, "extracted");
-      await mkdir2(extractionRoot, { mode: 448 });
-      const canonicalExtractionRoot = await realpath5(extractionRoot);
-      const download = await this.#downloader.download({
-        allowedHosts: /* @__PURE__ */ new Set([
-          "github.com",
-          "objects.githubusercontent.com",
-          "release-assets.githubusercontent.com"
-        ]),
-        destination: archivePath,
-        maximumBytes: ARCHIVE_DOWNLOAD_LIMIT_BYTES,
-        signal,
-        timeoutMilliseconds: ARCHIVE_DOWNLOAD_TIMEOUT_MILLISECONDS,
-        url: definition.archiveUrl
-      });
-      if (download.sha256 !== definition.archiveSha256) {
-        throw new ManagedAgentArchiveError(
-          "managed_archive_verification_failed",
-          "The managed Agent archive checksum is invalid"
-        );
-      }
-      const list = await runBoundedProcess({
-        arguments: definition.listArguments(archivePath),
-        command: definition.extractor,
-        cwd: working,
-        environment: { PATH: MINIMAL_PATH },
-        outputLimitBytes: 64 * 1024,
-        signal,
-        timeoutMilliseconds: ARCHIVE_EXTRACTION_TIMEOUT_MILLISECONDS
-      });
-      validateArchiveEntries(list.stdout, definition);
-      await runBoundedProcess({
-        arguments: definition.extractArguments(archivePath, extractionRoot),
-        command: definition.extractor,
-        cwd: working,
-        environment: { PATH: MINIMAL_PATH },
-        outputLimitBytes: 64 * 1024,
-        signal,
-        timeoutMilliseconds: ARCHIVE_EXTRACTION_TIMEOUT_MILLISECONDS
-      });
-      const extracted = await realpath5(
-        join7(canonicalExtractionRoot, definition.executableName)
-      );
-      const extractedMetadata = await stat4(extracted);
-      if (!isContainedPath3(canonicalExtractionRoot, extracted) || !extractedMetadata.isFile()) {
-        throw new ManagedAgentArchiveError(
-          "managed_archive_verification_failed",
-          "The managed Agent archive executable is invalid"
-        );
-      }
-      const binDirectory = join7(staging, "bin");
-      const executablePath = join7(binDirectory, definition.executableName);
-      await mkdir2(binDirectory, { mode: 448 });
-      await copyFile(extracted, executablePath);
-      await chmod(executablePath, 448);
-      const executableSha256 = await hashFile(executablePath, signal);
-      await writeFile(
-        join7(staging, "archive.json"),
-        `${JSON.stringify({
-          archiveSha256: definition.archiveSha256,
-          archiveUrl: definition.archiveUrl.toString(),
-          executableSha256,
-          version: definition.version
-        })}
-`,
-        { mode: 384 }
-      );
-      await validateManagedAgentArchive(staging, definition, signal);
-      try {
-        await rename2(staging, root);
-      } catch (error61) {
-        try {
-          return await validateManagedAgentArchive(root, definition, signal);
-        } catch {
-          throw new ManagedAgentArchiveError(
-            "managed_archive_publish_failed",
-            "The managed Agent archive could not be published",
-            { cause: error61 }
-          );
-        }
-      }
-      return await validateManagedAgentArchive(root, definition, signal);
-    } catch (error61) {
-      if (signal.aborted) {
-        signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedAgentArchiveError) {
-        throw error61;
-      }
-      throw new ManagedAgentArchiveError(
-        "managed_archive_install_failed",
-        "The pinned Agent archive could not be installed",
-        { cause: error61 }
-      );
-    } finally {
-      await Promise.all([
-        rm2(working, { force: true, recursive: true }),
-        rm2(staging, { force: true, recursive: true })
-      ]);
-    }
-  };
-};
 
 // src/agent-installation/opencode-managed-release.ts
 var OPENCODE_MANAGED_VERSION = "1.18.29";
@@ -2644,10 +2337,6 @@ async function resolveAdapterExecutables(specification, context) {
     context
   );
 }
-async function resolveAgentExecutable(specification, context) {
-  const executables = await resolveAgentExecutables(specification, context);
-  return executables[0] ?? null;
-}
 async function resolveAdapterExecutable(specification, context) {
   const executables = await resolveAdapterExecutables(specification, context);
   return executables[0] ?? null;
@@ -2713,41 +2402,41 @@ var DiscoveryAcpHandler = class {
 };
 function readableAcpStream(input2) {
   let byteLength = 0;
-  let open6 = true;
+  let open5 = true;
   return new ReadableStream({
     start(controller) {
       input2.on("data", (chunk) => {
-        if (!open6) {
+        if (!open5) {
           return;
         }
         if (!(chunk instanceof Uint8Array)) {
-          open6 = false;
+          open5 = false;
           controller.error(new Error("ACP adapter produced invalid output"));
           return;
         }
         byteLength += chunk.byteLength;
         if (byteLength > ACP_OUTPUT_LIMIT_BYTES) {
-          open6 = false;
+          open5 = false;
           controller.error(new Error("ACP adapter output limit exceeded"));
           return;
         }
         controller.enqueue(new Uint8Array(chunk));
       });
       input2.once("end", () => {
-        if (open6) {
-          open6 = false;
+        if (open5) {
+          open5 = false;
           controller.close();
         }
       });
       input2.once("error", (error61) => {
-        if (open6) {
-          open6 = false;
+        if (open5) {
+          open5 = false;
           controller.error(error61);
         }
       });
     },
     cancel() {
-      open6 = false;
+      open5 = false;
     }
   });
 }
@@ -2876,25 +2565,50 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
 }
 
 // src/agent-catalog/discover-agent.ts
-function probeFailure(specification, executableKind, error61) {
+function agentProbeFailure(specification, error61) {
+  if (error61 instanceof AgentProbeError) {
+    return new AgentProbeFailed(specification, error61.code, error61.message);
+  }
+  if (error61 instanceof ProcessExecutionError) {
+    const code = error61.code === "process_timeout" ? "agent_probe_timeout" : "agent_probe_failed";
+    return new AgentProbeFailed(
+      specification,
+      code,
+      "Agent version probe failed"
+    );
+  }
+  return new AgentProbeFailed(
+    specification,
+    "agent_probe_failed",
+    "Agent probe failed"
+  );
+}
+function integrationProbeFailure(specification, agent, error61) {
   if (error61 instanceof AgentProbeError) {
     if (error61.code === "authentication_required") {
-      return new AuthenticationRequiredAgent(specification);
+      return new AuthenticationRequiredAgent(specification, agent);
     }
-    return error61.code === "acp_incompatible" ? new IncompatibleAdapter(specification) : new ProbeFailed(specification, error61.code, error61.message);
+    return error61.code === "acp_incompatible" ? new IncompatibleAdapter(specification, agent) : new IntegrationProbeFailed(
+      specification,
+      agent,
+      error61.code,
+      error61.message
+    );
   }
   if (error61 instanceof ProcessExecutionError) {
-    const code = error61.code === "process_timeout" ? `${executableKind}_probe_timeout` : `${executableKind}_probe_failed`;
-    return new ProbeFailed(
+    const code = error61.code === "process_timeout" ? "adapter_probe_timeout" : "adapter_probe_failed";
+    return new IntegrationProbeFailed(
       specification,
+      agent,
       code,
-      `${executableKind === "agent" ? "Agent" : "Adapter"} version probe failed`
+      "Adapter version probe failed"
     );
   }
-  return new ProbeFailed(
+  return new IntegrationProbeFailed(
     specification,
-    `${executableKind}_probe_failed`,
-    `${executableKind === "agent" ? "Agent" : "Adapter"} probe failed`
+    agent,
+    "adapter_probe_failed",
+    "Adapter probe failed"
   );
 }
 async function discoverAgent(specification, context) {
@@ -2903,12 +2617,6 @@ async function discoverAgent(specification, context) {
     resolveAdapterExecutables(specification, context),
     resolveAgentExecutables(specification, context)
   ]);
-  if (specification instanceof DirectAcpAgentDefinition && agents.length === 0) {
-    return new MissingAgent(specification);
-  }
-  if (adapters.length === 0) {
-    return new MissingAdapter(specification);
-  }
   if (agents.length === 0) {
     return new MissingAgent(specification);
   }
@@ -2928,9 +2636,18 @@ async function discoverAgent(specification, context) {
       if (context.signal.aborted) {
         context.signal.throwIfAborted();
       }
-      lastFailure = probeFailure(specification, "agent", error61);
+      lastFailure = agentProbeFailure(specification, error61);
       continue;
     }
+    const installedAgent = new AgentIntegrationDefinition(
+      specification.id,
+      specification.label,
+      agent.identity.requestedPath,
+      agentVersion
+    );
+    if (adapters.length === 0) {
+      return new MissingAdapter(specification, installedAgent);
+    }
     for (const adapter of adapters) {
       if (specification instanceof DirectAcpAgentDefinition && adapter.path !== agent.path) {
         continue;
@@ -2959,7 +2676,11 @@ async function discoverAgent(specification, context) {
         if (context.signal.aborted) {
           context.signal.throwIfAborted();
         }
-        lastFailure = probeFailure(specification, "adapter", error61);
+        lastFailure = integrationProbeFailure(
+          specification,
+          installedAgent,
+          error61
+        );
         continue;
       }
       const definition = new LocalAgentDefinition(
@@ -3008,7 +2729,11 @@ async function discoverAgent(specification, context) {
         if (context.signal.aborted) {
           context.signal.throwIfAborted();
         }
-        const failure = probeFailure(specification, "adapter", error61);
+        const failure = integrationProbeFailure(
+          specification,
+          installedAgent,
+          error61
+        );
         if (failure instanceof AuthenticationRequiredAgent) {
           return failure;
         }
@@ -3016,7 +2741,7 @@ async function discoverAgent(specification, context) {
       }
     }
   }
-  return lastFailure ?? new IncompatibleAdapter(specification);
+  return lastFailure ?? new MissingAgent(specification);
 }
 
 // src/agent-catalog/discover-local-agents.ts
@@ -3027,11 +2752,7 @@ async function discoverLocalAgentInventory(options) {
       async (specification) => await discoverAgent(specification, options)
     )
   );
-  return new LocalAgentInventory(
-    discoveries,
-    options.platform,
-    options.architecture
-  );
+  return new LocalAgentInventory(discoveries);
 }
 
 // src/audit/audit-store.ts
@@ -5047,8 +4768,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter3) => {
-  const escapedDelim = escapeRegex(delimiter3 ?? ":");
+var mac = (delimiter2) => {
+  const escapedDelim = escapeRegex(delimiter2 ?? ":");
   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])$/;
@@ -8105,7 +7826,7 @@ function bucketFor(state, inst) {
   return bucket;
 }
 var handoff;
-var open4 = [];
+var open3 = [];
 var memo = {
   alloc(_inst, payload, empty) {
     const bucket = handoff;
@@ -8114,7 +7835,7 @@ var memo = {
     handoff = void 0;
     const entry = { value: empty, issues: null };
     bucket.set(payload.value, entry);
-    open4.push(entry);
+    open3.push(entry);
     return empty;
   },
   guard(inst) {
@@ -8180,10 +7901,10 @@ var memo = {
           return payload;
         }
         handoff = bucket;
-        const depth = open4.length;
+        const depth = open3.length;
         const result = base(payload, ctx);
         handoff = void 0;
-        const entry = open4.length > depth ? open4.pop() : void 0;
+        const entry = open3.length > depth ? open3.pop() : void 0;
         if (result instanceof Promise) {
           return result.then((r) => {
             if (entry)
@@ -22021,13 +21742,13 @@ var SESSION_ELICITATION_RESPOND_KIND = "session.elicitation.respond";
 var SESSION_ELICITATION_RESOLVED_KIND = "session.elicitation.resolved";
 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_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 AGENT_INSTALL_REQUEST_KIND = "agent.integration.install.request";
+var AGENT_INSTALL_CANCEL_KIND = "agent.integration.install.cancel";
+var AGENT_INSTALL_STARTED_KIND = "agent.integration.install.started";
+var AGENT_INSTALL_PROGRESS_KIND = "agent.integration.install.progress";
+var AGENT_INSTALL_COMPLETED_KIND = "agent.integration.install.completed";
+var AGENT_INSTALL_FAILED_KIND = "agent.integration.install.failed";
+var AGENT_INSTALL_CANCELLED_KIND = "agent.integration.install.cancelled";
 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_PATTERN);
@@ -23569,7 +23290,7 @@ function createDaemonConfig(connection, agents = [], installableAgents = []) {
 import { randomUUID } from "node:crypto";
 import {
   mkdir as mkdir3,
-  open as open5,
+  open as open4,
   realpath as realpath6,
   rename as rename3,
   stat as stat5,
@@ -23790,6 +23511,8 @@ function decodeClaimResponse(value) {
 }
 async function claimPairing(options, defaultWorkspace, localAgents, installableAgents, signal) {
   const agents = localAgents.map((agent) => ({
+    agentPath: agent.agentIdentity.requestedPath,
+    agentVersion: agent.agentVersion,
     id: agent.id,
     label: agent.label
   }));
@@ -23799,10 +23522,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
     response = await fetch2(endpoint, {
       body: JSON.stringify({
         agents,
-        installableAgents: installableAgents.map((agent) => ({
-          id: agent.id,
-          label: agent.label
-        })),
+        installableAgents,
         machineName: hostname3(),
         pairingCode: options.code,
         workspaceName: basename(defaultWorkspace) || "Local workspace"
@@ -23885,7 +23605,7 @@ async function readSavedConnection(channelId) {
     `${channelId}.json`
   );
   let encoded = "";
-  const handle = await open5(connectionPath, "r");
+  const handle = await open4(connectionPath, "r");
   try {
     const metadata = await handle.stat();
     if (!metadata.isFile() || metadata.size > MAX_CONNECTION_FILE_LENGTH) {
@@ -23922,7 +23642,7 @@ 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"
+      "No supported Agent is available for local discovery"
     );
   }
 }
@@ -24010,12 +23730,12 @@ async function resumeLocalMachine(arguments_, signal = new AbortController().sig
 // src/run-daemon.ts
 import { basename as basename3 } from "node:path";
 import { styleText } from "node:util";
-import { WebSocket as WebSocket2 } from "undici";
+import { fetch as fetch4, WebSocket as WebSocket2 } from "undici";
 
 // src/acp/session-manager.ts
 import { spawn as spawn3 } from "node:child_process";
 import {
-  methods as methods5,
+  methods as methods6,
   ndJsonStream as ndJsonStream2,
   PROTOCOL_VERSION as PROTOCOL_VERSION2,
   RequestError as RequestError2
@@ -24529,39 +24249,524 @@ var nativeSessionPageSchema = external_exports.object({
   nextCursor: external_exports.string().min(1).max(4096).nullish()
 }).readonly();
 
-// src/acp/session-history.ts
-var AcpHistoryReplay = class {
-  #messages = [];
-  #lastMessageId = null;
-  #characters = 0;
-  #imageCharacters = 0;
-  #truncated = false;
-  record = (update) => {
-    if (update.sessionUpdate !== "user_message_chunk" && update.sessionUpdate !== "agent_message_chunk")
-      return;
-    if (update.sessionUpdate === "agent_message_chunk" && isProgressMessage(update))
-      return;
-    const role = update.sessionUpdate === "user_message_chunk" ? "user" : "assistant";
-    const content = update.content;
-    const parsed = parseNativeHistoryText(
-      content.type === "text" ? content.text : content.type === "image" ? `[@image](data:${content.mimeType};base64,${content.data})` : `[${content.type} attachment]`
-    );
-    const text = parsed.text;
-    if (text.length === 0 && parsed.images.length === 0) return;
-    const previous = this.#messages.at(-1);
-    const id = update.messageId ?? null;
-    const continuation = previous?.role === role && id === this.#lastMessageId;
-    const combined = continuation ? `${previous.text}${text}` : text;
-    const allImages = continuation ? [...previous.images ?? [], ...parsed.images] : parsed.images;
-    const images = allImages.slice(0, 8);
-    this.#truncated ||= images.length < allImages.length;
-    if (continuation) {
-      this.#messages.pop();
-      this.#characters -= previous.text.length;
-      this.#imageCharacters -= (previous.images ?? []).reduce(
-        (size, image) => size + image.data.length,
-        0
-      );
+// src/acp/session-config/session-config-protocol.ts
+import { methods as methods5 } from "@agentclientprotocol/sdk";
+var AGENT_DEFAULT_REASONING_EFFORT = "agent_default";
+var MAXIMUM_CONFIG_OPTIONS = 100;
+var SessionConfigProtocolError = class extends Error {
+  code = "invalid_session_configuration_response";
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "SessionConfigProtocolError";
+  }
+};
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString2(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function truncate2(value, maximum) {
+  return value.length <= maximum ? value : value.slice(0, maximum);
+}
+function readBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function normalizeConfigValue(option, groupId = "", groupName = "") {
+  return {
+    description: truncate2(readString2(option["description"]), 500),
+    groupId: truncate2(groupId, 128),
+    groupName: truncate2(groupName, 255),
+    name: truncate2(
+      readString2(option["name"], readString2(option["value"])),
+      255
+    ),
+    value: truncate2(readString2(option["value"]), 500)
+  };
+}
+function normalizeConfigValues(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const normalized = [];
+  for (const entry of value) {
+    if (!isRecord6(entry)) {
+      continue;
+    }
+    const groupedOptions = entry["options"];
+    if (Array.isArray(groupedOptions)) {
+      const groupId = readString2(entry["group"]);
+      const groupName = readString2(entry["name"]);
+      for (const groupedOption of groupedOptions) {
+        if (isRecord6(groupedOption)) {
+          normalized.push(
+            normalizeConfigValue(groupedOption, groupId, groupName)
+          );
+        }
+      }
+      continue;
+    }
+    normalized.push(normalizeConfigValue(entry));
+  }
+  return normalized.filter((entry) => entry.value.length > 0).slice(0, 500);
+}
+function normalizeConfigOptions(value, modes) {
+  const normalized = [];
+  if (Array.isArray(value)) {
+    for (const option of value) {
+      if (!isRecord6(option)) {
+        continue;
+      }
+      const id = truncate2(readString2(option["id"]), 128);
+      const name = truncate2(readString2(option["name"], id), 255);
+      if (id.length === 0 || name.length === 0) {
+        continue;
+      }
+      if (option["type"] === "boolean") {
+        normalized.push({
+          booleanValue: readBoolean(option["currentValue"]),
+          category: truncate2(readString2(option["category"]), 128),
+          currentValue: "",
+          description: truncate2(readString2(option["description"]), 500),
+          id,
+          name,
+          type: "boolean",
+          values: []
+        });
+        continue;
+      }
+      if (option["type"] === "select") {
+        const values = normalizeConfigValues(option["options"]);
+        const currentValue = truncate2(readString2(option["currentValue"]), 500);
+        if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue)) {
+          normalized.push({
+            booleanValue: false,
+            category: truncate2(readString2(option["category"]), 128),
+            currentValue,
+            description: truncate2(readString2(option["description"]), 500),
+            id,
+            name,
+            type: "select",
+            values
+          });
+        }
+      }
+    }
+  }
+  if (isRecord6(modes)) {
+    const values = [];
+    const availableModes = modes["availableModes"];
+    if (Array.isArray(availableModes)) {
+      for (const mode of availableModes) {
+        if (!isRecord6(mode)) {
+          continue;
+        }
+        const id = truncate2(readString2(mode["id"]), 500);
+        if (id.length === 0) {
+          continue;
+        }
+        values.push({
+          description: truncate2(readString2(mode["description"]), 500),
+          groupId: "",
+          groupName: "",
+          name: truncate2(readString2(mode["name"], id), 255),
+          value: id
+        });
+      }
+    }
+    const currentValue = truncate2(readString2(modes["currentModeId"]), 500);
+    if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue) && !normalized.some((entry) => entry.category === "mode")) {
+      normalized.unshift({
+        booleanValue: false,
+        category: "mode",
+        currentValue,
+        description: "Agent session mode",
+        id: "mode",
+        name: "Mode",
+        type: "select",
+        values
+      });
+    }
+  }
+  return normalized.slice(0, 100);
+}
+function ensureReasoningEffortOption(current) {
+  if (current.some((option) => option.category === "thought_level")) {
+    return current;
+  }
+  const unavailable = {
+    booleanValue: false,
+    category: "thought_level",
+    currentValue: AGENT_DEFAULT_REASONING_EFFORT,
+    description: "This Agent does not expose adjustable reasoning effort for the selected model.",
+    id: "reasoning_effort",
+    name: "Reasoning effort",
+    type: "select",
+    values: [
+      {
+        description: "Selected by the Agent",
+        groupId: "",
+        groupName: "",
+        name: "Agent default",
+        value: AGENT_DEFAULT_REASONING_EFFORT
+      }
+    ]
+  };
+  const modelIndex = current.findIndex((option) => option.category === "model");
+  if (current.length < MAXIMUM_CONFIG_OPTIONS) {
+    if (modelIndex < 0) {
+      return [...current, unavailable];
+    }
+    return [
+      ...current.slice(0, modelIndex + 1),
+      unavailable,
+      ...current.slice(modelIndex + 1)
+    ];
+  }
+  if (modelIndex < 0) {
+    return [...current.slice(0, MAXIMUM_CONFIG_OPTIONS - 1), unavailable];
+  }
+  if (modelIndex < MAXIMUM_CONFIG_OPTIONS - 1) {
+    return [
+      ...current.slice(0, modelIndex + 1),
+      unavailable,
+      ...current.slice(modelIndex + 1, MAXIMUM_CONFIG_OPTIONS - 1)
+    ];
+  }
+  const model = current[modelIndex];
+  if (model === void 0) {
+    return [...current.slice(0, MAXIMUM_CONFIG_OPTIONS - 1), unavailable];
+  }
+  return [...current.slice(0, MAXIMUM_CONFIG_OPTIONS - 2), model, unavailable];
+}
+function normalizeStandardLifecycle(response) {
+  const lifecycle = isRecord6(response) ? response : {};
+  return ensureReasoningEffortOption(
+    normalizeConfigOptions(lifecycle["configOptions"], lifecycle["modes"])
+  );
+}
+function replaceStandardConfigOptions(current, value) {
+  const next = normalizeConfigOptions(value, void 0);
+  const withMode = next.some((option) => option.category === "mode") ? next : [
+    ...current.filter((option) => option.category === "mode"),
+    ...next
+  ].slice(0, 100);
+  return ensureReasoningEffortOption(withMode);
+}
+function updateCurrentValue(current, configId, value) {
+  return current.map(
+    (option) => option.id === configId ? { ...option, currentValue: value } : option
+  );
+}
+var StandardSessionConfigProtocol = class {
+  configure = async (current, change, nativeSessionId, transport) => {
+    const existing = current.find((option) => option.id === change.configId);
+    if (existing === void 0) {
+      return current;
+    }
+    if (existing.type === "select" && existing.category === "mode") {
+      await transport.request(
+        methods5.agent.session.setMode,
+        { modeId: change.value, sessionId: nativeSessionId },
+        "ACP agent exited while setting the session mode",
+        change.signal
+      );
+      return updateCurrentValue(current, existing.id, change.value);
+    }
+    const params = existing.type === "boolean" ? {
+      configId: existing.id,
+      sessionId: nativeSessionId,
+      type: "boolean",
+      value: change.booleanValue
+    } : {
+      configId: existing.id,
+      sessionId: nativeSessionId,
+      value: change.value
+    };
+    const response = await transport.request(
+      methods5.agent.session.setConfigOption,
+      params,
+      "ACP agent exited while changing session configuration",
+      change.signal
+    );
+    if (!isRecord6(response) || !Array.isArray(response["configOptions"])) {
+      throw new SessionConfigProtocolError(
+        "The Agent returned an invalid session configuration response"
+      );
+    }
+    return replaceStandardConfigOptions(current, response["configOptions"]);
+  };
+  normalizeLifecycle = (response) => normalizeStandardLifecycle(response);
+  normalizeUpdate = (current, value) => replaceStandardConfigOptions(current, value);
+};
+var standardSessionConfigProtocol = new StandardSessionConfigProtocol();
+
+// src/acp/session-config/grok-build-session-config.ts
+var LEGACY_MODEL_CONFIG_ID = "grok_build_legacy_model";
+var LEGACY_REASONING_EFFORT_CONFIG_ID = "grok_build_legacy_reasoning_effort";
+function legacyOptions(response) {
+  if (!isRecord6(response)) {
+    return [];
+  }
+  const metadata = response["_meta"];
+  if (!isRecord6(metadata)) {
+    return [];
+  }
+  const sessionConfig = metadata["x.ai/sessionConfig"];
+  if (!isRecord6(sessionConfig) || !Array.isArray(sessionConfig["options"])) {
+    return [];
+  }
+  return sessionConfig["options"].slice(0, 500).filter(isRecord6);
+}
+function legacyValue(option) {
+  const value = readString2(option["id"]);
+  return {
+    description: readString2(option["description"]).slice(0, 500),
+    groupId: "",
+    groupName: "",
+    name: readString2(option["label"], value).slice(0, 255),
+    value: value.slice(0, 500)
+  };
+}
+function modelsRecord(response) {
+  if (!isRecord6(response) || !isRecord6(response["models"])) {
+    return {};
+  }
+  return response["models"];
+}
+function legacyModelOptions(response) {
+  const options = legacyOptions(response);
+  const models = modelsRecord(response);
+  const values = [];
+  for (const option of options) {
+    if (option["category"] === "model") {
+      const value = legacyValue(option);
+      if (value.value.length > 0 && !values.some((existing) => existing.value === value.value)) {
+        values.push(value);
+      }
+    }
+  }
+  if (values.length === 0 && Array.isArray(models["availableModels"])) {
+    for (const model of models["availableModels"]) {
+      if (!isRecord6(model)) {
+        continue;
+      }
+      const value = readString2(model["modelId"]).slice(0, 500);
+      if (value.length === 0) {
+        continue;
+      }
+      if (!values.some((existing) => existing.value === value)) {
+        values.push({
+          description: "",
+          groupId: "",
+          groupName: "",
+          name: readString2(model["name"], value).slice(0, 255),
+          value
+        });
+      }
+    }
+  }
+  const selected = options.find(
+    (option) => option["category"] === "model" && option["selected"] === true
+  );
+  const currentValue = readString2(
+    models["currentModelId"],
+    selected === void 0 ? "" : readString2(selected["id"])
+  ).slice(0, 500);
+  if (values.length === 0 || !values.some((value) => value.value === currentValue)) {
+    return [];
+  }
+  const result = {
+    booleanValue: false,
+    category: "model",
+    currentValue,
+    description: "Model used by Grok Build",
+    id: LEGACY_MODEL_CONFIG_ID,
+    name: "Model",
+    type: "select",
+    values: values.slice(0, 500)
+  };
+  return [result];
+}
+function legacyReasoningEffortOptions(response) {
+  const options = legacyOptions(response);
+  const values = [];
+  for (const option of options) {
+    if (option["category"] !== "mode") {
+      continue;
+    }
+    const value = legacyValue(option);
+    if (value.value.length > 0 && !values.some((existing) => existing.value === value.value)) {
+      values.push(value);
+    }
+  }
+  if (values.length === 0) {
+    return [];
+  }
+  const selected = options.find(
+    (option) => option["category"] === "mode" && option["selected"] === true
+  );
+  if (selected === void 0) {
+    values.unshift({
+      description: "Use the selected model's default reasoning effort",
+      groupId: "",
+      groupName: "",
+      name: "Agent default",
+      value: AGENT_DEFAULT_REASONING_EFFORT
+    });
+  }
+  const currentValue = selected === void 0 ? AGENT_DEFAULT_REASONING_EFFORT : readString2(selected["id"], AGENT_DEFAULT_REASONING_EFFORT);
+  if (!values.some((value) => value.value === currentValue)) {
+    return [];
+  }
+  const result = {
+    booleanValue: false,
+    category: "thought_level",
+    currentValue,
+    description: "Reasoning effort used by Grok Build",
+    id: LEGACY_REASONING_EFFORT_CONFIG_ID,
+    name: "Reasoning effort",
+    type: "select",
+    values: values.slice(0, 500)
+  };
+  return [result];
+}
+function normalizeGrokLifecycle(response) {
+  const lifecycle = isRecord6(response) ? response : {};
+  const standard = normalizeConfigOptions(
+    lifecycle["configOptions"],
+    lifecycle["modes"]
+  );
+  const normalized = [...standard];
+  if (!normalized.some((option) => option.category === "model")) {
+    normalized.push(...legacyModelOptions(response));
+  }
+  if (!normalized.some((option) => option.category === "thought_level")) {
+    const efforts = legacyReasoningEffortOptions(response);
+    if (efforts.length > 0) {
+      const modelIndex = normalized.findIndex(
+        (option) => option.category === "model"
+      );
+      normalized.splice(
+        modelIndex < 0 ? normalized.length : modelIndex + 1,
+        0,
+        ...efforts
+      );
+    }
+  }
+  return ensureReasoningEffortOption(normalized.slice(0, 100));
+}
+function updateCurrentValue2(current, category, value) {
+  return current.map(
+    (option) => option.category === category ? { ...option, currentValue: value } : option
+  );
+}
+function validateGrokResponse(response, modelId) {
+  if (!isRecord6(response) || !isRecord6(response["_meta"])) {
+    throw new SessionConfigProtocolError(
+      "Grok Build returned an invalid session configuration response"
+    );
+  }
+  const model = response["_meta"]["model"];
+  const appliedModel = isRecord6(model) ? model["Ok"] : model;
+  if (appliedModel !== modelId) {
+    throw new SessionConfigProtocolError(
+      "Grok Build returned an invalid session configuration response"
+    );
+  }
+}
+var GrokBuildSessionConfigProtocol = class {
+  configure = async (current, change, nativeSessionId, transport) => {
+    const existing = current.find((option) => option.id === change.configId);
+    if (existing === void 0 || existing.id !== LEGACY_MODEL_CONFIG_ID && existing.id !== LEGACY_REASONING_EFFORT_CONFIG_ID) {
+      return await standardSessionConfigProtocol.configure(
+        current,
+        change,
+        nativeSessionId,
+        transport
+      );
+    }
+    const model = current.find((option) => option.category === "model");
+    if (model === void 0) {
+      return current;
+    }
+    if (existing.category === "thought_level" && change.value === AGENT_DEFAULT_REASONING_EFFORT) {
+      return current;
+    }
+    const modelId = existing.category === "model" ? change.value : model.currentValue;
+    const params = {
+      modelId,
+      sessionId: nativeSessionId
+    };
+    if (existing.category === "thought_level") {
+      params["_meta"] = {
+        reasoningEffort: change.value
+      };
+    }
+    const response = await transport.request(
+      "session/set_model",
+      params,
+      existing.category === "model" ? "Grok Build exited while setting the session model" : "Grok Build exited while setting reasoning effort",
+      change.signal
+    );
+    validateGrokResponse(response, modelId);
+    const updated = updateCurrentValue2(
+      current,
+      existing.category,
+      change.value
+    );
+    return existing.category === "thought_level" ? updated.map(
+      (option) => option.category === "thought_level" ? {
+        ...option,
+        values: option.values.filter(
+          (value) => value.value !== AGENT_DEFAULT_REASONING_EFFORT
+        )
+      } : option
+    ) : updated;
+  };
+  normalizeLifecycle = (response) => normalizeGrokLifecycle(response);
+  normalizeUpdate = (current, value) => standardSessionConfigProtocol.normalizeUpdate(current, value);
+};
+var grokBuildSessionConfigProtocol = new GrokBuildSessionConfigProtocol();
+
+// src/acp/session-config/session-config-registry.ts
+function sessionConfigProtocolForAgent(agentId) {
+  return agentId === "grok-build" ? grokBuildSessionConfigProtocol : standardSessionConfigProtocol;
+}
+
+// src/acp/session-history.ts
+var AcpHistoryReplay = class {
+  #messages = [];
+  #lastMessageId = null;
+  #characters = 0;
+  #imageCharacters = 0;
+  #truncated = false;
+  record = (update) => {
+    if (update.sessionUpdate !== "user_message_chunk" && update.sessionUpdate !== "agent_message_chunk")
+      return;
+    if (update.sessionUpdate === "agent_message_chunk" && isProgressMessage(update))
+      return;
+    const role = update.sessionUpdate === "user_message_chunk" ? "user" : "assistant";
+    const content = update.content;
+    const parsed = parseNativeHistoryText(
+      content.type === "text" ? content.text : content.type === "image" ? `[@image](data:${content.mimeType};base64,${content.data})` : `[${content.type} attachment]`
+    );
+    const text = parsed.text;
+    if (text.length === 0 && parsed.images.length === 0) return;
+    const previous = this.#messages.at(-1);
+    const id = update.messageId ?? null;
+    const continuation = previous?.role === role && id === this.#lastMessageId;
+    const combined = continuation ? `${previous.text}${text}` : text;
+    const allImages = continuation ? [...previous.images ?? [], ...parsed.images] : parsed.images;
+    const images = allImages.slice(0, 8);
+    this.#truncated ||= images.length < allImages.length;
+    if (continuation) {
+      this.#messages.pop();
+      this.#characters -= previous.text.length;
+      this.#imageCharacters -= (previous.images ?? []).reduce(
+        (size, image) => size + image.data.length,
+        0
+      );
     }
     const bounded = combined.slice(-SESSION_HISTORY_CHARACTER_LIMIT);
     this.#truncated ||= bounded.length < combined.length;
@@ -24633,7 +24838,7 @@ var FoundAcpStoredSession = class extends AcpStoredSessionLookup {
 var DeletedAcpStoredSession = class extends AcpStoredSessionLookup {
   found = false;
 };
-function readString2(value, field) {
+function readString3(value, field) {
   if (typeof value !== "string" || value.length === 0) {
     throw new Error(`Stored ACP session has an invalid ${field}`);
   }
@@ -24663,10 +24868,10 @@ function decodeSessionRow(row) {
     throw new Error("Stored ACP session is not an object");
   }
   return new AcpStoredSession(
-    readString2(Reflect.get(row, "session_id"), "session ID"),
-    readString2(Reflect.get(row, "agent_id"), "agent ID"),
-    readString2(Reflect.get(row, "native_session_id"), "native session ID"),
-    readString2(Reflect.get(row, "cwd"), "working directory"),
+    readString3(Reflect.get(row, "session_id"), "session ID"),
+    readString3(Reflect.get(row, "agent_id"), "agent ID"),
+    readString3(Reflect.get(row, "native_session_id"), "native session ID"),
+    readString3(Reflect.get(row, "cwd"), "working directory"),
     readAdditionalDirectories(Reflect.get(row, "additional_directories_json")),
     readPrompted(Reflect.get(row, "prompted"))
   );
@@ -24928,168 +25133,37 @@ function createWritableAcpStream(output2) {
     }
   });
 }
-function truncate2(value, maximumLength) {
+function truncate3(value, maximumLength) {
   return value.length <= maximumLength ? value : `${value.slice(0, Math.max(0, maximumLength - 1))}\u2026`;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readString3(value, fallback = "") {
+function readString4(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
-function readBoolean(value, fallback = false) {
-  return typeof value === "boolean" ? value : fallback;
-}
 function arraysEqual(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
-function normalizeConfigValue(option, groupId = "", groupName = "") {
+function normalizeCapabilities(capabilities) {
+  const session = capabilities.sessionCapabilities;
+  const prompt = capabilities.promptCapabilities;
   return {
-    description: truncate2(readString3(option["description"]), 500),
-    groupId: truncate2(groupId, 128),
-    groupName: truncate2(groupName, 255),
-    name: truncate2(
-      readString3(option["name"], readString3(option["value"])),
-      255
-    ),
-    value: truncate2(readString3(option["value"]), 500)
+    additionalDirectories: session?.additionalDirectories != null,
+    audioPrompt: prompt?.audio === true,
+    closeSession: session?.close != null,
+    deleteSession: session?.delete != null,
+    embeddedContextPrompt: prompt?.embeddedContext === true,
+    imagePrompt: prompt?.image === true,
+    listSessions: session?.list != null,
+    loadSession: capabilities.loadSession === true,
+    resumeSession: session?.resume != null,
+    unstableForkSession: session?.fork != null
   };
 }
-function normalizeConfigValues(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const normalized = [];
-  for (const entry of value) {
-    if (!isRecord6(entry)) {
-      continue;
-    }
-    const groupedOptions = entry["options"];
-    if (Array.isArray(groupedOptions)) {
-      const groupId = readString3(entry["group"]);
-      const groupName = readString3(entry["name"]);
-      for (const groupedOption of groupedOptions) {
-        if (isRecord6(groupedOption)) {
-          normalized.push(
-            normalizeConfigValue(groupedOption, groupId, groupName)
-          );
-        }
-      }
-      continue;
-    }
-    normalized.push(normalizeConfigValue(entry));
-  }
-  return normalized.filter((entry) => entry.value.length > 0).slice(0, 500);
-}
-function normalizeConfigOptions(value, modes) {
-  const normalized = [];
-  if (Array.isArray(value)) {
-    for (const option of value) {
-      if (!isRecord6(option)) {
-        continue;
-      }
-      const id = truncate2(readString3(option["id"]), 128);
-      const name = truncate2(readString3(option["name"], id), 255);
-      if (id.length === 0 || name.length === 0) {
-        continue;
-      }
-      if (option["type"] === "boolean") {
-        normalized.push({
-          booleanValue: readBoolean(option["currentValue"]),
-          category: truncate2(readString3(option["category"]), 128),
-          currentValue: "",
-          description: truncate2(readString3(option["description"]), 500),
-          id,
-          name,
-          type: "boolean",
-          values: []
-        });
-        continue;
-      }
-      if (option["type"] === "select") {
-        const values = normalizeConfigValues(option["options"]);
-        const currentValue = truncate2(readString3(option["currentValue"]), 500);
-        if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue)) {
-          normalized.push({
-            booleanValue: false,
-            category: truncate2(readString3(option["category"]), 128),
-            currentValue,
-            description: truncate2(readString3(option["description"]), 500),
-            id,
-            name,
-            type: "select",
-            values
-          });
-        }
-      }
-    }
-  }
-  if (isRecord6(modes)) {
-    const values = [];
-    const availableModes = modes["availableModes"];
-    if (Array.isArray(availableModes)) {
-      for (const mode of availableModes) {
-        if (!isRecord6(mode)) {
-          continue;
-        }
-        const id = truncate2(readString3(mode["id"]), 500);
-        if (id.length === 0) {
-          continue;
-        }
-        values.push({
-          description: truncate2(readString3(mode["description"]), 500),
-          groupId: "",
-          groupName: "",
-          name: truncate2(readString3(mode["name"], id), 255),
-          value: id
-        });
-      }
-    }
-    const currentValue = truncate2(readString3(modes["currentModeId"]), 500);
-    if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue) && !normalized.some((entry) => entry.category === "mode")) {
-      normalized.unshift({
-        booleanValue: false,
-        category: "mode",
-        currentValue,
-        description: "Agent session mode",
-        id: "mode",
-        name: "Mode",
-        type: "select",
-        values
-      });
-    }
-  }
-  return normalized.slice(0, 100);
-}
-function replaceConfigOptionsKeepingMode(current, value) {
-  const next = normalizeConfigOptions(value, void 0);
-  if (next.some((option) => option.category === "mode")) {
-    return next;
-  }
-  return [
-    ...current.filter((option) => option.category === "mode"),
-    ...next
-  ].slice(0, 100);
-}
-function normalizeCapabilities(capabilities) {
-  const session = capabilities.sessionCapabilities;
-  const prompt = capabilities.promptCapabilities;
-  return {
-    additionalDirectories: session?.additionalDirectories != null,
-    audioPrompt: prompt?.audio === true,
-    closeSession: session?.close != null,
-    deleteSession: session?.delete != null,
-    embeddedContextPrompt: prompt?.embeddedContext === true,
-    imagePrompt: prompt?.image === true,
-    listSessions: session?.list != null,
-    loadSession: capabilities.loadSession === true,
-    resumeSession: session?.resume != null,
-    unstableForkSession: session?.fork != null
-  };
-}
-function elicitationFieldType(value) {
-  if (value === "boolean") {
-    return "boolean";
+function elicitationFieldType(value) {
+  if (value === "boolean") {
+    return "boolean";
   }
   if (value === "integer") {
     return "integer";
@@ -25107,11 +25181,11 @@ function normalizeElicitationOptions(schema) {
   const oneOf = schema["oneOf"];
   if (Array.isArray(oneOf)) {
     for (const option of oneOf) {
-      if (isRecord6(option) && typeof option["const"] === "string") {
+      if (isRecord7(option) && typeof option["const"] === "string") {
         normalized.push({
-          description: truncate2(readString3(option["description"]), 500),
-          label: truncate2(readString3(option["title"], option["const"]), 255),
-          value: truncate2(option["const"], 500)
+          description: truncate3(readString4(option["description"]), 500),
+          label: truncate3(readString4(option["title"], option["const"]), 255),
+          value: truncate3(option["const"], 500)
         });
       }
     }
@@ -25127,7 +25201,7 @@ function normalizeElicitationOptions(schema) {
     return normalized.slice(0, 200);
   }
   const items = schema["items"];
-  if (!isRecord6(items)) {
+  if (!isRecord7(items)) {
     return normalized;
   }
   const anyOf = items["anyOf"];
@@ -25140,7 +25214,7 @@ function numericString(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toString() : "";
 }
 function normalizeElicitationFields(requestedSchema) {
-  if (!isRecord6(requestedSchema) || !isRecord6(requestedSchema["properties"])) {
+  if (!isRecord7(requestedSchema) || !isRecord7(requestedSchema["properties"])) {
     return [];
   }
   const properties = requestedSchema["properties"];
@@ -25150,7 +25224,7 @@ function normalizeElicitationFields(requestedSchema) {
   );
   const normalized = [];
   for (const [name, property] of Object.entries(properties)) {
-    if (!isRecord6(property)) {
+    if (!isRecord7(property)) {
       continue;
     }
     const type = elicitationFieldType(property["type"]);
@@ -25160,9 +25234,9 @@ function normalizeElicitationFields(requestedSchema) {
     normalized.push({
       defaultBooleanValue: typeof defaultValue === "boolean" ? defaultValue : false,
       defaultNumberValue: typeof defaultValue === "number" && Number.isFinite(defaultValue) ? defaultValue : 0,
-      defaultStringValue: typeof defaultValue === "string" ? truncate2(defaultValue, 1e4) : Array.isArray(defaultValue) ? truncate2(JSON.stringify(defaultValue), 1e4) : "",
-      description: truncate2(readString3(property["description"]), 500),
-      format: truncate2(readString3(property["format"]), 64),
+      defaultStringValue: typeof defaultValue === "string" ? truncate3(defaultValue, 1e4) : Array.isArray(defaultValue) ? truncate3(JSON.stringify(defaultValue), 1e4) : "",
+      description: truncate3(readString4(property["description"]), 500),
+      format: truncate3(readString4(property["format"]), 64),
       hasDefaultValue: defaultValue !== void 0 && defaultValue !== null,
       maximum: numericString(property["maximum"]),
       maximumLength: numericString(
@@ -25172,11 +25246,11 @@ function normalizeElicitationFields(requestedSchema) {
       minimumLength: numericString(
         property["minLength"] ?? property["minItems"]
       ),
-      name: truncate2(name, 128),
+      name: truncate3(name, 128),
       options,
-      pattern: truncate2(readString3(property["pattern"]), 500),
+      pattern: truncate3(readString4(property["pattern"]), 500),
       required: required2.has(name),
-      title: truncate2(readString3(property["title"], name), 255),
+      title: truncate3(readString4(property["title"], name), 255),
       type: normalizedType
     });
   }
@@ -25245,7 +25319,7 @@ function validateElicitationContent(encoded, requestedSchema) {
       "invalid_elicitation_response"
     );
   }
-  if (!isRecord6(decoded) || !isRecord6(requestedSchema) || !isRecord6(requestedSchema["properties"])) {
+  if (!isRecord7(decoded) || !isRecord7(requestedSchema) || !isRecord7(requestedSchema["properties"])) {
     throw new AcpExecutionError(
       "Elicitation response does not match the requested form",
       {},
@@ -25269,7 +25343,7 @@ function validateElicitationContent(encoded, requestedSchema) {
   const validated = {};
   for (const [name, value] of Object.entries(decoded)) {
     const property = properties[name];
-    if (!isRecord6(property)) {
+    if (!isRecord7(property)) {
       throw new AcpExecutionError(
         `Elicitation field ${name} was not requested`,
         {},
@@ -25421,6 +25495,7 @@ var AcpProcessSession = class _AcpProcessSession {
   #pendingPermissions = /* @__PURE__ */ new Map();
   #preSessionUpdates = [];
   #processExit;
+  #sessionConfigProtocol;
   #store;
   #verifiedAgentVersion;
   #preSessionUpdateBytes = 0;
@@ -25439,6 +25514,7 @@ var AcpProcessSession = class _AcpProcessSession {
     unstableForkSession: false
   };
   #commands = [];
+  #configRevision = 0;
   #configOptions = [];
   #nativeSessionId = "";
   #prompted = false;
@@ -25456,6 +25532,7 @@ var AcpProcessSession = class _AcpProcessSession {
     this.#cwd = cwd;
     this.#getObserver = getObserver;
     this.#mobiusSessionId = mobiusSessionId;
+    this.#sessionConfigProtocol = sessionConfigProtocolForAgent(agent.id);
     this.#store = store;
     this.#verifiedAgentVersion = agent.agentVersion;
     this.#child = spawn3(agent.adapterPath, [...agent.arguments], {
@@ -25560,7 +25637,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       await this.race(
         this.#connection.agent.request(
-          methods5.agent.session.load,
+          methods6.agent.session.load,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -25582,7 +25659,7 @@ var AcpProcessSession = class _AcpProcessSession {
   async #initializeAgent(signal) {
     const initialized = await this.race(
       this.#connection.agent.request(
-        methods5.agent.initialize,
+        methods6.agent.initialize,
         {
           clientCapabilities: {
             elicitation: { form: {}, url: {} },
@@ -25609,11 +25686,11 @@ var AcpProcessSession = class _AcpProcessSession {
     }
     const capabilities = initialized.agentCapabilities ?? {};
     this.#capabilities = normalizeCapabilities(capabilities);
-    this.#agentName = truncate2(
+    this.#agentName = truncate3(
       initialized.agentInfo?.title ?? initialized.agentInfo?.name ?? this.#agentId,
       255
     );
-    this.#agentVersion = truncate2(
+    this.#agentVersion = truncate3(
       this.#verifiedAgentVersion.length > 0 ? this.#verifiedAgentVersion : initialized.agentInfo?.version ?? "",
       128
     );
@@ -25650,7 +25727,7 @@ var AcpProcessSession = class _AcpProcessSession {
         );
       const forked = await this.race(
         this.#connection.agent.request(
-          methods5.agent.session.fork,
+          methods6.agent.session.fork,
           {
             sessionId: nativeSessionIdSchema.parse(origin.nativeSessionId),
             cwd: this.#cwd,
@@ -25683,7 +25760,7 @@ var AcpProcessSession = class _AcpProcessSession {
       if (this.#capabilities.resumeSession) {
         lifecycleResponse = await this.race(
           this.#connection.agent.request(
-            methods5.agent.session.resume,
+            methods6.agent.session.resume,
             {
               additionalDirectories: [...this.#additionalDirectories],
               cwd: this.#cwd,
@@ -25700,7 +25777,7 @@ var AcpProcessSession = class _AcpProcessSession {
         try {
           lifecycleResponse = await this.race(
             this.#connection.agent.request(
-              methods5.agent.session.load,
+              methods6.agent.session.load,
               {
                 additionalDirectories: [...this.#additionalDirectories],
                 cwd: this.#cwd,
@@ -25736,7 +25813,7 @@ var AcpProcessSession = class _AcpProcessSession {
       }
       const created = await this.race(
         this.#connection.agent.request(
-          methods5.agent.session.new,
+          methods6.agent.session.new,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -25750,11 +25827,7 @@ var AcpProcessSession = class _AcpProcessSession {
       this.selectNativeSession(created.sessionId);
       lifecycleResponse = created;
     }
-    const lifecycleRecord = isRecord6(lifecycleResponse) ? lifecycleResponse : {};
-    this.#configOptions = normalizeConfigOptions(
-      lifecycleRecord["configOptions"],
-      lifecycleRecord["modes"]
-    );
+    this.#configOptions = this.#sessionConfigProtocol.normalizeLifecycle(lifecycleResponse);
     await this.#updateTail;
     signal.throwIfAborted();
     if (this.#prompted) {
@@ -25779,7 +25852,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     const response = await this.race(
       this.#connection.agent.request(
-        methods5.agent.session.list,
+        methods6.agent.session.list,
         cursor === null ? {} : { cursor },
         { cancellationSignal: signal }
       ),
@@ -25804,7 +25877,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     await this.race(
       this.#connection.agent.request(
-        methods5.agent.session.delete,
+        methods6.agent.session.delete,
         { sessionId: nativeSessionIdSchema.parse(nativeSessionId) },
         { cancellationSignal: signal }
       ),
@@ -25825,64 +25898,50 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     }
     if (existing.type === "select") {
-      if (!existing.values.some((entry) => entry.value === options.value)) {
+      if (existing.values.length < 2) {
         throw new AcpExecutionError(
-          "The requested ACP configuration value is unavailable",
+          "The requested ACP configuration option is unavailable",
           {},
           "invalid_session_configuration"
         );
       }
-      if (existing.category === "mode") {
-        await this.race(
-          this.#connection.agent.request(
-            methods5.agent.session.setMode,
-            { modeId: options.value, sessionId: this.#nativeSessionId },
-            { cancellationSignal: options.signal }
-          ),
-          "ACP agent exited while setting the session mode",
-          options.signal
-        );
-        this.#configOptions = this.#configOptions.map(
-          (option) => option.id === existing.id ? { ...option, currentValue: options.value } : option
-        );
-      } else {
-        const response = await this.race(
-          this.#connection.agent.request(
-            methods5.agent.session.setConfigOption,
-            {
-              configId: existing.id,
-              sessionId: this.#nativeSessionId,
-              value: options.value
-            },
-            { cancellationSignal: options.signal }
-          ),
-          "ACP agent exited while changing session configuration",
-          options.signal
-        );
-        this.#configOptions = replaceConfigOptionsKeepingMode(
-          this.#configOptions,
-          response.configOptions
+      if (!existing.values.some((entry) => entry.value === options.value)) {
+        throw new AcpExecutionError(
+          "The requested ACP configuration value is unavailable",
+          {},
+          "invalid_session_configuration"
         );
       }
-    } else {
-      const response = await this.race(
-        this.#connection.agent.request(
-          methods5.agent.session.setConfigOption,
-          {
-            configId: existing.id,
-            sessionId: this.#nativeSessionId,
-            type: "boolean",
-            value: options.booleanValue
-          },
-          { cancellationSignal: options.signal }
-        ),
-        "ACP agent exited while changing session configuration",
-        options.signal
-      );
-      this.#configOptions = replaceConfigOptionsKeepingMode(
+    }
+    const configRevision = this.#configRevision;
+    try {
+      const configured = await this.#sessionConfigProtocol.configure(
         this.#configOptions,
-        response.configOptions
+        options,
+        this.#nativeSessionId,
+        {
+          request: async (method, params, failureMessage, signal) => await this.race(
+            this.#connection.agent.request(method, params, {
+              cancellationSignal: signal
+            }),
+            failureMessage,
+            signal
+          )
+        }
       );
+      await this.#updateTail;
+      if (this.#configRevision === configRevision) {
+        this.#configOptions = configured;
+      }
+    } catch (error61) {
+      if (error61 instanceof SessionConfigProtocolError) {
+        throw new AcpExecutionError(
+          error61.message,
+          { cause: error61 },
+          error61.code
+        );
+      }
+      throw error61;
     }
     return this.#configOptions;
   };
@@ -25966,7 +26025,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       const response = await this.race(
         this.#connection.agent.request(
-          methods5.agent.session.prompt,
+          methods6.agent.session.prompt,
           { prompt, sessionId: this.#nativeSessionId },
           { cancellationSignal: options.signal }
         ),
@@ -26013,7 +26072,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       await this.cancelPendingInteractions();
       if (this.#turn.running) {
-        await this.#connection.agent.notify(methods5.agent.session.cancel, {
+        await this.#connection.agent.notify(methods6.agent.session.cancel, {
           sessionId: this.#nativeSessionId
         });
       }
@@ -26103,8 +26162,8 @@ var AcpProcessSession = class _AcpProcessSession {
     const interactionId = `permission-${crypto.randomUUID()}`;
     const options = request.options.slice(0, 20).map((option) => ({
       kind: option.kind,
-      name: truncate2(option.name, 255),
-      optionId: truncate2(option.optionId, 255)
+      name: truncate3(option.name, 255),
+      optionId: truncate3(option.optionId, 255)
     }));
     if (options.length === 0) {
       throw new AcpExecutionError(
@@ -26129,9 +26188,9 @@ var AcpProcessSession = class _AcpProcessSession {
         kind: SESSION_PERMISSION_REQUESTED_KIND,
         options,
         sessionId: this.#mobiusSessionId,
-        title: truncate2(request.toolCall.title ?? "Permission required", 500),
-        toolCallId: truncate2(request.toolCall.toolCallId, 255),
-        toolKind: truncate2(request.toolCall.kind ?? "other", 64)
+        title: truncate3(request.toolCall.title ?? "Permission required", 500),
+        toolCallId: truncate3(request.toolCall.toolCallId, 255),
+        toolKind: truncate3(request.toolCall.kind ?? "other", 64)
       });
       return await pending.completion.promise;
     } finally {
@@ -26160,7 +26219,7 @@ var AcpProcessSession = class _AcpProcessSession {
     const schemaValue = Reflect.get(request, "requestedSchema");
     const requestedSchema = request.mode === "form" ? schemaValue : {};
     const elicitationIdValue = Reflect.get(request, "elicitationId");
-    const elicitationId = request.mode === "url" && typeof elicitationIdValue === "string" ? truncate2(elicitationIdValue, 255) : "";
+    const elicitationId = request.mode === "url" && typeof elicitationIdValue === "string" ? truncate3(elicitationIdValue, 255) : "";
     const pending = new PendingElicitation(
       interactionId,
       elicitationId,
@@ -26179,10 +26238,10 @@ var AcpProcessSession = class _AcpProcessSession {
         fields: normalizeElicitationFields(requestedSchema),
         interactionId,
         kind: SESSION_ELICITATION_REQUESTED_KIND,
-        message: truncate2(request.message, 2e3),
+        message: truncate3(request.message, 2e3),
         mode: request.mode,
         sessionId: this.#mobiusSessionId,
-        url: request.mode === "url" && typeof Reflect.get(request, "url") === "string" ? truncate2(readString3(Reflect.get(request, "url")), 4096) : ""
+        url: request.mode === "url" && typeof Reflect.get(request, "url") === "string" ? truncate3(readString4(Reflect.get(request, "url")), 4096) : ""
       });
       return await pending.completion.promise;
     } finally {
@@ -26271,7 +26330,7 @@ var AcpProcessSession = class _AcpProcessSession {
           content: normalizeContentBlock(update.content),
           contentId: `content-${crypto.randomUUID()}`,
           kind: AGENT_CONTENT_KIND,
-          messageId: truncate2(update.messageId ?? "", 255),
+          messageId: truncate3(update.messageId ?? "", 255),
           sessionId: this.#mobiusSessionId
         });
       }
@@ -26309,9 +26368,9 @@ var AcpProcessSession = class _AcpProcessSession {
     }
     if (update.sessionUpdate === "available_commands_update") {
       const commands = update.availableCommands.slice(0, 500).map((command) => ({
-        description: truncate2(command.description, 500),
-        inputHint: truncate2(command.input?.hint ?? "", 255),
-        name: truncate2(command.name, 128)
+        description: truncate3(command.description, 500),
+        inputHint: truncate3(command.input?.hint ?? "", 255),
+        name: truncate3(command.name, 128)
       })).filter((command) => command.name.length > 0);
       this.#commands = commands;
       await this.#getObserver().onCommands({
@@ -26322,10 +26381,11 @@ var AcpProcessSession = class _AcpProcessSession {
       return;
     }
     if (update.sessionUpdate === "config_option_update") {
-      this.#configOptions = replaceConfigOptionsKeepingMode(
+      this.#configOptions = this.#sessionConfigProtocol.normalizeUpdate(
         this.#configOptions,
         update.configOptions
       );
+      this.#configRevision += 1;
       await this.emitConfigUpdate();
       return;
     }
@@ -26333,15 +26393,16 @@ var AcpProcessSession = class _AcpProcessSession {
       this.#configOptions = this.#configOptions.map(
         (option) => option.category === "mode" ? { ...option, currentValue: update.currentModeId } : option
       );
+      this.#configRevision += 1;
       await this.emitConfigUpdate();
       return;
     }
     if (update.sessionUpdate === "session_info_update") {
       if (Object.hasOwn(update, "title")) {
-        this.#sessionTitle = truncate2(update.title ?? "", 500);
+        this.#sessionTitle = truncate3(update.title ?? "", 500);
       }
       if (Object.hasOwn(update, "updatedAt")) {
-        this.#sessionUpdatedAt = truncate2(update.updatedAt ?? "", 128);
+        this.#sessionUpdatedAt = truncate3(update.updatedAt ?? "", 128);
       }
       await this.#getObserver().onInfo({
         kind: SESSION_INFO_UPDATED_KIND,
@@ -26354,7 +26415,7 @@ var AcpProcessSession = class _AcpProcessSession {
     if (update.sessionUpdate === "usage_update") {
       await this.#getObserver().onUsage({
         costAmount: update.cost?.amount ?? 0,
-        costCurrency: truncate2(update.cost?.currency ?? "", 16),
+        costCurrency: truncate3(update.cost?.currency ?? "", 16),
         hasCost: update.cost !== void 0 && update.cost !== null,
         kind: SESSION_USAGE_UPDATED_KIND,
         sessionId: this.#mobiusSessionId,
@@ -26369,7 +26430,7 @@ var AcpProcessSession = class _AcpProcessSession {
     if (this.#capabilities.closeSession && this.#nativeSessionId.length > 0) {
       try {
         await this.#connection.agent.request(
-          methods5.agent.session.close,
+          methods6.agent.session.close,
           { sessionId: this.#nativeSessionId },
           {
             cancellationSignal: AbortSignal.timeout(
@@ -27001,13 +27062,12 @@ async function publishAgentCatalog(config2, signal) {
     response = await fetch3(catalogEndpoint(config2.relayUrl), {
       body: JSON.stringify({
         agents: catalog.agents.map((agent) => ({
+          agentPath: agent.agentIdentity.requestedPath,
+          agentVersion: agent.agentVersion,
           id: agent.id,
           label: agent.label
         })),
-        installableAgents: catalog.installableAgents.map((agent) => ({
-          id: agent.id,
-          label: agent.label
-        }))
+        installableAgents: catalog.installableAgents
       }),
       dispatcher: environmentProxyDispatcher,
       headers: { "content-type": "application/json" },
@@ -27103,7 +27163,7 @@ var InstallationJob = class {
 };
 function authorizedSpecificationFor(specifications, agentId) {
   for (const specification of specifications) {
-    if (specification.id === agentId && specification.supportsInstallation(process.platform, process.arch)) {
+    if (specification.id === agentId) {
       return specification;
     }
   }
@@ -27115,7 +27175,7 @@ function executionFailure(error61) {
   }
   return new InstallationManagerError(
     "installation_failed",
-    "The local Agent installation failed",
+    "The local Agent integration installation failed",
     { cause: error61 }
   );
 }
@@ -27186,7 +27246,7 @@ var AgentInstallationManager = class {
         command.requestId,
         command.agentId,
         "installation_in_progress",
-        "An installation for this Agent is already running"
+        "An integration installation for this Agent is already running"
       );
       const job2 = new InstallationJob(command.requestId, command.agentId);
       job2.state = busy;
@@ -27223,7 +27283,7 @@ var AgentInstallationManager = class {
       job.requestId,
       job.agentId
     );
-    job.controller.abort(new Error("Agent installation cancelled"));
+    job.controller.abort(new Error("Agent integration installation cancelled"));
     return await job.completion.promise;
   };
   close = async () => {
@@ -27233,7 +27293,7 @@ var AgentInstallationManager = class {
       if (job === void 0) {
         throw new InstallationManagerError(
           "installation_state_invalid",
-          "An active Agent installation is unavailable"
+          "An active Agent integration installation is unavailable"
         );
       }
       job.controller.abort(new Error("Mobius daemon stopped"));
@@ -27246,919 +27306,108 @@ var AgentInstallationManager = class {
     await this.#observer.onState(state);
   };
   #run = async (job, specification, externalSignal) => {
-    const abort = () => job.controller.abort(externalSignal.reason);
-    externalSignal.addEventListener("abort", abort, { once: true });
-    if (externalSignal.aborted) {
-      abort();
-    }
-    const deadline = setTimeout(() => {
-      job.controller.abort(
-        new InstallationManagerError(
-          "installation_timeout",
-          "The local Agent installation exceeded its deadline"
-        )
-      );
-    }, INSTALLATION_DEADLINE_MILLISECONDS);
-    const signal = job.controller.signal;
-    try {
-      signal.throwIfAborted();
-      this.#audit.record(
-        "agent_installation_authorized",
-        job.requestId,
-        specification.id
-      );
-      await this.#executor.execute(
-        specification.id,
-        job.requestId,
-        async (stage) => {
-          signal.throwIfAborted();
-          await this.#transition(
-            job,
-            new RunningInstallation(job.requestId, job.agentId, stage)
-          );
-          this.#audit.record(
-            `agent_installation_${stage}`,
-            job.requestId,
-            job.agentId
-          );
-        },
-        signal
-      );
-      signal.throwIfAborted();
-      const succeeded = new SucceededInstallation(job.requestId, job.agentId);
-      await this.#transition(job, succeeded);
-      this.#audit.record(
-        "agent_installation_completed",
-        job.requestId,
-        job.agentId
-      );
-      job.completion.resolve(succeeded);
-    } catch (error61) {
-      if (signal.aborted) {
-        if (signal.reason instanceof InstallationManagerError && signal.reason.code === "installation_timeout") {
-          const timedOut = new FailedInstallation(
-            job.requestId,
-            job.agentId,
-            signal.reason.code,
-            signal.reason.message
-          );
-          await this.#transition(job, timedOut);
-          this.#audit.record(
-            "agent_installation_failed_installation_timeout",
-            job.requestId,
-            job.agentId
-          );
-          job.completion.resolve(timedOut);
-          return;
-        }
-        const cancelled = new CancelledInstallation(job.requestId, job.agentId);
-        await this.#transition(job, cancelled);
-        this.#audit.record(
-          "agent_installation_cancelled",
-          job.requestId,
-          job.agentId
-        );
-        job.completion.resolve(cancelled);
-      } else {
-        const failure = executionFailure(error61);
-        const failed = new FailedInstallation(
-          job.requestId,
-          job.agentId,
-          failure.code,
-          failure.message
-        );
-        await this.#transition(job, failed);
-        this.#audit.record(
-          `agent_installation_failed_${failure.code}`,
-          job.requestId,
-          job.agentId
-        );
-        job.completion.resolve(failed);
-      }
-    } finally {
-      clearTimeout(deadline);
-      externalSignal.removeEventListener("abort", abort);
-      if (this.#activeAgents.get(job.agentId) === job.requestId) {
-        this.#activeAgents.delete(job.agentId);
-      }
-    }
-  };
-};
-
-// src/agent-installation/automatic-adapter-provisioner.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-var AUTOMATIC_ADAPTER_FAILURE_CODES = /* @__PURE__ */ new Set([
-  "adapter_not_found",
-  "adapter_probe_failed",
-  "adapter_probe_timeout",
-  "acp_incompatible"
-]);
-var InstalledAutomaticAdapter = class {
-  executable;
-  requestId;
-  specification;
-  constructor(specification, requestId, executable) {
-    this.executable = executable;
-    this.requestId = requestId;
-    this.specification = specification;
-  }
-};
-function shouldProvisionAdapter(unavailable, options) {
-  return unavailable.specification instanceof BridgedAcpAgentDefinition && AUTOMATIC_ADAPTER_FAILURE_CODES.has(unavailable.code) && options.environment[unavailable.specification.adapterOverrideVariable] === void 0 && unavailable.specification.supportsInstallation(
-    options.platform ?? process.platform,
-    options.architecture ?? process.arch
-  );
-}
-function stableFailureCode(error61) {
-  return error61 instanceof ManagedAdapterInstallError ? error61.code : "adapter_install_failed";
-}
-function discoveryOptions(options, environment, signal, specifications) {
-  return {
-    ...options.architecture === void 0 ? {} : { architecture: options.architecture },
-    defaultWorkspace: options.defaultWorkspace,
-    environment,
-    ...options.platform === void 0 ? {} : { platform: options.platform },
-    signal,
-    specifications
-  };
-}
-var AutomaticAdapterProvisioner = class {
-  #adapterInstaller;
-  #options;
-  #specifications;
-  constructor(options, adapterInstaller, specifications = supportedLocalAgentSpecifications()) {
-    this.#adapterInstaller = adapterInstaller;
-    this.#options = options;
-    this.#specifications = Object.freeze([...specifications]);
-  }
-  prepare = async (signal) => {
-    signal.throwIfAborted();
-    let inventory = await discoverLocalAgentInventory(
-      discoveryOptions(
-        this.#options,
-        this.#options.environment,
-        signal,
-        this.#specifications
-      )
-    );
-    const candidates = inventory.unavailable.filter(
-      (unavailable) => shouldProvisionAdapter(unavailable, this.#options)
-    );
-    const attempts = [];
-    for (const unavailable of candidates) {
-      signal.throwIfAborted();
-      const specification = unavailable.specification;
-      if (!(specification instanceof BridgedAcpAgentDefinition)) {
-        attempts.push(null);
-        continue;
-      }
-      const verifiedAgent = await findVerifiedAgentExecutable(
-        specification,
-        discoveryOptions(
-          this.#options,
-          this.#options.environment,
-          signal,
-          this.#specifications
-        )
-      );
-      if (verifiedAgent === null) {
-        attempts.push(null);
-        continue;
-      }
-      const requestId = `automatic-adapter-${randomUUID2()}`;
-      this.#options.audit.record(
-        "agent_adapter_auto_install_started",
-        requestId,
-        specification.id,
-        {
-          agentVersion: verifiedAgent.version,
-          adapterVersion: specification.adapterVersion
-        }
-      );
-      process.stdout.write(
-        `Installing the pinned ACP adapter for ${specification.label}.
-`
-      );
-      try {
-        const executable = await this.#adapterInstaller.install(
-          specification,
-          signal
-        );
-        this.#options.audit.record(
-          "agent_adapter_auto_install_completed",
-          requestId,
-          specification.id,
-          { adapterVersion: specification.adapterVersion }
-        );
-        attempts.push(
-          new InstalledAutomaticAdapter(specification, requestId, executable)
-        );
-      } catch (error61) {
-        if (signal.aborted) {
-          this.#options.audit.record(
-            "agent_adapter_auto_install_cancelled",
-            requestId,
-            specification.id
-          );
-          signal.throwIfAborted();
-        }
-        this.#options.audit.record(
-          "agent_adapter_auto_install_failed",
-          requestId,
-          specification.id,
-          { code: stableFailureCode(error61) }
-        );
-        process.stderr.write(
-          `The pinned ACP adapter for ${specification.label} could not be installed automatically; the daemon will continue.
-`
-        );
-        attempts.push(null);
-      }
-    }
-    signal.throwIfAborted();
-    const installed = attempts.filter(
-      (attempt) => attempt !== null
-    );
-    if (installed.length > 0) {
-      const verificationEnvironment = {
-        ...this.#options.environment
-      };
-      for (const attempt of installed) {
-        verificationEnvironment[attempt.specification.adapterOverrideVariable] = attempt.executable.path;
-      }
-      inventory = await discoverLocalAgentInventory(
-        discoveryOptions(
-          this.#options,
-          verificationEnvironment,
-          signal,
-          this.#specifications
-        )
-      );
-    }
-    this.#options.catalog.transition(
-      inventory.readyAgents(),
-      inventory.installable
-    );
-    for (const attempt of installed) {
-      const available = inventory.available.find(
-        (candidate) => candidate instanceof AvailableAgent && candidate.specification.id === attempt.specification.id
-      );
-      if (available === void 0) {
-        const unavailable = inventory.unavailable.find(
-          (candidate) => candidate.specification.id === attempt.specification.id
-        );
-        this.#options.audit.record(
-          "agent_adapter_auto_install_verification_failed",
-          attempt.requestId,
-          attempt.specification.id,
-          { code: unavailable?.code ?? "agent_verification_failed" }
-        );
-        continue;
-      }
-      this.#options.audit.record(
-        "agent_adapter_auto_install_verified",
-        attempt.requestId,
-        attempt.specification.id,
-        {
-          adapterVersion: available.agent.adapterVersion,
-          agentVersion: available.agent.agentVersion
-        }
-      );
-      process.stdout.write(
-        `${attempt.specification.label} ACP integration is ready.
-`
-      );
-    }
-    return inventory;
-  };
-};
-
-// src/agent-installation/fixed-installation-executor.ts
-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 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") {
-      throw new InstallationManagerError(
-        "unsupported_install_platform",
-        "This Agent installation recipe does not support the local platform"
-      );
-    }
-  };
-  requireInstalledExecutable = async (path2) => {
-    const executable = await resolveExecutablePath(path2);
-    if (executable === null) {
-      throw new InstallationManagerError(
-        "agent_verification_failed",
-        "The Agent installer did not produce a valid executable"
-      );
-    }
-    return executable;
-  };
-};
-
-// src/agent-installation/grok-build-install-recipe.ts
-import { mkdir as mkdir4, realpath as realpath7, stat as stat6 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname5, isAbsolute as isAbsolute7, join as join15, relative as relative4, sep as sep4 } from "node:path";
-var INSTALL_TIMEOUT_MILLISECONDS2 = 5 * 60 * 1e3;
-function isContainedPath4(root, candidate) {
-  const difference = relative4(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep4}`) && !isAbsolute7(difference);
-}
-async function resolveLifecycleScript(packageRoot) {
-  try {
-    const canonicalPackageRoot = await realpath7(packageRoot);
-    const script = await realpath7(
-      join15(canonicalPackageRoot, "bin", "postinstall.js")
-    );
-    const metadata = await stat6(script);
-    if (!metadata.isFile() || !isContainedPath4(canonicalPackageRoot, script)) {
-      throw new Error("Invalid Grok Build lifecycle script");
-    }
-    return script;
-  } catch (error61) {
-    throw new InstallationManagerError(
-      "agent_verification_failed",
-      "The managed Grok Build lifecycle script is invalid",
-      { cause: error61 }
-    );
-  }
-}
-var GrokBuildInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "grok-build";
-  label = "Grok Build";
-  releaseChannel = GROK_BUILD_MANAGED_VERSION;
-  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
-    super();
-    this.#npmInstaller = npmInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    const definition = grokBuildManagedPackage(process.platform, process.arch);
-    const versionRoot = join15(
-      options.stateDirectory,
-      "agents",
-      this.id,
-      GROK_BUILD_MANAGED_VERSION
-    );
-    const packageRoot = join15(versionRoot, "package");
-    const managedHome = join15(versionRoot, "home");
-    try {
-      await mkdir4(managedHome, { mode: 448, recursive: true });
-      const canonicalHome = await realpath7(managedHome);
-      await options.report("downloading");
-      await options.report("verifying");
-      await options.report("installing_agent");
-      await this.#npmInstaller.install(
-        packageRoot,
-        definition,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: definition.integrity,
-          package: definition.packageName,
-          version: definition.version
-        }
-      );
-      const script = await resolveLifecycleScript(
-        join15(packageRoot, "node_modules", "@xai-official", "grok")
-      );
-      await runBoundedProcess({
-        arguments: [script],
-        command: process.execPath,
-        cwd: dirname5(script),
-        environment: {
-          GROK_HOME: canonicalHome,
-          GROK_INSTALL_COMPLETIONS: "0",
-          GROK_NPM_REGISTRY: "https://registry.npmjs.org/",
-          HOME: canonicalHome,
-          PATH: `${dirname5(process.execPath)}${delimiter2}/usr/bin${delimiter2}/bin`
-        },
-        outputLimitBytes: 64 * 1024,
-        signal: options.signal,
-        timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS2
-      });
-      options.audit.record(
-        "agent_lifecycle_step_completed",
-        options.requestId,
-        this.id,
-        {
-          lifecycle: "postinstall",
-          package: definition.packageName,
-          version: definition.version
-        }
-      );
-      return await this.requireInstalledExecutable(
-        join15(canonicalHome, "bin", "grok")
-      );
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedNpmPackageError) {
-        if (error61.code === "managed_package_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed Grok Build packages did not match their pinned artifacts",
-            { cause: error61 }
-          );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed Grok Build package could not be published",
-            { cause: error61 }
-          );
-        }
-        throw new InstallationManagerError(error61.code, error61.message, {
-          cause: error61
-        });
-      }
-      if (error61 instanceof InstallationManagerError) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed Grok Build installation recipe failed",
-        { cause: error61 }
-      );
-    }
-  };
-};
-
-// src/agent-installation/workbuddy-install-recipe.ts
-import { join as join16 } from "node:path";
-var WorkBuddyInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "workbuddy";
-  label = "WorkBuddy";
-  releaseChannel = WORKBUDDY_MANAGED_VERSION;
-  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
-    super();
-    this.#npmInstaller = npmInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    try {
-      await options.report("downloading");
-      await options.report("verifying");
-      await options.report("installing_agent");
-      const executable = await this.#npmInstaller.install(
-        join16(
-          options.stateDirectory,
-          "agents",
-          this.id,
-          WORKBUDDY_MANAGED_VERSION
-        ),
-        WORKBUDDY_MANAGED_PACKAGE,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: WORKBUDDY_MANAGED_PACKAGE.integrity,
-          package: WORKBUDDY_MANAGED_PACKAGE.packageName,
-          version: WORKBUDDY_MANAGED_PACKAGE.version
-        }
-      );
-      return executable;
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedNpmPackageError) {
-        if (error61.code === "managed_package_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed WorkBuddy package did not match its pinned artifact",
-            { cause: error61 }
-          );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed WorkBuddy package could not be published",
-            { cause: error61 }
-          );
-        }
-        throw new InstallationManagerError(error61.code, error61.message, {
-          cause: error61
-        });
-      }
-      if (error61 instanceof InstallationManagerError) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed WorkBuddy installation recipe failed",
-        { cause: error61 }
-      );
-    }
-  };
-};
-
-// src/agent-installation/fixed-agent-install-recipes.ts
-var INSTALLER_DOWNLOAD_LIMIT_BYTES = 1024 * 1024;
-var INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS = 6e4;
-var AGENT_INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
-var MINIMAL_PATH2 = "/usr/bin:/bin";
-var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
-  id = "codex";
-  label = "Codex";
-  releaseChannel = "latest";
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    const root = join17(options.stateDirectory, "agents", this.id);
-    const temporaryRoot = join17(options.stateDirectory, "temporary");
-    await Promise.all([
-      mkdir5(root, { mode: 448, recursive: true }),
-      mkdir5(temporaryRoot, { mode: 448, recursive: true })
-    ]);
-    const temporaryDirectory = await mkdtemp3(
-      join17(temporaryRoot, ".codex-install-")
-    );
-    const installerPath = join17(temporaryDirectory, "install.sh");
-    const installDirectory = join17(root, "bin");
-    const codexHome = join17(root, "home");
-    try {
-      await Promise.all([
-        mkdir5(installDirectory, { mode: 448, recursive: true }),
-        mkdir5(codexHome, { mode: 448, recursive: true })
-      ]);
-      await options.report("downloading");
-      const download = await downloadVerifiedFile({
-        allowedHosts: /* @__PURE__ */ new Set(["chatgpt.com", "releases.openai.com"]),
-        destination: installerPath,
-        maximumBytes: INSTALLER_DOWNLOAD_LIMIT_BYTES,
-        signal: options.signal,
-        timeoutMilliseconds: INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS,
-        url: new URL("https://chatgpt.com/codex/install.sh")
-      });
-      options.audit.record(
-        "agent_installer_download_verified",
-        options.requestId,
-        this.id,
-        {
-          bytes: download.bytes.toString(),
-          releaseChannel: this.releaseChannel,
-          sha256: download.sha256
-        }
-      );
-      await options.report("verifying");
-      await options.report("installing_agent");
-      await runBoundedProcess({
-        arguments: [installerPath],
-        command: "/bin/sh",
-        cwd: temporaryDirectory,
-        environment: {
-          CODEX_HOME: codexHome,
-          CODEX_INSTALL_DIR: installDirectory,
-          CODEX_NON_INTERACTIVE: "1",
-          CODEX_RELEASE: this.releaseChannel,
-          HOME: codexHome,
-          PATH: MINIMAL_PATH2
-        },
-        outputLimitBytes: 64 * 1024,
-        signal: options.signal,
-        timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
-      });
-      return await this.requireInstalledExecutable(
-        join17(installDirectory, "codex")
-      );
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof InstallationManagerError || error61 instanceof Error && "code" in error61) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed Codex installation recipe failed"
-      );
-    } finally {
-      await rm3(temporaryDirectory, { force: true, recursive: true });
-    }
-  };
-};
-var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
-  id = "claude";
-  label = "Claude Code";
-  releaseChannel = "stable";
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    const root = join17(options.stateDirectory, "agents", this.id);
-    const managedHome = join17(root, "home");
-    const temporaryRoot = join17(options.stateDirectory, "temporary");
-    await Promise.all([
-      mkdir5(managedHome, { mode: 448, recursive: true }),
-      mkdir5(temporaryRoot, { mode: 448, recursive: true })
-    ]);
-    const temporaryDirectory = await mkdtemp3(
-      join17(temporaryRoot, ".claude-install-")
-    );
-    const installerPath = join17(temporaryDirectory, "install.sh");
-    try {
-      await options.report("downloading");
-      const download = await downloadVerifiedFile({
-        allowedHosts: /* @__PURE__ */ new Set(["claude.ai"]),
-        destination: installerPath,
-        maximumBytes: INSTALLER_DOWNLOAD_LIMIT_BYTES,
-        signal: options.signal,
-        timeoutMilliseconds: INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS,
-        url: new URL("https://claude.ai/install.sh")
-      });
-      options.audit.record(
-        "agent_installer_download_verified",
-        options.requestId,
-        this.id,
-        {
-          bytes: download.bytes.toString(),
-          releaseChannel: this.releaseChannel,
-          sha256: download.sha256
-        }
-      );
-      await options.report("verifying");
-      await options.report("installing_agent");
-      await runBoundedProcess({
-        arguments: [installerPath, "stable"],
-        command: "/bin/bash",
-        cwd: temporaryDirectory,
-        environment: {
-          HOME: managedHome,
-          PATH: MINIMAL_PATH2,
-          SHELL: "/bin/bash"
-        },
-        outputLimitBytes: 64 * 1024,
-        signal: options.signal,
-        timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
-      });
-      return await this.requireInstalledExecutable(
-        join17(managedHome, ".local", "bin", "claude")
-      );
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof InstallationManagerError || error61 instanceof Error && "code" in error61) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed Claude Code installation recipe failed"
-      );
-    } finally {
-      await rm3(temporaryDirectory, { force: true, recursive: true });
-    }
-  };
-};
-var PiInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "pi";
-  label = "Pi";
-  releaseChannel = PI_AGENT_PACKAGE.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(
-        join17(
-          options.stateDirectory,
-          "agents",
-          this.id,
-          PI_AGENT_PACKAGE.version
-        ),
-        PI_AGENT_PACKAGE,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: PI_AGENT_PACKAGE.integrity,
-          package: PI_AGENT_PACKAGE.packageName,
-          version: PI_AGENT_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 Pi package did not match its pinned artifact",
-            { cause: error61 }
-          );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed Pi 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 Pi installation recipe failed",
-        { cause: error61 }
-      );
-    }
-  };
-};
-var DeepSeekHarnessInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "deepseek-harness";
-  label = "DeepSeek Harness";
-  releaseChannel = DEEPSEEK_HARNESS_PACKAGE.version;
-  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
-    super();
-    this.#npmInstaller = npmInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    try {
-      const managedHome = join17(
-        options.stateDirectory,
-        "agents",
-        this.id,
-        "home"
-      );
-      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(
-        join17(
-          options.stateDirectory,
-          "agents",
-          this.id,
-          DEEPSEEK_HARNESS_PACKAGE.version
-        ),
-        DEEPSEEK_HARNESS_PACKAGE,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: DEEPSEEK_HARNESS_PACKAGE.integrity,
-          package: DEEPSEEK_HARNESS_PACKAGE.packageName,
-          version: DEEPSEEK_HARNESS_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 DeepSeek Harness package did not match its pinned artifact",
-            { cause: error61 }
-          );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed DeepSeek Harness 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 DeepSeek Harness installation recipe failed",
-        { cause: error61 }
-      );
+    const abort = () => job.controller.abort(externalSignal.reason);
+    externalSignal.addEventListener("abort", abort, { once: true });
+    if (externalSignal.aborted) {
+      abort();
     }
-  };
-};
-var OpenCodeInstallRecipe = class extends FixedAgentInstallRecipe {
-  #archiveInstaller;
-  id = "opencode";
-  label = "OpenCode";
-  releaseChannel = OPENCODE_MANAGED_VERSION;
-  constructor(archiveInstaller = new ManagedAgentArchiveInstaller()) {
-    super();
-    this.#archiveInstaller = archiveInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    const definition = openCodeManagedArchive(process.platform, process.arch);
+    const deadline = setTimeout(() => {
+      job.controller.abort(
+        new InstallationManagerError(
+          "installation_timeout",
+          "The local Agent integration installation exceeded its deadline"
+        )
+      );
+    }, INSTALLATION_DEADLINE_MILLISECONDS);
+    const signal = job.controller.signal;
     try {
-      await options.report("downloading");
-      await options.report("verifying");
-      await options.report("installing_agent");
-      const executable = await this.#archiveInstaller.install(
-        join17(
-          options.stateDirectory,
-          "agents",
-          this.id,
-          OPENCODE_MANAGED_VERSION
-        ),
-        definition,
-        options.signal
+      signal.throwIfAborted();
+      this.#audit.record(
+        "agent_installation_authorized",
+        job.requestId,
+        specification.id
       );
-      options.audit.record(
-        "agent_archive_verified",
-        options.requestId,
-        this.id,
-        {
-          sha256: definition.archiveSha256,
-          version: definition.version
-        }
+      await this.#executor.execute(
+        specification.id,
+        job.requestId,
+        async (stage) => {
+          signal.throwIfAborted();
+          await this.#transition(
+            job,
+            new RunningInstallation(job.requestId, job.agentId, stage)
+          );
+          this.#audit.record(
+            `agent_installation_${stage}`,
+            job.requestId,
+            job.agentId
+          );
+        },
+        signal
+      );
+      signal.throwIfAborted();
+      const succeeded = new SucceededInstallation(job.requestId, job.agentId);
+      await this.#transition(job, succeeded);
+      this.#audit.record(
+        "agent_installation_completed",
+        job.requestId,
+        job.agentId
       );
-      return executable;
+      job.completion.resolve(succeeded);
     } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedAgentArchiveError) {
-        if (error61.code === "managed_archive_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed OpenCode archive did not match its pinned artifact",
-            { cause: error61 }
+      if (signal.aborted) {
+        if (signal.reason instanceof InstallationManagerError && signal.reason.code === "installation_timeout") {
+          const timedOut = new FailedInstallation(
+            job.requestId,
+            job.agentId,
+            signal.reason.code,
+            signal.reason.message
           );
-        }
-        if (error61.code === "managed_archive_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed OpenCode archive could not be published",
-            { cause: error61 }
+          await this.#transition(job, timedOut);
+          this.#audit.record(
+            "agent_installation_failed_installation_timeout",
+            job.requestId,
+            job.agentId
           );
+          job.completion.resolve(timedOut);
+          return;
         }
-        throw new InstallationManagerError(error61.code, error61.message, {
-          cause: error61
-        });
+        const cancelled = new CancelledInstallation(job.requestId, job.agentId);
+        await this.#transition(job, cancelled);
+        this.#audit.record(
+          "agent_installation_cancelled",
+          job.requestId,
+          job.agentId
+        );
+        job.completion.resolve(cancelled);
+      } else {
+        const failure = executionFailure(error61);
+        const failed = new FailedInstallation(
+          job.requestId,
+          job.agentId,
+          failure.code,
+          failure.message
+        );
+        await this.#transition(job, failed);
+        this.#audit.record(
+          `agent_installation_failed_${failure.code}`,
+          job.requestId,
+          job.agentId
+        );
+        job.completion.resolve(failed);
       }
-      if (error61 instanceof InstallationManagerError) {
-        throw error61;
+    } finally {
+      clearTimeout(deadline);
+      externalSignal.removeEventListener("abort", abort);
+      if (this.#activeAgents.get(job.agentId) === job.requestId) {
+        this.#activeAgents.delete(job.agentId);
       }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed OpenCode installation recipe failed",
-        { cause: error61 }
-      );
     }
   };
 };
-function fixedAgentInstallRecipes() {
-  return Object.freeze([
-    new CodexInstallRecipe(),
-    new ClaudeCodeInstallRecipe(),
-    new PiInstallRecipe(),
-    new DeepSeekHarnessInstallRecipe(),
-    new OpenCodeInstallRecipe(),
-    new GrokBuildInstallRecipe(),
-    new WorkBuddyInstallRecipe()
-  ]);
-}
 
 // src/agent-installation/fixed-installation-executor.ts
+import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 function findSpecification(specifications, agentId) {
   for (const specification of specifications) {
     if (specification.id === agentId) {
@@ -28170,17 +27419,6 @@ function findSpecification(specifications, agentId) {
     "The requested Agent is not supported"
   );
 }
-function findRecipe(recipes, agentId) {
-  for (const recipe of recipes) {
-    if (recipe.id === agentId) {
-      return recipe;
-    }
-  }
-  throw new InstallationManagerError(
-    "agent_not_installable",
-    "The requested Agent does not have an approved installation recipe"
-  );
-}
 function resolveDefaultWorkspace2(path2) {
   try {
     const directory = realpathSync2(resolve4(path2));
@@ -28196,7 +27434,7 @@ function resolveDefaultWorkspace2(path2) {
     );
   }
 }
-function resolveUserInstallationDirectory(path2) {
+function resolveIntegrationStateDirectory(path2) {
   try {
     const directory = realpathSync2(resolve4(path2));
     const metadata = statSync2(directory);
@@ -28207,7 +27445,7 @@ function resolveUserInstallationDirectory(path2) {
   } catch (error61) {
     throw new InstallationManagerError(
       "unsafe_installation_root",
-      "The local Agent installation root is unavailable or unsafe",
+      "The local integration state directory is unavailable or unsafe",
       { cause: error61 }
     );
   }
@@ -28216,20 +27454,17 @@ function translateExecutionError(error61) {
   if (error61 instanceof InstallationManagerError) {
     return error61;
   }
-  if (error61 instanceof ManagedAdapterInstallError || error61 instanceof InstallerDownloadError || error61 instanceof ProcessExecutionError) {
+  if (error61 instanceof ManagedAdapterInstallError) {
     return new InstallationManagerError(error61.code, error61.message, {
       cause: error61
     });
   }
   return new InstallationManagerError(
     "installation_failed",
-    "The fixed local Agent installation failed",
+    "The local Agent integration installation failed",
     { cause: error61 }
   );
 }
-function requiresAgentReplacement(code) {
-  return code === "agent_not_found" || code === "agent_probe_failed" || code === "agent_probe_timeout";
-}
 function requiresAdapterReplacement(code) {
   return code === "adapter_not_found" || code === "adapter_probe_failed" || code === "adapter_probe_timeout" || code === "acp_incompatible";
 }
@@ -28240,12 +27475,10 @@ var FixedInstallationExecutor = class {
   #catalog;
   #environment;
   #publishCatalog;
-  #recipes;
   #specifications;
-  #stateDirectory;
-  constructor(options, specifications = supportedLocalAgentSpecifications(), recipes = fixedAgentInstallRecipes(), adapterInstaller) {
+  constructor(options, specifications = supportedLocalAgentSpecifications(), adapterInstaller) {
     const defaultWorkspace = resolveDefaultWorkspace2(options.defaultWorkspace);
-    const stateDirectory = resolveUserInstallationDirectory(
+    const stateDirectory = resolveIntegrationStateDirectory(
       options.stateDirectory
     );
     this.#defaultWorkspace = defaultWorkspace;
@@ -28253,9 +27486,7 @@ var FixedInstallationExecutor = class {
     this.#catalog = options.catalog;
     this.#environment = Object.freeze({ ...options.environment });
     this.#publishCatalog = options.publishCatalog;
-    this.#recipes = Object.freeze([...recipes]);
     this.#specifications = Object.freeze([...specifications]);
-    this.#stateDirectory = stateDirectory;
     this.#adapterInstaller = adapterInstaller ?? new ManagedAdapterInstaller({
       environment: this.#environment,
       stateDirectory
@@ -28264,35 +27495,59 @@ var FixedInstallationExecutor = class {
   execute = async (agentId, requestId, report, signal) => {
     try {
       const specification = findSpecification(this.#specifications, agentId);
-      const recipe = findRecipe(this.#recipes, agentId);
-      this.#audit.record(
-        "agent_installation_recipe_resolved",
-        requestId,
-        agentId,
-        {
-          adapterVersion: specification.adapterVersion,
-          releaseChannel: recipe.releaseChannel
-        }
-      );
-      const discoveryOptions2 = {
+      const discoveryOptions = {
         defaultWorkspace: this.#defaultWorkspace,
         environment: this.#environment,
         signal
       };
-      let agent = await resolveAgentExecutable(specification, discoveryOptions2);
-      let installedAgent = false;
-      if (agent === null) {
-        agent = await recipe.install({
-          audit: this.#audit,
-          environment: this.#environment,
-          report,
-          requestId,
-          signal,
-          stateDirectory: this.#stateDirectory
-        });
-        installedAgent = true;
+      const initialInventory = await discoverLocalAgentInventory({
+        ...discoveryOptions,
+        specifications: this.#specifications
+      });
+      const previous = this.#catalog.read();
+      this.#catalog.transition(
+        initialInventory.readyAgents(),
+        initialInventory.installable
+      );
+      try {
+        await this.#publishCatalog(signal);
+      } catch (error61) {
+        this.#catalog.transition(previous.agents, previous.installableAgents);
+        throw error61;
+      }
+      const alreadyReady = initialInventory.available.find(
+        (candidate2) => candidate2.specification.id === agentId
+      );
+      if (alreadyReady instanceof AvailableAgent) {
+        return;
+      }
+      const candidate = initialInventory.installable.find(
+        (agent2) => agent2.id === agentId
+      );
+      if (candidate instanceof MissingAgentDefinition) {
+        throw new InstallationManagerError(
+          "agent_not_installed",
+          `Install ${specification.label} on this machine, then try installing the integration again.`
+        );
+      }
+      if (!(candidate instanceof AgentIntegrationDefinition)) {
+        throw new InstallationManagerError(
+          "agent_verification_failed",
+          "The local Agent discovery result is unavailable"
+        );
       }
-      let adapter = specification instanceof DirectAcpAgentDefinition ? agent : await resolveAdapterExecutable(specification, discoveryOptions2);
+      const verifiedAgent = await findVerifiedAgentExecutable(
+        specification,
+        discoveryOptions
+      );
+      if (verifiedAgent === null) {
+        throw new InstallationManagerError(
+          "agent_not_installed",
+          `Install ${specification.label} on this machine, then try installing the integration again.`
+        );
+      }
+      const agent = verifiedAgent.executable;
+      let adapter = specification instanceof DirectAcpAgentDefinition ? agent : await resolveAdapterExecutable(specification, discoveryOptions);
       let installedAdapter = false;
       if (adapter === null) {
         if (!(specification instanceof BridgedAcpAgentDefinition)) {
@@ -28301,6 +27556,12 @@ var FixedInstallationExecutor = class {
             "The direct Agent executable is unavailable"
           );
         }
+        if (this.#environment[specification.adapterOverrideVariable] !== void 0) {
+          throw new InstallationManagerError(
+            "adapter_not_found",
+            "The configured ACP adapter is unavailable"
+          );
+        }
         await report("installing_adapter");
         adapter = await this.#adapterInstaller.install(specification, signal);
         installedAdapter = true;
@@ -28311,8 +27572,8 @@ var FixedInstallationExecutor = class {
       while (true) {
         await report("checking_acp");
         const environment = { ...this.#environment };
-        environment[specification.agentOverrideVariable] = agent.path;
-        environment[specification.adapterOverrideVariable] = adapter.path;
+        environment[specification.agentOverrideVariable] = agent.identity.requestedPath;
+        environment[specification.adapterOverrideVariable] = adapter.identity.requestedPath;
         const inventory = await discoverLocalAgentInventory({
           defaultWorkspace: this.#defaultWorkspace,
           environment,
@@ -28320,7 +27581,7 @@ var FixedInstallationExecutor = class {
           specifications: this.#specifications
         });
         const verified = inventory.available.find(
-          (candidate) => candidate.specification.id === agentId
+          (candidate2) => candidate2.specification.id === agentId
         );
         if (verified instanceof AvailableAgent) {
           this.#audit.record(
@@ -28332,7 +27593,7 @@ var FixedInstallationExecutor = class {
               agentVersion: verified.agent.agentVersion
             }
           );
-          const previous = this.#catalog.read();
+          const previousCatalog = this.#catalog.read();
           this.#catalog.transition(
             inventory.readyAgents(),
             inventory.installable
@@ -28341,15 +27602,15 @@ var FixedInstallationExecutor = class {
             await this.#publishCatalog(signal);
           } catch (error61) {
             this.#catalog.transition(
-              previous.agents,
-              previous.installableAgents
+              previousCatalog.agents,
+              previousCatalog.installableAgents
             );
             throw error61;
           }
           return;
         }
         const unavailable = inventory.unavailable.find(
-          (candidate) => candidate.specification.id === agentId
+          (candidate2) => candidate2.specification.id === agentId
         );
         if (unavailable === void 0) {
           throw new InstallationManagerError(
@@ -28357,7 +27618,7 @@ var FixedInstallationExecutor = class {
             "The complete Agent ACP path did not pass verification"
           );
         }
-        if (!installedAdapter && specification instanceof BridgedAcpAgentDefinition && requiresAdapterReplacement(unavailable.code)) {
+        if (!installedAdapter && specification instanceof BridgedAcpAgentDefinition && this.#environment[specification.adapterOverrideVariable] === void 0 && requiresAdapterReplacement(unavailable.code)) {
           await report("installing_adapter");
           adapter = await this.#adapterInstaller.install(specification, signal);
           installedAdapter = true;
@@ -28366,21 +27627,6 @@ var FixedInstallationExecutor = class {
           });
           continue;
         }
-        if (!installedAgent && (requiresAgentReplacement(unavailable.code) || unavailable.code === "acp_incompatible")) {
-          agent = await recipe.install({
-            audit: this.#audit,
-            environment: this.#environment,
-            report,
-            requestId,
-            signal,
-            stateDirectory: this.#stateDirectory
-          });
-          installedAgent = true;
-          if (specification instanceof DirectAcpAgentDefinition) {
-            adapter = agent;
-          }
-          continue;
-        }
         throw new InstallationManagerError(
           unavailable.code,
           unavailable.message
@@ -28405,15 +27651,15 @@ var LocalAuthorizationError = class extends Error {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir, realpath as realpath8, stat as stat7 } from "node:fs/promises";
+import { readdir, realpath as realpath7, stat as stat6 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import {
   basename as basename2,
-  dirname as dirname6,
-  isAbsolute as isAbsolute8,
-  join as join18,
+  dirname as dirname5,
+  isAbsolute as isAbsolute7,
+  join as join15,
   normalize as normalize2,
-  relative as relative5
+  relative as relative4
 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
@@ -28463,20 +27709,20 @@ var WorkspaceDirectoryService = class {
     if (id === "home") return homedir2();
     if (id.startsWith("path-")) {
       const path2 = decodePath(id, "path-");
-      if (isAbsolute8(path2)) return path2;
+      if (isAbsolute7(path2)) return path2;
     }
     throw new LocalAuthorizationError("The directory identifier is invalid");
   };
   resolvePath = async (requested, signal) => {
     signal.throwIfAborted();
-    if (!isAbsolute8(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 realpath8(requested);
+      const target = await realpath7(requested);
       signal.throwIfAborted();
-      const metadata = await stat7(target);
+      const metadata = await stat6(target);
       signal.throwIfAborted();
-      if (!isAbsolute8(target) || normalize2(target) !== target || !metadata.isDirectory())
+      if (!isAbsolute7(target) || normalize2(target) !== target || !metadata.isDirectory())
         throw new LocalAuthorizationError(
           "The selected location is not a directory"
         );
@@ -28491,8 +27737,8 @@ var WorkspaceDirectoryService = class {
     }
   };
   label = (path2) => {
-    const suffix = relative5(homedir2(), path2);
-    return suffix === "" ? "~" : !isAbsolute8(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
+    const suffix = relative4(homedir2(), path2);
+    return suffix === "" ? "~" : !isAbsolute7(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
   };
   identify = async (bindingId, requestedPath, signal) => {
     this.authorizeMachine(bindingId);
@@ -28520,7 +27766,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join18(target, child.name), signal);
+          const path2 = await this.resolvePath(join15(target, child.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -28528,7 +27774,7 @@ var WorkspaceDirectoryService = class {
         }
       }
       entries.sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname6(target);
+      const parent = dirname5(target);
       return new WorkspaceDirectoryListing(
         id,
         this.label(target),
@@ -28552,7 +27798,7 @@ var WorkspaceDirectoryService = class {
 };
 
 // src/native-sessions/service.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/native-sessions/codex-history.ts
 import { spawn as spawn4 } from "node:child_process";
@@ -28866,7 +28112,7 @@ var NativeSessionService = class {
       for (const info of page.sessions) {
         const authorized = await this.authorizeEntry(command, options, info);
         if (authorized === null) continue;
-        const entryId = randomUUID3();
+        const entryId = randomUUID2();
         if (this.#entries.size >= 5e3) this.#entries.clear();
         this.#entries.set(entryId, {
           scope: entryScope,
@@ -28891,7 +28137,7 @@ var NativeSessionService = class {
             {},
             "invalid_native_session_response"
           );
-        nextCursor = randomUUID3();
+        nextCursor = randomUUID2();
         if (this.#cursors.size >= 500) this.#cursors.clear();
         this.#cursors.set(nextCursor, {
           scope: cursorScope,
@@ -29211,7 +28457,7 @@ function connectRelay(url2, signal) {
 }
 
 // src/relay-connection/liveness.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var HEARTBEAT_ACK_TIMEOUT_MILLISECONDS = 1e4;
 var HEARTBEAT_INTERVAL_MILLISECONDS = 2e4;
 var RelayLivenessState = class {
@@ -29302,7 +28548,7 @@ var RelayConnectionLiveness = class {
       }
       throw new Error("Heartbeat was scheduled in an invalid state");
     }
-    const heartbeatId = randomUUID4();
+    const heartbeatId = randomUUID3();
     this.#state = new AwaitingHeartbeatAckState(
       heartbeatId,
       this.#timer.schedule(
@@ -29321,7 +28567,7 @@ var RelayConnectionLiveness = class {
 
 // src/relay-connection/session-event-outbox.ts
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 function readPendingEnvelope(row) {
   if (typeof row !== "object" || row === null || Array.isArray(row)) {
@@ -29336,7 +28582,7 @@ function readPendingEnvelope(row) {
 var SessionEventOutbox = class {
   #database;
   constructor(path2) {
-    mkdirSync3(dirname7(path2), { recursive: true });
+    mkdirSync3(dirname6(path2), { recursive: true });
     this.#database = new DatabaseSync3(path2);
     this.#database.exec(`
       CREATE TABLE IF NOT EXISTS relay_session_event_outbox (
@@ -29490,6 +28736,7 @@ var systemDaemonTimer = new SystemDaemonTimer();
 // src/run-daemon.ts
 var RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
 var RELAY_CONNECTION_REFRESH_MILLISECONDS = 20 * 60 * 1e3;
+var ACTIVE_TURN_RECONCILIATION_TIMEOUT_MILLISECONDS = 2e4;
 var RelayConnectionRefreshState = class {
 };
 var ScheduledRelayConnectionRefreshState = class extends RelayConnectionRefreshState {
@@ -29687,7 +28934,7 @@ var DaemonInstallationObserver = class {
       );
       return Promise.resolve();
     }
-    throw new Error("Unsupported Agent installation state");
+    throw new Error("Unsupported Agent integration installation state");
   };
 };
 var ResolvedSessionDirectories = class {
@@ -29701,16 +28948,20 @@ var ResolvedSessionDirectories = class {
   }
 };
 var ActiveDaemonTurn = class {
+  attemptId;
   command;
-  #connectionController;
+  #controller;
+  #finished = Promise.withResolvers();
   #cancellationRequested = false;
-  constructor(command, connectionController) {
+  constructor(command, attemptId) {
+    this.attemptId = attemptId;
     this.command = command;
-    this.#connectionController = connectionController;
+    this.#controller = new AbortController();
   }
-  abortConnection = () => {
-    this.#connectionController.abort();
+  abortDaemon = () => {
+    this.#controller.abort();
   };
+  finish = () => this.#finished.resolve();
   matches = (cancellation) => cancellation.commandId === this.command.commandId && cancellation.sessionId === this.command.sessionId;
   requestCancellation = () => {
     if (this.#cancellationRequested) {
@@ -29720,25 +28971,118 @@ var ActiveDaemonTurn = class {
     return true;
   };
   get signal() {
-    return this.#connectionController.signal;
+    return this.#controller.signal;
+  }
+  get completion() {
+    return this.#finished.promise;
+  }
+};
+var ActiveTurnReconciliationError = class extends Error {
+  code = "active_turn_reconciliation_failed";
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ActiveTurnReconciliationError";
   }
 };
+function activeTurnReconciliationEndpoint(config2, turn) {
+  const endpoint = new URL(config2.relayUrl);
+  endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
+  if (!endpoint.pathname.endsWith("/daemon")) {
+    throw new ActiveTurnReconciliationError("The Relay URL is invalid");
+  }
+  endpoint.pathname = `${endpoint.pathname.slice(0, -"/daemon".length)}/sessions/${encodeURIComponent(turn.command.sessionId)}/attempts/${encodeURIComponent(turn.attemptId)}/reconciliation`;
+  endpoint.searchParams.delete("liveness");
+  return endpoint;
+}
+async function reconcileActiveTurn(config2, turn, signal) {
+  signal.throwIfAborted();
+  const timeoutSignal = AbortSignal.timeout(
+    ACTIVE_TURN_RECONCILIATION_TIMEOUT_MILLISECONDS
+  );
+  const requestSignal = AbortSignal.any([signal, timeoutSignal]);
+  let response;
+  try {
+    response = await fetch4(activeTurnReconciliationEndpoint(config2, turn), {
+      body: JSON.stringify({ outcome: { kind: "running" } }),
+      dispatcher: environmentProxyDispatcher,
+      headers: { "content-type": "application/json" },
+      method: "POST",
+      signal: requestSignal
+    });
+  } catch (error61) {
+    if (signal.aborted) {
+      signal.throwIfAborted();
+    }
+    throw new ActiveTurnReconciliationError(
+      timeoutSignal.aborted ? "The active Agent turn reconciliation timed out" : "The active Agent turn could not be reconciled",
+      { cause: error61 }
+    );
+  }
+  await response.body?.cancel();
+  if (!response.ok) {
+    throw new ActiveTurnReconciliationError(
+      "The Relay rejected the active Agent turn reconciliation"
+    );
+  }
+}
+async function reconcileActiveTurns(config2, turns, signal) {
+  await Promise.all(
+    turns.map(async (turn) => await reconcileActiveTurn(config2, turn, signal))
+  );
+}
 function send(socket, message) {
   if (socket.readyState !== WebSocket2.OPEN) {
     throw new Error("Relay connection is not open");
   }
   socket.send(message);
 }
-function recordSessionEvent(outbox, socket, sessionId, payload, attemptId = null) {
-  const envelope2 = outbox.enqueue(sessionId, payload, attemptId);
-  if (socket.readyState === WebSocket2.OPEN) {
-    socket.send(envelope2);
+var DaemonSessionEventConnectionState = class {
+};
+var DisconnectedDaemonSessionEventState = class extends DaemonSessionEventConnectionState {
+  disconnect = () => this;
+  send = () => void 0;
+};
+var ConnectedDaemonSessionEventState = class extends DaemonSessionEventConnectionState {
+  #socket;
+  constructor(socket) {
+    super();
+    this.#socket = socket;
   }
-}
-function reportFailure(outbox, socket, command, code, message, attemptId = null) {
-  recordSessionEvent(
-    outbox,
-    socket,
+  disconnect = (socket) => socket === this.#socket ? new DisconnectedDaemonSessionEventState() : this;
+  send = (message) => {
+    if (this.#socket.readyState === WebSocket2.OPEN) {
+      try {
+        this.#socket.send(message);
+      } catch {
+      }
+    }
+  };
+};
+var DaemonSessionEventPublisher = class {
+  #outbox;
+  #connection = new DisconnectedDaemonSessionEventState();
+  constructor(outbox) {
+    this.#outbox = outbox;
+  }
+  connect = (socket) => {
+    const connection = new ConnectedDaemonSessionEventState(socket);
+    this.#connection = connection;
+    for (const pending of this.#outbox.pending()) {
+      connection.send(pending);
+    }
+  };
+  disconnect = (socket) => {
+    this.#connection = this.#connection.disconnect(socket);
+  };
+  recordAttempt = (sessionId, payload, attemptId) => {
+    this.#connection.send(this.#outbox.enqueue(sessionId, payload, attemptId));
+  };
+  recordRuntime = (sessionId, payload) => {
+    this.#connection.send(this.#outbox.enqueue(sessionId, payload));
+  };
+};
+function reportFailure(publisher, command, code, message, attemptId) {
+  publisher.recordAttempt(
     command.sessionId,
     encodeSessionFailedEvent({
       code,
@@ -29834,7 +29178,7 @@ async function executeWorkspaceList(socket, command, directories, audit, signal)
     reportOperationFailure(socket, command.requestId, "", error61);
   }
 }
-async function executeSessionPrepare(outbox, socket, command, config2, directories, audit, sessions, signal) {
+async function executeSessionPrepare(publisher, socket, command, config2, directories, audit, sessions, signal) {
   try {
     const resolved = await resolveSessionDirectories(
       directories,
@@ -29861,9 +29205,7 @@ async function executeSessionPrepare(outbox, socket, command, config2, directori
       event: "session_prepared",
       sessionId: command.sessionId
     });
-    recordSessionEvent(
-      outbox,
-      socket,
+    publisher.recordRuntime(
       command.sessionId,
       encodeSessionReadyEvent({
         additionalDirectories: resolved.additionalDirectoryEntries,
@@ -29894,7 +29236,7 @@ async function executeSessionPrepare(outbox, socket, command, config2, directori
     reportOperationFailure(socket, command.requestId, command.sessionId, error61);
   }
 }
-async function executeSessionConfigure(outbox, socket, command, config2, directories, audit, sessions, signal) {
+async function executeSessionConfigure(publisher, socket, command, config2, directories, audit, sessions, signal) {
   try {
     const resolved = await resolveSessionDirectories(
       directories,
@@ -29920,9 +29262,7 @@ async function executeSessionConfigure(outbox, socket, command, config2, directo
       event: "session_configured",
       sessionId: command.sessionId
     });
-    recordSessionEvent(
-      outbox,
-      socket,
+    publisher.recordRuntime(
       command.sessionId,
       encodeSessionConfigUpdatedEvent({
         configOptions,
@@ -29935,7 +29275,7 @@ async function executeSessionConfigure(outbox, socket, command, config2, directo
     reportOperationFailure(socket, command.requestId, command.sessionId, error61);
   }
 }
-async function executePrompt(outbox, socket, command, config2, directories, audit, sessions, attemptId, signal) {
+async function executePrompt(outbox, publisher, command, config2, directories, audit, sessions, attemptId, signal) {
   try {
     const resolved = await resolveSessionDirectories(
       directories,
@@ -29951,9 +29291,7 @@ async function executePrompt(outbox, socket, command, config2, directories, audi
       sessionId: command.sessionId
     });
     outbox.transitionExecution(command.commandId, "running");
-    recordSessionEvent(
-      outbox,
-      socket,
+    publisher.recordAttempt(
       command.sessionId,
       encodeSessionStartedEvent({
         commandId: command.commandId,
@@ -29970,9 +29308,7 @@ async function executePrompt(outbox, socket, command, config2, directories, audi
       cwd: resolved.cwd,
       images: command.images,
       onActivity: (activity) => {
-        recordSessionEvent(
-          outbox,
-          socket,
+        publisher.recordAttempt(
           command.sessionId,
           encodeAgentActivityEvent({
             activityId: activity.activityId,
@@ -29996,9 +29332,7 @@ async function executePrompt(outbox, socket, command, config2, directories, audi
         return Promise.resolve();
       },
       onText: (text) => {
-        recordSessionEvent(
-          outbox,
-          socket,
+        publisher.recordAttempt(
           command.sessionId,
           encodeAgentMessageDeltaEvent({
             commandId: command.commandId,
@@ -30015,9 +29349,7 @@ async function executePrompt(outbox, socket, command, config2, directories, audi
       sessionId: command.sessionId,
       signal
     });
-    recordSessionEvent(
-      outbox,
-      socket,
+    publisher.recordAttempt(
       command.sessionId,
       encodeSessionCompletedEvent({
         commandId: command.commandId,
@@ -30044,8 +29376,7 @@ async function executePrompt(outbox, socket, command, config2, directories, audi
     });
     const code = operationErrorCode(error61);
     reportFailure(
-      outbox,
-      socket,
+      publisher,
       command,
       code === "session_operation_failed" ? "agent_execution_failed" : code,
       code === "session_operation_failed" ? "The local agent could not complete the request" : operationErrorMessage(error61),
@@ -30091,29 +29422,15 @@ async function publishAgentCatalogUntilAvailable(config2, signal, timer) {
     }
   }
 }
-async function runRelayConnection(config2, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, onConnected, signal, timer) {
+async function runRelayConnection(config2, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, publisher, activeTurns, activeAttemptIds, onConnected, signal, timer) {
   const relayUrl = new URL(config2.relayUrl);
   relayUrl.searchParams.set("liveness", "1");
   const socket = await connectRelay(relayUrl, signal);
+  const reconnectingTurns = [...activeTurns.values()];
   onConnected();
-  const activeTurns = /* @__PURE__ */ new Map();
-  const activeAttemptIds = /* @__PURE__ */ new Map();
   const connectionController = new AbortController();
   const nativeRequests = /* @__PURE__ */ new Map();
-  const record2 = (sessionId, payload) => {
-    recordSessionEvent(
-      outbox,
-      socket,
-      sessionId,
-      payload,
-      activeAttemptIds.get(sessionId) ?? null
-    );
-  };
-  sessions.setObserver(new DaemonAcpObserver(record2));
   installationObserver.connect(socket);
-  for (const pending of outbox.pending()) {
-    send(socket, pending);
-  }
   try {
     await new Promise((resolve5, reject) => {
       let finished = false;
@@ -30125,11 +29442,8 @@ async function runRelayConnection(config2, directories, audit, sessions, install
         socket.removeEventListener("error", handleError);
         socket.removeEventListener("message", handleMessage);
         installationObserver.disconnect(socket);
+        publisher.disconnect(socket);
         connectionController.abort();
-        for (const turn of activeTurns.values()) {
-          turn.abortConnection();
-        }
-        activeTurns.clear();
       };
       const resolveConnection = () => {
         if (finished) {
@@ -30348,7 +29662,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
           if (kind === SESSION_PREPARE_KIND) {
             const command2 = decodeSessionPrepareCommand(encoded);
             void executeSessionPrepare(
-              outbox,
+              publisher,
               socket,
               command2,
               config2,
@@ -30362,7 +29676,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
           if (kind === SESSION_CONFIGURE_KIND) {
             const command2 = decodeSessionConfigureCommand(encoded);
             void executeSessionConfigure(
-              outbox,
+              publisher,
               socket,
               command2,
               config2,
@@ -30412,7 +29726,10 @@ async function runRelayConnection(config2, directories, audit, sessions, install
           if (kind === AGENT_INSTALL_REQUEST_KIND) {
             const command2 = decodeAgentInstallRequestCommand(encoded);
             void installations.request(command2, signal).catch((error61) => {
-              console.error("Mobius Agent installation failed", error61);
+              console.error(
+                "Mobius Agent integration installation failed",
+                error61
+              );
             });
             return;
           }
@@ -30438,12 +29755,12 @@ async function runRelayConnection(config2, directories, audit, sessions, install
           if (receipt.kind === "duplicate") {
             return;
           }
-          const turn = new ActiveDaemonTurn(command, new AbortController());
+          const turn = new ActiveDaemonTurn(command, receipt.attemptId);
           activeTurns.set(command.commandId, turn);
           activeAttemptIds.set(command.sessionId, receipt.attemptId);
           void executePrompt(
             outbox,
-            socket,
+            publisher,
             command,
             config2,
             directories,
@@ -30458,6 +29775,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
             if (activeAttemptIds.get(command.sessionId) === receipt.attemptId) {
               activeAttemptIds.delete(command.sessionId);
             }
+            turn.finish();
             connectionRefresh.afterTurnFinished();
           });
         } catch (error61) {
@@ -30469,6 +29787,28 @@ async function runRelayConnection(config2, directories, audit, sessions, install
       socket.addEventListener("close", handleClose);
       socket.addEventListener("error", handleError);
       socket.addEventListener("message", handleMessage);
+      void reconcileActiveTurns(
+        config2,
+        reconnectingTurns,
+        connectionController.signal
+      ).then(
+        () => {
+          if (finished) {
+            return;
+          }
+          publisher.connect(socket);
+          void Promise.all(
+            reconnectingTurns.map((turn) => turn.completion)
+          ).then(connectionRefresh.afterTurnFinished);
+        },
+        () => {
+          if (finished) {
+            return;
+          }
+          socket.close(1011, "Active Agent turn reconciliation failed");
+          rejectConnection();
+        }
+      );
       if (signal.aborted) {
         stop();
       }
@@ -30492,23 +29832,21 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
     publishCatalog: async (installationSignal) => await publishAgentCatalog(config2, installationSignal),
     stateDirectory
   });
-  await new AutomaticAdapterProvisioner(
-    {
-      defaultWorkspace: config2.defaultWorkspace,
-      audit: installationAudit,
-      catalog: config2.catalog,
-      environment: process.env
-    },
-    new ManagedAdapterInstaller({
-      environment: process.env,
-      stateDirectory
-    }),
-    specifications
-  ).prepare(signal);
   const sessionStore = new SqliteAcpSessionStore(config2.auditDatabasePath);
   const outbox = new SessionEventOutbox(config2.auditDatabasePath);
+  const publisher = new DaemonSessionEventPublisher(outbox);
+  const activeTurns = /* @__PURE__ */ new Map();
+  const activeAttemptIds = /* @__PURE__ */ new Map();
+  const recordSessionEvent = (sessionId, payload) => {
+    const attemptId = activeAttemptIds.get(sessionId);
+    if (attemptId === void 0) {
+      publisher.recordRuntime(sessionId, payload);
+      return;
+    }
+    publisher.recordAttempt(sessionId, payload, attemptId);
+  };
   const sessions = new AcpSessionManager(
-    new NullAcpSessionObserver(),
+    new DaemonAcpObserver(recordSessionEvent),
     sessionStore
   );
   const directories = new WorkspaceDirectoryService(
@@ -30564,6 +29902,9 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
           installationObserver,
           nativeSessions,
           outbox,
+          publisher,
+          activeTurns,
+          activeAttemptIds,
           announceConnection,
           signal,
           timer
@@ -30581,6 +29922,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
       await waitForRelayRetry(signal, timer);
     }
   } finally {
+    const turns = [...activeTurns.values()];
+    for (const turn of turns) {
+      turn.abortDaemon();
+    }
+    await Promise.all(turns.map((turn) => turn.completion));
     try {
       await catalogPublication;
     } finally {
@@ -30615,7 +29961,7 @@ Usage:
 Commands:
   pair   Pair this machine and start its local daemon
   start  Start the local daemon for a saved channel
-  agents Show locally available and installable Agents
+  agents Show detected, missing, and integration-ready Agents
 
 Pairing grants this browser access to the machine with your user account's permissions.
 New conversations default to ~/.mobius/workspace; choose other directories in the browser.
@@ -30631,7 +29977,7 @@ async function main() {
     if (arguments_.length > 1 || arguments_.length === 1 && arguments_[0] !== "--json") {
       throw new Error("Usage: mobius agents [--json]");
     }
-    await mkdir6(loadDefaultWorkspace(), { recursive: true, mode: 448 });
+    await mkdir4(loadDefaultWorkspace(), { recursive: true, mode: 448 });
     const inventory = await discoverLocalAgentInventory({
       defaultWorkspace: loadDefaultWorkspace(),
       environment: process.env,