@moxt-ai/mobius 0.0.187 → 0.0.189

package/dist/runtime.js

@@ -21409,24 +21409,28 @@ var decodeAcpSessionUpdateV2 = (value) => decode5(value, acpSessionUpdateV2Schem
 // ../protocol/src/session-live-history.ts
 var SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND = "session.live-history.v2.page.load";
 var SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND = "session.live-history.v2.page.loaded";
+var SESSION_PREVIEW_HISTORY_PAGE_LOAD_KIND = "session.preview-history.page.load";
+var SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND = "session.preview-history.page.loaded";
 var directoryIdentifier = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,2047}$/);
-var sessionLiveHistoryV2PageLoadSchema = external_exports.object({
+var pageLoadFields = {
   additionalDirectoryIds: external_exports.array(directoryIdentifier).max(16).readonly(),
   agentId: identifierStringSchema,
   bindingId: identifierStringSchema,
   cursor: external_exports.string().min(1).max(512).nullable(),
   directoryId: directoryIdentifier,
-  kind: external_exports.literal(SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND),
   eventLimit: external_exports.number().int().min(1).max(1e4),
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
-}).readonly();
-var sessionLiveHistoryV2PageLoadedSchema = external_exports.object({
+};
+var sessionLiveHistoryV2PageLoadSchema = external_exports.object({ ...pageLoadFields, kind: external_exports.literal(SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND) }).readonly();
+var sessionPreviewHistoryPageLoadSchema = external_exports.object({ ...pageLoadFields, kind: external_exports.literal(SESSION_PREVIEW_HISTORY_PAGE_LOAD_KIND) }).readonly();
+var pageLoadedFields = {
   events: nativeSessionEventsV2Schema,
-  kind: external_exports.literal(SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND),
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
-}).readonly();
+};
+var sessionLiveHistoryV2PageLoadedSchema = external_exports.object({ ...pageLoadedFields, kind: external_exports.literal(SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND) }).readonly();
+var sessionPreviewHistoryPageLoadedSchema = external_exports.object({ ...pageLoadedFields, kind: external_exports.literal(SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND) }).readonly();
 function decode6(schema, encoded) {
   try {
     const value = JSON.parse(encoded);
@@ -21437,8 +21441,12 @@ function decode6(schema, encoded) {
 }
 var decodeSessionLiveHistoryV2PageLoad = (encoded) => decode6(sessionLiveHistoryV2PageLoadSchema, encoded);
 var decodeSessionLiveHistoryV2PageLoaded = (encoded) => decode6(sessionLiveHistoryV2PageLoadedSchema, encoded);
+var decodeSessionPreviewHistoryPageLoad = (encoded) => decode6(sessionPreviewHistoryPageLoadSchema, encoded);
+var decodeSessionPreviewHistoryPageLoaded = (encoded) => decode6(sessionPreviewHistoryPageLoadedSchema, encoded);
 var encodeSessionLiveHistoryV2PageLoad = (value) => JSON.stringify(sessionLiveHistoryV2PageLoadSchema.parse(value));
 var encodeSessionLiveHistoryV2PageLoaded = (value) => JSON.stringify(sessionLiveHistoryV2PageLoadedSchema.parse(value));
+var encodeSessionPreviewHistoryPageLoad = (value) => JSON.stringify(sessionPreviewHistoryPageLoadSchema.parse(value));
+var encodeSessionPreviewHistoryPageLoaded = (value) => JSON.stringify(sessionPreviewHistoryPageLoadedSchema.parse(value));
 
 // ../protocol/src/daemon-transport.ts
 function defineMessageSignature(kind, encoder, decoder) {
@@ -21451,6 +21459,11 @@ function defineMessageSignature(kind, encoder, decoder) {
   };
 }
 var serviceToDaemonSignatures = {
+  [SESSION_PREVIEW_HISTORY_PAGE_LOAD_KIND]: defineMessageSignature(
+    SESSION_PREVIEW_HISTORY_PAGE_LOAD_KIND,
+    encodeSessionPreviewHistoryPageLoad,
+    decodeSessionPreviewHistoryPageLoad
+  ),
   [AGENT_INSTALL_CANCEL_KIND]: defineMessageSignature(
     AGENT_INSTALL_CANCEL_KIND,
     encodeAgentInstallCancelCommand,
@@ -21555,6 +21568,11 @@ function decodeServiceToDaemonMessage(encoded) {
   return signature.decoder(encoded);
 }
 var daemonToServiceSignatures = {
+  [SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND]: defineMessageSignature(
+    SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND,
+    encodeSessionPreviewHistoryPageLoaded,
+    decodeSessionPreviewHistoryPageLoaded
+  ),
   [SESSION_CONFIG_UPDATED_KIND]: defineMessageSignature(
     SESSION_CONFIG_UPDATED_KIND,
     encodeSessionConfigUpdatedEvent,
@@ -23314,6 +23332,11 @@ var threadLifecycleResponseSchema = external_exports.object({
   serviceTier: boundedText(256).nullish(),
   thread: external_exports.object({ id: boundedText(256), turns: threadTurnsSchema })
 });
+var CODEX_HISTORY_TURN_PAGE_LIMIT = 20;
+var threadTurnsPageSchema = external_exports.object({
+  data: external_exports.array(threadTurnSchema).max(CODEX_HISTORY_TURN_PAGE_LIMIT),
+  nextCursor: boundedText(1024).nullish()
+});
 var threadResumeResponseSchema = threadLifecycleResponseSchema;
 var threadForkResponseSchema = threadLifecycleResponseSchema;
 var threadTitleSchema = external_exports.string().transform((value) => value.slice(0, 500));
@@ -24388,14 +24411,14 @@ var CodexAcpAgent = class {
       const resumed = threadResumeResponseSchema.parse(
         await this.#appServer.request(
           "thread/resume",
-          { cwd: context.params.cwd, excludeTurns: false, threadId: context.params.sessionId },
+          { cwd: context.params.cwd, excludeTurns: true, threadId: context.params.sessionId },
           AbortSignal.any([context.signal, AbortSignal.timeout(APPROVAL_TIMEOUT_MILLISECONDS2)])
         )
       );
       this.#nativeSessionId = resumed.thread.id;
       this.#settings.selectRestoredThread(resumed);
       await this.#settings.probeCollaborationMode(this.#nativeSessionId, context.signal);
-      await this.#replayHistory(resumed.thread.turns);
+      await this.#replaySavedHistory(context.signal);
       await this.#emitAvailableCommands();
       return { configOptions: this.#settings.configOptions() };
     }).onRequest(methods.agent.session.fork, async (context) => {
@@ -24490,14 +24513,46 @@ var CodexAcpAgent = class {
     }
     return this.#closePromise;
   };
-  /**
-   * Reads the model catalog once per app-server. A failure leaves the catalog empty, which costs
-   * the Run settings panel its model selector; it must not cost the conversation itself, so the
-   * turn lifecycle continues without settings rather than failing initialization.
-   */
-  #replayHistory = async (turns) => {
-    for (const turn of turns ?? []) {
+  // ACP load requires chronological replay. Resume only restores execution;
+  // native pages supply history without a single full-transcript response.
+  #replaySavedHistory = async (signal) => {
+    const deadline = AbortSignal.any([signal, AbortSignal.timeout(6e4)]);
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor = null;
+    for (; ; ) {
+      deadline.throwIfAborted();
+      const page = threadTurnsPageSchema.parse(
+        await this.#appServer.request(
+          "thread/turns/list",
+          {
+            threadId: this.#nativeSessionId,
+            limit: CODEX_HISTORY_TURN_PAGE_LIMIT,
+            sortDirection: "asc",
+            itemsView: "full",
+            ...cursor === null ? {} : { cursor }
+          },
+          deadline
+        )
+      );
+      await this.#replayHistory(page.data, deadline);
+      if (page.nextCursor == null) {
+        return;
+      }
+      if (page.data.length === 0 || seenCursors.has(page.nextCursor)) {
+        throw new AcpExecutionError(
+          "Codex repeated a history page cursor",
+          {},
+          "invalid_native_session_response"
+        );
+      }
+      seenCursors.add(page.nextCursor);
+      cursor = page.nextCursor;
+    }
+  };
+  #replayHistory = async (turns, signal) => {
+    for (const turn of turns) {
       for (const rawItem of turn.items) {
+        signal.throwIfAborted();
         const item = decodeThreadItem(rawItem);
         if (item === null) {
           continue;
@@ -26877,7 +26932,7 @@ function createDaemonConfig(connection, agents = [], installableAgents = [], loc
 }
 
 // src/run-daemon.ts
-import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID8 } from "node:crypto";
 import { join as join18 } from "node:path";
 import { styleText } from "node:util";
 
@@ -27772,7 +27827,7 @@ var AcpActivity = class _AcpActivity {
   toolKind;
   content;
   detail;
-  constructor(activityId, activityType, input2, locations, name2, output2, sequence, status, title2, toolKind, content = [], detail = captureActivityDetail(content, input2, output2)) {
+  constructor(activityId, activityType, input2, locations, name2, output2, sequence, status, title2, toolKind2, content = [], detail = captureActivityDetail(content, input2, output2)) {
     this.activityId = activityId;
     this.activityType = activityType;
     this.input = input2;
@@ -27782,7 +27837,7 @@ var AcpActivity = class _AcpActivity {
     this.sequence = sequence;
     this.status = status;
     this.title = title2;
-    this.toolKind = toolKind;
+    this.toolKind = toolKind2;
     this.content = content;
     this.detail = detail;
   }
@@ -28439,6 +28494,9 @@ function sessionConfigProtocolForAgent(_agentId) {
 }
 
 // src/acp/session-contracts.ts
+var acpNativeHistoryReader = {
+  access: () => ({ kind: "acp" })
+};
 var NullAcpSessionObserver = class {
   onSessionEventV2 = (_sessionId, _event, _position) => Promise.resolve();
   onCommands = () => Promise.resolve();
@@ -34089,6 +34147,15 @@ function eventPage(sessionGenerationId, eventCount, eventLimit, cursor, read) {
     truncated: startPosition > 0
   };
 }
+function pageAcpSessionEventsV2(sessionGenerationId, events, eventLimit, cursor) {
+  return eventPage(
+    sessionGenerationId,
+    events.length,
+    eventLimit,
+    cursor,
+    (startPosition, endPosition) => events.slice(startPosition - 1, endPosition)
+  );
+}
 var MemoryAcpSessionEventStoreV2 = class {
   #events = /* @__PURE__ */ new Map();
   #session = (sessionId) => {
@@ -36211,6 +36278,147 @@ 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/native-sessions/native-history-events-v2.ts
+import { createHash as createHash3 } from "node:crypto";
+function contentBlock(content) {
+  switch (content.type) {
+    case "text":
+      return { text: content.text, type: "text" };
+    case "image":
+      return {
+        data: content.data,
+        mimeType: content.mimeType,
+        type: "image",
+        ...content.uri.length === 0 ? {} : { uri: content.uri }
+      };
+    case "resource_link":
+      return {
+        name: content.name.length === 0 ? content.uri : content.name,
+        type: "resource_link",
+        uri: content.uri,
+        ...content.mimeType.length === 0 ? {} : { mimeType: content.mimeType }
+      };
+    case "resource":
+      return {
+        resource: content.text.length > 0 ? {
+          text: content.text,
+          uri: content.uri,
+          ...content.mimeType.length === 0 ? {} : { mimeType: content.mimeType }
+        } : {
+          blob: content.data,
+          uri: content.uri,
+          ...content.mimeType.length === 0 ? {} : { mimeType: content.mimeType }
+        },
+        type: "resource"
+      };
+    case "diff":
+    case "terminal":
+    case "video":
+      return null;
+    default: {
+      const unhandled = content.type;
+      throw new Error(`Unknown native history content: ${String(unhandled)}`);
+    }
+  }
+}
+function toolContent2(content) {
+  if (content.type === "diff") {
+    return {
+      newText: content.newText,
+      path: content.path,
+      type: "diff",
+      ...content.oldText.length === 0 ? {} : { oldText: content.oldText }
+    };
+  }
+  if (content.type === "terminal") {
+    return { terminalId: content.terminalId, type: "terminal" };
+  }
+  const block = contentBlock(content);
+  return block === null ? null : { content: block, type: "content" };
+}
+function toolKind(value) {
+  switch (value) {
+    case "read":
+    case "edit":
+    case "delete":
+    case "move":
+    case "search":
+    case "execute":
+    case "think":
+    case "fetch":
+    case "switch_mode":
+    case "other":
+      return value;
+    default:
+      return "other";
+  }
+}
+function toolStatus(value) {
+  switch (value) {
+    case "pending":
+      return "pending";
+    case "running":
+    case "in_progress":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    default:
+      return "failed";
+  }
+}
+function activityEvent(activity2) {
+  const content = activity2.content.flatMap((item) => {
+    const converted = toolContent2(item);
+    return converted === null ? [] : [converted];
+  });
+  return {
+    payload: {
+      content,
+      kind: toolKind(activity2.toolKind),
+      locations: activity2.locations.map((path2) => ({ path: path2 })),
+      rawInput: activity2.input,
+      rawOutput: activity2.output,
+      sessionUpdate: "tool_call",
+      status: toolStatus(activity2.status),
+      title: activity2.title,
+      toolCallId: activity2.activityId,
+      ...activity2.name.length === 0 ? {} : { name: activity2.name }
+    },
+    type: "acp"
+  };
+}
+function contentEvent(sessionUpdate, messageId, content) {
+  return { payload: { content, messageId, sessionUpdate }, type: "acp" };
+}
+function historyEvents(history) {
+  return history.messages.flatMap((message, index2) => {
+    const messageId = `native-history-${index2.toString()}`;
+    const sessionUpdate = message.role === "user" ? "user_message_chunk" : "agent_message_chunk";
+    const images = (message.images ?? []).map(
+      (image) => contentEvent(sessionUpdate, messageId, {
+        data: image.data,
+        mimeType: image.mimeType,
+        type: "image"
+      })
+    );
+    const text2 = message.text.length === 0 ? [] : [contentEvent(sessionUpdate, messageId, { text: message.text, type: "text" })];
+    if (message.role === "user") {
+      return [...images, ...text2];
+    }
+    const activities = message.activities.map(activityEvent);
+    const content = message.content.flatMap((item) => {
+      const converted = contentBlock(item);
+      return converted === null ? [] : [contentEvent(sessionUpdate, messageId, converted)];
+    });
+    return [...activities, ...content, ...images, ...text2];
+  });
+}
+function nativeHistoryEventsV2(nativeSessionId, history, eventLimit, cursor) {
+  const events = historyEvents(history);
+  const generationId = createHash3("sha256").update(nativeSessionId).update("\0").update(JSON.stringify(events)).digest("hex");
+  return pageAcpSessionEventsV2(generationId, events, eventLimit, cursor);
+}
+
 // src/acp/process-capacity.ts
 var AcpProcessCapacityLease = class {
   #releaseCapacity;
@@ -36423,7 +36631,7 @@ var AgentRuntimeManager = class {
   #onSessionStatusChanged;
   #contentExternalizer;
   #observer;
-  constructor(observer = new NullAcpSessionObserver(), store = new MemoryAcpSessionStore(), nativeHistoryReader = null, sessionIdentity = "assigned", onSessionStatusChanged = () => void 0, contentExternalizer = new AcpContentExternalizer(new UnretainedExternalContentStore())) {
+  constructor(observer = new NullAcpSessionObserver(), store = new MemoryAcpSessionStore(), nativeHistoryReader = acpNativeHistoryReader, sessionIdentity = "assigned", onSessionStatusChanged = () => void 0, contentExternalizer = new AcpContentExternalizer(new UnretainedExternalContentStore())) {
     this.#observer = observer;
     this.#store = store;
     this.#nativeHistoryReader = nativeHistoryReader;
@@ -36953,6 +37161,14 @@ var AgentRuntimeManager = class {
     }
     this.#nativeOperations.add(key);
     try {
+      const historyAccess = this.#nativeHistoryReader.access(options2);
+      if (historyAccess.kind === "direct") {
+        const history = await historyAccess.read(nativeSessionId, () => null);
+        if (history.status === "unavailable") {
+          throw new AcpExecutionError(history.cause.message, {}, history.cause.code);
+        }
+        return nativeHistoryEventsV2(nativeSessionId, history, eventLimit, cursor);
+      }
       return await this.#queryProcesses.previewEventsV2(options2, nativeSessionId, eventLimit, cursor);
     } finally {
       this.#nativeOperations.delete(key);
@@ -36962,15 +37178,9 @@ var AgentRuntimeManager = class {
     return await this.#executionProcesses.use(options2.sessionId, async () => {
       const runtime = await this.ensureSession(options2);
       const stored = this.#store.read(options2.sessionId);
-      if (stored instanceof FoundAcpStoredSession && this.#nativeHistoryReader !== null) {
-        const history = await this.#nativeHistoryReader.read(
-          options2,
-          stored.session.nativeSessionId,
-          runtime.nativeHistoryTurn
-        );
-        if (history !== null) {
-          return history;
-        }
+      const historyAccess = this.#nativeHistoryReader.access(options2);
+      if (stored instanceof FoundAcpStoredSession && historyAccess.kind === "direct") {
+        return await historyAccess.read(stored.session.nativeSessionId, runtime.nativeHistoryTurn);
       }
       return await runtime.loadHistory(options2.signal);
     });
@@ -37863,7 +38073,7 @@ import { WebSocket as WebSocket2 } from "undici";
 import { WebSocket } from "undici";
 
 // src/prompt-artifact-resolver.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { fetch as fetch3 } from "undici";
 var ARTIFACT_SCHEME = "mobius-artifact:";
 var ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS = 2e4;
@@ -38001,7 +38211,7 @@ async function download(config2, command, reference, signal) {
       );
     }
     const bytes = await responseBytes(response, reference.byteLength, requestSignal);
-    if (createHash3("sha256").update(bytes).digest("hex") !== reference.sha256) {
+    if (createHash4("sha256").update(bytes).digest("hex") !== reference.sha256) {
       throw new PromptArtifactError(
         "artifact_integrity_failed",
         "The prompt artifact failed integrity validation"
@@ -39022,6 +39232,14 @@ var historyItemSchema = external_exports.discriminatedUnion("type", [
   dynamicToolCallSchema,
   planSchema
 ]);
+var CodexHistoryResponseError = class extends Error {
+  code;
+  constructor(response) {
+    super(response.message);
+    this.code = response.code;
+    this.name = "CodexHistoryResponseError";
+  }
+};
 function bounded(value, maximum) {
   return value.slice(0, maximum);
 }
@@ -39061,7 +39279,7 @@ function formatted(value) {
   }
   return JSON.stringify(value) ?? "";
 }
-function toolStatus(status) {
+function toolStatus2(status) {
   return status === "inProgress" ? "running" : status === "completed" ? "completed" : "failed";
 }
 function diffDisplayContent(path2, newText) {
@@ -39268,7 +39486,7 @@ function decodeHistory(thread, value, options) {
                 formatted_output: historyItem.aggregatedOutput ?? "",
                 ...historyItem.exitCode == null ? {} : { exit_code: historyItem.exitCode }
               }),
-              status: toolStatus(historyItem.status),
+              status: toolStatus2(historyItem.status),
               title: historyItem.command,
               toolKind: action
             })
@@ -39290,7 +39508,7 @@ function decodeHistory(thread, value, options) {
               locations: paths,
               name: "",
               output: "",
-              status: toolStatus(historyItem.status),
+              status: toolStatus2(historyItem.status),
               title: paths.join(", "),
               toolKind: "edit"
             })
@@ -39308,7 +39526,7 @@ function decodeHistory(thread, value, options) {
               locations: [],
               name: historyItem.tool,
               output: formatted(historyItem.error ?? historyItem.result),
-              status: toolStatus(historyItem.status),
+              status: toolStatus2(historyItem.status),
               title: `${historyItem.server}/${historyItem.tool}`,
               toolKind: "other"
             })
@@ -39326,7 +39544,7 @@ function decodeHistory(thread, value, options) {
               locations: [],
               name: historyItem.tool,
               output: formatted(historyItem.contentItems),
-              status: toolStatus(historyItem.status),
+              status: toolStatus2(historyItem.status),
               title: historyItem.namespace == null ? historyItem.tool : `${historyItem.namespace}/${historyItem.tool}`,
               toolKind: "other"
             })
@@ -39492,7 +39710,7 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
           fail(
             new AcpExecutionError(
               "Saved Codex history could not be read.",
-              { cause: message.error },
+              { cause: new CodexHistoryResponseError(message.error) },
               "native_history_unavailable"
             )
           );
@@ -40000,7 +40218,7 @@ var NativeSessionService = class {
 };
 
 // src/relay-connection/daemon-operation-state.ts
-import { createHash as createHash4, randomUUID as randomUUID5 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS = 1024;
 function isTerminal(state) {
   return state === "succeeded" || state === "failed" || state === "cancelled";
@@ -40009,7 +40227,7 @@ var DaemonOperationState = class {
   #executions = /* @__PURE__ */ new Map();
   #terminalCount = 0;
   claimExecution = (commandId, sessionId, commandJson) => {
-    const commandHash = createHash4("sha256").update(commandJson).digest("hex");
+    const commandHash = createHash5("sha256").update(commandJson).digest("hex");
     const existing = this.#executions.get(commandId);
     if (existing !== void 0) {
       if (existing.sessionId !== sessionId || existing.commandHash !== commandHash) {
@@ -40231,7 +40449,7 @@ import { WebSocket as WebSocket5 } from "undici";
 import { WebSocket as WebSocket3 } from "undici";
 
 // src/agent-catalog/discover-agent-settings.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 
 // src/agent-catalog/agent-settings-base.ts
 var AgentSettingsConfigurationError = class extends Error {
@@ -40695,7 +40913,7 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
     unsupportedModelIds: modelEffort.unsupportedModelIds,
     valuesByModel: {}
   };
-  return createHash5("sha256").update(
+  return createHash6("sha256").update(
     JSON.stringify({
       adapterVersion: agent.kind === "acp-adapter-process" ? agent.adapterVersion : agent.agentVersion,
       agentId: agent.id,
@@ -41007,7 +41225,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
         },
         queuedPromptRequests: recovery.queuedPromptRequests
       },
-      kind: "session.live-history.v2.page.loaded",
+      kind: SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND,
       requestId: command.requestId,
       sessionId: command.sessionId
     });
@@ -41036,6 +41254,81 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
     }
   }
 }
+async function executeSessionPreviewHistoryPageLoad(socket, command, config2, directories, audit, diagnostics, sessions, eventLogV2, signal) {
+  try {
+    const resolved = await resolveSessionDirectories(
+      directories,
+      config2.bindingId,
+      command.directoryId,
+      command.additionalDirectoryIds,
+      signal
+    );
+    const replay = await sessions.previewNativeSessionEventsV2(
+      {
+        additionalDirectories: resolved.additionalDirectories,
+        agent: config2.catalog.find(command.agentId),
+        cwd: resolved.cwd,
+        sessionId: command.sessionId,
+        signal
+      },
+      command.sessionId,
+      command.eventLimit,
+      command.cursor
+    );
+    signal.throwIfAborted();
+    const events = replay.events.map(
+      (event, index2) => eventLogV2.event(
+        command.sessionId,
+        replay.sessionGenerationId,
+        replay.startPosition + index2,
+        event,
+        "1970-01-01T00:00:00.000Z"
+      )
+    );
+    const tailCursor = events.at(-1)?.eventId ?? "";
+    audit.record({
+      commandId: command.requestId,
+      event: "session_event_log_v2_loaded",
+      sessionId: command.sessionId
+    });
+    send(socket, {
+      events: {
+        events: {
+          events,
+          nextCursor: replay.nextCursor,
+          sessionGenerationId: replay.sessionGenerationId,
+          tailCursor,
+          truncated: replay.truncated,
+          version: 2
+        },
+        queuedPromptRequests: []
+      },
+      kind: SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND,
+      requestId: command.requestId,
+      sessionId: command.sessionId
+    });
+  } catch (error62) {
+    if (!signal.aborted) {
+      diagnostics.daemonDiagnostic(
+        "session_history_v2_load_failed",
+        command.requestId,
+        {
+          agentId: command.agentId,
+          code: operationErrorCode(error62),
+          sessionId: command.sessionId
+        },
+        error62
+      );
+      audit.record({
+        commandId: command.requestId,
+        details: { agentId: command.agentId, code: operationErrorCode(error62) },
+        event: "session_history_v2_load_failed",
+        sessionId: command.sessionId
+      });
+      reportOperationFailure(socket, command.requestId, command.sessionId, error62);
+    }
+  }
+}
 
 // src/acp/session-config/apply-session-configuration.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
@@ -41785,6 +42078,20 @@ function createDaemonCommandHandler({
         );
         return;
       }
+      if (kind === SESSION_PREVIEW_HISTORY_PAGE_LOAD_KIND) {
+        void executeSessionPreviewHistoryPageLoad(
+          socket,
+          message,
+          config2,
+          directories,
+          audit,
+          diagnostics,
+          sessions,
+          eventLogV2,
+          signal
+        );
+        return;
+      }
       if (kind === NATIVE_SESSION_CANCEL_KIND) {
         nativeRequestHandler.cancel(message);
         return;
@@ -42756,7 +43063,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     publishCatalog: async (installationSignal) => await publishAgentCatalog(config2, installationSignal),
     stateDirectory
   });
-  const channelHash = createHash6("sha256").update(config2.channelId).digest("hex");
+  const channelHash = createHash7("sha256").update(config2.channelId).digest("hex");
   const sessionDatabase = openAcpSessionDatabase(join18(stateDirectory, "sessions", `${channelHash}.sqlite`));
   let eventsV2;
   try {
@@ -42782,13 +43089,16 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     }, eventLogV2.record),
     sessionStore,
     {
-      read: async (options2, nativeSessionId, nativeTurn) => options2.agent.id === "codex" ? (await readCodexFullHistory(
-        options2.agent,
-        options2.cwd,
-        nativeSessionId,
-        options2.signal,
-        nativeTurn
-      )).history : null
+      access: (options2) => options2.agent.id === "codex" ? {
+        kind: "direct",
+        read: async (nativeSessionId, nativeTurn) => (await readCodexFullHistory(
+          options2.agent,
+          options2.cwd,
+          nativeSessionId,
+          options2.signal,
+          nativeTurn
+        )).history
+      } : { kind: "acp" }
     },
     "native",
     publisher.publishStatus,
@@ -42964,7 +43274,7 @@ import { basename as basename6, resolve as resolve7 } from "node:path";
 import { fetch as fetch4 } from "undici";
 
 // src/storage/runtime-installation-store.ts
-import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir5, open as open5, readdir as readdir4, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname6, join as join19, resolve as resolve6 } from "node:path";
 var APPLICATION_ID_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){1,31}$/;
@@ -43100,7 +43410,7 @@ function installationId() {
   return `min_${randomUUID9().replaceAll("-", "")}`;
 }
 function channelIndexFileName(channelId) {
-  return `mci_${createHash7("sha256").update(channelId).digest("hex")}.json`;
+  return `mci_${createHash8("sha256").update(channelId).digest("hex")}.json`;
 }
 function decodeInstallationPointer(value) {
   if (!isRecord10(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {