@moxt-ai/mobius 0.0.359 → 0.0.360

package/dist/cli.js

@@ -2086,7 +2086,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@moxt-ai/mobius",
-      version: "0.0.359",
+      version: "0.0.360",
       description: "Mobius CLI for pairing and running local AI agent services.",
       type: "module",
       bin: {
@@ -82887,6 +82887,29 @@ var init_run_cleanup = __esm({
   }
 });
 
+// src/engine/acp/protocol/native-session.ts
+var path7, title, nativeSessionIdSchema, nativeSessionInfoSchema, nativeSessionPageSchema;
+var init_native_session = __esm({
+  "src/engine/acp/protocol/native-session.ts"() {
+    "use strict";
+    init_zod();
+    path7 = external_exports.string().min(1).max(2048).refine((value) => !value.includes("\0"));
+    title = external_exports.string().transform((value) => value.slice(0, 500));
+    nativeSessionIdSchema = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/);
+    nativeSessionInfoSchema = external_exports.object({
+      sessionId: nativeSessionIdSchema,
+      cwd: path7,
+      additionalDirectories: external_exports.array(path7).max(16).default([]).readonly(),
+      title: title.nullish(),
+      updatedAt: external_exports.iso.datetime({ offset: true }).nullish()
+    }).readonly();
+    nativeSessionPageSchema = external_exports.object({
+      sessions: external_exports.array(nativeSessionInfoSchema).max(500).readonly(),
+      nextCursor: external_exports.string().min(1).max(4096).nullish()
+    }).readonly();
+  }
+});
+
 // src/engine/acp/client/prompt-content.ts
 function validatePromptContent(options, capabilities) {
   if (options.images.length > 0 && !capabilities.imagePrompt) {
@@ -82949,29 +82972,6 @@ var init_prompt_content = __esm({
   }
 });
 
-// src/engine/acp/protocol/native-session.ts
-var path7, title, nativeSessionIdSchema, nativeSessionInfoSchema, nativeSessionPageSchema;
-var init_native_session = __esm({
-  "src/engine/acp/protocol/native-session.ts"() {
-    "use strict";
-    init_zod();
-    path7 = external_exports.string().min(1).max(2048).refine((value) => !value.includes("\0"));
-    title = external_exports.string().transform((value) => value.slice(0, 500));
-    nativeSessionIdSchema = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/);
-    nativeSessionInfoSchema = external_exports.object({
-      sessionId: nativeSessionIdSchema,
-      cwd: path7,
-      additionalDirectories: external_exports.array(path7).max(16).default([]).readonly(),
-      title: title.nullish(),
-      updatedAt: external_exports.iso.datetime({ offset: true }).nullish()
-    }).readonly();
-    nativeSessionPageSchema = external_exports.object({
-      sessions: external_exports.array(nativeSessionInfoSchema).max(500).readonly(),
-      nextCursor: external_exports.string().min(1).max(4096).nullish()
-    }).readonly();
-  }
-});
-
 // src/engine/acp/protocol/session-config-protocol.ts
 import { methods as methods9 } from "@agentclientprotocol/sdk";
 function isRecord6(value) {
@@ -83295,6 +83295,117 @@ var init_agent_update_stream = __esm({
   }
 });
 
+// src/engine/acp/adapter/agent-initialization.ts
+import { methods as methods10, PROTOCOL_VERSION as PROTOCOL_VERSION3 } from "@agentclientprotocol/sdk";
+async function validateAgentRuntime(agent, signal) {
+  signal.throwIfAborted();
+  const unchanged = await Promise.all(agent.runtimeExecutables.map((identity2) => revalidateExecutable(identity2)));
+  signal.throwIfAborted();
+  if (unchanged.some((result) => !result)) {
+    throw new AcpExecutionError(
+      "The local Agent runtime changed; restart Mobius before starting a new conversation",
+      {},
+      "agent_runtime_changed"
+    );
+  }
+}
+async function initializeAgentConnection(connection, agentId, verifiedVersion, signal) {
+  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(
+      methods10.agent.initialize,
+      {
+        clientCapabilities: {
+          elicitation: { form: {}, url: {} },
+          plan: {},
+          session: { compaction: {}, configOptions: { boolean: {} } }
+        },
+        clientInfo: { name: "mobius", version: "0.0.3" },
+        protocolVersion: PROTOCOL_VERSION3
+      },
+      { cancellationSignal: signal }
+    ),
+    "ACP agent exited during initialization",
+    signal
+  ).catch((cause) => {
+    signal.throwIfAborted();
+    throw new RetryableAcpInitializationError(cause);
+  });
+  if (initialized.protocolVersion !== PROTOCOL_VERSION3) {
+    throw new AcpExecutionError(
+      "ACP agent selected an unsupported protocol version",
+      {},
+      "unsupported_acp_protocol"
+    );
+  }
+  return {
+    capabilities: normalizeAcpCapabilities(initialized),
+    agentName: truncate(initialized.agentInfo?.title ?? initialized.agentInfo?.name ?? agentId, 255),
+    agentVersion: truncate(
+      verifiedVersion.length > 0 ? verifiedVersion : initialized.agentInfo?.version ?? "",
+      128
+    )
+  };
+}
+var RetryableAcpInitializationError;
+var init_agent_initialization = __esm({
+  "src/engine/acp/adapter/agent-initialization.ts"() {
+    "use strict";
+    init_executable();
+    init_value_utils();
+    init_acp_error();
+    init_session_capabilities();
+    RetryableAcpInitializationError = class extends AcpExecutionError {
+      constructor(cause) {
+        super("ACP agent initialization failed", { cause });
+        this.name = "RetryableAcpInitializationError";
+      }
+    };
+  }
+});
+
+// src/engine/acp/adapter/configuration-changes.ts
+function recordConfigurationOptions(changes, options) {
+  const modes = options.filter((option) => option.category === "mode");
+  const selection = modes.length > 0 ? { kind: "unchanged" } : changes.kind === "mode" ? { kind: "selected", modeId: changes.modeId } : changes.kind === "replacement" ? changes.selection : { kind: "unchanged" };
+  return {
+    kind: "replacement",
+    options,
+    modes: modes.length > 0 ? modes : changes.kind === "replacement" ? changes.modes : [],
+    selection
+  };
+}
+function recordConfigurationMode(changes, modeId) {
+  return changes.kind === "replacement" ? { ...changes, selection: { kind: "selected", modeId } } : { kind: "mode", modeId };
+}
+function applyConfigurationMode(options, modeId) {
+  return options.map((option) => option.category === "mode" ? { ...option, currentValue: modeId } : option);
+}
+function applyConfigurationChanges(base, changes) {
+  switch (changes.kind) {
+    case "unchanged":
+      return base;
+    case "mode":
+      return applyConfigurationMode(base, changes.modeId);
+    case "replacement": {
+      const options = changes.options.some((option) => option.category === "mode") ? changes.options : [
+        ...changes.modes.length > 0 ? changes.modes : base.filter((option) => option.category === "mode"),
+        ...changes.options
+      ].slice(0, MAXIMUM_CONFIG_OPTIONS);
+      return changes.selection.kind === "selected" ? applyConfigurationMode(options, changes.selection.modeId) : options;
+    }
+  }
+}
+var init_configuration_changes = __esm({
+  "src/engine/acp/adapter/configuration-changes.ts"() {
+    "use strict";
+    init_session_config_protocol();
+  }
+});
+
 // src/engine/acp/adapter/session-events.ts
 import { setImmediate as yieldToRuntime2 } from "node:timers/promises";
 var AdapterSessionConnection, AcpSessionConnector;
