@moxt-ai/mobius 0.0.359 → 0.0.360

package/dist/engine.js

@@ -75873,9 +75873,25 @@ async function runCleanup(...actions) {
   }
 }
 
-// src/engine/acp/adapter/live-sessions.ts
+// src/engine/acp/protocol/native-session.ts
+var path6 = external_exports.string().min(1).max(2048).refine((value) => !value.includes("\0"));
+var title = external_exports.string().transform((value) => value.slice(0, 500));
+var nativeSessionIdSchema = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/);
+var nativeSessionInfoSchema = external_exports.object({
+  sessionId: nativeSessionIdSchema,
+  cwd: path6,
+  additionalDirectories: external_exports.array(path6).max(16).default([]).readonly(),
+  title: title.nullish(),
+  updatedAt: external_exports.iso.datetime({ offset: true }).nullish()
+}).readonly();
+var 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/adapter/execution-connections.ts
 import { isAbsolute as isAbsolute14, resolve as resolve13 } from "node:path";
-import { methods as methods10 } from "@agentclientprotocol/sdk";
+import { methods as methods11 } from "@agentclientprotocol/sdk";
 
 // src/engine/acp/client/prompt-content.ts
 function validatePromptContent(options, capabilities) {
@@ -75933,22 +75949,6 @@ function buildPromptContent(options, capabilities) {
   return prompt;
 }
 
-// src/engine/acp/protocol/native-session.ts
-var path6 = external_exports.string().min(1).max(2048).refine((value) => !value.includes("\0"));
-var title = external_exports.string().transform((value) => value.slice(0, 500));
-var nativeSessionIdSchema = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/);
-var nativeSessionInfoSchema = external_exports.object({
-  sessionId: nativeSessionIdSchema,
-  cwd: path6,
-  additionalDirectories: external_exports.array(path6).max(16).default([]).readonly(),
-  title: title.nullish(),
-  updatedAt: external_exports.iso.datetime({ offset: true }).nullish()
-}).readonly();
-var 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";
 var MAXIMUM_CONFIG_OPTIONS = 100;
@@ -76261,6 +76261,101 @@ var AgentUpdateStream = class {
   };
 };
 
+// src/engine/acp/adapter/agent-initialization.ts
+import { methods as methods10, PROTOCOL_VERSION as PROTOCOL_VERSION3 } from "@agentclientprotocol/sdk";
+var RetryableAcpInitializationError = class extends AcpExecutionError {
+  constructor(cause) {
+    super("ACP agent initialization failed", { cause });
+    this.name = "RetryableAcpInitializationError";
+  }
+};
+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
+    )
+  };
+}
+
+// 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;
+    }
+  }
+}
+
 // src/engine/acp/adapter/session-events.ts
 var AdapterSessionConnection = class {
   #connection;
@@ -76270,19 +76365,24 @@ var AdapterSessionConnection = class {
   #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) {
@@ -76308,13 +76408,15 @@ var AdapterSessionConnection = class {
             };
             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": {
@@ -76386,10 +76488,92 @@ var AdapterSessionConnection = class {
   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();
@@ -76435,14 +76619,14 @@ var AcpSessionConnector = class {
   };
 };
 
-// src/engine/acp/adapter/live-sessions.ts
+// src/engine/acp/adapter/execution-connections.ts
 var absolutePathSchema = external_exports.string().min(1).refine(isAbsolute14);
 var targetSchema = external_exports.object({
   nativeSessionId: nativeSessionIdSchema,
   cwd: absolutePathSchema,
   additionalDirectories: external_exports.array(absolutePathSchema)
 });
-var AcpLiveSessions = class {
+var AcpExecutionConnections = class {
   #sessions = /* @__PURE__ */ new Set();
   #externalizer;
   #normalizeEvent;
@@ -76450,16 +76634,72 @@ var AcpLiveSessions = class {
     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);
@@ -76488,12 +76728,12 @@ var AcpLiveSessions = class {
     }
     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",
@@ -76501,19 +76741,19 @@ var AcpLiveSessions = class {
     );
     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)]) }
           );
@@ -76526,13 +76766,20 @@ var AcpLiveSessions = class {
     }
     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();
