@moxt-ai/mobius 0.0.9 → 0.0.11

package/dist/index.js

@@ -29,13 +29,18 @@ import { fileURLToPath } from "node:url";
 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, 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;
@@ -154,6 +159,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;
@@ -180,24 +298,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"
@@ -388,7 +517,11 @@ var LocalAgentDefinition = class {
   environment;
   id;
   label;
-  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity) {
+  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;
@@ -396,6 +529,7 @@ var LocalAgentDefinition = class {
     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 });
@@ -527,7 +661,8 @@ import { spawn as spawn2 } from "node:child_process";
 import {
   methods as methods2,
   ndJsonStream,
-  PROTOCOL_VERSION
+  PROTOCOL_VERSION,
+  RequestError
 } from "@agentclientprotocol/sdk";
 
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/external.js
@@ -20302,7 +20437,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(
@@ -21541,7 +21679,8 @@ var AcpHistoryReplay = class {
     status: "available",
     messages: [...this.#messages],
     truncated: this.#truncated,
-    coveredCommandIds: []
+    coveredCommandIds: [],
+    coveredMessageIds: []
   });
 };
 
@@ -21757,6 +21896,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();
@@ -22365,8 +22506,11 @@ var AcpProcessSession = class _AcpProcessSession {
   #mobiusSessionId;
   #pendingElicitations = /* @__PURE__ */ new Map();
   #pendingPermissions = /* @__PURE__ */ new Map();
+  #preSessionUpdates = [];
   #processExit;
   #store;
+  #verifiedAgentVersion;
+  #preSessionUpdateBytes = 0;
   #agentName = "";
   #agentVersion = "";
   #capabilities = {
@@ -22400,6 +22544,7 @@ var AcpProcessSession = class _AcpProcessSession {
     this.#getObserver = getObserver;
     this.#mobiusSessionId = mobiusSessionId;
     this.#store = store;
+    this.#verifiedAgentVersion = agent.agentVersion;
     this.#child = spawn2(agent.adapterPath, [...agent.arguments], {
       cwd,
       detached: process.platform !== "win32",
@@ -22555,7 +22700,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);
@@ -22601,7 +22749,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",
@@ -22616,7 +22764,7 @@ 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) {
@@ -22686,7 +22834,7 @@ var AcpProcessSession = class _AcpProcessSession {
         "ACP agent exited while starting a session",
         signal
       );
-      this.#nativeSessionId = created.sessionId;
+      this.selectNativeSession(created.sessionId);
       lifecycleResponse = created;
     }
     const lifecycleRecord = isRecord3(lifecycleResponse) ? lifecycleResponse : {};
@@ -22948,13 +23096,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(methods2.agent.session.cancel, {
+          sessionId: this.#nativeSessionId
+        });
+      }
+    } finally {
+      await this.closeProcess(capturedProcesses);
     }
-    await this.#connection.agent.notify(methods2.agent.session.cancel, {
-      sessionId: this.#nativeSessionId
-    });
   };
   respondPermission = async (options) => {
     const pending = this.#pendingPermissions.get(options.interactionId);
@@ -23141,11 +23293,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;
@@ -23283,9 +23469,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();
@@ -23301,13 +23490,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 RequestError && error61.code === -32e3) {
+          throw new AcpExecutionError(
+            "Agent authentication is required",
+            { cause: error61 },
+            "authentication_required"
+          );
+        }
+        throw error61;
+      }
     } finally {
       removeAbortListener();
     }
@@ -23566,7 +23767,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) => {
@@ -23587,12 +23794,27 @@ var AcpSessionManager = class {
         "session_busy"
       );
     }
+    const deadlineController = new AbortController();
+    const deadlineError = new AcpExecutionError(
+      "The local Agent prompt exceeded its deadline",
+      {},
+      "prompt_timeout"
+    );
+    const deadline = setTimeout(
+      () => deadlineController.abort(deadlineError),
+      options.agent.promptTimeoutMilliseconds
+    );
+    deadline.unref();
+    const boundedOptions = {
+      ...options,
+      signal: AbortSignal.any([options.signal, deadlineController.signal])
+    };
     this.#activeSessionIds.add(options.sessionId);
     try {
       if (this.#cancellationRequests.has(options.sessionId)) {
         return { stopReason: "cancelled" };
       }
-      const runtime = await this.ensureSession(options);
+      const runtime = await this.ensureSession(boundedOptions);
       if (this.#nativeOperations.has(
         `${options.agent.id}:${runtime.nativeSessionId()}`
       ))
@@ -23604,7 +23826,19 @@ var AcpSessionManager = class {
       if (this.#cancellationRequests.has(options.sessionId)) {
         return { stopReason: "cancelled" };
       }
-      return await runtime.prompt(options);
+      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) {
@@ -23618,6 +23852,7 @@ var AcpSessionManager = class {
         cause: error61
       });
     } finally {
+      clearTimeout(deadline);
       this.#activeSessionIds.delete(options.sessionId);
       this.#cancellationRequests.delete(options.sessionId);
     }
@@ -23911,25 +24146,16 @@ var LocalAuthorizationError = class extends Error {
 // src/pairing/pair-local-machine.ts
 import { randomUUID } from "node:crypto";
 import {
-  mkdir as mkdir2,
-  open as open4,
-  realpath as realpath3,
-  rename as rename2,
-  stat as stat3,
-  writeFile
+  mkdir as mkdir3,
+  open as open6,
+  realpath as realpath5,
+  rename as rename3,
+  stat as stat5,
+  writeFile as writeFile2
 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename, join as join7, resolve as resolve3 } from "node:path";
-import { fetch } from "undici";
-
-// src/agent-catalog/discover-local-agents.ts
-import { spawn as spawn3 } from "node:child_process";
-import { isAbsolute, join as join6 } from "node:path";
-import {
-  methods as methods3,
-  ndJsonStream as ndJsonStream2,
-  PROTOCOL_VERSION as PROTOCOL_VERSION2
-} from "@agentclientprotocol/sdk";
+import { basename, join as join13, resolve as resolve3 } from "node:path";
+import { fetch as fetch2 } from "undici";
 
 // src/agent-installation/installation-grants.ts
 import { open as open2 } from "node:fs/promises";
@@ -23973,7 +24199,104 @@ async function readGrantedAgents(stateDirectory) {
   }
 }
 
