@moxt-ai/mobius 0.0.17 → 0.0.18

package/dist/index.js

@@ -2007,8 +2007,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (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])$/;
@@ -18981,13 +18981,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);
@@ -21025,6 +21025,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;
@@ -24525,7 +24541,7 @@ var LocalAuthorizationError = class extends Error {
 import { randomUUID } from "node:crypto";
 import {
   mkdir as mkdir3,
-  open as open5,
+  open as open4,
   realpath as realpath6,
   rename as rename3,
   stat as stat5,
@@ -24552,12 +24568,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 {
@@ -24568,7 +24591,7 @@ var MissingAgent = class extends UnavailableAgent {
     super(specification);
   }
 };
-var ProbeFailed = class extends UnavailableAgent {
+var AgentProbeFailed = class extends UnavailableAgent {
   code;
   message;
   status = "probe_failed";
@@ -24578,20 +24601,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 {
@@ -24599,7 +24632,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) {
@@ -24614,13 +24647,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
         )
@@ -25014,7 +25042,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 {
@@ -25162,7 +25189,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(
@@ -25465,14 +25491,14 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
 import { join as join9 } 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 open4,
+  open as open3,
   realpath as realpath5,
   rename as rename2,
   rm as rm2,
@@ -25482,208 +25508,16 @@ import {
 import { dirname as dirname4, isAbsolute as isAbsolute4, join as join8, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
-import { createHash } from "node:crypto";
-import { open as open3, 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 open3(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;
@@ -25722,9 +25556,6 @@ var ManagedAgentArchiveError = class extends Error {
     this.name = "ManagedAgentArchiveError";
   }
 };
-var ManagedAgentArchiveDownloader = class {
-  download = async (options) => await downloadVerifiedFile(options);
-};
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -25734,7 +25565,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) {
@@ -25765,7 +25596,7 @@ async function hashFile(path2, signal) {
 async function readManifest(path2) {
   let handle;
   try {
-    handle = await open4(path2, "r");
+    handle = await open3(path2, "r");
   } catch (error61) {
     throw new ManagedAgentArchiveError(
       "managed_archive_verification_failed",
@@ -25836,144 +25667,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 = dirname4(root);
-    await mkdir2(parent, { mode: 448, recursive: true });
-    const working = await mkdtemp2(
-      join8(parent, `.${definition.version}.archive-`)
-    );
-    const staging = await mkdtemp2(
-      join8(parent, `.${definition.version}.staging-`)
-    );
-    try {
-      const archivePath = join8(working, definition.archiveName);
-      const extractionRoot = join8(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(
-        join8(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 = join8(staging, "bin");
-      const executablePath = join8(binDirectory, definition.executableName);
-      await mkdir2(binDirectory, { mode: 448 });
-      await copyFile(extracted, executablePath);
-      await chmod(executablePath, 448);
-      const executableSha256 = await hashFile(executablePath, signal);
-      await writeFile(
-        join8(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";
@@ -26476,10 +26169,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;
@@ -26545,41 +26234,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;
     }
   });
 }
@@ -26708,25 +26397,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) {
@@ -26735,12 +26449,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);
   }
@@ -26760,9 +26468,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;
@@ -26791,7 +26508,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(
@@ -26840,7 +26561,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;
         }
@@ -26848,7 +26573,7 @@ async function discoverAgent(specification, context) {
       }
     }
   }
-  return lastFailure ?? new IncompatibleAdapter(specification);
+  return lastFailure ?? new MissingAgent(specification);
 }
 
 // src/agent-catalog/discover-local-agents.ts
@@ -26859,11 +26584,7 @@ async function discoverLocalAgentInventory(options) {
       async (specification) => await discoverAgent(specification, options)
     )
   );
-  return new LocalAgentInventory(
-    discoveries,
-    options.platform,
-    options.architecture
-  );
+  return new LocalAgentInventory(discoveries);
 }
 
 // src/pairing/pair-local-machine.ts
@@ -27079,6 +26800,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
   }));
@@ -27088,10 +26811,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"
@@ -27174,7 +26894,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) {
@@ -27211,7 +26931,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"
     );
   }
 }
@@ -27299,7 +27019,7 @@ 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/agent-catalog/publish-agent-catalog.ts
 import { fetch as fetch3 } from "undici";
@@ -27332,13 +27052,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" },
@@ -27434,7 +27153,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;
     }
   }
@@ -27446,7 +27165,7 @@ function executionFailure(error61) {
   }
   return new InstallationManagerError(
     "installation_failed",
-    "The local Agent installation failed",
+    "The local Agent integration installation failed",
     { cause: error61 }
   );
 }
@@ -27517,7 +27236,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;
@@ -27554,7 +27273,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 () => {
@@ -27564,7 +27283,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"));
@@ -27586,7 +27305,7 @@ var AgentInstallationManager = class {
       job.controller.abort(
         new InstallationManagerError(
           "installation_timeout",
-          "The local Agent installation exceeded its deadline"
+          "The local Agent integration installation exceeded its deadline"
         )
       );
     }, INSTALLATION_DEADLINE_MILLISECONDS);
@@ -27676,891 +27395,66 @@ var AgentInstallationManager = class {
   };
 };
 
-// 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;
+// 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) {
+      return 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
+  throw new InstallationManagerError(
+    "unknown_agent",
+    "The requested Agent is not supported"
   );
 }