+  };
+  prompt = async ({ content, signal, ...target }) => {
     signal.throwIfAborted();
-    const { connection, scope } = this.#resolve(target);
-    const prompt = buildPromptContent(content, scope.capabilities());
+    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 }
       ),
@@ -76559,10 +76806,10 @@ var AcpLiveSessions = class {
       );
     }
   };
-  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",
         {},
@@ -76574,7 +76821,7 @@ var AcpLiveSessions = class {
         "_session/steering",
         {
           _meta: { steering: { idleBehavior: "promptRequired" } },
-          prompt: buildPromptContent(content, scope.capabilities()),
+          prompt: buildPromptContent(content, connection.snapshot().capabilities),
           sessionId: target.nativeSessionId
         },
         { cancellationSignal: signal }
@@ -76604,14 +76851,14 @@ var AcpLiveSessions = class {
       "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 {
@@ -76637,10 +76884,14 @@ var AcpLiveSessions = class {
     }
     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(
@@ -76656,6 +76907,7 @@ var AcpLiveSessions = class {
         existing.values.map((entry) => entry.value)
       );
     }
+    connection.beginStateChange();
     try {
       const configured = await sessionConfigProtocolForAgent(scope.agent.id).configure(
         current,
@@ -76683,8 +76935,9 @@ var AcpLiveSessions = class {
         );
       }
       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);
       }
@@ -76703,6 +76956,38 @@ var AcpLiveSessions = class {
   };
 };
 
+// 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)
+  };
+}
+
 // src/engine/acp/adapter/native-session-lookup.ts
 var lookupSchema = external_exports.object({
   nativeSessionId: nativeSessionIdSchema,
@@ -76711,7 +76996,7 @@ var lookupSchema = external_exports.object({
     maximumEntries: external_exports.number().int().positive().nullable()
   })
 });
-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(
@@ -76725,9 +77010,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) {
@@ -76749,9 +77034,6 @@ async function findNativeSession(list, cwd, nativeSessionId, budget, signal) {
   throw new AcpExecutionError("The native session was not found", {}, "native_session_not_found");
 }
 
-// src/engine/acp/adapter/query-processes.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
-
 // src/engine/session/history/session-event-store.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
 
@@ -77393,112 +77675,53 @@ var RetainedAgentProcesses = class {
   };
 };
 
-// src/engine/acp/adapter/query-session.ts
-import { methods as methods12 } from "@agentclientprotocol/sdk";
-
-// src/engine/acp/adapter/agent-initialization.ts
-import { methods as methods11, PROTOCOL_VERSION as PROTOCOL_VERSION3 } from "@agentclientprotocol/sdk";
-var RetryableAcpInitializationError = class extends AcpExecutionError {
-  constructor(cause) {
-    super("ACP agent initialization failed", { cause });
-    this.name = "RetryableAcpInitializationError";
-  }
-};
-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
+var queryKeySchema = external_exports.string().brand();
+var previewKeySchema = external_exports.string().brand();
+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]));
 }
 
 // src/engine/acp/adapter/query-session.ts
+import { methods as methods12 } from "@agentclientprotocol/sdk";
 var 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();
@@ -77515,7 +77738,7 @@ var AcpQuerySession = class _AcpQuerySession {
     }
     throw new AcpExecutionError("ACP agent initialization failed");
   };