-// src/agent-installation/managed-adapter-installer.ts
+// 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-installation/managed-npm-package.ts
 import {
   mkdir,
   mkdtemp,
@@ -23983,15 +24306,38 @@ import {
   rm,
   stat as stat2
 } from "node:fs/promises";
-import { delimiter, dirname as dirname3, join as join5, relative } from "node:path";
-var ADAPTER_INSTALL_TIMEOUT_MILLISECONDS = 2 * 60 * 1e3;
+import { delimiter, dirname as dirname3, isAbsolute, join as join5, relative, sep } from "node:path";
+var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
-var ManagedAdapterInstallError = class extends Error {
+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 = "ManagedAdapterInstallError";
+    this.name = "ManagedNpmPackageError";
   }
 };
 function isRecord5(value) {
@@ -24000,28 +24346,43 @@ function isRecord5(value) {
 function packagePath(root, packageName) {
   return join5(root, "node_modules", ...packageName.split("/"));
 }
-async function readPackageJson(path2) {
-  const handle = await open3(path2, "r");
+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 metadata = await handle.stat();
-    if (!metadata.isFile() || metadata.size > PACKAGE_METADATA_LIMIT_BYTES) {
-      throw new ManagedAdapterInstallError(
-        "adapter_verification_failed",
-        "The managed adapter package metadata is invalid"
+    const handle = await open3(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 (!isRecord5(value)) {
+        throw new ManagedNpmPackageError(
+          "managed_package_verification_failed",
+          "The managed npm package metadata is invalid"
+        );
+      }
+      return value;
+    } finally {
+      await handle.close();
     }
-    const value = JSON.parse(
-      await handle.readFile({ encoding: "utf8" })
-    );
-    if (!isRecord5(value)) {
-      throw new ManagedAdapterInstallError(
-        "adapter_verification_failed",
-        "The managed adapter package metadata is invalid"
-      );
+  } catch (error61) {
+    if (error61 instanceof ManagedNpmPackageError) {
+      throw error61;
     }
-    return value;
-  } finally {
-    await handle.close();
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package metadata is invalid",
+      { cause: error61 }
+    );
   }
 }
 function readBinPath(packageMetadata, executableName) {
@@ -24032,139 +24393,217 @@ function readBinPath(packageMetadata, executableName) {
   if (isRecord5(bin) && typeof bin[executableName] === "string") {
     return bin[executableName];
   }
-  throw new ManagedAdapterInstallError(
-    "adapter_verification_failed",
-    "The managed adapter executable declaration is invalid"
+  throw new ManagedNpmPackageError(
+    "managed_package_verification_failed",
+    "The managed npm package executable declaration is invalid"
   );
 }
-async function validateManagedAdapter(root, specification) {
-  const rootPath = await realpath2(root);
-  const packageRoot = await realpath2(
-    packagePath(rootPath, specification.adapterPackage)
-  );
-  const packageDifference = relative(rootPath, packageRoot);
-  if (packageDifference.startsWith("..") || packageDifference.length === 0) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter package escaped its private cache"
+function verifyPackageLock(lock, definition) {
+  if (lock["lockfileVersion"] !== 3) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile is invalid"
     );
   }
-  const metadata = await readPackageJson(join5(packageRoot, "package.json"));
-  if (metadata["name"] !== specification.adapterPackage || metadata["version"] !== specification.adapterVersion) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter package identity is invalid"
+  const packages = lock["packages"];
+  if (!isRecord5(packages)) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile is invalid"
     );
   }
-  const declaredBin = readBinPath(metadata, specification.adapterExecutable);
-  const executable = await resolveExecutablePath(
-    join5(packageRoot, declaredBin)
-  );
-  if (executable === null) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter executable 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") || !isRecord5(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
+          throw new Error("Invalid locked dependency");
+        }
+        resolved = new URL(candidate["resolved"]);
+      } 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;
+    }
   }
-  const executableDifference = relative(rootPath, executable.path);
-  if (executableDifference.startsWith("..") || executableDifference.length === 0) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter executable escaped its private cache"
+  if (matches !== 1 || !isRecord5(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile does not match the pinned artifact"
     );
   }
-  return executable;
 }
-var ManagedAdapterInstaller = class {
-  #environment;
-  #stateDirectory;
-  constructor(options) {
-    this.#environment = options.environment;
-    this.#stateDirectory = options.stateDirectory;
+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 }
+    );
   }