@@ -83305,7 +83416,10 @@ var init_session_events = __esm({
     init_value_utils();
     init_acp_error();
     init_agent_update_stream();
+    init_session_capabilities();
     init_session_config_protocol();
+    init_agent_initialization();
+    init_configuration_changes();
     AdapterSessionConnection = class {
       #connection;
       #onBackgroundActivity;
@@ -83314,19 +83428,24 @@ var init_session_events = __esm({
       #updates;
       #lifetime = new AbortController();
       #onClosed;
+      #agent;
+      #state = { kind: "uninitialized" };
+      #initialization = {
+        kind: "not-started"
+      };
       events;
       constructor(options, externalizer, normalizeEvent, onClosed = () => void 0) {
+        this.#agent = options.agent;
         this.#onClosed = onClosed;
         this.#onBackgroundActivity = options.onBackgroundActivity ?? (() => {
         });
-        const protocol = sessionConfigProtocolForAgent(options.agent.id);
         this.#updates = new AgentUpdateStream(async (notification) => {
           this.#lifetime.signal.throwIfAborted();
           if (notification.sessionId !== this.#updates.sessionId()) {
             throw new AcpExecutionError("ACP agent referenced an unknown session", {}, "invalid_agent_session");
           }
           const signal = AbortSignal.any([this.#lifetime.signal, AbortSignal.timeout(3e4)]);
-          const externalized = await externalizer.update(options.sessionId(), notification.update, signal);
+          const externalized = options.externalizeUpdate === void 0 ? await externalizer.update(notification.sessionId, notification.update, signal) : await options.externalizeUpdate(notification.update, signal);
           signal.throwIfAborted();
           const update = externalized.agent;
           for (const eventUpdate of externalized.events) {
@@ -83352,13 +83471,15 @@ var init_session_events = __esm({
                 };
                 break;
               case "config_option_update":
+                this.#applyConfigurationUpdate(update.configOptions);
                 event = {
                   kind: "configuration",
                   payload,
-                  configOptions: protocol.normalizeUpdate(options.configOptions(), update.configOptions)
+                  configOptions: this.snapshot().configOptions
                 };
                 break;
               case "current_mode_update":
+                this.#applyModeUpdate(update.currentModeId);
                 event = { kind: "mode", payload, modeId: update.currentModeId };
                 break;
               case "session_info_update": {
@@ -83430,10 +83551,92 @@ var init_session_events = __esm({
       get termination() {
         return this.#connection.termination;
       }
+      #ready = () => {
+        const state = this.#state;
+        if (state.kind !== "ready") {
+          throw new AcpExecutionError(
+            "The Agent session is not initialized or has closed",
+            {},
+            "invalid_agent_session"
+          );
+        }
+        return state;
+      };
+      snapshot = () => this.#ready().snapshot;
+      beginStateChange = () => {
+        const state = this.#ready();
+        if (state.operation.kind !== "idle") {
+          throw new AcpExecutionError("Another session configuration operation is running", {}, "session_busy");
+        }
+        this.#state = { ...state, operation: { kind: "pending", changes: { kind: "unchanged" } } };
+      };
+      cancelStateChange = () => {
+        if (this.#state.kind === "ready") {
+          this.#state = { ...this.#state, operation: { kind: "idle" } };
+        }
+      };
+      commitConfiguration = (options) => {
+        const state = this.#ready();
+        if (state.operation.kind !== "pending") {
+          throw new AcpExecutionError("No session configuration operation is running", {}, "invalid_agent_session");
+        }
+        const configOptions = applyConfigurationChanges(options, state.operation.changes);
+        this.#state = { ...state, snapshot: { ...state.snapshot, configOptions }, operation: { kind: "idle" } };
+        return configOptions;
+      };
+      commitLifecycle = (response) => {
+        const state = this.#ready();
+        const capabilities = restrictAcpSessionCapabilities(state.snapshot.capabilities, response);
+        this.commitConfiguration(sessionConfigProtocolForAgent(this.#agent.id).normalizeLifecycle(response));
+        this.#state = { ...this.#ready(), snapshot: { capabilities, configOptions: this.snapshot().configOptions } };
+        return this.snapshot();
+      };
+      #applyConfigurationUpdate = (value) => {
+        const state = this.#ready();
+        const protocol = sessionConfigProtocolForAgent(this.#agent.id);
+        const configOptions = protocol.normalizeUpdate(state.snapshot.configOptions, value);
+        const operation = state.operation.kind === "pending" ? {
+          kind: "pending",
+          changes: recordConfigurationOptions(state.operation.changes, protocol.normalizeUpdate([], value))
+        } : state.operation;
+        this.#state = { ...state, snapshot: { ...state.snapshot, configOptions }, operation };
+      };
+      #applyModeUpdate = (modeId) => {
+        const state = this.#ready();
+        const operation = state.operation.kind === "pending" ? { kind: "pending", changes: recordConfigurationMode(state.operation.changes, modeId) } : state.operation;
+        this.#state = {
+          ...state,
+          snapshot: {
+            ...state.snapshot,
+            configOptions: applyConfigurationMode(state.snapshot.configOptions, modeId)
+          },
+          operation
+        };
+      };
       initialize = (signal) => this.#connection.initialize(signal);
+      initializeAgent = (signal) => {
+        if (this.#initialization.kind === "not-started") {
+          this.#initialization = {
+            kind: "started",
+            result: initializeAgentConnection(this, this.#agent.id, this.#agent.agentVersion, signal).then(
+              (agent) => {
+                this.#lifetime.signal.throwIfAborted();
+                this.#state = {
+                  kind: "ready",
+                  snapshot: { capabilities: agent.capabilities, configOptions: [] },
+                  operation: { kind: "idle" }
+                };
+                return agent;
+              }
+            )
+          };
+        }
+        return this.#initialization.result;
+      };
       agentSettingsModelEffort = () => this.#connection.agentSettingsModelEffort();
       race = (operation, exitMessage, signal) => this.#connection.race(operation, exitMessage, signal);
       closeProcess = async () => {
+        this.#state = { kind: "closed" };
         this.#lifetime.abort(new DOMException("The adapter event subscription closed", "AbortError"));
         try {
           await this.#connection.closeProcess();
@@ -83481,12 +83684,12 @@ var init_session_events = __esm({
   }
 });
 
-// src/engine/acp/adapter/live-sessions.ts
+// src/engine/acp/adapter/execution-connections.ts
 import { isAbsolute as isAbsolute14, resolve as resolve14 } from "node:path";
-import { methods as methods10 } from "@agentclientprotocol/sdk";
-var absolutePathSchema, targetSchema, AcpLiveSessions;
-var init_live_sessions = __esm({
-  "src/engine/acp/adapter/live-sessions.ts"() {
+import { methods as methods11 } from "@agentclientprotocol/sdk";
+var absolutePathSchema, targetSchema, AcpExecutionConnections;
+var init_execution_connections = __esm({
+  "src/engine/acp/adapter/execution-connections.ts"() {
     "use strict";
     init_protocol();
     init_zod();
@@ -83502,7 +83705,7 @@ var init_live_sessions = __esm({
       cwd: absolutePathSchema,
       additionalDirectories: external_exports.array(absolutePathSchema)
     });
-    AcpLiveSessions = class {
+    AcpExecutionConnections = class {
       #sessions = /* @__PURE__ */ new Set();
       #externalizer;
       #normalizeEvent;
@@ -83510,16 +83713,72 @@ var init_live_sessions = __esm({
         this.#externalizer = externalizer;
         this.#normalizeEvent = normalizeEvent;
       }
-      connectSession = (scope) => {
+      acquire = (params) => {
+        params.signal.throwIfAborted();
+        const existing = [...this.#sessions].find(
+          ({ subscriber }) => subscriber.onSessionEvent === params.onSessionEvent
+        );
+        if (existing !== void 0) {
+          if (existing.scope.agent !== params.scope.agent || existing.scope.cwd !== params.scope.cwd || !arraysEqual(existing.scope.additionalDirectories, params.scope.additionalDirectories)) {
+            throw new AcpExecutionError(
+              "The agent or workspace cannot change after a conversation has started",
+              {},
+              "session_identity_mismatch"
+            );
+          }
+          return existing;
+        }
         const connection = new AdapterSessionConnection(
-          scope,
+          {
+            agent: params.scope.agent,
+            cwd: params.scope.cwd,
+            ...params.scope.externalizeUpdate === void 0 ? {} : { externalizeUpdate: params.scope.externalizeUpdate },
+            onEvent: (event) => params.onSessionEvent(connection.events.sessionId(), event),
+            ...params.onBackgroundActivity === void 0 ? {} : { onBackgroundActivity: params.onBackgroundActivity },
+            interactions: params.interactions
+          },
           this.#externalizer,
           this.#normalizeEvent,
           () => this.#sessions.delete(session)
         );
-        const session = { connection, scope };
+        const session = { connection, scope: params.scope, subscriber: params };
         this.#sessions.add(session);
-        return connection;
+        return session;
+      };
+      /** Resource scope only: the concrete adapter supplies the protocol operation. */
+      withConnection = async (params, operation) => {
+        const signal = AbortSignal.any([params.signal, AbortSignal.timeout(6e4)]);
+        signal.throwIfAborted();
+        const session = this.acquire(params);
+        const wasBound = session.connection.events.sessionId().length > 0;
+        try {
+          await session.connection.initializeAgent(signal);
+          session.connection.beginStateChange();
+          try {
+            const result = await operation(session, signal);
+            signal.throwIfAborted();
+            return result;
+          } catch (cause) {
+            session.connection.cancelStateChange();
+            throw cause;
+          }
+        } catch (cause) {
+          if (!wasBound) {
+            await session.connection.closeProcess();
+          }
+          throw cause;
+        }
+      };
+      bind = (session, nativeSessionId) => {
+        const existing = this.#find({
+          nativeSessionId,
+          cwd: session.scope.cwd,
+          additionalDirectories: session.scope.additionalDirectories
+        });
+        if (existing !== void 0 && existing !== session) {
+          throw new AcpExecutionError("Another writer is using this native session", {}, "session_busy");
+        }
+        session.connection.events.select(nativeSessionId);
       };
       #find = (target) => {
         const decoded = targetSchema.safeParse(target);
@@ -83548,12 +83807,12 @@ var init_live_sessions = __esm({
         }
         return session;
       };
-      cancel = async (target, signal) => {
+      cancel = async ({ signal, ...target }) => {
         const bounded = AbortSignal.any([signal, AbortSignal.timeout(3e4)]);
         bounded.throwIfAborted();
         const { connection } = this.#resolve(target);
         await connection.race(
-          connection.connection.agent.notify(methods10.agent.session.cancel, {
+          connection.connection.agent.notify(methods11.agent.session.cancel, {
             sessionId: connection.events.sessionId()
           }),
           "ACP agent exited while cancelling a prompt",
@@ -83561,19 +83820,19 @@ var init_live_sessions = __esm({
         );
         return "retained";
       };
-      closeSession = async (target, signal) => {
+      closeSession = async ({ signal, ...target }) => {
         const session = this.#find(target);
         if (session === void 0) {
           signal.throwIfAborted();
           return;
         }
-        const { connection, scope } = session;
+        const { connection } = session;
         try {
           signal.throwIfAborted();
-          if (scope.capabilities().closeSession) {
+          if (connection.snapshot().capabilities.closeSession) {
             try {
               await connection.connection.agent.request(
-                methods10.agent.session.close,
+                methods11.agent.session.close,
                 { sessionId: connection.events.sessionId() },
                 { cancellationSignal: AbortSignal.any([signal, AbortSignal.timeout(1e3)]) }
               );
@@ -83586,13 +83845,20 @@ var init_live_sessions = __esm({
         }
         signal.throwIfAborted();
       };
-      prompt = async (target, content, signal) => {
+      releaseSession = async ({ signal, ...target }) => {
+        const session = this.#find(target);
+        if (session !== void 0) {
+          await session.connection.closeProcess();
+        }
         signal.throwIfAborted();
-        const { connection, scope } = this.#resolve(target);
-        const prompt = buildPromptContent(content, scope.capabilities());
+      };
+      prompt = async ({ content, signal, ...target }) => {
+        signal.throwIfAborted();
+        const { connection } = this.#resolve(target);
+        const prompt = buildPromptContent(content, connection.snapshot().capabilities);
         const response = await connection.race(
           connection.connection.agent.request(
-            methods10.agent.session.prompt,
+            methods11.agent.session.prompt,
             { prompt, sessionId: target.nativeSessionId },
             { cancellationSignal: signal }
           ),
@@ -83619,10 +83885,10 @@ var init_live_sessions = __esm({
           );
         }
       };
-      steer = async (target, content, signal) => {
+      steer = async ({ content, signal, ...target }) => {
         signal.throwIfAborted();
-        const { connection, scope } = this.#resolve(target);
-        if (!scope.capabilities().steering) {
+        const { connection } = this.#resolve(target);
+        if (!connection.snapshot().capabilities.steering) {
           throw new AcpExecutionError(
             "The selected agent does not support mid-turn steering",
             {},
@@ -83634,7 +83900,7 @@ var init_live_sessions = __esm({
             "_session/steering",
             {
               _meta: { steering: { idleBehavior: "promptRequired" } },
-              prompt: buildPromptContent(content, scope.capabilities()),
+              prompt: buildPromptContent(content, connection.snapshot().capabilities),
               sessionId: target.nativeSessionId
             },
             { cancellationSignal: signal }
@@ -83664,14 +83930,14 @@ var init_live_sessions = __esm({
           "acp_invalid_steering_response"
         );
       };
-      renameSession = async (target, title2, signal) => {
+      renameSession = async ({ title: title2, signal, ...target }) => {
         signal.throwIfAborted();
-        const { connection, scope } = this.#resolve(target);
+        const { connection } = this.#resolve(target);
         const normalized = truncate(title2, 500);
         if (normalized.length === 0) {
           throw new AcpExecutionError("The Session title cannot be empty", {}, "invalid_session_title");
         }
-        if (!scope.capabilities().renameSession) {
+        if (!connection.snapshot().capabilities.renameSession) {
           return { nativeRenameApplied: false };
         }
         try {
@@ -83697,10 +83963,14 @@ var init_live_sessions = __esm({
         }
         return { nativeRenameApplied: true };
       };
-      configureSession = async (target, selection, signal) => {
+      configureSession = async ({
+        selection,
+        signal,
+        ...target
+      }) => {
         signal.throwIfAborted();
         const { connection, scope } = this.#resolve(target);
-        const current = scope.configOptions();
+        const current = connection.snapshot().configOptions;
         const existing = current.find((option) => option.id === selection.configId);
         if (existing === void 0 || existing.type !== selection.type || existing.type === "select" && existing.values.length < 2) {
           throw new AcpExecutionError(
@@ -83716,6 +83986,7 @@ var init_live_sessions = __esm({
             existing.values.map((entry) => entry.value)
           );
         }
+        connection.beginStateChange();
         try {
           const configured = await sessionConfigProtocolForAgent(scope.agent.id).configure(
             current,
@@ -83743,8 +84014,9 @@ var init_live_sessions = __esm({
             );
           }
           await connection.events.drained();
-          return configured;
+          return connection.commitConfiguration(configured);
         } catch (error62) {
+          connection.cancelStateChange();
           if (error62 instanceof SessionConfigProtocolError) {
             throw new AcpExecutionError(error62.message, { cause: error62 }, error62.code);
           }
@@ -83765,8 +84037,48 @@ var init_live_sessions = __esm({
   }
 });
 
+// src/engine/acp/adapter/lifecycle-output.ts
+function sessionWorkspace(scope) {
+  return { cwd: scope.cwd, additionalDirectories: [...scope.additionalDirectories], mcpServers: [] };
+}
+function createdNativeSessionId(response) {
+  const decoded = external_exports.object({ sessionId: nativeSessionIdSchema }).safeParse(response);
+  if (!decoded.success) {
+    throw new AcpExecutionError(
+      "The Agent returned an invalid native session",
+      { cause: decoded.error },
+      "invalid_native_session_response"
+    );
+  }
+  return decoded.data.sessionId;
+}
+async function normalizeOpenedSession(session, nativeSessionId, response, signal) {
+  await session.connection.race(
+    session.connection.events.drained(),
+    "ACP agent exited while opening a session",
+    signal
+  );
+  signal.throwIfAborted();
+  const initialized = await session.connection.initializeAgent(signal);
+  return {
+    nativeSessionId,
+    agentName: initialized.agentName,
+    agentVersion: initialized.agentVersion,
+    agentSettingsModelEffort: session.connection.agentSettingsModelEffort(),
+    ...session.connection.commitLifecycle(response)
+  };
+}
+var init_lifecycle_output = __esm({
+  "src/engine/acp/adapter/lifecycle-output.ts"() {
+    "use strict";
+    init_zod();
+    init_acp_error();
+    init_native_session();
+  }
+});
+
 // src/engine/acp/adapter/native-session-lookup.ts
-async function findNativeSession(list, cwd, nativeSessionId, budget, signal) {
+async function findNativeSession(list, query, nativeSessionId, budget) {
   const decoded = lookupSchema.safeParse({ nativeSessionId, budget });
   if (!decoded.success) {
     throw new AcpExecutionError(
@@ -83780,9 +84092,9 @@ async function findNativeSession(list, cwd, nativeSessionId, budget, signal) {
   let inspected = 0;
   const visited = /* @__PURE__ */ new Set();
   for (let pageNumber = 0; pageNumber < limits.maximumPages; pageNumber += 1) {
-    signal.throwIfAborted();
-    const page = await list(cwd, cursor, signal);
-    signal.throwIfAborted();
+    query.signal.throwIfAborted();
+    const page = await list({ query, cursor });
+    query.signal.throwIfAborted();
     inspected += page.sessions.length;
     const found = page.sessions.find((session) => session.sessionId === decoded.data.nativeSessionId);
     if (found !== void 0) {
@@ -84485,75 +84797,27 @@ var init_retained_agent_processes = __esm({
   }
 });
 
-// src/engine/acp/adapter/agent-initialization.ts
-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.runtimeExecutables.map((identity2) => revalidateExecutable(identity2)));
-  signal.throwIfAborted();
-  if (unchanged.some((result) => !result)) {
-    throw new AcpExecutionError(
-      "The local Agent runtime changed; restart Mobius before starting a new conversation",
-      {},
-      "agent_runtime_changed"
-    );
-  }
+// src/engine/acp/adapter/query-scope.ts
+function nativeSessionQueryKey(query) {
+  return queryKeySchema.parse(
+    JSON.stringify([
+      query.agent.id,
+      query.cwd,
+      query.additionalDirectories,
+      Object.entries(query.agent.environment).sort(([left], [right]) => left.localeCompare(right))
+    ])
+  );
 }
-async function initializeAgentConnection(connection, agentId, verifiedVersion, signal) {
-  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,
-      {
-        clientCapabilities: {
-          elicitation: { form: {}, url: {} },
-          plan: {},
-          session: { compaction: {}, configOptions: { boolean: {} } }
-        },
-        clientInfo: { name: "mobius", version: "0.0.3" },
-        protocolVersion: PROTOCOL_VERSION3
-      },
-      { cancellationSignal: signal }
-    ),
-    "ACP agent exited during initialization",
-    signal
-  ).catch((cause) => {
-    signal.throwIfAborted();
-    throw new RetryableAcpInitializationError(cause);
-  });
-  if (initialized.protocolVersion !== PROTOCOL_VERSION3) {
-    throw new AcpExecutionError(
-      "ACP agent selected an unsupported protocol version",
-      {},
-      "unsupported_acp_protocol"
-    );
-  }
-  return {
-    capabilities: normalizeAcpCapabilities(initialized),
-    agentName: truncate(initialized.agentInfo?.title ?? initialized.agentInfo?.name ?? agentId, 255),
-    agentVersion: truncate(
-      verifiedVersion.length > 0 ? verifiedVersion : initialized.agentInfo?.version ?? "",
-      128
-    )
-  };
+function nativeSessionPreviewKey(queryKey, nativeSessionId) {
+  return previewKeySchema.parse(JSON.stringify([queryKey, nativeSessionId]));
 }
-var RetryableAcpInitializationError;
-var init_agent_initialization = __esm({
-  "src/engine/acp/adapter/agent-initialization.ts"() {
+var queryKeySchema, previewKeySchema;
+var init_query_scope = __esm({
+  "src/engine/acp/adapter/query-scope.ts"() {
     "use strict";
-    init_executable();
-    init_value_utils();
-    init_acp_error();
-    init_session_capabilities();
-    RetryableAcpInitializationError = class extends AcpExecutionError {
-      constructor(cause) {
-        super("ACP agent initialization failed", { cause });
-        this.name = "RetryableAcpInitializationError";
-      }
-    };
+    init_zod();
+    queryKeySchema = external_exports.string().brand();
+    previewKeySchema = external_exports.string().brand();
   }
 });
 
@@ -84565,48 +84829,35 @@ var init_query_session = __esm({
     "use strict";
     init_acp_error();
     init_native_session();
-    init_session_capabilities();
     init_agent_initialization();
     AcpQuerySession = class _AcpQuerySession {
-      #cwd;
-      #sessionId;
+      #options;
       #events;
       #connection;
       #lifecycle = { kind: "open" };
-      #capabilities = unsupportedSessionCapabilities();
-      #configOptions = [];
-      constructor(agent, cwd, sessionId, events, connector) {
-        this.#cwd = cwd;
-        this.#sessionId = sessionId;
+      #eventScope = crypto.randomUUID();
+      constructor(options, events, connector) {
+        this.#options = options;
         this.#events = events;
         this.#connection = connector.connectQuerySession({
-          agent,
-          cwd,
-          sessionId: () => sessionId,
-          configOptions: () => this.#configOptions,
+          agent: options.agent,
+          cwd: options.cwd,
+          ...options.externalizeUpdate === void 0 ? {} : { externalizeUpdate: options.externalizeUpdate },
           onEvent: async (event) => {
-            this.#events.append(sessionId, { type: "acp", payload: event.payload });
-            if (event.kind === "configuration") {
-              this.#configOptions = event.configOptions;
-            }
+            this.#events.append(this.#eventScope, { type: "acp", payload: event.payload });
           }
         });
         void this.#connection.termination.then(() => {
           this.#lifecycle = { kind: "terminated" };
         });
       }
-      static start = async (agent, cwd, sessionId, events, connector, signal) => {
+      static start = async (options, events, connector) => {
+        const { agent, signal } = options;
         for (let attempt = 1; attempt <= 2; attempt += 1) {
           await validateAgentRuntime(agent, signal);
-          const runtime = new _AcpQuerySession(agent, cwd, sessionId, events, connector);
+          const runtime = new _AcpQuerySession(options, events, connector);
           try {
-            const initialized = await initializeAgentConnection(
-              runtime.#connection,
-              agent.id,
-              agent.agentVersion,
-              signal
-            );
-            runtime.#capabilities = initialized.capabilities;
+            await runtime.#connection.initializeAgent(options.signal);
             return runtime;
           } catch (error62) {
             await runtime.closeProcess();
@@ -84623,7 +84874,7 @@ var init_query_session = __esm({
         }
         throw new AcpExecutionError("ACP agent initialization failed");
       };
-      capabilities = () => this.#capabilities;
+      capabilities = () => this.#connection.snapshot().capabilities;
       hasTerminated = () => {
         switch (this.#lifecycle.kind) {
           case "open":
@@ -84637,7 +84888,7 @@ var init_query_session = __esm({
         }
       };
       listNativeSessions = async (cursor, signal) => {
-        if (!this.#capabilities.listSessions) {
+        if (!this.capabilities().listSessions) {
           throw new AcpExecutionError(
             "This Agent does not support native session listing",
             {},
@@ -84661,22 +84912,24 @@ var init_query_session = __esm({
         }
         return decoded.data;
       };
-      previewEvents = async (nativeSessionId, eventLimit, additionalDirectories, signal) => {
-        if (!this.#capabilities.loadSession) {
+      previewEvents = async (nativeSessionId, eventLimit, signal) => {
+        if (!this.capabilities().loadSession) {
           throw new AcpExecutionError(
             "This Agent restores context but does not provide message history.",
             {},
             "native_history_unsupported"
           );
         }
-        this.#events.reset(this.#sessionId);
+        this.#eventScope = nativeSessionId;
+        this.#events.reset(nativeSessionId);
         this.#connection.events.select(nativeSessionId);
-        await this.#connection.race(
+        this.#connection.beginStateChange();
+        const response = await this.#connection.race(
           this.#connection.connection.agent.request(
             methods12.agent.session.load,
             {
-              additionalDirectories: [...additionalDirectories],
-              cwd: this.#cwd,
+              additionalDirectories: [...this.#options.additionalDirectories],
+              cwd: this.#options.cwd,
               mcpServers: [],
               sessionId: nativeSessionId
             },
@@ -84687,16 +84940,16 @@ var init_query_session = __esm({
         );
         await this.#connection.events.drained();
         signal.throwIfAborted();
-        return this.#events.page(this.#sessionId, eventLimit, null);
+        this.#connection.commitLifecycle(response);
+        return this.#events.page(nativeSessionId, eventLimit, null);
       };
       closeProcess = async () => await this.#connection.closeProcess();
-      discardEvents = () => this.#events.remove(this.#sessionId);
+      discardEvents = () => this.#events.remove(this.#eventScope);
     };
   }
 });
 
 // src/engine/acp/adapter/query-processes.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
 var AgentQueryProcesses;
 var init_query_processes = __esm({
   "src/engine/acp/adapter/query-processes.ts"() {
@@ -84704,6 +84957,7 @@ var init_query_processes = __esm({
     init_session_event_store();
     init_operation_drain();
     init_retained_agent_processes();
+    init_query_scope();
     init_query_session();
     AgentQueryProcesses = class {
       #eventPreviewsBySession = /* @__PURE__ */ new Map();
@@ -84720,45 +84974,46 @@ var init_query_processes = __esm({
       refreshAgent = (agent) => {
         this.#agent = agent;
       };
-      retire = async (readers, cwd, runtime) => {
-        readers.detach(cwd, runtime);
+      retire = async (readers, key, runtime) => {
+        readers.detach(key, runtime);
         try {
           await this.#processes.retire(runtime, () => runtime.closeProcess());
         } finally {
           runtime.discardEvents();
         }
       };
-      async #ensure(agent, readers, cwd, signal) {
-        signal.throwIfAborted();
-        const pending = readers.pending(cwd);
+      async #ensure(readers, query) {
+        query.signal.throwIfAborted();
+        const key = nativeSessionQueryKey(query);
+        const pending = readers.pending(key);
         if (pending !== void 0) {
-          return await waitForSharedOperation(pending, signal);
+          return await waitForSharedOperation(pending, query.signal);
         }
-        const existing = readers.get(cwd);
+        const existing = readers.get(key);
         if (existing !== void 0 && !existing.hasTerminated()) {
-          readers.touch(cwd, existing);
+          readers.touch(key, existing);
           return existing;
         }
-        return await readers.prepare(cwd, async () => {
+        return await readers.prepare(key, async () => {
           if (existing !== void 0) {
-            await this.retire(readers, cwd, existing);
+            await this.retire(readers, key, existing);
           }
-          const readerId = randomUUID14();
           const runtime = await this.#processes.startRetained(
-            signal,
-            () => AcpQuerySession.start(agent, cwd, readerId, this.#store, this.#connector, signal),
+            query.signal,
+            () => AcpQuerySession.start(query, this.#store, this.#connector),
             {
-              isBusy: () => readers.isBusy(cwd),
-              retire: (runtime2) => this.retire(readers, cwd, runtime2),
-              retireIdle: (runtime2) => this.retire(readers, cwd, runtime2)
+              isBusy: () => readers.isBusy(key),
+              retire: (runtime2) => this.retire(readers, key, runtime2),
+              retireIdle: (runtime2) => this.retire(readers, key, runtime2)
             }
           );
-          readers.retain(cwd, runtime);
+          readers.retain(key, runtime);
           return runtime;
         });
       }
-      #use = async (cwd, signal, operation) => {
+      #use = async (query, operation) => {
         const agent = this.#agent;
+        const scoped = { ...query, agent };
         let readers = this.#processesByAgent.get(agent);
         if (readers === void 0) {
           readers = new RetainedAgentProcesses({
@@ -84768,35 +85023,38 @@ var init_query_processes = __esm({
           this.#processesByAgent.set(agent, readers);
         }
         const current = readers;
-        return await current.use(cwd, async () => await operation(await this.#ensure(agent, current, cwd, signal)));
+        return await current.use(
+          nativeSessionQueryKey(scoped),
+          async () => await operation(await this.#ensure(current, scoped))
+        );
       };
-      capabilities = async (cwd, signal) => await this.#use(cwd, signal, async (runtime) => runtime.capabilities());
-      listNativeSessions = async (cwd, cursor, signal) => await this.#use(cwd, signal, async (runtime) => await runtime.listNativeSessions(cursor, signal));
-      previewSessionEvents = async (cwd, additionalDirectories, request, signal) => {
-        signal.throwIfAborted();
-        const agent = this.#agent;
-        const { nativeSessionId, eventLimit, cursor, sessionId } = request;
+      capabilities = async (query) => await this.#use(query, async (runtime) => runtime.capabilities());
+      listNativeSessions = async (query, cursor) => await this.#use(query, async (runtime) => await runtime.listNativeSessions(cursor, query.signal));
+      previewSessionEvents = async (query, request) => {
+        query.signal.throwIfAborted();
+        const scoped = { ...query, agent: this.#agent };
+        const { nativeSessionId, eventLimit, cursor } = request;
+        const key = nativeSessionPreviewKey(nativeSessionQueryKey(scoped), nativeSessionId);
         if (cursor !== null) {
-          const preview = this.#eventPreviewsBySession.get(sessionId);
+          const preview = this.#eventPreviewsBySession.get(key);
           if (preview === void 0 || preview.nativeSessionId !== nativeSessionId) {
             throw new Error("The native event cursor is invalid");
           }
-          return preview.store.page(sessionId, eventLimit, cursor);
+          return preview.store.page(nativeSessionId, eventLimit, cursor);
         }
         const store = new MemorySessionEventStore();
-        const previous = this.#eventPreviewsBySession.get(sessionId);
-        previous?.store.close();
-        this.#eventPreviewsBySession.set(sessionId, { nativeSessionId, store });
+        this.#eventPreviewsBySession.get(key)?.store.close();
+        this.#eventPreviewsBySession.set(key, { nativeSessionId, store });
         try {
           return await this.#processes.runTransient(
-            signal,
-            async () => await AcpQuerySession.start(agent, cwd, sessionId, store, this.#connector, signal),
-            async (runtime) => await runtime.previewEvents(nativeSessionId, eventLimit, additionalDirectories, signal),
-            async (runtime) => await runtime.closeProcess()
+            query.signal,
+            () => AcpQuerySession.start(scoped, store, this.#connector),
+            (runtime) => runtime.previewEvents(nativeSessionId, eventLimit, query.signal),
+            (runtime) => runtime.closeProcess()
           );
         } catch (error62) {
-          if (this.#eventPreviewsBySession.get(sessionId)?.store === store) {
-            this.#eventPreviewsBySession.delete(sessionId);
+          if (this.#eventPreviewsBySession.get(key)?.store === store) {
+            this.#eventPreviewsBySession.delete(key);
           }
           store.close();
           throw error62;
@@ -84805,7 +85063,7 @@ var init_query_processes = __esm({
       close = async () => {
         await Promise.all(
           [...this.#processesByAgent.values()].flatMap(
-            (readers) => readers.entries().map(async ([cwd, runtime]) => await this.retire(readers, cwd, runtime))
+            (readers) => readers.entries().map(async ([key, runtime]) => await this.retire(readers, key, runtime))
           )
         );
         this.#processesByAgent.clear();
@@ -84820,39 +85078,104 @@ var init_query_processes = __esm({
 });
 
 // src/engine/acp/adapter/claude/adapter.ts
+import { methods as methods13 } from "@agentclientprotocol/sdk";
 var ClaudeAdapter;
 var init_adapter = __esm({
   "src/engine/acp/adapter/claude/adapter.ts"() {
     "use strict";
     init_run_cleanup();
-    init_live_sessions();
+    init_native_session();
+    init_execution_connections();
+    init_lifecycle_output();
     init_native_session_lookup();
     init_query_processes();
     init_session_events();
     ClaudeAdapter = class {
       #queryProcesses;
       #connector;
-      #liveSessions;
+      #executionConnections;
       constructor(agent, dependencies) {
         this.#connector = new AcpSessionConnector(dependencies.contentExternalizer);
-        this.#liveSessions = new AcpLiveSessions(dependencies.contentExternalizer);
+        this.#executionConnections = new AcpExecutionConnections(dependencies.contentExternalizer);
         this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
       }
       refreshAgent = (agent) => this.#queryProcesses.refreshAgent(agent);
-      getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
-      connectSession = (options) => this.#liveSessions.connectSession(options);
-      cancel = (...args) => this.#liveSessions.cancel(...args);
-      closeSession = (...args) => this.#liveSessions.closeSession(...args);
-      prompt = (...args) => this.#liveSessions.prompt(...args);
-      steer = (...args) => this.#liveSessions.steer(...args);
-      renameSession = (...args) => this.#liveSessions.renameSession(...args);
-      configureSession = (...args) => this.#liveSessions.configureSession(...args);
-      listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
-      findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
-      readSessionHistory = (cwd, additionalDirectories, request, signal) => this.#queryProcesses.previewSessionEvents(cwd, additionalDirectories, request, signal);
+      getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+      createSession = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const response = await connection.race(
+          connection.connection.agent.request(methods13.agent.session.new, sessionWorkspace(params.scope), {
+            cancellationSignal: signal
+          }),
+          "ACP agent exited while starting a session",
+          signal
+        );
+        const nativeSessionId = createdNativeSessionId(response);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      forkSession = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods13.agent.session.fork,
+            {
+              ...sessionWorkspace(params.scope),
+              sessionId: nativeSessionIdSchema.parse(params.sourceNativeSessionId)
+            },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while forking a session",
+          signal
+        );
+        const nativeSessionId = createdNativeSessionId(response);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      openSession = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const nativeSessionId = nativeSessionIdSchema.parse(params.nativeSessionId);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods13.agent.session.resume,
+            { ...sessionWorkspace(params.scope), sessionId: nativeSessionId },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while resuming a session",
+          signal
+        );
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      openSessionWithReplay = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const nativeSessionId = nativeSessionIdSchema.parse(params.nativeSessionId);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods13.agent.session.load,
+            { ...sessionWorkspace(params.scope), sessionId: nativeSessionId },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while loading a session",
+          signal
+        );
+        await connection.race(connection.events.drained(), "ACP agent exited while loading a session", signal);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      cancel = (...args) => this.#executionConnections.cancel(...args);
+      closeSession = (...args) => this.#executionConnections.closeSession(...args);
+      releaseSession = (params) => this.#executionConnections.releaseSession(params);
+      prompt = (...args) => this.#executionConnections.prompt(...args);
+      steer = (...args) => this.#executionConnections.steer(...args);
+      renameSession = (...args) => this.#executionConnections.renameSession(...args);
+      configureSession = (...args) => this.#executionConnections.configureSession(...args);
+      listSessions = async ({ query, cursor }) => await this.#queryProcesses.listNativeSessions(query, cursor);
+      findSession = ({ query, nativeSessionId, budget }) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
+      readSessionHistory = async ({ query, request }) => await this.#queryProcesses.previewSessionEvents(query, request);
       close = async () => await runCleanup(
         () => this.#queryProcesses.close(),
-        () => this.#liveSessions.close()
+        () => this.#executionConnections.close()
       );
     };
   }
@@ -90768,6 +91091,7 @@ var init_tool_event = __esm({
 
 // src/engine/acp/adapter/codex/adapter.ts
 import { createHash as createHash5 } from "node:crypto";
+import { methods as methods14 } from "@agentclientprotocol/sdk";
 var CodexAdapter;
 var init_adapter2 = __esm({
   "src/engine/acp/adapter/codex/adapter.ts"() {
@@ -90779,7 +91103,8 @@ var init_adapter2 = __esm({
     init_app_server_client();
     init_history2();
     init_native_session();
-    init_live_sessions();
+    init_execution_connections();
+    init_lifecycle_output();
     init_native_session_lookup();
     init_preview_event_cache();
     init_query_processes();
@@ -90789,7 +91114,7 @@ var init_adapter2 = __esm({
       #agent;
       #queryProcesses;
       #connector;
-      #liveSessions;
+      #executionConnections;
       #dependencies;
       #contentExternalizer;
       #previewCache = null;
@@ -90805,37 +91130,112 @@ var init_adapter2 = __esm({
           }
         };
         this.#connector = new AcpSessionConnector(this.#contentExternalizer, fitCodexToolEvent);
-        this.#liveSessions = new AcpLiveSessions(this.#contentExternalizer, fitCodexToolEvent);
+        this.#executionConnections = new AcpExecutionConnections(this.#contentExternalizer, fitCodexToolEvent);
         this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
       }
       refreshAgent = (agent) => {
         this.#agent = agent;
         this.#queryProcesses.refreshAgent(agent);
       };
-      getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
-      connectSession = (options) => this.#liveSessions.connectSession(options);
-      cancel = async (target, signal) => {
-        await this.#liveSessions.closeSession(target, signal);
+      getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+      #executionParams = (params) => {
+        const externalize = params.scope.externalizeUpdate;
+        return externalize === void 0 ? params : {
+          ...params,
+          scope: {
+            ...params.scope,
+            externalizeUpdate: (update, signal) => externalize(prepareCodexToolUpdate(update), signal)
+          }
+        };
+      };
+      createSession = (params) => this.#executionConnections.withConnection(this.#executionParams(params), async (execution, signal) => {
+        const { connection } = execution;
+        const response = await connection.race(
+          connection.connection.agent.request(methods14.agent.session.new, sessionWorkspace(params.scope), {
+            cancellationSignal: signal
+          }),
+          "ACP agent exited while starting a session",
+          signal
+        );
+        const nativeSessionId = createdNativeSessionId(response);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      forkSession = (params) => this.#executionConnections.withConnection(this.#executionParams(params), async (execution, signal) => {
+        const { connection } = execution;
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods14.agent.session.fork,
+            {
+              ...sessionWorkspace(params.scope),
+              sessionId: nativeSessionIdSchema.parse(params.sourceNativeSessionId)
+            },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while forking a session",
+          signal
+        );
+        const nativeSessionId = createdNativeSessionId(response);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      openSession = (params) => this.#executionConnections.withConnection(this.#executionParams(params), async (execution, signal) => {
+        const { connection } = execution;
+        const nativeSessionId = nativeSessionIdSchema.parse(params.nativeSessionId);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods14.agent.session.resume,
+            { ...sessionWorkspace(params.scope), sessionId: nativeSessionId },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while resuming a session",
+          signal
+        );
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      openSessionWithReplay = (params) => this.#executionConnections.withConnection(this.#executionParams(params), async (execution, signal) => {
+        const { connection } = execution;
+        const nativeSessionId = nativeSessionIdSchema.parse(params.nativeSessionId);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods14.agent.session.load,
+            { ...sessionWorkspace(params.scope), sessionId: nativeSessionId },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while loading a session",
+          signal
+        );
+        await connection.race(connection.events.drained(), "ACP agent exited while loading a session", signal);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      cancel = async (params) => {
+        await this.#executionConnections.closeSession(params);
         return "closed";
       };
-      closeSession = (...args) => this.#liveSessions.closeSession(...args);
-      prompt = (...args) => this.#liveSessions.prompt(...args);
-      steer = (...args) => this.#liveSessions.steer(...args);
-      renameSession = (...args) => this.#liveSessions.renameSession(...args);
-      configureSession = (...args) => this.#liveSessions.configureSession(...args);
-      listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
-      findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
+      closeSession = (...args) => this.#executionConnections.closeSession(...args);
+      releaseSession = (params) => this.#executionConnections.releaseSession(params);
+      prompt = (...args) => this.#executionConnections.prompt(...args);
+      steer = (...args) => this.#executionConnections.steer(...args);
+      renameSession = (...args) => this.#executionConnections.renameSession(...args);
+      configureSession = (...args) => this.#executionConnections.configureSession(...args);
+      listSessions = async ({ query, cursor }) => await this.#queryProcesses.listNativeSessions(query, cursor);
+      findSession = ({ query, nativeSessionId, budget }) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
       close = async () => {
         await runCleanup(
           () => this.#queryProcesses.close(),
-          () => this.#liveSessions.close(),
+          () => this.#executionConnections.close(),
           () => this.#previewCache?.close()
         );
       };
-      readSessionHistory = async (cwd, _additionalDirectories, request, cancellation) => {
-        const agent = this.#agent;
-        const signal = AbortSignal.any([cancellation, AbortSignal.timeout(6e4)]);
-        const { sessionId } = request;
+      readSessionHistory = async ({
+        query,
+        request
+      }) => {
+        const { agent, cwd } = query;
+        const signal = AbortSignal.any([query.signal, AbortSignal.timeout(6e4)]);
+        const sessionId = request.nativeSessionId;
         signal.throwIfAborted();
         nativeSessionIdSchema.parse(request.nativeSessionId);
         if (agent.id !== "codex") {
@@ -90886,7 +91286,7 @@ var init_adapter2 = __esm({
               client2,
               request.nativeSessionId,
               async (update) => {
-                const externalized = await this.#contentExternalizer.update(sessionId, update, signal);
+                const externalized = query.externalizeUpdate === void 0 ? await this.#contentExternalizer.update(sessionId, update, signal) : await query.externalizeUpdate(prepareCodexToolUpdate(update), signal);
                 for (const event of externalized.events) {
                   events.push({
                     type: "acp",
@@ -90908,39 +91308,104 @@ var init_adapter2 = __esm({
 });
 
 // src/engine/acp/adapter/pi/adapter.ts
+import { methods as methods15 } from "@agentclientprotocol/sdk";
 var PiAdapter;
 var init_adapter3 = __esm({
   "src/engine/acp/adapter/pi/adapter.ts"() {
     "use strict";
     init_run_cleanup();
-    init_live_sessions();
+    init_native_session();
+    init_execution_connections();
+    init_lifecycle_output();
     init_native_session_lookup();
     init_query_processes();
     init_session_events();
     PiAdapter = class {
       #queryProcesses;
       #connector;
-      #liveSessions;
+      #executionConnections;
       constructor(agent, dependencies) {
         this.#connector = new AcpSessionConnector(dependencies.contentExternalizer);
-        this.#liveSessions = new AcpLiveSessions(dependencies.contentExternalizer);
+        this.#executionConnections = new AcpExecutionConnections(dependencies.contentExternalizer);
         this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
       }
       refreshAgent = (agent) => this.#queryProcesses.refreshAgent(agent);
-      getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
-      connectSession = (options) => this.#liveSessions.connectSession(options);
-      cancel = (...args) => this.#liveSessions.cancel(...args);
-      closeSession = (...args) => this.#liveSessions.closeSession(...args);
-      prompt = (...args) => this.#liveSessions.prompt(...args);
-      steer = (...args) => this.#liveSessions.steer(...args);
-      renameSession = (...args) => this.#liveSessions.renameSession(...args);
-      configureSession = (...args) => this.#liveSessions.configureSession(...args);
-      listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
-      findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
-      readSessionHistory = (cwd, additionalDirectories, request, signal) => this.#queryProcesses.previewSessionEvents(cwd, additionalDirectories, request, signal);
+      getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+      createSession = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const response = await connection.race(
+          connection.connection.agent.request(methods15.agent.session.new, sessionWorkspace(params.scope), {
+            cancellationSignal: signal
+          }),
+          "ACP agent exited while starting a session",
+          signal
+        );
+        const nativeSessionId = createdNativeSessionId(response);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      forkSession = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods15.agent.session.fork,
+            {
+              ...sessionWorkspace(params.scope),
+              sessionId: nativeSessionIdSchema.parse(params.sourceNativeSessionId)
+            },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while forking a session",
+          signal
+        );
+        const nativeSessionId = createdNativeSessionId(response);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      openSession = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const nativeSessionId = nativeSessionIdSchema.parse(params.nativeSessionId);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods15.agent.session.resume,
+            { ...sessionWorkspace(params.scope), sessionId: nativeSessionId },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while resuming a session",
+          signal
+        );
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      openSessionWithReplay = (params) => this.#executionConnections.withConnection(params, async (execution, signal) => {
+        const { connection } = execution;
+        const nativeSessionId = nativeSessionIdSchema.parse(params.nativeSessionId);
+        this.#executionConnections.bind(execution, nativeSessionId);
+        const response = await connection.race(
+          connection.connection.agent.request(
+            methods15.agent.session.load,
+            { ...sessionWorkspace(params.scope), sessionId: nativeSessionId },
+            { cancellationSignal: signal }
+          ),
+          "ACP agent exited while loading a session",
+          signal
+        );
+        await connection.race(connection.events.drained(), "ACP agent exited while loading a session", signal);
+        return normalizeOpenedSession(execution, nativeSessionId, response, signal);
+      });
+      cancel = (...args) => this.#executionConnections.cancel(...args);
+      closeSession = (...args) => this.#executionConnections.closeSession(...args);
+      releaseSession = (params) => this.#executionConnections.releaseSession(params);
+      prompt = (...args) => this.#executionConnections.prompt(...args);
+      steer = (...args) => this.#executionConnections.steer(...args);
+      renameSession = (...args) => this.#executionConnections.renameSession(...args);
+      configureSession = (...args) => this.#executionConnections.configureSession(...args);
+      listSessions = async ({ query, cursor }) => await this.#queryProcesses.listNativeSessions(query, cursor);
+      findSession = ({ query, nativeSessionId, budget }) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
+      readSessionHistory = async ({ query, request }) => await this.#queryProcesses.previewSessionEvents(query, request);
       close = async () => await runCleanup(
         () => this.#queryProcesses.close(),
-        () => this.#liveSessions.close()
+        () => this.#executionConnections.close()
       );
     };
   }
@@ -91258,10 +91723,12 @@ var init_content_externalizer = __esm({
 
 // src/engine/agent/runtime-agents.ts
 function createRuntimeAdapterRegistry(adapters, processes, externalize, linkedResources) {
-  return new AdapterRegistry(adapters, {
-    processes,
-    contentExternalizer: new AcpContentExternalizer(externalize, linkedResources)
-  });
+  const contentExternalizer = new AcpContentExternalizer(externalize, linkedResources);
+  const externalizeSessionUpdate = (sessionId, update, signal) => contentExternalizer.update(sessionId, update, signal);
+  return {
+    adapters: new AdapterRegistry(adapters, { processes, contentExternalizer }),
+    externalizeSessionUpdate
+  };
 }
 var RuntimeAgentDependencies;
 var init_runtime_agents = __esm({
@@ -93525,7 +93992,6 @@ var init_agent_turn = __esm({
 });
 
 // src/engine/session/live/session-restore.ts
-import { methods as methods13 } from "@agentclientprotocol/sdk";
 function hasMethodNotFoundCode(cause) {
   const visited = /* @__PURE__ */ new Set();
   let current = cause;
@@ -93543,7 +94009,6 @@ async function restoreSession(session, signal, recovery, origin) {
   if (origin !== void 0) {
     session.setSessionTitle(origin.title);
   }
-  await session.initializeAgent(signal);
   let stored = session.metrics.measureSync(
     "session-state-read",
     () => origin?.kind === "import" ? new FoundStoredSession(
@@ -93563,7 +94028,7 @@ async function restoreSession(session, signal, recovery, origin) {
     stored = session.metrics.measureSync("session-state-read", () => session.store.read(session.sessionId));
   }
   const forkSource = origin?.kind === "fork" ? session.store.findNative(session.agentId, origin.nativeSessionId)[0] : void 0;
-  let lifecycleResponse2;
+  let opened;
   if (origin?.kind === "fork") {
     if (!session.capabilities.unstableForkSession) {
       throw new AcpExecutionError(
@@ -93581,22 +94046,9 @@ async function restoreSession(session, signal, recovery, origin) {
     }
     const forked = await session.metrics.measure(
       "session-fork",
-      async () => await session.race(
-        session.agentRequest(
-          methods13.agent.session.fork,
-          {
-            sessionId: nativeSessionIdSchema.parse(origin.nativeSessionId),
-            cwd: session.cwd,
-            additionalDirectories: [...session.additionalDirectories],
-            mcpServers: []
-          },
-          { cancellationSignal: signal }
-        ),
-        "ACP agent exited while forking a session",
-        signal
-      )
+      async () => await session.forkSession(origin.nativeSessionId, signal)
     );
-    session.selectNativeSession(forked.sessionId);
+    session.selectNativeSession(forked.nativeSessionId);
     if (session.nativeSessionId() === origin.nativeSessionId || session.store.findNative(session.agentId, session.nativeSessionId()).length > 0) {
       throw new AcpExecutionError(
         "The Agent did not create an independent fork",
@@ -93609,7 +94061,7 @@ async function restoreSession(session, signal, recovery, origin) {
     if (recovery.kind === "execution-only") {
       session.startExecutionOnlyCapture();
     }
-    lifecycleResponse2 = forked;
+    opened = forked;
   } else if (stored instanceof FoundStoredSession && stored.session.agentId === session.agentId && stored.session.cwd === session.cwd && arraysEqual(stored.session.additionalDirectories, session.additionalDirectories)) {
     session.selectNativeSession(stored.session.nativeSessionId);
     session.setPrompted(stored.session.prompted);
@@ -93623,29 +94075,13 @@ async function restoreSession(session, signal, recovery, origin) {
           "native_history_unsupported"
         );
       }
-      lifecycleResponse2 = await session.metrics.measure(
+      opened = await session.metrics.measure(
         "session-load",
-        async () => (await session.loadSession(signal, "ACP agent exited while loading a session")).response
+        async () => await session.openSessionWithReplay(signal)
       );
     } else if (recovery.kind === "execution-only") {
       try {
-        lifecycleResponse2 = await session.metrics.measure(
-          "session-resume",
-          async () => await session.race(
-            session.agentRequest(
-              methods13.agent.session.resume,
-              {
-                additionalDirectories: [...session.additionalDirectories],
-                cwd: session.cwd,
-                mcpServers: [],
-                sessionId: session.nativeSessionId()
-              },
-              { cancellationSignal: signal }
-            ),
-            "ACP agent exited while resuming a session",
-            signal
-          )
-        );
+        opened = await session.metrics.measure("session-resume", async () => await session.openSession(signal));
       } catch (cause) {
         signal.throwIfAborted();
         if (cause instanceof AcpExecutionError && !hasMethodNotFoundCode(cause)) {
@@ -93659,27 +94095,11 @@ async function restoreSession(session, signal, recovery, origin) {
       }
       session.startExecutionOnlyCapture();
     } else if (session.capabilities.resumeSession) {
-      lifecycleResponse2 = await session.metrics.measure(
-        "session-resume",
-        async () => await session.race(
-          session.agentRequest(
-            methods13.agent.session.resume,
-            {
-              additionalDirectories: [...session.additionalDirectories],
-              cwd: session.cwd,
-              mcpServers: [],
-              sessionId: session.nativeSessionId()
-            },
-            { cancellationSignal: signal }
-          ),
-          "ACP agent exited while resuming a session",
-          signal
-        )
-      );
+      opened = await session.metrics.measure("session-resume", async () => await session.openSession(signal));
     } else if (session.capabilities.loadSession) {
-      lifecycleResponse2 = await session.metrics.measure(
+      opened = await session.metrics.measure(
         "session-load",
-        async () => (await session.loadSession(signal, "ACP agent exited while loading a session")).response
+        async () => await session.openSessionWithReplay(signal)
       );
     } else {
       throw new AcpExecutionError(
@@ -93699,37 +94119,20 @@ async function restoreSession(session, signal, recovery, origin) {
       }
       session.store.remove(session.sessionId);
     }
-    const created = await session.metrics.measure(
-      "session-new",
-      async () => await session.race(
-        session.agentRequest(
-          methods13.agent.session.new,
-          {
-            additionalDirectories: [...session.additionalDirectories],
-            cwd: session.cwd,
-            mcpServers: []
-          },
-          { cancellationSignal: signal }
-        ),
-        "ACP agent exited while starting a session",
-        signal
-      )
-    );
-    session.selectNativeSession(created.sessionId);
+    const created = await session.metrics.measure("session-new", async () => await session.createSession(signal));
+    session.selectNativeSession(created.nativeSessionId);
     session.setNativeHistoryOwnership({ kind: "fresh-session" });
     if (recovery.kind === "execution-only") {
       session.startExecutionOnlyCapture();
     }
-    lifecycleResponse2 = created;
+    opened = created;
   }
-  session.restrictSessionCapabilities(lifecycleResponse2);
-  session.setConfigOptions(session.sessionConfigProtocol.normalizeLifecycle(lifecycleResponse2));
+  session.applySessionOpened(opened);
   if (forkSource !== void 0) {
     await session.restoreStoredConfigurations(forkSource, signal, "fork");
   } else if (stored instanceof FoundStoredSession && session.restored) {
     await session.restoreStoredConfigurations(stored.session, signal);
   }
-  await session.drained();
   signal.throwIfAborted();
   session.writeStoredSession(
     stored instanceof FoundStoredSession && session.restored ? stored.session.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
@@ -93746,7 +94149,6 @@ var init_session_restore = __esm({
 });
 
 // src/engine/session/live/agent-session.ts
-import { methods as methods14 } from "@agentclientprotocol/sdk";
 var AgentSession;
 var init_agent_session = __esm({
   "src/engine/session/live/agent-session.ts"() {
@@ -93757,7 +94159,6 @@ var init_agent_session = __esm({
     init_agent_initialization();
     init_prompt_content();
     init_session_capabilities();
-    init_session_config_protocol();
     init_serial_task_queue();
     init_value_utils();
     init_session_api();
@@ -93793,14 +94194,20 @@ var init_agent_session = __esm({
       get sessionId() {
         return this.#mobiusSessionId;
       }
-      get sessionConfigProtocol() {
-        return this.#sessionConfigProtocol;
-      }
       get store() {
         return this.#store;
       }
-      hasBackgroundActivity = () => this.#connection.hasBackgroundActivity();
-      #connection;
+      hasBackgroundActivity = () => this.#backgroundActivity !== "none";
+      #backgroundActivity = "none";
+      #modelEffort = null;
+      #scope;
+      #subscriber;
+      #nativeIdentity = {
+        kind: "unbound"
+      };
+      get #nativeSessionId() {
+        return this.#nativeIdentity.kind === "bound" ? this.#nativeIdentity.nativeSessionId : "";
+      }
       #adapter;
       #additionalDirectories;
       #agentId;
@@ -93809,11 +94216,8 @@ var init_agent_session = __esm({
       #getObserver;
       #interactions;
       #mobiusSessionId;
-      #updates;
       #metrics;
-      #sessionConfigProtocol;
       #store;
-      #verifiedAgentVersion;
       #agentName = "";
       #agentVersion = "";
       #capabilities = unsupportedSessionCapabilities();
@@ -93829,7 +94233,7 @@ var init_agent_session = __esm({
       #sessionTitle = null;
       #sessionUpdatedAt = "";
       #turn = new IdleAgentTurn();
-      constructor(agent, cwd, additionalDirectories, mobiusSessionId, getObserver, store, metrics, adapter) {
+      constructor(agent, cwd, additionalDirectories, mobiusSessionId, getObserver, store, metrics, adapter, externalize) {
         this.#additionalDirectories = [...additionalDirectories];
         this.#adapter = adapter;
         this.#agentId = agent.id;
@@ -93838,9 +94242,7 @@ var init_agent_session = __esm({
         this.#environment = agent.environment;
         this.#mobiusSessionId = mobiusSessionId;
         this.#metrics = metrics;
-        this.#sessionConfigProtocol = sessionConfigProtocolForAgent(agent.id);
         this.#store = store;
-        this.#verifiedAgentVersion = agent.agentVersion;
         this.#getObserver = getObserver;
         this.#interactions = new SessionInteractions({
           cwd: () => this.#cwd,
@@ -93851,25 +94253,31 @@ var init_agent_session = __esm({
           observer: getObserver,
           recordSessionEvent: this.recordLifecycleEvent
         });
-        const scope = {
+        this.#scope = {
           agent,
           cwd,
-          sessionId: () => this.#mobiusSessionId,
-          configOptions: () => this.#configOptions,
-          onEvent: this.#processEvent
-        };
-        this.#connection = this.#adapter.connectSession({
-          ...scope,
           additionalDirectories: this.#additionalDirectories,
-          capabilities: () => this.#capabilities,
-          onBackgroundActivity: (activity) => this.#getObserver().onBackgroundActivity?.(this, activity),
+          ...externalize === void 0 ? {} : { externalizeUpdate: (update, signal) => externalize(this.#mobiusSessionId, update, signal) }
+        };
+        this.#subscriber = {
+          onSessionEvent: async (nativeSessionId, event) => {
+            if (this.#nativeSessionId.length === 0) {
+              this.selectNativeSession(nativeSessionId);
+            } else {
+              this.assertNativeSession(nativeSessionId);
+            }
+            await this.#processEvent(event);
+          },
+          onBackgroundActivity: (activity) => {
+            this.#backgroundActivity = activity;
+            this.#getObserver().onBackgroundActivity?.(this, activity);
+          },
           interactions: {
             onPermission: this.#interactions.onPermission,
             onElicitation: this.#interactions.onElicitation,
             onElicitationComplete: this.#interactions.onElicitationComplete
           }
-        });
-        this.#updates = this.#connection.events;
+        };
       }
       static async #start(options, getObserver, store, initialize, metrics, adapter) {
         for (let attempt = 1; attempt <= 2; attempt += 1) {
@@ -93887,7 +94295,8 @@ var init_agent_session = __esm({
               getObserver,
               store,
               metrics,
-              adapter
+              adapter,
+              options.externalizeSessionUpdate
             )
           );
           try {
@@ -93910,11 +94319,14 @@ var init_agent_session = __esm({
         }
         throw new AcpExecutionError("ACP agent initialization failed");
       }
-      static start = async (options, recovery, getObserver, store, metrics, adapter) => await _AgentSession.#start(
+      static start = async (options, recovery, getObserver, store, metrics, adapter, capabilities = unsupportedSessionCapabilities()) => await _AgentSession.#start(
         options,
         getObserver,
         store,
-        async (runtime) => await runtime.initialize(options.signal, recovery, options.origin),
+        async (runtime) => {
+          runtime.#capabilities = capabilities;
+          await runtime.initialize(options.signal, recovery, options.origin);
+        },
         metrics,
         adapter
       );
@@ -93927,7 +94339,7 @@ var init_agent_session = __esm({
           new StoredSession(
             this.#mobiusSessionId,
             this.#agentId,
-            this.#updates.sessionId(),
+            this.#nativeSessionId,
             this.#cwd,
             this.#additionalDirectories,
             this.#prompted,
@@ -93949,9 +94361,9 @@ var init_agent_session = __esm({
         if (normalized.length === 0) {
           throw new AcpExecutionError("The Session title cannot be empty", {}, "invalid_session_title");
         }
-        const nativeSessionId = this.#updates.sessionId();
+        const nativeSessionId = this.#nativeSessionId;
         if (nativeSessionId.length > 0) {
-          await this.#adapter.renameSession(this.#target(), normalized, signal);
+          await this.#adapter.renameSession({ ...this.#target(), title: normalized, signal });
         }
         const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         await this.#processEvent({
@@ -93966,7 +94378,7 @@ var init_agent_session = __esm({
       };
       #captureSelectedConfigurationValues = () => {
         this.#sessionConfigurations.capture(this.#configOptions);
-        if (this.#updates.sessionId().length > 0) {
+        if (this.#nativeSessionId.length > 0) {
           this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
         }
       };
@@ -93996,8 +94408,12 @@ var init_agent_session = __esm({
           }
         }
       };
-      restrictSessionCapabilities = (response) => {
-        this.#capabilities = restrictAcpSessionCapabilities(this.#capabilities, response);
+      applySessionOpened = (opened) => {
+        this.#agentName = opened.agentName;
+        this.#agentVersion = opened.agentVersion;
+        this.#modelEffort = opened.agentSettingsModelEffort;
+        this.#capabilities = opened.capabilities;
+        this.setConfigOptions(opened.configOptions);
       };
       prepared = () => new PreparedSession(
         this.#agentName,
@@ -94017,7 +94433,7 @@ var init_agent_session = __esm({
             "native_history_unsupported"
           );
         }
-        await this.#completedHistory(signal, "ACP agent exited while loading history");
+        await this.#completedHistory(signal);
       };
       /** Starts live event capture without asking the native Agent to replay its persisted history. */
       startExecutionOnlyCapture = () => {
@@ -94037,26 +94453,33 @@ var init_agent_session = __esm({
             "native_history_unsupported"
           );
         }
-        const history = await this.#completedHistory(signal, "ACP agent exited while loading history");
+        const history = await this.#completedHistory(signal);
         return history.eventPage(eventLimit, cursor);
       };
-      async #completedHistory(signal, exitMessage) {
+      async #completedHistory(signal) {
         if (!this.#prompted && this.#nativeHistoryOwnership.kind === "fresh-session") {
           if (this.#sessionLoad.kind === "not-requested") {
             this.#store.events.reset(this.#mobiusSessionId);
             this.#sessionLoad = {
               history: new HistoryReplayCapture(this.#store.events, this.#mobiusSessionId),
               kind: "loaded",
-              response: {}
+              opened: {
+                nativeSessionId: this.nativeSessionId(),
+                capabilities: this.#capabilities,
+                configOptions: [],
+                agentName: this.#agentName,
+                agentVersion: this.#agentVersion,
+                agentSettingsModelEffort: this.#modelEffort
+              }
             };
           }
           if (this.#sessionLoad.kind === "loaded") {
             return this.#sessionLoad.history;
           }
         }
-        return (await this.#loadSession(signal, exitMessage)).history;
+        return (await this.#loadSession(signal)).history;
       }
-      async #loadSession(signal, exitMessage) {
+      async #loadSession(signal) {
         if (this.#sessionLoad.kind === "loaded") {
           return this.#sessionLoad;
         }
@@ -94067,24 +94490,13 @@ var init_agent_session = __esm({
         const history = new HistoryReplayCapture(this.#store.events, this.#mobiusSessionId);
         const completion = Promise.resolve().then(async () => {
           try {
-            const response = await this.race(
-              this.#connection.connection.agent.request(
-                methods14.agent.session.load,
-                {
-                  additionalDirectories: [...this.#additionalDirectories],
-                  cwd: this.#cwd,
-                  mcpServers: [],
-                  sessionId: this.#updates.sessionId()
-                },
-                { cancellationSignal: signal }
-              ),
-              exitMessage,
-              signal
-            );
-            await this.#updates.drained();
+            const opened = await this.#adapter.openSessionWithReplay({
+              ...this.#sessionParams(signal),
+              nativeSessionId: this.nativeSessionId()
+            });
             signal.throwIfAborted();
-            this.restrictSessionCapabilities(response);
-            const loaded = { history, kind: "loaded", response };
+            this.#capabilities = opened.capabilities;
+            const loaded = { history, kind: "loaded", opened };
             this.#sessionLoad = loaded;
             return loaded;
           } catch (cause) {
@@ -94095,24 +94507,10 @@ var init_agent_session = __esm({
         this.#sessionLoad = { completion, history, kind: "capturing" };
         return await completion;
       }
-      async #initializeAgent(signal) {
-        await this.#metrics.measure("agent-initialize", async () => await this.#initializeAgentOperation(signal));
-      }
-      async #initializeAgentOperation(signal) {
-        const initialized = await initializeAgentConnection(
-          this.#connection,
-          this.#agentId,
-          this.#verifiedAgentVersion,
-          signal
-        );
-        this.#capabilities = initialized.capabilities;
-        this.#agentName = initialized.agentName;
-        this.#agentVersion = initialized.agentVersion;
-      }
       initialize = async (signal, recovery, origin) => await restoreSession(this, signal, recovery, origin);
-      nativeSessionId = () => this.#updates.sessionId();
+      nativeSessionId = () => this.#nativeSessionId;
       adoptNativeSessionId = (sessionId) => {
-        if (this.#prompted || this.#updates.sessionId() !== sessionId) {
+        if (this.#prompted || this.#nativeSessionId !== sessionId) {
           throw new AcpExecutionError("The new native Session cannot be adopted", {}, "session_identity_mismatch");
         }
         const previousSessionId = this.#mobiusSessionId;
@@ -94134,7 +94532,7 @@ var init_agent_session = __esm({
       };
       #applyConfiguration = async (selection, signal) => {
         const configRevision = this.#configRevision;
-        const configured = await this.#adapter.configureSession(this.#target(), selection, signal);
+        const configured = await this.#adapter.configureSession({ ...this.#target(), selection, signal });
         if (this.#configRevision === configRevision) {
           this.#configOptions = configured;
           this.#configRevision = crypto.randomUUID();
@@ -94181,7 +94579,7 @@ var init_agent_session = __esm({
         await this.emitConfigUpdate();
       };
       #target = () => ({
-        nativeSessionId: this.#updates.sessionId(),
+        nativeSessionId: this.#nativeSessionId,
         cwd: this.#cwd,
         additionalDirectories: this.#additionalDirectories
       });
@@ -94193,11 +94591,18 @@ var init_agent_session = __esm({
           this.#sessionLoad = {
             kind: "loaded",
             history: new HistoryReplayCapture(this.#store.events, this.#mobiusSessionId),
-            response: {}
+            opened: {
+              nativeSessionId: this.nativeSessionId(),
+              capabilities: this.#capabilities,
+              configOptions: [],
+              agentName: this.#agentName,
+              agentVersion: this.#agentVersion,
+              agentSettingsModelEffort: this.#modelEffort
+            }
           };
         }
         if (this.#capabilities.loadSession && this.#sessionLoad.kind !== "execution-only") {
-          await this.#completedHistory(options.signal, "ACP agent exited while loading history before a prompt");
+          await this.#completedHistory(options.signal);
         }
         validatePromptContent(options, this.#capabilities);
         if (this.#sessionTitle === null || this.#sessionTitle.length === 0) {
@@ -94231,7 +94636,7 @@ var init_agent_session = __esm({
           });
         }
         try {
-          const result = await this.#adapter.prompt(this.#target(), options, options.signal);
+          const result = await this.#adapter.prompt({ ...this.#target(), content: options, signal: options.signal });
           this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
           if (lifecycle !== void 0) {
             await this.recordLifecycleEvent({
@@ -94302,7 +94707,7 @@ var init_agent_session = __esm({
           });
         }
         try {
-          const outcome = await this.#adapter.steer(this.#target(), options, options.signal);
+          const outcome = await this.#adapter.steer({ ...this.#target(), content: options, signal: options.signal });
           if (lifecycle !== void 0) {
             await this.recordLifecycleEvent({
               payload: {
@@ -94336,7 +94741,7 @@ var init_agent_session = __esm({
         await this.#interactions.cancelPendingInteractions();
         signal.throwIfAborted();
         if (this.#turn.running) {
-          return await this.#adapter.cancel(this.#target(), signal);
+          return await this.#adapter.cancel({ ...this.#target(), signal });
         }
         return "retained";
       };
@@ -94361,7 +94766,14 @@ var init_agent_session = __esm({
         await this.#getObserver().onSessionEvent?.(liveEvent2);
       };
       selectNativeSession = (sessionId) => {
-        this.#updates.select(sessionId);
+        if (this.#nativeSessionId.length > 0 && this.#nativeSessionId !== sessionId) {
+          throw new AcpExecutionError(
+            "ACP agent attempted to replace the selected session",
+            {},
+            "invalid_agent_session"
+          );
+        }
+        this.#nativeIdentity = { kind: "bound", nativeSessionId: sessionId };
         this.#nativeHistoryOwnership = { kind: "agent-owned" };
       };
       #processEvent = async (event) => {
@@ -94406,7 +94818,7 @@ var init_agent_session = __esm({
                   break;
               }
             }
-            if (this.#updates.sessionId().length > 0) {
+            if (this.#nativeSessionId.length > 0) {
               this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
             }
             await this.#getObserver().onInfo({
@@ -94428,31 +94840,28 @@ var init_agent_session = __esm({
             await this.closeProcess();
           }
         }
-        if (this.#updates.sessionId().length === 0) {
+        if (this.#nativeSessionId.length === 0) {
           await this.closeProcess();
           return;
         }
-        await this.#adapter.closeSession(this.#target(), AbortSignal.timeout(3e4));
+        await this.#adapter.closeSession({ ...this.#target(), signal: AbortSignal.timeout(3e4) });
       };
-      closeProcess = () => this.#connection.closeProcess();
-      agentSettingsModelEffort = () => this.#connection.agentSettingsModelEffort();
-      race = (operation, exitMessage, signal) => this.#connection.race(operation, exitMessage, signal);
-      agentRequest(method, params, options) {
-        return this.#connection.connection.agent.request(
-          method,
-          params,
-          options
-        );
-      }
-      drained() {
-        return this.#updates.drained();
-      }
-      initializeAgent(signal) {
-        return this.#initializeAgent(signal);
-      }
-      async loadSession(signal, exitMessage) {
-        return await this.#loadSession(signal, exitMessage);
-      }
+      closeProcess = async () => {
+        if (this.#nativeIdentity.kind === "bound") {
+          await this.#adapter.releaseSession({ ...this.#target(), signal: AbortSignal.timeout(3e4) });
+        }
+        this.#backgroundActivity = "none";
+      };
+      agentSettingsModelEffort = () => this.#modelEffort;
+      #sessionParams = (signal) => ({
+        ...this.#subscriber,
+        scope: this.#scope,
+        signal
+      });
+      createSession = (signal) => this.#adapter.createSession(this.#sessionParams(signal));
+      forkSession = (sourceSessionId, signal) => this.#adapter.forkSession({ ...this.#sessionParams(signal), sourceNativeSessionId: sourceSessionId });
+      openSession = (signal) => this.#adapter.openSession({ ...this.#sessionParams(signal), nativeSessionId: this.nativeSessionId() });
+      openSessionWithReplay = async (signal) => (await this.#loadSession(signal)).opened;
       setConfigOptions(options) {
         this.#configOptions = options;
         this.#configRevision = crypto.randomUUID();
@@ -94470,7 +94879,7 @@ var init_agent_session = __esm({
         this.#sessionTitle = title2;
       }
       assertNativeSession = (sessionId) => {
-        if (sessionId !== this.#updates.sessionId()) {
+        if (sessionId !== this.#nativeSessionId) {
           throw new AcpExecutionError("ACP agent referenced an unknown session", {}, "invalid_agent_session");
         }
       };
@@ -94501,6 +94910,23 @@ var init_native_chat_agent = __esm({
   }
 });
 
+// src/engine/session/native/native-query.ts
+function nativeSessionQuery(options) {
+  const externalize = options.externalizeSessionUpdate;
+  return {
+    agent: options.agent,
+    cwd: options.cwd,
+    additionalDirectories: options.additionalDirectories,
+    signal: options.signal,
+    ...externalize === void 0 ? {} : { externalizeUpdate: (update, signal) => externalize(options.sessionId, update, signal) }
+  };
+}
+var init_native_query = __esm({
+  "src/engine/session/native/native-query.ts"() {
+    "use strict";
+  }
+});
+
 // src/engine/session/turn/active-executions.ts
 var unreachable2, ActiveExecutions;
 var init_active_executions = __esm({
@@ -94596,9 +95022,11 @@ var init_session_manager = __esm({
     "use strict";
     init_protocol();
     init_acp_error();
+    init_session_capabilities();
     init_operation_metrics();
     init_agent_session();
     init_native_chat_agent();
+    init_native_query();
     init_retained_agent_processes();
     init_session_store2();
     init_active_executions();
@@ -94721,21 +95149,29 @@ var init_session_manager = __esm({
         if (retiring !== void 0) {
           await waitForSharedOperation(retiring, options.signal);
         }
-        const runtime = await this.#processes.startRetained(options.signal, start, this.#retention(options.sessionId));
+        const stored = this.#store.read(options.sessionId);
+        const capabilities = options.origin !== void 0 || stored instanceof FoundStoredSession && stored.session.prompted ? await options.adapter.getCapabilities(nativeSessionQuery(options)) : unsupportedSessionCapabilities();
+        const runtime = await this.#processes.startRetained(
+          options.signal,
+          () => start(capabilities),
+          this.#retention(options.sessionId)
+        );
         this.#executionProcesses.retain(options.sessionId, runtime);
         return runtime;
       }
       async #startPreparation(options, recovery, metrics = unmeasuredOperationMetrics) {
         return await this.#executionProcesses.prepare(options.sessionId, async () => {
+          const effectiveOptions = options.origin === void 0 && this.#sessionIdentity === "native" && isNativeChatSessionId(options.agent.id, options.sessionId) && this.#store.read(options.sessionId) instanceof MissingStoredSession ? { ...options, origin: { kind: "import", nativeSessionId: options.sessionId, title: "" } } : options;
           return await this.#startRetainedSessionProcess(
-            options,
-            async () => await AgentSession.start(
-              options.origin === void 0 && this.#sessionIdentity === "native" && isNativeChatSessionId(options.agent.id, options.sessionId) && this.#store.read(options.sessionId) instanceof MissingStoredSession ? { ...options, origin: { kind: "import", nativeSessionId: options.sessionId, title: "" } } : options,
+            effectiveOptions,
+            async (capabilities) => await AgentSession.start(
+              effectiveOptions,
               recovery,
               () => this.#observer,
               this.#store,
               metrics,
-              options.adapter
+              options.adapter,
+              capabilities
             )
           );
         });
@@ -94750,13 +95186,14 @@ var init_session_manager = __esm({
           this.#store.remove(options.sessionId);
           return await this.#startRetainedSessionProcess(
             options,
-            async () => await AgentSession.start(
+            async (capabilities) => await AgentSession.start(
               options,
               recovery,
               () => this.#observer,
               this.#store,
               metrics,
-              options.adapter
+              options.adapter,
+              capabilities
             )
           );
         });
@@ -94768,13 +95205,14 @@ var init_session_manager = __esm({
           await this.#retireSessionProcess(options.sessionId, existing, async () => await existing.close());
           const runtime = await this.#startRetainedSessionProcess(
             options,
-            async () => await AgentSession.start(
+            async (capabilities) => await AgentSession.start(
               options,
               recovery,
               () => this.#observer,
               this.#store,
               unmeasuredOperationMetrics,
-              options.adapter
+              options.adapter,
+              capabilities
             )
           );
           try {
@@ -95402,7 +95840,7 @@ var init_local_authorization_error = __esm({
 });
 
 // src/engine/session/native/native-session-browser.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 function nextForkTitle(sourceTitle, sessions) {
   let highest = 0;
   for (const session of sessions) {
@@ -95433,6 +95871,7 @@ var init_native_session_browser = __esm({
     init_native_session();
     init_operation_drain();
     init_local_authorization_error();
+    init_native_query();
     MAXIMUM_SESSION_TITLE_LENGTH = 500;
     forkSuffixPattern = / \(Fork #([1-9][0-9]*)\)$/u;
     NativeSessionService = class {
@@ -95460,17 +95899,14 @@ var init_native_session_browser = __esm({
         (scoped) => this.#sessions.withNativeSessionOperation(
           scoped,
           nativeSessionId,
-          (target) => target.adapter.readSessionHistory(
-            target.cwd,
-            target.additionalDirectories,
-            {
+          (target) => target.adapter.readSessionHistory({
+            query: nativeSessionQuery(target),
+            request: {
               nativeSessionId,
               eventLimit,
-              cursor,
-              sessionId: target.sessionId
-            },
-            target.signal
-          )
+              cursor
+            }
+          })
         )
       );
       #execute = async (command, signal) => {
@@ -95501,7 +95937,7 @@ var init_native_session_browser = __esm({
             queuedCancellation: "before-start"
           };
         }
-        const capabilities = await options.adapter.getCapabilities(cwd, signal);
+        const capabilities = await options.adapter.getCapabilities(nativeSessionQuery(options));
         if (!capabilities.listSessions) {
           throw new AcpExecutionError(
             "This Agent does not support native session listing",
@@ -95516,7 +95952,7 @@ var init_native_session_browser = __esm({
           if (authorized === null) {
             return null;
           }
-          const entryId = decodeIdentifier(randomUUID15());
+          const entryId = decodeIdentifier(randomUUID14());
           if (this.#entries.size >= 5e3) {
             this.#entries.clear();
           }
@@ -95555,7 +95991,7 @@ var init_native_session_browser = __esm({
             }
             cursor = known.cursor;
           }
-          const page = await options.adapter.listSessions(cwd, cursor, signal);
+          const page = await options.adapter.listSessions({ query: nativeSessionQuery(options), cursor });
           const entries = [];
           for (const info of page.sessions) {
             const entry = await register(info);
@@ -95572,7 +96008,7 @@ var init_native_session_browser = __esm({
                 "invalid_native_session_response"
               );
             }
-            nextCursor = decodeIdentifier(randomUUID15());
+            nextCursor = decodeIdentifier(randomUUID14());
             if (this.#cursors.size >= 500) {
               this.#cursors.clear();
             }
@@ -95590,15 +96026,14 @@ var init_native_session_browser = __esm({
           };
         }
         if (command.action === "find") {
-          const found = await options.adapter.findSession(
-            cwd,
-            command.nativeSessionId,
-            {
+          const found = await options.adapter.findSession({
+            query: nativeSessionQuery(options),
+            nativeSessionId: command.nativeSessionId,
+            budget: {
               maximumPages: 500,
               maximumEntries: 500
-            },
-            signal
-          );
+            }
+          });
           const entry = await register(found);
           if (entry !== null) {
             return { ...envelope2, action: "find", entry };
@@ -95736,15 +96171,14 @@ var init_native_session_browser = __esm({
         }
       };
       resolveTarget = async (command, options, selected) => {
-        const info = await options.adapter.findSession(
-          options.cwd,
-          selected.nativeSessionId,
-          {
+        const info = await options.adapter.findSession({
+          query: nativeSessionQuery(options),
+          nativeSessionId: selected.nativeSessionId,
+          budget: {
             maximumPages: 100,
             maximumEntries: null
-          },
-          options.signal
-        ).catch((cause) => {
+          }
+        }).catch((cause) => {
           options.signal.throwIfAborted();
           if (cause instanceof AcpExecutionError && cause.code === "native_session_not_found") {
             throw new AcpExecutionError(
@@ -96031,7 +96465,7 @@ var init_prompt_lifecycle = __esm({
 });
 
 // src/engine/session/turn/execution-receipts.ts
-import { createHash as createHash7, randomUUID as randomUUID16 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID15 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS, ExecutionReceipts;
 var init_execution_receipts = __esm({
   "src/engine/session/turn/execution-receipts.ts"() {
@@ -96178,7 +96612,7 @@ var init_execution_receipts = __esm({
         ).digest("hex");
         this.#save(commandId, {
           admissionOrder: this.#nextAdmissionOrder(),
-          attemptId: randomUUID16(),
+          attemptId: randomUUID15(),
           commandHash,
           sessionId,
           started: false,
@@ -96260,7 +96694,7 @@ var init_execution_receipts = __esm({
         if (identity2 !== void 0) {
           return identity2.sessionId === sessionId && identity2.commandHash === commandHash ? { kind: "expired" } : { kind: "conflict" };
         }
-        const attemptId = randomUUID16();
+        const attemptId = randomUUID15();
         this.#save(commandId, {
           admissionOrder: this.#nextAdmissionOrder(),
           attemptId,
@@ -96395,7 +96829,7 @@ var init_runtime_turn_activity = __esm({
 });
 
 // src/engine/session/turn/active-turn.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 var ActiveRuntimeTurn;
 var init_active_turn = __esm({
   "src/engine/session/turn/active-turn.ts"() {
@@ -96410,7 +96844,7 @@ var init_active_turn = __esm({
       #dispatch;
       #sequence = 0;
       #interaction = null;
-      #epoch = decodeIdentifier(randomUUID17());
+      #epoch = decodeIdentifier(randomUUID16());
       constructor(command, attemptId) {
         this.attemptId = attemptId;
         this.command = command;
@@ -97019,11 +97453,11 @@ var init_session_layer = __esm({
 });
 
 // src/engine/storage/files/scratch-directory.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 import { lstat as lstat4, mkdir as mkdir5, readdir as readdir6, readFile as readFile7, realpath as realpath8, rename as rename4, rm as rm3, stat as stat8, utimes, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname12, join as join30 } from "node:path";
 async function atomicWrite(path8, bytes, signal) {
-  const temporary = `${path8}.${randomUUID18()}.tmp`;
+  const temporary = `${path8}.${randomUUID17()}.tmp`;
   try {
     await writeFile2(temporary, bytes, { mode: 384, signal });
     signal.throwIfAborted();
@@ -97039,7 +97473,7 @@ var init_scratch_directory = __esm({
     ScratchDirectory = class {
       #root;
       constructor(parent) {
-        this.#root = join30(parent, randomUUID18());
+        this.#root = join30(parent, randomUUID17());
       }
       /** Refreshes this directory's lease and removes sibling directories whose lease is older than `leaseMilliseconds`. */
       refreshLease = async (leaseMilliseconds) => {
@@ -99231,7 +99665,7 @@ var init_native_sessions = __esm({
 });
 
 // src/engine/session/prompt/apply-session-configuration.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 function invalidSessionConfiguration(message) {
   return new AcpExecutionError(message, {}, "invalid_session_configuration");
 }
@@ -99369,7 +99803,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
     booleanValue: selection.booleanValue,
     configId: selection.configId,
     cwd,
-    requestId: `cfg_${randomUUID19()}`,
+    requestId: `cfg_${randomUUID18()}`,
     sessionId,
     signal,
     value: selection.value,
@@ -99442,7 +99876,11 @@ async function executePrompt({
       command.additionalDirectoryIds,
       signal
     );
-    const { agent, adapter } = await resolveAgent(command.agentId, signal, command.sessionId);
+    const { agent, adapter, externalizeSessionUpdate } = await resolveAgent(
+      command.agentId,
+      signal,
+      command.sessionId
+    );
     const availability = await waitForSessionAvailability(signal);
     if (availability.kind === "busy") {
       throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
@@ -99460,6 +99898,7 @@ async function executePrompt({
     const recovery = command.historyPolicy === SessionHistoryPolicy.ExecutionOnly ? { kind: "execution-only" } : { kind: "interactive-only" };
     const preparation = {
       adapter,
+      ...externalizeSessionUpdate === void 0 ? {} : { externalizeSessionUpdate },
       additionalDirectories: resolved.additionalDirectories,
       agent: executionAgent,
       cwd: resolved.cwd,
@@ -99514,6 +99953,7 @@ async function executePrompt({
     if (availability.disposition === SessionPromptDisposition.Steer) {
       await sessions.steerPrompt({
         adapter,
+        ...externalizeSessionUpdate === void 0 ? {} : { externalizeSessionUpdate },
         additionalDirectories: resolved.additionalDirectories,
         agent: executionAgent,
         commandId: command.commandId,
@@ -99530,6 +99970,7 @@ async function executePrompt({
     } else {
       const result = await sessions.runPrompt({
         adapter,
+        ...externalizeSessionUpdate === void 0 ? {} : { externalizeSessionUpdate },
         additionalDirectories: resolved.additionalDirectories,
         agent: executionAgent,
         commandId: command.commandId,
@@ -100943,7 +101384,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
     const publisher = new RuntimeSessionEventPublisher(timer);
     const externalContent = __using(_stack, new LocalExternalContentStore(stateDirectory), true);
     const processes = new AgentProcessPool(config2.localContext.maxAcpProcesses, timer);
-    const adapters = createRuntimeAdapterRegistry(
+    const { adapters, externalizeSessionUpdate } = createRuntimeAdapterRegistry(
       config2.adapters,
       processes,
       (sessionId, content, contentSignal) => externalContent.put({ ...content, sessionId, signal: contentSignal }),
@@ -100953,7 +101394,11 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
       const catalogAgent = await resolveCatalogAgent(config2, agentId, resolveSignal);
       const environment = sessionId === void 0 ? void 0 : config2.sessionEnvironment?.({ sessionId, agentId });
       const agent = environment === void 0 ? catalogAgent : catalogAgent.withEnvironment({ ...catalogAgent.environment, ...environment });
-      return { agent, adapter: adapters.resolve(catalogAgent) };
+      return {
+        agent,
+        adapter: adapters.resolve(catalogAgent),
+        externalizeSessionUpdate
+      };
     };
     const layer = buildSessionLayer({
       processes,
@@ -101338,7 +101783,7 @@ var init_engine = __esm({
 });
 
 // src/storage/daemon/version-data.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 import { cp as cp2, lstat as lstat5, mkdtemp, readFile as readFile8, rename as rename5, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join33, relative as relative3, sep as sep5 } from "node:path";
 async function prepareVersionDataDirectory(root, version2, signal) {
@@ -101429,7 +101874,7 @@ async function discardVersionData(root, version2, signal) {
     return;
   }
   const versions = join33(root, STATE_ROOT_LAYOUT.versions);
-  const discarded = join33(versions, `.${version2}-discarded-${randomUUID20()}`);
+  const discarded = join33(versions, `.${version2}-discarded-${randomUUID19()}`);
   try {
     await rename5(join33(versions, version2), discarded);
   } catch (cause) {
@@ -101443,7 +101888,7 @@ async function discardVersionData(root, version2, signal) {
 async function writeCurrentDataVersion(root, version2, signal) {
   await validateLocalPath(root, true, true, signal);
   await validateLocalPath(join33(root, STATE_ROOT_LAYOUT.versions, version2), true, true, signal);
-  const temporary = join33(root, `.current-data-${randomUUID20()}.txt`);
+  const temporary = join33(root, `.current-data-${randomUUID19()}.txt`);
   try {
     await writeFile3(temporary, `versions/${version2}
 `, { mode: 384, flag: "wx", signal });
@@ -103047,7 +103492,7 @@ var init_quit = __esm({
 });
 
 // src/daemon/upgrades/upgrade.ts
-import { randomUUID as randomUUID21 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import { setInterval as setInterval2, setTimeout as setTimeout4 } from "node:timers/promises";
 async function reportDaemonUpgradeAvailability(send2, signal) {
   if (!process.connected) {
@@ -103106,7 +103551,7 @@ async function requestDaemonReleaseUpgrade(stateDirectory, currentVersion, signa
   return await requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal);
 }
 async function requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal) {
-  const id = randomUUID21();
+  const id = randomUUID20();
   const response = decodeKnownLifecycleResponse(
     await sendLocalRequest(stateDirectory, "manager", { kind: "switch", id, context: "npm", launch }, signal)
   );