@moxt-ai/mobius 0.0.317 → 0.0.319

package/dist/cli.js

@@ -2086,7 +2086,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@moxt-ai/mobius",
-      version: "0.0.317",
+      version: "0.0.319",
       description: "Mobius CLI for pairing and running local AI agent services.",
       type: "module",
       bin: {
@@ -5781,6 +5781,224 @@ var init_state_root = __esm({
   }
 });
 
+// src/util/value-utils.ts
+function truncate(value, maximumLength) {
+  return value.length <= maximumLength ? value : `${value.slice(0, Math.max(0, maximumLength - 1))}\u2026`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index2) => value === right[index2]);
+}
+function recordsEqual(left, right) {
+  const leftEntries = Object.entries(left);
+  const rightEntries = Object.entries(right);
+  return leftEntries.length === rightEntries.length && leftEntries.every(([name2, value]) => right[name2] === value);
+}
+var init_value_utils = __esm({
+  "src/util/value-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/infra/operation-error.ts
+function operationErrorCode(error62) {
+  return error62 instanceof OperationError ? error62.code : "session_operation_failed";
+}
+function operationErrorMessage(error62) {
+  return error62 instanceof OperationError ? error62.message : "The local agent operation could not be completed";
+}
+var OperationError;
+var init_operation_error = __esm({
+  "src/infra/operation-error.ts"() {
+    "use strict";
+    OperationError = class extends Error {
+      code;
+      constructor(code, message, options = {}) {
+        super(message, options);
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/acp/acp-error.ts
+var AcpExecutionError, AcpConfigurationValueUnavailableError;
+var init_acp_error = __esm({
+  "src/acp/acp-error.ts"() {
+    "use strict";
+    init_operation_error();
+    AcpExecutionError = class extends OperationError {
+      constructor(message, options = {}, code = "acp_execution_failed") {
+        super(code, message, options);
+        this.name = "AcpExecutionError";
+      }
+    };
+    AcpConfigurationValueUnavailableError = class extends AcpExecutionError {
+      configId;
+      offeredValueCount;
+      offeredValues;
+      requestedValue;
+      constructor(configId, requestedValue, offeredValues) {
+        super("The requested ACP configuration value is unavailable", {}, "invalid_session_configuration");
+        this.name = "AcpConfigurationValueUnavailableError";
+        this.configId = configId.slice(0, 128);
+        this.requestedValue = requestedValue.slice(0, 128);
+        this.offeredValueCount = offeredValues.length;
+        this.offeredValues = Object.freeze(offeredValues.slice(0, 32).map((value) => value.slice(0, 128)));
+      }
+    };
+  }
+});
+
+// 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;
+    }
+  }
+}
+var init_in_process_endpoint = __esm({
+  "src/acp/agent/in-process-endpoint.ts"() {
+    "use strict";
+    init_acp_error();
+  }
+});
+
+// src/acp/connection/agent-operation.ts
+import { RequestError } from "@agentclientprotocol/sdk";
+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();
+  }
+}
+var init_agent_operation = __esm({
+  "src/acp/connection/agent-operation.ts"() {
+    "use strict";
+    init_value_utils();
+    init_acp_error();
+    init_in_process_endpoint();
+  }
+});
+
+// src/acp/connection/create-client.ts
+import {
+  client,
+  methods
+} from "@agentclientprotocol/sdk";
+var createAcpClient;
+var init_create_client = __esm({
+  "src/acp/connection/create-client.ts"() {
+    "use strict";
+    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;
+var init_endpoint_agent_connection = __esm({
+  "src/acp/connection/endpoint-agent-connection.ts"() {
+    "use strict";
+    init_agent_operation();
+    init_create_client();
+    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/harness/claude/parent-lifeline.ts
 import { spawn } from "node:child_process";
 import { Duplex } from "node:stream";
@@ -42527,7 +42745,7 @@ ${plan}` }]
 });
 
 // src/acp/harness/claude/upstream/dist/goal-extension.js
-import { RequestError } from "@agentclientprotocol/sdk";
+import { RequestError as RequestError2 } from "@agentclientprotocol/sdk";
 function goalUpdateFromPrompt(prompt) {
   const match = /^\/goal(?:\s+([\s\S]*))?$/.exec(prompt);
   const argument = match?.[1]?.trim();
@@ -42545,17 +42763,17 @@ function goalUpdateFromPrompt(prompt) {
 }
 function parseGoalRequest(params) {
   if (!params || typeof params !== "object") {
-    throw RequestError.invalidParams(void 0, "goal params must be an object");
+    throw RequestError2.invalidParams(void 0, "goal params must be an object");
   }
   const { sessionId, action, objective } = params;
   if (typeof sessionId !== "string" || sessionId.length === 0) {
-    throw RequestError.invalidParams(void 0, "goal params require a non-empty sessionId");
+    throw RequestError2.invalidParams(void 0, "goal params require a non-empty sessionId");
   }
   if (!GOAL_ACTIONS.includes(action)) {
-    throw RequestError.invalidParams(void 0, 'goal action must be "set" or "clear"');
+    throw RequestError2.invalidParams(void 0, 'goal action must be "set" or "clear"');
   }
   if (action === "set" && (typeof objective !== "string" || objective.trim().length === 0)) {
-    throw RequestError.invalidParams(void 0, 'goal action "set" requires a non-empty objective');
+    throw RequestError2.invalidParams(void 0, 'goal action "set" requires a non-empty objective');
   }
   return action === "set" ? { sessionId, action, objective: objective.trim() } : { sessionId, action: "clear" };
 }
@@ -42631,7 +42849,7 @@ var init_modes = __esm({
 });
 
 // src/acp/harness/claude/upstream/dist/permissions/normalization.js
-function isRecord(value) {
+function isRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isDestination(value) {
@@ -42648,13 +42866,13 @@ function safePlainString(value, maxLength) {
   });
 }
 function isRule(value) {
-  if (!isRecord(value) || !safePlainString(value.toolName, MAX_TOOL_NAME_LENGTH)) {
+  if (!isRecord2(value) || !safePlainString(value.toolName, MAX_TOOL_NAME_LENGTH)) {
     return false;
   }
   return value.ruleContent === void 0 || safePlainString(value.ruleContent, MAX_RULE_CONTENT_LENGTH);
 }
 function isKnownUpdate(value) {
-  if (!isRecord(value) || !isDestination(value.destination) || typeof value.type !== "string") {
+  if (!isRecord2(value) || !isDestination(value.destination) || typeof value.type !== "string") {
     return false;
   }
   switch (value.type) {
@@ -65115,7 +65333,7 @@ var init_settings = __esm({
 });
 
 // src/acp/harness/claude/upstream/dist/session-mode.js
-import { RequestError as RequestError2 } from "@agentclientprotocol/sdk";
+import { RequestError as RequestError3 } from "@agentclientprotocol/sdk";
 var MODE_CONFIG_ID, AUTO_MODE_FALLBACK, AUTO_MODE_FALLBACK_NOTICE, SessionModeManager;
 var init_session_mode = __esm({
   "src/acp/harness/claude/upstream/dist/session-mode.js"() {
@@ -65265,7 +65483,7 @@ var init_session_mode = __esm({
           throw new Error("Session not found");
         }
         if (session.queryClosed) {
-          throw RequestError2.internalError(void 0, this.options.sessionEndedMessage);
+          throw RequestError3.internalError(void 0, this.options.sessionEndedMessage);
         }
         return session;
       }
@@ -65345,7 +65563,7 @@ import * as fs4 from "node:fs/promises";
 import * as os3 from "node:os";
 import * as path6 from "node:path";
 import { promisify } from "node:util";
-import { agent as acpAgent, CreateElicitationResponse as CreateElicitationResponse2, methods, ndJsonStream, RequestError as RequestError3 } from "@agentclientprotocol/sdk";
+import { agent as acpAgent, CreateElicitationResponse as CreateElicitationResponse2, methods as methods2, ndJsonStream, RequestError as RequestError4 } from "@agentclientprotocol/sdk";
 function supportsMcpOAuth(query) {
   return typeof query.mcpAuthenticate === "function";
 }
@@ -65367,19 +65585,19 @@ function waitUnlessAborted(milliseconds, signal) {
 }
 function parseSteerRequest(params) {
   if (!params || typeof params !== "object") {
-    throw RequestError3.invalidParams(void 0, "steer params must be an object");
+    throw RequestError4.invalidParams(void 0, "steer params must be an object");
   }
   const { sessionId, prompt, _meta } = params;
   if (typeof sessionId !== "string" || sessionId.length === 0) {
-    throw RequestError3.invalidParams(void 0, "steer params require a non-empty sessionId");
+    throw RequestError4.invalidParams(void 0, "steer params require a non-empty sessionId");
   }
   if (!Array.isArray(prompt) || prompt.length === 0) {
-    throw RequestError3.invalidParams(void 0, "steer params require a non-empty prompt array");
+    throw RequestError4.invalidParams(void 0, "steer params require a non-empty prompt array");
   }
   const steering = _meta && typeof _meta === "object" ? _meta.steering : void 0;
   const idleBehavior = steering && typeof steering === "object" ? steering.idleBehavior : void 0;
   if (idleBehavior !== void 0 && idleBehavior !== "promptRequired") {
-    throw RequestError3.invalidParams(void 0, "unsupported steering idleBehavior");
+    throw RequestError4.invalidParams(void 0, "unsupported steering idleBehavior");
   }
   return {
     sessionId,
@@ -65389,14 +65607,14 @@ function parseSteerRequest(params) {
 }
 function parseRenameRequest(params) {
   if (!params || typeof params !== "object") {
-    throw RequestError3.invalidParams(void 0, "rename params must be an object");
+    throw RequestError4.invalidParams(void 0, "rename params must be an object");
   }
   const { sessionId, title: title2 } = params;
   if (typeof sessionId !== "string" || sessionId.length === 0) {
-    throw RequestError3.invalidParams(void 0, "rename params require a non-empty sessionId");
+    throw RequestError4.invalidParams(void 0, "rename params require a non-empty sessionId");
   }
   if (typeof title2 !== "string" || title2.trim().length === 0) {
-    throw RequestError3.invalidParams(void 0, "rename params require a non-empty title");
+    throw RequestError4.invalidParams(void 0, "rename params require a non-empty title");
   }
   return { sessionId, title: title2 };
 }
@@ -66860,7 +67078,7 @@ function createClaudeAcpApp(options = {}) {
   const app = acpAgent({ name: "claude-code-acp" }).onConnect((connection) => {
     agent = new ClaudeAcpAgent(new ClientConnection(connection.client, options.onSessionUpdate), options.logger, options.environment, options.spawnClaudeCodeProcess, options.onBackgroundActivity);
     options.onConnect?.(connection);
-  }).onRequest(methods.agent.initialize, (ctx) => requiredAgent(agent).initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => requiredAgent(agent).newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => requiredAgent(agent).loadSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => requiredAgent(agent).unstable_forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => requiredAgent(agent).listSessions(ctx.params, ctx.signal)).onRequest(methods.agent.session.delete, (ctx) => requiredAgent(agent).deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => requiredAgent(agent).resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => requiredAgent(agent).closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => requiredAgent(agent).setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => requiredAgent(agent).setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => requiredAgent(agent).authenticate(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => requiredAgent(agent).unstable_listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => requiredAgent(agent).unstable_setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => requiredAgent(agent).unstable_disableProvider(ctx.params)).onRequest(methods.agent.logout, (ctx) => requiredAgent(agent).logout(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => runPromptWithCancellation(requiredAgent(agent), ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => requiredAgent(agent).cancel(ctx.params)).onRequest(STEER_METHOD, { parse: parseSteerRequest }, (ctx) => requiredAgent(agent).steer(ctx.params)).onRequest(RENAME_METHOD, { parse: parseRenameRequest }, (ctx) => requiredAgent(agent).renameSession(ctx.params)).onRequest(GOAL_CONTROL_METHOD, { parse: parseGoalRequest }, (ctx) => requiredAgent(agent).goal(ctx.params));
+  }).onRequest(methods2.agent.initialize, (ctx) => requiredAgent(agent).initialize(ctx.params)).onRequest(methods2.agent.session.new, (ctx) => requiredAgent(agent).newSession(ctx.params)).onRequest(methods2.agent.session.load, (ctx) => requiredAgent(agent).loadSession(ctx.params, ctx.signal)).onRequest(methods2.agent.session.fork, (ctx) => requiredAgent(agent).unstable_forkSession(ctx.params, ctx.signal)).onRequest(methods2.agent.session.list, (ctx) => requiredAgent(agent).listSessions(ctx.params, ctx.signal)).onRequest(methods2.agent.session.delete, (ctx) => requiredAgent(agent).deleteSession(ctx.params)).onRequest(methods2.agent.session.resume, (ctx) => requiredAgent(agent).resumeSession(ctx.params)).onRequest(methods2.agent.session.close, (ctx) => requiredAgent(agent).closeSession(ctx.params)).onRequest(methods2.agent.session.setMode, (ctx) => requiredAgent(agent).setSessionMode(ctx.params)).onRequest(methods2.agent.session.setConfigOption, (ctx) => requiredAgent(agent).setSessionConfigOption(ctx.params)).onRequest(methods2.agent.authenticate, (ctx) => requiredAgent(agent).authenticate(ctx.params)).onRequest(methods2.agent.providers.list, (ctx) => requiredAgent(agent).unstable_listProviders(ctx.params)).onRequest(methods2.agent.providers.set, (ctx) => requiredAgent(agent).unstable_setProvider(ctx.params)).onRequest(methods2.agent.providers.disable, (ctx) => requiredAgent(agent).unstable_disableProvider(ctx.params)).onRequest(methods2.agent.logout, (ctx) => requiredAgent(agent).logout(ctx.params)).onRequest(methods2.agent.session.prompt, (ctx) => runPromptWithCancellation(requiredAgent(agent), ctx.params, ctx.signal)).onNotification(methods2.agent.session.cancel, (ctx) => requiredAgent(agent).cancel(ctx.params)).onRequest(STEER_METHOD, { parse: parseSteerRequest }, (ctx) => requiredAgent(agent).steer(ctx.params)).onRequest(RENAME_METHOD, { parse: parseRenameRequest }, (ctx) => requiredAgent(agent).renameSession(ctx.params)).onRequest(GOAL_CONTROL_METHOD, { parse: parseGoalRequest }, (ctx) => requiredAgent(agent).goal(ctx.params));
   return { agent: () => agent, app };
 }
 function requiredAgent(agent) {
@@ -67028,26 +67246,26 @@ var init_acp_agent = __esm({
         if (this.onSessionUpdate !== void 0) {
           return this.onSessionUpdate(params);
         }
-        return this.ctx.notify(methods.client.session.update, params);
+        return this.ctx.notify(methods2.client.session.update, params);
       }
       requestPermission(params, signal) {
-        return this.ctx.request(methods.client.session.requestPermission, params, {
+        return this.ctx.request(methods2.client.session.requestPermission, params, {
           cancellationSignal: signal
         });
       }
       readTextFile(params) {
-        return this.ctx.request(methods.client.fs.readTextFile, params);
+        return this.ctx.request(methods2.client.fs.readTextFile, params);
       }
       writeTextFile(params) {
-        return this.ctx.request(methods.client.fs.writeTextFile, params);
+        return this.ctx.request(methods2.client.fs.writeTextFile, params);
       }
       createElicitation(params, signal) {
-        return this.ctx.request(methods.client.elicitation.create, params, {
+        return this.ctx.request(methods2.client.elicitation.create, params, {
           cancellationSignal: signal
         });
       }
       completeElicitation(params) {
-        return this.ctx.notify(methods.client.elicitation.complete, params);
+        return this.ctx.notify(methods2.client.elicitation.complete, params);
       }
       extNotification(method, params) {
         return this.ctx.notify(method, params);
@@ -67377,13 +67595,13 @@ var init_acp_agent = __esm({
        */
       async unstable_setProvider(params) {
         if (params.providerId !== PROVIDER_ID) {
-          throw RequestError3.invalidParams({ providerId: params.providerId }, `Unknown provider ID "${params.providerId}"; expected "${PROVIDER_ID}".`);
+          throw RequestError4.invalidParams({ providerId: params.providerId }, `Unknown provider ID "${params.providerId}"; expected "${PROVIDER_ID}".`);
         }
         if (!SUPPORTED_PROTOCOLS.includes(params.apiType)) {
-          throw RequestError3.invalidParams({ apiType: params.apiType, supported: SUPPORTED_PROTOCOLS }, `Unsupported apiType "${params.apiType}" for provider "${PROVIDER_ID}".`);
+          throw RequestError4.invalidParams({ apiType: params.apiType, supported: SUPPORTED_PROTOCOLS }, `Unsupported apiType "${params.apiType}" for provider "${PROVIDER_ID}".`);
         }
         if (!isValidBaseUrl(params.baseUrl)) {
-          throw RequestError3.invalidParams({ baseUrl: params.baseUrl }, "baseUrl must be a non-empty absolute http(s) URL.");
+          throw RequestError4.invalidParams({ baseUrl: params.baseUrl }, "baseUrl must be a non-empty absolute http(s) URL.");
         }
         const config2 = {
           apiType: params.apiType,
@@ -67393,7 +67611,7 @@ var init_acp_agent = __esm({
         if (params.apiType === "vertex") {
           const vertex = params._meta?.claudeCode?.vertex;
           if (!vertex || typeof vertex.projectId !== "string" || vertex.projectId.trim() === "" || typeof vertex.region !== "string" || vertex.region.trim() === "") {
-            throw RequestError3.invalidParams(void 0, "vertex apiType requires non-empty `_meta.claudeCode.vertex.projectId` and `_meta.claudeCode.vertex.region`.");
+            throw RequestError4.invalidParams(void 0, "vertex apiType requires non-empty `_meta.claudeCode.vertex.projectId` and `_meta.claudeCode.vertex.region`.");
           }
           config2.vertex = { projectId: vertex.projectId, region: vertex.region };
         }
@@ -67449,7 +67667,7 @@ var init_acp_agent = __esm({
           await execFileAsync(cliPath, ["auth", "logout"]);
         } catch (error62) {
           const stderr = typeof error62 === "object" && error62 && "stderr" in error62 ? String(error62.stderr).trim() : void 0;
-          throw RequestError3.internalError({ stderr: stderr || void 0 }, `claude auth logout failed: ${error62 instanceof Error ? error62.message : String(error62)}`);
+          throw RequestError4.internalError({ stderr: stderr || void 0 }, `claude auth logout failed: ${error62 instanceof Error ? error62.message : String(error62)}`);
         }
       }
       async prompt(params) {
@@ -67461,7 +67679,7 @@ var init_acp_agent = __esm({
           throw new Error("Session not found");
         }
         if (session.queryClosed) {
-          throw RequestError3.internalError(void 0, SESSION_ENDED_MESSAGE);
+          throw RequestError4.internalError(void 0, SESSION_ENDED_MESSAGE);
         }
         if (session.autoModeFallbackWarningPending) {
           await this.sessionModes.publishFallbackWarning(params.sessionId, session);
@@ -67601,7 +67819,7 @@ var init_acp_agent = __esm({
           throw new Error("Session not found");
         }
         if (session.queryClosed) {
-          throw RequestError3.internalError(void 0, SESSION_ENDED_MESSAGE);
+          throw RequestError4.internalError(void 0, SESSION_ENDED_MESSAGE);
         }
         const turnInFlight = (session.turnQueue ?? []).find((turn) => !turn.settled);
         if (!turnInFlight) {
@@ -67932,7 +68150,7 @@ var init_acp_agent = __esm({
               for (const queued of [...session.turnQueue ?? []]) {
                 if (!queued.settled) {
                   queued.settled = true;
-                  queued.reject(RequestError3.internalError(void 0, SESSION_ENDED_MESSAGE));
+                  queued.reject(RequestError4.internalError(void 0, SESSION_ENDED_MESSAGE));
                 }
               }
               session.turnQueue = [];
@@ -68081,16 +68299,15 @@ var init_acp_agent = __esm({
                     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) {
@@ -68099,9 +68316,9 @@ var init_acp_agent = __esm({
                           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(RequestError3.internalError(errorKindData("no_result"), TURN_NO_RESULT_MESSAGE));
+                        failActive(RequestError4.internalError(errorKindData("no_result"), TURN_NO_RESULT_MESSAGE));
                       }
                       await session.titles.onTurnEnd(session);
                     }
@@ -68360,9 +68577,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;
@@ -68457,7 +68673,7 @@ ${message.api_refusal_explanation}` : "";
                         break;
                       }
                       if (message.is_error) {
-                        failActive(RequestError3.internalError(errorKindData(lastAssistantError), message.result));
+                        failActive(RequestError4.internalError(errorKindData(lastAssistantError), message.result));
                         break;
                       }
                       if (session.activeTurn?.isLocalOnlyCommand || !deliveredAssistantText && (message.usage.output_tokens ?? 0) === 0) {
@@ -68473,7 +68689,7 @@ ${message.api_refusal_explanation}` : "";
                         break;
                       }
                       if (message.is_error) {
-                        failActive(RequestError3.internalError(errorKindData(lastAssistantError), message.errors.join(", ") || message.subtype));
+                        failActive(RequestError4.internalError(errorKindData(lastAssistantError), message.errors.join(", ") || message.subtype));
                         break;
                       }
                       stopReason = "end_turn";
@@ -68483,7 +68699,7 @@ ${message.api_refusal_explanation}` : "";
                     case "error_max_turns":
                     case "error_max_structured_output_retries":
                       if (message.is_error) {
-                        failActive(RequestError3.internalError(errorKindData(lastAssistantError), message.errors.join(", ") || message.subtype));
+                        failActive(RequestError4.internalError(errorKindData(lastAssistantError), message.errors.join(", ") || message.subtype));
                         break;
                       }
                       stopReason = "max_turn_requests";
@@ -68624,12 +68840,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"));
@@ -68640,8 +68862,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;
                   }
@@ -68695,7 +68917,7 @@ ${message.api_refusal_explanation}` : "";
                   break;
                 }
                 if (message.type === "assistant" && message.error === "authentication_failed") {
-                  failActive(RequestError3.authRequired(errorKindData(message.error)));
+                  failActive(RequestError4.authRequired(errorKindData(message.error)));
                   break;
                 }
                 let content;
@@ -68820,7 +69042,7 @@ ${message.api_refusal_explanation}` : "";
           const processDied = error62 instanceof Error && (message.includes("ProcessTransport") || message.includes("terminated process") || message.includes("process exited with") || message.includes("process terminated by signal") || message.includes("Failed to write to process stdin"));
           if (processDied) {
             this.logger.error(`Session ${params.sessionId}: Claude Agent process died: ${message}`);
-            failAllTurns(RequestError3.internalError(void 0, "The Claude Agent process exited unexpectedly. Please start a new session."));
+            failAllTurns(RequestError4.internalError(void 0, "The Claude Agent process exited unexpectedly. Please start a new session."));
             this.closeQueryStream(session);
             delete this.sessions[params.sessionId];
           } else {
@@ -68906,7 +69128,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",
@@ -68916,7 +69138,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;
@@ -69025,7 +69247,7 @@ ${message.api_refusal_explanation}` : "";
           throw new Error("Session not found");
         }
         if (session.queryClosed) {
-          throw RequestError3.internalError(void 0, SESSION_ENDED_MESSAGE);
+          throw RequestError4.internalError(void 0, SESSION_ENDED_MESSAGE);
         }
         const option = session.configOptions.find((o) => o.id === params.configId);
         if (!option) {
@@ -69621,16 +69843,16 @@ ${message.api_refusal_explanation}` : "";
        */
       async validateCwd(cwd) {
         if (!path6.isAbsolute(cwd)) {
-          throw RequestError3.invalidParams({ cwd }, `\`cwd\` must be an absolute path, but received: ${cwd}`);
+          throw RequestError4.invalidParams({ cwd }, `\`cwd\` must be an absolute path, but received: ${cwd}`);
         }
         let stats;
         try {
           stats = await fs4.stat(cwd);
         } catch {
-          throw RequestError3.invalidParams({ cwd }, `\`cwd\` does not exist on the machine running the agent: ${cwd}`);
+          throw RequestError4.invalidParams({ cwd }, `\`cwd\` does not exist on the machine running the agent: ${cwd}`);
         }
         if (!stats.isDirectory()) {
-          throw RequestError3.invalidParams({ cwd }, `\`cwd\` is not a directory: ${cwd}`);
+          throw RequestError4.invalidParams({ cwd }, `\`cwd\` is not a directory: ${cwd}`);
         }
       }
       async createSession(params, creationOpts = {}) {
@@ -69853,12 +70075,12 @@ ${message.api_refusal_explanation}` : "";
           initializationResult = await q2.initializationResult();
         } catch (error62) {
           if (creationOpts.resume && error62 instanceof Error && (error62.message === "Query closed before response received" || error62.message.includes("No conversation found with session ID"))) {
-            throw RequestError3.resourceNotFound(sessionId);
+            throw RequestError4.resourceNotFound(sessionId);
           }
           throw error62;
         }
         if (shouldHideClaudeAuth() && initializationResult.account.subscriptionType && !this.gatewayAuthRequest) {
-          throw RequestError3.authRequired(void 0, "This integration does not support using claude.ai subscriptions.");
+          throw RequestError4.authRequired(void 0, "This integration does not support using claude.ai subscriptions.");
         }
         const settingsAvailableModels = settingsManager.getSettings().availableModels;
         const settingsModelOverrides = settingsManager.getSettings().modelOverrides;
@@ -69934,7 +70156,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 {
@@ -70081,6 +70303,28 @@ var init_endpoint = __esm({
   }
 });
 
+// src/acp/adapter/claude/agent-connection.ts
+var ClaudeAgentConnection;
+var init_agent_connection = __esm({
+  "src/acp/adapter/claude/agent-connection.ts"() {
+    "use strict";
+    init_endpoint_agent_connection();
+    init_endpoint();
+    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/util/filesystem/path-error.ts
 var LocalPathError;
 var init_path_error = __esm({
@@ -71025,7 +71269,7 @@ var init_version_output = __esm({
 });
 
 // src/agent/specification/agent-specification.ts
-var VERSION_PROBE_TIMEOUT_MILLISECONDS, ACP_PROBE_TIMEOUT_MILLISECONDS, LocalAgentSpecification, DirectAcpAgentSpecification, InProcessAcpAgentSpecification;
+var VERSION_PROBE_TIMEOUT_MILLISECONDS, ACP_PROBE_TIMEOUT_MILLISECONDS, LocalAgentSpecification, InProcessAcpAgentSpecification;
 var init_agent_specification = __esm({
   "src/agent/specification/agent-specification.ts"() {
     "use strict";
@@ -71047,17 +71291,6 @@ var init_agent_specification = __esm({
       resolveInstalledAgentExecutables = (_context) => Promise.resolve([]);
       verifyAcp = (_connection, _initialized, _defaultWorkspace, _signal) => Promise.resolve();
     };
-    DirectAcpAgentSpecification = class extends LocalAgentSpecification {
-      adapterOverrideVariable;
-      agentOverrideVariable;
-      launchArguments;
-      constructor(executableOverrideVariable, launchArguments) {
-        super();
-        this.adapterOverrideVariable = executableOverrideVariable;
-        this.agentOverrideVariable = executableOverrideVariable;
-        this.launchArguments = Object.freeze([...launchArguments]);
-      }
-    };
     InProcessAcpAgentSpecification = class extends LocalAgentSpecification {
       launchArguments = Object.freeze([]);
       adapterOverrideVariable;
@@ -71077,13 +71310,13 @@ var ClaudeCodeAgentSpecification;
 var init_claude_code_agent = __esm({
   "src/agent/specification/vendors/claude-code-agent.ts"() {
     "use strict";
-    init_endpoint();
+    init_agent_connection();
     init_platform();
     init_executable();
     init_agent_specification();
     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";
@@ -71109,76 +71342,6 @@ var init_claude_code_agent = __esm({
   }
 });
 
-// src/infra/operation-error.ts
-function operationErrorCode(error62) {
-  return error62 instanceof OperationError ? error62.code : "session_operation_failed";
-}
-function operationErrorMessage(error62) {
-  return error62 instanceof OperationError ? error62.message : "The local agent operation could not be completed";
-}
-var OperationError;
-var init_operation_error = __esm({
-  "src/infra/operation-error.ts"() {
-    "use strict";
-    OperationError = class extends Error {
-      code;
-      constructor(code, message, options = {}) {
-        super(message, options);
-        this.code = code;
-      }
-    };
-  }
-});
-
-// src/acp/acp-error.ts
-var AcpExecutionError, AcpConfigurationValueUnavailableError;
-var init_acp_error = __esm({
-  "src/acp/acp-error.ts"() {
-    "use strict";
-    init_operation_error();
-    AcpExecutionError = class extends OperationError {
-      constructor(message, options = {}, code = "acp_execution_failed") {
-        super(code, message, options);
-        this.name = "AcpExecutionError";
-      }
-    };
-    AcpConfigurationValueUnavailableError = class extends AcpExecutionError {
-      configId;
-      offeredValueCount;
-      offeredValues;
-      requestedValue;
-      constructor(configId, requestedValue, offeredValues) {
-        super("The requested ACP configuration value is unavailable", {}, "invalid_session_configuration");
-        this.name = "AcpConfigurationValueUnavailableError";
-        this.configId = configId.slice(0, 128);
-        this.requestedValue = requestedValue.slice(0, 128);
-        this.offeredValueCount = offeredValues.length;
-        this.offeredValues = Object.freeze(offeredValues.slice(0, 32).map((value) => value.slice(0, 128)));
-      }
-    };
-  }
-});
-
-// 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;
-    }
-  }
-}
-var init_in_process_endpoint = __esm({
-  "src/acp/agent/in-process-endpoint.ts"() {
-    "use strict";
-    init_acp_error();
-  }
-});
-
 // src/acp/harness/codex/app-server-protocol.ts
 import { isAbsolute as isAbsolute8 } from "node:path";
 function decodeAppServerMessage(value) {
@@ -71741,7 +71904,7 @@ var init_app_server_client = __esm({
 
 // src/acp/harness/codex/items.ts
 import { pathToFileURL } from "node:url";
-function truncate(value, limit) {
+function truncate2(value, limit) {
   return value.length <= limit ? value : value.slice(0, limit);
 }
 function boundedParagraphs(values, limit) {
@@ -71757,7 +71920,7 @@ function boundedParagraphs(values, limit) {
   return text2;
 }
 function textContent(text2) {
-  const block = { text: truncate(text2, TOOL_OUTPUT_CHARACTER_LIMIT), type: "text" };
+  const block = { text: truncate2(text2, TOOL_OUTPUT_CHARACTER_LIMIT), type: "text" };
   return { content: block, type: "content" };
 }
 function structuredToolText(value) {
@@ -71846,16 +72009,16 @@ function presentToolItem(item) {
       rawInput: { command: item.command, cwd: item.cwd },
       rawOutput: {
         ...item.exitCode == null ? {} : { exitCode: item.exitCode },
-        output: truncate(output2, TOOL_OUTPUT_CHARACTER_LIMIT)
+        output: truncate2(output2, TOOL_OUTPUT_CHARACTER_LIMIT)
       },
       status: commandStatus(item.status),
-      title: truncate(firstLine(item.command), TITLE_CHARACTER_LIMIT)
+      title: truncate2(firstLine(item.command), TITLE_CHARACTER_LIMIT)
     };
   }
   if (item.type === "fileChange") {
     const paths = item.changes.map((change) => change.path);
     const content = item.changes.map((change) => ({
-      newText: truncate(change.diff, TOOL_OUTPUT_CHARACTER_LIMIT),
+      newText: truncate2(change.diff, TOOL_OUTPUT_CHARACTER_LIMIT),
       path: change.path,
       type: "diff"
     }));
@@ -71866,7 +72029,7 @@ function presentToolItem(item) {
       rawInput: { changes: item.changes.map((change) => change.path) },
       rawOutput: null,
       status: patchStatus(item.status),
-      title: truncate(paths.join(", "), TITLE_CHARACTER_LIMIT)
+      title: truncate2(paths.join(", "), TITLE_CHARACTER_LIMIT)
     };
   }
   if (item.type === "mcpToolCall") {
@@ -71879,7 +72042,7 @@ function presentToolItem(item) {
       rawInput: item.arguments ?? null,
       rawOutput: item.error ?? item.result ?? null,
       status: mcpStatus(item.status),
-      title: truncate(label, TITLE_CHARACTER_LIMIT)
+      title: truncate2(label, TITLE_CHARACTER_LIMIT)
     };
   }
   if (item.type === "dynamicToolCall") {
@@ -71892,16 +72055,16 @@ function presentToolItem(item) {
       rawInput: item.arguments ?? null,
       rawOutput: item.contentItems ?? null,
       status: mcpStatus(item.status),
-      title: truncate(label, TITLE_CHARACTER_LIMIT)
+      title: truncate2(label, TITLE_CHARACTER_LIMIT)
     };
   }
   if (item.type === "collabAgentToolCall") {
-    const spawn10 = item.tool === "spawnAgent";
+    const spawn8 = item.tool === "spawnAgent";
     return {
       content: [],
       kind: "other",
       locations: [],
-      rawInput: spawn10 ? {
+      rawInput: spawn8 ? {
         model: item.model,
         prompt: item.prompt,
         reasoningEffort: item.reasoningEffort,
@@ -71909,10 +72072,10 @@ function presentToolItem(item) {
       } : { receiverThreadIds: item.receiverThreadIds, senderThreadId: item.senderThreadId },
       rawOutput: {
         agentsStates: item.agentsStates,
-        ...spawn10 ? { receiverThreadIds: item.receiverThreadIds } : {}
+        ...spawn8 ? { receiverThreadIds: item.receiverThreadIds } : {}
       },
       status: collaborationStatus(item.status),
-      title: spawn10 ? "Dispatch subagent" : "Wait for subagent"
+      title: spawn8 ? "Dispatch subagent" : "Wait for subagent"
     };
   }
   if (item.type === "subAgentActivity" && item.kind === "started") {
@@ -71923,7 +72086,7 @@ function presentToolItem(item) {
       rawInput: { agentPath: item.agentPath },
       rawOutput: { agentThreadId: item.agentThreadId },
       status: "in_progress",
-      title: truncate(`Dispatch subagent ${item.agentPath}`, TITLE_CHARACTER_LIMIT)
+      title: truncate2(`Dispatch subagent ${item.agentPath}`, TITLE_CHARACTER_LIMIT)
     };
   }
   return null;
@@ -72533,7 +72696,7 @@ var init_history_images = __esm({
 // src/acp/harness/codex/owned-agent.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
-import { methods as methods2 } from "@agentclientprotocol/sdk";
+import { methods as methods3 } from "@agentclientprotocol/sdk";
 function permissionDecision(optionId) {
   if (optionId === "accept" || optionId === "acceptForSession" || optionId === "decline") {
     return optionId;
@@ -72787,7 +72950,7 @@ var init_owned_agent = __esm({
         if (connection === null || this.#context.threadId().length === 0) {
           return;
         }
-        await connection.client.notify(methods2.client.session.update, {
+        await connection.client.notify(methods3.client.session.update, {
           sessionId: this.#context.threadId(),
           update: { configOptions: this.#settings.configOptions(), sessionUpdate: "config_option_update" }
         });
@@ -73012,7 +73175,7 @@ var init_owned_agent = __esm({
           return "cancel";
         }
         const response = await connection.client.request(
-          methods2.client.session.requestPermission,
+          methods3.client.session.requestPermission,
           {
             options: [...APPROVAL_OPTIONS],
             sessionId: this.#context.threadId(),
@@ -73049,7 +73212,7 @@ var init_owned_agent = __esm({
         }
         const questions = decoded.data.questions;
         const response = await connection.client.request(
-          methods2.client.elicitation.create,
+          methods3.client.elicitation.create,
           {
             message: questions.map((question) => question.question).join("\n\n").slice(0, 2e3),
             mode: "form",
@@ -73078,7 +73241,7 @@ var init_owned_agent = __esm({
         const signal = AbortSignal.timeout(APPROVAL_TIMEOUT_MILLISECONDS);
         if (params.mode === "url" && params.url !== void 0) {
           const response2 = await connection.client.request(
-            methods2.client.elicitation.create,
+            methods3.client.elicitation.create,
             {
               elicitationId: `${this.#context.threadId()}-${String(request.id)}`,
               message: params.message,
@@ -73092,7 +73255,7 @@ var init_owned_agent = __esm({
           return;
         }
         const response = await connection.client.request(
-          methods2.client.elicitation.create,
+          methods3.client.elicitation.create,
           {
             message: params.message,
             mode: "form",
@@ -73447,7 +73610,7 @@ var init_directory = __esm({
 });
 
 // ../mobius-sdk/src/protocol/shared/message-codec.ts
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseJson(encoded) {
@@ -73459,12 +73622,12 @@ function parseJson(encoded) {
       cause: error62
     });
   }
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     throw new ProtocolMessageError("Message must be a JSON object");
   }
   return value;
 }
-function readString(value, key, maximumLength) {
+function readString2(value, key, maximumLength) {
   const field = value[key];
   if (typeof field !== "string" || field.length === 0 || field.length > maximumLength) {
     throw new ProtocolMessageError(`Invalid string field: ${key}`);
@@ -73502,7 +73665,7 @@ function readIdentifier(value, key) {
   }
 }
 function readDirectoryIdentifier(value, key) {
-  const field = readString(value, key, MAX_DIRECTORY_IDENTIFIER_LENGTH);
+  const field = readString2(value, key, MAX_DIRECTORY_IDENTIFIER_LENGTH);
   if (!isDirectoryIdentifier(field)) {
     throw new ProtocolMessageError(`Invalid directory identifier field: ${key}`);
   }
@@ -73514,7 +73677,7 @@ function assertKind(value, expectedKind) {
   }
 }
 function decodeMessageKind(encoded) {
-  return readString(parseJson(encoded), "kind", 64);
+  return readString2(parseJson(encoded), "kind", 64);
 }
 function decodeZodMessage(encoded, schema) {
   const result = schema.safeParse(parseJson(encoded));
@@ -74715,7 +74878,9 @@ var init_native = __esm({
           external_exports.object({
             commandId: identifierStringSchema,
             prompt: external_exports.string().max(1e5),
-            images: external_exports.array(promptImageSchema).max(8).readonly()
+            images: external_exports.array(promptImageSchema).max(8).readonly(),
+            // Absent from daemons that predate it; a client then cannot restore the prompt's files.
+            resources: external_exports.array(promptResourceSchema).max(16).readonly().optional()
           }).readonly()
         ).readonly(),
         turn: activeTurnSnapshotSchema.nullable()
@@ -76391,7 +76556,7 @@ var init_settings3 = __esm({
 // src/acp/harness/codex/agent.ts
 import {
   agent as createAgentApp,
-  methods as methods3,
+  methods as methods4,
   PROTOCOL_VERSION
 } from "@agentclientprotocol/sdk";
 function promptInput(prompt) {
@@ -76490,7 +76655,7 @@ var init_agent = __esm({
         });
         this.#app = createAgentApp({ name: "mobius-codex" }).onConnect((connection) => {
           this.#connection = connection;
-        }).onRequest(methods3.agent.initialize, async () => ({
+        }).onRequest(methods4.agent.initialize, async () => ({
           _meta: { steering: { supported: true } },
           agentCapabilities: {
             loadSession: true,
@@ -76500,7 +76665,7 @@ var init_agent = __esm({
           agentInfo: { name: "Codex", version: CODEX_AGENT_VERSION },
           authMethods: [],
           protocolVersion: PROTOCOL_VERSION
-        })).onRequest(methods3.agent.session.new, async (context) => {
+        })).onRequest(methods4.agent.session.new, async (context) => {
           const created = threadStartResponseSchema.parse(
             await this.#appServer.request(
               "thread/start",
@@ -76513,13 +76678,13 @@ var init_agent = __esm({
           await this.#settings.probeCollaborationMode(this.#nativeSessionId, context.signal);
           this.#advertiseCompactCommand();
           return { configOptions: this.#settings.configOptions(), sessionId: created.thread.id };
-        }).onRequest(methods3.agent.session.setConfigOption, async (context) => {
+        }).onRequest(methods4.agent.session.setConfigOption, async (context) => {
           this.#settings.applySelection(context.params.configId, context.params.value);
           return { configOptions: this.#settings.configOptions() };
-        }).onRequest(methods3.agent.session.setMode, async (context) => {
+        }).onRequest(methods4.agent.session.setMode, async (context) => {
           this.#settings.applySelection("mode", context.params.modeId);
           return {};
-        }).onRequest(methods3.agent.session.load, async (context) => {
+        }).onRequest(methods4.agent.session.load, async (context) => {
           await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
           await this.#replaySavedHistory(context.signal);
           this.#advertiseCompactCommand();
@@ -76527,7 +76692,7 @@ var init_agent = __esm({
             _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
             configOptions: this.#settings.configOptions()
           };
-        }).onRequest(methods3.agent.session.fork, async (context) => {
+        }).onRequest(methods4.agent.session.fork, async (context) => {
           const forked = threadForkResponseSchema.parse(
             await this.#appServer.request(
               "thread/fork",
@@ -76546,14 +76711,14 @@ var init_agent = __esm({
           await this.#settings.probeCollaborationMode(this.#nativeSessionId, context.signal);
           this.#advertiseCompactCommand();
           return { configOptions: this.#settings.configOptions(), sessionId: forked.thread.id };
-        }).onRequest(methods3.agent.session.resume, async (context) => {
+        }).onRequest(methods4.agent.session.resume, async (context) => {
           await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
           this.#advertiseCompactCommand();
           return {
             _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
             configOptions: this.#settings.configOptions()
           };
-        }).onRequest(methods3.agent.session.prompt, async (context) => {
+        }).onRequest(methods4.agent.session.prompt, async (context) => {
           if (isCompactCommand(context.params.prompt)) {
             return await this.#sessionAgent.compact(context.signal);
           }
@@ -76562,7 +76727,7 @@ var init_agent = __esm({
           "_session/steering",
           (params) => params,
           async (context) => await this.#sessionAgent.steer(context.params, context.signal)
-        ).onRequest(methods3.agent.session.list, async (context) => {
+        ).onRequest(methods4.agent.session.list, async (context) => {
           const decoded = threadListResponseSchema.parse(
             await this.#appServer.request(
               "thread/list",
@@ -76584,9 +76749,9 @@ var init_agent = __esm({
               updatedAt: new Date(thread.updatedAt * 1e3).toISOString()
             }))
           };
-        }).onRequest(methods3.agent.session.close, async () => {
+        }).onRequest(methods4.agent.session.close, async () => {
           await this.#sessionAgent.cancel();
-        }).onNotification(methods3.agent.session.cancel, async () => {
+        }).onNotification(methods4.agent.session.cancel, async () => {
           await this.#sessionAgent.cancel();
         });
       }
@@ -76705,17 +76870,39 @@ var init_agent = __esm({
   }
 });
 
+// src/acp/adapter/codex/agent-connection.ts
+var CodexAgentConnection;
+var init_agent_connection2 = __esm({
+  "src/acp/adapter/codex/agent-connection.ts"() {
+    "use strict";
+    init_endpoint_agent_connection();
+    init_agent();
+    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;
 var init_codex_agent = __esm({
   "src/agent/specification/vendors/codex-agent.ts"() {
     "use strict";
-    init_agent();
+    init_agent_connection2();
     init_agent_specification();
     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";
@@ -77171,7 +77358,7 @@ var init_auth = __esm({
 });
 
 // src/acp/harness/pi/upstream/dist/acp/auth-required.js
-import { RequestError as RequestError4 } from "@agentclientprotocol/sdk";
+import { RequestError as RequestError5 } from "@agentclientprotocol/sdk";
 function maybeAuthRequiredError(err) {
   const msg = String(err?.message ?? err ?? "");
   const s = msg.toLowerCase();
@@ -77192,7 +77379,7 @@ function maybeAuthRequiredError(err) {
   if (!hit) {
     return null;
   }
-  return RequestError4.authRequired({
+  return RequestError5.authRequired({
     authMethods: getAuthMethods()
   }, "Configure an API key or log in with an OAuth provider.");
 }
@@ -77680,7 +77867,7 @@ var init_pi_settings = __esm({
 });
 
 // src/acp/harness/pi/upstream/dist/acp/extension-questions.js
-import { RequestError as RequestError5 } from "@agentclientprotocol/sdk";
+import { RequestError as RequestError6 } from "@agentclientprotocol/sdk";
 function questionField(question) {
   const title2 = question.title || "Answer";
   switch (question.method) {
@@ -77728,7 +77915,7 @@ var init_extension_questions = __esm({
       external_exports.object({ ...questionBase, method: external_exports.literal("editor"), prefill: external_exports.string().max(1e4).optional() })
     ]).readonly();
     QUESTION_TIMEOUT_MS = 36e5;
-    PiQuestionError = class extends RequestError5 {
+    PiQuestionError = class extends RequestError6 {
       constructor(kind, cause) {
         const messages = {
           request_failed: "Pi could not request an answer.",
@@ -77840,7 +78027,7 @@ var init_extension_questions = __esm({
             throw new PiQuestionError("invalid_response");
           }
         } catch (cause) {
-          if (!signal.aborted && !(cause instanceof RequestError5 && cause.code === -32800)) {
+          if (!signal.aborted && !(cause instanceof RequestError6 && cause.code === -32800)) {
             turn.controller.abort(cause instanceof PiQuestionError ? cause : new PiQuestionError("request_failed", cause));
           }
         } finally {
@@ -78148,7 +78335,7 @@ var init_pi_tools = __esm({
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { readFileSync as readFileSync7 } from "node:fs";
 import { isAbsolute as isAbsolute11, resolve as resolvePath } from "node:path";
-import { RequestError as RequestError6 } from "@agentclientprotocol/sdk";
+import { RequestError as RequestError7 } from "@agentclientprotocol/sdk";
 function toUsageUpdate(stats) {
   const used = stats?.contextUsage?.tokens;
   const size = stats?.contextUsage?.contextWindow;
@@ -78322,7 +78509,7 @@ var init_session = __esm({
           });
         } catch (e) {
           if (e instanceof PiRpcSpawnError) {
-            throw RequestError6.internalError({ code: e.code }, e.message);
+            throw RequestError7.internalError({ code: e.code }, e.message);
           }
           throw e;
         }
@@ -78351,7 +78538,7 @@ var init_session = __esm({
       get(sessionId) {
         const s = this.sessions.get(sessionId);
         if (!s) {
-          throw RequestError6.invalidParams(`Unknown sessionId: ${sessionId}`);
+          throw RequestError7.invalidParams(`Unknown sessionId: ${sessionId}`);
         }
         return s;
       }
@@ -78448,8 +78635,8 @@ var init_session = __esm({
           if (cause instanceof PiRpcProcessError) {
             const pending = this.pendingTurn;
             const reason = pending?.questionSignal.reason;
-            const error62 = reason instanceof RequestError6 ? reason : RequestError6.internalError({ code: cause.code, details: cause.message });
-            if (!(reason instanceof RequestError6)) {
+            const error62 = reason instanceof RequestError7 ? reason : RequestError7.internalError({ code: cause.code, details: cause.message });
+            if (!(reason instanceof RequestError7)) {
               error62.cause = cause;
             }
             this.extensionQuestions.endTurn(error62);
@@ -78517,12 +78704,12 @@ var init_session = __esm({
         const signal = this.extensionQuestions.startTurn();
         try {
           const result = await this.proc.compact(customInstructions, { signal, timeoutMs });
-          if (signal.aborted && signal.reason instanceof RequestError6) {
+          if (signal.aborted && signal.reason instanceof RequestError7) {
             throw signal.reason;
           }
           return result;
         } catch (cause) {
-          if (signal.aborted && signal.reason instanceof RequestError6) {
+          if (signal.aborted && signal.reason instanceof RequestError7) {
             try {
               await this.proc.abort({ signal: this.proc.signal, timeoutMs });
             } catch (abortCause) {
@@ -78615,14 +78802,14 @@ var init_session = __esm({
         await this.publishContextUsage();
         const retryFailure = this.turnRetryFailure;
         this.turnRetryFailure = null;
-        if (questionSignal?.aborted && questionSignal.reason instanceof RequestError6 && !this.cancelRequested) {
+        if (questionSignal?.aborted && questionSignal.reason instanceof RequestError7 && !this.cancelRequested) {
           this.pendingTurn?.reject(questionSignal.reason);
         } else if (retryFailure !== null && !this.cancelRequested) {
           this.pendingTurn?.reject(
             // The message rides in `data.details` so clients that unwrap the
             // JSON-RPC internal-error envelope (like Mobius) surface the real
             // model error; `code` keeps the failure machine-readable.
-            RequestError6.internalError({
+            RequestError7.internalError({
               code: "pi_retries_exhausted",
               details: `Pi retries exhausted: ${retryFailure}`
             })
@@ -79074,7 +79261,7 @@ import { spawnSync } from "node:child_process";
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync8, realpathSync as realpathSync3, statSync as statSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import { basename as basename6, dirname as dirname9, isAbsolute as isAbsolute12, join as join20 } from "node:path";
-import { RequestError as RequestError7 } from "@agentclientprotocol/sdk";
+import { RequestError as RequestError8 } from "@agentclientprotocol/sdk";
 function thinkingLevelName(id) {
   return id.split(/[_-]/u).map((part) => part.length === 0 ? part : `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
 }
@@ -79278,7 +79465,7 @@ async function setSessionModel(proc, requestedModelId) {
     }
   }
   if (!provider || !modelId) {
-    throw RequestError7.invalidParams(`Unknown modelId: ${requestedModelId}`);
+    throw RequestError8.invalidParams(`Unknown modelId: ${requestedModelId}`);
   }
   await proc.setModel(provider, modelId);
 }
@@ -79559,7 +79746,7 @@ var init_agent2 = __esm({
         const restorePromise = (async () => {
           const stored = this.findStoredSession(sessionId);
           if (!stored) {
-            throw RequestError7.invalidParams(`Unknown sessionId: ${sessionId}`);
+            throw RequestError8.invalidParams(`Unknown sessionId: ${sessionId}`);
           }
           const cwd = opts?.cwd ?? stored.cwd;
           let proc;
@@ -79572,7 +79759,7 @@ var init_agent2 = __esm({
             });
           } catch (e) {
             if (e?.name === "PiRpcSpawnError") {
-              throw RequestError7.internalError({ code: e?.code }, String(e?.message ?? e));
+              throw RequestError8.internalError({ code: e?.code }, String(e?.message ?? e));
             }
             throw e;
           }
@@ -79632,7 +79819,7 @@ var init_agent2 = __esm({
       }
       async newSession(params) {
         if (!isAbsolute12(params.cwd)) {
-          throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+          throw RequestError8.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         this.lastSessionCwd = params.cwd;
         const fileCommands = loadSlashCommands(params.cwd, this.environment);
@@ -79671,16 +79858,16 @@ var init_agent2 = __esm({
         }
         if (availableModelsErr) {
           this.cleanupFailedNewSession(session.sessionId, state);
-          throw RequestError7.internalError({}, String(availableModelsErr?.message ?? availableModelsErr));
+          throw RequestError8.internalError({}, String(availableModelsErr?.message ?? availableModelsErr));
         }
         const rawModelsCount = Array.isArray(availableModels?.models) ? availableModels.models.length : 0;
         if (rawModelsCount === 0) {
           this.cleanupFailedNewSession(session.sessionId, state);
-          throw RequestError7.authRequired({ authMethods: getAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
+          throw RequestError8.authRequired({ authMethods: getAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
         }
         if (stateErr && maybeAuthRequiredError(stateErr)) {
           this.cleanupFailedNewSession(session.sessionId, state);
-          throw RequestError7.authRequired({ authMethods: getAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
+          throw RequestError8.authRequired({ authMethods: getAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
         }
         let configuration;
         try {
@@ -79690,7 +79877,7 @@ var init_agent2 = __esm({
           configuration = await getSessionConfiguration(session.proc, { state, availableModels });
         } catch (err) {
           this.cleanupFailedNewSession(session.sessionId, state);
-          throw maybeAuthRequiredError(err) ?? RequestError7.internalError({}, String(err?.message ?? err));
+          throw maybeAuthRequiredError(err) ?? RequestError8.internalError({}, String(err?.message ?? err));
         }
         const { configOptions, models, modes } = configuration;
         const quietStartup = getQuietStartup(params.cwd, this.environment);
@@ -80188,7 +80375,7 @@ ${JSON.stringify(stats, null, 2)}`;
         signal.throwIfAborted();
         const parsed = steerRequestSchema.safeParse(params);
         if (!parsed.success) {
-          throw RequestError7.invalidParams("Invalid steering request");
+          throw RequestError8.invalidParams("Invalid steering request");
         }
         const session = this.sessions.maybeGet(parsed.data.sessionId);
         if (session === void 0) {
@@ -80229,11 +80416,11 @@ ${JSON.stringify(stats, null, 2)}`;
       }
       async forkSession(params) {
         if (!isAbsolute12(params.cwd)) {
-          throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+          throw RequestError8.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         const source = this.findStoredSession(params.sessionId);
         if (!source) {
-          throw RequestError7.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+          throw RequestError8.invalidParams(`Unknown sessionId: ${params.sessionId}`);
         }
         this.lastSessionCwd = params.cwd;
         const fileCommands = loadSlashCommands(params.cwd, this.environment);
@@ -80295,13 +80482,13 @@ ${JSON.stringify(stats, null, 2)}`;
       }
       async resumeSession(params) {
         if (!isAbsolute12(params.cwd)) {
-          throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+          throw RequestError8.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         this.sessions.close(params.sessionId);
         this.lastSessionCwd = params.cwd;
         const stored = this.findStoredSession(params.sessionId);
         if (!stored) {
-          throw RequestError7.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+          throw RequestError8.invalidParams(`Unknown sessionId: ${params.sessionId}`);
         }
         const session = await this.restoreSession(params.sessionId, {
           cwd: params.cwd,
@@ -80366,13 +80553,13 @@ ${JSON.stringify(stats, null, 2)}`;
       }
       async loadSession(params) {
         if (!isAbsolute12(params.cwd)) {
-          throw RequestError7.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+          throw RequestError8.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
         }
         this.sessions.close(params.sessionId);
         this.lastSessionCwd = params.cwd;
         const stored = this.findStoredSession(params.sessionId);
         if (!stored) {
-          throw RequestError7.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+          throw RequestError8.invalidParams(`Unknown sessionId: ${params.sessionId}`);
         }
         const enableSkillCommands = getEnableSkillCommands(params.cwd, this.environment);
         const session = await this.restoreSession(params.sessionId, {
@@ -80547,7 +80734,7 @@ ${JSON.stringify(stats, null, 2)}`;
         const session = await this.restoreSession(params.sessionId);
         const mode = params.modeId;
         if (typeof mode !== "string" || mode.length === 0) {
-          throw RequestError7.invalidParams("Expected nonempty string modeId");
+          throw RequestError8.invalidParams("Expected nonempty string modeId");
         }
         await session.proc.setThinkingLevel(mode);
         await emitConfigOptionsUpdate(this.conn, session.sessionId, session.proc);
@@ -80558,18 +80745,18 @@ ${JSON.stringify(stats, null, 2)}`;
         const configId = String(params.configId);
         let modelChanged = false;
         if (typeof params.value !== "string") {
-          throw RequestError7.invalidParams(`Expected string value for config option: ${configId}`);
+          throw RequestError8.invalidParams(`Expected string value for config option: ${configId}`);
         }
         if (configId === MODEL_CONFIG_ID2) {
           await setSessionModel(session.proc, params.value);
           modelChanged = true;
         } else if (configId === THOUGHT_LEVEL_CONFIG_ID) {
           if (params.value.length === 0) {
-            throw RequestError7.invalidParams("Expected nonempty thinking level");
+            throw RequestError8.invalidParams("Expected nonempty thinking level");
           }
           await session.proc.setThinkingLevel(params.value);
         } else {
-          throw RequestError7.invalidParams(`Unknown config option: ${configId}`);
+          throw RequestError8.invalidParams(`Unknown config option: ${configId}`);
         }
         const configOptions = await emitConfigOptionsUpdate(this.conn, session.sessionId, session.proc);
         if (modelChanged) {
@@ -80582,11 +80769,11 @@ ${JSON.stringify(stats, null, 2)}`;
 });
 
 // src/acp/harness/pi/upstream/dist/acp/client.js
-import { methods as methods4 } from "@agentclientprotocol/sdk";
+import { methods as methods5 } from "@agentclientprotocol/sdk";
 function createPiAcpClient(connection, onSessionUpdate) {
   return {
-    requestElicitation: async (request, signal) => await connection.client.request(methods4.client.elicitation.create, request, { cancellationSignal: signal }),
-    requestPermission: async (request) => await connection.client.request(methods4.client.session.requestPermission, request),
+    requestElicitation: async (request, signal) => await connection.client.request(methods5.client.elicitation.create, request, { cancellationSignal: signal }),
+    requestPermission: async (request) => await connection.client.request(methods5.client.session.requestPermission, request),
     sessionUpdate: onSessionUpdate
   };
 }
@@ -80597,7 +80784,7 @@ var init_client = __esm({
 });
 
 // src/acp/harness/pi/endpoint.ts
-import { agent as createAgentApp2, methods as methods5 } from "@agentclientprotocol/sdk";
+import { agent as createAgentApp2, methods as methods6 } from "@agentclientprotocol/sdk";
 function piAgentOrThrow(agent) {
   if (agent === null) {
     throw new Error("The Pi ACP client is not connected");
@@ -80632,36 +80819,36 @@ var init_endpoint2 = __esm({
           piAgent = new PiAcpAgent(createPiAcpClient(connection, options.onSessionUpdate), { environment });
           this.#agent = piAgent;
         }).onRequest(
-          methods5.agent.initialize,
+          methods6.agent.initialize,
           async (context) => await piAgentOrThrow(piAgent).initialize(context.params)
         ).onRequest(
-          methods5.agent.authenticate,
+          methods6.agent.authenticate,
           async (context) => await piAgentOrThrow(piAgent).authenticate(context.params)
         ).onRequest(
-          methods5.agent.session.new,
+          methods6.agent.session.new,
           async (context) => await piAgentOrThrow(piAgent).newSession(context.params)
         ).onRequest(
-          methods5.agent.session.load,
+          methods6.agent.session.load,
           async (context) => await piAgentOrThrow(piAgent).loadSession(context.params)
         ).onRequest(
-          methods5.agent.session.resume,
+          methods6.agent.session.resume,
           async (context) => await piAgentOrThrow(piAgent).resumeSession(context.params)
         ).onRequest(
-          methods5.agent.session.list,
+          methods6.agent.session.list,
           async (context) => await piAgentOrThrow(piAgent).listSessions(context.params)
         ).onRequest(
-          methods5.agent.session.delete,
+          methods6.agent.session.delete,
           async (context) => await piAgentOrThrow(piAgent).deleteSession(context.params)
         ).onRequest(
-          methods5.agent.session.fork,
+          methods6.agent.session.fork,
           async (context) => await piAgentOrThrow(piAgent).forkSession(context.params)
         ).onRequest(
-          methods5.agent.session.setMode,
+          methods6.agent.session.setMode,
           async (context) => await piAgentOrThrow(piAgent).setSessionMode(context.params)
         ).onRequest(
-          methods5.agent.session.setConfigOption,
+          methods6.agent.session.setConfigOption,
           async (context) => await piAgentOrThrow(piAgent).setSessionConfigOption(context.params)
-        ).onRequest(methods5.agent.session.prompt, async (context) => {
+        ).onRequest(methods6.agent.session.prompt, async (context) => {
           const agent = piAgentOrThrow(piAgent);
           const cancel = () => {
             void agent.cancel({ sessionId: context.params.sessionId });
@@ -80676,7 +80863,7 @@ var init_endpoint2 = __esm({
           "_session/steering",
           (params) => params,
           async (context) => await piAgentOrThrow(piAgent).steer(context.params, context.signal)
-        ).onNotification(methods5.agent.session.cancel, async (context) => {
+        ).onNotification(methods6.agent.session.cancel, async (context) => {
           await piAgentOrThrow(piAgent).cancel(context.params);
         });
       }
@@ -80701,6 +80888,28 @@ var init_endpoint2 = __esm({
   }
 });
 
+// src/acp/adapter/pi/agent-connection.ts
+var PiAgentConnection;
+var init_agent_connection3 = __esm({
+  "src/acp/adapter/pi/agent-connection.ts"() {
+    "use strict";
+    init_endpoint_agent_connection();
+    init_endpoint2();
+    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;
 var init_agent_probe_error = __esm({
@@ -80721,20 +80930,20 @@ var init_agent_probe_error = __esm({
 import { createHash as createHash3 } from "node:crypto";
 import { join as join21 } from "node:path";
 import {
-  methods as methods6
+  methods as methods7
 } from "@agentclientprotocol/sdk";
 var ACP_PROBE_TIMEOUT_MILLISECONDS2, PiAgentSpecification;
 var init_pi_agent = __esm({
   "src/agent/specification/vendors/pi-agent.ts"() {
     "use strict";
-    init_endpoint2();
+    init_agent_connection3();
     init_agent_probe_error();
     init_agent_specification();
     ACP_PROBE_TIMEOUT_MILLISECONDS2 = 3e4;
     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) => {
@@ -80759,7 +80968,7 @@ var init_pi_agent = __esm({
           throw new AgentProbeError("acp_incompatible", "Pi ACP adapter does not support session recovery");
         }
         const session = await connection.agent.request(
-          methods6.agent.session.new,
+          methods7.agent.session.new,
           {
             additionalDirectories: [],
             cwd: defaultWorkspace,
@@ -80771,7 +80980,7 @@ var init_pi_agent = __esm({
           throw new AgentProbeError("acp_incompatible", "Pi ACP adapter returned an invalid session");
         }
         const prompt = await connection.agent.request(
-          methods6.agent.session.prompt,
+          methods7.agent.session.prompt,
           {
             prompt: [{ text: "/session", type: "text" }],
             sessionId: session.sessionId
@@ -80967,37 +81176,13 @@ var init_local_executable = __esm({
   }
 });
 
-// src/util/value-utils.ts
-function truncate2(value, maximumLength) {
-  return value.length <= maximumLength ? value : `${value.slice(0, Math.max(0, maximumLength - 1))}\u2026`;
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readString2(value, fallback = "") {
-  return typeof value === "string" ? value : fallback;
-}
-function arraysEqual(left, right) {
-  return left.length === right.length && left.every((value, index2) => value === right[index2]);
-}
-function recordsEqual(left, right) {
-  const leftEntries = Object.entries(left);
-  const rightEntries = Object.entries(right);
-  return leftEntries.length === rightEntries.length && leftEntries.every(([name2, value]) => right[name2] === value);
-}
-var init_value_utils = __esm({
-  "src/util/value-utils.ts"() {
-    "use strict";
-  }
-});
-
 // src/acp/protocol/session-capabilities.ts
 function hasTrueChildField(value, childKey, fieldKey) {
-  if (!isRecord3(value)) {
+  if (!isRecord(value)) {
     return false;
   }
   const child = Reflect.get(value, childKey);
-  return isRecord3(child) && Reflect.get(child, fieldKey) === true;
+  return isRecord(child) && Reflect.get(child, fieldKey) === true;
 }
 function unsupportedSessionCapabilities() {
   return Object.freeze({
@@ -81037,11 +81222,11 @@ function normalizeAcpCapabilities(initialized) {
   });
 }
 function restrictAcpSessionCapabilities(capabilities, response) {
-  if (!isRecord3(response) || !isRecord3(response["_meta"])) {
+  if (!isRecord(response) || !isRecord(response["_meta"])) {
     return capabilities;
   }
   const steering = response["_meta"]["steering"];
-  if (!isRecord3(steering) || steering["supported"] !== false) {
+  if (!isRecord(steering) || steering["supported"] !== false) {
     return capabilities;
   }
   return Object.freeze({ ...capabilities, steering: false });
@@ -81054,178 +81239,89 @@ var init_session_capabilities = __esm({
 });
 
 // src/acp/agent/agent-definition.ts
-var AgentDefinition, LocalAgentDefinition, InProcessAcpAgentDefinition;
+var AcpAgentDefinition;
 var init_agent_definition = __esm({
   "src/acp/agent/agent-definition.ts"() {
     "use strict";
     init_local_executable();
     init_session_capabilities();
-    AgentDefinition = class {
+    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, createConnection2, 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 = createConnection2;
       }
-    };
-    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(
-        this.id,
-        this.label,
-        this.command,
-        this.arguments,
-        environment,
-        this.adapterVersion,
-        this.agentVersion,
-        this.adapterIdentity,
-        this.agentIdentity,
-        this.capabilities
-      );
-    };
-    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(
+      createConnection = (options) => this.#connectionFactory({ ...options, command: this.command, environment: this.environment });
+      withEnvironment = (environment) => new _AcpAgentDefinition(
         this.id,
         this.label,
         this.command,
-        this.createEndpoint,
+        this.#connectionFactory,
         environment,
         this.agentVersion,
         this.agentIdentity,
-        this.capabilities
+        this.capabilities,
+        this.adapterVersion,
+        this.runtimeExecutables
       );
     };
   }
 });
 
-// src/acp/connection/create-client.ts
-import {
-  client,
-  methods as methods7
-} from "@agentclientprotocol/sdk";
-var createAcpClient;
-var init_create_client = __esm({
-  "src/acp/connection/create-client.ts"() {
-    "use strict";
-    createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
-      methods7.client.session.requestPermission,
-      async (context) => await handler.onPermission(context.params, context.signal)
-    ).onRequest(
-      methods7.client.elicitation.create,
-      async (context) => await handler.onElicitation(context.params, context.signal)
-    ).onNotification(methods7.client.session.update, async (context) => {
-      await handler.onUpdate(context.params);
-    }).onNotification(methods7.client.elicitation.complete, async (context) => {
-      await handler.onElicitationComplete(context.params);
-    });
-  }
-});
-
 // src/agent/discovery/acp-readiness-probe.ts
-import { spawn as spawn6 } from "node:child_process";
 import {
   methods as methods8,
-  ndJsonStream as ndJsonStream2,
-  PROTOCOL_VERSION as PROTOCOL_VERSION2,
-  RequestError as RequestError8
+  PROTOCOL_VERSION as PROTOCOL_VERSION2
 } from "@agentclientprotocol/sdk";
-function readableAcpStream(input2) {
-  let byteLength = 0;
-  let open7 = true;
-  return new ReadableStream({
-    start(controller) {
-      input2.on("data", (chunk) => {
-        if (!open7) {
-          return;
-        }
-        if (!(chunk instanceof Uint8Array)) {
-          open7 = false;
-          controller.error(new Error("ACP adapter produced invalid output"));
-          return;
-        }
-        byteLength += chunk.byteLength;
-        if (byteLength > ACP_OUTPUT_LIMIT_BYTES) {
-          open7 = false;
-          controller.error(new Error("ACP adapter output limit exceeded"));
-          return;
-        }
-        controller.enqueue(new Uint8Array(chunk));
-      });
-      input2.once("end", () => {
-        if (open7) {
-          open7 = false;
-          controller.close();
-        }
-      });
-      input2.once("error", (error62) => {
-        if (open7) {
-          open7 = false;
-          controller.error(error62);
-        }
-      });
-    },
-    cancel() {
-      open7 = 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(
             methods8.agent.initialize,
             {
               clientCapabilities: {},
@@ -81240,161 +81336,43 @@ 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 RequestError8 && 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 = spawn6(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(
-    ndJsonStream2(writableAcpStream(stdin), readableAcpStream(stdout))
-  );
-  try {
-    const initialized = await Promise.race([
-      connection.agent.request(
-        methods8.agent.initialize,
-        {
-          clientCapabilities: {},
-          clientInfo: { name: "mobius", version: "0.0.3" },
-          protocolVersion: PROTOCOL_VERSION2
-        },
-        { cancellationSignal: controller.signal }
-      ),
-      processExit
-    ]);
-    if (initialized.protocolVersion !== PROTOCOL_VERSION2) {
-      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 RequestError8 && 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);
   }
 }
-var ACP_OUTPUT_LIMIT_BYTES, VerifiedAcpReadiness, DiscoveryAcpHandler;
+var VerifiedAcpReadiness, DiscoveryAcpHandler;
 var init_acp_readiness_probe = __esm({
   "src/agent/discovery/acp-readiness-probe.ts"() {
     "use strict";
-    init_in_process_endpoint();
-    init_create_client();
+    init_acp_error();
     init_session_capabilities();
-    init_executable();
     init_agent_probe_error();
     init_version_output();
-    ACP_OUTPUT_LIMIT_BYTES = 1024 * 1024;
     VerifiedAcpReadiness = class {
       adapterVersion;
       capabilities;
@@ -81508,10 +81486,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({
@@ -81532,7 +81507,6 @@ var init_executable_discovery = __esm({
   "src/agent/discovery/executable-discovery.ts"() {
     "use strict";
     init_executable();
-    init_agent_specification();
     init_version_output();
   }
 });
@@ -81633,7 +81607,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 = "";
@@ -81664,26 +81638,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(
@@ -82107,244 +82071,6 @@ var init_session_config_protocol = __esm({
   }
 });
 
-// src/acp/connection/agent-connection.ts
-import { spawn as spawn7 } from "node:child_process";
-import { ndJsonStream as ndJsonStream3, RequestError as RequestError9 } from "@agentclientprotocol/sdk";
-function requestErrorMessage(error62) {
-  const fallback = truncate2(error62.message, 500);
-  if (error62.message !== "Internal error" || !isRecord3(error62.data)) {
-    return fallback;
-  }
-  const agentError = error62.data["error"];
-  if (isRecord3(agentError)) {
-    const message = agentError["message"];
-    if (typeof message === "string" && message.length > 0) {
-      return truncate2(message, 500);
-    }
-  }
-  const details = error62.data["details"];
-  return typeof details === "string" && details.length > 0 ? truncate2(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((resolve21, 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;
-          }
-          resolve21();
-        });
-      });
-    }
-  });
-}
-var AgentConnection;
-var init_agent_connection = __esm({
-  "src/acp/connection/agent-connection.ts"() {
-    "use strict";
-    init_executable();
-    init_value_utils();
-    init_acp_error();
-    init_in_process_endpoint();
-    init_create_client();
-    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 = spawn7(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((resolve21) => {
-          child.once("error", (cause) => {
-            resolve21({ kind: "failed", error: new AcpExecutionError("The ACP process could not run", { cause }) });
-          });
-          child.once("exit", (code, signal) => {
-            resolve21({
-              kind: "failed",
-              error: new AcpExecutionError("The ACP process stopped", { cause: { code, signal } })
-            });
-          });
-        });
-        const stream = ndJsonStream3(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 RequestError9 && error62.code === -32e3) {
-              throw new AcpExecutionError(
-                "Agent authentication is required",
-                { cause: error62 },
-                "authentication_required"
-              );
-            }
-            if (error62 instanceof RequestError9) {
-              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, MAX_PENDING_BYTES, MAX_SELECTED_UPDATES, MAX_SELECTED_BYTES, MAX_RUNTIME_QUEUED_BYTES, UPDATES_PER_YIELD, runtimeQueuedBytes, updatesSinceYield, AgentUpdateStream;
@@ -82481,7 +82207,6 @@ var init_session_events = __esm({
     init_protocol();
     init_value_utils();
     init_acp_error();
-    init_agent_connection();
     init_agent_update_stream();
     init_session_config_protocol();
     MAXIMUM_REASONING_UPDATE_CHARACTERS = 1e6;
@@ -82525,9 +82250,9 @@ var init_session_events = __esm({
                   kind: "commands",
                   payload,
                   commands: update.availableCommands.slice(0, 500).map((command) => ({
-                    description: truncate2(command.description, 500),
-                    inputHint: truncate2(command.input?.hint ?? "", 255),
-                    name: truncate2(command.name, 128)
+                    description: truncate(command.description, 500),
+                    inputHint: truncate(command.input?.hint ?? "", 255),
+                    name: truncate(command.name, 128)
                   })).filter((command) => command.name.length > 0)
                 };
                 break;
@@ -82544,10 +82269,10 @@ var init_session_events = __esm({
               case "session_info_update": {
                 const changes = [];
                 if (Object.hasOwn(update, "title")) {
-                  changes.push({ kind: "title", value: truncate2(update.title ?? "", 500) });
+                  changes.push({ kind: "title", value: truncate(update.title ?? "", 500) });
                 }
                 if (Object.hasOwn(update, "updatedAt")) {
-                  changes.push({ kind: "updated-at", value: truncate2(update.updatedAt ?? "", 128) });
+                  changes.push({ kind: "updated-at", value: truncate(update.updatedAt ?? "", 128) });
                 }
                 event = { kind: "info", payload, changes };
                 break;
@@ -82592,21 +82317,23 @@ var init_session_events = __esm({
           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"));
@@ -82807,7 +82534,7 @@ var init_live_sessions = __esm({
           "ACP agent exited during steering",
           signal
         );
-        if (isRecord3(response)) {
+        if (isRecord(response)) {
           const outcome = response["outcome"];
           if (outcome === "injected" || outcome === "startedNewTurn") {
             return outcome;
@@ -82832,7 +82559,7 @@ var init_live_sessions = __esm({
       renameSession = async (target, title2, signal) => {
         signal.throwIfAborted();
         const { connection, scope } = this.#resolve(target);
-        const normalized = truncate2(title2, 500);
+        const normalized = truncate(title2, 500);
         if (normalized.length === 0) {
           throw new AcpExecutionError("The Session title cannot be empty", {}, "invalid_session_title");
         }
@@ -83712,10 +83439,7 @@ var init_retained_agent_processes = __esm({
 import { methods as methods11, PROTOCOL_VERSION as PROTOCOL_VERSION3 } from "@agentclientprotocol/sdk";
 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(
@@ -83726,16 +83450,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(
       methods11.agent.initialize,
@@ -83765,8 +83483,8 @@ async function initializeAgentConnection(connection, agentId, verifiedVersion, s
   }
   return {
     capabilities: normalizeAcpCapabilities(initialized),
-    agentName: truncate2(initialized.agentInfo?.title ?? initialized.agentInfo?.name ?? agentId, 255),
-    agentVersion: truncate2(
+    agentName: truncate(initialized.agentInfo?.title ?? initialized.agentInfo?.name ?? agentId, 255),
+    agentVersion: truncate(
       verifiedVersion.length > 0 ? verifiedVersion : initialized.agentInfo?.version ?? "",
       128
     )
@@ -90804,11 +90522,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;
 }
 var init_resolve_catalog_agent = __esm({
   "src/runtime/catalog/resolve-catalog-agent.ts"() {
@@ -91776,9 +91497,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord3(value)) {
+  if (isRecord(value)) {
     const error62 = value["error"];
-    if (isRecord3(error62)) {
+    if (isRecord(error62)) {
       const code = error62["code"];
       const message = error62["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -91789,7 +91510,7 @@ function readRelayError(value) {
   return new PairingClientError("pairing_failed", "The relay could not pair this machine");
 }
 function decodePairingResponse(value, credentialField, expectedKeys) {
-  if (!isRecord3(value) || !hasExactKeys2(value, expectedKeys)) {
+  if (!isRecord(value) || !hasExactKeys2(value, expectedKeys)) {
     throw new PairingClientError("invalid_relay_response", "The relay returned an invalid pairing response");
   }
   const appId = value["appId"];
@@ -92108,7 +91829,7 @@ var init_agent_diagnostics = __esm({
       label;
       status = "ready";
       constructor(discovery) {
-        this.adapterVersion = discovery.agent.kind === "acp-adapter-process" ? discovery.agent.adapterVersion : discovery.agent.agentVersion;
+        this.adapterVersion = discovery.agent.adapterVersion;
         this.agentVersion = discovery.agent.agentVersion;
         this.id = discovery.specification.id;
         this.label = discovery.specification.label;
@@ -92643,7 +92364,7 @@ var init_worker_lifecycle_log = __esm({
 });
 
 // src/daemon/lifecycle/worker-process.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { isAbsolute as isAbsolute15 } from "node:path";
 async function decodeWorkerLaunch(value) {
   const { entry, executable, version: version2 } = workerLaunch.parse(value);
@@ -92692,7 +92413,7 @@ var init_worker_process = __esm({
       constructor(launch, signal, environment) {
         signal.throwIfAborted();
         this.launch = launch;
-        this.#child = spawn8(launch.executable, [launch.entry, "__worker"], {
+        this.#child = spawn6(launch.executable, [launch.entry, "__worker"], {
           env: environment,
           windowsHide: true,
           stdio: ["ignore", "pipe", "pipe", "ipc"]
@@ -92709,7 +92430,7 @@ var init_worker_process = __esm({
           this.#drained.resolve();
         });
         this.#child.on("message", (value) => {
-          if (isRecord3(value) && value["kind"] === "worker-ready") {
+          if (isRecord(value) && value["kind"] === "worker-ready") {
             if (value["version"] !== launch.version) {
               this.#started.reject(
                 new WorkerStartupError(
@@ -93211,9 +92932,9 @@ var init_package2 = __esm({
 });
 
 // src/daemon/lifecycle/manager-client.ts
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 async function spawnManager(launch) {
-  const child = spawn9(launch.executable, [launch.entry, "__manager"], {
+  const child = spawn7(launch.executable, [launch.entry, "__manager"], {
     detached: true,
     windowsHide: true,
     env: process.env,
@@ -93761,11 +93482,11 @@ function normalizeElicitationOptions(schema) {
   const oneOf = schema["oneOf"];
   if (Array.isArray(oneOf)) {
     for (const option of oneOf) {
-      if (isRecord3(option) && typeof option["const"] === "string") {
+      if (isRecord(option) && typeof option["const"] === "string") {
         normalized.push({
-          description: truncate2(readString2(option["description"]), 500),
-          label: truncate2(readString2(option["title"], option["const"]), 255),
-          value: truncate2(option["const"], 500)
+          description: truncate(readString(option["description"]), 500),
+          label: truncate(readString(option["title"], option["const"]), 255),
+          value: truncate(option["const"], 500)
         });
       }
     }
@@ -93781,7 +93502,7 @@ function normalizeElicitationOptions(schema) {
     return normalized.slice(0, 200);
   }
   const items = schema["items"];
-  if (!isRecord3(items)) {
+  if (!isRecord(items)) {
     return normalized;
   }
   const anyOf = items["anyOf"];
@@ -93794,7 +93515,7 @@ function numericString(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toString() : "";
 }
 function normalizeElicitationFields(requestedSchema) {
-  if (!isRecord3(requestedSchema) || !isRecord3(requestedSchema["properties"])) {
+  if (!isRecord(requestedSchema) || !isRecord(requestedSchema["properties"])) {
     return [];
   }
   const properties = requestedSchema["properties"];
@@ -93804,7 +93525,7 @@ function normalizeElicitationFields(requestedSchema) {
   );
   const normalized = [];
   for (const [name2, property] of Object.entries(properties)) {
-    if (!isRecord3(property)) {
+    if (!isRecord(property)) {
       continue;
     }
     const type = elicitationFieldType(property["type"]);
@@ -93815,20 +93536,20 @@ function normalizeElicitationFields(requestedSchema) {
     normalized.push({
       defaultBooleanValue: typeof defaultValue === "boolean" ? defaultValue : false,
       defaultNumberValue: typeof defaultValue === "number" && Number.isFinite(defaultValue) ? defaultValue : 0,
-      defaultStringValue: typeof defaultValue === "string" ? truncate2(defaultValue, 1e4) : Array.isArray(defaultValue) ? truncate2(JSON.stringify(defaultValue), 1e4) : "",
-      description: truncate2(readString2(property["description"]), 500),
-      format: truncate2(readString2(property["format"]), 64),
+      defaultStringValue: typeof defaultValue === "string" ? truncate(defaultValue, 1e4) : Array.isArray(defaultValue) ? truncate(JSON.stringify(defaultValue), 1e4) : "",
+      description: truncate(readString(property["description"]), 500),
+      format: truncate(readString(property["format"]), 64),
       hasDefaultValue: defaultValue !== void 0 && defaultValue !== null,
       maximum: numericString(property["maximum"]),
       maximumLength: numericString(property["maxLength"] ?? property["maxItems"]),
       minimum: numericString(property["minimum"]),
       minimumLength: numericString(property["minLength"] ?? property["minItems"]),
-      ...normalizedType === "string" && isRecord3(metadata) && metadata["io.mobius/multiline"] === true ? { multiline: true } : {},
-      name: truncate2(name2, 128),
+      ...normalizedType === "string" && isRecord(metadata) && metadata["io.mobius/multiline"] === true ? { multiline: true } : {},
+      name: truncate(name2, 128),
       options,
-      pattern: truncate2(readString2(property["pattern"]), 500),
+      pattern: truncate(readString(property["pattern"]), 500),
       required: required2.has(name2),
-      title: truncate2(readString2(property["title"], name2), 255),
+      title: truncate(readString(property["title"], name2), 255),
       type: normalizedType
     });
   }
@@ -93897,7 +93618,7 @@ function validateElicitationContent(encoded, requestedSchema) {
       "invalid_elicitation_response"
     );
   }
-  if (!isRecord3(decoded) || !isRecord3(requestedSchema) || !isRecord3(requestedSchema["properties"])) {
+  if (!isRecord(decoded) || !isRecord(requestedSchema) || !isRecord(requestedSchema["properties"])) {
     throw new AcpExecutionError(
       "Elicitation response does not match the requested form",
       {},
@@ -93917,7 +93638,7 @@ function validateElicitationContent(encoded, requestedSchema) {
   const validated = {};
   for (const [name2, value] of Object.entries(decoded)) {
     const property = properties[name2];
-    if (!isRecord3(property)) {
+    if (!isRecord(property)) {
       throw new AcpExecutionError(
         `Elicitation field ${name2} was not requested`,
         {},
@@ -94171,8 +93892,8 @@ var init_session_interactions = __esm({
         const interactionId = `permission-${crypto.randomUUID()}`;
         const options = request.options.slice(0, 20).map((option) => ({
           kind: option.kind,
-          name: truncate2(option.name, 255),
-          optionId: truncate2(option.optionId, 255)
+          name: truncate(option.name, 255),
+          optionId: truncate(option.optionId, 255)
         }));
         if (options.length === 0) {
           throw new AcpExecutionError(
@@ -94204,9 +93925,9 @@ var init_session_interactions = __esm({
             kind: SESSION_PERMISSION_REQUESTED_KIND,
             options,
             sessionId: this.#context.sessionId(),
-            title: truncate2(title2 ?? "Permission required", 500),
-            toolCallId: truncate2(request.toolCall.toolCallId, 255),
-            toolKind: truncate2(kind ?? "other", 64)
+            title: truncate(title2 ?? "Permission required", 500),
+            toolCallId: truncate(request.toolCall.toolCallId, 255),
+            toolKind: truncate(kind ?? "other", 64)
           });
           return await pending.completion.promise;
         } finally {
@@ -94235,7 +93956,7 @@ var init_session_interactions = __esm({
         const schemaValue = Reflect.get(request, "requestedSchema");
         const requestedSchema = request.mode === "form" ? schemaValue : {};
         const elicitationIdValue = Reflect.get(request, "elicitationId");
-        const elicitationId = request.mode === "url" && typeof elicitationIdValue === "string" ? truncate2(elicitationIdValue, 255) : "";
+        const elicitationId = request.mode === "url" && typeof elicitationIdValue === "string" ? truncate(elicitationIdValue, 255) : "";
         const pending = new PendingElicitation(interactionId, elicitationId, requestedSchema);
         this.#pendingElicitations.set(interactionId, pending);
         const abort = () => {
@@ -94250,10 +93971,10 @@ var init_session_interactions = __esm({
             fields: normalizeElicitationFields(requestedSchema),
             interactionId,
             kind: SESSION_ELICITATION_REQUESTED_KIND,
-            message: truncate2(request.message, 2e3),
+            message: truncate(request.message, 2e3),
             mode: request.mode,
             sessionId: this.#context.sessionId(),
-            url: request.mode === "url" && typeof Reflect.get(request, "url") === "string" ? truncate2(readString2(Reflect.get(request, "url")), 4096) : ""
+            url: request.mode === "url" && typeof Reflect.get(request, "url") === "string" ? truncate(readString(Reflect.get(request, "url")), 4096) : ""
           });
           return await pending.completion.promise;
         } finally {
@@ -94945,7 +94666,7 @@ var init_agent_session = __esm({
        * directory observes the same title transition.
        */
       renameSession = async (title2, signal) => {
-        const normalized = truncate2(title2, 500);
+        const normalized = truncate(title2, 500);
         if (normalized.length === 0) {
           throw new AcpExecutionError("The Session title cannot be empty", {}, "invalid_session_title");
         }
@@ -95154,7 +94875,7 @@ var init_agent_session = __esm({
         }
         validatePromptContent(options, this.#capabilities);
         if (this.#sessionTitle === null || this.#sessionTitle.length === 0) {
-          this.#sessionTitle = truncate2(options.prompt, 500);
+          this.#sessionTitle = truncate(options.prompt, 500);
         }
         this.#prompted = true;
         this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
@@ -95202,7 +94923,7 @@ var init_agent_session = __esm({
                 code: failure2.code,
                 commandId: options.commandId,
                 kind: "prompt.failed",
-                message: truncate2(failure2.message, 500)
+                message: truncate(failure2.message, 500)
               },
               type: "lifecycle-metadata"
             });
@@ -95268,7 +94989,7 @@ var init_agent_session = __esm({
                 code: failure2.code,
                 commandId: options.commandId,
                 kind: "prompt.failed",
-                message: truncate2(failure2.message, 500)
+                message: truncate(failure2.message, 500)
               },
               type: "lifecycle-metadata"
             });
@@ -97445,7 +97166,8 @@ var init_session_turns = __esm({
             queued.push({
               commandId: candidate.command.commandId,
               prompt: candidate.command.prompt,
-              images: candidate.command.images
+              images: candidate.command.images,
+              resources: candidate.command.resources
             });
           }
           return { turn: turnSnapshot ?? null, queued };
@@ -99063,7 +98785,7 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
   };
   return createHash9("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,