@moxt-ai/mobius 0.0.318 → 0.0.319

package/dist/runtime.js

@@ -1017,92 +1017,46 @@ function restrictAcpSessionCapabilities(capabilities, response) {
 }
 
 // src/acp/agent/agent-definition.ts
-var AgentDefinition = class {
+var AcpAgentDefinition = class _AcpAgentDefinition {
   agentIdentity;
   agentVersion;
+  adapterVersion;
   capabilities;
   command;
   environment;
   id;
   label;
-  constructor(id, label, _command, environment, agentVersion, agentIdentity, capabilities) {
+  runtimeExecutables;
+  #connectionFactory;
+  constructor(id, label, command, createConnection, environment = {}, agentVersion = "", agentIdentity = readExecutableIdentity(command), capabilities = unsupportedSessionCapabilities(), adapterVersion = agentVersion, runtimeExecutables = [agentIdentity]) {
     this.agentIdentity = agentIdentity;
     this.agentVersion = agentVersion;
+    this.adapterVersion = adapterVersion;
     this.capabilities = Object.freeze({ ...capabilities });
     this.command = agentIdentity.realPath;
     this.environment = Object.freeze({ ...environment });
     this.id = id;
     this.label = label;
+    this.runtimeExecutables = Object.freeze([.../* @__PURE__ */ new Set([agentIdentity, ...runtimeExecutables])]);
+    this.#connectionFactory = createConnection;
   }
-};
-var LocalAgentDefinition = class _LocalAgentDefinition extends AgentDefinition {
-  kind = "acp-adapter-process";
-  adapterIdentity;
-  adapterPath;
-  adapterVersion;
-  arguments;
-  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readExecutableIdentity(command), agentIdentity = adapterIdentity, capabilities = unsupportedSessionCapabilities()) {
-    super(id, label, command, environment, agentVersion, agentIdentity, capabilities);
-    this.adapterIdentity = adapterIdentity;
-    this.adapterPath = adapterIdentity.realPath;
-    this.adapterVersion = adapterVersion;
-    this.arguments = Object.freeze([...arguments_]);
-  }
-  withEnvironment = (environment) => new _LocalAgentDefinition(
+  createConnection = (options) => this.#connectionFactory({ ...options, command: this.command, environment: this.environment });
+  withEnvironment = (environment) => new _AcpAgentDefinition(
     this.id,
     this.label,
     this.command,
-    this.arguments,
+    this.#connectionFactory,
     environment,
-    this.adapterVersion,
     this.agentVersion,
-    this.adapterIdentity,
     this.agentIdentity,
-    this.capabilities
-  );
-};
-var InProcessAcpAgentDefinition = class _InProcessAcpAgentDefinition extends AgentDefinition {
-  kind = "in-process-acp";
-  createEndpoint;
-  constructor(id, label, command, createEndpoint, environment = {}, agentVersion = "", agentIdentity = readExecutableIdentity(command), capabilities = unsupportedSessionCapabilities()) {
-    super(id, label, command, environment, agentVersion, agentIdentity, capabilities);
-    this.createEndpoint = createEndpoint;
-  }
-  withEnvironment = (environment) => new _InProcessAcpAgentDefinition(
-    this.id,
-    this.label,
-    this.command,
-    this.createEndpoint,
-    environment,
-    this.agentVersion,
-    this.agentIdentity,
-    this.capabilities
+    this.capabilities,
+    this.adapterVersion,
+    this.runtimeExecutables
   );
 };
 
-// src/acp/adapter/adapter-registry.ts
-var AdapterRegistry = class {
-  #resolve;
-  #dependencies;
-  #adapters = /* @__PURE__ */ new Map();
-  constructor(resolve19, dependencies) {
-    this.#resolve = resolve19;
-    this.#dependencies = dependencies;
-  }
-  resolve = (agent) => {
-    const existing = this.#adapters.get(agent.id);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const adapter = this.#resolve(agent, this.#dependencies);
-    this.#adapters.set(agent.id, adapter);
-    return adapter;
-  };
-  close = async () => {
-    await Promise.all([...this.#adapters.values()].map((adapter) => adapter.close()));
-    this.#adapters.clear();
-  };
-};
+// src/acp/connection/agent-operation.ts
+import { RequestError } from "@agentclientprotocol/sdk";
 
 // src/infra/operation-error.ts
 var OperationError = class extends Error {
@@ -1141,6 +1095,145 @@ var AcpConfigurationValueUnavailableError = class extends AcpExecutionError {
   }
 };
 
+// src/acp/agent/in-process-endpoint.ts
+function acpEndpointTerminationError(termination) {
+  switch (termination.kind) {
+    case "failed":
+      return termination.error;
+    case "closed":
+      return new AcpExecutionError("The ACP endpoint is closed", {}, "acp_endpoint_closed");
+    default: {
+      const unreachable3 = termination;
+      return unreachable3;
+    }
+  }
+}
+
+// src/acp/connection/agent-operation.ts
+function requestErrorMessage(error62) {
+  const fallback = truncate(error62.message, 500);
+  if (error62.message !== "Internal error" || !isRecord(error62.data)) {
+    return fallback;
+  }
+  const agentError = error62.data["error"];
+  if (isRecord(agentError)) {
+    const message = agentError["message"];
+    if (typeof message === "string" && message.length > 0) {
+      return truncate(message, 500);
+    }
+  }
+  const details = error62.data["details"];
+  return typeof details === "string" && details.length > 0 ? truncate(details, 500) : fallback;
+}
+async function raceAgentOperation(operation, termination, exitMessage, signal) {
+  let removeAbortListener = () => {
+  };
+  const aborted2 = new Promise((_resolve, reject2) => {
+    const rejectAbort = () => {
+      reject2(signal.reason ?? new Error("ACP request was cancelled"));
+    };
+    signal.addEventListener("abort", rejectAbort, { once: true });
+    removeAbortListener = () => signal.removeEventListener("abort", rejectAbort);
+    if (signal.aborted) {
+      rejectAbort();
+    }
+  });
+  try {
+    return await Promise.race([
+      aborted2,
+      operation,
+      termination.then((result) => {
+        const cause = acpEndpointTerminationError(result);
+        throw new AcpExecutionError(exitMessage, { cause }, cause.code);
+      })
+    ]);
+  } catch (error62) {
+    signal.throwIfAborted();
+    if (error62 instanceof RequestError && error62.code === -32e3) {
+      throw new AcpExecutionError(
+        "Agent authentication is required",
+        { cause: error62 },
+        "authentication_required"
+      );
+    }
+    if (error62 instanceof RequestError) {
+      throw new AcpExecutionError(requestErrorMessage(error62), { cause: error62 }, "acp_agent_error");
+    }
+    throw error62;
+  } finally {
+    removeAbortListener();
+  }
+}
+
+// src/acp/connection/create-client.ts
+import {
+  client,
+  methods
+} from "@agentclientprotocol/sdk";
+var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
+  methods.client.session.requestPermission,
+  async (context) => await handler.onPermission(context.params, context.signal)
+).onRequest(
+  methods.client.elicitation.create,
+  async (context) => await handler.onElicitation(context.params, context.signal)
+).onNotification(methods.client.session.update, async (context) => {
+  await handler.onUpdate(context.params);
+}).onNotification(methods.client.elicitation.complete, async (context) => {
+  await handler.onElicitationComplete(context.params);
+});
+
+// src/acp/connection/endpoint-agent-connection.ts
+var EndpointAgentConnection = class {
+  #endpoint;
+  connection;
+  termination;
+  #closePromise = null;
+  constructor(endpoint, client2) {
+    this.#endpoint = endpoint;
+    this.termination = endpoint.terminated;
+    this.connection = createAcpClient(client2).connect(endpoint.app());
+  }
+  initialize = async (signal) => {
+    await this.#endpoint.initialize(signal);
+  };
+  agentSettingsModelEffort = () => this.#endpoint.agentSettingsModelEffort?.() ?? null;
+  closeProcess = () => {
+    this.#closePromise ??= (async () => {
+      try {
+        await this.#endpoint.close();
+      } finally {
+        this.connection.close();
+      }
+    })();
+    return this.#closePromise;
+  };
+  race = (operation, exitMessage, signal) => raceAgentOperation(operation, this.termination, exitMessage, signal);
+};
+
+// src/acp/adapter/adapter-registry.ts
+var AdapterRegistry = class {
+  #resolve;
+  #dependencies;
+  #adapters = /* @__PURE__ */ new Map();
+  constructor(resolve19, dependencies) {
+    this.#resolve = resolve19;
+    this.#dependencies = dependencies;
+  }
+  resolve = (agent) => {
+    const existing = this.#adapters.get(agent.id);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const adapter = this.#resolve(agent, this.#dependencies);
+    this.#adapters.set(agent.id, adapter);
+    return adapter;
+  };
+  close = async () => {
+    await Promise.all([...this.#adapters.values()].map((adapter) => adapter.close()));
+    this.#adapters.clear();
+  };
+};
+
 // src/util/run-cleanup.ts
 async function runCleanup(...actions) {
   const [first, ...remaining] = actions;
@@ -22842,7 +22935,7 @@ var nativeSessionPageSchema = external_exports.object({
 }).readonly();
 
 // src/acp/protocol/session-config-protocol.ts
-import { methods } from "@agentclientprotocol/sdk";
+import { methods as methods2 } from "@agentclientprotocol/sdk";
 var MAXIMUM_CONFIG_OPTIONS = 100;
 var SessionConfigProtocolError = class extends Error {
   code = "invalid_session_configuration_response";
@@ -23012,7 +23105,7 @@ var StandardSessionConfigProtocol = class {
     }
     if (existing.type === "select" && existing.category === "mode") {
       await transport.request(
-        methods.agent.session.setMode,
+        methods2.agent.session.setMode,
         { modeId: change.value, sessionId: nativeSessionId },
         "ACP agent exited while setting the session mode",
         change.signal
@@ -23030,7 +23123,7 @@ var StandardSessionConfigProtocol = class {
       value: change.value
     };
     const response = await transport.request(
-      methods.agent.session.setConfigOption,
+      methods2.agent.session.setConfigOption,
       params,
       "ACP agent exited while changing session configuration",
       change.signal
@@ -23051,266 +23144,6 @@ function sessionConfigProtocolForAgent(_agentId) {
 // src/acp/adapter/session-events.ts
 import { setImmediate as yieldToRuntime2 } from "node:timers/promises";
 
-// src/acp/connection/agent-connection.ts
-import { spawn as spawn2 } from "node:child_process";
-import { ndJsonStream, RequestError } from "@agentclientprotocol/sdk";
-
-// src/acp/agent/in-process-endpoint.ts
-function acpEndpointTerminationError(termination) {
-  switch (termination.kind) {
-    case "failed":
-      return termination.error;
-    case "closed":
-      return new AcpExecutionError("The ACP endpoint is closed", {}, "acp_endpoint_closed");
-    default: {
-      const unreachable3 = termination;
-      return unreachable3;
-    }
-  }
-}
-
-// src/acp/connection/create-client.ts
-import {
-  client,
-  methods as methods2
-} from "@agentclientprotocol/sdk";
-var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
-  methods2.client.session.requestPermission,
-  async (context) => await handler.onPermission(context.params, context.signal)
-).onRequest(
-  methods2.client.elicitation.create,
-  async (context) => await handler.onElicitation(context.params, context.signal)
-).onNotification(methods2.client.session.update, async (context) => {
-  await handler.onUpdate(context.params);
-}).onNotification(methods2.client.elicitation.complete, async (context) => {
-  await handler.onElicitationComplete(context.params);
-});
-
-// src/acp/connection/agent-connection.ts
-function requestErrorMessage(error62) {
-  const fallback = truncate(error62.message, 500);
-  if (error62.message !== "Internal error" || !isRecord(error62.data)) {
-    return fallback;
-  }
-  const agentError = error62.data["error"];
-  if (isRecord(agentError)) {
-    const message = agentError["message"];
-    if (typeof message === "string" && message.length > 0) {
-      return truncate(message, 500);
-    }
-  }
-  const details = error62.data["details"];
-  return typeof details === "string" && details.length > 0 ? truncate(details, 500) : fallback;
-}
-function readableWebStream(input2) {
-  let streamOpen = true;
-  return new ReadableStream({
-    start(controller) {
-      input2.on("data", (chunk) => {
-        if (!streamOpen) {
-          return;
-        }
-        if (chunk instanceof Uint8Array) {
-          controller.enqueue(new Uint8Array(chunk));
-          return;
-        }
-        streamOpen = false;
-        controller.error(new Error("ACP process produced a non-binary chunk"));
-      });
-      input2.once("end", () => {
-        if (!streamOpen) {
-          return;
-        }
-        streamOpen = false;
-        controller.close();
-      });
-      input2.once("error", (error62) => {
-        if (!streamOpen) {
-          return;
-        }
-        streamOpen = false;
-        controller.error(error62);
-      });
-    },
-    cancel() {
-      streamOpen = false;
-    }
-  });
-}
-function createWritableAcpStream(output2) {
-  let outputFailure;
-  const pendingWriteFailures = /* @__PURE__ */ new Set();
-  const fail = (error62) => {
-    outputFailure = error62;
-    for (const reject2 of pendingWriteFailures) {
-      reject2(error62);
-    }
-    pendingWriteFailures.clear();
-  };
-  output2.on("error", fail);
-  output2.once("close", () => {
-    if (outputFailure === void 0) {
-      fail(new Error("ACP process input closed"));
-    }
-  });
-  return new WritableStream({
-    write(chunk) {
-      if (outputFailure !== void 0) {
-        return Promise.reject(outputFailure);
-      }
-      return new Promise((resolve19, reject2) => {
-        pendingWriteFailures.add(reject2);
-        output2.write(chunk, (error62) => {
-          pendingWriteFailures.delete(reject2);
-          if (error62) {
-            outputFailure = error62;
-            reject2(error62);
-            return;
-          }
-          if (outputFailure !== void 0) {
-            reject2(outputFailure);
-            return;
-          }
-          resolve19();
-        });
-      });
-    }
-  });
-}
-var AgentConnection = class {
-  connection;
-  termination;
-  #process;
-  constructor(agent, cwd, client2, onBackgroundActivity = () => {
-  }) {
-    if (agent.kind === "in-process-acp") {
-      const inProcess = agent.createEndpoint({
-        command: agent.command,
-        cwd,
-        environment: agent.environment,
-        onSessionUpdate: client2.onUpdate,
-        onBackgroundActivity
-      });
-      this.#process = { kind: "in-process", endpoint: inProcess };
-      this.termination = inProcess.terminated;
-      this.connection = createAcpClient(client2).connect(inProcess.app());
-      return;
-    }
-    const launch = executableLaunch2(agent.adapterPath, agent.arguments);
-    const child = spawn2(launch.command, [...launch.arguments], {
-      cwd,
-      ...platformSpawnOptions,
-      env: { ...process.env, ...agent.environment },
-      shell: false,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    this.#process = { kind: "child", child };
-    const stdin = child.stdin;
-    const stdout = child.stdout;
-    const stderr = child.stderr;
-    if (stdin === null || stdout === null || stderr === null) {
-      child.kill("SIGKILL");
-      throw new AcpExecutionError("ACP process streams are unavailable");
-    }
-    stderr.setEncoding("utf8");
-    stderr.on("data", (chunk) => {
-      process.stderr.write(`[${agent.id}-acp] ${chunk}`);
-    });
-    this.termination = new Promise((resolve19) => {
-      child.once("error", (cause) => {
-        resolve19({ kind: "failed", error: new AcpExecutionError("The ACP process could not run", { cause }) });
-      });
-      child.once("exit", (code, signal) => {
-        resolve19({
-          kind: "failed",
-          error: new AcpExecutionError("The ACP process stopped", { cause: { code, signal } })
-        });
-      });
-    });
-    const stream = ndJsonStream(createWritableAcpStream(stdin), readableWebStream(stdout));
-    let pendingUpdates = 0;
-    this.connection = createAcpClient({
-      onElicitation: client2.onElicitation,
-      onElicitationComplete: client2.onElicitationComplete,
-      onPermission: client2.onPermission,
-      // ACP notifications acknowledge transport writes, not their consumption.
-      // Stop reading the child while updates from the current chunk drain;
-      // the OS pipe then backpressures history replay instead of filling our queue.
-      onUpdate: async (notification) => {
-        pendingUpdates += 1;
-        stdout.pause();
-        try {
-          await client2.onUpdate(notification);
-        } finally {
-          pendingUpdates -= 1;
-          if (pendingUpdates === 0) {
-            stdout.resume();
-          }
-        }
-      }
-    }).connect(stream);
-  }
-  get inProcessAgent() {
-    return this.#process.kind === "in-process" ? this.#process.endpoint : null;
-  }
-  closeProcess = async () => {
-    try {
-      if (this.#process.kind === "in-process") {
-        await this.#process.endpoint.close();
-        return;
-      }
-      await stopProcessTree(this.#process.child);
-    } finally {
-      this.connection.close();
-    }
-  };
-  race = async (operation, exitMessage, signal) => {
-    let removeAbortListener = () => {
-    };
-    const aborted2 = new Promise((_resolve, reject2) => {
-      const rejectAbort = () => {
-        reject2(signal.reason ?? new Error("ACP request was cancelled"));
-      };
-      signal.addEventListener("abort", rejectAbort, { once: true });
-      removeAbortListener = () => {
-        signal.removeEventListener("abort", rejectAbort);
-      };
-      if (signal.aborted) {
-        rejectAbort();
-      }
-    });
-    try {
-      try {
-        return await Promise.race([
-          // The caller has already started operation. Even when cancellation
-          // won before entry, observe its later rejection during endpoint cleanup.
-          aborted2,
-          operation,
-          this.termination.then((termination) => {
-            const cause = acpEndpointTerminationError(termination);
-            throw new AcpExecutionError(exitMessage, { cause }, cause.code);
-          })
-        ]);
-      } catch (error62) {
-        signal.throwIfAborted();
-        if (error62 instanceof RequestError && error62.code === -32e3) {
-          throw new AcpExecutionError(
-            "Agent authentication is required",
-            { cause: error62 },
-            "authentication_required"
-          );
-        }
-        if (error62 instanceof RequestError) {
-          throw new AcpExecutionError(requestErrorMessage(error62), { cause: error62 }, "acp_agent_error");
-        }
-        throw error62;
-      }
-    } finally {
-      removeAbortListener();
-    }
-  };
-};
-
 // src/acp/connection/agent-update-stream.ts
 import { setImmediate as yieldToRuntime } from "node:timers/promises";
 var MAX_PENDING_UPDATES = 100;
@@ -23539,21 +23372,23 @@ var AdapterSessionConnection = class {
       onElicitation: options.interactions.onElicitation,
       onElicitationComplete: options.interactions.onElicitationComplete
     };
-    this.#connection = new AgentConnection(options.agent, options.cwd, client2, (active) => {
-      if (this.#lifetime.signal.aborted) {
-        return;
+    this.#connection = options.agent.createConnection({
+      cwd: options.cwd,
+      client: client2,
+      onBackgroundActivity: (active) => {
+        if (this.#lifetime.signal.aborted) {
+          return;
+        }
+        this.#backgroundActivity = active;
+        this.#onBackgroundActivity(active);
       }
-      this.#backgroundActivity = active;
-      this.#onBackgroundActivity(active);
     });
   }
   get connection() {
     return this.#connection.connection;
   }
-  get inProcessAgent() {
-    return this.#connection.inProcessAgent;
-  }
-  agentSettingsModelEffort = () => this.#connection.inProcessAgent?.agentSettingsModelEffort?.() ?? null;
+  initialize = (signal) => this.#connection.initialize(signal);
+  agentSettingsModelEffort = () => this.#connection.agentSettingsModelEffort();
   race = (operation, exitMessage, signal) => this.#connection.race(operation, exitMessage, signal);
   closeProcess = async () => {
     this.#lifetime.abort(new DOMException("The adapter event subscription closed", "AbortError"));
@@ -24611,10 +24446,7 @@ var RetryableAcpInitializationError = class extends AcpExecutionError {
 };
 async function validateAgentRuntime(agent, signal) {
   signal.throwIfAborted();
-  const unchanged = await Promise.all([
-    agent.kind === "acp-adapter-process" ? revalidateExecutable(agent.adapterIdentity) : Promise.resolve(true),
-    revalidateExecutable(agent.agentIdentity)
-  ]);
+  const unchanged = await Promise.all(agent.runtimeExecutables.map((identity2) => revalidateExecutable(identity2)));
   signal.throwIfAborted();
   if (unchanged.some((result) => !result)) {
     throw new AcpExecutionError(
@@ -24625,16 +24457,10 @@ async function validateAgentRuntime(agent, signal) {
   }
 }
 async function initializeAgentConnection(connection, agentId, verifiedVersion, signal) {
-  if (connection.inProcessAgent !== null) {
-    await connection.race(
-      connection.inProcessAgent.initialize(signal),
-      "The Codex app-server exited during initialization",
-      signal
-    ).catch((cause) => {
-      signal.throwIfAborted();
-      throw new RetryableAcpInitializationError(cause);
-    });
-  }
+  await connection.race(connection.initialize(signal), "The Agent runtime exited during initialization", signal).catch((cause) => {
+    signal.throwIfAborted();
+    throw new RetryableAcpInitializationError(cause);
+  });
   const initialized = await connection.race(
     connection.connection.agent.request(
       methods4.agent.initialize,
@@ -24943,7 +24769,7 @@ var ClaudeAdapter = class {
 import { createHash as createHash3 } from "node:crypto";
 
 // src/acp/harness/codex/app-server-client.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 
 // src/acp/harness/codex/app-server-protocol.ts
 import { isAbsolute as isAbsolute5 } from "node:path";
@@ -25263,7 +25089,7 @@ var CodexAppServerClient = class {
   constructor(options) {
     this.#handlers = options.handlers;
     const launch = executableLaunch2(options.command, ["app-server"]);
-    this.#child = spawn3(launch.command, [...launch.arguments], {
+    this.#child = spawn2(launch.command, [...launch.arguments], {
       cwd: options.cwd,
       ...platformSpawnOptions,
       env: { ...process.env, ...options.environment },
@@ -25917,12 +25743,12 @@ function presentToolItem(item) {
     };
   }
   if (item.type === "collabAgentToolCall") {
-    const spawn8 = item.tool === "spawnAgent";
+    const spawn6 = item.tool === "spawnAgent";
     return {
       content: [],
       kind: "other",
       locations: [],
-      rawInput: spawn8 ? {
+      rawInput: spawn6 ? {
         model: item.model,
         prompt: item.prompt,
         reasoningEffort: item.reasoningEffort,
@@ -25930,10 +25756,10 @@ function presentToolItem(item) {
       } : { receiverThreadIds: item.receiverThreadIds, senderThreadId: item.senderThreadId },
       rawOutput: {
         agentsStates: item.agentsStates,
-        ...spawn8 ? { receiverThreadIds: item.receiverThreadIds } : {}
+        ...spawn6 ? { receiverThreadIds: item.receiverThreadIds } : {}
       },
       status: collaborationStatus(item.status),
-      title: spawn8 ? "Dispatch subagent" : "Wait for subagent"
+      title: spawn6 ? "Dispatch subagent" : "Wait for subagent"
     };
   }
   if (item.type === "subAgentActivity" && item.kind === "started") {
@@ -32455,7 +32281,7 @@ import { fetch as fetch3 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.318",
+  version: "0.0.319",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -32559,7 +32385,7 @@ var package_default = {
 };
 
 // src/acp/harness/claude/parent-lifeline.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { Duplex } from "node:stream";
 var supervisor = `
 const { spawn, spawnSync } = require("node:child_process");
@@ -32588,7 +32414,7 @@ child.once("close", (code) => { exited = true; process.exitCode = code ?? 1; lif
 `;
 function spawnClaudeWithParentLifeline(options) {
   options.signal.throwIfAborted();
-  const child = spawn4(process.execPath, ["-e", supervisor, "--", options.command, ...options.args], {
+  const child = spawn3(process.execPath, ["-e", supervisor, "--", options.command, ...options.args], {
     cwd: options.cwd,
     env: options.env,
     stdio: ["pipe", "pipe", "pipe", "pipe"],
@@ -32638,7 +32464,7 @@ import * as fs3 from "node:fs/promises";
 import * as os3 from "node:os";
 import * as path6 from "node:path";
 import { promisify as promisify2 } from "node:util";
-import { agent as acpAgent, CreateElicitationResponse as CreateElicitationResponse2, methods as methods7, ndJsonStream as ndJsonStream2, RequestError as RequestError4 } from "@agentclientprotocol/sdk";
+import { agent as acpAgent, CreateElicitationResponse as CreateElicitationResponse2, methods as methods7, ndJsonStream, RequestError as RequestError4 } from "@agentclientprotocol/sdk";
 
 // ../../node_modules/.pnpm/@anthropic-ai+claude-agent-sdk@0.3.257_@anthropic-ai+sdk@0.122.0_zod@4.6.5__@modelconte_b0b90ed00d211c5955785f7de7f8dbf4/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as $ne } from "node:module";
@@ -73410,16 +73236,15 @@ var ClaudeAcpAgent = class {
                 session.lastSessionState = message.state;
                 if (message.state === "idle") {
                   disarmResultWatchdog();
+                  const boundary = session.idleBoundary;
+                  const hadEarlierResult = boundary.kind === "accounted" && boundary.turn !== session.activeTurn;
+                  session.idleBoundary = { kind: "unaccounted" };
                   if (session.cancelled && session.activeTurn && !session.activeTurn.settled) {
                     settleActive(turnOutcome(session, "cancelled"));
                     session.emittedAssistantText = false;
                   } else if (isHeldOpen(session.activeTurn)) {
-                    if (session.owedTrailingIdles > 0) {
-                      session.owedTrailingIdles--;
-                    }
                     settleDeferredIfDrained();
-                  } else if (session.owedTrailingIdles > 0) {
-                    session.owedTrailingIdles--;
+                  } else if (hadEarlierResult) {
                   } else if (isSteering(session.activeTurn)) {
                     const steered = session.activeTurn;
                     if (steered.steeredEchoes?.size === 0 && steered.steeredSettle !== void 0) {
@@ -73428,7 +73253,7 @@ var ClaudeAcpAgent = class {
                       steered.steeredSettle = void 0;
                       settleDeferredIfDrained();
                     }
-                  } else if (!session.cancelled && session.activeTurn && !session.activeTurn.settled) {
+                  } else if (boundary.kind === "unaccounted" && !session.cancelled && session.activeTurn && !session.activeTurn.settled) {
                     this.logger.error(`Session ${params.sessionId}: SDK went idle without emitting a result for the active turn; failing the in-flight prompt (issue #825)`);
                     failActive(RequestError4.internalError(errorKindData("no_result"), TURN_NO_RESULT_MESSAGE));
                   }
@@ -73689,9 +73514,8 @@ ${message.api_refusal_explanation}` : "";
                 }
               }
               const deliveredAssistantText = session.emittedAssistantText;
-              const owesTrailingIdle = isAutonomousResult || !isSteering(session.activeTurn);
-              if (owesTrailingIdle && (isAutonomousResult || !session.cancelled || !session.activeTurn)) {
-                session.owedTrailingIdles++;
+              if (isAutonomousResult || !session.cancelled || !session.activeTurn) {
+                session.idleBoundary = { kind: "accounted", turn: session.activeTurn ?? null };
               }
               if (!isAutonomousResult) {
                 session.accumulatedUsage.inputTokens += message.usage.input_tokens;
@@ -73953,12 +73777,18 @@ ${message.api_refusal_explanation}` : "";
                 if (session.activeTurn !== queued) {
                   if (session.activeTurn) {
                     if (session.cancelled) {
-                      session.owedTrailingIdles++;
+                      session.idleBoundary = {
+                        kind: "accounted",
+                        turn: session.activeTurn ?? null
+                      };
                       settleActive(turnOutcome(session, "cancelled"));
                     } else if (isHeldOpen(session.activeTurn)) {
                       settleActive(session.activeTurn.deferredSettle);
                     } else if (isSteering(session.activeTurn) && session.activeTurn.steeredSettle !== void 0) {
-                      session.owedTrailingIdles++;
+                      session.idleBoundary = {
+                        kind: "accounted",
+                        turn: session.activeTurn ?? null
+                      };
                       settleActive(session.activeTurn.steeredSettle);
                     } else {
                       settleActive(turnOutcome(session, "end_turn"));
@@ -73969,8 +73799,8 @@ ${message.api_refusal_explanation}` : "";
                 break;
               }
               if ("isReplay" in message && message.isReplay) {
-                if (isSteering(session.activeTurn)) {
-                  session.activeTurn.steeredEchoes.delete(message.uuid);
+                if (isSteering(session.activeTurn) && session.activeTurn.steeredEchoes.delete(message.uuid)) {
+                  session.activeTurn.steeredSettle = void 0;
                 }
                 break;
               }
@@ -74235,7 +74065,7 @@ ${message.api_refusal_explanation}` : "";
         session.activeTurn = null;
         session.emittedAssistantText = false;
         if (session.lastSessionState !== "idle") {
-          session.owedTrailingIdles++;
+          session.idleBoundary = { kind: "accounted", turn: active };
         }
         active.resolve({
           stopReason: "cancelled",
@@ -74245,7 +74075,7 @@ ${message.api_refusal_explanation}` : "";
       }
     }
     if (isSteering(session.activeTurn) && session.activeTurn.steeredSettle !== void 0) {
-      session.owedTrailingIdles++;
+      session.idleBoundary = { kind: "accounted", turn: session.activeTurn ?? null };
     }
     if (session.activeTurn && session.cancelController && !session.cancelController.signal.aborted && !session.forceCancelTimer) {
       const cancelController = session.cancelController;
@@ -75263,7 +75093,7 @@ ${message.api_refusal_explanation}` : "";
       emittedToolCalls: /* @__PURE__ */ new Set(),
       liveBackgroundTasks: /* @__PURE__ */ new Map(),
       emittedAssistantText: false,
-      owedTrailingIdles: 0,
+      idleBoundary: { kind: "unaccounted" },
       messageIdToUuid: /* @__PURE__ */ new Map()
     };
     return {
@@ -76670,6 +76500,20 @@ var ClaudeAcpEndpoint = class {
   };
 };
 
+// src/acp/adapter/claude/agent-connection.ts
+var ClaudeAgentConnection = class extends EndpointAgentConnection {
+  constructor(options) {
+    const endpoint = new ClaudeAcpEndpoint({
+      command: options.command,
+      cwd: options.cwd,
+      environment: options.environment,
+      onSessionUpdate: options.client.onUpdate,
+      onBackgroundActivity: (active) => options.onBackgroundActivity?.(active)
+    });
+    super(endpoint, options.client);
+  }
+};
+
 // src/agent/discovery/version-output.ts
 function normalizeVersionOutput(output2) {
   return output2.trim().split(/\r?\n/, 1)[0]?.trim().slice(0, 128) ?? "";
@@ -76693,17 +76537,6 @@ var LocalAgentSpecification = class {
   resolveInstalledAgentExecutables = (_context) => Promise.resolve([]);
   verifyAcp = (_connection, _initialized, _defaultWorkspace, _signal) => Promise.resolve();
 };
-var DirectAcpAgentSpecification = class extends LocalAgentSpecification {
-  adapterOverrideVariable;
-  agentOverrideVariable;
-  launchArguments;
-  constructor(executableOverrideVariable, launchArguments) {
-    super();
-    this.adapterOverrideVariable = executableOverrideVariable;
-    this.agentOverrideVariable = executableOverrideVariable;
-    this.launchArguments = Object.freeze([...launchArguments]);
-  }
-};
 var InProcessAcpAgentSpecification = class extends LocalAgentSpecification {
   launchArguments = Object.freeze([]);
   adapterOverrideVariable;
@@ -76719,7 +76552,7 @@ var InProcessAcpAgentSpecification = class extends LocalAgentSpecification {
 // src/agent/specification/vendors/claude-code-agent.ts
 var ClaudeCodeAgentSpecification = class extends InProcessAcpAgentSpecification {
   agentExecutable = "claude";
-  createEndpoint = (options) => new ClaudeAcpEndpoint(options);
+  createConnection = (options) => new ClaudeAgentConnection(options);
   id = "claude";
   label = "Claude Code";
   minimumSupportedAgentVersion = "2.1.273";
@@ -77725,11 +77558,25 @@ var CodexAcpAgent = class {
   };
 };
 
+// src/acp/adapter/codex/agent-connection.ts
+var CodexAgentConnection = class extends EndpointAgentConnection {
+  constructor(options) {
+    const endpoint = new CodexAcpAgent({
+      command: options.command,
+      cwd: options.cwd,
+      environment: options.environment,
+      onSessionUpdate: options.client.onUpdate,
+      onBackgroundActivity: (active) => options.onBackgroundActivity?.(active)
+    });
+    super(endpoint, options.client);
+  }
+};
+
 // src/agent/specification/vendors/codex-agent.ts
 var CodexAgentSpecification = class extends InProcessAcpAgentSpecification {
   versionProbeTimeoutMilliseconds = 1e4;
   agentExecutable = "codex";
-  createEndpoint = (options) => new CodexAcpAgent(options);
+  createConnection = (options) => new CodexAgentConnection(options);
   id = "codex";
   label = "Codex";
   minimumSupportedAgentVersion = "0.153.0";
@@ -77757,7 +77604,7 @@ import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute13,
 import { RequestError as RequestError8 } from "@agentclientprotocol/sdk";
 
 // src/acp/harness/pi/upstream/dist/pi-rpc/process.js
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import * as readline from "node:readline";
 
 // src/acp/harness/pi/upstream/dist/pi-rpc/command.js
@@ -77874,7 +77721,7 @@ var PiRpcProcess = class _PiRpcProcess {
         args.push("--fork", params.origin.sessionPath);
         break;
     }
-    const child = spawn6(cmd, args, {
+    const child = spawn5(cmd, args, {
       cwd: params.cwd,
       stdio: "pipe",
       env: params.environment,
@@ -81590,6 +81437,20 @@ function piAgentOrThrow(agent) {
   return agent;
 }
 
+// src/acp/adapter/pi/agent-connection.ts
+var PiAgentConnection = class extends EndpointAgentConnection {
+  constructor(options) {
+    const endpoint = new PiAcpEndpoint({
+      command: options.command,
+      cwd: options.cwd,
+      environment: options.environment,
+      onSessionUpdate: options.client.onUpdate,
+      onBackgroundActivity: (active) => options.onBackgroundActivity?.(active)
+    });
+    super(endpoint, options.client);
+  }
+};
+
 // src/agent/discovery/agent-probe-error.ts
 var AgentProbeError = class extends Error {
   code;
@@ -81605,7 +81466,7 @@ var ACP_PROBE_TIMEOUT_MILLISECONDS2 = 3e4;
 var PiAgentSpecification = class extends InProcessAcpAgentSpecification {
   acpProbeTimeoutMilliseconds = ACP_PROBE_TIMEOUT_MILLISECONDS2;
   agentExecutable = "pi";
-  createEndpoint = (options) => new PiAcpEndpoint(options);
+  createConnection = (options) => new PiAgentConnection(options);
   // The Pi ACP fork inlines embedded prompt resources into the turn message, so Mobius
   // keeps the adapter's opt-in capability flag enabled for every launch it owns.
   createLaunchEnvironment = async (_agent, context) => {
@@ -81793,14 +81654,10 @@ var LocalAgentInventory = class {
 };
 
 // src/agent/discovery/acp-readiness-probe.ts
-import { spawn as spawn7 } from "node:child_process";
 import {
   methods as methods12,
-  ndJsonStream as ndJsonStream3,
-  PROTOCOL_VERSION as PROTOCOL_VERSION3,
-  RequestError as RequestError9
+  PROTOCOL_VERSION as PROTOCOL_VERSION3
 } from "@agentclientprotocol/sdk";
-var ACP_OUTPUT_LIMIT_BYTES = 1024 * 1024;
 var VerifiedAcpReadiness = class {
   adapterVersion;
   capabilities;
@@ -81815,76 +81672,38 @@ var DiscoveryAcpHandler = class {
   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;
-  return new ReadableStream({
-    start(controller) {
-      input2.on("data", (chunk) => {
-        if (!open6) {
-          return;
-        }
-        if (!(chunk instanceof Uint8Array)) {
-          open6 = false;
-          controller.error(new Error("ACP adapter produced invalid output"));
-          return;
-        }
-        byteLength += chunk.byteLength;
-        if (byteLength > ACP_OUTPUT_LIMIT_BYTES) {
-          open6 = false;
-          controller.error(new Error("ACP adapter output limit exceeded"));
-          return;
-        }
-        controller.enqueue(new Uint8Array(chunk));
-      });
-      input2.once("end", () => {
-        if (open6) {
-          open6 = false;
-          controller.close();
-        }
-      });
-      input2.once("error", (error62) => {
-        if (open6) {
-          open6 = false;
-          controller.error(error62);
-        }
-      });
-    },
-    cancel() {
-      open6 = false;
-    }
-  });
-}
-function writableAcpStream(output2) {
-  return new WritableStream({
-    write(chunk) {
-      return new Promise((resolveWrite, rejectWrite) => {
-        output2.write(chunk, (error62) => {
-          if (error62) {
-            rejectWrite(error62);
-            return;
-          }
-          resolveWrite();
-        });
-      });
+function filterEnvironment(environment) {
+  const filtered = {};
+  for (const [name2, value] of Object.entries(environment)) {
+    if (typeof value === "string") {
+      filtered[name2] = value;
     }
-  });
+  }
+  return filtered;
 }
-async function probeInProcessReadiness(specification, agent, environment, defaultWorkspace, controller) {
-  const handler = new DiscoveryAcpHandler();
-  const inProcess = agent.createEndpoint({
-    command: agent.command,
-    cwd: defaultWorkspace,
-    environment: { ...filterEnvironment(environment), ...agent.environment },
-    onSessionUpdate: handler.onUpdate
-  });
+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"));
+  }, specification.acpProbeTimeoutMilliseconds);
+  const abort = () => controller.abort(signal.reason);
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted) {
+    abort();
+  }
   try {
-    const connection = createAcpClient(handler).connect(inProcess.app());
+    const runtime = agent.withEnvironment({ ...filterEnvironment(environment), ...agent.environment }).createConnection({
+      cwd: defaultWorkspace,
+      client: new DiscoveryAcpHandler()
+    });
     try {
-      return await Promise.race([
+      return await runtime.race(
         (async () => {
-          await inProcess.initialize(controller.signal);
-          const initialized = await connection.agent.request(
+          await runtime.initialize(controller.signal);
+          const initialized = await runtime.connection.agent.request(
             methods12.agent.initialize,
             {
               clientCapabilities: {},
@@ -81899,148 +81718,33 @@ async function probeInProcessReadiness(specification, agent, environment, defaul
               "ACP agent selected an unsupported protocol version"
             );
           }
-          await specification.verifyAcp(connection, initialized, defaultWorkspace, controller.signal);
+          await specification.verifyAcp(runtime.connection, initialized, defaultWorkspace, controller.signal);
           return new VerifiedAcpReadiness(
             normalizeVersionOutput(initialized.agentInfo?.version ?? ""),
             normalizeAcpCapabilities(initialized)
           );
         })(),
-        inProcess.terminated.then((termination) => {
-          throw new AgentProbeError("acp_incompatible", "The ACP endpoint stopped during initialization", {
-            cause: acpEndpointTerminationError(termination)
-          });
-        })
-      ]);
-    } finally {
-      connection.close();
-    }
-  } finally {
-    await inProcess.close();
-  }
-}
-function filterEnvironment(environment) {
-  const filtered = {};
-  for (const [name2, value] of Object.entries(environment)) {
-    if (typeof value === "string") {
-      filtered[name2] = value;
-    }
-  }
-  return filtered;
-}
-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"));
-  }, specification.acpProbeTimeoutMilliseconds);
-  const abort = () => controller.abort(signal.reason);
-  signal.addEventListener("abort", abort, { once: true });
-  if (signal.aborted) {
-    abort();
-  }
-  if (agent.kind === "in-process-acp") {
-    try {
-      return await probeInProcessReadiness(specification, agent, environment, defaultWorkspace, controller);
-    } catch (error62) {
-      if (signal.aborted) {
-        signal.throwIfAborted();
-      }
-      if (timedOut) {
-        throw new AgentProbeError("adapter_probe_timeout", "ACP agent probe timed out", { cause: error62 });
-      }
-      if (error62 instanceof AgentProbeError) {
-        throw error62;
-      }
-      if (error62 instanceof RequestError9 && error62.code === -32e3 && specification.authenticationCommand().length > 0) {
-        throw new AgentProbeError("authentication_required", "Agent authentication is required", {
-          cause: error62
-        });
-      }
-      throw new AgentProbeError("acp_incompatible", "ACP agent initialization failed", { cause: error62 });
+        "The ACP endpoint stopped during initialization",
+        controller.signal
+      );
     } finally {
-      clearTimeout(timeout);
-      signal.removeEventListener("abort", abort);
-    }
-  }
-  const launch = executableLaunch2(agent.adapterPath, agent.arguments);
-  const child = spawn7(launch.command, [...launch.arguments], {
-    cwd: defaultWorkspace,
-    ...platformSpawnOptions,
-    env: { ...environment, ...agent.environment },
-    shell: false,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  const processExit = new Promise((_resolve, reject2) => {
-    const rejectExit = () => reject2(new Error("ACP adapter exited during initialization"));
-    child.once("error", reject2);
-    child.once("exit", rejectExit);
-    if (child.exitCode !== null || child.signalCode !== null) {
-      rejectExit();
-    }
-  });
-  const stdin = child.stdin;
-  const stdout = child.stdout;
-  const stderr = child.stderr;
-  if (stdin === null || stdout === null || stderr === null) {
-    await stopProcessTree(child);
-    throw new AgentProbeError("acp_incompatible", "ACP adapter streams are unavailable");
-  }
-  let stderrBytes = 0;
-  const consumeStderr = (chunk) => {
-    stderrBytes += chunk.byteLength;
-    if (stderrBytes > ACP_OUTPUT_LIMIT_BYTES) {
-      controller.abort(new Error("ACP adapter output limit exceeded"));
-    }
-  };
-  stderr.on("data", consumeStderr);
-  const connection = createAcpClient(new DiscoveryAcpHandler()).connect(
-    ndJsonStream3(writableAcpStream(stdin), readableAcpStream(stdout))
-  );
-  try {
-    const initialized = await Promise.race([
-      connection.agent.request(
-        methods12.agent.initialize,
-        {
-          clientCapabilities: {},
-          clientInfo: { name: "mobius", version: "0.0.3" },
-          protocolVersion: PROTOCOL_VERSION3
-        },
-        { cancellationSignal: controller.signal }
-      ),
-      processExit
-    ]);
-    if (initialized.protocolVersion !== PROTOCOL_VERSION3) {
-      throw new AgentProbeError("acp_incompatible", "ACP adapter selected an unsupported protocol version");
+      await runtime.closeProcess();
     }
-    await specification.verifyAcp(connection, initialized, defaultWorkspace, controller.signal);
-    return new VerifiedAcpReadiness(
-      normalizeVersionOutput(initialized.agentInfo?.version ?? ""),
-      normalizeAcpCapabilities(initialized)
-    );
   } catch (error62) {
-    if (signal.aborted) {
-      signal.throwIfAborted();
-    }
+    signal.throwIfAborted();
     if (timedOut) {
-      throw new AgentProbeError("adapter_probe_timeout", "ACP adapter probe timed out", { cause: error62 });
+      throw new AgentProbeError("adapter_probe_timeout", "ACP agent probe timed out", { cause: error62 });
     }
     if (error62 instanceof AgentProbeError) {
       throw error62;
     }
-    if (error62 instanceof RequestError9 && error62.code === -32e3 && specification.authenticationCommand().length > 0) {
+    if (error62 instanceof AcpExecutionError && error62.code === "authentication_required" && specification.authenticationCommand().length > 0) {
       throw new AgentProbeError("authentication_required", "Agent authentication is required", { cause: error62 });
     }
-    throw new AgentProbeError("acp_incompatible", "ACP adapter initialization failed", { cause: error62 });
+    throw new AgentProbeError("acp_incompatible", "ACP agent initialization failed", { cause: error62 });
   } finally {
     clearTimeout(timeout);
     signal.removeEventListener("abort", abort);
-    const capturedProcesses = await captureProcessTree(child);
-    connection.close();
-    stdin.end();
-    stderr.removeListener("data", consumeStderr);
-    await stopProcessTree(child, capturedProcesses);
   }
 }
 
@@ -82135,10 +81839,7 @@ async function resolveAgentExecutables(specification, context) {
   );
 }
 async function resolveAdapterExecutables(specification, context) {
-  if (specification instanceof DirectAcpAgentSpecification || specification instanceof InProcessAcpAgentSpecification) {
-    return await resolveAgentExecutables(specification, context);
-  }
-  throw new Error("Unsupported local Agent execution topology");
+  return await resolveAgentExecutables(specification, context);
 }
 async function probeVersion(executable, arguments_, environment, defaultWorkspace, signal, timeoutMilliseconds, normalize4 = normalizeVersionOutput) {
   const result = await runBoundedProcess({
@@ -82252,7 +81953,7 @@ async function discoverAgent(specification, context) {
       return new MissingAdapter(specification);
     }
     for (const adapter of adapters) {
-      if (specification instanceof DirectAcpAgentSpecification && adapter.path !== agent.path) {
+      if (adapter.path !== agent.path) {
         continue;
       }
       let adapterVersion = "";
@@ -82283,26 +81984,16 @@ async function discoverAgent(specification, context) {
         lastFailure = integrationProbeFailure(specification, error62);
         continue;
       }
-      const buildDefinition = (verifiedAdapterVersion, capabilities) => specification instanceof InProcessAcpAgentSpecification ? new InProcessAcpAgentDefinition(
+      const buildDefinition = (verifiedAdapterVersion, capabilities) => new AcpAgentDefinition(
         specification.id,
         specification.label,
         agent.path,
-        specification.createEndpoint,
+        specification.createConnection,
         launchEnvironment,
         agentVersion.length > 0 ? agentVersion : verifiedAdapterVersion,
         agent.identity,
-        capabilities
-      ) : new LocalAgentDefinition(
-        specification.id,
-        specification.label,
-        adapter.path,
-        specification.launchArguments,
-        launchEnvironment,
-        verifiedAdapterVersion,
-        agentVersion,
-        adapter.identity,
-        agent.identity,
-        capabilities
+        capabilities,
+        specification instanceof InProcessAcpAgentSpecification ? agentVersion : verifiedAdapterVersion
       );
       try {
         const readiness = await probeWithRetry(
@@ -82690,11 +82381,14 @@ function createCatalogAgentResolver(discover, readConfig, publish) {
   };
 }
 async function unchangedIdentity(agent, signal) {
-  if (!await revalidateExecutable(agent.agentIdentity)) {
-    return false;
+  for (const identity2 of agent.runtimeExecutables) {
+    signal.throwIfAborted();
+    if (!await revalidateExecutable(identity2)) {
+      return false;
+    }
   }
   signal.throwIfAborted();
-  return agent.kind !== "acp-adapter-process" || await revalidateExecutable(agent.adapterIdentity);
+  return true;
 }
 
 // src/runtime/connection/runtime-installation-store.ts
@@ -88982,7 +88676,7 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
   };
   return createHash8("sha256").update(
     JSON.stringify({
-      adapterVersion: agent.kind === "acp-adapter-process" ? agent.adapterVersion : agent.agentVersion,
+      adapterVersion: agent.adapterVersion,
       agentId: agent.id,
       agentVersion: agent.agentVersion,
       modelEffort: revisionModelEffort,
@@ -91738,8 +91432,8 @@ var MobiusRuntimeEngine = class {
   };
 };
 export {
-  InProcessAcpAgentDefinition,
-  LocalAgentDefinition,
+  AcpAgentDefinition,
+  EndpointAgentConnection,
   MobiusRuntimeConfigurationError,
   MobiusRuntimeEngine,
   OpaqueRuntimeReconnectTarget,