-  capabilities = () => this.#capabilities;
+  capabilities = () => this.#connection.snapshot().capabilities;
   hasTerminated = () => {
     switch (this.#lifecycle.kind) {
       case "open":
@@ -77529,7 +77752,7 @@ var AcpQuerySession = class _AcpQuerySession {
     }
   };
   listNativeSessions = async (cursor, signal) => {
-    if (!this.#capabilities.listSessions) {
+    if (!this.capabilities().listSessions) {
       throw new AcpExecutionError(
         "This Agent does not support native session listing",
         {},
@@ -77553,22 +77776,24 @@ var AcpQuerySession = class _AcpQuerySession {
     }
     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
         },
@@ -77579,10 +77804,11 @@ var AcpQuerySession = class _AcpQuerySession {
     );
     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
@@ -77601,45 +77827,46 @@ var AgentQueryProcesses = class {
   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({
@@ -77649,35 +77876,38 @@ var AgentQueryProcesses = class {
       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;
@@ -77686,7 +77916,7 @@ var AgentQueryProcesses = class {
   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();
@@ -77699,35 +77929,99 @@ var AgentQueryProcesses = class {
 };
 
 // src/engine/acp/adapter/claude/adapter.ts
+import { methods as methods13 } from "@agentclientprotocol/sdk";
 var 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()
   );
 };
 
 // src/engine/acp/adapter/codex/adapter.ts
 import { createHash as createHash5 } from "node:crypto";
+import { methods as methods14 } from "@agentclientprotocol/sdk";
 
 // src/engine/storage/session/temporary-session-event-cache.ts
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
@@ -83027,7 +83321,7 @@ var CodexAdapter = class {
   #agent;
   #queryProcesses;
   #connector;
-  #liveSessions;
+  #executionConnections;
   #dependencies;
   #contentExternalizer;
   #previewCache = null;
@@ -83043,37 +83337,112 @@ var CodexAdapter = class {
       }
     };
     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") {
@@ -83124,7 +83493,7 @@ var CodexAdapter = class {
           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",
@@ -83144,30 +83513,93 @@ var CodexAdapter = class {
 };
 
 // src/engine/acp/adapter/pi/adapter.ts
+import { methods as methods15 } from "@agentclientprotocol/sdk";
 var 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()
   );
 };
 
@@ -83465,10 +83897,12 @@ var AcpContentExternalizer = class {
 
 // 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 = class {
   agents;
@@ -84567,9 +85001,6 @@ var unmeasuredOperationMetrics = Object.freeze({
   snapshot: () => Object.freeze([])
 });
 
-// src/engine/session/live/agent-session.ts
-import { methods as methods14 } from "@agentclientprotocol/sdk";
-
 // ../mobius-sdk/src/conversation-title.ts
 var CONVERSATION_TITLE_CHARACTER_LIMIT = 42;
 function conversationTitleFromText(text2) {
@@ -85408,7 +85839,6 @@ var RunningAgentTurn = class extends AgentTurnState {
 };
 
 // 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;
@@ -85426,7 +85856,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(
@@ -85446,7 +85875,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 lifecycleResponse;
+  let opened;
   if (origin?.kind === "fork") {
     if (!session.capabilities.unstableForkSession) {
       throw new AcpExecutionError(
@@ -85464,22 +85893,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",
@@ -85492,7 +85908,7 @@ async function restoreSession(session, signal, recovery, origin) {
     if (recovery.kind === "execution-only") {
       session.startExecutionOnlyCapture();
     }
-    lifecycleResponse = 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);
@@ -85506,29 +85922,13 @@ async function restoreSession(session, signal, recovery, origin) {
           "native_history_unsupported"
         );
       }
-      lifecycleResponse = 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 {
-        lifecycleResponse = 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)) {
@@ -85542,27 +85942,11 @@ async function restoreSession(session, signal, recovery, origin) {
       }
       session.startExecutionOnlyCapture();
     } else if (session.capabilities.resumeSession) {
-      lifecycleResponse = 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) {
-      lifecycleResponse = 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(
@@ -85582,37 +85966,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();
     }
-    lifecycleResponse = created;
+    opened = created;
   }
-  session.restrictSessionCapabilities(lifecycleResponse);
-  session.setConfigOptions(session.sessionConfigProtocol.normalizeLifecycle(lifecycleResponse));
+  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()
@@ -85644,14 +86011,20 @@ var AgentSession = class _AgentSession {
   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;
@@ -85660,11 +86033,8 @@ var AgentSession = class _AgentSession {
   #getObserver;
   #interactions;
   #mobiusSessionId;
-  #updates;
   #metrics;
-  #sessionConfigProtocol;
   #store;
-  #verifiedAgentVersion;
   #agentName = "";
   #agentVersion = "";
   #capabilities = unsupportedSessionCapabilities();
@@ -85680,7 +86050,7 @@ var AgentSession = class _AgentSession {
   #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;
@@ -85689,9 +86059,7 @@ var AgentSession = class _AgentSession {
     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,
@@ -85702,25 +86070,31 @@ var AgentSession = class _AgentSession {
       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) {
@@ -85738,7 +86112,8 @@ var AgentSession = class _AgentSession {
           getObserver,
           store,
           metrics,
-          adapter
+          adapter,
+          options.externalizeSessionUpdate
         )
       );
       try {
@@ -85761,11 +86136,14 @@ var AgentSession = class _AgentSession {
     }
     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
   );
@@ -85778,7 +86156,7 @@ var AgentSession = class _AgentSession {
       new StoredSession(
         this.#mobiusSessionId,
         this.#agentId,
-        this.#updates.sessionId(),
+        this.#nativeSessionId,
         this.#cwd,
         this.#additionalDirectories,
         this.#prompted,
@@ -85800,9 +86178,9 @@ var AgentSession = class _AgentSession {
     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({
@@ -85817,7 +86195,7 @@ var AgentSession = class _AgentSession {
   };
   #captureSelectedConfigurationValues = () => {
     this.#sessionConfigurations.capture(this.#configOptions);
-    if (this.#updates.sessionId().length > 0) {
+    if (this.#nativeSessionId.length > 0) {
       this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
     }
   };
@@ -85847,8 +86225,12 @@ var AgentSession = class _AgentSession {
       }
     }
   };
-  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,
@@ -85868,7 +86250,7 @@ var AgentSession = class _AgentSession {
         "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 = () => {
@@ -85888,26 +86270,33 @@ var AgentSession = class _AgentSession {
         "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;
     }
@@ -85918,24 +86307,13 @@ var AgentSession = class _AgentSession {
     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) {
@@ -85946,24 +86324,10 @@ var AgentSession = class _AgentSession {
     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;
@@ -85985,7 +86349,7 @@ var AgentSession = class _AgentSession {
   };
   #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();
@@ -86032,7 +86396,7 @@ var AgentSession = class _AgentSession {
     await this.emitConfigUpdate();
   };
   #target = () => ({
-    nativeSessionId: this.#updates.sessionId(),
+    nativeSessionId: this.#nativeSessionId,
     cwd: this.#cwd,
     additionalDirectories: this.#additionalDirectories
   });
@@ -86044,11 +86408,18 @@ var AgentSession = class _AgentSession {
       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) {
@@ -86082,7 +86453,7 @@ var AgentSession = class _AgentSession {
       });
     }
     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({
@@ -86153,7 +86524,7 @@ var AgentSession = class _AgentSession {
       });
     }
     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: {
@@ -86187,7 +86558,7 @@ var AgentSession = class _AgentSession {
     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";
   };
@@ -86212,7 +86583,14 @@ var AgentSession = class _AgentSession {
     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) => {
@@ -86257,7 +86635,7 @@ var AgentSession = class _AgentSession {
               break;
           }
         }
-        if (this.#updates.sessionId().length > 0) {
+        if (this.#nativeSessionId.length > 0) {
           this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
         }
         await this.#getObserver().onInfo({
@@ -86279,31 +86657,28 @@ var AgentSession = class _AgentSession {
         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();
@@ -86321,7 +86696,7 @@ var AgentSession = class _AgentSession {
     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");
     }
   };
@@ -86344,6 +86719,18 @@ function isNativeChatSessionId(agentId, sessionId) {
   return (agentId === "codex" || agentId === "claude" || agentId === "pi") && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(sessionId);
 }
 
+// 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) }
+  };
+}
+
 // src/engine/session/turn/active-executions.ts
 var unreachable2 = (state) => {
   throw new AcpExecutionError("Unexpected execution state", { cause: state });
@@ -86543,21 +86930,29 @@ var SessionManager2 = class {
     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
         )
       );
     });
@@ -86572,13 +86967,14 @@ var SessionManager2 = class {
       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
         )
       );
     });
@@ -86590,13 +86986,14 @@ var SessionManager2 = class {
       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 {
@@ -87207,7 +87604,7 @@ var SessionManager2 = class {
 };
 
 // src/engine/session/native/native-session-browser.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 
 // src/engine/session/workspace/local-authorization-error.ts
 var LocalAuthorizationError = class extends OperationError {
@@ -87266,17 +87663,14 @@ var NativeSessionService = class {
     (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) => {
@@ -87307,7 +87701,7 @@ var NativeSessionService = class {
         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",
@@ -87322,7 +87716,7 @@ var NativeSessionService = class {
       if (authorized === null) {
         return null;
       }
-      const entryId = decodeIdentifier(randomUUID15());
+      const entryId = decodeIdentifier(randomUUID14());
       if (this.#entries.size >= 5e3) {
         this.#entries.clear();
       }
@@ -87361,7 +87755,7 @@ var NativeSessionService = class {
         }
         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);
@@ -87378,7 +87772,7 @@ var NativeSessionService = class {
             "invalid_native_session_response"
           );
         }
-        nextCursor = decodeIdentifier(randomUUID15());
+        nextCursor = decodeIdentifier(randomUUID14());
         if (this.#cursors.size >= 500) {
           this.#cursors.clear();
         }
@@ -87396,15 +87790,14 @@ var NativeSessionService = class {
       };
     }
     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 };
@@ -87542,15 +87935,14 @@ var NativeSessionService = class {
     }
   };
   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(
@@ -87819,7 +88211,7 @@ async function settleAbandonedTurn(projection, operations, cancellation) {
 }
 
 // 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 = 1024;
 var ExecutionReceipts = class {
   #executions = /* @__PURE__ */ new Map();
@@ -87960,7 +88352,7 @@ var ExecutionReceipts = class {
     ).digest("hex");
     this.#save(commandId, {
       admissionOrder: this.#nextAdmissionOrder(),
-      attemptId: randomUUID16(),
+      attemptId: randomUUID15(),
       commandHash,
       sessionId,
       started: false,
@@ -88042,7 +88434,7 @@ var ExecutionReceipts = class {
     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,
@@ -88169,7 +88561,7 @@ var RuntimeTurnActivity = class {
 };
 
 // src/engine/session/turn/active-turn.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 var ActiveRuntimeTurn = class {
   attemptId;
   command;
@@ -88179,7 +88571,7 @@ var ActiveRuntimeTurn = class {
   #dispatch;
   #sequence = 0;
   #interaction = null;
-  #epoch = decodeIdentifier(randomUUID17());
+  #epoch = decodeIdentifier(randomUUID16());
   constructor(command, attemptId) {
     this.attemptId = attemptId;
     this.command = command;
@@ -88745,11 +89137,11 @@ import { extname as extname2, join as join29 } from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // 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 readFile6, realpath as realpath7, rename as rename4, rm as rm3, stat as stat6, utimes, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname11, join as join28 } from "node:path";
 async function atomicWrite(path7, bytes, signal) {
-  const temporary = `${path7}.${randomUUID18()}.tmp`;
+  const temporary = `${path7}.${randomUUID17()}.tmp`;
   try {
     await writeFile2(temporary, bytes, { mode: 384, signal });
     signal.throwIfAborted();
@@ -88761,7 +89153,7 @@ async function atomicWrite(path7, bytes, signal) {
 var ScratchDirectory = class {
   #root;
   constructor(parent) {
-    this.#root = join28(parent, randomUUID18());
+    this.#root = join28(parent, randomUUID17());
   }
   /** Refreshes this directory's lease and removes sibling directories whose lease is older than `leaseMilliseconds`. */
   refreshLease = async (leaseMilliseconds) => {
@@ -90767,7 +91159,7 @@ function createNativeSessionCommands(context) {
 }
 
 // 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");
 }
@@ -90905,7 +91297,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,
@@ -90971,7 +91363,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");
@@ -90989,6 +91385,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,
@@ -91043,6 +91440,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,
@@ -91059,6 +91457,7 @@ async function executePrompt({
     } else {
       const result = await sessions.runPrompt({
         adapter,
+        ...externalizeSessionUpdate === void 0 ? {} : { externalizeSessionUpdate },
         additionalDirectories: resolved.additionalDirectories,
         agent: executionAgent,
         commandId: command.commandId,
@@ -91195,7 +91594,7 @@ var sessionPromptCommand = {
 // package.json
 var 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: {
@@ -92457,7 +92856,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 }),
@@ -92467,7 +92866,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,