@moxt-ai/mobius 0.0.10 → 0.0.12

package/dist/cli.js

@@ -6,100 +6,24 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { mkdir as mkdir4 } from "node:fs/promises";
+import { mkdir as mkdir5 } from "node:fs/promises";
 
-// src/agent-catalog/discover-local-agents.ts
-import { spawn as spawn2 } from "node:child_process";
-import { isAbsolute as isAbsolute2, join as join6 } from "node:path";
-import {
-  methods as methods2,
-  ndJsonStream,
-  PROTOCOL_VERSION,
-  RequestError
-} from "@agentclientprotocol/sdk";
-
-// src/acp/create-client.ts
-import {
-  client,
-  methods
-} from "@agentclientprotocol/sdk";
-var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
-  methods.client.session.requestPermission,
-  async (context) => await handler.onPermission(context.params, context.signal)
-).onRequest(
-  methods.client.elicitation.create,
-  async (context) => await handler.onElicitation(context.params, context.signal)
-).onNotification(methods.client.session.update, async (context) => {
-  await handler.onUpdate(context.params);
-}).onNotification(methods.client.elicitation.complete, async (context) => {
-  await handler.onElicitationComplete(context.params);
-});
-
-// src/agent-installation/installation-grants.ts
-import { open } from "node:fs/promises";
-import { join } from "node:path";
-var MAX_GRANT_FILE_LENGTH = 16 * 1024;
-var AGENT_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function readGrantedAgents(stateDirectory) {
-  const path2 = join(stateDirectory, "installation-grants.json");
-  let handle;
-  try {
-    handle = await open(path2, "r");
-  } catch (error61) {
-    if (error61 instanceof Error && "code" in error61 && error61.code === "ENOENT") {
-      return /* @__PURE__ */ new Set();
-    }
-    throw error61;
-  }
-  try {
-    const metadata = await handle.stat();
-    if (!metadata.isFile() || metadata.size > MAX_GRANT_FILE_LENGTH || typeof process.getuid === "function" && metadata.uid !== process.getuid() || process.platform !== "win32" && (metadata.mode & 63) !== 0) {
-      throw new Error("The local installation grant file is not private");
-    }
-    const encoded = await handle.readFile({ encoding: "utf8" });
-    const value = JSON.parse(encoded);
-    if (!isRecord(value) || Object.keys(value).length !== 1 || !Array.isArray(value["agents"])) {
-      throw new Error("The local installation grant file is invalid");
-    }
-    const agents = /* @__PURE__ */ new Set();
-    for (const candidate of value["agents"]) {
-      if (typeof candidate !== "string" || !AGENT_ID_PATTERN.test(candidate) || agents.has(candidate)) {
-        throw new Error("The local installation grant file is invalid");
-      }
-      agents.add(candidate);
-    }
-    return agents;
-  } finally {
-    await handle.close();
-  }
-}
-
-// src/agent-installation/managed-adapter-installer.ts
-import { join as join4 } from "node:path";
-
-// src/agent-installation/managed-npm-package.ts
-import {
-  mkdir,
-  mkdtemp,
-  open as open2,
-  realpath as realpath2,
-  rename,
-  rm,
-  stat as stat2
-} from "node:fs/promises";
-import { delimiter, dirname, isAbsolute, join as join3, relative, sep } from "node:path";
+// src/agent-catalog/local-agent.ts
+import { realpathSync, statSync } from "node:fs";
 
 // src/process/executable.ts
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access, realpath, stat } from "node:fs/promises";
-import { join as join2, resolve } from "node:path";
+import { join, resolve } from "node:path";
 var DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024;
 var PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS = 1e3;
 var PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS = 5e3;
+var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
+var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
+var PROCESS_EXIT_CHECK_ATTEMPTS = 8;
+var GRACEFUL_STOP_SIGNAL = 15;
+var FORCED_STOP_SIGNAL = 9;
 var ExecutableIdentity = class {
   changedAtMilliseconds;
   device;
@@ -193,7 +117,7 @@ async function findExecutableOnPath(executableName, environment, platform = proc
     }
     for (const extension of extensions) {
       const requestedPath = resolve(
-        join2(entry, `${executableName}${extension}`)
+        join(entry, `${executableName}${extension}`)
       );
       const executable = await resolveExecutablePath(requestedPath, platform);
       if (executable !== null) {
@@ -218,6 +142,119 @@ function appendBounded(chunks, chunk, currentBytes, limitBytes) {
   chunks.push(chunk);
   return nextBytes;
 }
+function parseProcessTable(output2) {
+  const entries = [];
+  for (const line of output2.split("\n")) {
+    const groups = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<pgid>\d+)\s*$/.exec(
+      line
+    )?.groups;
+    if (groups === void 0) {
+      continue;
+    }
+    const processId = Number(groups["pid"]);
+    const parentProcessId = Number(groups["ppid"]);
+    const processGroupId = Number(groups["pgid"]);
+    if (!Number.isSafeInteger(processId) || processId <= 0 || !Number.isSafeInteger(parentProcessId) || parentProcessId < 0 || !Number.isSafeInteger(processGroupId) || processGroupId <= 0) {
+      continue;
+    }
+    entries.push({ parentProcessId, processGroupId, processId });
+  }
+  return entries;
+}
+function readProcessTable() {
+  if (process.platform === "win32") {
+    return Promise.resolve([]);
+  }
+  const executable = process.platform === "darwin" ? "/bin/ps" : "/usr/bin/ps";
+  return new Promise((resolveTable) => {
+    execFile(
+      executable,
+      ["-axo", "pid=,ppid=,pgid="],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT_BYTES,
+        signal: AbortSignal.timeout(PROCESS_TABLE_TIMEOUT_MILLISECONDS),
+        timeout: PROCESS_TABLE_TIMEOUT_MILLISECONDS
+      },
+      (error61, stdout) => {
+        resolveTable(error61 === null ? parseProcessTable(stdout) : []);
+      }
+    );
+  });
+}
+function selectProcessTree(entries, rootProcessId) {
+  const processIds = /* @__PURE__ */ new Set([rootProcessId]);
+  let previousSize = 0;
+  while (previousSize !== processIds.size) {
+    previousSize = processIds.size;
+    for (const entry of entries) {
+      if (processIds.has(entry.parentProcessId)) {
+        processIds.add(entry.processId);
+      }
+    }
+  }
+  return entries.filter((entry) => processIds.has(entry.processId)).map((entry) => ({
+    processGroupId: entry.processGroupId,
+    processId: entry.processId
+  }));
+}
+function mergeProcessTrees(captured, current) {
+  const processes = /* @__PURE__ */ new Map();
+  for (const identity2 of captured) {
+    processes.set(identity2.processId, identity2);
+  }
+  for (const identity2 of current) {
+    processes.set(identity2.processId, identity2);
+  }
+  return [...processes.values()];
+}
+async function captureProcessTree(child) {
+  if (process.platform === "win32" || child.pid === void 0) {
+    return [];
+  }
+  return selectProcessTree(await readProcessTable(), child.pid);
+}
+function signalDetachedProcessGroups(processes, rootProcessId, signal) {
+  const processIds = new Set(processes.map((identity2) => identity2.processId));
+  const signalledGroups = /* @__PURE__ */ new Set();
+  for (const identity2 of processes) {
+    if (identity2.processGroupId === rootProcessId || !processIds.has(identity2.processGroupId) || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(-identity2.processGroupId, signal);
+      signalledGroups.add(identity2.processGroupId);
+    } catch {
+    }
+  }
+  for (const identity2 of processes) {
+    if (identity2.processId === rootProcessId || identity2.processGroupId === rootProcessId || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(identity2.processId, signal);
+    } catch {
+    }
+  }
+}
+function processExists(processId) {
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForCapturedProcessesExit(processes, rootProcessId) {
+  const processIds = processes.map((identity2) => identity2.processId).filter((processId) => processId !== rootProcessId);
+  for (let attempt = 0; attempt < PROCESS_EXIT_CHECK_ATTEMPTS; attempt += 1) {
+    if (processIds.every((processId) => !processExists(processId))) {
+      return true;
+    }
+    await readProcessTable();
+  }
+  return processIds.every((processId) => !processExists(processId));
+}
 function terminateProcess(child) {
   if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
     return;
@@ -244,24 +281,35 @@ function forceTerminateProcess(child) {
   }
   child.kill("SIGKILL");
 }
-async function stopProcessTree(child) {
-  if (child.exitCode !== null || child.signalCode !== null) {
+async function stopProcessTree(child, capturedProcesses = []) {
+  const childProcessId = child.pid;
+  if (childProcessId === void 0) {
     return;
   }
-  terminateProcess(child);
-  const exitedAfterTermination = await waitForProcessExit(
-    child,
-    PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS
+  const childExited = child.exitCode !== null || child.signalCode !== null;
+  if (childExited && capturedProcesses.length === 0) {
+    return;
+  }
+  const processes = mergeProcessTrees(
+    capturedProcesses,
+    childExited ? [] : await captureProcessTree(child)
   );
-  if (exitedAfterTermination) {
+  signalDetachedProcessGroups(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
+  terminateProcess(child);
+  const [exitedAfterTermination, descendantsExitedAfterTermination] = await Promise.all([
+    waitForProcessExit(child, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
+    waitForCapturedProcessesExit(processes, childProcessId)
+  ]);
+  if (exitedAfterTermination && descendantsExitedAfterTermination) {
     return;
   }
+  signalDetachedProcessGroups(processes, childProcessId, FORCED_STOP_SIGNAL);
   forceTerminateProcess(child);
-  const exitedAfterForce = await waitForProcessExit(
-    child,
-    PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS
-  );
-  if (!exitedAfterForce) {
+  const [exitedAfterForce, descendantsExitedAfterForce] = await Promise.all([
+    waitForProcessExit(child, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
+    waitForCapturedProcessesExit(processes, childProcessId)
+  ]);
+  if (!exitedAfterForce || !descendantsExitedAfterForce) {
     throw new ProcessExecutionError(
       "process_termination_timeout",
       "The executable process could not be stopped"
@@ -428,590 +476,1533 @@ async function runBoundedProcess(options) {
   }
 }
 
-// src/agent-installation/managed-npm-package.ts
-var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
-var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
-var PACKAGE_LOCK_LIMIT_BYTES = 8 * 1024 * 1024;
-var ManagedNpmPackageDefinition = class {
-  executableName;
-  packageName;
-  version;
-  constructor(packageName, version2, executableName) {
-    this.executableName = executableName;
-    this.packageName = packageName;
-    this.version = version2;
+// src/agent-catalog/local-agent.ts
+function readTrustedIdentity(path2) {
+  const resolvedPath = realpathSync(path2);
+  const metadata = statSync(resolvedPath);
+  return new ExecutableIdentity(
+    resolvedPath,
+    resolvedPath,
+    metadata.dev,
+    metadata.ino,
+    metadata.size,
+    metadata.ctimeMs
+  );
+}
+var LocalAgentDefinition = class {
+  adapterIdentity;
+  adapterPath;
+  adapterVersion;
+  agentIdentity;
+  agentVersion;
+  arguments;
+  command;
+  environment;
+  id;
+  label;
+  promptTimeoutMilliseconds;
+  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity, promptTimeoutMilliseconds = 30 * 60 * 1e3) {
+    if (!Number.isSafeInteger(promptTimeoutMilliseconds) || promptTimeoutMilliseconds < 1) {
+      throw new Error("The local Agent prompt deadline is invalid");
+    }
+    this.adapterIdentity = adapterIdentity;
+    this.adapterPath = adapterIdentity.realPath;
+    this.adapterVersion = adapterVersion;
+    this.agentIdentity = agentIdentity;
+    this.agentVersion = agentVersion;
+    this.id = id;
+    this.label = label;
+    this.promptTimeoutMilliseconds = promptTimeoutMilliseconds;
+    this.command = adapterIdentity.realPath;
+    this.arguments = Object.freeze([...arguments_]);
+    this.environment = Object.freeze({ ...environment });
   }
 };
-var SriManagedNpmPackageDefinition = class extends ManagedNpmPackageDefinition {
-  integrity;
-  tarballUrl;
-  constructor(packageName, version2, executableName, integrity, tarballUrl) {
-    super(packageName, version2, executableName);
-    this.integrity = integrity;
-    this.tarballUrl = tarballUrl;
+var InstallableAgentDefinition = class {
+  id;
+  label;
+  requiresLocalApproval;
+  constructor(id, label, requiresLocalApproval = true) {
+    this.id = id;
+    this.label = label;
+    this.requiresLocalApproval = requiresLocalApproval;
   }
 };
-var ManagedNpmPackageError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "ManagedNpmPackageError";
+var LocalAgentCatalogSnapshot = class {
+  agents;
+  installableAgents;
+  constructor(agents, installableAgents) {
+    this.agents = Object.freeze([...agents]);
+    this.installableAgents = Object.freeze([...installableAgents]);
   }
 };
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function packagePath(root, packageName) {
-  return join3(root, "node_modules", ...packageName.split("/"));
-}
-function isContainedPath(root, candidate) {
-  const difference = relative(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep}`) && !isAbsolute(difference);
-}
-async function readJsonRecord(path2, maximumBytes) {
-  try {
-    const handle = await open2(path2, "r");
-    try {
-      const metadata = await handle.stat();
-      if (!metadata.isFile() || metadata.size > maximumBytes) {
-        throw new ManagedNpmPackageError(
-          "managed_package_verification_failed",
-          "The managed npm package metadata is invalid"
-        );
-      }
-      const value = JSON.parse(
-        await handle.readFile({ encoding: "utf8" })
-      );
-      if (!isRecord2(value)) {
-        throw new ManagedNpmPackageError(
-          "managed_package_verification_failed",
-          "The managed npm package metadata is invalid"
-        );
+var LocalAgentCatalogError = class extends Error {
+  code = "agent_not_ready";
+  constructor() {
+    super("The requested local Agent is not ready");
+    this.name = "LocalAgentCatalogError";
+  }
+};
+var LocalAgentCatalog = class {
+  #snapshot;
+  constructor(agents, installableAgents) {
+    this.#snapshot = this.validate(agents, installableAgents);
+  }
+  find = (agentId) => {
+    for (const agent of this.#snapshot.agents) {
+      if (agent.id === agentId) {
+        return agent;
       }
-      return value;
-    } finally {
-      await handle.close();
     }
+    throw new LocalAgentCatalogError();
+  };
+  read = () => this.#snapshot;
+  transition = (agents, installableAgents) => {
+    const next = this.validate(agents, installableAgents);
+    this.#snapshot = next;
+    return next;
+  };
+  validate = (agents, installableAgents) => {
+    const identifiers = /* @__PURE__ */ new Set();
+    for (const agent of agents) {
+      if (identifiers.has(agent.id)) {
+        throw new Error("The local Agent catalog contains duplicate entries");
+      }
+      identifiers.add(agent.id);
+    }
+    for (const agent of installableAgents) {
+      if (identifiers.has(agent.id)) {
+        throw new Error("A local Agent cannot be ready and installable");
+      }
+      identifiers.add(agent.id);
+    }
+    return new LocalAgentCatalogSnapshot(agents, installableAgents);
+  };
+};
+
+// src/agent-catalog/agent-discovery.ts
+var AgentDiscovery = class {
+  specification;
+  constructor(specification) {
+    this.specification = specification;
+  }
+};
+var AvailableAgent = class extends AgentDiscovery {
+  agent;
+  status = "ready";
+  constructor(specification, agent) {
+    super(specification);
+    this.agent = agent;
+  }
+};
+var UnavailableAgent = class extends AgentDiscovery {
+};
+var MissingAdapter = class extends UnavailableAgent {
+  code = "adapter_not_found";
+  message = "ACP adapter not found";
+  status = "missing_adapter";
+  constructor(specification) {
+    super(specification);
+  }
+};
+var MissingAgent = class extends UnavailableAgent {
+  code = "agent_not_found";
+  message = "Agent executable not found";
+  status = "missing_agent";
+  constructor(specification) {
+    super(specification);
+  }
+};
+var ProbeFailed = class extends UnavailableAgent {
+  code;
+  message;
+  status = "probe_failed";
+  constructor(specification, code, message) {
+    super(specification);
+    this.code = code;
+    this.message = message;
+  }
+};
+var IncompatibleAdapter = class extends UnavailableAgent {
+  code = "acp_incompatible";
+  message = "ACP adapter is incompatible";
+  status = "incompatible_adapter";
+  constructor(specification) {
+    super(specification);
+  }
+};
+var AuthenticationRequiredAgent = class extends UnavailableAgent {
+  code = "authentication_required";
+  message = "Agent authentication is required";
+  status = "authentication_required";
+  constructor(specification) {
+    super(specification);
+  }
+};
+var LocalAgentInventory = class {
+  available;
+  discoveries;
+  installable;
+  unavailable;
+  constructor(discoveries, grantedAgents = /* @__PURE__ */ new Set(), platform = process.platform, architecture = process.arch) {
+    const available = [];
+    const unavailable = [];
+    for (const discovery of discoveries) {
+      if (discovery instanceof AvailableAgent) {
+        available.push(discovery);
+      } else if (discovery instanceof UnavailableAgent) {
+        unavailable.push(discovery);
+      } else {
+        throw new Error("Unsupported Agent discovery outcome");
+      }
+    }
+    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(
+          discovery.specification.id,
+          discovery.specification.label,
+          !grantedAgents.has(discovery.specification.id)
+        )
+      )
+    );
+    this.unavailable = Object.freeze(unavailable);
+  }
+  readyAgents = () => this.available.map((discovery) => discovery.agent);
+};
+
+// src/agent-catalog/agent-diagnostics.ts
+var AvailableAgentDiagnostic = class {
+  adapterVersion;
+  agentVersion;
+  id;
+  label;
+  status = "ready";
+  constructor(discovery) {
+    this.adapterVersion = discovery.agent.adapterVersion;
+    this.agentVersion = discovery.agent.agentVersion;
+    this.id = discovery.specification.id;
+    this.label = discovery.specification.label;
+  }
+};
+var UnavailableAgentDiagnostic = class {
+  code;
+  id;
+  label;
+  message;
+  recoveryCommand;
+  status;
+  constructor(discovery) {
+    this.code = discovery.code;
+    this.id = discovery.specification.id;
+    this.label = discovery.specification.label;
+    this.message = discovery.message;
+    this.recoveryCommand = discovery instanceof MissingAdapter ? discovery.specification.recoveryCommand() : discovery.code === "authentication_required" ? discovery.specification.authenticationCommand() : "";
+    this.status = discovery.status;
+  }
+};
+var AgentDiagnostics = class {
+  available;
+  unavailable;
+  constructor(inventory) {
+    this.available = inventory.available.map(
+      (discovery) => new AvailableAgentDiagnostic(discovery)
+    );
+    this.unavailable = inventory.unavailable.map(
+      (discovery) => new UnavailableAgentDiagnostic(discovery)
+    );
+  }
+};
+function humanLine(label, status, detail) {
+  return `${label.padEnd(13)} ${status.padEnd(17)} ${detail}`.trimEnd();
+}
+function formatAgentDiagnostics(inventory, json2) {
+  const diagnostics = new AgentDiagnostics(inventory);
+  if (json2) {
+    return `${JSON.stringify(diagnostics, null, 2)}
+`;
+  }
+  const lines = [];
+  for (const available of diagnostics.available) {
+    lines.push(
+      humanLine(
+        available.label,
+        available.status,
+        `${available.agentVersion}   ${available.adapterVersion}`
+      )
+    );
+  }
+  for (const unavailable of diagnostics.unavailable) {
+    lines.push(
+      humanLine(unavailable.label, unavailable.status, unavailable.message)
+    );
+    if (unavailable.recoveryCommand.length > 0) {
+      lines.push(
+        unavailable.code === "authentication_required" ? `  Authenticate locally: ${unavailable.recoveryCommand}` : `  Install adapter: ${unavailable.recoveryCommand}`
+      );
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/agent-installation/installation-grants.ts
+import { open } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var MAX_GRANT_FILE_LENGTH = 16 * 1024;
+var AGENT_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readGrantedAgents(stateDirectory) {
+  const path2 = join2(stateDirectory, "installation-grants.json");
+  let handle;
+  try {
+    handle = await open(path2, "r");
+  } catch (error61) {
+    if (error61 instanceof Error && "code" in error61 && error61.code === "ENOENT") {
+      return /* @__PURE__ */ new Set();
+    }
+    throw error61;
+  }
+  try {
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.size > MAX_GRANT_FILE_LENGTH || typeof process.getuid === "function" && metadata.uid !== process.getuid() || process.platform !== "win32" && (metadata.mode & 63) !== 0) {
+      throw new Error("The local installation grant file is not private");
+    }
+    const encoded = await handle.readFile({ encoding: "utf8" });
+    const value = JSON.parse(encoded);
+    if (!isRecord(value) || Object.keys(value).length !== 1 || !Array.isArray(value["agents"])) {
+      throw new Error("The local installation grant file is invalid");
+    }
+    const agents = /* @__PURE__ */ new Set();
+    for (const candidate of value["agents"]) {
+      if (typeof candidate !== "string" || !AGENT_ID_PATTERN.test(candidate) || agents.has(candidate)) {
+        throw new Error("The local installation grant file is invalid");
+      }
+      agents.add(candidate);
+    }
+    return agents;
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/storage/state-directory.ts
+import { homedir } from "node:os";
+import { join as join3, resolve as resolve2 } from "node:path";
+function readStateDirectory(environment = process.env) {
+  const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
+  if (configured !== void 0 && configured.length > 0) {
+    return resolve2(configured);
+  }
+  return join3(homedir(), ".mobius");
+}
+
+// src/agent-installation/managed-npm-package.ts
+import {
+  mkdir,
+  mkdtemp,
+  open as open2,
+  realpath as realpath2,
+  rename,
+  rm,
+  stat as stat2
+} from "node:fs/promises";
+import { delimiter, dirname, isAbsolute, join as join4, relative, sep } from "node:path";
+var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
+var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
+var PACKAGE_LOCK_LIMIT_BYTES = 8 * 1024 * 1024;
+var ManagedNpmPackageDefinition = class {
+  dependencyResolutionArguments = Object.freeze([]);
+  executableName;
+  includeOptionalDependencies = false;
+  packageName;
+  version;
+  verifyDependencyClosure = false;
+  constructor(packageName, version2, executableName) {
+    this.executableName = executableName;
+    this.packageName = packageName;
+    this.version = version2;
+  }
+};
+var SriManagedNpmPackageDefinition = class extends ManagedNpmPackageDefinition {
+  integrity;
+  tarballUrl;
+  constructor(packageName, version2, executableName, integrity, tarballUrl) {
+    super(packageName, version2, executableName);
+    this.integrity = integrity;
+    this.tarballUrl = tarballUrl;
+  }
+};
+var ManagedNpmPackageError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "ManagedNpmPackageError";
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function packagePath(root, packageName) {
+  return join4(root, "node_modules", ...packageName.split("/"));
+}
+function isContainedPath(root, candidate) {
+  const difference = relative(root, candidate);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep}`) && !isAbsolute(difference);
+}
+async function readJsonRecord(path2, maximumBytes) {
+  try {
+    const handle = await open2(path2, "r");
+    try {
+      const metadata = await handle.stat();
+      if (!metadata.isFile() || metadata.size > maximumBytes) {
+        throw new ManagedNpmPackageError(
+          "managed_package_verification_failed",
+          "The managed npm package metadata is invalid"
+        );
+      }
+      const value = JSON.parse(
+        await handle.readFile({ encoding: "utf8" })
+      );
+      if (!isRecord2(value)) {
+        throw new ManagedNpmPackageError(
+          "managed_package_verification_failed",
+          "The managed npm package metadata is invalid"
+        );
+      }
+      return value;
+    } finally {
+      await handle.close();
+    }
+  } catch (error61) {
+    if (error61 instanceof ManagedNpmPackageError) {
+      throw error61;
+    }
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package metadata is invalid",
+      { cause: error61 }
+    );
+  }
+}
+function readBinPath(packageMetadata, executableName) {
+  const bin = packageMetadata["bin"];
+  if (typeof bin === "string") {
+    return bin;
+  }
+  if (isRecord2(bin) && typeof bin[executableName] === "string") {
+    return bin[executableName];
+  }
+  throw new ManagedNpmPackageError(
+    "managed_package_verification_failed",
+    "The managed npm package executable declaration is invalid"
+  );
+}
+function verifyPackageLock(lock, definition) {
+  if (lock["lockfileVersion"] !== 3) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile is invalid"
+    );
+  }
+  const packages = lock["packages"];
+  if (!isRecord2(packages)) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile is invalid"
+    );
+  }
+  const suffix = `node_modules/${definition.packageName}`;
+  let entry;
+  let matches = 0;
+  for (const [key, candidate] of Object.entries(packages)) {
+    const normalizedKey = key.replaceAll("\\", "/");
+    if (definition.verifyDependencyClosure && normalizedKey.length > 0) {
+      let resolved;
+      try {
+        if (!normalizedKey.split("/").includes("node_modules") || !isRecord2(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
+          throw new Error("Invalid locked dependency");
+        }
+        resolved = new URL(candidate["resolved"]);
+      } catch (error61) {
+        throw new ManagedNpmPackageError(
+          "managed_package_verification_failed",
+          "The managed npm dependency closure is invalid",
+          { cause: error61 }
+        );
+      }
+      if (resolved.protocol !== "https:" || resolved.hostname !== "registry.npmjs.org" || resolved.port.length > 0 || resolved.username.length > 0 || resolved.password.length > 0) {
+        throw new ManagedNpmPackageError(
+          "managed_package_verification_failed",
+          "The managed npm dependency closure is invalid"
+        );
+      }
+    }
+    if (normalizedKey === suffix || normalizedKey.endsWith(`/${suffix}`)) {
+      entry = candidate;
+      matches += 1;
+    }
+  }
+  if (matches !== 1 || !isRecord2(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile does not match the pinned artifact"
+    );
+  }
+}
+async function validateManagedNpmPackage(root, definition) {
+  try {
+    return await validateManagedNpmPackageContents(root, definition);
+  } catch (error61) {
+    if (error61 instanceof ManagedNpmPackageError) {
+      throw error61;
+    }
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package is invalid",
+      { cause: error61 }
+    );
+  }
+}
+async function validateManagedNpmPackageContents(root, definition) {
+  const rootPath = await realpath2(root);
+  const packageRoot = await realpath2(
+    packagePath(rootPath, definition.packageName)
+  );
+  if (!isContainedPath(rootPath, packageRoot)) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package escaped its private cache"
+    );
+  }
+  const metadata = await readJsonRecord(
+    join4(packageRoot, "package.json"),
+    PACKAGE_METADATA_LIMIT_BYTES
+  );
+  if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package identity is invalid"
+    );
+  }
+  if (definition instanceof SriManagedNpmPackageDefinition) {
+    verifyPackageLock(
+      await readJsonRecord(
+        join4(rootPath, "package-lock.json"),
+        PACKAGE_LOCK_LIMIT_BYTES
+      ),
+      definition
+    );
+  }
+  const declaredBin = readBinPath(metadata, definition.executableName);
+  const executable = await resolveExecutablePath(
+    join4(packageRoot, declaredBin)
+  );
+  if (executable === null || !isContainedPath(rootPath, executable.path)) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package executable is invalid"
+    );
+  }
+  return executable;
+}
+var ManagedNpmPackageInstaller = class {
+  install = async (root, definition, environment, signal) => {
+    signal.throwIfAborted();
+    try {
+      const metadata = await stat2(root);
+      if (metadata.isDirectory()) {
+        return await validateManagedNpmPackage(root, definition);
+      }
+    } catch (error61) {
+      if (!(error61 instanceof Error) || !("code" in error61) || error61.code !== "ENOENT") {
+        throw error61;
+      }
+    }
+    const parent = dirname(root);
+    await mkdir(parent, { mode: 448, recursive: true });
+    const staging = await mkdtemp(
+      join4(parent, `.${definition.version}.staging-`)
+    );
+    try {
+      const npm = await findExecutableOnPath(
+        process.platform === "win32" ? "npm.cmd" : "npm",
+        environment
+      );
+      if (npm === null) {
+        throw new ManagedNpmPackageError(
+          "package_manager_not_found",
+          "A supported npm executable is required to install the managed package"
+        );
+      }
+      const installArguments = ["install", "--prefix", staging];
+      installArguments.push(...definition.dependencyResolutionArguments);
+      if (definition.includeOptionalDependencies) {
+        installArguments.push("--include=optional");
+      } else {
+        installArguments.push("--omit=optional");
+      }
+      installArguments.push(
+        "--ignore-scripts",
+        "--no-audit",
+        "--no-fund",
+        "--package-lock=true",
+        "--save-exact",
+        "--registry=https://registry.npmjs.org/",
+        `${definition.packageName}@${definition.version}`
+      );
+      const installEnvironment = {
+        HOME: join4(staging, "home"),
+        NPM_CONFIG_AUDIT: "false",
+        NPM_CONFIG_CACHE: join4(staging, ".npm-cache"),
+        NPM_CONFIG_FUND: "false",
+        NPM_CONFIG_IGNORE_SCRIPTS: "true",
+        NPM_CONFIG_PACKAGE_LOCK: "true",
+        NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
+        PATH: `${dirname(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
+      };
+      if (definition.includeOptionalDependencies) {
+        installEnvironment["NPM_CONFIG_INCLUDE"] = "optional";
+      } else {
+        installEnvironment["NPM_CONFIG_OMIT"] = "optional";
+      }
+      await runBoundedProcess({
+        arguments: installArguments,
+        command: npm.path,
+        cwd: staging,
+        environment: installEnvironment,
+        outputLimitBytes: 64 * 1024,
+        signal,
+        timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
+      });
+      await Promise.all([
+        rm(join4(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm(join4(staging, "home"), { force: true, recursive: true })
+      ]);
+      await validateManagedNpmPackage(staging, definition);
+      try {
+        await rename(staging, root);
+      } catch (error61) {
+        try {
+          return await validateManagedNpmPackage(root, definition);
+        } catch {
+          throw new ManagedNpmPackageError(
+            "managed_package_publish_failed",
+            "The managed npm package could not be published",
+            { cause: error61 }
+          );
+        }
+      }
+      return await validateManagedNpmPackage(root, definition);
+    } catch (error61) {
+      if (signal.aborted) {
+        signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedNpmPackageError) {
+        throw error61;
+      }
+      throw new ManagedNpmPackageError(
+        "managed_package_install_failed",
+        "The pinned npm package could not be installed",
+        { cause: error61 }
+      );
+    } finally {
+      await rm(staging, { force: true, recursive: true });
+    }
+  };
+};
+
+// src/agent-catalog/agent-specification.ts
+import { join as join5 } from "node:path";
+var VERSION_PROBE_TIMEOUT_MILLISECONDS = 3e3;
+var ACP_PROBE_TIMEOUT_MILLISECONDS = 5e3;
+var DEFAULT_PROMPT_TIMEOUT_MILLISECONDS = 30 * 60 * 1e3;
+var LocalAgentSpecification = class {
+  acpProbeTimeoutMilliseconds = ACP_PROBE_TIMEOUT_MILLISECONDS;
+  authenticationCommand = () => "";
+  adapterVersionArguments = ["--version"];
+  agentVersionArguments = ["--version"];
+  promptTimeoutMilliseconds = DEFAULT_PROMPT_TIMEOUT_MILLISECONDS;
+  versionProbeTimeoutMilliseconds = VERSION_PROBE_TIMEOUT_MILLISECONDS;
+  resolveManagedAgent = async (stateDirectory, platform, signal) => {
+    signal.throwIfAborted();
+    const executable = await resolveExecutablePath(
+      join5(stateDirectory, ...this.managedAgentExecutablePath),
+      platform
+    );
+    signal.throwIfAborted();
+    if (executable === null) {
+      throw new Error("The managed Agent executable is unavailable");
+    }
+    return executable;
+  };
+  createLaunchEnvironment = async (_agent, _context) => Object.freeze({});
+  recoveryCommand = () => "";
+  supportsInstallation = (platform, architecture) => (platform === "darwin" || platform === "linux") && (architecture === "arm64" || architecture === "x64");
+  verifyAcp = (_connection, _initialized, _defaultWorkspace, _signal) => Promise.resolve();
+};
+var DirectAcpAgentDefinition = class extends LocalAgentSpecification {
+  adapterOverrideVariable;
+  agentOverrideVariable;
+  launchArguments;
+  managedAdapterExecutablePath;
+  managedAgentExecutablePath;
+  constructor(executableOverrideVariable, launchArguments, managedExecutablePath) {
+    super();
+    this.adapterOverrideVariable = executableOverrideVariable;
+    this.agentOverrideVariable = executableOverrideVariable;
+    this.launchArguments = Object.freeze([...launchArguments]);
+    this.managedAdapterExecutablePath = Object.freeze([
+      ...managedExecutablePath
+    ]);
+    this.managedAgentExecutablePath = this.managedAdapterExecutablePath;
+  }
+};
+var BridgedAcpAgentDefinition = class extends LocalAgentSpecification {
+  launchArguments = Object.freeze([]);
+  get adapterExecutable() {
+    return this.adapterPackageDefinition.executableName;
+  }
+  get adapterPackage() {
+    return this.adapterPackageDefinition.packageName;
+  }
+  get adapterVersion() {
+    return this.adapterPackageDefinition.version;
+  }
+  createLaunchEnvironment = async (agent, _context) => Object.freeze({ [this.adapterEnvironmentVariable]: agent.path });
+  recoveryCommand = () => `npm install -g --omit=optional ${this.adapterPackage}@${this.adapterVersion}`;
+};
+
+// src/agent-catalog/agents/claude-code-agent.ts
+var ClaudeCodeAgentSpecification = class extends BridgedAcpAgentDefinition {
+  adapterEnvironmentVariable = "CLAUDE_CODE_EXECUTABLE";
+  adapterOverrideVariable = "MOBIUS_CLAUDE_ACP_PATH";
+  adapterPackageDefinition = new ManagedNpmPackageDefinition(
+    "@agentclientprotocol/claude-agent-acp",
+    "0.73.0",
+    "claude-agent-acp"
+  );
+  agentExecutable = "claude";
+  agentOverrideVariable = "MOBIUS_CLAUDE_PATH";
+  id = "claude";
+  label = "Claude Code";
+  managedAdapterExecutablePath = [
+    "adapters",
+    "claude",
+    "0.73.0",
+    "node_modules",
+    "@agentclientprotocol",
+    "claude-agent-acp",
+    "dist",
+    "index.js"
+  ];
+  managedAgentExecutablePath = [
+    "agents",
+    "claude",
+    "home",
+    ".local",
+    "bin",
+    "claude"
+  ];
+};
+
+// src/agent-catalog/agents/codex-agent.ts
+var CodexAgentSpecification = class extends BridgedAcpAgentDefinition {
+  adapterEnvironmentVariable = "CODEX_PATH";
+  adapterOverrideVariable = "MOBIUS_CODEX_ACP_PATH";
+  adapterPackageDefinition = new ManagedNpmPackageDefinition(
+    "@agentclientprotocol/codex-acp",
+    "1.8.0",
+    "codex-acp"
+  );
+  agentExecutable = "codex";
+  agentOverrideVariable = "MOBIUS_CODEX_PATH";
+  id = "codex";
+  label = "Codex";
+  managedAdapterExecutablePath = [
+    "adapters",
+    "codex",
+    "1.8.0",
+    "node_modules",
+    "@agentclientprotocol",
+    "codex-acp",
+    "dist",
+    "index.js"
+  ];
+  managedAgentExecutablePath = ["agents", "codex", "bin", "codex"];
+};
+
+// src/agent-catalog/agents/deepseek-harness-agent.ts
+import { realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join6, normalize } from "node:path";
+
+// src/agent-installation/deepseek-managed-package.ts
+var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
+  dependencyResolutionArguments = Object.freeze([
+    "--before=2026-09-03T06:31:52.107Z"
+  ]);
+  includeOptionalDependencies = true;
+  verifyDependencyClosure = true;
+};
+var DEEPSEEK_HARNESS_PACKAGE = new DeepSeekHarnessManagedPackage(
+  "@deepseek-ai/dsh",
+  "0.1.2-rc.1",
+  "dsh",
+  "sha512-RPq48TzxvwpdT9/7W1tbhZDBMmeK+bxDrX9cqQC27Wx/LqtgJF8PSa3b3xriU8oxtvhwYmk21w2cej3uMQrnVA==",
+  "https://registry.npmjs.org/@deepseek-ai/dsh/-/dsh-0.1.2-rc.1.tgz"
+);
+
+// src/agent-catalog/agent-probe-error.ts
+var AgentProbeError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "AgentProbeError";
+  }
+};
+
+// src/agent-catalog/agents/deepseek-harness-agent.ts
+async function validateAgentHome(path2) {
+  if (!isAbsolute2(path2) || normalize(path2) !== path2) {
+    throw new AgentProbeError(
+      "agent_environment_invalid",
+      "The configured Agent home is invalid"
+    );
+  }
+  try {
+    const resolved = await realpath3(path2);
+    const metadata = await stat3(resolved);
+    if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
+      throw new Error("Agent home is not a user-owned directory");
+    }
+    return resolved;
   } catch (error61) {
-    if (error61 instanceof ManagedNpmPackageError) {
+    if (error61 instanceof AgentProbeError) {
       throw error61;
     }
-    throw new ManagedNpmPackageError(
-      "managed_package_verification_failed",
-      "The managed npm package metadata is invalid",
-      { cause: error61 }
-    );
-  }
-}
-function readBinPath(packageMetadata, executableName) {
-  const bin = packageMetadata["bin"];
-  if (typeof bin === "string") {
-    return bin;
-  }
-  if (isRecord2(bin) && typeof bin[executableName] === "string") {
-    return bin[executableName];
+    throw new AgentProbeError(
+      "agent_environment_invalid",
+      "The configured Agent home is invalid",
+      { cause: error61 }
+    );
+  }
+}
+var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
+  adapterVersion = DEEPSEEK_HARNESS_PACKAGE.version;
+  authenticationCommand = () => "dsh web";
+  agentExecutable = "dsh";
+  id = "deepseek-harness";
+  label = "DeepSeek Harness";
+  constructor() {
+    super(
+      "MOBIUS_DEEPSEEK_HARNESS_PATH",
+      ["--profile", "acp"],
+      [
+        "agents",
+        "deepseek-harness",
+        DEEPSEEK_HARNESS_PACKAGE.version,
+        "node_modules",
+        "@deepseek-ai",
+        "dsh",
+        "lib",
+        "bin.js"
+      ]
+    );
+  }
+  createLaunchEnvironment = async (agent, context) => {
+    let selectedHome = context.environment["DSH_HOME"];
+    try {
+      const managed = await this.resolveManagedAgent(
+        readStateDirectory(context.environment),
+        context.platform ?? process.platform,
+        context.signal
+      );
+      if (managed.path === agent.path) {
+        selectedHome = join6(
+          readStateDirectory(context.environment),
+          "agents",
+          this.id,
+          "home"
+        );
+      }
+    } catch {
+      context.signal.throwIfAborted();
+    }
+    if (selectedHome === void 0 || selectedHome.length === 0) {
+      return Object.freeze({ DSH_PERMISSION_MODE: "workspace-write" });
+    }
+    return Object.freeze({
+      DSH_HOME: await validateAgentHome(selectedHome),
+      DSH_PERMISSION_MODE: "workspace-write"
+    });
+  };
+  resolveManagedAgent = async (stateDirectory, _platform, signal) => {
+    signal.throwIfAborted();
+    const executable = await validateManagedNpmPackage(
+      join6(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      DEEPSEEK_HARNESS_PACKAGE
+    );
+    signal.throwIfAborted();
+    return executable;
+  };
+  verifyAcp = (_connection, initialized, _defaultWorkspace, _signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    const session = capabilities.sessionCapabilities;
+    const prompt = capabilities.promptCapabilities;
+    if ((initialized.authMethods ?? []).length !== 0 || capabilities.loadSession === true || capabilities.mcpCapabilities?.http !== true || session?.close == null || session.list == null || session.resume == null || session.additionalDirectories != null || session.delete != null || session.fork != null || prompt?.audio === true || prompt?.embeddedContext === true || prompt?.image === true) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "DeepSeek Harness reported an unsupported ACP capability set"
+      );
+    }
+    return Promise.resolve();
+  };
+};
+
+// src/agent-catalog/agents/opencode-agent.ts
+import { join as join8 } from "node:path";
+
+// src/agent-installation/managed-agent-archive.ts
+import { createHash as createHash2 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import {
+  chmod,
+  copyFile,
+  mkdir as mkdir2,
+  mkdtemp as mkdtemp2,
+  open as open4,
+  realpath as realpath4,
+  rename as rename2,
+  rm as rm2,
+  stat as stat4,
+  writeFile
+} from "node:fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join7, relative as relative2, sep as sep2 } from "node:path";
+
+// src/agent-installation/verified-download.ts
+import { createHash } from "node:crypto";
+import { open as open3, unlink } from "node:fs/promises";
+import { fetch } from "undici";
+
+// src/network/environment-proxy.ts
+import { EnvHttpProxyAgent } from "undici";
+var environmentProxyDispatcher = new EnvHttpProxyAgent();
+
+// src/agent-installation/verified-download.ts
+var MAX_REDIRECTS = 4;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var InstallerDownloadError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "InstallerDownloadError";
+  }
+};
+var VerifiedDownload = class {
+  bytes;
+  sha256;
+  url;
+  constructor(url2, bytes, sha256) {
+    this.bytes = bytes;
+    this.sha256 = sha256;
+    this.url = url2;
+  }
+};
+var UndiciInstallerDownloadTransport = class {
+  get = async (url2, signal) => await fetch(url2, {
+    dispatcher: environmentProxyDispatcher,
+    headers: {
+      accept: "text/plain, application/octet-stream;q=0.9",
+      "user-agent": "Mobius-Agent-Installer/0.0.3"
+    },
+    method: "GET",
+    redirect: "manual",
+    signal
+  });
+};
+function validateUrl(url2, allowedHosts) {
+  if (url2.protocol !== "https:" || url2.username.length > 0 || url2.password.length > 0 || url2.port.length > 0 || !allowedHosts.has(url2.hostname)) {
+    throw new InstallerDownloadError(
+      "installer_host_not_allowed",
+      "The installer download target is not allowed"
+    );
+  }
+}
+async function fetchInstaller(options, signal, transport) {
+  let url2 = new URL(options.url);
+  for (let redirectCount = 0; redirectCount <= MAX_REDIRECTS; redirectCount += 1) {
+    validateUrl(url2, options.allowedHosts);
+    const response = await transport.get(url2, signal);
+    if (!REDIRECT_STATUSES.has(response.status)) {
+      return { response, url: url2 };
+    }
+    await response.body?.cancel();
+    const location = response.headers.get("location");
+    if (location === null || redirectCount === MAX_REDIRECTS) {
+      throw new InstallerDownloadError(
+        "installer_redirect_invalid",
+        "The installer returned an invalid redirect"
+      );
+    }
+    let redirected;
+    try {
+      redirected = new URL(location, url2);
+    } catch (error61) {
+      throw new InstallerDownloadError(
+        "installer_redirect_invalid",
+        "The installer returned an invalid redirect",
+        { cause: error61 }
+      );
+    }
+    try {
+      validateUrl(redirected, options.allowedHosts);
+    } catch (error61) {
+      throw new InstallerDownloadError(
+        "installer_redirect_not_allowed",
+        "The installer redirect left the approved host allowlist",
+        { cause: error61 }
+      );
+    }
+    url2 = redirected;
   }
-  throw new ManagedNpmPackageError(
-    "managed_package_verification_failed",
-    "The managed npm package executable declaration is invalid"
+  throw new InstallerDownloadError(
+    "installer_redirect_invalid",
+    "The installer returned too many redirects"
   );
 }
-function verifyPackageLock(lock, definition) {
-  if (lock["lockfileVersion"] !== 3) {
-    throw new ManagedNpmPackageError(
-      "managed_package_verification_failed",
-      "The managed npm package lockfile is invalid"
-    );
-  }
-  const packages = lock["packages"];
-  if (!isRecord2(packages)) {
-    throw new ManagedNpmPackageError(
-      "managed_package_verification_failed",
-      "The managed npm package lockfile is invalid"
+async function writeCompleteChunk(handle, chunk) {
+  let offset = 0;
+  while (offset < chunk.byteLength) {
+    const written = await handle.write(
+      chunk,
+      offset,
+      chunk.byteLength - offset
     );
-  }
-  const suffix = `node_modules/${definition.packageName}`;
-  let entry;
-  let matches = 0;
-  for (const [key, candidate] of Object.entries(packages)) {
-    const normalizedKey = key.replaceAll("\\", "/");
-    if (normalizedKey === suffix || normalizedKey.endsWith(`/${suffix}`)) {
-      entry = candidate;
-      matches += 1;
+    if (written.bytesWritten < 1) {
+      throw new InstallerDownloadError(
+        "installer_write_failed",
+        "The verified installer could not be stored"
+      );
     }
-  }
-  if (matches !== 1 || !isRecord2(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"
-    );
+    offset += written.bytesWritten;
   }
 }
-async function validateManagedNpmPackage(root, definition) {
+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 {
-    return await validateManagedNpmPackageContents(root, definition);
-  } catch (error61) {
-    if (error61 instanceof ManagedNpmPackageError) {
-      throw error61;
+    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"
+      );
     }
-    throw new ManagedNpmPackageError(
-      "managed_package_verification_failed",
-      "The managed npm package is invalid",
-      { cause: error61 }
-    );
-  }
-}
-async function validateManagedNpmPackageContents(root, definition) {
-  const rootPath = await realpath2(root);
-  const packageRoot = await realpath2(
-    packagePath(rootPath, definition.packageName)
-  );
-  if (!isContainedPath(rootPath, packageRoot)) {
-    throw new ManagedNpmPackageError(
-      "managed_package_verification_failed",
-      "The managed npm package escaped its private cache"
-    );
-  }
-  const metadata = await readJsonRecord(
-    join3(packageRoot, "package.json"),
-    PACKAGE_METADATA_LIMIT_BYTES
-  );
-  if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
-    throw new ManagedNpmPackageError(
-      "managed_package_verification_failed",
-      "The managed npm package identity is invalid"
-    );
-  }
-  if (definition instanceof SriManagedNpmPackageDefinition) {
-    verifyPackageLock(
-      await readJsonRecord(
-        join3(rootPath, "package-lock.json"),
-        PACKAGE_LOCK_LIMIT_BYTES
-      ),
-      definition
-    );
-  }
-  const declaredBin = readBinPath(metadata, definition.executableName);
-  const executable = await resolveExecutablePath(
-    join3(packageRoot, declaredBin)
-  );
-  if (executable === null || !isContainedPath(rootPath, executable.path)) {
-    throw new ManagedNpmPackageError(
-      "managed_package_verification_failed",
-      "The managed npm package executable is invalid"
-    );
-  }
-  return executable;
-}
-var ManagedNpmPackageInstaller = class {
-  install = async (root, definition, environment, signal) => {
-    signal.throwIfAborted();
-    try {
-      const metadata = await stat2(root);
-      if (metadata.isDirectory()) {
-        return await validateManagedNpmPackage(root, definition);
-      }
-    } catch (error61) {
-      if (!(error61 instanceof Error) || !("code" in error61) || error61.code !== "ENOENT") {
-        throw error61;
+    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"
+        );
       }
     }
-    const parent = dirname(root);
-    await mkdir(parent, { mode: 448, recursive: true });
-    const staging = await mkdtemp(
-      join3(parent, `.${definition.version}.staging-`)
-    );
+    handle = await open3(options.destination, "wx", 384);
+    const digest = createHash("sha256");
+    const reader = fetched.response.body.getReader();
+    let bytes = 0;
     try {
-      const npm = await findExecutableOnPath(
-        process.platform === "win32" ? "npm.cmd" : "npm",
-        environment
-      );
-      if (npm === null) {
-        throw new ManagedNpmPackageError(
-          "package_manager_not_found",
-          "A supported npm executable is required to install the managed package"
-        );
-      }
-      await runBoundedProcess({
-        arguments: [
-          "install",
-          "--prefix",
-          staging,
-          "--omit=optional",
-          "--ignore-scripts",
-          "--no-audit",
-          "--no-fund",
-          "--package-lock=true",
-          "--save-exact",
-          "--registry=https://registry.npmjs.org/",
-          `${definition.packageName}@${definition.version}`
-        ],
-        command: npm.path,
-        cwd: staging,
-        environment: {
-          HOME: join3(staging, "home"),
-          NPM_CONFIG_AUDIT: "false",
-          NPM_CONFIG_CACHE: join3(staging, ".npm-cache"),
-          NPM_CONFIG_FUND: "false",
-          NPM_CONFIG_IGNORE_SCRIPTS: "true",
-          NPM_CONFIG_OMIT: "optional",
-          NPM_CONFIG_PACKAGE_LOCK: "true",
-          NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
-          PATH: `${dirname(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
-        },
-        outputLimitBytes: 64 * 1024,
-        signal,
-        timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
-      });
-      await Promise.all([
-        rm(join3(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm(join3(staging, "home"), { force: true, recursive: true })
-      ]);
-      await validateManagedNpmPackage(staging, definition);
-      try {
-        await rename(staging, root);
-      } catch (error61) {
-        try {
-          return await validateManagedNpmPackage(root, definition);
-        } catch {
-          throw new ManagedNpmPackageError(
-            "managed_package_publish_failed",
-            "The managed npm package could not be published",
-            { cause: error61 }
+      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);
       }
-      return await validateManagedNpmPackage(root, definition);
-    } catch (error61) {
-      if (signal.aborted) {
-        signal.throwIfAborted();
-      }
-      if (error61 instanceof ManagedNpmPackageError) {
-        throw error61;
-      }
-      throw new ManagedNpmPackageError(
-        "managed_package_install_failed",
-        "The pinned npm package could not be installed",
+    } 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 }
       );
-    } finally {
-      await rm(staging, { force: true, recursive: true });
     }
-  };
+    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
+  ];
 };
-
-// src/agent-installation/managed-adapter-installer.ts
-var ManagedAdapterInstallError = class extends Error {
+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 = "ManagedAdapterInstallError";
+    this.name = "ManagedAgentArchiveError";
   }
 };
-function translateError(error61) {
-  if (error61 instanceof ManagedAdapterInstallError) {
-    return error61;
-  }
-  if (error61 instanceof ManagedNpmPackageError) {
-    if (error61.code === "package_manager_not_found") {
-      return new ManagedAdapterInstallError(
-        error61.code,
-        "A supported npm executable is required to install the ACP adapter",
-        { cause: error61 }
-      );
+var ManagedAgentArchiveDownloader = class {
+  download = async (options) => await downloadVerifiedFile(options);
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isContainedPath2(root, candidate) {
+  const difference = relative2(root, candidate);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep2}`) && !isAbsolute3(difference);
+}
+async function hashFile(path2, signal) {
+  signal.throwIfAborted();
+  const digest = createHash2("sha256");
+  const stream = createReadStream(path2, { signal });
+  try {
+    for await (const chunk of stream) {
+      signal.throwIfAborted();
+      if (!(chunk instanceof Uint8Array)) {
+        throw new ManagedAgentArchiveError(
+          "managed_archive_verification_failed",
+          "The managed Agent archive produced invalid bytes"
+        );
+      }
+      digest.update(chunk);
     }
-    if (error61.code === "managed_package_verification_failed") {
-      return new ManagedAdapterInstallError(
-        "adapter_verification_failed",
-        "The managed adapter did not match its pinned artifact",
-        { cause: error61 }
-      );
+    return digest.digest("hex");
+  } catch (error61) {
+    if (signal.aborted) {
+      signal.throwIfAborted();
     }
-    if (error61.code === "managed_package_publish_failed") {
-      return new ManagedAdapterInstallError(
-        "adapter_publish_failed",
-        "The managed adapter could not be published",
-        { cause: error61 }
-      );
+    if (error61 instanceof ManagedAgentArchiveError) {
+      throw error61;
     }
+    throw new ManagedAgentArchiveError(
+      "managed_archive_verification_failed",
+      "The managed Agent artifact could not be verified",
+      { cause: error61 }
+    );
   }
-  return new ManagedAdapterInstallError(
-    "adapter_install_failed",
-    "The pinned ACP adapter could not be installed",
-    { cause: error61 }
-  );
 }
-async function validateManagedAdapter(root, specification) {
+async function readManifest(path2) {
+  let handle;
   try {
-    return await validateManagedNpmPackage(
-      root,
-      specification.adapterPackageDefinition
-    );
+    handle = await open4(path2, "r");
   } catch (error61) {
-    throw translateError(error61);
-  }
-}
-var ManagedAdapterInstaller = class {
-  #environment;
-  #npmInstaller;
-  #stateDirectory;
-  constructor(options, npmInstaller = new ManagedNpmPackageInstaller()) {
-    this.#environment = options.environment;
-    this.#npmInstaller = npmInstaller;
-    this.#stateDirectory = options.stateDirectory;
+    throw new ManagedAgentArchiveError(
+      "managed_archive_verification_failed",
+      "The managed Agent archive manifest is invalid",
+      { cause: error61 }
+    );
   }
-  install = async (specification, signal) => {
-    const root = join4(
-      this.#stateDirectory,
-      "adapters",
-      specification.id,
-      specification.adapterVersion
+  try {
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.size > MANIFEST_LIMIT_BYTES) {
+      throw new ManagedAgentArchiveError(
+        "managed_archive_verification_failed",
+        "The managed Agent archive manifest is invalid"
+      );
+    }
+    const parsed = JSON.parse(
+      await handle.readFile({ encoding: "utf8" })
     );
-    try {
-      return await this.#npmInstaller.install(
-        root,
-        specification.adapterPackageDefinition,
-        this.#environment,
-        signal
+    if (!isRecord3(parsed)) {
+      throw new ManagedAgentArchiveError(
+        "managed_archive_verification_failed",
+        "The managed Agent archive manifest is invalid"
       );
-    } catch (error61) {
-      if (signal.aborted) {
-        signal.throwIfAborted();
-      }
-      throw translateError(error61);
     }
-  };
-};
-
-// src/agent-installation/pi-managed-packages.ts
-var PI_ACP_PACKAGE = new SriManagedNpmPackageDefinition(
-  "pi-acp",
-  "0.0.33",
-  "pi-acp",
-  "sha512-vX9kY1tK14E72G4dBAx+RGCk/k7XPjTHls6dLUxA8WSkBav6B6JHuSBv3eusp50LCR/GTRsR2kIKsG0Z5jANzw==",
-  "https://registry.npmjs.org/pi-acp/-/pi-acp-0.0.33.tgz"
-);
-var PI_AGENT_PACKAGE = new SriManagedNpmPackageDefinition(
-  "@earendil-works/pi-coding-agent",
-  "0.85.0",
-  "pi",
-  "sha512-INxVkLAVfAMju5MojJpmyu/0bMP+r+ffZuS7UqVv32E2JwHBRbcHfELDfmFNvapEbgYfKN2r9OYO1p3TqDBR+g==",
-  "https://registry.npmjs.org/@earendil-works/pi-coding-agent/-/pi-coding-agent-0.85.0.tgz"
-);
-
-// src/storage/state-directory.ts
-import { homedir } from "node:os";
-import { join as join5, resolve as resolve2 } from "node:path";
-function readStateDirectory(environment = process.env) {
-  const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
-  if (configured !== void 0 && configured.length > 0) {
-    return resolve2(configured);
+    return parsed;
+  } catch (error61) {
+    if (error61 instanceof ManagedAgentArchiveError) {
+      throw error61;
+    }
+    throw new ManagedAgentArchiveError(
+      "managed_archive_verification_failed",
+      "The managed Agent archive manifest is invalid",
+      { cause: error61 }
+    );
+  } finally {
+    await handle.close();
   }
-  return join5(homedir(), ".mobius");
-}
-
-// src/agent-catalog/local-agent.ts
-import { realpathSync, statSync } from "node:fs";
-function readTrustedIdentity(path2) {
-  const resolvedPath = realpathSync(path2);
-  const metadata = statSync(resolvedPath);
-  return new ExecutableIdentity(
-    resolvedPath,
-    resolvedPath,
-    metadata.dev,
-    metadata.ino,
-    metadata.size,
-    metadata.ctimeMs
-  );
 }
-var LocalAgentDefinition = class {
-  adapterIdentity;
-  adapterPath;
-  adapterVersion;
-  agentIdentity;
-  agentVersion;
-  arguments;
-  command;
-  environment;
-  id;
-  label;
-  promptTimeoutMilliseconds;
-  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity, promptTimeoutMilliseconds = 30 * 60 * 1e3) {
-    if (!Number.isSafeInteger(promptTimeoutMilliseconds) || promptTimeoutMilliseconds < 1) {
-      throw new Error("The local Agent prompt deadline is invalid");
+async function validateManagedAgentArchive(root, definition, signal) {
+  try {
+    const rootPath = await realpath4(root);
+    const rootMetadata = await stat4(rootPath);
+    if (!rootMetadata.isDirectory() || typeof process.getuid === "function" && rootMetadata.uid !== process.getuid()) {
+      throw new Error("Managed Agent root is not user-owned");
     }
-    this.adapterIdentity = adapterIdentity;
-    this.adapterPath = adapterIdentity.realPath;
-    this.adapterVersion = adapterVersion;
-    this.agentIdentity = agentIdentity;
-    this.agentVersion = agentVersion;
-    this.id = id;
-    this.label = label;
-    this.promptTimeoutMilliseconds = promptTimeoutMilliseconds;
-    this.command = adapterIdentity.realPath;
-    this.arguments = Object.freeze([...arguments_]);
-    this.environment = Object.freeze({ ...environment });
-  }
-};
-var InstallableAgentDefinition = class {
-  id;
-  label;
-  requiresLocalApproval;
-  constructor(id, label, requiresLocalApproval = true) {
-    this.id = id;
-    this.label = label;
-    this.requiresLocalApproval = requiresLocalApproval;
-  }
-};
-var LocalAgentCatalogSnapshot = class {
-  agents;
-  installableAgents;
-  constructor(agents, installableAgents) {
-    this.agents = Object.freeze([...agents]);
-    this.installableAgents = Object.freeze([...installableAgents]);
+    const manifest = await readManifest(join7(rootPath, "archive.json"));
+    if (manifest["archiveSha256"] !== definition.archiveSha256 || manifest["archiveUrl"] !== definition.archiveUrl.toString() || manifest["version"] !== definition.version || typeof manifest["executableSha256"] !== "string") {
+      throw new Error("Managed Agent archive identity is invalid");
+    }
+    const executable = await resolveExecutablePath(
+      join7(rootPath, "bin", definition.executableName)
+    );
+    if (executable === null || !isContainedPath2(rootPath, executable.path) || await hashFile(executable.path, signal) !== manifest["executableSha256"]) {
+      throw new Error("Managed Agent executable is invalid");
+    }
+    return executable;
+  } catch (error61) {
+    if (signal.aborted) {
+      signal.throwIfAborted();
+    }
+    if (error61 instanceof ManagedAgentArchiveError) {
+      throw error61;
+    }
+    throw new ManagedAgentArchiveError(
+      "managed_archive_verification_failed",
+      "The managed Agent archive did not match its pinned artifact",
+      { cause: error61 }
+    );
   }
-};
-var LocalAgentCatalogError = class extends Error {
-  code = "agent_not_ready";
-  constructor() {
-    super("The requested local Agent is not ready");
-    this.name = "LocalAgentCatalogError";
+}
+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 LocalAgentCatalog = class {
-  #snapshot;
-  constructor(agents, installableAgents) {
-    this.#snapshot = this.validate(agents, installableAgents);
+}
+var ManagedAgentArchiveInstaller = class {
+  #downloader;
+  constructor(downloader = new ManagedAgentArchiveDownloader()) {
+    this.#downloader = downloader;
   }
-  find = (agentId) => {
-    for (const agent of this.#snapshot.agents) {
-      if (agent.id === agentId) {
-        return agent;
+  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;
       }
     }
-    throw new LocalAgentCatalogError();
-  };
-  read = () => this.#snapshot;
-  transition = (agents, installableAgents) => {
-    const next = this.validate(agents, installableAgents);
-    this.#snapshot = next;
-    return next;
-  };
-  validate = (agents, installableAgents) => {
-    const identifiers = /* @__PURE__ */ new Set();
-    for (const agent of agents) {
-      if (identifiers.has(agent.id)) {
-        throw new Error("The local Agent catalog contains duplicate entries");
+    const parent = dirname2(root);
+    await mkdir2(parent, { mode: 448, recursive: true });
+    const working = await mkdtemp2(
+      join7(parent, `.${definition.version}.archive-`)
+    );
+    const staging = await mkdtemp2(
+      join7(parent, `.${definition.version}.staging-`)
+    );
+    try {
+      const archivePath = join7(working, definition.archiveName);
+      const extractionRoot = join7(working, "extracted");
+      await mkdir2(extractionRoot, { mode: 448 });
+      const canonicalExtractionRoot = await realpath4(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 realpath4(
+        join7(canonicalExtractionRoot, definition.executableName)
+      );
+      const extractedMetadata = await stat4(extracted);
+      if (!isContainedPath2(canonicalExtractionRoot, extracted) || !extractedMetadata.isFile()) {
+        throw new ManagedAgentArchiveError(
+          "managed_archive_verification_failed",
+          "The managed Agent archive executable is invalid"
+        );
+      }
+      const binDirectory = join7(staging, "bin");
+      const executablePath = join7(binDirectory, definition.executableName);
+      await mkdir2(binDirectory, { mode: 448 });
+      await copyFile(extracted, executablePath);
+      await chmod(executablePath, 448);
+      const executableSha256 = await hashFile(executablePath, signal);
+      await writeFile(
+        join7(staging, "archive.json"),
+        `${JSON.stringify({
+          archiveSha256: definition.archiveSha256,
+          archiveUrl: definition.archiveUrl.toString(),
+          executableSha256,
+          version: definition.version
+        })}
+`,
+        { mode: 384 }
+      );
+      await validateManagedAgentArchive(staging, definition, signal);
+      try {
+        await rename2(staging, root);
+      } catch (error61) {
+        try {
+          return await validateManagedAgentArchive(root, definition, signal);
+        } catch {
+          throw new ManagedAgentArchiveError(
+            "managed_archive_publish_failed",
+            "The managed Agent archive could not be published",
+            { cause: error61 }
+          );
+        }
       }
-      identifiers.add(agent.id);
-    }
-    for (const agent of installableAgents) {
-      if (identifiers.has(agent.id)) {
-        throw new Error("A local Agent cannot be ready and installable");
+      return await validateManagedAgentArchive(root, definition, signal);
+    } catch (error61) {
+      if (signal.aborted) {
+        signal.throwIfAborted();
       }
-      identifiers.add(agent.id);
+      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 })
+      ]);
     }
-    return new LocalAgentCatalogSnapshot(agents, installableAgents);
   };
 };
 
-// src/agent-catalog/discover-local-agents.ts
-var VERSION_PROBE_TIMEOUT_MILLISECONDS = 3e3;
-var ACP_PROBE_TIMEOUT_MILLISECONDS = 5e3;
-var ACP_OUTPUT_LIMIT_BYTES = 1024 * 1024;
-var DEFAULT_PROMPT_TIMEOUT_MILLISECONDS = 30 * 60 * 1e3;
-var PI_ACP_PROBE_TIMEOUT_MILLISECONDS = 3e4;
-var PI_PROMPT_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
-var LocalAgentSpecification = class {
-  acpProbeTimeoutMilliseconds = ACP_PROBE_TIMEOUT_MILLISECONDS;
-  authenticationCommand = () => "";
-  adapterVersionArguments = ["--version"];
-  agentVersionArguments = ["--version"];
-  promptTimeoutMilliseconds = DEFAULT_PROMPT_TIMEOUT_MILLISECONDS;
-  get adapterExecutable() {
-    return this.adapterPackageDefinition.executableName;
+// src/agent-installation/opencode-managed-release.ts
+var OPENCODE_MANAGED_VERSION = "1.18.29";
+function releaseUrl(asset) {
+  return new URL(
+    `https://github.com/anomalyco/opencode/releases/download/v${OPENCODE_MANAGED_VERSION}/${asset}`
+  );
+}
+function openCodeManagedArchive(platform, architecture) {
+  if (platform === "darwin" && architecture === "arm64") {
+    const asset = "opencode-darwin-arm64.zip";
+    return new ZipManagedAgentArchiveDefinition(
+      OPENCODE_MANAGED_VERSION,
+      asset,
+      releaseUrl(asset),
+      "fe764f7f360c584a83e18dd5f23fb1a6b2725f5ee8854b0252fe558f7798e946",
+      "opencode"
+    );
   }
-  get adapterPackage() {
-    return this.adapterPackageDefinition.packageName;
+  if (platform === "darwin" && architecture === "x64") {
+    const asset = "opencode-darwin-x64.zip";
+    return new ZipManagedAgentArchiveDefinition(
+      OPENCODE_MANAGED_VERSION,
+      asset,
+      releaseUrl(asset),
+      "9858853e7bacdbbd22c2d70c377e009dc4b354dd04f5588705411e7afb89fd2d",
+      "opencode"
+    );
   }
-  get adapterVersion() {
-    return this.adapterPackageDefinition.version;
+  if (platform === "linux" && architecture === "arm64") {
+    const asset = "opencode-linux-arm64.tar.gz";
+    return new TarGzipManagedAgentArchiveDefinition(
+      OPENCODE_MANAGED_VERSION,
+      asset,
+      releaseUrl(asset),
+      "70baf769395ca4e7a68924026530c390eace194f3b7e4919d4efcb2aa2eed3c0",
+      "opencode"
+    );
   }
-  resolveManagedAgent = async (stateDirectory, platform) => {
-    const executable = await resolveExecutablePath(
-      join6(stateDirectory, ...this.managedAgentExecutablePath),
-      platform
+  if (platform === "linux" && architecture === "x64") {
+    const asset = "opencode-linux-x64.tar.gz";
+    return new TarGzipManagedAgentArchiveDefinition(
+      OPENCODE_MANAGED_VERSION,
+      asset,
+      releaseUrl(asset),
+      "ea800b7ff56226b70952126c9fc1e2517ca4c4b5682fd9d3f9e87449697a1194",
+      "opencode"
     );
-    if (executable === null) {
-      throw new Error("The managed Agent executable is unavailable");
-    }
-    return executable;
-  };
-  recoveryCommand = () => `npm install -g --omit=optional ${this.adapterPackage}@${this.adapterVersion}`;
-  supportsInstallation = (platform, architecture) => (platform === "darwin" || platform === "linux") && (architecture === "arm64" || architecture === "x64");
-  verifyAcp = (_connection, _initialized, _defaultWorkspace, _signal) => Promise.resolve();
-};
-var BridgedAcpAgentDefinition = class extends LocalAgentSpecification {
-};
-var CodexAgentSpecification = class extends BridgedAcpAgentDefinition {
-  adapterEnvironmentVariable = "CODEX_PATH";
-  adapterOverrideVariable = "MOBIUS_CODEX_ACP_PATH";
-  adapterPackageDefinition = new ManagedNpmPackageDefinition(
-    "@agentclientprotocol/codex-acp",
-    "1.8.0",
-    "codex-acp"
+  }
+  throw new Error(
+    "OpenCode does not publish an approved archive for this platform"
   );
-  agentExecutable = "codex";
-  agentOverrideVariable = "MOBIUS_CODEX_PATH";
-  id = "codex";
-  label = "Codex";
-  managedAdapterExecutablePath = [
-    "adapters",
-    "codex",
-    "1.8.0",
-    "node_modules",
-    "@agentclientprotocol",
-    "codex-acp",
-    "dist",
-    "index.js"
-  ];
-  managedAgentExecutablePath = ["agents", "codex", "bin", "codex"];
-};
-var ClaudeCodeAgentSpecification = class extends BridgedAcpAgentDefinition {
-  adapterEnvironmentVariable = "CLAUDE_CODE_EXECUTABLE";
-  adapterOverrideVariable = "MOBIUS_CLAUDE_ACP_PATH";
-  adapterPackageDefinition = new ManagedNpmPackageDefinition(
-    "@agentclientprotocol/claude-agent-acp",
-    "0.73.0",
-    "claude-agent-acp"
+}
+
+// src/agent-catalog/agents/opencode-agent.ts
+var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
+  versionProbeTimeoutMilliseconds = 15e3;
+  adapterVersion = OPENCODE_MANAGED_VERSION;
+  authenticationCommand = () => "opencode auth login";
+  agentExecutable = "opencode";
+  id = "opencode";
+  label = "OpenCode";
+  constructor() {
+    super(
+      "MOBIUS_OPENCODE_PATH",
+      ["acp"],
+      [
+        "agents",
+        "opencode",
+        OPENCODE_MANAGED_VERSION,
+        "bin",
+        process.platform === "win32" ? "opencode.exe" : "opencode"
+      ]
+    );
+  }
+  createLaunchEnvironment = async (_agent, _context) => Object.freeze({ OPENCODE_DISABLE_AUTOUPDATE: "1" });
+  resolveManagedAgent = async (stateDirectory, platform, signal) => await validateManagedAgentArchive(
+    join8(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    openCodeManagedArchive(platform, process.arch),
+    signal
   );
-  agentExecutable = "claude";
-  agentOverrideVariable = "MOBIUS_CLAUDE_PATH";
-  id = "claude";
-  label = "Claude Code";
-  managedAdapterExecutablePath = [
-    "adapters",
-    "claude",
-    "0.73.0",
-    "node_modules",
-    "@agentclientprotocol",
-    "claude-agent-acp",
-    "dist",
-    "index.js"
-  ];
-  managedAgentExecutablePath = [
-    "agents",
-    "claude",
-    "home",
-    ".local",
-    "bin",
-    "claude"
-  ];
+  verifyAcp = (_connection, initialized, _defaultWorkspace, _signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    const session = capabilities.sessionCapabilities;
+    if (capabilities.loadSession !== true || session?.close == null || session.list == null || session.resume == null) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "OpenCode does not support the required ACP session lifecycle"
+      );
+    }
+    return Promise.resolve();
+  };
 };
+
+// src/agent-catalog/agents/pi-agent.ts
+import { join as join9 } from "node:path";
+import {
+  methods
+} from "@agentclientprotocol/sdk";
+
+// src/agent-installation/pi-managed-packages.ts
+var PI_ACP_PACKAGE = new SriManagedNpmPackageDefinition(
+  "pi-acp",
+  "0.0.33",
+  "pi-acp",
+  "sha512-vX9kY1tK14E72G4dBAx+RGCk/k7XPjTHls6dLUxA8WSkBav6B6JHuSBv3eusp50LCR/GTRsR2kIKsG0Z5jANzw==",
+  "https://registry.npmjs.org/pi-acp/-/pi-acp-0.0.33.tgz"
+);
+var PI_AGENT_PACKAGE = new SriManagedNpmPackageDefinition(
+  "@earendil-works/pi-coding-agent",
+  "0.85.0",
+  "pi",
+  "sha512-INxVkLAVfAMju5MojJpmyu/0bMP+r+ffZuS7UqVv32E2JwHBRbcHfELDfmFNvapEbgYfKN2r9OYO1p3TqDBR+g==",
+  "https://registry.npmjs.org/@earendil-works/pi-coding-agent/-/pi-coding-agent-0.85.0.tgz"
+);
+
+// src/agent-catalog/agents/pi-agent.ts
+var ACP_PROBE_TIMEOUT_MILLISECONDS2 = 3e4;
+var PROMPT_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
-  acpProbeTimeoutMilliseconds = PI_ACP_PROBE_TIMEOUT_MILLISECONDS;
+  acpProbeTimeoutMilliseconds = ACP_PROBE_TIMEOUT_MILLISECONDS2;
   adapterEnvironmentVariable = "PI_ACP_PI_COMMAND";
   adapterOverrideVariable = "MOBIUS_PI_ACP_PATH";
   adapterPackageDefinition = PI_ACP_PACKAGE;
@@ -1041,11 +2032,16 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
     "bundle",
     "cli.js"
   ];
-  promptTimeoutMilliseconds = PI_PROMPT_TIMEOUT_MILLISECONDS;
-  resolveManagedAgent = async (stateDirectory, _platform) => await validateManagedNpmPackage(
-    join6(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
-    PI_AGENT_PACKAGE
-  );
+  promptTimeoutMilliseconds = PROMPT_TIMEOUT_MILLISECONDS;
+  resolveManagedAgent = async (stateDirectory, _platform, signal) => {
+    signal.throwIfAborted();
+    const executable = await validateManagedNpmPackage(
+      join9(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+      PI_AGENT_PACKAGE
+    );
+    signal.throwIfAborted();
+    return executable;
+  };
   verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
     const capabilities = initialized.agentCapabilities ?? {};
     if (capabilities.loadSession !== true) {
@@ -1055,7 +2051,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const session = await connection.agent.request(
-      methods2.agent.session.new,
+      methods.agent.session.new,
       {
         additionalDirectories: [],
         cwd: defaultWorkspace,
@@ -1070,7 +2066,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       );
     }
     const prompt = await connection.agent.request(
-      methods2.agent.session.prompt,
+      methods.agent.session.prompt,
       {
         prompt: [{ text: "/session", type: "text" }],
         sessionId: session.sessionId
@@ -1078,145 +2074,158 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
       { cancellationSignal: signal }
     );
     if (prompt.stopReason !== "end_turn") {
-      throw new AgentProbeError(
-        "acp_incompatible",
-        "Pi ACP adapter did not complete its conformance prompt"
-      );
-    }
-  };
-};
-function supportedLocalAgentSpecifications() {
-  return Object.freeze([
-    new CodexAgentSpecification(),
-    new ClaudeCodeAgentSpecification(),
-    new PiAgentSpecification()
-  ]);
-}
-var AgentDiscovery = class {
-  specification;
-  constructor(specification) {
-    this.specification = specification;
-  }
-};
-var AvailableAgent = class extends AgentDiscovery {
-  agent;
-  status = "ready";
-  constructor(specification, agent) {
-    super(specification);
-    this.agent = agent;
-  }
-};
-var UnavailableAgent = class extends AgentDiscovery {
-};
-var MissingAdapter = class extends UnavailableAgent {
-  code = "adapter_not_found";
-  message = "ACP adapter not found";
-  status = "missing_adapter";
-  constructor(specification) {
-    super(specification);
-  }
-};
-var MissingAgent = class extends UnavailableAgent {
-  code = "agent_not_found";
-  message = "Agent executable not found";
-  status = "missing_agent";
-  constructor(specification) {
-    super(specification);
-  }
-};
-var ProbeFailed = class extends UnavailableAgent {
-  code;
-  message;
-  status = "probe_failed";
-  constructor(specification, code, message) {
-    super(specification);
-    this.code = code;
-    this.message = message;
-  }
-};
-var IncompatibleAdapter = class extends UnavailableAgent {
-  code = "acp_incompatible";
-  message = "ACP adapter is incompatible";
-  status = "incompatible_adapter";
-  constructor(specification) {
-    super(specification);
-  }
-};
-var AuthenticationRequiredAgent = class extends UnavailableAgent {
-  code = "authentication_required";
-  message = "Agent authentication is required";
-  status = "authentication_required";
-  constructor(specification) {
-    super(specification);
-  }
-};
-var LocalAgentInventory = class {
-  available;
-  discoveries;
-  installable;
-  unavailable;
-  constructor(discoveries, grantedAgents = /* @__PURE__ */ new Set(), platform = process.platform, architecture = process.arch) {
-    const available = [];
-    const unavailable = [];
-    for (const discovery of discoveries) {
-      if (discovery instanceof AvailableAgent) {
-        available.push(discovery);
-      } else if (discovery instanceof UnavailableAgent) {
-        unavailable.push(discovery);
-      } else {
-        throw new Error("Unsupported Agent discovery outcome");
-      }
-    }
-    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(
-          discovery.specification.id,
-          discovery.specification.label,
-          !grantedAgents.has(discovery.specification.id)
-        )
-      )
-    );
-    this.unavailable = Object.freeze(unavailable);
-  }
-  readyAgents = () => this.available.map((discovery) => discovery.agent);
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Pi ACP adapter did not complete its conformance prompt"
+      );
+    }
+  };
 };
-var AgentProbeError = class extends Error {
+
+// src/agent-catalog/agents/supported-agent-specifications.ts
+function supportedLocalAgentSpecifications() {
+  return Object.freeze([
+    new CodexAgentSpecification(),
+    new ClaudeCodeAgentSpecification(),
+    new PiAgentSpecification(),
+    new DeepSeekHarnessAgentSpecification(),
+    new OpenCodeAgentSpecification()
+  ]);
+}
+
+// src/agent-catalog/acp-readiness-probe.ts
+import { spawn as spawn2 } from "node:child_process";
+import {
+  methods as methods3,
+  ndJsonStream,
+  PROTOCOL_VERSION,
+  RequestError
+} from "@agentclientprotocol/sdk";
+
+// src/acp/create-client.ts
+import {
+  client,
+  methods as methods2
+} from "@agentclientprotocol/sdk";
+var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
+  methods2.client.session.requestPermission,
+  async (context) => await handler.onPermission(context.params, context.signal)
+).onRequest(
+  methods2.client.elicitation.create,
+  async (context) => await handler.onElicitation(context.params, context.signal)
+).onNotification(methods2.client.session.update, async (context) => {
+  await handler.onUpdate(context.params);
+}).onNotification(methods2.client.elicitation.complete, async (context) => {
+  await handler.onElicitationComplete(context.params);
+});
+
+// src/agent-catalog/executable-discovery.ts
+import { isAbsolute as isAbsolute4, join as join11 } from "node:path";
+
+// src/agent-installation/managed-adapter-installer.ts
+import { join as join10 } from "node:path";
+var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
     super(message, options);
     this.code = code;
-    this.name = "AgentProbeError";
+    this.name = "ManagedAdapterInstallError";
   }
 };
-var DiscoveryAcpHandler = class {
-  onElicitation = (_request, _signal) => Promise.reject(new Error("ACP probe does not accept elicitations"));
-  onElicitationComplete = (_notification) => Promise.resolve();
-  onPermission = (_request, _signal) => Promise.reject(new Error("ACP probe does not grant permissions"));
-  onUpdate = (_notification) => Promise.resolve();
+function translateError(error61) {
+  if (error61 instanceof ManagedAdapterInstallError) {
+    return error61;
+  }
+  if (error61 instanceof ManagedNpmPackageError) {
+    if (error61.code === "package_manager_not_found") {
+      return new ManagedAdapterInstallError(
+        error61.code,
+        "A supported npm executable is required to install the ACP adapter",
+        { cause: error61 }
+      );
+    }
+    if (error61.code === "managed_package_verification_failed") {
+      return new ManagedAdapterInstallError(
+        "adapter_verification_failed",
+        "The managed adapter did not match its pinned artifact",
+        { cause: error61 }
+      );
+    }
+    if (error61.code === "managed_package_publish_failed") {
+      return new ManagedAdapterInstallError(
+        "adapter_publish_failed",
+        "The managed adapter could not be published",
+        { cause: error61 }
+      );
+    }
+  }
+  return new ManagedAdapterInstallError(
+    "adapter_install_failed",
+    "The pinned ACP adapter could not be installed",
+    { cause: error61 }
+  );
+}
+async function validateManagedAdapter(root, specification) {
+  try {
+    return await validateManagedNpmPackage(
+      root,
+      specification.adapterPackageDefinition
+    );
+  } catch (error61) {
+    throw translateError(error61);
+  }
+}
+var ManagedAdapterInstaller = class {
+  #environment;
+  #npmInstaller;
+  #stateDirectory;
+  constructor(options, npmInstaller = new ManagedNpmPackageInstaller()) {
+    this.#environment = options.environment;
+    this.#npmInstaller = npmInstaller;
+    this.#stateDirectory = options.stateDirectory;
+  }
+  install = async (specification, signal) => {
+    const root = join10(
+      this.#stateDirectory,
+      "adapters",
+      specification.id,
+      specification.adapterVersion
+    );
+    try {
+      return await this.#npmInstaller.install(
+        root,
+        specification.adapterPackageDefinition,
+        this.#environment,
+        signal
+      );
+    } catch (error61) {
+      if (signal.aborted) {
+        signal.throwIfAborted();
+      }
+      throw translateError(error61);
+    }
+  };
 };
-async function resolveManagedExecutable(specification, options) {
+
+// src/agent-catalog/executable-discovery.ts
+async function resolveManagedExecutable(specification, context) {
   try {
     return await specification.resolveManagedAgent(
-      readStateDirectory(options.environment),
-      options.platform ?? process.platform
+      readStateDirectory(context.environment),
+      context.platform ?? process.platform,
+      context.signal
     );
   } catch {
+    context.signal.throwIfAborted();
     return null;
   }
 }
-async function resolveManagedAdapterExecutable(specification, options) {
+async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join6(
-        readStateDirectory(options.environment),
+      join11(
+        readStateDirectory(context.environment),
         "adapters",
         specification.id,
         specification.adapterVersion
@@ -1228,19 +2237,19 @@ async function resolveManagedAdapterExecutable(specification, options) {
   }
   return managed;
 }
-async function resolveSpecificationExecutables(executableName, overrideVariable, resolveManaged, options) {
-  const override = options.environment[overrideVariable];
+async function resolveSpecificationExecutables(executableName, overrideVariable, resolveManaged, context) {
+  const override = context.environment[overrideVariable];
   if (override !== void 0) {
-    if (override.length === 0 || !isAbsolute2(override)) {
+    if (override.length === 0 || !isAbsolute4(override)) {
       return [];
     }
-    const executable = await resolveExecutablePath(override, options.platform);
+    const executable = await resolveExecutablePath(override, context.platform);
     return executable === null ? [] : [executable];
   }
   const external = await findExecutableOnPath(
     executableName,
-    options.environment,
-    options.platform
+    context.environment,
+    context.platform
   );
   const managed = await resolveManaged();
   if (external === null) {
@@ -1251,41 +2260,47 @@ async function resolveSpecificationExecutables(executableName, overrideVariable,
   }
   return [external, managed];
 }
-async function resolveAgentExecutables(specification, options) {
+async function resolveAgentExecutables(specification, context) {
   return await resolveSpecificationExecutables(
     specification.agentExecutable,
     specification.agentOverrideVariable,
-    async () => await resolveManagedExecutable(specification, options),
-    options
+    async () => await resolveManagedExecutable(specification, context),
+    context
   );
 }
-async function resolveAdapterExecutables(specification, options) {
+async function resolveAdapterExecutables(specification, context) {
+  if (specification instanceof DirectAcpAgentDefinition) {
+    return await resolveAgentExecutables(specification, context);
+  }
+  if (!(specification instanceof BridgedAcpAgentDefinition)) {
+    throw new Error("Unsupported local Agent execution topology");
+  }
   return await resolveSpecificationExecutables(
     specification.adapterExecutable,
     specification.adapterOverrideVariable,
-    async () => await resolveManagedAdapterExecutable(specification, options),
-    options
+    async () => await resolveManagedAdapterExecutable(specification, context),
+    context
   );
 }
-async function resolveAgentExecutable(specification, options) {
-  const executables = await resolveAgentExecutables(specification, options);
+async function resolveAgentExecutable(specification, context) {
+  const executables = await resolveAgentExecutables(specification, context);
   return executables[0] ?? null;
 }
-async function resolveAdapterExecutable(specification, options) {
-  const executables = await resolveAdapterExecutables(specification, options);
+async function resolveAdapterExecutable(specification, context) {
+  const executables = await resolveAdapterExecutables(specification, context);
   return executables[0] ?? null;
 }
 function normalizedVersion(output2) {
   return output2.trim().split(/\r?\n/, 1)[0]?.trim().slice(0, 128) ?? "";
 }
-async function probeVersion(executable, arguments_, environment, defaultWorkspace, signal) {
+async function probeVersion(executable, arguments_, environment, defaultWorkspace, signal, timeoutMilliseconds) {
   const result = await runBoundedProcess({
     arguments: arguments_,
     command: executable.path,
     cwd: defaultWorkspace,
     environment,
     signal,
-    timeoutMilliseconds: VERSION_PROBE_TIMEOUT_MILLISECONDS
+    timeoutMilliseconds
   });
   const version2 = normalizedVersion(result.stdout || result.stderr);
   if (version2.length === 0) {
@@ -1304,63 +2319,73 @@ var VerifiedAgentExecutable = class {
     this.version = version2;
   }
 };
-async function findVerifiedAgentExecutable(specification, options) {
-  const executables = await resolveAgentExecutables(specification, options);
+async function findVerifiedAgentExecutable(specification, context) {
+  const executables = await resolveAgentExecutables(specification, context);
   for (const executable of executables) {
     try {
       const version2 = await probeVersion(
         executable,
         specification.agentVersionArguments,
-        options.environment,
-        options.defaultWorkspace,
-        options.signal
+        context.environment,
+        context.defaultWorkspace,
+        context.signal,
+        specification.versionProbeTimeoutMilliseconds
       );
       return new VerifiedAgentExecutable(executable, version2);
     } catch {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
+      if (context.signal.aborted) {
+        context.signal.throwIfAborted();
       }
     }
   }
   return null;
 }
+
+// src/agent-catalog/acp-readiness-probe.ts
+var ACP_OUTPUT_LIMIT_BYTES = 1024 * 1024;
+var DiscoveryAcpHandler = class {
+  onElicitation = (_request, _signal) => Promise.reject(new Error("ACP probe does not accept elicitations"));
+  onElicitationComplete = (_notification) => Promise.resolve();
+  onPermission = (_request, _signal) => Promise.reject(new Error("ACP probe does not grant permissions"));
+  onUpdate = (_notification) => Promise.resolve();
+};
 function readableAcpStream(input2) {
   let byteLength = 0;
-  let open6 = true;
+  let open7 = true;
   return new ReadableStream({
     start(controller) {
       input2.on("data", (chunk) => {
-        if (!open6) {
+        if (!open7) {
           return;
         }
         if (!(chunk instanceof Uint8Array)) {
-          open6 = false;
+          open7 = false;
           controller.error(new Error("ACP adapter produced invalid output"));
           return;
         }
         byteLength += chunk.byteLength;
         if (byteLength > ACP_OUTPUT_LIMIT_BYTES) {
-          open6 = false;
+          open7 = false;
           controller.error(new Error("ACP adapter output limit exceeded"));
           return;
         }
         controller.enqueue(new Uint8Array(chunk));
       });
       input2.once("end", () => {
-        if (open6) {
-          open6 = false;
+        if (open7) {
+          open7 = false;
           controller.close();
         }
       });
       input2.once("error", (error61) => {
-        if (open6) {
-          open6 = false;
+        if (open7) {
+          open7 = false;
           controller.error(error61);
         }
       });
     },
     cancel() {
-      open6 = false;
+      open7 = false;
     }
   });
 }
@@ -1379,7 +2404,7 @@ function writableAcpStream(output2) {
     }
   });
 }
-async function probeAcp(specification, agent, environment, defaultWorkspace, signal) {
+async function probeAcpReadiness(specification, agent, environment, defaultWorkspace, signal) {
   signal.throwIfAborted();
   const controller = new AbortController();
   let timedOut = false;
@@ -1423,13 +2448,13 @@ async function probeAcp(specification, agent, environment, defaultWorkspace, sig
     }
   };
   stderr.on("data", consumeStderr);
-  const connection = createAcpClient(new DiscoveryAcpHandler()).connect(
-    ndJsonStream(writableAcpStream(stdin), readableAcpStream(stdout))
-  );
+  const connection = createAcpClient(
+    new DiscoveryAcpHandler()
+  ).connect(ndJsonStream(writableAcpStream(stdin), readableAcpStream(stdout)));
   try {
     const initialized = await Promise.race([
       connection.agent.request(
-        methods2.agent.initialize,
+        methods3.agent.initialize,
         {
           clientCapabilities: {},
           clientInfo: { name: "mobius", version: "0.0.3" },
@@ -1487,6 +2512,8 @@ async function probeAcp(specification, agent, environment, defaultWorkspace, sig
     await stopProcessTree(child);
   }
 }
+
+// src/agent-catalog/discover-agent.ts
 function probeFailure(specification, executableKind, error61) {
   if (error61 instanceof AgentProbeError) {
     if (error61.code === "authentication_required") {
@@ -1508,12 +2535,15 @@ function probeFailure(specification, executableKind, error61) {
     `${executableKind === "agent" ? "Agent" : "Adapter"} probe failed`
   );
 }
-async function discoverSpecification(specification, options) {
-  options.signal.throwIfAborted();
+async function discoverAgent(specification, context) {
+  context.signal.throwIfAborted();
   const [adapters, agents] = await Promise.all([
-    resolveAdapterExecutables(specification, options),
-    resolveAgentExecutables(specification, options)
+    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);
   }
@@ -1527,35 +2557,45 @@ async function discoverSpecification(specification, options) {
       agentVersion = await probeVersion(
         agent,
         specification.agentVersionArguments,
-        options.environment,
-        options.defaultWorkspace,
-        options.signal
+        context.environment,
+        context.defaultWorkspace,
+        context.signal,
+        specification.versionProbeTimeoutMilliseconds
       );
     } catch (error61) {
-      if (options.signal.aborted) {
-        options.signal.throwIfAborted();
+      if (context.signal.aborted) {
+        context.signal.throwIfAborted();
       }
       lastFailure = probeFailure(specification, "agent", error61);
       continue;
     }
     for (const adapter of adapters) {
+      if (specification instanceof DirectAcpAgentDefinition && adapter.path !== agent.path) {
+        continue;
+      }
       let adapterVersion = "";
+      let launchEnvironment;
       try {
+        launchEnvironment = await specification.createLaunchEnvironment(
+          agent,
+          context
+        );
         if (specification.adapterVersionArguments.length > 0) {
           adapterVersion = await probeVersion(
             adapter,
             specification.adapterVersionArguments,
             {
-              ...options.environment,
-              [specification.adapterEnvironmentVariable]: agent.path
+              ...context.environment,
+              ...launchEnvironment
             },
-            options.defaultWorkspace,
-            options.signal
+            context.defaultWorkspace,
+            context.signal,
+            specification.versionProbeTimeoutMilliseconds
           );
         }
       } catch (error61) {
-        if (options.signal.aborted) {
-          options.signal.throwIfAborted();
+        if (context.signal.aborted) {
+          context.signal.throwIfAborted();
         }
         lastFailure = probeFailure(specification, "adapter", error61);
         continue;
@@ -1564,8 +2604,8 @@ async function discoverSpecification(specification, options) {
         specification.id,
         specification.label,
         adapter.path,
-        [],
-        { [specification.adapterEnvironmentVariable]: agent.path },
+        specification.launchArguments,
+        launchEnvironment,
         adapterVersion,
         agentVersion,
         adapter.identity,
@@ -1573,12 +2613,12 @@ async function discoverSpecification(specification, options) {
         specification.promptTimeoutMilliseconds
       );
       try {
-        const acpVersion = await probeAcp(
+        const acpVersion = await probeAcpReadiness(
           specification,
           definition,
-          options.environment,
-          options.defaultWorkspace,
-          options.signal
+          context.environment,
+          context.defaultWorkspace,
+          context.signal
         );
         const verifiedAdapterVersion = adapterVersion.length > 0 ? adapterVersion : acpVersion;
         if (verifiedAdapterVersion.length === 0) {
@@ -1593,8 +2633,8 @@ async function discoverSpecification(specification, options) {
             specification.id,
             specification.label,
             adapter.path,
-            [],
-            { [specification.adapterEnvironmentVariable]: agent.path },
+            specification.launchArguments,
+            launchEnvironment,
             verifiedAdapterVersion,
             agentVersion,
             adapter.identity,
@@ -1603,20 +2643,26 @@ async function discoverSpecification(specification, options) {
           )
         );
       } catch (error61) {
-        if (options.signal.aborted) {
-          options.signal.throwIfAborted();
+        if (context.signal.aborted) {
+          context.signal.throwIfAborted();
         }
-        lastFailure = probeFailure(specification, "adapter", error61);
+        const failure = probeFailure(specification, "adapter", error61);
+        if (failure instanceof AuthenticationRequiredAgent) {
+          return failure;
+        }
+        lastFailure = failure;
       }
     }
   }
   return lastFailure ?? new IncompatibleAdapter(specification);
 }
+
+// src/agent-catalog/discover-local-agents.ts
 async function discoverLocalAgentInventory(options) {
   const specifications = options.specifications ?? supportedLocalAgentSpecifications();
   const discoveries = await Promise.all(
     specifications.map(
-      async (specification) => await discoverSpecification(specification, options)
+      async (specification) => await discoverAgent(specification, options)
     )
   );
   let grantedAgents = /* @__PURE__ */ new Set();
@@ -1634,89 +2680,14 @@ async function discoverLocalAgentInventory(options) {
   );
 }
 
-// src/agent-catalog/agent-diagnostics.ts
-var AvailableAgentDiagnostic = class {
-  adapterVersion;
-  agentVersion;
-  id;
-  label;
-  status = "ready";
-  constructor(discovery) {
-    this.adapterVersion = discovery.agent.adapterVersion;
-    this.agentVersion = discovery.agent.agentVersion;
-    this.id = discovery.specification.id;
-    this.label = discovery.specification.label;
-  }
-};
-var UnavailableAgentDiagnostic = class {
-  code;
-  id;
-  label;
-  message;
-  recoveryCommand;
-  status;
-  constructor(discovery) {
-    this.code = discovery.code;
-    this.id = discovery.specification.id;
-    this.label = discovery.specification.label;
-    this.message = discovery.message;
-    this.recoveryCommand = discovery instanceof MissingAdapter ? discovery.specification.recoveryCommand() : discovery.code === "authentication_required" ? discovery.specification.authenticationCommand() : "";
-    this.status = discovery.status;
-  }
-};
-var AgentDiagnostics = class {
-  available;
-  unavailable;
-  constructor(inventory) {
-    this.available = inventory.available.map(
-      (discovery) => new AvailableAgentDiagnostic(discovery)
-    );
-    this.unavailable = inventory.unavailable.map(
-      (discovery) => new UnavailableAgentDiagnostic(discovery)
-    );
-  }
-};
-function humanLine(label, status, detail) {
-  return `${label.padEnd(13)} ${status.padEnd(17)} ${detail}`.trimEnd();
-}
-function formatAgentDiagnostics(inventory, json2) {
-  const diagnostics = new AgentDiagnostics(inventory);
-  if (json2) {
-    return `${JSON.stringify(diagnostics, null, 2)}
-`;
-  }
-  const lines = [];
-  for (const available of diagnostics.available) {
-    lines.push(
-      humanLine(
-        available.label,
-        available.status,
-        `${available.agentVersion}   ${available.adapterVersion}`
-      )
-    );
-  }
-  for (const unavailable of diagnostics.unavailable) {
-    lines.push(
-      humanLine(unavailable.label, unavailable.status, unavailable.message)
-    );
-    if (unavailable.recoveryCommand.length > 0) {
-      lines.push(
-        unavailable.code === "authentication_required" ? `  Authenticate locally: ${unavailable.recoveryCommand}` : `  Install adapter: ${unavailable.recoveryCommand}`
-      );
-    }
-  }
-  return `${lines.join("\n")}
-`;
-}
-
 // src/audit/audit-store.ts
 import { mkdirSync } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { dirname as dirname3 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 var AuditStore = class {
   database;
   constructor(path2) {
-    mkdirSync(dirname2(path2), { recursive: true });
+    mkdirSync(dirname3(path2), { recursive: true });
     this.database = new DatabaseSync(path2);
     this.database.exec(`
       CREATE TABLE IF NOT EXISTS audit_events (
@@ -1760,10 +2731,10 @@ var AuditStore = class {
 };
 
 // src/config.ts
-import { join as join7 } from "node:path";
+import { join as join12 } from "node:path";
 function loadDefaultWorkspace() {
   const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = process.env;
-  return configuredWorkspace ?? join7(readStateDirectory(), "workspace");
+  return configuredWorkspace ?? join12(readStateDirectory(), "workspace");
 }
 function createDaemonConfig(connection, agents = [], installableAgents = []) {
   return {
@@ -1781,22 +2752,16 @@ function createDaemonConfig(connection, agents = [], installableAgents = []) {
 // src/pairing/pair-local-machine.ts
 import { randomUUID } from "node:crypto";
 import {
-  mkdir as mkdir2,
-  open as open3,
-  realpath as realpath3,
-  rename as rename2,
-  stat as stat3,
-  writeFile
+  mkdir as mkdir3,
+  open as open5,
+  realpath as realpath5,
+  rename as rename3,
+  stat as stat5,
+  writeFile as writeFile2
 } from "node:fs/promises";
 import { hostname } from "node:os";
-import { basename, join as join8, resolve as resolve3 } from "node:path";
-import { fetch } from "undici";
-
-// src/network/environment-proxy.ts
-import { EnvHttpProxyAgent } from "undici";
-var environmentProxyDispatcher = new EnvHttpProxyAgent();
-
-// src/pairing/pair-local-machine.ts
+import { basename, join as join13, resolve as resolve3 } from "node:path";
+import { fetch as fetch2 } from "undici";
 var PAIRING_TIMEOUT_MILLISECONDS = 2e4;
 var PAIRING_CODE_PATTERN = /^[A-HJ-NP-Z2-9]{4}(?:-[A-HJ-NP-Z2-9]{4}){4}$/;
 var IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
@@ -1821,7 +2786,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -1934,9 +2899,9 @@ function parseChannelArgument(arguments_) {
 async function resolveDefaultWorkspace(path2) {
   const requestedWorkspace = resolve3(path2);
   try {
-    await mkdir2(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath3(requestedWorkspace);
-    const metadata = await stat3(defaultWorkspace);
+    await mkdir3(requestedWorkspace, { recursive: true, mode: 448 });
+    const defaultWorkspace = await realpath5(requestedWorkspace);
+    const metadata = await stat5(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError(
         "invalid_workspace",
@@ -1974,9 +2939,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord3(value)) {
+  if (isRecord4(value)) {
     const error61 = value["error"];
-    if (isRecord3(error61)) {
+    if (isRecord4(error61)) {
       const code = error61["code"];
       const message = error61["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -1990,7 +2955,7 @@ function readRelayError(value) {
   );
 }
 function decodeClaimResponse(value) {
-  if (!isRecord3(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+  if (!isRecord4(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
     throw new PairingClientError(
       "invalid_relay_response",
       "The relay returned an invalid pairing response"
@@ -2012,10 +2977,10 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
     id: agent.id,
     label: agent.label
   }));
-  const endpoint = new URL("/api/pairings/claim", options.relayOrigin);
+  const endpoint = new URL("/mobius/api/pairings/claim", options.relayOrigin);
   let response;
   try {
-    response = await fetch(endpoint, {
+    response = await fetch2(endpoint, {
       body: JSON.stringify({
         agents,
         installableAgents: installableAgents.map((agent) => ({
@@ -2049,14 +3014,14 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   return decodeClaimResponse(value);
 }
 async function persistConnection(channelId, relayOrigin, daemonToken, defaultWorkspace) {
-  const connectionsDirectory = join8(readStateDirectory(), "connections");
-  await mkdir2(connectionsDirectory, { mode: 448, recursive: true });
-  const connectionPath = join8(connectionsDirectory, `${channelId}.json`);
-  const temporaryPath = join8(
+  const connectionsDirectory = join13(readStateDirectory(), "connections");
+  await mkdir3(connectionsDirectory, { mode: 448, recursive: true });
+  const connectionPath = join13(connectionsDirectory, `${channelId}.json`);
+  const temporaryPath = join13(
     connectionsDirectory,
     `.${channelId}.${randomUUID()}.tmp`
   );
-  await writeFile(
+  await writeFile2(
     temporaryPath,
     `${JSON.stringify(
       {
@@ -2071,11 +3036,11 @@ async function persistConnection(channelId, relayOrigin, daemonToken, defaultWor
 `,
     { flag: "wx", mode: 384 }
   );
-  await rename2(temporaryPath, connectionPath);
+  await rename3(temporaryPath, connectionPath);
   return connectionPath;
 }
 function decodeSavedConnection(value, expectedChannelId) {
-  if (!isRecord3(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+  if (!isRecord4(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
     throw new PairingClientError(
       "invalid_connection",
       "The saved connection is invalid"
@@ -2099,13 +3064,13 @@ function decodeSavedConnection(value, expectedChannelId) {
   };
 }
 async function readSavedConnection(channelId) {
-  const connectionPath = join8(
+  const connectionPath = join13(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
   );
   let encoded = "";
-  const handle = await open3(connectionPath, "r");
+  const handle = await open5(connectionPath, "r");
   try {
     const metadata = await handle.stat();
     if (!metadata.isFile() || metadata.size > MAX_CONNECTION_FILE_LENGTH) {
@@ -2149,12 +3114,12 @@ function assertInventoryUsable(inventory) {
 function buildPairedDaemon(connection, connectionPath, inventory) {
   assertInventoryUsable(inventory);
   const relayUrl = new URL(
-    `/api/channels/${encodeURIComponent(connection.channelId)}/daemon`,
+    `/mobius/api/channels/${encodeURIComponent(connection.channelId)}/daemon`,
     connection.relayOrigin
   );
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.daemonToken);
-  const auditDatabasePath = join8(
+  const auditDatabasePath = join13(
     readStateDirectory(),
     "audit",
     `${connection.channelId}.sqlite`
@@ -2213,7 +3178,7 @@ async function pairLocalMachine(arguments_, signal = new AbortController().signa
 }
 async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
   const channelId = parseChannelArgument(arguments_);
-  const connectionPath = join8(
+  const connectionPath = join13(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
@@ -2229,6 +3194,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";
 
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -7248,7 +8214,7 @@ function bucketFor(state, inst) {
   return bucket;
 }
 var handoff;
-var open4 = [];
+var open6 = [];
 var memo = {
   alloc(_inst, payload, empty) {
     const bucket = handoff;
@@ -7257,7 +8223,7 @@ var memo = {
     handoff = void 0;
     const entry = { value: empty, issues: null };
     bucket.set(payload.value, entry);
-    open4.push(entry);
+    open6.push(entry);
     return empty;
   },
   guard(inst) {
@@ -7323,10 +8289,10 @@ var memo = {
           return payload;
         }
         handoff = bucket;
-        const depth = open4.length;
+        const depth = open6.length;
         const result = base(payload, ctx);
         handoff = void 0;
-        const entry = open4.length > depth ? open4.pop() : void 0;
+        const entry = open6.length > depth ? open6.pop() : void 0;
         if (result instanceof Promise) {
           return result.then((r) => {
             if (entry)
@@ -21615,7 +22581,7 @@ var ProtocolMessageError = class extends Error {
     this.name = "ProtocolMessageError";
   }
 };
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseJson2(encoded) {
@@ -21627,7 +22593,7 @@ function parseJson2(encoded) {
       cause: error61
     });
   }
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     throw new ProtocolMessageError("Message must be a JSON object");
   }
   return value;
@@ -21711,7 +22677,7 @@ function readActivityContent(value) {
 }
 function readActivityDetail(value) {
   const field = value["detail"];
-  if (!isRecord4(field)) {
+  if (!isRecord5(field)) {
     throw new ProtocolMessageError("Invalid activity detail field");
   }
   const kind = readString(field, "kind", 32);
@@ -22002,7 +22968,10 @@ var sessionHistorySchema = external_exports.discriminatedUnion("status", [
     status: external_exports.literal("available"),
     messages: external_exports.array(historyMessage).max(SESSION_HISTORY_MESSAGE_LIMIT).readonly(),
     truncated: external_exports.boolean(),
-    coveredCommandIds: external_exports.array(external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/)).max(1e4).readonly()
+    coveredCommandIds: external_exports.array(external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/)).max(1e4).readonly(),
+    coveredMessageIds: external_exports.array(
+      external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}:(?:user|agent)$/)
+    ).max(2e4).readonly().default([])
   }).readonly(),
   external_exports.strictObject({ status: external_exports.literal("unavailable") }).readonly()
 ]).refine(
@@ -22676,14 +23645,15 @@ import { WebSocket as WebSocket2 } from "undici";
 // src/acp/session-manager.ts
 import { spawn as spawn3 } from "node:child_process";
 import {
-  methods as methods3,
+  methods as methods4,
   ndJsonStream as ndJsonStream2,
-  PROTOCOL_VERSION as PROTOCOL_VERSION2
+  PROTOCOL_VERSION as PROTOCOL_VERSION2,
+  RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
 
 // src/acp/activity.ts
 var TRUNCATION_MARKER = "\n\u2026 output truncated by Mobius";
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var AcpActivity = class _AcpActivity {
@@ -22957,7 +23927,7 @@ function contentPhase(content) {
     return "";
   }
   const codex = metadata["codex"];
-  if (!isRecord5(codex)) {
+  if (!isRecord6(codex)) {
     return "";
   }
   const phase = codex["phase"];
@@ -23252,13 +24222,14 @@ var AcpHistoryReplay = class {
     status: "available",
     messages: [...this.#messages],
     truncated: this.#truncated,
-    coveredCommandIds: []
+    coveredCommandIds: [],
+    coveredMessageIds: []
   });
 };
 
 // src/acp/session-store.ts
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 var AcpStoredSession = class {
   additionalDirectories;
@@ -23361,7 +24332,7 @@ var MemoryAcpSessionStore = class {
 var SqliteAcpSessionStore = class {
   #database;
   constructor(path2) {
-    mkdirSync2(dirname3(path2), { recursive: true });
+    mkdirSync2(dirname4(path2), { recursive: true });
     this.#database = new DatabaseSync2(path2);
     this.#database.exec(`
       CREATE TABLE IF NOT EXISTS acp_deleted_sessions (session_id TEXT PRIMARY KEY) STRICT;
@@ -23468,6 +24439,8 @@ var SqliteAcpSessionStore = class {
 
 // src/acp/session-manager.ts
 var PROCESS_STOP_TIMEOUT_MILLISECONDS = 1e3;
+var MAX_PRE_SESSION_UPDATES = 100;
+var MAX_PRE_SESSION_UPDATE_BYTES = 1024 * 1024;
 var SESSION_CONTROL_COMMAND_ID = "session-control";
 var NullAcpSessionObserver = class {
   onCommands = () => Promise.resolve();
@@ -23588,7 +24561,7 @@ function createWritableAcpStream(output2) {
 function truncate2(value, maximumLength) {
   return value.length <= maximumLength ? value : `${value.slice(0, Math.max(0, maximumLength - 1))}\u2026`;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString3(value, fallback = "") {
@@ -23618,7 +24591,7 @@ function normalizeConfigValues(value) {
   }
   const normalized = [];
   for (const entry of value) {
-    if (!isRecord6(entry)) {
+    if (!isRecord7(entry)) {
       continue;
     }
     const groupedOptions = entry["options"];
@@ -23626,7 +24599,7 @@ function normalizeConfigValues(value) {
       const groupId = readString3(entry["group"]);
       const groupName = readString3(entry["name"]);
       for (const groupedOption of groupedOptions) {
-        if (isRecord6(groupedOption)) {
+        if (isRecord7(groupedOption)) {
           normalized.push(
             normalizeConfigValue(groupedOption, groupId, groupName)
           );
@@ -23642,7 +24615,7 @@ function normalizeConfigOptions(value, modes) {
   const normalized = [];
   if (Array.isArray(value)) {
     for (const option of value) {
-      if (!isRecord6(option)) {
+      if (!isRecord7(option)) {
         continue;
       }
       const id = truncate2(readString3(option["id"]), 128);
@@ -23681,12 +24654,12 @@ function normalizeConfigOptions(value, modes) {
       }
     }
   }
-  if (isRecord6(modes)) {
+  if (isRecord7(modes)) {
     const values = [];
     const availableModes = modes["availableModes"];
     if (Array.isArray(availableModes)) {
       for (const mode of availableModes) {
-        if (!isRecord6(mode)) {
+        if (!isRecord7(mode)) {
           continue;
         }
         const id = truncate2(readString3(mode["id"]), 500);
@@ -23764,7 +24737,7 @@ function normalizeElicitationOptions(schema) {
   const oneOf = schema["oneOf"];
   if (Array.isArray(oneOf)) {
     for (const option of oneOf) {
-      if (isRecord6(option) && typeof option["const"] === "string") {
+      if (isRecord7(option) && typeof option["const"] === "string") {
         normalized.push({
           description: truncate2(readString3(option["description"]), 500),
           label: truncate2(readString3(option["title"], option["const"]), 255),
@@ -23784,7 +24757,7 @@ function normalizeElicitationOptions(schema) {
     return normalized.slice(0, 200);
   }
   const items = schema["items"];
-  if (!isRecord6(items)) {
+  if (!isRecord7(items)) {
     return normalized;
   }
   const anyOf = items["anyOf"];
@@ -23797,7 +24770,7 @@ function numericString(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toString() : "";
 }
 function normalizeElicitationFields(requestedSchema) {
-  if (!isRecord6(requestedSchema) || !isRecord6(requestedSchema["properties"])) {
+  if (!isRecord7(requestedSchema) || !isRecord7(requestedSchema["properties"])) {
     return [];
   }
   const properties = requestedSchema["properties"];
@@ -23807,7 +24780,7 @@ function normalizeElicitationFields(requestedSchema) {
   );
   const normalized = [];
   for (const [name, property] of Object.entries(properties)) {
-    if (!isRecord6(property)) {
+    if (!isRecord7(property)) {
       continue;
     }
     const type = elicitationFieldType(property["type"]);
@@ -23902,7 +24875,7 @@ function validateElicitationContent(encoded, requestedSchema) {
       "invalid_elicitation_response"
     );
   }
-  if (!isRecord6(decoded) || !isRecord6(requestedSchema) || !isRecord6(requestedSchema["properties"])) {
+  if (!isRecord7(decoded) || !isRecord7(requestedSchema) || !isRecord7(requestedSchema["properties"])) {
     throw new AcpExecutionError(
       "Elicitation response does not match the requested form",
       {},
@@ -23926,7 +24899,7 @@ function validateElicitationContent(encoded, requestedSchema) {
   const validated = {};
   for (const [name, value] of Object.entries(decoded)) {
     const property = properties[name];
-    if (!isRecord6(property)) {
+    if (!isRecord7(property)) {
       throw new AcpExecutionError(
         `Elicitation field ${name} was not requested`,
         {},
@@ -24076,8 +25049,11 @@ var AcpProcessSession = class _AcpProcessSession {
   #mobiusSessionId;
   #pendingElicitations = /* @__PURE__ */ new Map();
   #pendingPermissions = /* @__PURE__ */ new Map();
+  #preSessionUpdates = [];
   #processExit;
   #store;
+  #verifiedAgentVersion;
+  #preSessionUpdateBytes = 0;
   #agentName = "";
   #agentVersion = "";
   #capabilities = {
@@ -24111,6 +25087,7 @@ var AcpProcessSession = class _AcpProcessSession {
     this.#getObserver = getObserver;
     this.#mobiusSessionId = mobiusSessionId;
     this.#store = store;
+    this.#verifiedAgentVersion = agent.agentVersion;
     this.#child = spawn3(agent.adapterPath, [...agent.arguments], {
       cwd,
       detached: process.platform !== "win32",
@@ -24213,7 +25190,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       await this.race(
         this.#connection.agent.request(
-          methods3.agent.session.load,
+          methods4.agent.session.load,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -24235,7 +25212,7 @@ var AcpProcessSession = class _AcpProcessSession {
   async #initializeAgent(signal) {
     const initialized = await this.race(
       this.#connection.agent.request(
-        methods3.agent.initialize,
+        methods4.agent.initialize,
         {
           clientCapabilities: {
             elicitation: { form: {}, url: {} },
@@ -24266,7 +25243,10 @@ var AcpProcessSession = class _AcpProcessSession {
       initialized.agentInfo?.title ?? initialized.agentInfo?.name ?? this.#agentId,
       255
     );
-    this.#agentVersion = truncate2(initialized.agentInfo?.version ?? "", 128);
+    this.#agentVersion = truncate2(
+      this.#verifiedAgentVersion.length > 0 ? this.#verifiedAgentVersion : initialized.agentInfo?.version ?? "",
+      128
+    );
   }
   initialize = async (signal, origin) => {
     await this.#initializeAgent(signal);
@@ -24300,7 +25280,7 @@ var AcpProcessSession = class _AcpProcessSession {
         );
       const forked = await this.race(
         this.#connection.agent.request(
-          methods3.agent.session.fork,
+          methods4.agent.session.fork,
           {
             sessionId: nativeSessionIdSchema.parse(origin.nativeSessionId),
             cwd: this.#cwd,
@@ -24312,7 +25292,7 @@ var AcpProcessSession = class _AcpProcessSession {
         "ACP agent exited while forking a session",
         signal
       );
-      this.#nativeSessionId = nativeSessionIdSchema.parse(forked.sessionId);
+      this.selectNativeSession(forked.sessionId);
       if (this.#nativeSessionId === origin.nativeSessionId || this.#store.findNative(this.#agentId, this.#nativeSessionId).length > 0) {
         throw new AcpExecutionError(
           "The Agent did not create an independent fork",
@@ -24327,13 +25307,13 @@ var AcpProcessSession = class _AcpProcessSession {
       stored.session.additionalDirectories,
       this.#additionalDirectories
     )) {
-      this.#nativeSessionId = stored.session.nativeSessionId;
+      this.selectNativeSession(stored.session.nativeSessionId);
       this.#prompted = stored.session.prompted;
       this.#restored = true;
       if (this.#capabilities.resumeSession) {
         lifecycleResponse = await this.race(
           this.#connection.agent.request(
-            methods3.agent.session.resume,
+            methods4.agent.session.resume,
             {
               additionalDirectories: [...this.#additionalDirectories],
               cwd: this.#cwd,
@@ -24350,7 +25330,7 @@ var AcpProcessSession = class _AcpProcessSession {
         try {
           lifecycleResponse = await this.race(
             this.#connection.agent.request(
-              methods3.agent.session.load,
+              methods4.agent.session.load,
               {
                 additionalDirectories: [...this.#additionalDirectories],
                 cwd: this.#cwd,
@@ -24386,7 +25366,7 @@ var AcpProcessSession = class _AcpProcessSession {
       }
       const created = await this.race(
         this.#connection.agent.request(
-          methods3.agent.session.new,
+          methods4.agent.session.new,
           {
             additionalDirectories: [...this.#additionalDirectories],
             cwd: this.#cwd,
@@ -24397,10 +25377,10 @@ var AcpProcessSession = class _AcpProcessSession {
         "ACP agent exited while starting a session",
         signal
       );
-      this.#nativeSessionId = created.sessionId;
+      this.selectNativeSession(created.sessionId);
       lifecycleResponse = created;
     }
-    const lifecycleRecord = isRecord6(lifecycleResponse) ? lifecycleResponse : {};
+    const lifecycleRecord = isRecord7(lifecycleResponse) ? lifecycleResponse : {};
     this.#configOptions = normalizeConfigOptions(
       lifecycleRecord["configOptions"],
       lifecycleRecord["modes"]
@@ -24429,7 +25409,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     const response = await this.race(
       this.#connection.agent.request(
-        methods3.agent.session.list,
+        methods4.agent.session.list,
         cursor === null ? {} : { cursor },
         { cancellationSignal: signal }
       ),
@@ -24454,7 +25434,7 @@ var AcpProcessSession = class _AcpProcessSession {
       );
     await this.race(
       this.#connection.agent.request(
-        methods3.agent.session.delete,
+        methods4.agent.session.delete,
         { sessionId: nativeSessionIdSchema.parse(nativeSessionId) },
         { cancellationSignal: signal }
       ),
@@ -24485,7 +25465,7 @@ var AcpProcessSession = class _AcpProcessSession {
       if (existing.category === "mode") {
         await this.race(
           this.#connection.agent.request(
-            methods3.agent.session.setMode,
+            methods4.agent.session.setMode,
             { modeId: options.value, sessionId: this.#nativeSessionId },
             { cancellationSignal: options.signal }
           ),
@@ -24498,7 +25478,7 @@ var AcpProcessSession = class _AcpProcessSession {
       } else {
         const response = await this.race(
           this.#connection.agent.request(
-            methods3.agent.session.setConfigOption,
+            methods4.agent.session.setConfigOption,
             {
               configId: existing.id,
               sessionId: this.#nativeSessionId,
@@ -24517,7 +25497,7 @@ var AcpProcessSession = class _AcpProcessSession {
     } else {
       const response = await this.race(
         this.#connection.agent.request(
-          methods3.agent.session.setConfigOption,
+          methods4.agent.session.setConfigOption,
           {
             configId: existing.id,
             sessionId: this.#nativeSessionId,
@@ -24616,7 +25596,7 @@ var AcpProcessSession = class _AcpProcessSession {
     try {
       const response = await this.race(
         this.#connection.agent.request(
-          methods3.agent.session.prompt,
+          methods4.agent.session.prompt,
           { prompt, sessionId: this.#nativeSessionId },
           { cancellationSignal: options.signal }
         ),
@@ -24659,13 +25639,17 @@ var AcpProcessSession = class _AcpProcessSession {
     }
   };
   cancel = async () => {
-    await this.cancelPendingInteractions();
-    if (!this.#turn.running) {
-      return;
+    const capturedProcesses = await captureProcessTree(this.#child);
+    try {
+      await this.cancelPendingInteractions();
+      if (this.#turn.running) {
+        await this.#connection.agent.notify(methods4.agent.session.cancel, {
+          sessionId: this.#nativeSessionId
+        });
+      }
+    } finally {
+      await this.closeProcess(capturedProcesses);
     }
-    await this.#connection.agent.notify(methods3.agent.session.cancel, {
-      sessionId: this.#nativeSessionId
-    });
   };
   respondPermission = async (options) => {
     const pending = this.#pendingPermissions.get(options.interactionId);
@@ -24852,11 +25836,45 @@ var AcpProcessSession = class _AcpProcessSession {
     });
   };
   onUpdate = (notification) => {
+    if (this.#nativeSessionId.length === 0) {
+      const notificationBytes = Buffer.byteLength(JSON.stringify(notification));
+      if (this.#preSessionUpdates.length >= MAX_PRE_SESSION_UPDATES || this.#preSessionUpdateBytes + notificationBytes > MAX_PRE_SESSION_UPDATE_BYTES) {
+        return Promise.reject(
+          new AcpExecutionError(
+            "ACP agent sent too many updates before creating its session",
+            {},
+            "agent_update_limit"
+          )
+        );
+      }
+      this.#preSessionUpdates.push(notification);
+      this.#preSessionUpdateBytes += notificationBytes;
+      return Promise.resolve();
+    }
+    return this.enqueueUpdate(notification);
+  };
+  enqueueUpdate = (notification) => {
     this.#updateTail = this.#updateTail.then(
       async () => await this.processUpdate(notification)
     );
     return this.#updateTail;
   };
+  selectNativeSession = (sessionId) => {
+    const selected = nativeSessionIdSchema.parse(sessionId);
+    if (this.#nativeSessionId.length > 0 && this.#nativeSessionId !== selected) {
+      throw new AcpExecutionError(
+        "ACP agent attempted to replace the selected session",
+        {},
+        "invalid_agent_session"
+      );
+    }
+    this.#nativeSessionId = selected;
+    const pending = this.#preSessionUpdates.splice(0);
+    this.#preSessionUpdateBytes = 0;
+    for (const notification of pending) {
+      void this.enqueueUpdate(notification);
+    }
+  };
   processUpdate = async (notification) => {
     this.assertNativeSession(notification.sessionId);
     const update = notification.update;
@@ -24981,7 +25999,7 @@ var AcpProcessSession = class _AcpProcessSession {
     if (this.#capabilities.closeSession && this.#nativeSessionId.length > 0) {
       try {
         await this.#connection.agent.request(
-          methods3.agent.session.close,
+          methods4.agent.session.close,
           { sessionId: this.#nativeSessionId },
           {
             cancellationSignal: AbortSignal.timeout(
@@ -24994,9 +26012,12 @@ var AcpProcessSession = class _AcpProcessSession {
     }
     await this.closeProcess();
   };
-  closeProcess = async () => {
-    this.#connection.close();
-    await stopProcessTree(this.#child);
+  closeProcess = async (capturedProcesses = []) => {
+    try {
+      await stopProcessTree(this.#child, capturedProcesses);
+    } finally {
+      this.#connection.close();
+    }
   };
   race = async (operation, exitMessage, signal) => {
     signal.throwIfAborted();
@@ -25012,13 +26033,25 @@ var AcpProcessSession = class _AcpProcessSession {
       };
     });
     try {
-      return await Promise.race([
-        operation,
-        this.#processExit.then(() => {
-          throw new AcpExecutionError(exitMessage);
-        }),
-        aborted2
-      ]);
+      try {
+        return await Promise.race([
+          operation,
+          this.#processExit.then(() => {
+            throw new AcpExecutionError(exitMessage);
+          }),
+          aborted2
+        ]);
+      } catch (error61) {
+        signal.throwIfAborted();
+        if (error61 instanceof RequestError2 && error61.code === -32e3) {
+          throw new AcpExecutionError(
+            "Agent authentication is required",
+            { cause: error61 },
+            "authentication_required"
+          );
+        }
+        throw error61;
+      }
     } finally {
       removeAbortListener();
     }
@@ -25277,7 +26310,13 @@ var AcpSessionManager = class {
     this.#cancellationRequests.add(sessionId);
     const runtime = this.#sessions.get(sessionId);
     if (runtime !== void 0) {
-      await runtime.cancel();
+      try {
+        await runtime.cancel();
+      } finally {
+        if (this.#sessions.get(sessionId) === runtime) {
+          this.#sessions.delete(sessionId);
+        }
+      }
     }
   };
   runPrompt = async (options) => {
@@ -25330,7 +26369,19 @@ var AcpSessionManager = class {
       if (this.#cancellationRequests.has(options.sessionId)) {
         return { stopReason: "cancelled" };
       }
-      return await runtime.prompt(boundedOptions);
+      try {
+        const result = await runtime.prompt(boundedOptions);
+        return this.#cancellationRequests.has(options.sessionId) ? { stopReason: "cancelled" } : result;
+      } catch (error61) {
+        if (this.#cancellationRequests.has(options.sessionId)) {
+          if (this.#sessions.get(options.sessionId) === runtime) {
+            this.#sessions.delete(options.sessionId);
+          }
+          await runtime.closeProcess();
+          return { stopReason: "cancelled" };
+        }
+        throw error61;
+      }
     } catch (error61) {
       const failedRuntime = this.#sessions.get(options.sessionId);
       if (failedRuntime !== void 0) {
@@ -25550,7 +26601,7 @@ var AcpSessionManager = class {
 };
 
 // src/agent-catalog/publish-agent-catalog.ts
-import { fetch as fetch2 } from "undici";
+import { fetch as fetch3 } from "undici";
 var CATALOG_UPDATE_TIMEOUT_MILLISECONDS = 2e4;
 var AgentCatalogPublishError = class extends Error {
   code = "agent_catalog_update_failed";
@@ -25577,7 +26628,7 @@ async function publishAgentCatalog(config2, signal) {
   let response;
   const catalog = config2.catalog.read();
   try {
-    response = await fetch2(catalogEndpoint(config2.relayUrl), {
+    response = await fetch3(catalogEndpoint(config2.relayUrl), {
       body: JSON.stringify({
         agents: catalog.agents.map((agent) => ({
           id: agent.id,
@@ -25983,7 +27034,7 @@ var InstalledAutomaticAdapter = class {
   }
 };
 function shouldProvisionAdapter(unavailable, options) {
-  return AUTOMATIC_ADAPTER_FAILURE_CODES.has(unavailable.code) && options.environment[unavailable.specification.adapterOverrideVariable] === void 0 && unavailable.specification.supportsInstallation(
+  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
   );
@@ -26027,6 +27078,10 @@ var AutomaticAdapterProvisioner = class {
     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(
@@ -26065,293 +27120,100 @@ var AutomaticAdapterProvisioner = class {
           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 mkdir3, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-
-// src/agent-installation/verified-download.ts
-import { createHash } from "node:crypto";
-import { open as open5, unlink } from "node:fs/promises";
-import { fetch as fetch3 } from "undici";
-var MAX_REDIRECTS = 4;
-var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-var InstallerDownloadError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "InstallerDownloadError";
-  }
-};
-var VerifiedDownload = class {
-  bytes;
-  sha256;
-  url;
-  constructor(url2, bytes, sha256) {
-    this.bytes = bytes;
-    this.sha256 = sha256;
-    this.url = url2;
-  }
-};
-var UndiciInstallerDownloadTransport = class {
-  get = async (url2, signal) => await fetch3(url2, {
-    dispatcher: environmentProxyDispatcher,
-    headers: {
-      accept: "text/plain, application/octet-stream;q=0.9",
-      "user-agent": "Mobius-Agent-Installer/0.0.3"
-    },
-    method: "GET",
-    redirect: "manual",
-    signal
-  });
-};
-function validateUrl(url2, allowedHosts) {
-  if (url2.protocol !== "https:" || url2.username.length > 0 || url2.password.length > 0 || url2.port.length > 0 || !allowedHosts.has(url2.hostname)) {
-    throw new InstallerDownloadError(
-      "installer_host_not_allowed",
-      "The installer download target is not allowed"
-    );
-  }
-}
-async function fetchInstaller(options, signal, transport) {
-  let url2 = new URL(options.url);
-  for (let redirectCount = 0; redirectCount <= MAX_REDIRECTS; redirectCount += 1) {
-    validateUrl(url2, options.allowedHosts);
-    const response = await transport.get(url2, signal);
-    if (!REDIRECT_STATUSES.has(response.status)) {
-      return { response, url: url2 };
-    }
-    await response.body?.cancel();
-    const location = response.headers.get("location");
-    if (location === null || redirectCount === MAX_REDIRECTS) {
-      throw new InstallerDownloadError(
-        "installer_redirect_invalid",
-        "The installer returned an invalid redirect"
-      );
-    }
-    let redirected;
-    try {
-      redirected = new URL(location, url2);
-    } catch (error61) {
-      throw new InstallerDownloadError(
-        "installer_redirect_invalid",
-        "The installer returned an invalid redirect",
-        { cause: error61 }
-      );
-    }
-    try {
-      validateUrl(redirected, options.allowedHosts);
-    } catch (error61) {
-      throw new InstallerDownloadError(
-        "installer_redirect_not_allowed",
-        "The installer redirect left the approved host allowlist",
-        { cause: error61 }
-      );
-    }
-    url2 = redirected;
-  }
-  throw new InstallerDownloadError(
-    "installer_redirect_invalid",
-    "The installer returned too many redirects"
-  );
-}
-async function writeCompleteChunk(handle, chunk) {
-  let offset = 0;
-  while (offset < chunk.byteLength) {
-    const written = await handle.write(
-      chunk,
-      offset,
-      chunk.byteLength - offset
-    );
-    if (written.bytesWritten < 1) {
-      throw new InstallerDownloadError(
-        "installer_write_failed",
-        "The verified installer could not be stored"
-      );
-    }
-    offset += written.bytesWritten;
-  }
-}
-async function downloadVerifiedFile(options, transport = new UndiciInstallerDownloadTransport()) {
-  options.signal.throwIfAborted();
-  const timeoutSignal = AbortSignal.timeout(options.timeoutMilliseconds);
-  const signal = AbortSignal.any([options.signal, timeoutSignal]);
-  let handle = null;
-  let responseBody = null;
-  try {
-    const fetched = await fetchInstaller(options, signal, transport);
-    responseBody = fetched.response.body;
-    if (!fetched.response.ok || fetched.response.body === null) {
-      throw new InstallerDownloadError(
-        "installer_download_failed",
-        "The approved installer could not be downloaded"
-      );
-    }
-    const contentLength = fetched.response.headers.get("content-length");
-    if (contentLength !== null) {
-      const declaredLength = Number(contentLength);
-      if (!Number.isSafeInteger(declaredLength) || declaredLength < 1 || declaredLength > options.maximumBytes) {
-        throw new InstallerDownloadError(
-          "installer_size_invalid",
-          "The installer size is outside the approved limit"
+        attempts.push(
+          new InstalledAutomaticAdapter(specification, requestId, executable)
         );
-      }
-    }
-    handle = await open5(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"
+      } catch (error61) {
+        if (signal.aborted) {
+          this.#options.audit.record(
+            "agent_adapter_auto_install_cancelled",
+            requestId,
+            specification.id
           );
+          signal.throwIfAborted();
         }
-        digest.update(chunk.value);
-        await writeCompleteChunk(handle, chunk.value);
+        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);
       }
-    } finally {
-      await reader.cancel().catch(() => void 0);
-      reader.releaseLock();
     }
-    if (bytes === 0) {
-      throw new InstallerDownloadError(
-        "installer_verification_failed",
-        "The downloaded installer is empty"
+    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
+        )
       );
     }
-    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 }
+    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.
+`
       );
     }
-    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);
-  }
-}
+    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 mkdir4, mkdtemp as mkdtemp3, rm as rm3 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 var INSTALLER_DOWNLOAD_LIMIT_BYTES = 1024 * 1024;
 var INSTALLER_DOWNLOAD_TIMEOUT_MILLISECONDS = 6e4;
 var AGENT_INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
-var MINIMAL_PATH = "/usr/bin:/bin";
+var MINIMAL_PATH2 = "/usr/bin:/bin";
 var FixedAgentInstallRecipe = class {
   assertSupportedPlatform = () => {
     if (process.platform !== "darwin" && process.platform !== "linux" || process.arch !== "arm64" && process.arch !== "x64") {
@@ -26378,22 +27240,22 @@ var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
   releaseChannel = "latest";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join9(options.stateDirectory, "agents", this.id);
-    const temporaryRoot = join9(options.stateDirectory, "temporary");
+    const root = join14(options.stateDirectory, "agents", this.id);
+    const temporaryRoot = join14(options.stateDirectory, "temporary");
     await Promise.all([
-      mkdir3(root, { mode: 448, recursive: true }),
-      mkdir3(temporaryRoot, { mode: 448, recursive: true })
+      mkdir4(root, { mode: 448, recursive: true }),
+      mkdir4(temporaryRoot, { mode: 448, recursive: true })
     ]);
-    const temporaryDirectory = await mkdtemp2(
-      join9(temporaryRoot, ".codex-install-")
+    const temporaryDirectory = await mkdtemp3(
+      join14(temporaryRoot, ".codex-install-")
     );
-    const installerPath = join9(temporaryDirectory, "install.sh");
-    const installDirectory = join9(root, "bin");
-    const codexHome = join9(root, "home");
+    const installerPath = join14(temporaryDirectory, "install.sh");
+    const installDirectory = join14(root, "bin");
+    const codexHome = join14(root, "home");
     try {
       await Promise.all([
-        mkdir3(installDirectory, { mode: 448, recursive: true }),
-        mkdir3(codexHome, { mode: 448, recursive: true })
+        mkdir4(installDirectory, { mode: 448, recursive: true }),
+        mkdir4(codexHome, { mode: 448, recursive: true })
       ]);
       await options.report("downloading");
       const download = await downloadVerifiedFile({
@@ -26426,14 +27288,14 @@ var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
           CODEX_NON_INTERACTIVE: "1",
           CODEX_RELEASE: this.releaseChannel,
           HOME: codexHome,
-          PATH: MINIMAL_PATH
+          PATH: MINIMAL_PATH2
         },
         outputLimitBytes: 64 * 1024,
         signal: options.signal,
         timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
       });
       return await this.requireInstalledExecutable(
-        join9(installDirectory, "codex")
+        join14(installDirectory, "codex")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -26447,7 +27309,7 @@ var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
         "The fixed Codex installation recipe failed"
       );
     } finally {
-      await rm2(temporaryDirectory, { force: true, recursive: true });
+      await rm3(temporaryDirectory, { force: true, recursive: true });
     }
   };
 };
@@ -26457,17 +27319,17 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
   releaseChannel = "stable";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join9(options.stateDirectory, "agents", this.id);
-    const managedHome = join9(root, "home");
-    const temporaryRoot = join9(options.stateDirectory, "temporary");
+    const root = join14(options.stateDirectory, "agents", this.id);
+    const managedHome = join14(root, "home");
+    const temporaryRoot = join14(options.stateDirectory, "temporary");
     await Promise.all([
-      mkdir3(managedHome, { mode: 448, recursive: true }),
-      mkdir3(temporaryRoot, { mode: 448, recursive: true })
+      mkdir4(managedHome, { mode: 448, recursive: true }),
+      mkdir4(temporaryRoot, { mode: 448, recursive: true })
     ]);
-    const temporaryDirectory = await mkdtemp2(
-      join9(temporaryRoot, ".claude-install-")
+    const temporaryDirectory = await mkdtemp3(
+      join14(temporaryRoot, ".claude-install-")
     );
-    const installerPath = join9(temporaryDirectory, "install.sh");
+    const installerPath = join14(temporaryDirectory, "install.sh");
     try {
       await options.report("downloading");
       const download = await downloadVerifiedFile({
@@ -26496,7 +27358,7 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
         cwd: temporaryDirectory,
         environment: {
           HOME: managedHome,
-          PATH: MINIMAL_PATH,
+          PATH: MINIMAL_PATH2,
           SHELL: "/bin/bash"
         },
         outputLimitBytes: 64 * 1024,
@@ -26504,7 +27366,7 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
         timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
       });
       return await this.requireInstalledExecutable(
-        join9(managedHome, ".local", "bin", "claude")
+        join14(managedHome, ".local", "bin", "claude")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -26518,7 +27380,7 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
         "The fixed Claude Code installation recipe failed"
       );
     } finally {
-      await rm2(temporaryDirectory, { force: true, recursive: true });
+      await rm3(temporaryDirectory, { force: true, recursive: true });
     }
   };
 };
@@ -26538,7 +27400,7 @@ var PiInstallRecipe = class extends FixedAgentInstallRecipe {
       await options.report("verifying");
       await options.report("installing_agent");
       const executable = await this.#npmInstaller.install(
-        join9(
+        join14(
           options.stateDirectory,
           "agents",
           this.id,
@@ -26593,11 +27455,161 @@ var PiInstallRecipe = class extends FixedAgentInstallRecipe {
     }
   };
 };
+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 = join14(
+        options.stateDirectory,
+        "agents",
+        this.id,
+        "home"
+      );
+      await mkdir4(managedHome, { mode: 448, recursive: true });
+      await options.report("downloading");
+      await options.report("verifying");
+      await options.report("installing_agent");
+      const executable = await this.#npmInstaller.install(
+        join14(
+          options.stateDirectory,
+          "agents",
+          this.id,
+          DEEPSEEK_HARNESS_PACKAGE.version
+        ),
+        DEEPSEEK_HARNESS_PACKAGE,
+        options.environment,
+        options.signal
+      );
+      options.audit.record(
+        "agent_npm_package_verified",
+        options.requestId,
+        this.id,
+        {
+          integrity: DEEPSEEK_HARNESS_PACKAGE.integrity,
+          package: DEEPSEEK_HARNESS_PACKAGE.packageName,
+          version: DEEPSEEK_HARNESS_PACKAGE.version
+        }
+      );
+      return executable;
+    } catch (error61) {
+      if (options.signal.aborted) {
+        options.signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedNpmPackageError) {
+        if (error61.code === "managed_package_verification_failed") {
+          throw new InstallationManagerError(
+            "agent_verification_failed",
+            "The managed DeepSeek Harness package did not match its pinned artifact",
+            { cause: error61 }
+          );
+        }
+        if (error61.code === "managed_package_publish_failed") {
+          throw new InstallationManagerError(
+            "agent_publish_failed",
+            "The managed DeepSeek Harness package could not be published",
+            { cause: error61 }
+          );
+        }
+        throw new InstallationManagerError(error61.code, error61.message, {
+          cause: error61
+        });
+      }
+      if (error61 instanceof InstallationManagerError) {
+        throw error61;
+      }
+      throw new InstallationManagerError(
+        "agent_install_failed",
+        "The fixed DeepSeek Harness installation recipe failed",
+        { cause: error61 }
+      );
+    }
+  };
+};
+var OpenCodeInstallRecipe = class extends FixedAgentInstallRecipe {
+  #archiveInstaller;
+  id = "opencode";
+  label = "OpenCode";
+  releaseChannel = OPENCODE_MANAGED_VERSION;
+  constructor(archiveInstaller = new ManagedAgentArchiveInstaller()) {
+    super();
+    this.#archiveInstaller = archiveInstaller;
+  }
+  install = async (options) => {
+    this.assertSupportedPlatform();
+    const definition = openCodeManagedArchive(process.platform, process.arch);
+    try {
+      await options.report("downloading");
+      await options.report("verifying");
+      await options.report("installing_agent");
+      const executable = await this.#archiveInstaller.install(
+        join14(
+          options.stateDirectory,
+          "agents",
+          this.id,
+          OPENCODE_MANAGED_VERSION
+        ),
+        definition,
+        options.signal
+      );
+      options.audit.record(
+        "agent_archive_verified",
+        options.requestId,
+        this.id,
+        {
+          sha256: definition.archiveSha256,
+          version: definition.version
+        }
+      );
+      return executable;
+    } catch (error61) {
+      if (options.signal.aborted) {
+        options.signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedAgentArchiveError) {
+        if (error61.code === "managed_archive_verification_failed") {
+          throw new InstallationManagerError(
+            "agent_verification_failed",
+            "The managed OpenCode archive did not match its pinned artifact",
+            { cause: error61 }
+          );
+        }
+        if (error61.code === "managed_archive_publish_failed") {
+          throw new InstallationManagerError(
+            "agent_publish_failed",
+            "The managed OpenCode archive could not be published",
+            { cause: error61 }
+          );
+        }
+        throw new InstallationManagerError(error61.code, error61.message, {
+          cause: error61
+        });
+      }
+      if (error61 instanceof InstallationManagerError) {
+        throw error61;
+      }
+      throw new InstallationManagerError(
+        "agent_install_failed",
+        "The fixed OpenCode installation recipe failed",
+        { cause: error61 }
+      );
+    }
+  };
+};
 function fixedAgentInstallRecipes() {
   return Object.freeze([
     new CodexInstallRecipe(),
     new ClaudeCodeInstallRecipe(),
-    new PiInstallRecipe()
+    new PiInstallRecipe(),
+    new DeepSeekHarnessInstallRecipe(),
+    new OpenCodeInstallRecipe()
   ]);
 }
 
@@ -26735,12 +27747,15 @@ var FixedInstallationExecutor = class {
         });
         installedAgent = true;
       }
-      let adapter = await resolveAdapterExecutable(
-        specification,
-        discoveryOptions2
-      );
+      let adapter = specification instanceof DirectAcpAgentDefinition ? agent : await resolveAdapterExecutable(specification, discoveryOptions2);
       let installedAdapter = false;
       if (adapter === null) {
+        if (!(specification instanceof BridgedAcpAgentDefinition)) {
+          throw new InstallationManagerError(
+            "agent_verification_failed",
+            "The direct Agent executable is unavailable"
+          );
+        }
         await report("installing_adapter");
         adapter = await this.#adapterInstaller.install(specification, signal);
         installedAdapter = true;
@@ -26797,7 +27812,7 @@ var FixedInstallationExecutor = class {
             "The complete Agent ACP path did not pass verification"
           );
         }
-        if (!installedAdapter && requiresAdapterReplacement(unavailable.code)) {
+        if (!installedAdapter && specification instanceof BridgedAcpAgentDefinition && requiresAdapterReplacement(unavailable.code)) {
           await report("installing_adapter");
           adapter = await this.#adapterInstaller.install(specification, signal);
           installedAdapter = true;
@@ -26816,6 +27831,9 @@ var FixedInstallationExecutor = class {
             stateDirectory: this.#stateDirectory
           });
           installedAgent = true;
+          if (specification instanceof DirectAcpAgentDefinition) {
+            adapter = agent;
+          }
           continue;
         }
         throw new InstallationManagerError(
@@ -26877,15 +27895,15 @@ var LocalAuthorizationError = class extends Error {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir, realpath as realpath4, stat as stat4 } from "node:fs/promises";
+import { readdir, realpath as realpath6, stat as stat6 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import {
   basename as basename2,
-  dirname as dirname4,
-  isAbsolute as isAbsolute3,
-  join as join10,
-  normalize,
-  relative as relative2
+  dirname as dirname5,
+  isAbsolute as isAbsolute5,
+  join as join15,
+  normalize as normalize2,
+  relative as relative3
 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
@@ -26913,7 +27931,7 @@ function decodePath(value, prefix) {
   if (encoded.length === 0 || encoded.length > 2e3 || !/^[a-zA-Z0-9_-]+$/.test(encoded))
     throw new LocalAuthorizationError("The directory identifier is invalid");
   const decoded = Buffer.from(encoded, "base64url").toString("utf8");
-  if (Buffer.from(decoded, "utf8").toString("base64url") !== encoded || decoded.includes("\0") || normalize(decoded) !== decoded)
+  if (Buffer.from(decoded, "utf8").toString("base64url") !== encoded || decoded.includes("\0") || normalize2(decoded) !== decoded)
     throw new LocalAuthorizationError("The directory identifier is invalid");
   return decoded;
 }
@@ -26935,20 +27953,20 @@ var WorkspaceDirectoryService = class {
     if (id === "home") return homedir2();
     if (id.startsWith("path-")) {
       const path2 = decodePath(id, "path-");
-      if (isAbsolute3(path2)) return path2;
+      if (isAbsolute5(path2)) return path2;
     }
     throw new LocalAuthorizationError("The directory identifier is invalid");
   };
   resolvePath = async (requested, signal) => {
     signal.throwIfAborted();
-    if (!isAbsolute3(requested) || requested.includes("\0") || normalize(requested) !== requested)
+    if (!isAbsolute5(requested) || requested.includes("\0") || normalize2(requested) !== requested)
       throw new LocalAuthorizationError("The local directory path is invalid");
     try {
-      const target = await realpath4(requested);
+      const target = await realpath6(requested);
       signal.throwIfAborted();
-      const metadata = await stat4(target);
+      const metadata = await stat6(target);
       signal.throwIfAborted();
-      if (!isAbsolute3(target) || normalize(target) !== target || !metadata.isDirectory())
+      if (!isAbsolute5(target) || normalize2(target) !== target || !metadata.isDirectory())
         throw new LocalAuthorizationError(
           "The selected location is not a directory"
         );
@@ -26963,8 +27981,8 @@ var WorkspaceDirectoryService = class {
     }
   };
   label = (path2) => {
-    const suffix = relative2(homedir2(), path2);
-    return suffix === "" ? "~" : !isAbsolute3(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
+    const suffix = relative3(homedir2(), path2);
+    return suffix === "" ? "~" : !isAbsolute5(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
   };
   identify = async (bindingId, requestedPath, signal) => {
     this.authorizeMachine(bindingId);
@@ -26992,7 +28010,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join10(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();
@@ -27000,7 +28018,7 @@ var WorkspaceDirectoryService = class {
         }
       }
       entries.sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname4(target);
+      const parent = dirname5(target);
       return new WorkspaceDirectoryListing(
         id,
         this.label(target),
@@ -27115,7 +28133,8 @@ function decodeHistory(thread, value) {
       status: "available",
       messages,
       truncated,
-      coveredCommandIds: []
+      coveredCommandIds: [],
+      coveredMessageIds: []
     }
   };
 }
@@ -27792,7 +28811,7 @@ var RelayConnectionLiveness = class {
 
 // src/relay-connection/session-event-outbox.ts
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname5 } 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)) {
@@ -27807,7 +28826,7 @@ function readPendingEnvelope(row) {
 var SessionEventOutbox = class {
   #database;
   constructor(path2) {
-    mkdirSync3(dirname5(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 (
@@ -28551,10 +29570,11 @@ function waitForRelayRetry(signal, timer) {
     signal.addEventListener("abort", finish, { once: true });
   });
 }
-async function runRelayConnection(config2, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, signal, timer) {
+async function runRelayConnection(config2, directories, audit, sessions, installations, installationObserver, nativeSessions, outbox, onConnected, signal, timer) {
   const relayUrl = new URL(config2.relayUrl);
   relayUrl.searchParams.set("liveness", "1");
   const socket = await connectRelay(relayUrl, signal);
+  onConnected();
   const activeTurns = /* @__PURE__ */ new Map();
   const activeAttemptIds = /* @__PURE__ */ new Map();
   const connectionController = new AbortController();
@@ -28989,6 +30009,24 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
     installationAudit
   );
   let retryAnnounced = false;
+  let connectionAnnounced = false;
+  const announceConnection = () => {
+    if (connectionAnnounced) {
+      return;
+    }
+    connectionAnnounced = true;
+    const reconnectCommand = `npx --yes @moxt-ai/mobius start --channel ${config2.channelId}`;
+    process.stdout.write("Mobius daemon connected to the relay.\n\n");
+    process.stdout.write(
+      `${styleText(
+        ["bold", "yellow"],
+        `Reconnect this channel later:
+  ${reconnectCommand}`
+      )}
+
+`
+    );
+  };
   try {
     while (!signal.aborted) {
       try {
@@ -29002,6 +30040,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
           installationObserver,
           nativeSessions,
           outbox,
+          announceConnection,
           signal,
           timer
         );
@@ -29064,7 +30103,7 @@ async function main() {
     if (arguments_.length > 1 || arguments_.length === 1 && arguments_[0] !== "--json") {
       throw new Error("Usage: mobius agents [--json]");
     }
-    await mkdir4(loadDefaultWorkspace(), { recursive: true, mode: 448 });
+    await mkdir5(loadDefaultWorkspace(), { recursive: true, mode: 448 });
     const inventory = await discoverLocalAgentInventory({
       defaultWorkspace: loadDefaultWorkspace(),
       environment: process.env,