-function stableFailureCode(error61) {
-  return error61 instanceof ManagedAdapterInstallError ? error61.code : "adapter_install_failed";
+function resolveDefaultWorkspace2(path2) {
+  try {
+    const directory = realpathSync2(resolve4(path2));
+    if (!statSync2(directory).isDirectory()) {
+      throw new Error("Default workspace is not a directory");
+    }
+    return directory;
+  } catch (error61) {
+    throw new InstallationManagerError(
+      "unsafe_installation_root",
+      "The default workspace is unavailable or unsafe",
+      { cause: error61 }
+    );
+  }
 }
-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
-  };
+function resolveIntegrationStateDirectory(path2) {
+  try {
+    const directory = realpathSync2(resolve4(path2));
+    const metadata = statSync2(directory);
+    if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
+      throw new Error("Installation directory is not user-owned");
+    }
+    return directory;
+  } catch (error61) {
+    throw new InstallationManagerError(
+      "unsafe_installation_root",
+      "The local integration state directory is unavailable or unsafe",
+      { cause: error61 }
+    );
+  }
 }
-var AutomaticAdapterProvisioner = class {
-  #adapterInstaller;
-  #options;
-  #specifications;
-  constructor(options, adapterInstaller, specifications = supportedLocalAgentSpecifications()) {
-    this.#adapterInstaller = adapterInstaller;
-    this.#options = options;
-    this.#specifications = Object.freeze([...specifications]);
+function translateExecutionError(error61) {
+  if (error61 instanceof InstallationManagerError) {
+    return error61;
   }
-  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 }
-      );
-    }
-  };
-};
-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);
-    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
-      );
-      options.audit.record(
-        "agent_archive_verified",
-        options.requestId,
-        this.id,
-        {
-          sha256: definition.archiveSha256,
-          version: definition.version
-        }
-      );
-      return executable;
-    } 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 (error61.code === "managed_archive_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed OpenCode archive 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 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
-function findSpecification(specifications, agentId) {
-  for (const specification of specifications) {
-    if (specification.id === agentId) {
-      return specification;
-    }
-  }
-  throw new InstallationManagerError(
-    "unknown_agent",
-    "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));
-    if (!statSync2(directory).isDirectory()) {
-      throw new Error("Default workspace is not a directory");
-    }
-    return directory;
-  } catch (error61) {
-    throw new InstallationManagerError(
-      "unsafe_installation_root",
-      "The default workspace is unavailable or unsafe",
-      { cause: error61 }
-    );
-  }
-}
-function resolveUserInstallationDirectory(path2) {
-  try {
-    const directory = realpathSync2(resolve4(path2));
-    const metadata = statSync2(directory);
-    if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
-      throw new Error("Installation directory is not user-owned");
-    }
-    return directory;
-  } catch (error61) {
-    throw new InstallationManagerError(
-      "unsafe_installation_root",
-      "The local Agent installation root is unavailable or unsafe",
-      { cause: error61 }
-    );
-  }
-}
-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";
 }
@@ -28571,12 +27465,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;
@@ -28584,9 +27476,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
@@ -28595,35 +27485,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"
+        );
+      }
+      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.`
+        );
       }
-      let adapter = specification instanceof DirectAcpAgentDefinition ? agent : await resolveAdapterExecutable(specification, discoveryOptions2);
+      const agent = verifiedAgent.executable;
+      let adapter = specification instanceof DirectAcpAgentDefinition ? agent : await resolveAdapterExecutable(specification, discoveryOptions);
       let installedAdapter = false;
       if (adapter === null) {
         if (!(specification instanceof BridgedAcpAgentDefinition)) {
@@ -28632,6 +27546,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;
@@ -28642,8 +27562,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,
@@ -28651,7 +27571,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(
@@ -28663,7 +27583,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
@@ -28672,15 +27592,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(
@@ -28688,7 +27608,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;
@@ -28697,21 +27617,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
@@ -28727,15 +27632,15 @@ var FixedInstallationExecutor = class {
 };
 
 // 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;
@@ -28785,20 +27690,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"
         );
@@ -28813,8 +27718,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);
@@ -28842,7 +27747,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();
@@ -28850,7 +27755,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),
@@ -28874,7 +27779,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";
@@ -29188,7 +28093,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,
@@ -29213,7 +28118,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,
@@ -29533,7 +28438,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 {
@@ -29624,7 +28529,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(
@@ -29643,7 +28548,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)) {
@@ -29658,7 +28563,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 (
@@ -29812,6 +28717,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 {
@@ -30009,7 +28915,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 {
@@ -30023,16 +28929,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) {
@@ -30042,25 +28952,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,
@@ -30156,7 +29159,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,
@@ -30183,9 +29186,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,
@@ -30216,7 +29217,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,
@@ -30242,9 +29243,7 @@ async function executeSessionConfigure(outbox, socket, command, config2, directo
       event: "session_configured",
       sessionId: command.sessionId
     });
-    recordSessionEvent(
-      outbox,
-      socket,
+    publisher.recordRuntime(
       command.sessionId,
       encodeSessionConfigUpdatedEvent({
         configOptions,
@@ -30257,7 +29256,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,
@@ -30273,9 +29272,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,
@@ -30292,9 +29289,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,
@@ -30318,9 +29313,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,
@@ -30337,9 +29330,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,
@@ -30366,8 +29357,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),
@@ -30413,29 +29403,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;
@@ -30447,11 +29423,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) {
@@ -30670,7 +29643,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,
@@ -30684,7 +29657,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,
@@ -30734,7 +29707,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;
           }
@@ -30760,12 +29736,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,
@@ -30780,6 +29756,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) {
@@ -30791,6 +29768,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();
       }
@@ -30814,23 +29813,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(
@@ -30886,6 +29883,9 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
           installationObserver,
           nativeSessions,
           outbox,
+          publisher,
+          activeTurns,
+          activeAttemptIds,
           announceConnection,
           signal,
           timer
@@ -30903,6 +29903,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 {