-  install = async (specification, signal) => {
+}
+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(
+    join5(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(
+        join5(rootPath, "package-lock.json"),
+        PACKAGE_LOCK_LIMIT_BYTES
+      ),
+      definition
+    );
+  }
+  const declaredBin = readBinPath(metadata, definition.executableName);
+  const executable = await resolveExecutablePath(
+    join5(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();
-    const agentCache = join5(this.#stateDirectory, "adapters", specification.id);
-    const published = join5(agentCache, specification.adapterVersion);
     try {
-      const metadata = await stat2(published);
+      const metadata = await stat2(root);
       if (metadata.isDirectory()) {
-        return await validateManagedAdapter(published, specification);
+        return await validateManagedNpmPackage(root, definition);
       }
     } catch (error61) {
       if (!(error61 instanceof Error) || !("code" in error61) || error61.code !== "ENOENT") {
         throw error61;
       }
     }
-    await mkdir(agentCache, { mode: 448, recursive: true });
+    const parent = dirname3(root);
+    await mkdir(parent, { mode: 448, recursive: true });
     const staging = await mkdtemp(
-      join5(agentCache, `.${specification.adapterVersion}.staging-`)
+      join5(parent, `.${definition.version}.staging-`)
     );
     try {
       const npm = await findExecutableOnPath(
         process.platform === "win32" ? "npm.cmd" : "npm",
-        this.#environment
+        environment
       );
       if (npm === null) {
-        throw new ManagedAdapterInstallError(
+        throw new ManagedNpmPackageError(
           "package_manager_not_found",
-          "A supported npm executable is required to install the ACP adapter"
+          "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: join5(staging, "home"),
+        NPM_CONFIG_AUDIT: "false",
+        NPM_CONFIG_CACHE: join5(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: `${dirname3(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
+      };
+      if (definition.includeOptionalDependencies) {
+        installEnvironment["NPM_CONFIG_INCLUDE"] = "optional";
+      } else {
+        installEnvironment["NPM_CONFIG_OMIT"] = "optional";
+      }
       await runBoundedProcess({
-        arguments: [
-          "install",
-          "--prefix",
-          staging,
-          "--omit=optional",
-          "--ignore-scripts",
-          "--no-audit",
-          "--no-fund",
-          "--package-lock=false",
-          "--save=false",
-          "--registry=https://registry.npmjs.org/",
-          `${specification.adapterPackage}@${specification.adapterVersion}`
-        ],
+        arguments: installArguments,
         command: npm.path,
         cwd: staging,
-        environment: {
-          HOME: join5(staging, "home"),
-          NPM_CONFIG_AUDIT: "false",
-          NPM_CONFIG_FUND: "false",
-          NPM_CONFIG_IGNORE_SCRIPTS: "true",
-          NPM_CONFIG_OMIT: "optional",
-          NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
-          PATH: `${dirname3(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
-        },
+        environment: installEnvironment,
         outputLimitBytes: 64 * 1024,
         signal,
-        timeoutMilliseconds: ADAPTER_INSTALL_TIMEOUT_MILLISECONDS
+        timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
-      await validateManagedAdapter(staging, specification);
+      await Promise.all([
+        rm(join5(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm(join5(staging, "home"), { force: true, recursive: true })
+      ]);
+      await validateManagedNpmPackage(staging, definition);
       try {
-        await rename(staging, published);
+        await rename(staging, root);
       } catch (error61) {
         try {
-          return await validateManagedAdapter(published, specification);
+          return await validateManagedNpmPackage(root, definition);
         } catch {
-          throw new ManagedAdapterInstallError(
-            "adapter_publish_failed",
-            "The managed adapter could not be published",
+          throw new ManagedNpmPackageError(
+            "managed_package_publish_failed",
+            "The managed npm package could not be published",
             { cause: error61 }
           );
         }
       }
-      return await validateManagedAdapter(published, specification);
+      return await validateManagedNpmPackage(root, definition);
     } catch (error61) {
       if (signal.aborted) {
         signal.throwIfAborted();
       }
-      if (error61 instanceof ManagedAdapterInstallError) {
+      if (error61 instanceof ManagedNpmPackageError) {
         throw error61;
       }
-      throw new ManagedAdapterInstallError(
-        "adapter_install_failed",
-        "The pinned ACP adapter could not be installed",
+      throw new ManagedNpmPackageError(
+        "managed_package_install_failed",
+        "The pinned npm package could not be installed",
         { cause: error61 }
       );
     } finally {
@@ -24173,42 +24612,76 @@ var ManagedAdapterInstaller = class {
   };
 };
 
-// src/agent-catalog/discover-local-agents.ts
+// src/agent-catalog/agent-specification.ts
+import { join as join6 } from "node:path";
 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 LocalAgentSpecification = class {
-  recoveryCommand = () => `npm install -g --omit=optional ${this.adapterPackage}@${this.adapterVersion}`;
+  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(
+      join6(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 CodexAgentSpecification = class extends LocalAgentSpecification {
-  adapterEnvironmentVariable = "CODEX_PATH";
-  adapterExecutable = "codex-acp";
-  adapterOverrideVariable = "MOBIUS_CODEX_ACP_PATH";
-  adapterPackage = "@agentclientprotocol/codex-acp";
-  adapterVersion = "1.8.0";
-  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 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}`;
 };
-var ClaudeCodeAgentSpecification = class extends LocalAgentSpecification {
+
+// src/agent-catalog/agents/claude-code-agent.ts
+var ClaudeCodeAgentSpecification = class extends BridgedAcpAgentDefinition {
   adapterEnvironmentVariable = "CLAUDE_CODE_EXECUTABLE";
-  adapterExecutable = "claude-agent-acp";
   adapterOverrideVariable = "MOBIUS_CLAUDE_ACP_PATH";
-  adapterPackage = "@agentclientprotocol/claude-agent-acp";
-  adapterVersion = "0.73.0";
+  adapterPackageDefinition = new ManagedNpmPackageDefinition(
+    "@agentclientprotocol/claude-agent-acp",
+    "0.73.0",
+    "claude-agent-acp"
+  );
   agentExecutable = "claude";
   agentOverrideVariable = "MOBIUS_CLAUDE_PATH";
   id = "claude";
@@ -24232,122 +24705,1001 @@ var ClaudeCodeAgentSpecification = class extends LocalAgentSpecification {
     "claude"
   ];
 };
-function supportedLocalAgentSpecifications() {
-  return Object.freeze([
-    new CodexAgentSpecification(),
-    new ClaudeCodeAgentSpecification()
+
+// 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 join7, 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"
   ]);
-}
-var AgentDiscovery = class {
-  specification;
-  constructor(specification) {
-    this.specification = specification;
-  }
+  includeOptionalDependencies = true;
+  verifyDependencyClosure = true;
 };
-var AvailableAgent = class extends AgentDiscovery {
-  agent;
-  status = "ready";
-  constructor(specification, agent) {
-    super(specification);
-    this.agent = agent;
+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";
   }
 };
-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);
+
+// 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"
+    );
   }
-};
-var MissingAgent = class extends UnavailableAgent {
-  code = "agent_not_found";
-  message = "Agent executable not found";
-  status = "missing_agent";
-  constructor(specification) {
-    super(specification);
+  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 AgentProbeError) {
+      throw error61;
+    }
+    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 = join7(
+          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(
+      join7(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();
+  };
 };
-var ProbeFailed = class extends UnavailableAgent {
+
+// src/agent-catalog/agents/opencode-agent.ts
+import { join as join9 } 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 open5,
+  realpath as realpath4,
+  rename as rename2,
+  rm as rm2,
+  stat as stat4,
+  writeFile
+} from "node:fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join8, relative as relative2, sep as sep2 } from "node:path";
+
+// src/agent-installation/verified-download.ts
+import { createHash } from "node:crypto";
+import { open as open4, 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;
-  message;
-  status = "probe_failed";
-  constructor(specification, code, message) {
-    super(specification);
+  constructor(code, message, options = {}) {
+    super(message, options);
     this.code = code;
-    this.message = message;
+    this.name = "InstallerDownloadError";
   }
 };
-var IncompatibleAdapter = class extends UnavailableAgent {
-  code = "acp_incompatible";
-  message = "ACP adapter is incompatible";
-  status = "incompatible_adapter";
-  constructor(specification) {
-    super(specification);
+var VerifiedDownload = class {
+  bytes;
+  sha256;
+  url;
+  constructor(url2, bytes, sha256) {
+    this.bytes = bytes;
+    this.sha256 = sha256;
+    this.url = url2;
   }
 };
-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.specification.supportsInstallation(platform, architecture)
-      ).map(
-        (discovery) => new InstallableAgentDefinition(
-          discovery.specification.id,
-          discovery.specification.label,
-          !grantedAgents.has(discovery.specification.id)
-        )
-      )
+var UndiciInstallerDownloadTransport = class {
+  get = async (url2, signal) => await fetch(url2, {
+    dispatcher: environmentProxyDispatcher,
+    headers: {
+      accept: "text/plain, application/octet-stream;q=0.9",
+      "user-agent": "Mobius-Agent-Installer/0.0.3"
+    },
+    method: "GET",
+    redirect: "manual",
+    signal
+  });
+};
+function validateUrl(url2, allowedHosts) {
+  if (url2.protocol !== "https:" || url2.username.length > 0 || url2.password.length > 0 || url2.port.length > 0 || !allowedHosts.has(url2.hostname)) {
+    throw new InstallerDownloadError(
+      "installer_host_not_allowed",
+      "The installer download target is not allowed"
+    );
+  }
+}
+async function fetchInstaller(options, signal, transport) {
+  let url2 = new URL(options.url);
+  for (let redirectCount = 0; redirectCount <= MAX_REDIRECTS; redirectCount += 1) {
+    validateUrl(url2, options.allowedHosts);
+    const response = await transport.get(url2, signal);
+    if (!REDIRECT_STATUSES.has(response.status)) {
+      return { response, url: url2 };
+    }
+    await response.body?.cancel();
+    const location = response.headers.get("location");
+    if (location === null || redirectCount === MAX_REDIRECTS) {
+      throw new InstallerDownloadError(
+        "installer_redirect_invalid",
+        "The installer returned an invalid redirect"
+      );
+    }
+    let redirected;
+    try {
+      redirected = new URL(location, url2);
+    } catch (error61) {
+      throw new InstallerDownloadError(
+        "installer_redirect_invalid",
+        "The installer returned an invalid redirect",
+        { cause: error61 }
+      );
+    }
+    try {
+      validateUrl(redirected, options.allowedHosts);
+    } catch (error61) {
+      throw new InstallerDownloadError(
+        "installer_redirect_not_allowed",
+        "The installer redirect left the approved host allowlist",
+        { cause: error61 }
+      );
+    }
+    url2 = redirected;
+  }
+  throw new InstallerDownloadError(
+    "installer_redirect_invalid",
+    "The installer returned too many redirects"
+  );
+}
+async function writeCompleteChunk(handle, chunk) {
+  let offset = 0;
+  while (offset < chunk.byteLength) {
+    const written = await handle.write(
+      chunk,
+      offset,
+      chunk.byteLength - offset
+    );
+    if (written.bytesWritten < 1) {
+      throw new InstallerDownloadError(
+        "installer_write_failed",
+        "The verified installer could not be stored"
+      );
+    }
+    offset += written.bytesWritten;
+  }
+}
+async function downloadVerifiedFile(options, transport = new UndiciInstallerDownloadTransport()) {
+  options.signal.throwIfAborted();
+  const timeoutSignal = AbortSignal.timeout(options.timeoutMilliseconds);
+  const signal = AbortSignal.any([options.signal, timeoutSignal]);
+  let handle = null;
+  let responseBody = null;
+  try {
+    const fetched = await fetchInstaller(options, signal, transport);
+    responseBody = fetched.response.body;
+    if (!fetched.response.ok || fetched.response.body === null) {
+      throw new InstallerDownloadError(
+        "installer_download_failed",
+        "The approved installer could not be downloaded"
+      );
+    }
+    const contentLength = fetched.response.headers.get("content-length");
+    if (contentLength !== null) {
+      const declaredLength = Number(contentLength);
+      if (!Number.isSafeInteger(declaredLength) || declaredLength < 1 || declaredLength > options.maximumBytes) {
+        throw new InstallerDownloadError(
+          "installer_size_invalid",
+          "The installer size is outside the approved limit"
+        );
+      }
+    }
+    handle = await open4(options.destination, "wx", 384);
+    const digest = createHash("sha256");
+    const reader = fetched.response.body.getReader();
+    let bytes = 0;
+    try {
+      while (true) {
+        signal.throwIfAborted();
+        const chunk = await reader.read();
+        if (chunk.done) {
+          break;
+        }
+        bytes += chunk.value.byteLength;
+        if (bytes > options.maximumBytes) {
+          throw new InstallerDownloadError(
+            "installer_size_invalid",
+            "The installer exceeded the approved size limit"
+          );
+        }
+        digest.update(chunk.value);
+        await writeCompleteChunk(handle, chunk.value);
+      }
+    } finally {
+      await reader.cancel().catch(() => void 0);
+      reader.releaseLock();
+    }
+    if (bytes === 0) {
+      throw new InstallerDownloadError(
+        "installer_verification_failed",
+        "The downloaded installer is empty"
+      );
+    }
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    return new VerifiedDownload(fetched.url, bytes, digest.digest("hex"));
+  } catch (error61) {
+    if (handle !== null) {
+      await handle.close().catch(() => void 0);
+    }
+    await unlink(options.destination).catch(() => void 0);
+    if (options.signal.aborted) {
+      options.signal.throwIfAborted();
+    }
+    if (timeoutSignal.aborted) {
+      throw new InstallerDownloadError(
+        "installer_download_timeout",
+        "The installer download timed out",
+        { cause: error61 }
+      );
+    }
+    if (error61 instanceof InstallerDownloadError) {
+      throw error61;
+    }
+    throw new InstallerDownloadError(
+      "installer_download_failed",
+      "The approved installer could not be downloaded",
+      { cause: error61 }
+    );
+  } finally {
+    await responseBody?.cancel().catch(() => void 0);
+  }
+}
+
+// src/agent-installation/managed-agent-archive.ts
+var ARCHIVE_DOWNLOAD_LIMIT_BYTES = 128 * 1024 * 1024;
+var ARCHIVE_DOWNLOAD_TIMEOUT_MILLISECONDS = 2 * 60 * 1e3;
+var ARCHIVE_EXTRACTION_TIMEOUT_MILLISECONDS = 6e4;
+var MANIFEST_LIMIT_BYTES = 16 * 1024;
+var MINIMAL_PATH = "/usr/bin:/bin";
+var ManagedAgentArchiveDefinition = class {
+  archiveName;
+  archiveSha256;
+  archiveUrl;
+  executableName;
+  version;
+  constructor(version2, archiveName, archiveUrl, archiveSha256, executableName) {
+    this.archiveName = archiveName;
+    this.archiveSha256 = archiveSha256;
+    this.archiveUrl = new URL(archiveUrl);
+    this.executableName = executableName;
+    this.version = version2;
+  }
+};
+var ZipManagedAgentArchiveDefinition = class extends ManagedAgentArchiveDefinition {
+  extractor = "/usr/bin/unzip";
+  extractArguments = (archivePath, destination) => ["-q", archivePath, "-d", destination];
+  listArguments = (archivePath) => [
+    "-Z1",
+    archivePath
+  ];
+};
+var TarGzipManagedAgentArchiveDefinition = class extends ManagedAgentArchiveDefinition {
+  extractor = "/usr/bin/tar";
+  extractArguments = (archivePath, destination) => ["-xzf", archivePath, "-C", destination];
+  listArguments = (archivePath) => [
+    "-tzf",
+    archivePath
+  ];
+};
+var ManagedAgentArchiveError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "ManagedAgentArchiveError";
+  }
+};
+var ManagedAgentArchiveDownloader = class {
+  download = async (options) => await downloadVerifiedFile(options);
+};
+function isRecord6(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);
+    }
+    return digest.digest("hex");
+  } catch (error61) {
+    if (signal.aborted) {
+      signal.throwIfAborted();
+    }
+    if (error61 instanceof ManagedAgentArchiveError) {
+      throw error61;
+    }
+    throw new ManagedAgentArchiveError(
+      "managed_archive_verification_failed",
+      "The managed Agent artifact could not be verified",
+      { cause: error61 }
+    );
+  }
+}
+async function readManifest(path2) {
+  let handle;
+  try {
+    handle = await open5(path2, "r");
+  } catch (error61) {
+    throw new ManagedAgentArchiveError(
+      "managed_archive_verification_failed",
+      "The managed Agent archive manifest is invalid",
+      { cause: error61 }
+    );
+  }
+  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" })
+    );
+    if (!isRecord6(parsed)) {
+      throw new ManagedAgentArchiveError(
+        "managed_archive_verification_failed",
+        "The managed Agent archive manifest is invalid"
+      );
+    }
+    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();
+  }
+}
+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");
+    }
+    const manifest = await readManifest(join8(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(
+      join8(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 }
+    );
+  }
+}
+function validateArchiveEntries(output2, definition) {
+  const entries = output2.split(/\r?\n/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (entries.length !== 1 || entries[0] !== definition.executableName && entries[0] !== `./${definition.executableName}`) {
+    throw new ManagedAgentArchiveError(
+      "managed_archive_verification_failed",
+      "The managed Agent archive contains unexpected entries"
+    );
+  }
+}
+var ManagedAgentArchiveInstaller = class {
+  #downloader;
+  constructor(downloader = new ManagedAgentArchiveDownloader()) {
+    this.#downloader = downloader;
+  }
+  install = async (root, definition, signal) => {
+    signal.throwIfAborted();
+    try {
+      const metadata = await stat4(root);
+      if (metadata.isDirectory()) {
+        return await validateManagedAgentArchive(root, definition, signal);
+      }
+    } catch (error61) {
+      if (error61 instanceof ManagedAgentArchiveError || !(error61 instanceof Error) || !("code" in error61) || error61.code !== "ENOENT") {
+        throw error61;
+      }
+    }
+    const parent = dirname4(root);
+    await mkdir2(parent, { mode: 448, recursive: true });
+    const working = await mkdtemp2(
+      join8(parent, `.${definition.version}.archive-`)
+    );
+    const staging = await mkdtemp2(
+      join8(parent, `.${definition.version}.staging-`)
+    );
+    try {
+      const archivePath = join8(working, definition.archiveName);
+      const extractionRoot = join8(working, "extracted");
+      await mkdir2(extractionRoot, { mode: 448 });
+      const canonicalExtractionRoot = await 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(
+        join8(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 = join8(staging, "bin");
+      const executablePath = join8(binDirectory, definition.executableName);
+      await mkdir2(binDirectory, { mode: 448 });
+      await copyFile(extracted, executablePath);
+      await chmod(executablePath, 448);
+      const executableSha256 = await hashFile(executablePath, signal);
+      await writeFile(
+        join8(staging, "archive.json"),
+        `${JSON.stringify({
+          archiveSha256: definition.archiveSha256,
+          archiveUrl: definition.archiveUrl.toString(),
+          executableSha256,
+          version: definition.version
+        })}
+`,
+        { mode: 384 }
+      );
+      await validateManagedAgentArchive(staging, definition, signal);
+      try {
+        await rename2(staging, root);
+      } catch (error61) {
+        try {
+          return await validateManagedAgentArchive(root, definition, signal);
+        } catch {
+          throw new ManagedAgentArchiveError(
+            "managed_archive_publish_failed",
+            "The managed Agent archive could not be published",
+            { cause: error61 }
+          );
+        }
+      }
+      return await validateManagedAgentArchive(root, definition, signal);
+    } catch (error61) {
+      if (signal.aborted) {
+        signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedAgentArchiveError) {
+        throw error61;
+      }
+      throw new ManagedAgentArchiveError(
+        "managed_archive_install_failed",
+        "The pinned Agent archive could not be installed",
+        { cause: error61 }
+      );
+    } finally {
+      await Promise.all([
+        rm2(working, { force: true, recursive: true }),
+        rm2(staging, { force: true, recursive: true })
+      ]);
+    }
+  };
+};
+
+// src/agent-installation/opencode-managed-release.ts
+var OPENCODE_MANAGED_VERSION = "1.18.29";
+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"
+    );
+  }
+  if (platform === "darwin" && architecture === "x64") {
+    const asset = "opencode-darwin-x64.zip";
+    return new ZipManagedAgentArchiveDefinition(
+      OPENCODE_MANAGED_VERSION,
+      asset,
+      releaseUrl(asset),
+      "9858853e7bacdbbd22c2d70c377e009dc4b354dd04f5588705411e7afb89fd2d",
+      "opencode"
+    );
+  }
+  if (platform === "linux" && architecture === "arm64") {
+    const asset = "opencode-linux-arm64.tar.gz";
+    return new TarGzipManagedAgentArchiveDefinition(
+      OPENCODE_MANAGED_VERSION,
+      asset,
+      releaseUrl(asset),
+      "70baf769395ca4e7a68924026530c390eace194f3b7e4919d4efcb2aa2eed3c0",
+      "opencode"
+    );
+  }
+  if (platform === "linux" && architecture === "x64") {
+    const asset = "opencode-linux-x64.tar.gz";
+    return new TarGzipManagedAgentArchiveDefinition(
+      OPENCODE_MANAGED_VERSION,
+      asset,
+      releaseUrl(asset),
+      "ea800b7ff56226b70952126c9fc1e2517ca4c4b5682fd9d3f9e87449697a1194",
+      "opencode"
+    );
+  }
+  throw new Error(
+    "OpenCode does not publish an approved archive for this platform"
+  );
+}
+
+// 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(
+    join9(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    openCodeManagedArchive(platform, process.arch),
+    signal
+  );
+  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 join10 } from "node:path";
+import {
+  methods as methods3
+} 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 = ACP_PROBE_TIMEOUT_MILLISECONDS2;
+  adapterEnvironmentVariable = "PI_ACP_PI_COMMAND";
+  adapterOverrideVariable = "MOBIUS_PI_ACP_PATH";
+  adapterPackageDefinition = PI_ACP_PACKAGE;
+  adapterVersionArguments = [];
+  authenticationCommand = () => "pi-acp --terminal-login";
+  agentExecutable = "pi";
+  agentOverrideVariable = "MOBIUS_PI_PATH";
+  id = "pi";
+  label = "Pi";
+  managedAdapterExecutablePath = [
+    "adapters",
+    "pi",
+    PI_ACP_PACKAGE.version,
+    "node_modules",
+    "pi-acp",
+    "dist",
+    "index.js"
+  ];
+  managedAgentExecutablePath = [
+    "agents",
+    "pi",
+    PI_AGENT_PACKAGE.version,
+    "node_modules",
+    "@earendil-works",
+    "pi-coding-agent",
+    "dist",
+    "bundle",
+    "cli.js"
+  ];
+  promptTimeoutMilliseconds = PROMPT_TIMEOUT_MILLISECONDS;
+  resolveManagedAgent = async (stateDirectory, _platform, signal) => {
+    signal.throwIfAborted();
+    const executable = await validateManagedNpmPackage(
+      join10(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) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Pi ACP adapter does not support session recovery"
+      );
+    }
+    const session = await connection.agent.request(
+      methods3.agent.session.new,
+      {
+        additionalDirectories: [],
+        cwd: defaultWorkspace,
+        mcpServers: []
+      },
+      { cancellationSignal: signal }
+    );
+    if (session.sessionId.length === 0) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Pi ACP adapter returned an invalid session"
+      );
+    }
+    const prompt = await connection.agent.request(
+      methods3.agent.session.prompt,
+      {
+        prompt: [{ text: "/session", type: "text" }],
+        sessionId: session.sessionId
+      },
+      { cancellationSignal: signal }
+    );
+    if (prompt.stopReason !== "end_turn") {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Pi ACP adapter did not complete its conformance prompt"
+      );
+    }
+  };
+};
+
+// 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 spawn3 } from "node:child_process";
+import {
+  methods as methods4,
+  ndJsonStream as ndJsonStream2,
+  PROTOCOL_VERSION as PROTOCOL_VERSION2,
+  RequestError as RequestError2
+} from "@agentclientprotocol/sdk";
+
+// src/agent-catalog/executable-discovery.ts
+import { isAbsolute as isAbsolute4, join as join12 } from "node:path";
+
+// src/agent-installation/managed-adapter-installer.ts
+import { join as join11 } from "node:path";
+var ManagedAdapterInstallError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "ManagedAdapterInstallError";
+  }
+};
+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
     );
-    this.unavailable = Object.freeze(unavailable);
+  } catch (error61) {
+    throw translateError(error61);
   }
-  readyAgents = () => this.available.map((discovery) => discovery.agent);
-};
-var AgentProbeError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "AgentProbeError";
+}
+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 = join11(
+      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);
+    }
+  };
 };
-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();
-};
-async function resolveManagedExecutable(managedExecutablePath, options) {
-  return await resolveExecutablePath(
-    join6(readStateDirectory(options.environment), ...managedExecutablePath),
-    options.platform
-  );
+
+// src/agent-catalog/executable-discovery.ts
+async function resolveManagedExecutable(specification, context) {
+  try {
+    return await specification.resolveManagedAgent(
+      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),
+      join12(
+        readStateDirectory(context.environment),
         "adapters",
         specification.id,
         specification.adapterVersion
@@ -24359,19 +25711,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 || !isAbsolute(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) {
@@ -24382,44 +25734,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.managedAgentExecutablePath,
-      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, environment, defaultWorkspace, signal) {
+async function probeVersion(executable, arguments_, environment, defaultWorkspace, signal, timeoutMilliseconds) {
   const result = await runBoundedProcess({
-    arguments: ["--version"],
+    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) {
@@ -24438,62 +25793,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,
-        options.environment,
-        options.defaultWorkspace,
-        options.signal
+        specification.agentVersionArguments,
+        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;
     }
   });
 }
@@ -24512,14 +25878,14 @@ function writableAcpStream(output2) {
     }
   });
 }
-async function probeAcp(agent, environment, defaultWorkspace, signal) {
+async function probeAcpReadiness(specification, agent, environment, defaultWorkspace, signal) {
   signal.throwIfAborted();
   const controller = new AbortController();
   let timedOut = false;
   const timeout = setTimeout(() => {
     timedOut = true;
     controller.abort(new Error("ACP probe timed out"));
-  }, ACP_PROBE_TIMEOUT_MILLISECONDS);
+  }, specification.acpProbeTimeoutMilliseconds);
   const abort = () => controller.abort(signal.reason);
   signal.addEventListener("abort", abort, { once: true });
   if (signal.aborted) {
@@ -24556,13 +25922,13 @@ async function probeAcp(agent, environment, defaultWorkspace, signal) {
     }
   };
   stderr.on("data", consumeStderr);
-  const connection = createAcpClient(new DiscoveryAcpHandler()).connect(
-    ndJsonStream2(writableAcpStream(stdin), readableAcpStream(stdout))
-  );
+  const connection = createAcpClient(
+    new DiscoveryAcpHandler()
+  ).connect(ndJsonStream2(writableAcpStream(stdin), readableAcpStream(stdout)));
   try {
     const initialized = await Promise.race([
       connection.agent.request(
-        methods3.agent.initialize,
+        methods4.agent.initialize,
         {
           clientCapabilities: {},
           clientInfo: { name: "mobius", version: "0.0.3" },
@@ -24578,6 +25944,13 @@ async function probeAcp(agent, environment, defaultWorkspace, signal) {
         "ACP adapter selected an unsupported protocol version"
       );
     }
+    await specification.verifyAcp(
+      connection,
+      initialized,
+      defaultWorkspace,
+      controller.signal
+    );
+    return normalizedVersion(initialized.agentInfo?.version ?? "");
   } catch (error61) {
     if (signal.aborted) {
       signal.throwIfAborted();
@@ -24592,6 +25965,13 @@ async function probeAcp(agent, environment, defaultWorkspace, signal) {
     if (error61 instanceof AgentProbeError) {
       throw error61;
     }
+    if (error61 instanceof RequestError2 && error61.code === -32e3 && specification.authenticationCommand().length > 0) {
+      throw new AgentProbeError(
+        "authentication_required",
+        "Agent authentication is required",
+        { cause: error61 }
+      );
+    }
     throw new AgentProbeError(
       "acp_incompatible",
       "ACP adapter initialization failed",
@@ -24606,8 +25986,13 @@ async function probeAcp(agent, environment, defaultWorkspace, signal) {
     await stopProcessTree(child);
   }
 }
+
+// src/agent-catalog/discover-agent.ts
 function probeFailure(specification, executableKind, error61) {
   if (error61 instanceof AgentProbeError) {
+    if (error61.code === "authentication_required") {
+      return new AuthenticationRequiredAgent(specification);
+    }
     return error61.code === "acp_incompatible" ? new IncompatibleAdapter(specification) : new ProbeFailed(specification, error61.code, error61.message);
   }
   if (error61 instanceof ProcessExecutionError) {
@@ -24624,12 +26009,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);
   }
@@ -24642,32 +26030,46 @@ async function discoverSpecification(specification, options) {
     try {
       agentVersion = await probeVersion(
         agent,
-        options.environment,
-        options.defaultWorkspace,
-        options.signal
+        specification.agentVersionArguments,
+        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 {
-        adapterVersion = await probeVersion(
-          adapter,
-          {
-            ...options.environment,
-            [specification.adapterEnvironmentVariable]: agent.path
-          },
-          options.defaultWorkspace,
-          options.signal
+        launchEnvironment = await specification.createLaunchEnvironment(
+          agent,
+          context
         );
+        if (specification.adapterVersionArguments.length > 0) {
+          adapterVersion = await probeVersion(
+            adapter,
+            specification.adapterVersionArguments,
+            {
+              ...context.environment,
+              ...launchEnvironment
+            },
+            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;
@@ -24676,36 +26078,65 @@ async function discoverSpecification(specification, options) {
         specification.id,
         specification.label,
         adapter.path,
-        [],
-        { [specification.adapterEnvironmentVariable]: agent.path },
+        specification.launchArguments,
+        launchEnvironment,
         adapterVersion,
         agentVersion,
         adapter.identity,
-        agent.identity
+        agent.identity,
+        specification.promptTimeoutMilliseconds
       );
       try {
-        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) {
+          throw new AgentProbeError(
+            "acp_incompatible",
+            "ACP adapter did not report a version"
+          );
+        }
+        return new AvailableAgent(
+          specification,
+          new LocalAgentDefinition(
+            specification.id,
+            specification.label,
+            adapter.path,
+            specification.launchArguments,
+            launchEnvironment,
+            verifiedAdapterVersion,
+            agentVersion,
+            adapter.identity,
+            agent.identity,
+            specification.promptTimeoutMilliseconds
+          )
         );
-        return new AvailableAgent(specification, definition);
       } 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();
@@ -24723,10 +26154,6 @@ async function discoverLocalAgentInventory(options) {
   );
 }
 
-// src/network/environment-proxy.ts
-import { EnvHttpProxyAgent } from "undici";
-var environmentProxyDispatcher = new EnvHttpProxyAgent();
-
 // src/pairing/pair-local-machine.ts
 var PAIRING_TIMEOUT_MILLISECONDS = 2e4;
 var PAIRING_CODE_PATTERN = /^[A-HJ-NP-Z2-9]{4}(?:-[A-HJ-NP-Z2-9]{4}){4}$/;
@@ -24752,7 +26179,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -24865,9 +26292,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",
@@ -24905,9 +26332,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord6(value)) {
+  if (isRecord7(value)) {
     const error61 = value["error"];
-    if (isRecord6(error61)) {
+    if (isRecord7(error61)) {
       const code = error61["code"];
       const message = error61["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -24921,7 +26348,7 @@ function readRelayError(value) {
   );
 }
 function decodeClaimResponse(value) {
-  if (!isRecord6(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
+  if (!isRecord7(value) || !hasExactKeys(value, CLAIM_RESPONSE_KEYS)) {
     throw new PairingClientError(
       "invalid_relay_response",
       "The relay returned an invalid pairing response"
@@ -24946,7 +26373,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   const endpoint = new URL("/api/pairings/claim", options.relayOrigin);
   let response;
   try {
-    response = await fetch(endpoint, {
+    response = await fetch2(endpoint, {
       body: JSON.stringify({
         agents,
         installableAgents: installableAgents.map((agent) => ({
@@ -24980,14 +26407,14 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   return decodeClaimResponse(value);
 }
 async function persistConnection(channelId, relayOrigin, daemonToken, defaultWorkspace) {
-  const connectionsDirectory = join7(readStateDirectory(), "connections");
-  await mkdir2(connectionsDirectory, { mode: 448, recursive: true });
-  const connectionPath = join7(connectionsDirectory, `${channelId}.json`);
-  const temporaryPath = join7(
+  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(
       {
@@ -25002,11 +26429,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 (!isRecord6(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
+  if (!isRecord7(value) || !hasExactKeys(value, SAVED_CONNECTION_KEYS)) {
     throw new PairingClientError(
       "invalid_connection",
       "The saved connection is invalid"
@@ -25030,13 +26457,13 @@ function decodeSavedConnection(value, expectedChannelId) {
   };
 }
 async function readSavedConnection(channelId) {
-  const connectionPath = join7(
+  const connectionPath = join13(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
   );
   let encoded = "";
-  const handle = await open4(connectionPath, "r");
+  const handle = await open6(connectionPath, "r");
   try {
     const metadata = await handle.stat();
     if (!metadata.isFile() || metadata.size > MAX_CONNECTION_FILE_LENGTH) {
@@ -25085,7 +26512,7 @@ function buildPairedDaemon(connection, connectionPath, inventory) {
   );
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.daemonToken);
-  const auditDatabasePath = join7(
+  const auditDatabasePath = join13(
     readStateDirectory(),
     "audit",
     `${connection.channelId}.sqlite`
@@ -25144,7 +26571,7 @@ async function pairLocalMachine(arguments_, signal = new AbortController().signa
 }
 async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
   const channelId = parseChannelArgument(arguments_);
-  const connectionPath = join7(
+  const connectionPath = join13(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
@@ -25163,7 +26590,7 @@ import { basename as basename3 } from "node:path";
 import { WebSocket as WebSocket2 } from "undici";
 
 // 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";
@@ -25190,7 +26617,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,
@@ -25596,7 +27023,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
   );
@@ -25640,6 +27067,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(
@@ -25719,252 +27150,59 @@ var AutomaticAdapterProvisioner = class {
           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 join8 } 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"
+          this.#specifications
+        )
       );
     }
-    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"
+    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
       );
-    }
-    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"
+      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;
       }
-    }
-    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"
-          );
+      this.#options.audit.record(
+        "agent_adapter_auto_install_verified",
+        attempt.requestId,
+        attempt.specification.id,
+        {
+          adapterVersion: available.agent.adapterVersion,
+          agentVersion: available.agent.agentVersion
         }
-        digest.update(chunk.value);
-        await writeCompleteChunk(handle, chunk.value);
-      }
-    } finally {
-      await reader.cancel().catch(() => void 0);
-      reader.releaseLock();
-    }
-    if (bytes === 0) {
-      throw new InstallerDownloadError(
-        "installer_verification_failed",
-        "The downloaded installer is empty"
       );
-    }
-    await handle.sync();
-    await handle.close();
-    handle = null;
-    return new VerifiedDownload(fetched.url, bytes, digest.digest("hex"));
-  } catch (error61) {
-    if (handle !== null) {
-      await handle.close().catch(() => void 0);
-    }
-    await unlink(options.destination).catch(() => void 0);
-    if (options.signal.aborted) {
-      options.signal.throwIfAborted();
-    }
-    if (timeoutSignal.aborted) {
-      throw new InstallerDownloadError(
-        "installer_download_timeout",
-        "The installer download timed out",
-        { cause: error61 }
+      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") {
@@ -25991,22 +27229,22 @@ var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
   releaseChannel = "latest";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join8(options.stateDirectory, "agents", this.id);
-    const temporaryRoot = join8(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(
-      join8(temporaryRoot, ".codex-install-")
+    const temporaryDirectory = await mkdtemp3(
+      join14(temporaryRoot, ".codex-install-")
     );
-    const installerPath = join8(temporaryDirectory, "install.sh");
-    const installDirectory = join8(root, "bin");
-    const codexHome = join8(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({
@@ -26039,14 +27277,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(
-        join8(installDirectory, "codex")
+        join14(installDirectory, "codex")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -26060,7 +27298,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 });
     }
   };
 };
@@ -26070,17 +27308,17 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
   releaseChannel = "stable";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join8(options.stateDirectory, "agents", this.id);
-    const managedHome = join8(root, "home");
-    const temporaryRoot = join8(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(
-      join8(temporaryRoot, ".claude-install-")
+    const temporaryDirectory = await mkdtemp3(
+      join14(temporaryRoot, ".claude-install-")
     );
-    const installerPath = join8(temporaryDirectory, "install.sh");
+    const installerPath = join14(temporaryDirectory, "install.sh");
     try {
       await options.report("downloading");
       const download = await downloadVerifiedFile({
@@ -26109,7 +27347,7 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
         cwd: temporaryDirectory,
         environment: {
           HOME: managedHome,
-          PATH: MINIMAL_PATH,
+          PATH: MINIMAL_PATH2,
           SHELL: "/bin/bash"
         },
         outputLimitBytes: 64 * 1024,
@@ -26117,7 +27355,7 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
         timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
       });
       return await this.requireInstalledExecutable(
-        join8(managedHome, ".local", "bin", "claude")
+        join14(managedHome, ".local", "bin", "claude")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -26131,14 +27369,236 @@ 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 });
+    }
+  };
+};
+var PiInstallRecipe = class extends FixedAgentInstallRecipe {
+  #npmInstaller;
+  id = "pi";
+  label = "Pi";
+  releaseChannel = PI_AGENT_PACKAGE.version;
+  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
+    super();
+    this.#npmInstaller = npmInstaller;
+  }
+  install = async (options) => {
+    this.assertSupportedPlatform();
+    try {
+      await options.report("downloading");
+      await options.report("verifying");
+      await options.report("installing_agent");
+      const executable = await this.#npmInstaller.install(
+        join14(
+          options.stateDirectory,
+          "agents",
+          this.id,
+          PI_AGENT_PACKAGE.version
+        ),
+        PI_AGENT_PACKAGE,
+        options.environment,
+        options.signal
+      );
+      options.audit.record(
+        "agent_npm_package_verified",
+        options.requestId,
+        this.id,
+        {
+          integrity: PI_AGENT_PACKAGE.integrity,
+          package: PI_AGENT_PACKAGE.packageName,
+          version: PI_AGENT_PACKAGE.version
+        }
+      );
+      return executable;
+    } catch (error61) {
+      if (options.signal.aborted) {
+        options.signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedNpmPackageError) {
+        if (error61.code === "managed_package_verification_failed") {
+          throw new InstallationManagerError(
+            "agent_verification_failed",
+            "The managed Pi package did not match its pinned artifact",
+            { cause: error61 }
+          );
+        }
+        if (error61.code === "managed_package_publish_failed") {
+          throw new InstallationManagerError(
+            "agent_publish_failed",
+            "The managed Pi package could not be published",
+            { cause: error61 }
+          );
+        }
+        throw new InstallationManagerError(error61.code, error61.message, {
+          cause: error61
+        });
+      }
+      if (error61 instanceof InstallationManagerError) {
+        throw error61;
+      }
+      throw new InstallationManagerError(
+        "agent_install_failed",
+        "The fixed Pi installation recipe failed",
+        { cause: error61 }
+      );
+    }
+  };
+};
+var DeepSeekHarnessInstallRecipe = class extends FixedAgentInstallRecipe {
+  #npmInstaller;
+  id = "deepseek-harness";
+  label = "DeepSeek Harness";
+  releaseChannel = DEEPSEEK_HARNESS_PACKAGE.version;
+  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
+    super();
+    this.#npmInstaller = npmInstaller;
+  }
+  install = async (options) => {
+    this.assertSupportedPlatform();
+    try {
+      const managedHome = 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 ClaudeCodeInstallRecipe(),
+    new PiInstallRecipe(),
+    new DeepSeekHarnessInstallRecipe(),
+    new OpenCodeInstallRecipe()
   ]);
 }
 
@@ -26268,6 +27728,7 @@ var FixedInstallationExecutor = class {
       if (agent === null) {
         agent = await recipe.install({
           audit: this.#audit,
+          environment: this.#environment,
           report,
           requestId,
           signal,
@@ -26275,12 +27736,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;
@@ -26337,7 +27801,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;
@@ -26349,12 +27813,16 @@ var FixedInstallationExecutor = class {
         if (!installedAgent && (requiresAgentReplacement(unavailable.code) || unavailable.code === "acp_incompatible")) {
           agent = await recipe.install({
             audit: this.#audit,
+            environment: this.#environment,
             report,
             requestId,
             signal,
             stateDirectory: this.#stateDirectory
           });
           installedAgent = true;
+          if (specification instanceof DirectAcpAgentDefinition) {
+            adapter = agent;
+          }
           continue;
         }
         throw new InstallationManagerError(
@@ -26407,15 +27875,15 @@ Mobius Web requested installation of ${label} (${requestId}). Allow this fixed u
 };
 
 // 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 isAbsolute2,
-  join as join9,
-  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;
@@ -26443,7 +27911,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;
 }
@@ -26465,20 +27933,20 @@ var WorkspaceDirectoryService = class {
     if (id === "home") return homedir2();
     if (id.startsWith("path-")) {
       const path2 = decodePath(id, "path-");
-      if (isAbsolute2(path2)) return path2;
+      if (isAbsolute5(path2)) return path2;
     }
     throw new LocalAuthorizationError("The directory identifier is invalid");
   };
   resolvePath = async (requested, signal) => {
     signal.throwIfAborted();
-    if (!isAbsolute2(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 (!isAbsolute2(target) || normalize(target) !== target || !metadata.isDirectory())
+      if (!isAbsolute5(target) || normalize2(target) !== target || !metadata.isDirectory())
         throw new LocalAuthorizationError(
           "The selected location is not a directory"
         );
@@ -26493,8 +27961,8 @@ var WorkspaceDirectoryService = class {
     }
   };
   label = (path2) => {
-    const suffix = relative2(homedir2(), path2);
-    return suffix === "" ? "~" : !isAbsolute2(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);
@@ -26522,7 +27990,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join9(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();
@@ -26530,7 +27998,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),
@@ -26645,7 +28113,8 @@ function decodeHistory(thread, value) {
       status: "available",
       messages,
       truncated,
-      coveredCommandIds: []
+      coveredCommandIds: [],
+      coveredMessageIds: []
     }
   };
 }
@@ -27322,7 +28791,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)) {
@@ -27337,7 +28806,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 (