@moxt-ai/mobius 0.0.187 → 0.0.189

package/dist/index.js

@@ -21435,24 +21435,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);
@@ -21463,8 +21467,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) {
@@ -21477,6 +21485,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,
@@ -21581,6 +21594,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,
@@ -23464,7 +23482,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;
@@ -23474,7 +23492,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;
   }
@@ -24131,6 +24149,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();
@@ -29838,6 +29859,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) => {
@@ -31960,6 +31990,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 createHash2 } 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 = createHash2("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;
@@ -32172,7 +32343,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;
@@ -32702,6 +32873,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);
@@ -32711,15 +32890,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);
     });
@@ -33669,6 +33842,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));
@@ -34743,14 +34921,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(methods4.agent.session.fork, async (context) => {
@@ -34845,14 +35023,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;
@@ -35815,7 +36025,7 @@ var OhMyPiAgentSpecification = class extends DirectAcpAgentDefinition {
 import { join as join11 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { chmod, copyFile, mkdir as mkdir4, mkdtemp as mkdtemp2, open as open4, realpath as realpath7, rename as rename3, rm as rm3, stat as stat6, writeFile as writeFile3 } from "node:fs/promises";
 import { delimiter as delimiter2, dirname as dirname3, isAbsolute as isAbsolute7, join as join10, relative as relative3, sep as sep3 } from "node:path";
@@ -35928,7 +36138,7 @@ function isContainedPath3(root, candidate) {
 }
 async function hashFile(path2, signal) {
   signal.throwIfAborted();
-  const digest = createHash2("sha256");
+  const digest = createHash3("sha256");
   const stream = createReadStream(path2, { signal });
   try {
     for await (const chunk of stream) {
@@ -37126,7 +37336,7 @@ async function discoverLocalAgentInventory(options) {
 }
 
 // src/storage/runtime-installation-store.ts
-import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir5, open as open5, readdir as readdir3, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname4, join as join16, resolve as resolve4 } from "node:path";
 var APPLICATION_ID_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){1,31}$/;
@@ -37262,7 +37472,7 @@ function installationId() {
   return `min_${randomUUID3().replaceAll("-", "")}`;
 }
 function channelIndexFileName(channelId) {
-  return `mci_${createHash3("sha256").update(channelId).digest("hex")}.json`;
+  return `mci_${createHash4("sha256").update(channelId).digest("hex")}.json`;
 }
 function decodeInstallationPointer(value) {
   if (!isRecord9(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {
@@ -37961,7 +38171,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
 import { join as join19 } from "node:path";
 import { styleText } from "node:util";
 
@@ -38747,7 +38957,7 @@ import { WebSocket as WebSocket2 } from "undici";
 import { WebSocket } from "undici";
 
 // src/prompt-artifact-resolver.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { fetch as fetch4 } from "undici";
 var ARTIFACT_SCHEME = "mobius-artifact:";
 var ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS = 2e4;
@@ -38885,7 +39095,7 @@ async function download(config2, command, reference, signal) {
       );
     }
     const bytes = await responseBytes(response, reference.byteLength, requestSignal);
-    if (createHash4("sha256").update(bytes).digest("hex") !== reference.sha256) {
+    if (createHash5("sha256").update(bytes).digest("hex") !== reference.sha256) {
       throw new PromptArtifactError(
         "artifact_integrity_failed",
         "The prompt artifact failed integrity validation"
@@ -39906,6 +40116,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);
 }
@@ -39945,7 +40163,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) {
@@ -40152,7 +40370,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
             })
@@ -40174,7 +40392,7 @@ function decodeHistory(thread, value, options) {
               locations: paths,
               name: "",
               output: "",
-              status: toolStatus(historyItem.status),
+              status: toolStatus2(historyItem.status),
               title: paths.join(", "),
               toolKind: "edit"
             })
@@ -40192,7 +40410,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"
             })
@@ -40210,7 +40428,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"
             })
@@ -40376,7 +40594,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"
             )
           );
@@ -40884,7 +41102,7 @@ var NativeSessionService = class {
 };
 
 // src/relay-connection/daemon-operation-state.ts
-import { createHash as createHash5, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID6 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS = 1024;
 function isTerminal(state) {
   return state === "succeeded" || state === "failed" || state === "cancelled";
@@ -40893,7 +41111,7 @@ var DaemonOperationState = class {
   #executions = /* @__PURE__ */ new Map();
   #terminalCount = 0;
   claimExecution = (commandId, sessionId, commandJson) => {
-    const commandHash = createHash5("sha256").update(commandJson).digest("hex");
+    const commandHash = createHash6("sha256").update(commandJson).digest("hex");
     const existing = this.#executions.get(commandId);
     if (existing !== void 0) {
       if (existing.sessionId !== sessionId || existing.commandHash !== commandHash) {
@@ -41115,7 +41333,7 @@ import { WebSocket as WebSocket5 } from "undici";
 import { WebSocket as WebSocket3 } from "undici";
 
 // src/agent-catalog/discover-agent-settings.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 
 // src/agent-catalog/agent-settings-base.ts
 var AgentSettingsConfigurationError = class extends Error {
@@ -41579,7 +41797,7 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
     unsupportedModelIds: modelEffort.unsupportedModelIds,
     valuesByModel: {}
   };
-  return createHash6("sha256").update(
+  return createHash7("sha256").update(
     JSON.stringify({
       adapterVersion: agent.kind === "acp-adapter-process" ? agent.adapterVersion : agent.agentVersion,
       agentId: agent.id,
@@ -41891,7 +42109,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
     });
@@ -41920,6 +42138,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 randomUUID7 } from "node:crypto";
@@ -42669,6 +42962,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;
@@ -43620,7 +43927,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     publishCatalog: async (installationSignal) => await publishAgentCatalog(config2, installationSignal),
     stateDirectory
   });
-  const channelHash = createHash7("sha256").update(config2.channelId).digest("hex");
+  const channelHash = createHash8("sha256").update(config2.channelId).digest("hex");
   const sessionDatabase = openAcpSessionDatabase(join19(stateDirectory, "sessions", `${channelHash}.sqlite`));
   let eventsV2;
   try {
@@ -43646,13 +43953,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,