@moxt-ai/mobius 0.0.16 → 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;
@@ -21139,7 +21155,7 @@ function loadDaemonConfig() {
 // src/acp/session-manager.ts
 import { spawn as spawn2 } from "node:child_process";
 import {
-  methods as methods2,
+  methods as methods3,
   ndJsonStream,
   PROTOCOL_VERSION,
   RequestError
@@ -21653,6 +21669,491 @@ var nativeSessionPageSchema = external_exports.object({
   nextCursor: external_exports.string().min(1).max(4096).nullish()
 }).readonly();
 
+// src/acp/session-config/session-config-protocol.ts
+import { methods as methods2 } from "@agentclientprotocol/sdk";
+var AGENT_DEFAULT_REASONING_EFFORT = "agent_default";
+var MAXIMUM_CONFIG_OPTIONS = 100;
+var SessionConfigProtocolError = class extends Error {
+  code = "invalid_session_configuration_response";
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "SessionConfigProtocolError";
+  }
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString2(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function truncate2(value, maximum) {
+  return value.length <= maximum ? value : value.slice(0, maximum);
+}
+function readBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function normalizeConfigValue(option, groupId = "", groupName = "") {
+  return {
+    description: truncate2(readString2(option["description"]), 500),
+    groupId: truncate2(groupId, 128),
+    groupName: truncate2(groupName, 255),
+    name: truncate2(
+      readString2(option["name"], readString2(option["value"])),
+      255
+    ),
+    value: truncate2(readString2(option["value"]), 500)
+  };
+}
+function normalizeConfigValues(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const normalized = [];
+  for (const entry of value) {
+    if (!isRecord3(entry)) {
+      continue;
+    }
+    const groupedOptions = entry["options"];
+    if (Array.isArray(groupedOptions)) {
+      const groupId = readString2(entry["group"]);
+      const groupName = readString2(entry["name"]);
+      for (const groupedOption of groupedOptions) {
+        if (isRecord3(groupedOption)) {
+          normalized.push(
+            normalizeConfigValue(groupedOption, groupId, groupName)
+          );
+        }
+      }
+      continue;
+    }
+    normalized.push(normalizeConfigValue(entry));
+  }
+  return normalized.filter((entry) => entry.value.length > 0).slice(0, 500);
+}
+function normalizeConfigOptions(value, modes) {
+  const normalized = [];
+  if (Array.isArray(value)) {
+    for (const option of value) {
+      if (!isRecord3(option)) {
+        continue;
+      }
+      const id = truncate2(readString2(option["id"]), 128);
+      const name = truncate2(readString2(option["name"], id), 255);
+      if (id.length === 0 || name.length === 0) {
+        continue;
+      }
+      if (option["type"] === "boolean") {
+        normalized.push({
+          booleanValue: readBoolean(option["currentValue"]),
+          category: truncate2(readString2(option["category"]), 128),
+          currentValue: "",
+          description: truncate2(readString2(option["description"]), 500),
+          id,
+          name,
+          type: "boolean",
+          values: []
+        });
+        continue;
+      }
+      if (option["type"] === "select") {
+        const values = normalizeConfigValues(option["options"]);
+        const currentValue = truncate2(readString2(option["currentValue"]), 500);
+        if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue)) {
+          normalized.push({
+            booleanValue: false,
+            category: truncate2(readString2(option["category"]), 128),
+            currentValue,
+            description: truncate2(readString2(option["description"]), 500),
+            id,
+            name,
+            type: "select",
+            values
+          });
+        }
+      }
+    }
+  }
+  if (isRecord3(modes)) {
+    const values = [];
+    const availableModes = modes["availableModes"];
+    if (Array.isArray(availableModes)) {
+      for (const mode of availableModes) {
+        if (!isRecord3(mode)) {
+          continue;
+        }
+        const id = truncate2(readString2(mode["id"]), 500);
+        if (id.length === 0) {
+          continue;
+        }
+        values.push({
+          description: truncate2(readString2(mode["description"]), 500),
+          groupId: "",
+          groupName: "",
+          name: truncate2(readString2(mode["name"], id), 255),
+          value: id
+        });
+      }
+    }
+    const currentValue = truncate2(readString2(modes["currentModeId"]), 500);
+    if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue) && !normalized.some((entry) => entry.category === "mode")) {
+      normalized.unshift({
+        booleanValue: false,
+        category: "mode",
+        currentValue,
+        description: "Agent session mode",
+        id: "mode",
+        name: "Mode",
+        type: "select",
+        values
+      });
+    }
+  }
+  return normalized.slice(0, 100);
+}
+function ensureReasoningEffortOption(current) {
+  if (current.some((option) => option.category === "thought_level")) {
+    return current;
+  }
+  const unavailable = {
+    booleanValue: false,
+    category: "thought_level",
+    currentValue: AGENT_DEFAULT_REASONING_EFFORT,
+    description: "This Agent does not expose adjustable reasoning effort for the selected model.",
+    id: "reasoning_effort",
+    name: "Reasoning effort",
+    type: "select",
+    values: [
+      {
+        description: "Selected by the Agent",
+        groupId: "",
+        groupName: "",
+        name: "Agent default",
+        value: AGENT_DEFAULT_REASONING_EFFORT
+      }
+    ]
+  };
+  const modelIndex = current.findIndex((option) => option.category === "model");
+  if (current.length < MAXIMUM_CONFIG_OPTIONS) {
+    if (modelIndex < 0) {
+      return [...current, unavailable];
+    }
+    return [
+      ...current.slice(0, modelIndex + 1),
+      unavailable,
+      ...current.slice(modelIndex + 1)
+    ];
+  }
+  if (modelIndex < 0) {
+    return [...current.slice(0, MAXIMUM_CONFIG_OPTIONS - 1), unavailable];
+  }
+  if (modelIndex < MAXIMUM_CONFIG_OPTIONS - 1) {
+    return [
+      ...current.slice(0, modelIndex + 1),
+      unavailable,
+      ...current.slice(modelIndex + 1, MAXIMUM_CONFIG_OPTIONS - 1)
+    ];
+  }
+  const model = current[modelIndex];
+  if (model === void 0) {
+    return [...current.slice(0, MAXIMUM_CONFIG_OPTIONS - 1), unavailable];
+  }
+  return [...current.slice(0, MAXIMUM_CONFIG_OPTIONS - 2), model, unavailable];
+}
+function normalizeStandardLifecycle(response) {
+  const lifecycle = isRecord3(response) ? response : {};
+  return ensureReasoningEffortOption(
+    normalizeConfigOptions(lifecycle["configOptions"], lifecycle["modes"])
+  );
+}
+function replaceStandardConfigOptions(current, value) {
+  const next = normalizeConfigOptions(value, void 0);
+  const withMode = next.some((option) => option.category === "mode") ? next : [
+    ...current.filter((option) => option.category === "mode"),
+    ...next
+  ].slice(0, 100);
+  return ensureReasoningEffortOption(withMode);
+}
+function updateCurrentValue(current, configId, value) {
+  return current.map(
+    (option) => option.id === configId ? { ...option, currentValue: value } : option
+  );
+}
+var StandardSessionConfigProtocol = class {
+  configure = async (current, change, nativeSessionId, transport) => {
+    const existing = current.find((option) => option.id === change.configId);
+    if (existing === void 0) {
+      return current;
+    }
+    if (existing.type === "select" && existing.category === "mode") {
+      await transport.request(
+        methods2.agent.session.setMode,
+        { modeId: change.value, sessionId: nativeSessionId },
+        "ACP agent exited while setting the session mode",
+        change.signal
+      );
+      return updateCurrentValue(current, existing.id, change.value);
+    }
+    const params = existing.type === "boolean" ? {
+      configId: existing.id,
+      sessionId: nativeSessionId,
+      type: "boolean",
+      value: change.booleanValue
+    } : {
+      configId: existing.id,
+      sessionId: nativeSessionId,
+      value: change.value
+    };
+    const response = await transport.request(
+      methods2.agent.session.setConfigOption,
+      params,
+      "ACP agent exited while changing session configuration",
+      change.signal
+    );
+    if (!isRecord3(response) || !Array.isArray(response["configOptions"])) {
+      throw new SessionConfigProtocolError(
+        "The Agent returned an invalid session configuration response"
+      );
+    }
+    return replaceStandardConfigOptions(current, response["configOptions"]);
+  };
+  normalizeLifecycle = (response) => normalizeStandardLifecycle(response);
+  normalizeUpdate = (current, value) => replaceStandardConfigOptions(current, value);
+};
+var standardSessionConfigProtocol = new StandardSessionConfigProtocol();
+
+// src/acp/session-config/grok-build-session-config.ts
+var LEGACY_MODEL_CONFIG_ID = "grok_build_legacy_model";
+var LEGACY_REASONING_EFFORT_CONFIG_ID = "grok_build_legacy_reasoning_effort";
+function legacyOptions(response) {
+  if (!isRecord3(response)) {
+    return [];
+  }
+  const metadata = response["_meta"];
+  if (!isRecord3(metadata)) {
+    return [];
+  }
+  const sessionConfig = metadata["x.ai/sessionConfig"];
+  if (!isRecord3(sessionConfig) || !Array.isArray(sessionConfig["options"])) {
+    return [];
+  }
+  return sessionConfig["options"].slice(0, 500).filter(isRecord3);
+}
+function legacyValue(option) {
+  const value = readString2(option["id"]);
+  return {
+    description: readString2(option["description"]).slice(0, 500),
+    groupId: "",
+    groupName: "",
+    name: readString2(option["label"], value).slice(0, 255),
+    value: value.slice(0, 500)
+  };
+}
+function modelsRecord(response) {
+  if (!isRecord3(response) || !isRecord3(response["models"])) {
+    return {};
+  }
+  return response["models"];
+}
+function legacyModelOptions(response) {
+  const options = legacyOptions(response);
+  const models = modelsRecord(response);
+  const values = [];
+  for (const option of options) {
+    if (option["category"] === "model") {
+      const value = legacyValue(option);
+      if (value.value.length > 0 && !values.some((existing) => existing.value === value.value)) {
+        values.push(value);
+      }
+    }
+  }
+  if (values.length === 0 && Array.isArray(models["availableModels"])) {
+    for (const model of models["availableModels"]) {
+      if (!isRecord3(model)) {
+        continue;
+      }
+      const value = readString2(model["modelId"]).slice(0, 500);
+      if (value.length === 0) {
+        continue;
+      }
+      if (!values.some((existing) => existing.value === value)) {
+        values.push({
+          description: "",
+          groupId: "",
+          groupName: "",
+          name: readString2(model["name"], value).slice(0, 255),
+          value
+        });
+      }
+    }
+  }
+  const selected = options.find(
+    (option) => option["category"] === "model" && option["selected"] === true
+  );
+  const currentValue = readString2(
+    models["currentModelId"],
+    selected === void 0 ? "" : readString2(selected["id"])
+  ).slice(0, 500);
+  if (values.length === 0 || !values.some((value) => value.value === currentValue)) {
+    return [];
+  }
+  const result = {
+    booleanValue: false,
+    category: "model",
+    currentValue,
+    description: "Model used by Grok Build",
+    id: LEGACY_MODEL_CONFIG_ID,
+    name: "Model",
+    type: "select",
+    values: values.slice(0, 500)
+  };
+  return [result];
+}
+function legacyReasoningEffortOptions(response) {
+  const options = legacyOptions(response);
+  const values = [];
+  for (const option of options) {
+    if (option["category"] !== "mode") {
+      continue;
+    }
+    const value = legacyValue(option);
+    if (value.value.length > 0 && !values.some((existing) => existing.value === value.value)) {
+      values.push(value);
+    }
+  }
+  if (values.length === 0) {
+    return [];
+  }
+  const selected = options.find(
+    (option) => option["category"] === "mode" && option["selected"] === true
+  );
+  if (selected === void 0) {
+    values.unshift({
+      description: "Use the selected model's default reasoning effort",
+      groupId: "",
+      groupName: "",
+      name: "Agent default",
+      value: AGENT_DEFAULT_REASONING_EFFORT
+    });
+  }
+  const currentValue = selected === void 0 ? AGENT_DEFAULT_REASONING_EFFORT : readString2(selected["id"], AGENT_DEFAULT_REASONING_EFFORT);
+  if (!values.some((value) => value.value === currentValue)) {
+    return [];
+  }
+  const result = {
+    booleanValue: false,
+    category: "thought_level",
+    currentValue,
+    description: "Reasoning effort used by Grok Build",
+    id: LEGACY_REASONING_EFFORT_CONFIG_ID,
+    name: "Reasoning effort",
+    type: "select",
+    values: values.slice(0, 500)
+  };
+  return [result];
+}
+function normalizeGrokLifecycle(response) {
+  const lifecycle = isRecord3(response) ? response : {};
+  const standard = normalizeConfigOptions(
+    lifecycle["configOptions"],
+    lifecycle["modes"]
+  );
+  const normalized = [...standard];
+  if (!normalized.some((option) => option.category === "model")) {
+    normalized.push(...legacyModelOptions(response));
+  }
+  if (!normalized.some((option) => option.category === "thought_level")) {
+    const efforts = legacyReasoningEffortOptions(response);
+    if (efforts.length > 0) {
+      const modelIndex = normalized.findIndex(
+        (option) => option.category === "model"
+      );
+      normalized.splice(
+        modelIndex < 0 ? normalized.length : modelIndex + 1,
+        0,
+        ...efforts
+      );
+    }
+  }
+  return ensureReasoningEffortOption(normalized.slice(0, 100));
+}
+function updateCurrentValue2(current, category, value) {
+  return current.map(
+    (option) => option.category === category ? { ...option, currentValue: value } : option
+  );
+}
+function validateGrokResponse(response, modelId) {
+  if (!isRecord3(response) || !isRecord3(response["_meta"])) {
+    throw new SessionConfigProtocolError(
+      "Grok Build returned an invalid session configuration response"
+    );
+  }
+  const model = response["_meta"]["model"];
+  const appliedModel = isRecord3(model) ? model["Ok"] : model;
+  if (appliedModel !== modelId) {
+    throw new SessionConfigProtocolError(
+      "Grok Build returned an invalid session configuration response"
+    );
+  }
+}
+var GrokBuildSessionConfigProtocol = class {
+  configure = async (current, change, nativeSessionId, transport) => {
+    const existing = current.find((option) => option.id === change.configId);
+    if (existing === void 0 || existing.id !== LEGACY_MODEL_CONFIG_ID && existing.id !== LEGACY_REASONING_EFFORT_CONFIG_ID) {
+      return await standardSessionConfigProtocol.configure(
+        current,
+        change,
+        nativeSessionId,
+        transport
+      );
+    }
+    const model = current.find((option) => option.category === "model");
+    if (model === void 0) {
+      return current;
+    }
+    if (existing.category === "thought_level" && change.value === AGENT_DEFAULT_REASONING_EFFORT) {
+      return current;
+    }
+    const modelId = existing.category === "model" ? change.value : model.currentValue;
+    const params = {
+      modelId,
+      sessionId: nativeSessionId
+    };
+    if (existing.category === "thought_level") {
+      params["_meta"] = {
+        reasoningEffort: change.value
+      };
+    }
+    const response = await transport.request(
+      "session/set_model",
+      params,
+      existing.category === "model" ? "Grok Build exited while setting the session model" : "Grok Build exited while setting reasoning effort",
+      change.signal
+    );
+    validateGrokResponse(response, modelId);
+    const updated = updateCurrentValue2(
+      current,
+      existing.category,
+      change.value
+    );
+    return existing.category === "thought_level" ? updated.map(
+      (option) => option.category === "thought_level" ? {
+        ...option,
+        values: option.values.filter(
+          (value) => value.value !== AGENT_DEFAULT_REASONING_EFFORT
+        )
+      } : option
+    ) : updated;
+  };
+  normalizeLifecycle = (response) => normalizeGrokLifecycle(response);
+  normalizeUpdate = (current, value) => standardSessionConfigProtocol.normalizeUpdate(current, value);
+};
+var grokBuildSessionConfigProtocol = new GrokBuildSessionConfigProtocol();
+
+// src/acp/session-config/session-config-registry.ts
+function sessionConfigProtocolForAgent(agentId) {
+  return agentId === "grok-build" ? grokBuildSessionConfigProtocol : standardSessionConfigProtocol;
+}
+
 // src/acp/session-history.ts
 var AcpHistoryReplay = class {
   #messages = [];
@@ -21757,7 +22258,7 @@ var FoundAcpStoredSession = class extends AcpStoredSessionLookup {
 var DeletedAcpStoredSession = class extends AcpStoredSessionLookup {
   found = false;
 };
-function readString2(value, field) {
+function readString3(value, field) {
   if (typeof value !== "string" || value.length === 0) {
     throw new Error(`Stored ACP session has an invalid ${field}`);
   }
@@ -21787,10 +22288,10 @@ function decodeSessionRow(row) {
     throw new Error("Stored ACP session is not an object");
   }
   return new AcpStoredSession(
-    readString2(Reflect.get(row, "session_id"), "session ID"),
-    readString2(Reflect.get(row, "agent_id"), "agent ID"),
-    readString2(Reflect.get(row, "native_session_id"), "native session ID"),
-    readString2(Reflect.get(row, "cwd"), "working directory"),
+    readString3(Reflect.get(row, "session_id"), "session ID"),
+    readString3(Reflect.get(row, "agent_id"), "agent ID"),
+    readString3(Reflect.get(row, "native_session_id"), "native session ID"),
+    readString3(Reflect.get(row, "cwd"), "working directory"),
     readAdditionalDirectories(Reflect.get(row, "additional_directories_json")),
     readPrompted(Reflect.get(row, "prompted"))
   );
@@ -22052,168 +22553,37 @@ function createWritableAcpStream(output2) {
     }
   });
 }
-function truncate2(value, maximumLength) {
+function truncate3(value, maximumLength) {
   return value.length <= maximumLength ? value : `${value.slice(0, Math.max(0, maximumLength - 1))}\u2026`;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readString3(value, fallback = "") {
+function readString4(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
-function readBoolean(value, fallback = false) {
-  return typeof value === "boolean" ? value : fallback;
-}
 function arraysEqual(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
-function normalizeConfigValue(option, groupId = "", groupName = "") {
+function normalizeCapabilities(capabilities) {
+  const session = capabilities.sessionCapabilities;
+  const prompt = capabilities.promptCapabilities;
   return {
-    description: truncate2(readString3(option["description"]), 500),
-    groupId: truncate2(groupId, 128),
-    groupName: truncate2(groupName, 255),
-    name: truncate2(
-      readString3(option["name"], readString3(option["value"])),
-      255
-    ),
-    value: truncate2(readString3(option["value"]), 500)
+    additionalDirectories: session?.additionalDirectories != null,
+    audioPrompt: prompt?.audio === true,
+    closeSession: session?.close != null,
+    deleteSession: session?.delete != null,
+    embeddedContextPrompt: prompt?.embeddedContext === true,
+    imagePrompt: prompt?.image === true,
+    listSessions: session?.list != null,
+    loadSession: capabilities.loadSession === true,
+    resumeSession: session?.resume != null,
+    unstableForkSession: session?.fork != null
   };
 }
-function normalizeConfigValues(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const normalized = [];
-  for (const entry of value) {
-    if (!isRecord3(entry)) {
-      continue;
-    }
-    const groupedOptions = entry["options"];
-    if (Array.isArray(groupedOptions)) {
-      const groupId = readString3(entry["group"]);
-      const groupName = readString3(entry["name"]);
-      for (const groupedOption of groupedOptions) {
-        if (isRecord3(groupedOption)) {
-          normalized.push(
-            normalizeConfigValue(groupedOption, groupId, groupName)
-          );
-        }
-      }
-      continue;
-    }
-    normalized.push(normalizeConfigValue(entry));
-  }
-  return normalized.filter((entry) => entry.value.length > 0).slice(0, 500);
-}
-function normalizeConfigOptions(value, modes) {
-  const normalized = [];
-  if (Array.isArray(value)) {
-    for (const option of value) {
-      if (!isRecord3(option)) {
-        continue;
-      }
-      const id = truncate2(readString3(option["id"]), 128);
-      const name = truncate2(readString3(option["name"], id), 255);
-      if (id.length === 0 || name.length === 0) {
-        continue;
-      }
-      if (option["type"] === "boolean") {
-        normalized.push({
-          booleanValue: readBoolean(option["currentValue"]),
-          category: truncate2(readString3(option["category"]), 128),
-          currentValue: "",
-          description: truncate2(readString3(option["description"]), 500),
-          id,
-          name,
-          type: "boolean",
-          values: []
-        });
-        continue;
-      }
-      if (option["type"] === "select") {
-        const values = normalizeConfigValues(option["options"]);
-        const currentValue = truncate2(readString3(option["currentValue"]), 500);
-        if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue)) {
-          normalized.push({
-            booleanValue: false,
-            category: truncate2(readString3(option["category"]), 128),
-            currentValue,
-            description: truncate2(readString3(option["description"]), 500),
-            id,
-            name,
-            type: "select",
-            values
-          });
-        }
-      }
-    }
-  }
-  if (isRecord3(modes)) {
-    const values = [];
-    const availableModes = modes["availableModes"];
-    if (Array.isArray(availableModes)) {
-      for (const mode of availableModes) {
-        if (!isRecord3(mode)) {
-          continue;
-        }
-        const id = truncate2(readString3(mode["id"]), 500);
-        if (id.length === 0) {
-          continue;
-        }
-        values.push({
-          description: truncate2(readString3(mode["description"]), 500),
-          groupId: "",
-          groupName: "",
-          name: truncate2(readString3(mode["name"], id), 255),
-          value: id
-        });
-      }
-    }
-    const currentValue = truncate2(readString3(modes["currentModeId"]), 500);
-    if (currentValue.length > 0 && values.some((entry) => entry.value === currentValue) && !normalized.some((entry) => entry.category === "mode")) {
-      normalized.unshift({
-        booleanValue: false,
-        category: "mode",
-        currentValue,
-        description: "Agent session mode",
-        id: "mode",
-        name: "Mode",
-        type: "select",
-        values
-      });
-    }
-  }
-  return normalized.slice(0, 100);
-}
-function replaceConfigOptionsKeepingMode(current, value) {
-  const next = normalizeConfigOptions(value, void 0);
-  if (next.some((option) => option.category === "mode")) {
-    return next;
-  }
-  return [
-    ...current.filter((option) => option.category === "mode"),
-    ...next
-  ].slice(0, 100);
-}
-function normalizeCapabilities(capabilities) {
-  const session = capabilities.sessionCapabilities;
-  const prompt = capabilities.promptCapabilities;
-  return {
-    additionalDirectories: session?.additionalDirectories != null,
-    audioPrompt: prompt?.audio === true,
-    closeSession: session?.close != null,
-    deleteSession: session?.delete != null,
-    embeddedContextPrompt: prompt?.embeddedContext === true,
-    imagePrompt: prompt?.image === true,
-    listSessions: session?.list != null,
-    loadSession: capabilities.loadSession === true,
-    resumeSession: session?.resume != null,
-    unstableForkSession: session?.fork != null
-  };
-}
-function elicitationFieldType(value) {
-  if (value === "boolean") {
-    return "boolean";
+function elicitationFieldType(value) {
+  if (value === "boolean") {
+    return "boolean";
   }
   if (value === "integer") {
     return "integer";
@@ -22231,11 +22601,11 @@ function normalizeElicitationOptions(schema) {
   const oneOf = schema["oneOf"];
   if (Array.isArray(oneOf)) {
     for (const option of oneOf) {
-      if (isRecord3(option) && typeof option["const"] === "string") {
+      if (isRecord4(option) && typeof option["const"] === "string") {
         normalized.push({
-          description: truncate2(readString3(option["description"]), 500),
-          label: truncate2(readString3(option["title"], option["const"]), 255),
-          value: truncate2(option["const"], 500)
+          description: truncate3(readString4(option["description"]), 500),
+          label: truncate3(readString4(option["title"], option["const"]), 255),
+          value: truncate3(option["const"], 500)
         });
       }
     }
@@ -22251,7 +22621,7 @@ function normalizeElicitationOptions(schema) {
     return normalized.slice(0, 200);
   }
   const items = schema["items"];
-  if (!isRecord3(items)) {
+  if (!isRecord4(items)) {
     return normalized;
   }
   const anyOf = items["anyOf"];
@@ -22264,7 +22634,7 @@ function numericString(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toString() : "";
 }
 function normalizeElicitationFields(requestedSchema) {
-  if (!isRecord3(requestedSchema) || !isRecord3(requestedSchema["properties"])) {
+  if (!isRecord4(requestedSchema) || !isRecord4(requestedSchema["properties"])) {
     return [];
   }
   const properties = requestedSchema["properties"];
@@ -22274,7 +22644,7 @@ function normalizeElicitationFields(requestedSchema) {
   );
   const normalized = [];
   for (const [name, property] of Object.entries(properties)) {
-    if (!isRecord3(property)) {
+    if (!isRecord4(property)) {
       continue;
     }
     const type = elicitationFieldType(property["type"]);
@@ -22284,9 +22654,9 @@ function normalizeElicitationFields(requestedSchema) {
     normalized.push({
       defaultBooleanValue: typeof defaultValue === "boolean" ? defaultValue : false,
       defaultNumberValue: typeof defaultValue === "number" && Number.isFinite(defaultValue) ? defaultValue : 0,
-      defaultStringValue: typeof defaultValue === "string" ? truncate2(defaultValue, 1e4) : Array.isArray(defaultValue) ? truncate2(JSON.stringify(defaultValue), 1e4) : "",
-      description: truncate2(readString3(property["description"]), 500),
-      format: truncate2(readString3(property["format"]), 64),
+      defaultStringValue: typeof defaultValue === "string" ? truncate3(defaultValue, 1e4) : Array.isArray(defaultValue) ? truncate3(JSON.stringify(defaultValue), 1e4) : "",
+      description: truncate3(readString4(property["description"]), 500),
+      format: truncate3(readString4(property["format"]), 64),
       hasDefaultValue: defaultValue !== void 0 && defaultValue !== null,
       maximum: numericString(property["maximum"]),
       maximumLength: numericString(
@@ -22296,11 +22666,11 @@ function normalizeElicitationFields(requestedSchema) {
       minimumLength: numericString(
         property["minLength"] ?? property["minItems"]
       ),
-      name: truncate2(name, 128),
+      name: truncate3(name, 128),
       options,
-      pattern: truncate2(readString3(property["pattern"]), 500),
+      pattern: truncate3(readString4(property["pattern"]), 500),
       required: required2.has(name),
-      title: truncate2(readString3(property["title"], name), 255),
+      title: truncate3(readString4(property["title"], name), 255),
       type: normalizedType
     });
   }
@@ -22369,7 +22739,7 @@ function validateElicitationContent(encoded, requestedSchema) {
       "invalid_elicitation_response"
     );
   }
-  if (!isRecord3(decoded) || !isRecord3(requestedSchema) || !isRecord3(requestedSchema["properties"])) {
+  if (!isRecord4(decoded) || !isRecord4(requestedSchema) || !isRecord4(requestedSchema["properties"])) {
     throw new AcpExecutionError(
       "Elicitation response does not match the requested form",
       {},
@@ -22393,7 +22763,7 @@ function validateElicitationContent(encoded, requestedSchema) {
   const validated = {};
   for (const [name, value] of Object.entries(decoded)) {
     const property = properties[name];
-    if (!isRecord3(property)) {
+    if (!isRecord4(property)) {
       throw new AcpExecutionError(
         `Elicitation field ${name} was not requested`,
         {},
@@ -22545,6 +22915,7 @@ var AcpProcessSession = class _AcpProcessSession {
   #pendingPermissions = /* @__PURE__ */ new Map();
   #preSessionUpdates = [];
   #processExit;
+  #sessionConfigProtocol;
   #store;
   #verifiedAgentVersion;
   #preSessionUpdateBytes = 0;
@@ -22563,6 +22934,7 @@ var AcpProcessSession = class _AcpProcessSession {
     unstableForkSession: false
   };
   #commands = [];
+  #configRevision = 0;
   #configOptions = [];
   #nativeSessionId = "";
   #prompted = false;
@@ -22580,6 +22952,7 @@ var AcpProcessSession = class _AcpProcessSession {
     this.#cwd = cwd;
     this.#getObserver = getObserver;
     this.#mobiusSessionId = mobiusSessionId;
+    this.#sessionConfigProtocol = sessionConfigProtocolForAgent(agent.id);
     this.#store = store;
     this.#verifiedAgentVersion = agent.agentVersion;
     this.#child = spawn2(agent.adapterPath, [...agent.arguments], {
@@ -22684,7 +23057,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       await this.race(
         this.#connection.agent.request(
-          methods2.agent.session.load,
+          methods3.agent.session.load,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -22706,7 +23079,7 @@ var AcpProcessSession = class _AcpProcessSession {
   async #initializeAgent(signal) {
     const initialized = await this.race(
       this.#connection.agent.request(
-        methods2.agent.initialize,
+        methods3.agent.initialize,
         {
           clientCapabilities: {
             elicitation: { form: {}, url: {} },
@@ -22733,11 +23106,11 @@ var AcpProcessSession = class _AcpProcessSession {
     }
     const capabilities = initialized.agentCapabilities ?? {};
     this.#capabilities = normalizeCapabilities(capabilities);
-    this.#agentName = truncate2(
+    this.#agentName = truncate3(
       initialized.agentInfo?.title ?? initialized.agentInfo?.name ?? this.#agentId,
       255
     );
-    this.#agentVersion = truncate2(
+    this.#agentVersion = truncate3(
       this.#verifiedAgentVersion.length > 0 ? this.#verifiedAgentVersion : initialized.agentInfo?.version ?? "",
       128
     );
@@ -22774,7 +23147,7 @@ var AcpProcessSession = class _AcpProcessSession {
         );
       const forked = await this.race(
         this.#connection.agent.request(
-          methods2.agent.session.fork,
+          methods3.agent.session.fork,
           {
             sessionId: nativeSessionIdSchema.parse(origin.nativeSessionId),
             cwd: this.#cwd,
@@ -22807,7 +23180,7 @@ var AcpProcessSession = class _AcpProcessSession {
       if (this.#capabilities.resumeSession) {
         lifecycleResponse = await this.race(
           this.#connection.agent.request(
-            methods2.agent.session.resume,
+            methods3.agent.session.resume,
             {
               additionalDirectories: [...this.#additionalDirectories],
               cwd: this.#cwd,
@@ -22824,7 +23197,7 @@ var AcpProcessSession = class _AcpProcessSession {
         try {
           lifecycleResponse = await this.race(
             this.#connection.agent.request(
-              methods2.agent.session.load,
+              methods3.agent.session.load,
               {
                 additionalDirectories: [...this.#additionalDirectories],
                 cwd: this.#cwd,
@@ -22860,7 +23233,7 @@ var AcpProcessSession = class _AcpProcessSession {
       }
       const created = await this.race(
         this.#connection.agent.request(
-          methods2.agent.session.new,
+          methods3.agent.session.new,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -22874,11 +23247,7 @@ var AcpProcessSession = class _AcpProcessSession {
       this.selectNativeSession(created.sessionId);
       lifecycleResponse = created;
     }
-    const lifecycleRecord = isRecord3(lifecycleResponse) ? lifecycleResponse : {};
-    this.#configOptions = normalizeConfigOptions(
-      lifecycleRecord["configOptions"],
-      lifecycleRecord["modes"]
-    );
+    this.#configOptions = this.#sessionConfigProtocol.normalizeLifecycle(lifecycleResponse);
     await this.#updateTail;
     signal.throwIfAborted();
     if (this.#prompted) {
@@ -22903,7 +23272,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     const response = await this.race(
       this.#connection.agent.request(
-        methods2.agent.session.list,
+        methods3.agent.session.list,
         cursor === null ? {} : { cursor },
         { cancellationSignal: signal }
       ),
@@ -22928,7 +23297,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     await this.race(
       this.#connection.agent.request(
-        methods2.agent.session.delete,
+        methods3.agent.session.delete,
         { sessionId: nativeSessionIdSchema.parse(nativeSessionId) },
         { cancellationSignal: signal }
       ),
@@ -22949,64 +23318,50 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     }
     if (existing.type === "select") {
-      if (!existing.values.some((entry) => entry.value === options.value)) {
+      if (existing.values.length < 2) {
         throw new AcpExecutionError(
-          "The requested ACP configuration value is unavailable",
+          "The requested ACP configuration option is unavailable",
           {},
           "invalid_session_configuration"
         );
       }
-      if (existing.category === "mode") {
-        await this.race(
-          this.#connection.agent.request(
-            methods2.agent.session.setMode,
-            { modeId: options.value, sessionId: this.#nativeSessionId },
-            { cancellationSignal: options.signal }
-          ),
-          "ACP agent exited while setting the session mode",
-          options.signal
-        );
-        this.#configOptions = this.#configOptions.map(
-          (option) => option.id === existing.id ? { ...option, currentValue: options.value } : option
-        );
-      } else {
-        const response = await this.race(
-          this.#connection.agent.request(
-            methods2.agent.session.setConfigOption,
-            {
-              configId: existing.id,
-              sessionId: this.#nativeSessionId,
-              value: options.value
-            },
-            { cancellationSignal: options.signal }
-          ),
-          "ACP agent exited while changing session configuration",
-          options.signal
-        );
-        this.#configOptions = replaceConfigOptionsKeepingMode(
-          this.#configOptions,
-          response.configOptions
+      if (!existing.values.some((entry) => entry.value === options.value)) {
+        throw new AcpExecutionError(
+          "The requested ACP configuration value is unavailable",
+          {},
+          "invalid_session_configuration"
         );
       }
-    } else {
-      const response = await this.race(
-        this.#connection.agent.request(
-          methods2.agent.session.setConfigOption,
-          {
-            configId: existing.id,
-            sessionId: this.#nativeSessionId,
-            type: "boolean",
-            value: options.booleanValue
-          },
-          { cancellationSignal: options.signal }
-        ),
-        "ACP agent exited while changing session configuration",
-        options.signal
-      );
-      this.#configOptions = replaceConfigOptionsKeepingMode(
+    }
+    const configRevision = this.#configRevision;
+    try {
+      const configured = await this.#sessionConfigProtocol.configure(
         this.#configOptions,
-        response.configOptions
+        options,
+        this.#nativeSessionId,
+        {
+          request: async (method, params, failureMessage, signal) => await this.race(
+            this.#connection.agent.request(method, params, {
+              cancellationSignal: signal
+            }),
+            failureMessage,
+            signal
+          )
+        }
       );
+      await this.#updateTail;
+      if (this.#configRevision === configRevision) {
+        this.#configOptions = configured;
+      }
+    } catch (error61) {
+      if (error61 instanceof SessionConfigProtocolError) {
+        throw new AcpExecutionError(
+          error61.message,
+          { cause: error61 },
+          error61.code
+        );
+      }
+      throw error61;
     }
     return this.#configOptions;
   };
@@ -23090,7 +23445,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       const response = await this.race(
         this.#connection.agent.request(
-          methods2.agent.session.prompt,
+          methods3.agent.session.prompt,
           { prompt, sessionId: this.#nativeSessionId },
           { cancellationSignal: options.signal }
         ),
@@ -23137,7 +23492,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       await this.cancelPendingInteractions();
       if (this.#turn.running) {
-        await this.#connection.agent.notify(methods2.agent.session.cancel, {
+        await this.#connection.agent.notify(methods3.agent.session.cancel, {
           sessionId: this.#nativeSessionId
         });
       }
@@ -23227,8 +23582,8 @@ var AcpProcessSession = class _AcpProcessSession {
     const interactionId = `permission-${crypto.randomUUID()}`;
     const options = request.options.slice(0, 20).map((option) => ({
       kind: option.kind,
-      name: truncate2(option.name, 255),
-      optionId: truncate2(option.optionId, 255)
+      name: truncate3(option.name, 255),
+      optionId: truncate3(option.optionId, 255)
     }));
     if (options.length === 0) {
       throw new AcpExecutionError(
@@ -23253,9 +23608,9 @@ var AcpProcessSession = class _AcpProcessSession {
         kind: SESSION_PERMISSION_REQUESTED_KIND,
         options,
         sessionId: this.#mobiusSessionId,
-        title: truncate2(request.toolCall.title ?? "Permission required", 500),
-        toolCallId: truncate2(request.toolCall.toolCallId, 255),
-        toolKind: truncate2(request.toolCall.kind ?? "other", 64)
+        title: truncate3(request.toolCall.title ?? "Permission required", 500),
+        toolCallId: truncate3(request.toolCall.toolCallId, 255),
+        toolKind: truncate3(request.toolCall.kind ?? "other", 64)
       });
       return await pending.completion.promise;
     } finally {
@@ -23284,7 +23639,7 @@ var AcpProcessSession = class _AcpProcessSession {
     const schemaValue = Reflect.get(request, "requestedSchema");
     const requestedSchema = request.mode === "form" ? schemaValue : {};
     const elicitationIdValue = Reflect.get(request, "elicitationId");
-    const elicitationId = request.mode === "url" && typeof elicitationIdValue === "string" ? truncate2(elicitationIdValue, 255) : "";
+    const elicitationId = request.mode === "url" && typeof elicitationIdValue === "string" ? truncate3(elicitationIdValue, 255) : "";
     const pending = new PendingElicitation(
       interactionId,
       elicitationId,
@@ -23303,10 +23658,10 @@ var AcpProcessSession = class _AcpProcessSession {
         fields: normalizeElicitationFields(requestedSchema),
         interactionId,
         kind: SESSION_ELICITATION_REQUESTED_KIND,
-        message: truncate2(request.message, 2e3),
+        message: truncate3(request.message, 2e3),
         mode: request.mode,
         sessionId: this.#mobiusSessionId,
-        url: request.mode === "url" && typeof Reflect.get(request, "url") === "string" ? truncate2(readString3(Reflect.get(request, "url")), 4096) : ""
+        url: request.mode === "url" && typeof Reflect.get(request, "url") === "string" ? truncate3(readString4(Reflect.get(request, "url")), 4096) : ""
       });
       return await pending.completion.promise;
     } finally {
@@ -23395,7 +23750,7 @@ var AcpProcessSession = class _AcpProcessSession {
           content: normalizeContentBlock(update.content),
           contentId: `content-${crypto.randomUUID()}`,
           kind: AGENT_CONTENT_KIND,
-          messageId: truncate2(update.messageId ?? "", 255),
+          messageId: truncate3(update.messageId ?? "", 255),
           sessionId: this.#mobiusSessionId
         });
       }
@@ -23433,9 +23788,9 @@ var AcpProcessSession = class _AcpProcessSession {
     }
     if (update.sessionUpdate === "available_commands_update") {
       const commands = update.availableCommands.slice(0, 500).map((command) => ({
-        description: truncate2(command.description, 500),
-        inputHint: truncate2(command.input?.hint ?? "", 255),
-        name: truncate2(command.name, 128)
+        description: truncate3(command.description, 500),
+        inputHint: truncate3(command.input?.hint ?? "", 255),
+        name: truncate3(command.name, 128)
       })).filter((command) => command.name.length > 0);
       this.#commands = commands;
       await this.#getObserver().onCommands({
@@ -23446,10 +23801,11 @@ var AcpProcessSession = class _AcpProcessSession {
       return;
     }
     if (update.sessionUpdate === "config_option_update") {
-      this.#configOptions = replaceConfigOptionsKeepingMode(
+      this.#configOptions = this.#sessionConfigProtocol.normalizeUpdate(
         this.#configOptions,
         update.configOptions
       );
+      this.#configRevision += 1;
       await this.emitConfigUpdate();
       return;
     }
@@ -23457,15 +23813,16 @@ var AcpProcessSession = class _AcpProcessSession {
       this.#configOptions = this.#configOptions.map(
         (option) => option.category === "mode" ? { ...option, currentValue: update.currentModeId } : option
       );
+      this.#configRevision += 1;
       await this.emitConfigUpdate();
       return;
     }
     if (update.sessionUpdate === "session_info_update") {
       if (Object.hasOwn(update, "title")) {
-        this.#sessionTitle = truncate2(update.title ?? "", 500);
+        this.#sessionTitle = truncate3(update.title ?? "", 500);
       }
       if (Object.hasOwn(update, "updatedAt")) {
-        this.#sessionUpdatedAt = truncate2(update.updatedAt ?? "", 128);
+        this.#sessionUpdatedAt = truncate3(update.updatedAt ?? "", 128);
       }
       await this.#getObserver().onInfo({
         kind: SESSION_INFO_UPDATED_KIND,
@@ -23478,7 +23835,7 @@ var AcpProcessSession = class _AcpProcessSession {
     if (update.sessionUpdate === "usage_update") {
       await this.#getObserver().onUsage({
         costAmount: update.cost?.amount ?? 0,
-        costCurrency: truncate2(update.cost?.currency ?? "", 16),
+        costCurrency: truncate3(update.cost?.currency ?? "", 16),
         hasCost: update.cost !== void 0 && update.cost !== null,
         kind: SESSION_USAGE_UPDATED_KIND,
         sessionId: this.#mobiusSessionId,
@@ -23493,7 +23850,7 @@ var AcpProcessSession = class _AcpProcessSession {
     if (this.#capabilities.closeSession && this.#nativeSessionId.length > 0) {
       try {
         await this.#connection.agent.request(
-          methods2.agent.session.close,
+          methods3.agent.session.close,
           { sessionId: this.#nativeSessionId },
           {
             cancellationSignal: AbortSignal.timeout(
@@ -24184,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,
@@ -24211,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 {
@@ -24227,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";
@@ -24237,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 {
@@ -24258,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) {
@@ -24273,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
         )
@@ -24347,7 +24716,7 @@ var ManagedNpmPackageError = class extends Error {
     this.name = "ManagedNpmPackageError";
   }
 };
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
@@ -24371,7 +24740,7 @@ async function readJsonRecord(path2, maximumBytes) {
       const value = JSON.parse(
         await handle.readFile({ encoding: "utf8" })
       );
-      if (!isRecord4(value)) {
+      if (!isRecord5(value)) {
         throw new ManagedNpmPackageError(
           "managed_package_verification_failed",
           "The managed npm package metadata is invalid"
@@ -24397,7 +24766,7 @@ function readBinPath(packageMetadata, executableName) {
   if (typeof bin === "string") {
     return bin;
   }
-  if (isRecord4(bin) && typeof bin[executableName] === "string") {
+  if (isRecord5(bin) && typeof bin[executableName] === "string") {
     return bin[executableName];
   }
   throw new ManagedNpmPackageError(
@@ -24413,7 +24782,7 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
     );
   }
   const packages = lock["packages"];
-  if (!isRecord4(packages)) {
+  if (!isRecord5(packages)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package lockfile is invalid"
@@ -24427,7 +24796,7 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
     if (verifyDependencyClosure && normalizedKey.length > 0) {
       let resolved;
       try {
-        if (!normalizedKey.split("/").includes("node_modules") || !isRecord4(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
+        if (!normalizedKey.split("/").includes("node_modules") || !isRecord5(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
           throw new Error("Invalid locked dependency");
         }
         resolved = new URL(candidate["resolved"]);
@@ -24450,7 +24819,7 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
       matches += 1;
     }
   }
-  if (matches !== 1 || !isRecord4(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
+  if (matches !== 1 || !isRecord5(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package lockfile does not match the pinned artifact"
@@ -24673,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 {
@@ -24779,11 +25147,11 @@ var AgentProbeError = class extends Error {
 
 // src/agent-catalog/agents/verify-session-creation.ts
 import {
-  methods as methods3
+  methods as methods4
 } from "@agentclientprotocol/sdk";
 async function verifySessionCreation(connection, capabilities, defaultWorkspace, signal, label) {
   const session = await connection.agent.request(
-    methods3.agent.session.new,
+    methods4.agent.session.new,
     {
       additionalDirectories: [],
       cwd: defaultWorkspace,
@@ -24799,7 +25167,7 @@ async function verifySessionCreation(connection, capabilities, defaultWorkspace,
   }
   if (capabilities.sessionCapabilities?.close != null) {
     await connection.agent.request(
-      methods3.agent.session.close,
+      methods4.agent.session.close,
       { sessionId: session.sessionId },
       { cancellationSignal: signal }
     );
@@ -24821,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(
@@ -25124,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,
@@ -25141,259 +25508,64 @@ 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 {
+// src/agent-installation/managed-agent-archive.ts
+var ARCHIVE_DOWNLOAD_LIMIT_BYTES = 128 * 1024 * 1024;
+var ARCHIVE_DOWNLOAD_TIMEOUT_MILLISECONDS = 2 * 60 * 1e3;
+var MANIFEST_LIMIT_BYTES = 16 * 1024;
+var ManagedAgentArchiveDefinition = class {
+  archiveName;
+  archiveSha256;
+  archiveUrl;
+  executableName;
+  version;
+  constructor(version2, archiveName, archiveUrl, archiveSha256, executableName) {
+    this.archiveName = archiveName;
+    this.archiveSha256 = archiveSha256;
+    this.archiveUrl = new URL(archiveUrl);
+    this.executableName = executableName;
+    this.version = version2;
+  }
+};
+var ZipManagedAgentArchiveDefinition = class extends ManagedAgentArchiveDefinition {
+  extractor = "/usr/bin/unzip";
+  extractArguments = (archivePath, destination) => ["-q", archivePath, "-d", destination];
+  listArguments = (archivePath) => [
+    "-Z1",
+    archivePath
+  ];
+};
+var TarGzipManagedAgentArchiveDefinition = class extends ManagedAgentArchiveDefinition {
+  extractor = "/usr/bin/tar";
+  extractArguments = (archivePath, destination) => ["-xzf", archivePath, "-C", destination];
+  listArguments = (archivePath) => [
+    "-tzf",
+    archivePath
+  ];
+};
+var ManagedAgentArchiveError = 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;
+    this.name = "ManagedAgentArchiveError";
   }
 };
-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"
-    );
-  }
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-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;
-  archiveUrl;
-  executableName;
-  version;
-  constructor(version2, archiveName, archiveUrl, archiveSha256, executableName) {
-    this.archiveName = archiveName;
-    this.archiveSha256 = archiveSha256;
-    this.archiveUrl = new URL(archiveUrl);
-    this.executableName = executableName;
-    this.version = version2;
-  }
-};
-var ZipManagedAgentArchiveDefinition = class extends ManagedAgentArchiveDefinition {
-  extractor = "/usr/bin/unzip";
-  extractArguments = (archivePath, destination) => ["-q", archivePath, "-d", destination];
-  listArguments = (archivePath) => [
-    "-Z1",
-    archivePath
-  ];
-};
-var TarGzipManagedAgentArchiveDefinition = class extends ManagedAgentArchiveDefinition {
-  extractor = "/usr/bin/tar";
-  extractArguments = (archivePath, destination) => ["-xzf", archivePath, "-C", destination];
-  listArguments = (archivePath) => [
-    "-tzf",
-    archivePath
-  ];
-};
-var ManagedAgentArchiveError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "ManagedAgentArchiveError";
-  }
-};
-var ManagedAgentArchiveDownloader = class {
-  download = async (options) => await downloadVerifiedFile(options);
-};
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isContainedPath3(root, candidate) {
-  const difference = relative3(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute4(difference);
+function isContainedPath3(root, candidate) {
+  const difference = relative3(root, candidate);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute4(difference);
 }
 async function hashFile(path2, signal) {
   signal.throwIfAborted();
-  const digest = createHash2("sha256");
+  const digest = createHash("sha256");
   const stream = createReadStream(path2, { signal });
   try {
     for await (const chunk of stream) {
@@ -25424,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",
@@ -25443,7 +25615,7 @@ async function readManifest(path2) {
     const parsed = JSON.parse(
       await handle.readFile({ encoding: "utf8" })
     );
-    if (!isRecord5(parsed)) {
+    if (!isRecord6(parsed)) {
       throw new ManagedAgentArchiveError(
         "managed_archive_verification_failed",
         "The managed Agent archive manifest is invalid"
@@ -25495,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";
@@ -25730,7 +25764,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 // src/agent-catalog/agents/pi-agent.ts
 import { join as join10 } from "node:path";
 import {
-  methods as methods4
+  methods as methods5
 } from "@agentclientprotocol/sdk";
 
 // src/agent-installation/pi-managed-packages.ts
@@ -25802,7 +25836,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const session = await connection.agent.request(
-      methods4.agent.session.new,
+      methods5.agent.session.new,
       {
         additionalDirectories: [],
         cwd: defaultWorkspace,
@@ -25817,7 +25851,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const prompt = await connection.agent.request(
-      methods4.agent.session.prompt,
+      methods5.agent.session.prompt,
       {
         prompt: [{ text: "/session", type: "text" }],
         sessionId: session.sessionId
@@ -25954,7 +25988,7 @@ function supportedLocalAgentSpecifications() {
 // src/agent-catalog/acp-readiness-probe.ts
 import { spawn as spawn3 } from "node:child_process";
 import {
-  methods as methods5,
+  methods as methods6,
   ndJsonStream as ndJsonStream2,
   PROTOCOL_VERSION as PROTOCOL_VERSION2,
   RequestError as RequestError2
@@ -26135,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;
@@ -26204,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;
     }
   });
 }
@@ -26307,7 +26337,7 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
   try {
     const initialized = await Promise.race([
       connection.agent.request(
-        methods5.agent.initialize,
+        methods6.agent.initialize,
         {
           clientCapabilities: {},
           clientInfo: { name: "mobius", version: "0.0.3" },
@@ -26367,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) {
@@ -26394,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);
   }
@@ -26419,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;
@@ -26450,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(
@@ -26499,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;
         }
@@ -26507,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
@@ -26518,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
@@ -26550,7 +26612,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -26703,9 +26765,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord6(value)) {
+  if (isRecord7(value)) {
     const error61 = value["error"];
-    if (isRecord6(error61)) {
+    if (isRecord7(error61)) {
       const code = error61["code"];
       const message = error61["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -26719,7 +26781,7 @@ function readRelayError(value) {
   );
 }
 function decodeClaimResponse(value) {
-  if (!isRecord6(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+  if (!isRecord7(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
     throw new PairingClientError(
       "invalid_relay_response",
       "The relay returned an invalid pairing response"
@@ -26738,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
   }));
@@ -26747,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"
@@ -26803,7 +26864,7 @@ async function persistConnection(channelId, relayOrigin, daemonToken, defaultWor
   return connectionPath;
 }
 function decodeSavedConnection(value, expectedChannelId) {
-  if (!isRecord6(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+  if (!isRecord7(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
     throw new PairingClientError(
       "invalid_connection",
       "The saved connection is invalid"
@@ -26833,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) {
@@ -26870,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"
     );
   }
 }
@@ -26958,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";
@@ -26991,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" },
@@ -27093,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;
     }
   }
@@ -27105,7 +27165,7 @@ function executionFailure(error61) {
   }
   return new InstallationManagerError(
     "installation_failed",
-    "The local Agent installation failed",
+    "The local Agent integration installation failed",
     { cause: error61 }
   );
 }
@@ -27176,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;
@@ -27213,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 () => {
@@ -27223,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"));
@@ -27245,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);
@@ -27257,898 +27317,87 @@ var AgentInstallationManager = class {
         job.requestId,
         specification.id
       );
-      await this.#executor.execute(
-        specification.id,
-        job.requestId,
-        async (stage) => {
-          signal.throwIfAborted();
-          await this.#transition(
-            job,
-            new RunningInstallation(job.requestId, job.agentId, stage)
-          );
-          this.#audit.record(
-            `agent_installation_${stage}`,
-            job.requestId,
-            job.agentId
-          );
-        },
-        signal
-      );
-      signal.throwIfAborted();
-      const succeeded = new SucceededInstallation(job.requestId, job.agentId);
-      await this.#transition(job, succeeded);
-      this.#audit.record(
-        "agent_installation_completed",
-        job.requestId,
-        job.agentId
-      );
-      job.completion.resolve(succeeded);
-    } catch (error61) {
-      if (signal.aborted) {
-        if (signal.reason instanceof InstallationManagerError && signal.reason.code === "installation_timeout") {
-          const timedOut = new FailedInstallation(
-            job.requestId,
-            job.agentId,
-            signal.reason.code,
-            signal.reason.message
-          );
-          await this.#transition(job, timedOut);
-          this.#audit.record(
-            "agent_installation_failed_installation_timeout",
-            job.requestId,
-            job.agentId
-          );
-          job.completion.resolve(timedOut);
-          return;
-        }
-        const cancelled = new CancelledInstallation(job.requestId, job.agentId);
-        await this.#transition(job, cancelled);
-        this.#audit.record(
-          "agent_installation_cancelled",
-          job.requestId,
-          job.agentId
-        );
-        job.completion.resolve(cancelled);
-      } else {
-        const failure = executionFailure(error61);
-        const failed = new FailedInstallation(
-          job.requestId,
-          job.agentId,
-          failure.code,
-          failure.message
-        );
-        await this.#transition(job, failed);
-        this.#audit.record(
-          `agent_installation_failed_${failure.code}`,
-          job.requestId,
-          job.agentId
-        );
-        job.completion.resolve(failed);
-      }
-    } finally {
-      clearTimeout(deadline);
-      externalSignal.removeEventListener("abort", abort);
-      if (this.#activeAgents.get(job.agentId) === job.requestId) {
-        this.#activeAgents.delete(job.agentId);
-      }
-    }
-  };
-};
-
-// src/agent-installation/automatic-adapter-provisioner.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-var AUTOMATIC_ADAPTER_FAILURE_CODES = /* @__PURE__ */ new Set([
-  "adapter_not_found",
-  "adapter_probe_failed",
-  "adapter_probe_timeout",
-  "acp_incompatible"
-]);
-var InstalledAutomaticAdapter = class {
-  executable;
-  requestId;
-  specification;
-  constructor(specification, requestId, executable) {
-    this.executable = executable;
-    this.requestId = requestId;
-    this.specification = specification;
-  }
-};
-function shouldProvisionAdapter(unavailable, options) {
-  return unavailable.specification instanceof BridgedAcpAgentDefinition && AUTOMATIC_ADAPTER_FAILURE_CODES.has(unavailable.code) && options.environment[unavailable.specification.adapterOverrideVariable] === void 0 && unavailable.specification.supportsInstallation(
-    options.platform ?? process.platform,
-    options.architecture ?? process.arch
-  );
-}
-function stableFailureCode(error61) {
-  return error61 instanceof ManagedAdapterInstallError ? error61.code : "adapter_install_failed";
-}
-function discoveryOptions(options, environment, signal, specifications) {
-  return {
-    ...options.architecture === void 0 ? {} : { architecture: options.architecture },
-    defaultWorkspace: options.defaultWorkspace,
-    environment,
-    ...options.platform === void 0 ? {} : { platform: options.platform },
-    signal,
-    specifications
-  };
-}
-var AutomaticAdapterProvisioner = class {
-  #adapterInstaller;
-  #options;
-  #specifications;
-  constructor(options, adapterInstaller, specifications = supportedLocalAgentSpecifications()) {
-    this.#adapterInstaller = adapterInstaller;
-    this.#options = options;
-    this.#specifications = Object.freeze([...specifications]);
-  }
-  prepare = async (signal) => {
-    signal.throwIfAborted();
-    let inventory = await discoverLocalAgentInventory(
-      discoveryOptions(
-        this.#options,
-        this.#options.environment,
-        signal,
-        this.#specifications
-      )
-    );
-    const candidates = inventory.unavailable.filter(
-      (unavailable) => shouldProvisionAdapter(unavailable, this.#options)
-    );
-    const attempts = [];
-    for (const unavailable of candidates) {
-      signal.throwIfAborted();
-      const specification = unavailable.specification;
-      if (!(specification instanceof BridgedAcpAgentDefinition)) {
-        attempts.push(null);
-        continue;
-      }
-      const verifiedAgent = await findVerifiedAgentExecutable(
-        specification,
-        discoveryOptions(
-          this.#options,
-          this.#options.environment,
-          signal,
-          this.#specifications
-        )
-      );
-      if (verifiedAgent === null) {
-        attempts.push(null);
-        continue;
-      }
-      const requestId = `automatic-adapter-${randomUUID2()}`;
-      this.#options.audit.record(
-        "agent_adapter_auto_install_started",
-        requestId,
-        specification.id,
-        {
-          agentVersion: verifiedAgent.version,
-          adapterVersion: specification.adapterVersion
-        }
-      );
-      process.stdout.write(
-        `Installing the pinned ACP adapter for ${specification.label}.
-`
-      );
-      try {
-        const executable = await this.#adapterInstaller.install(
-          specification,
-          signal
-        );
-        this.#options.audit.record(
-          "agent_adapter_auto_install_completed",
-          requestId,
-          specification.id,
-          { adapterVersion: specification.adapterVersion }
-        );
-        attempts.push(
-          new InstalledAutomaticAdapter(specification, requestId, executable)
-        );
-      } catch (error61) {
-        if (signal.aborted) {
-          this.#options.audit.record(
-            "agent_adapter_auto_install_cancelled",
-            requestId,
-            specification.id
-          );
-          signal.throwIfAborted();
-        }
-        this.#options.audit.record(
-          "agent_adapter_auto_install_failed",
-          requestId,
-          specification.id,
-          { code: stableFailureCode(error61) }
-        );
-        process.stderr.write(
-          `The pinned ACP adapter for ${specification.label} could not be installed automatically; the daemon will continue.
-`
-        );
-        attempts.push(null);
-      }
-    }
-    signal.throwIfAborted();
-    const installed = attempts.filter(
-      (attempt) => attempt !== null
-    );
-    if (installed.length > 0) {
-      const verificationEnvironment = {
-        ...this.#options.environment
-      };
-      for (const attempt of installed) {
-        verificationEnvironment[attempt.specification.adapterOverrideVariable] = attempt.executable.path;
-      }
-      inventory = await discoverLocalAgentInventory(
-        discoveryOptions(
-          this.#options,
-          verificationEnvironment,
-          signal,
-          this.#specifications
-        )
-      );
-    }
-    this.#options.catalog.transition(
-      inventory.readyAgents(),
-      inventory.installable
-    );
-    for (const attempt of installed) {
-      const available = inventory.available.find(
-        (candidate) => candidate instanceof AvailableAgent && candidate.specification.id === attempt.specification.id
-      );
-      if (available === void 0) {
-        const unavailable = inventory.unavailable.find(
-          (candidate) => candidate.specification.id === attempt.specification.id
-        );
-        this.#options.audit.record(
-          "agent_adapter_auto_install_verification_failed",
-          attempt.requestId,
-          attempt.specification.id,
-          { code: unavailable?.code ?? "agent_verification_failed" }
-        );
-        continue;
-      }
-      this.#options.audit.record(
-        "agent_adapter_auto_install_verified",
-        attempt.requestId,
-        attempt.specification.id,
-        {
-          adapterVersion: available.agent.adapterVersion,
-          agentVersion: available.agent.agentVersion
-        }
-      );
-      process.stdout.write(
-        `${attempt.specification.label} ACP integration is ready.
-`
-      );
-    }
-    return inventory;
-  };
-};
-
-// src/agent-installation/fixed-installation-executor.ts
-import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
-
-// src/agent-installation/fixed-agent-install-recipes.ts
-import { mkdir as mkdir5, mkdtemp as mkdtemp3, rm as rm3 } from "node:fs/promises";
-import { join as join17 } from "node:path";
-
-// src/agent-installation/fixed-agent-install-recipe.ts
-var FixedAgentInstallRecipe = class {
-  assertSupportedPlatform = () => {
-    if (process.platform !== "darwin" && process.platform !== "linux" || process.arch !== "arm64" && process.arch !== "x64") {
-      throw new InstallationManagerError(
-        "unsupported_install_platform",
-        "This Agent installation recipe does not support the local platform"
-      );
-    }
-  };
-  requireInstalledExecutable = async (path2) => {
-    const executable = await resolveExecutablePath(path2);
-    if (executable === null) {
-      throw new InstallationManagerError(
-        "agent_verification_failed",
-        "The Agent installer did not produce a valid executable"
-      );
-    }
-    return executable;
-  };
-};
-
-// src/agent-installation/grok-build-install-recipe.ts
-import { mkdir as mkdir4, realpath as realpath7, stat as stat6 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname5, isAbsolute as isAbsolute7, join as join15, relative as relative4, sep as sep4 } from "node:path";
-var INSTALL_TIMEOUT_MILLISECONDS2 = 5 * 60 * 1e3;
-function isContainedPath4(root, candidate) {
-  const difference = relative4(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep4}`) && !isAbsolute7(difference);
-}
-async function resolveLifecycleScript(packageRoot) {
-  try {
-    const canonicalPackageRoot = await realpath7(packageRoot);
-    const script = await realpath7(
-      join15(canonicalPackageRoot, "bin", "postinstall.js")
-    );
-    const metadata = await stat6(script);
-    if (!metadata.isFile() || !isContainedPath4(canonicalPackageRoot, script)) {
-      throw new Error("Invalid Grok Build lifecycle script");
-    }
-    return script;
-  } catch (error61) {
-    throw new InstallationManagerError(
-      "agent_verification_failed",
-      "The managed Grok Build lifecycle script is invalid",
-      { cause: error61 }
-    );
-  }
-}
-var GrokBuildInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "grok-build";
-  label = "Grok Build";
-  releaseChannel = GROK_BUILD_MANAGED_VERSION;
-  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
-    super();
-    this.#npmInstaller = npmInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    const definition = grokBuildManagedPackage(process.platform, process.arch);
-    const versionRoot = join15(
-      options.stateDirectory,
-      "agents",
-      this.id,
-      GROK_BUILD_MANAGED_VERSION
-    );
-    const packageRoot = join15(versionRoot, "package");
-    const managedHome = join15(versionRoot, "home");
-    try {
-      await mkdir4(managedHome, { mode: 448, recursive: true });
-      const canonicalHome = await realpath7(managedHome);
-      await options.report("downloading");
-      await options.report("verifying");
-      await options.report("installing_agent");
-      await this.#npmInstaller.install(
-        packageRoot,
-        definition,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: definition.integrity,
-          package: definition.packageName,
-          version: definition.version
-        }
-      );
-      const script = await resolveLifecycleScript(
-        join15(packageRoot, "node_modules", "@xai-official", "grok")
-      );
-      await runBoundedProcess({
-        arguments: [script],
-        command: process.execPath,
-        cwd: dirname5(script),
-        environment: {
-          GROK_HOME: canonicalHome,
-          GROK_INSTALL_COMPLETIONS: "0",
-          GROK_NPM_REGISTRY: "https://registry.npmjs.org/",
-          HOME: canonicalHome,
-          PATH: `${dirname5(process.execPath)}${delimiter2}/usr/bin${delimiter2}/bin`
-        },
-        outputLimitBytes: 64 * 1024,
-        signal: options.signal,
-        timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS2
-      });
-      options.audit.record(
-        "agent_lifecycle_step_completed",
-        options.requestId,
-        this.id,
-        {
-          lifecycle: "postinstall",
-          package: definition.packageName,
-          version: definition.version
-        }
-      );
-      return await this.requireInstalledExecutable(
-        join15(canonicalHome, "bin", "grok")
-      );
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedNpmPackageError) {
-        if (error61.code === "managed_package_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed Grok Build packages did not match their pinned artifacts",
-            { cause: error61 }
-          );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed Grok Build package could not be published",
-            { cause: error61 }
-          );
-        }
-        throw new InstallationManagerError(error61.code, error61.message, {
-          cause: error61
-        });
-      }
-      if (error61 instanceof InstallationManagerError) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed Grok Build installation recipe failed",
-        { cause: error61 }
-      );
-    }
-  };
-};
-
-// src/agent-installation/workbuddy-install-recipe.ts
-import { join as join16 } from "node:path";
-var WorkBuddyInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "workbuddy";
-  label = "WorkBuddy";
-  releaseChannel = WORKBUDDY_MANAGED_VERSION;
-  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
-    super();
-    this.#npmInstaller = npmInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    try {
-      await options.report("downloading");
-      await options.report("verifying");
-      await options.report("installing_agent");
-      const executable = await this.#npmInstaller.install(
-        join16(
-          options.stateDirectory,
-          "agents",
-          this.id,
-          WORKBUDDY_MANAGED_VERSION
-        ),
-        WORKBUDDY_MANAGED_PACKAGE,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: WORKBUDDY_MANAGED_PACKAGE.integrity,
-          package: WORKBUDDY_MANAGED_PACKAGE.packageName,
-          version: WORKBUDDY_MANAGED_PACKAGE.version
-        }
-      );
-      return executable;
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedNpmPackageError) {
-        if (error61.code === "managed_package_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed WorkBuddy package did not match its pinned artifact",
-            { cause: error61 }
-          );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed WorkBuddy package could not be published",
-            { cause: error61 }
-          );
-        }
-        throw new InstallationManagerError(error61.code, error61.message, {
-          cause: error61
-        });
-      }
-      if (error61 instanceof InstallationManagerError) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed WorkBuddy installation recipe failed",
-        { cause: error61 }
-      );
-    }
-  };
-};
-
-// src/agent-installation/fixed-agent-install-recipes.ts
-var INSTALLER_DOWNLOAD_LIMIT_BYTES = 1024 * 1024;
-var INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS = 6e4;
-var AGENT_INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
-var MINIMAL_PATH2 = "/usr/bin:/bin";
-var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
-  id = "codex";
-  label = "Codex";
-  releaseChannel = "latest";
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    const root = join17(options.stateDirectory, "agents", this.id);
-    const temporaryRoot = join17(options.stateDirectory, "temporary");
-    await Promise.all([
-      mkdir5(root, { mode: 448, recursive: true }),
-      mkdir5(temporaryRoot, { mode: 448, recursive: true })
-    ]);
-    const temporaryDirectory = await mkdtemp3(
-      join17(temporaryRoot, ".codex-install-")
-    );
-    const installerPath = join17(temporaryDirectory, "install.sh");
-    const installDirectory = join17(root, "bin");
-    const codexHome = join17(root, "home");
-    try {
-      await Promise.all([
-        mkdir5(installDirectory, { mode: 448, recursive: true }),
-        mkdir5(codexHome, { mode: 448, recursive: true })
-      ]);
-      await options.report("downloading");
-      const download = await downloadVerifiedFile({
-        allowedHosts: /* @__PURE__ */ new Set(["chatgpt.com", "releases.openai.com"]),
-        destination: installerPath,
-        maximumBytes: INSTALLER_DOWNLOAD_LIMIT_BYTES,
-        signal: options.signal,
-        timeoutMilliseconds: INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS,
-        url: new URL("https://chatgpt.com/codex/install.sh")
-      });
-      options.audit.record(
-        "agent_installer_download_verified",
-        options.requestId,
-        this.id,
-        {
-          bytes: download.bytes.toString(),
-          releaseChannel: this.releaseChannel,
-          sha256: download.sha256
-        }
-      );
-      await options.report("verifying");
-      await options.report("installing_agent");
-      await runBoundedProcess({
-        arguments: [installerPath],
-        command: "/bin/sh",
-        cwd: temporaryDirectory,
-        environment: {
-          CODEX_HOME: codexHome,
-          CODEX_INSTALL_DIR: installDirectory,
-          CODEX_NON_INTERACTIVE: "1",
-          CODEX_RELEASE: this.releaseChannel,
-          HOME: codexHome,
-          PATH: MINIMAL_PATH2
-        },
-        outputLimitBytes: 64 * 1024,
-        signal: options.signal,
-        timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
-      });
-      return await this.requireInstalledExecutable(
-        join17(installDirectory, "codex")
-      );
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof InstallationManagerError || error61 instanceof Error && "code" in error61) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed Codex installation recipe failed"
-      );
-    } finally {
-      await rm3(temporaryDirectory, { force: true, recursive: true });
-    }
-  };
-};
-var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
-  id = "claude";
-  label = "Claude Code";
-  releaseChannel = "stable";
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    const root = join17(options.stateDirectory, "agents", this.id);
-    const managedHome = join17(root, "home");
-    const temporaryRoot = join17(options.stateDirectory, "temporary");
-    await Promise.all([
-      mkdir5(managedHome, { mode: 448, recursive: true }),
-      mkdir5(temporaryRoot, { mode: 448, recursive: true })
-    ]);
-    const temporaryDirectory = await mkdtemp3(
-      join17(temporaryRoot, ".claude-install-")
-    );
-    const installerPath = join17(temporaryDirectory, "install.sh");
-    try {
-      await options.report("downloading");
-      const download = await downloadVerifiedFile({
-        allowedHosts: /* @__PURE__ */ new Set(["claude.ai"]),
-        destination: installerPath,
-        maximumBytes: INSTALLER_DOWNLOAD_LIMIT_BYTES,
-        signal: options.signal,
-        timeoutMilliseconds: INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS,
-        url: new URL("https://claude.ai/install.sh")
-      });
-      options.audit.record(
-        "agent_installer_download_verified",
-        options.requestId,
-        this.id,
-        {
-          bytes: download.bytes.toString(),
-          releaseChannel: this.releaseChannel,
-          sha256: download.sha256
-        }
-      );
-      await options.report("verifying");
-      await options.report("installing_agent");
-      await runBoundedProcess({
-        arguments: [installerPath, "stable"],
-        command: "/bin/bash",
-        cwd: temporaryDirectory,
-        environment: {
-          HOME: managedHome,
-          PATH: MINIMAL_PATH2,
-          SHELL: "/bin/bash"
-        },
-        outputLimitBytes: 64 * 1024,
-        signal: options.signal,
-        timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
-      });
-      return await this.requireInstalledExecutable(
-        join17(managedHome, ".local", "bin", "claude")
-      );
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof InstallationManagerError || error61 instanceof Error && "code" in error61) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed Claude Code installation recipe failed"
-      );
-    } finally {
-      await rm3(temporaryDirectory, { force: true, recursive: true });
-    }
-  };
-};
-var PiInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "pi";
-  label = "Pi";
-  releaseChannel = PI_AGENT_PACKAGE.version;
-  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
-    super();
-    this.#npmInstaller = npmInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    try {
-      await options.report("downloading");
-      await options.report("verifying");
-      await options.report("installing_agent");
-      const executable = await this.#npmInstaller.install(
-        join17(
-          options.stateDirectory,
-          "agents",
-          this.id,
-          PI_AGENT_PACKAGE.version
-        ),
-        PI_AGENT_PACKAGE,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: PI_AGENT_PACKAGE.integrity,
-          package: PI_AGENT_PACKAGE.packageName,
-          version: PI_AGENT_PACKAGE.version
-        }
-      );
-      return executable;
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedNpmPackageError) {
-        if (error61.code === "managed_package_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed Pi package did not match its pinned artifact",
-            { cause: error61 }
-          );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed Pi package could not be published",
-            { cause: error61 }
-          );
-        }
-        throw new InstallationManagerError(error61.code, error61.message, {
-          cause: error61
-        });
-      }
-      if (error61 instanceof InstallationManagerError) {
-        throw error61;
-      }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed Pi installation recipe failed",
-        { cause: error61 }
-      );
-    }
-  };
-};
-var DeepSeekHarnessInstallRecipe = class extends FixedAgentInstallRecipe {
-  #npmInstaller;
-  id = "deepseek-harness";
-  label = "DeepSeek Harness";
-  releaseChannel = DEEPSEEK_HARNESS_PACKAGE.version;
-  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
-    super();
-    this.#npmInstaller = npmInstaller;
-  }
-  install = async (options) => {
-    this.assertSupportedPlatform();
-    try {
-      const managedHome = join17(
-        options.stateDirectory,
-        "agents",
-        this.id,
-        "home"
-      );
-      await mkdir5(managedHome, { mode: 448, recursive: true });
-      await options.report("downloading");
-      await options.report("verifying");
-      await options.report("installing_agent");
-      const executable = await this.#npmInstaller.install(
-        join17(
-          options.stateDirectory,
-          "agents",
-          this.id,
-          DEEPSEEK_HARNESS_PACKAGE.version
-        ),
-        DEEPSEEK_HARNESS_PACKAGE,
-        options.environment,
-        options.signal
-      );
-      options.audit.record(
-        "agent_npm_package_verified",
-        options.requestId,
-        this.id,
-        {
-          integrity: DEEPSEEK_HARNESS_PACKAGE.integrity,
-          package: DEEPSEEK_HARNESS_PACKAGE.packageName,
-          version: DEEPSEEK_HARNESS_PACKAGE.version
-        }
-      );
-      return executable;
-    } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedNpmPackageError) {
-        if (error61.code === "managed_package_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed DeepSeek Harness package did not match its pinned artifact",
-            { cause: error61 }
+      await this.#executor.execute(
+        specification.id,
+        job.requestId,
+        async (stage) => {
+          signal.throwIfAborted();
+          await this.#transition(
+            job,
+            new RunningInstallation(job.requestId, job.agentId, stage)
           );
-        }
-        if (error61.code === "managed_package_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed DeepSeek Harness package could not be published",
-            { cause: error61 }
+          this.#audit.record(
+            `agent_installation_${stage}`,
+            job.requestId,
+            job.agentId
           );
-        }
-        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
+        },
+        signal
       );
-      options.audit.record(
-        "agent_archive_verified",
-        options.requestId,
-        this.id,
-        {
-          sha256: definition.archiveSha256,
-          version: definition.version
-        }
+      signal.throwIfAborted();
+      const succeeded = new SucceededInstallation(job.requestId, job.agentId);
+      await this.#transition(job, succeeded);
+      this.#audit.record(
+        "agent_installation_completed",
+        job.requestId,
+        job.agentId
       );
-      return executable;
+      job.completion.resolve(succeeded);
     } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedAgentArchiveError) {
-        if (error61.code === "managed_archive_verification_failed") {
-          throw new InstallationManagerError(
-            "agent_verification_failed",
-            "The managed OpenCode archive did not match its pinned artifact",
-            { cause: error61 }
+      if (signal.aborted) {
+        if (signal.reason instanceof InstallationManagerError && signal.reason.code === "installation_timeout") {
+          const timedOut = new FailedInstallation(
+            job.requestId,
+            job.agentId,
+            signal.reason.code,
+            signal.reason.message
           );
-        }
-        if (error61.code === "managed_archive_publish_failed") {
-          throw new InstallationManagerError(
-            "agent_publish_failed",
-            "The managed OpenCode archive could not be published",
-            { cause: error61 }
+          await this.#transition(job, timedOut);
+          this.#audit.record(
+            "agent_installation_failed_installation_timeout",
+            job.requestId,
+            job.agentId
           );
+          job.completion.resolve(timedOut);
+          return;
         }
-        throw new InstallationManagerError(error61.code, error61.message, {
-          cause: error61
-        });
+        const cancelled = new CancelledInstallation(job.requestId, job.agentId);
+        await this.#transition(job, cancelled);
+        this.#audit.record(
+          "agent_installation_cancelled",
+          job.requestId,
+          job.agentId
+        );
+        job.completion.resolve(cancelled);
+      } else {
+        const failure = executionFailure(error61);
+        const failed = new FailedInstallation(
+          job.requestId,
+          job.agentId,
+          failure.code,
+          failure.message
+        );
+        await this.#transition(job, failed);
+        this.#audit.record(
+          `agent_installation_failed_${failure.code}`,
+          job.requestId,
+          job.agentId
+        );
+        job.completion.resolve(failed);
       }
-      if (error61 instanceof InstallationManagerError) {
-        throw error61;
+    } finally {
+      clearTimeout(deadline);
+      externalSignal.removeEventListener("abort", abort);
+      if (this.#activeAgents.get(job.agentId) === job.requestId) {
+        this.#activeAgents.delete(job.agentId);
       }
-      throw new InstallationManagerError(
-        "agent_install_failed",
-        "The fixed OpenCode installation recipe failed",
-        { cause: error61 }
-      );
     }
   };
 };
-function fixedAgentInstallRecipes() {
-  return Object.freeze([
-    new CodexInstallRecipe(),
-    new ClaudeCodeInstallRecipe(),
-    new PiInstallRecipe(),
-    new DeepSeekHarnessInstallRecipe(),
-    new OpenCodeInstallRecipe(),
-    new GrokBuildInstallRecipe(),
-    new WorkBuddyInstallRecipe()
-  ]);
-}
 
 // src/agent-installation/fixed-installation-executor.ts
+import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 function findSpecification(specifications, agentId) {
   for (const specification of specifications) {
     if (specification.id === agentId) {
@@ -28160,17 +27409,6 @@ function findSpecification(specifications, agentId) {
     "The requested Agent is not supported"
   );
 }
-function findRecipe(recipes, agentId) {
-  for (const recipe of recipes) {
-    if (recipe.id === agentId) {
-      return recipe;
-    }
-  }
-  throw new InstallationManagerError(
-    "agent_not_installable",
-    "The requested Agent does not have an approved installation recipe"
-  );
-}
 function resolveDefaultWorkspace2(path2) {
   try {
     const directory = realpathSync2(resolve4(path2));
@@ -28186,7 +27424,7 @@ function resolveDefaultWorkspace2(path2) {
     );
   }
 }
-function resolveUserInstallationDirectory(path2) {
+function resolveIntegrationStateDirectory(path2) {
   try {
     const directory = realpathSync2(resolve4(path2));
     const metadata = statSync2(directory);
@@ -28197,7 +27435,7 @@ function resolveUserInstallationDirectory(path2) {
   } catch (error61) {
     throw new InstallationManagerError(
       "unsafe_installation_root",
-      "The local Agent installation root is unavailable or unsafe",
+      "The local integration state directory is unavailable or unsafe",
       { cause: error61 }
     );
   }
@@ -28206,20 +27444,17 @@ function translateExecutionError(error61) {
   if (error61 instanceof InstallationManagerError) {
     return error61;
   }
-  if (error61 instanceof ManagedAdapterInstallError || error61 instanceof InstallerDownloadError || error61 instanceof ProcessExecutionError) {
+  if (error61 instanceof ManagedAdapterInstallError) {
     return new InstallationManagerError(error61.code, error61.message, {
       cause: error61
     });
   }
   return new InstallationManagerError(
     "installation_failed",
-    "The fixed local Agent installation failed",
+    "The local Agent integration installation failed",
     { cause: error61 }
   );
 }
-function requiresAgentReplacement(code) {
-  return code === "agent_not_found" || code === "agent_probe_failed" || code === "agent_probe_timeout";
-}
 function requiresAdapterReplacement(code) {
   return code === "adapter_not_found" || code === "adapter_probe_failed" || code === "adapter_probe_timeout" || code === "acp_incompatible";
 }
@@ -28230,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;
@@ -28243,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
@@ -28254,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)) {
@@ -28291,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;
@@ -28301,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,
@@ -28310,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(
@@ -28322,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
@@ -28331,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(
@@ -28347,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;
@@ -28356,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
@@ -28386,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;
@@ -28444,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"
         );
@@ -28472,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);
@@ -28501,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();
@@ -28509,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),
@@ -28533,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";
@@ -28847,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,
@@ -28872,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,
@@ -29192,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 {
@@ -29283,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(
@@ -29302,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)) {
@@ -29317,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 (
@@ -29471,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 {
@@ -29668,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 {
@@ -29682,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) {
@@ -29701,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,
@@ -29815,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,
@@ -29842,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,
@@ -29875,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,
@@ -29901,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,
@@ -29916,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,
@@ -29932,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,
@@ -29951,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,
@@ -29977,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,
@@ -29996,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,
@@ -30025,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),
@@ -30072,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;
@@ -30106,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) {
@@ -30329,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,
@@ -30343,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,
@@ -30393,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;
           }
@@ -30419,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,
@@ -30439,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) {
@@ -30450,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();
       }
@@ -30473,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(
@@ -30545,6 +29883,9 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
           installationObserver,
           nativeSessions,
           outbox,
+          publisher,
+          activeTurns,
+          activeAttemptIds,
           announceConnection,
           signal,
           timer
@@ -30562,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 {