replicas-engine 0.1.654 → 0.1.656

package/README.md

@@ -28,6 +28,7 @@ Chats:
 - `GET /chats/:chatId`
 - `DELETE /chats/:chatId`
 - `GET /chats/:chatId/history`
+- `GET /chats/:chatId/history-page?limit=<count>` (`limit` required)
 - `GET /chats/:chatId/slash-commands`
 - `POST /chats/:chatId/messages`
 - `POST /chats/:chatId/interrupt`

package/dist/src/{chunk-DDFRCI5Q.js → chunk-KCMDTZ5H.js}

@@ -758,7 +758,7 @@ var sendChatMessageRequestSchema = z3.object({
   ]).optional()
 }).passthrough();
 function isChatMessageSender(value) {
-  return isRecord(value) && typeof value.senderUserId === "string" && typeof value.senderEmail === "string" && typeof value.recordedAt === "string";
+  return isRecord(value) && (value.messageId === void 0 || typeof value.messageId === "string") && typeof value.senderUserId === "string" && typeof value.senderEmail === "string" && typeof value.recordedAt === "string";
 }
 function normalizeCodexAspTranscriptStatus(status, failed = false) {
   if (failed || status === "failed" || status === "declined") return "failed";
@@ -881,6 +881,27 @@ function applyCodexAspTranscriptDelta(current, delta) {
     turns
   };
 }
+function isLatestChatHistoryPage(params) {
+  return params.beforeCursor === void 0 && params.beforeEvent === void 0 && params.beforeTurn === void 0;
+}
+function getChatHistoryPageSenders(senders, params) {
+  return isLatestChatHistoryPage(params) ? senders : senders?.filter((sender) => sender.messageId);
+}
+function parseChatHistoryCursor(value) {
+  if (value === void 0) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord(parsed) || parsed.mode !== "range" && parsed.mode !== "legacy") return void 0;
+    const valid = (part) => part === null || typeof part === "string";
+    if (!valid(parsed.events) || !valid(parsed.turns)) return void 0;
+    return { mode: parsed.mode, events: parsed.events, turns: parsed.turns };
+  } catch {
+    return void 0;
+  }
+}
+function createChatHistoryCursor(cursor, mode = "range") {
+  return cursor.events === null && cursor.turns === null ? null : JSON.stringify({ mode, ...cursor });
+}
 function chatHistoryPageParamsFromQuery(query) {
   const parse = (value) => {
     if (value === void 0) return void 0;
@@ -890,7 +911,8 @@ function chatHistoryPageParamsFromQuery(query) {
   return {
     limit: parse(query.limit),
     beforeEvent: parse(query.beforeEvent),
-    beforeTurn: parse(query.beforeTurn)
+    beforeTurn: parse(query.beforeTurn),
+    beforeCursor: query.beforeCursor || void 0
   };
 }
 function getChatHistoryPageWindow(totalItems, limit, before) {
@@ -5723,6 +5745,105 @@ var EMAIL_KEYS = [
 var MANUAL_EMAIL_TEMPLATE_KEYS = ["product_update"];
 var EMAIL_TEMPLATE_KEYS = [...EMAIL_KEYS, ...MANUAL_EMAIL_TEMPLATE_KEYS];
 
+// ../shared/src/chat-transcript-pages.ts
+var decoder = new TextDecoder("utf-8", { fatal: true });
+var MAX_SOURCE_PAGE_BYTES = 4 * 1024 * 1024;
+var SOURCE_RANGE_BYTES = 256 * 1024;
+async function readExactRange(readRange, startByte, endByte, error) {
+  const bytes = await readRange(startByte, endByte);
+  if (bytes.length !== endByte - startByte) throw new Error(error);
+  return bytes;
+}
+async function readJsonlPage(args) {
+  let endByte = args.size;
+  if (args.before === null) endByte = 0;
+  else if (args.before !== void 0) {
+    endByte = /^(0|[1-9]\d*)$/.test(args.before) ? Number(args.before) : Number.NaN;
+  }
+  if (!Number.isSafeInteger(endByte) || endByte < 0 || endByte > args.size || !Number.isSafeInteger(args.limit) || args.limit < 1) {
+    throw new RangeError("Invalid JSONL page");
+  }
+  let startByte = endByte;
+  let bytes = new Uint8Array();
+  let items = [];
+  while (startByte > 0 && items.length < args.limit && (endByte - startByte < MAX_SOURCE_PAGE_BYTES || bytes.indexOf(10) === -1)) {
+    const nextStartByte = Math.max(0, startByte - SOURCE_RANGE_BYTES);
+    const chunk = await readExactRange(
+      args.readRange,
+      nextStartByte,
+      startByte,
+      "Incomplete JSONL page read"
+    );
+    const combined = new Uint8Array(chunk.length + bytes.length);
+    combined.set(chunk);
+    combined.set(bytes, chunk.length);
+    bytes = combined;
+    startByte = nextStartByte;
+    items = [];
+    let lineStart = 0;
+    for (let lineEnd = bytes.indexOf(10); lineEnd !== -1; lineEnd = bytes.indexOf(10, lineStart)) {
+      if (!(startByte > 0 && lineStart === 0)) {
+        try {
+          const item = args.parse(JSON.parse(decoder.decode(bytes.subarray(lineStart, lineEnd))));
+          if (item !== void 0) items.push({ item, startByte: startByte + lineStart });
+        } catch {
+        }
+      }
+      lineStart = lineEnd + 1;
+    }
+  }
+  const selected = items.slice(-args.limit);
+  const firstCompleteLine = bytes.indexOf(10) + 1;
+  let before = 0;
+  if (selected.length === args.limit) before = selected[0].startByte;
+  else if (startByte > 0) before = startByte + firstCompleteLine;
+  return {
+    items: selected.map(({ item }) => item),
+    before: before > 0 ? String(before) : null
+  };
+}
+function parseChatTranscriptHistoryIndex(value) {
+  if (!isRecord(value) || value.version !== 2 || !isNonNegativeInteger(value.sourceSize)) return void 0;
+  if (value.codexAspTranscript === void 0) {
+    return { version: 2, sourceSize: value.sourceSize };
+  }
+  if (!isRecord(value.codexAspTranscript) || typeof value.codexAspTranscript.threadId !== "string" || typeof value.codexAspTranscript.updatedAt !== "string" || !isNonNegativeInteger(value.codexAspTranscript.size)) return void 0;
+  return {
+    version: 2,
+    sourceSize: value.sourceSize,
+    codexAspTranscript: {
+      threadId: value.codexAspTranscript.threadId,
+      updatedAt: value.codexAspTranscript.updatedAt,
+      size: value.codexAspTranscript.size
+    }
+  };
+}
+function getChatTranscriptHistorySize(index) {
+  return index.codexAspTranscript?.size ?? 0;
+}
+function createChatTranscriptPages(sourceBytes) {
+  const history = parseAgentEventJsonlWithCodexAspTranscript(new TextDecoder("utf-8", { fatal: true }).decode(sourceBytes));
+  const bytes = new TextEncoder().encode(history.transcript?.turns.length ? `${history.transcript.turns.map((turn) => JSON.stringify(turn)).join("\n")}
+` : "");
+  return {
+    bytes,
+    index: {
+      version: 2,
+      sourceSize: sourceBytes.byteLength,
+      ...history.transcript ? {
+        codexAspTranscript: {
+          threadId: history.transcript.threadId,
+          updatedAt: history.transcript.updatedAt,
+          size: bytes.byteLength
+        }
+      } : {}
+    }
+  };
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
 // ../shared/src/object-store/types.ts
 var MEDIA_KIND = {
   IMAGE: "image",
@@ -5737,8 +5858,9 @@ function normalizeChatMessageSenders(value) {
   if (!Array.isArray(value)) return void 0;
   const senders = value.flatMap((sender) => {
     if (!isChatMessageSender(sender)) return [];
-    const { senderUserId, senderEmail, senderDisplayName, senderAvatarUrl, recordedAt } = sender;
+    const { messageId, senderUserId, senderEmail, senderDisplayName, senderAvatarUrl, recordedAt } = sender;
     return [{
+      ...typeof messageId === "string" ? { messageId } : {},
       senderUserId,
       senderEmail,
       ...typeof senderDisplayName === "string" ? { senderDisplayName } : {},
@@ -5760,6 +5882,7 @@ function normalizeChatTranscriptMetadata(value) {
     parentChatId,
     deletedAt,
     senders,
+    historyIndex,
     captureId,
     captureReason,
     sha256
@@ -5774,6 +5897,8 @@ function normalizeChatTranscriptMetadata(value) {
   if (typeof deletedAt === "string" || deletedAt === null) metadata.deletedAt = deletedAt;
   const normalizedSenders = normalizeChatMessageSenders(senders);
   if (normalizedSenders) metadata.senders = normalizedSenders;
+  const parsedHistoryIndex = parseChatTranscriptHistoryIndex(historyIndex);
+  if (parsedHistoryIndex) metadata.historyIndex = parsedHistoryIndex;
   if (typeof captureId === "string") metadata.captureId = captureId;
   if (captureReason === "workspace_sleep") metadata.captureReason = captureReason;
   if (typeof sha256 === "string") metadata.sha256 = sha256;
@@ -5823,9 +5948,6 @@ var memoryGenerationManifestSchema = z6.object({
   rolloutSources: z6.record(z6.string(), z6.string()).optional()
 });
 
-// ../shared/src/chat-transcript-pages.ts
-var decoder = new TextDecoder("utf-8", { fatal: true });
-
 // ../shared/src/skill-registry.ts
 var SKILL_REGISTRY_MANIFEST_VERSION = 1;
 function isSkillRegistryManifest(value) {
@@ -6100,7 +6222,7 @@ var DEFAULT_CODEX_ARGS = [
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.654";
+var ENGINE_PACKAGE_VERSION = "0.1.656";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -6434,8 +6556,11 @@ export {
   isCodexAspTranscript,
   isCodexAspTranscriptDelta,
   applyCodexAspTranscriptDelta,
+  isLatestChatHistoryPage,
+  getChatHistoryPageSenders,
+  parseChatHistoryCursor,
+  createChatHistoryCursor,
   chatHistoryPageParamsFromQuery,
-  getChatHistoryPageWindow,
   paginateChatHistory,
   CODEX_AUTH_ENV_KEYS,
   codexAuthEnvFromResponse,
@@ -6464,6 +6589,10 @@ export {
   parseLatestCodexAspTranscriptTurn,
   parseAgentEvents,
   parseDisplayMessages,
+  isAgentBackendEvent,
+  readJsonlPage,
+  getChatTranscriptHistorySize,
+  createChatTranscriptPages,
   parseChatTranscriptArtifact,
   MEMORY_ROOT,
   MEMORY_SUMMARY_FILENAME,

package/dist/src/headless-agent.js

@@ -7,7 +7,7 @@ import {
   headlessAgentRequestSchema,
   putPresignedFile,
   recoverCompletedTurn
-} from "./chunk-DDFRCI5Q.js";
+} from "./chunk-KCMDTZ5H.js";
 
 // src/headless-agent.ts
 import { createHash } from "crypto";

package/dist/src/index.js

@@ -104,7 +104,9 @@ import {
   coerceBackgroundTaskPayload,
   coerceClaudeResultPayload,
   createAcceptedUserMessageEvent,
+  createChatHistoryCursor,
   createChatRequestSchema,
+  createChatTranscriptPages,
   createErrorResult,
   createProviderSlashCommand,
   createSuccessResult,
@@ -119,7 +121,8 @@ import {
   extractToolResultText,
   findGitCommitSignals,
   findPrMergeSignals,
-  getChatHistoryPageWindow,
+  getChatHistoryPageSenders,
+  getChatTranscriptHistorySize,
   getClaudeModelContextWindow,
   getCodexAspTurnResponse,
   getDeepseekAssistantMessageText,
@@ -132,6 +135,7 @@ import {
   gitIdentityConfigCommands,
   hasChatStarted,
   imageContentToUserMessageImages,
+  isAgentBackendEvent,
   isAgentChatMcpActivityRecord,
   isAgentChatSkillActivityRecord,
   isAgentChatTurnActivityRecord,
@@ -143,6 +147,7 @@ import {
   isCodexAuthError,
   isDefaultChat,
   isGitHubUrl,
+  isLatestChatHistoryPage,
   isRecord,
   isSkillRegistryManifest,
   isTerminalBackgroundTaskStatus,
@@ -158,6 +163,7 @@ import {
   paginateEngineLogContent,
   parseAgentEventJsonlWithCodexAspTranscript,
   parseAgentEvents,
+  parseChatHistoryCursor,
   parseChatTranscriptArtifact,
   parseCodeHostPrUrl,
   parseDisplayMessages,
@@ -169,6 +175,7 @@ import {
   percentage,
   putPresignedFile,
   raceWithTimeout,
+  readJsonlPage,
   readReplicasRuntimeEnv,
   recoverCompletedTurn,
   resolveWarmHookConfig,
@@ -176,7 +183,7 @@ import {
   serializeCanvasContentResponse,
   shellQuotePosix,
   stripAgentDiagnosticErrors
-} from "./chunk-DDFRCI5Q.js";
+} from "./chunk-KCMDTZ5H.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
@@ -4147,11 +4154,11 @@ var CodexHistoryFile = class {
   }
   filePath;
   writeLock = new AsyncLock();
-  eventLineIndex = null;
   /** Best-effort ordered append; failures must not disrupt the turn. */
   append(event) {
     void this.writeLock.run(
-      () => appendFile2(this.filePath, JSON.stringify(event) + "\n", "utf-8").catch((error) => {
+      () => appendFile2(this.filePath, `${JSON.stringify(event)}
+`).catch((error) => {
         console.error("[CodexHistoryFile] Failed to append event:", error);
       })
     );
@@ -4172,85 +4179,51 @@ var CodexHistoryFile = class {
   }
   async loadEventsPage(page) {
     if (page.limit === void 0) {
-      const history2 = await this.load();
-      return { events: history2.events, eventsStartIndex: 0, totalEvents: history2.events.length };
+      const history = await this.load();
+      return { events: history.events };
+    }
+    const cursor = parseChatHistoryCursor(page.beforeCursor);
+    if (page.beforeCursor !== void 0 && cursor?.mode !== "range") throw new RangeError("Invalid chat history cursor");
+    if (cursor?.events === null) {
+      return {
+        events: [],
+        beforeCursor: createChatHistoryCursor({
+          events: null,
+          turns: cursor.turns
+        })
+      };
     }
     let file;
     try {
       file = await open(this.filePath, "r");
     } catch (error) {
-      if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
-        console.error("[CodexHistoryFile] Failed to open history file:", error);
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return { events: [], beforeCursor: null };
       }
-      return { events: [], eventsStartIndex: 0, totalEvents: 0 };
+      throw error;
     }
     try {
-      const stats = await file.stat();
-      let index = this.eventLineIndex;
-      if (!index || index.size !== stats.size || index.mtimeMs !== stats.mtimeMs) {
-        const starts = stats.size > 0 ? [0] : [];
-        const buffer = Buffer.allocUnsafe(64 * 1024);
-        let position = 0;
-        while (position < stats.size) {
-          const { bytesRead: bytesRead2 } = await file.read(
-            buffer,
-            0,
-            Math.min(buffer.length, stats.size - position),
-            position
-          );
-          if (bytesRead2 === 0) break;
-          for (let offset = 0; offset < bytesRead2; offset += 1) {
-            const next = position + offset + 1;
-            if (buffer[offset] === 10 && next < stats.size) starts.push(next);
-          }
-          position += bytesRead2;
-        }
-        index = { size: stats.size, mtimeMs: stats.mtimeMs, starts };
-        this.eventLineIndex = index;
-      }
-      const totalEvents2 = index.starts.length;
-      const { startIndex: eventsStartIndex2, endIndex: eventsEnd2 } = getChatHistoryPageWindow(
-        totalEvents2,
-        page.limit,
-        page.beforeEvent
-      );
-      const startByte = index.starts[eventsStartIndex2] ?? index.size;
-      const endByte = index.starts[eventsEnd2] ?? index.size;
-      const content = Buffer.allocUnsafe(endByte - startByte);
-      let bytesRead = 0;
-      while (bytesRead < content.length) {
-        const result = await file.read(
-          content,
-          bytesRead,
-          content.length - bytesRead,
-          startByte + bytesRead
-        );
-        if (result.bytesRead === 0) break;
-        bytesRead += result.bytesRead;
-      }
-      if (bytesRead === content.length) {
-        const parsed = parseAgentEventJsonlWithCodexAspTranscript(content.toString("utf-8"));
-        if (!parsed.transcript && parsed.events.length === eventsEnd2 - eventsStartIndex2) {
-          return { events: parsed.events, eventsStartIndex: eventsStartIndex2, totalEvents: totalEvents2 };
-        }
-      }
-    } catch (error) {
-      console.error("[CodexHistoryFile] Failed to load history page:", error);
+      const result = await readJsonlPage({
+        size: (await file.stat()).size,
+        limit: page.limit,
+        before: cursor?.events,
+        readRange: async (startByte, endByte) => {
+          const bytes = Buffer.allocUnsafe(endByte - startByte);
+          const { bytesRead } = await file.read(bytes, 0, bytes.length, startByte);
+          return bytes.subarray(0, bytesRead);
+        },
+        parse: (value) => isAgentBackendEvent(value) && value.type !== CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE ? value : void 0
+      });
+      return {
+        events: result.items,
+        beforeCursor: createChatHistoryCursor({
+          events: result.before,
+          turns: cursor?.turns ?? null
+        })
+      };
     } finally {
       await file.close();
     }
-    const history = await this.load();
-    const totalEvents = history.events.length;
-    const { startIndex: eventsStartIndex, endIndex: eventsEnd } = getChatHistoryPageWindow(
-      totalEvents,
-      page.limit,
-      page.beforeEvent
-    );
-    return {
-      events: history.events.slice(eventsStartIndex, eventsEnd),
-      eventsStartIndex,
-      totalEvents
-    };
   }
 };
 
@@ -5721,6 +5694,7 @@ var DEFAULT_MODEL = DEFAULT_CODEX_MODEL;
 var THREAD_START_METHOD = "thread/start";
 var THREAD_RESUME_METHOD = "thread/resume";
 var THREAD_READ_METHOD = "thread/read";
+var THREAD_TURNS_LIST_METHOD = "thread/turns/list";
 var THREAD_GOAL_SET_METHOD = "thread/goal/set";
 var THREAD_GOAL_GET_METHOD = "thread/goal/get";
 var THREAD_GOAL_CLEAR_METHOD = "thread/goal/clear";
@@ -6049,8 +6023,11 @@ function formatTurnFailure(turn) {
   return parts.join(" ");
 }
 function threadToAspTranscript(thread) {
+  return turnsToAspTranscript(thread.id, timestampFromSeconds(thread.updatedAt), thread.turns);
+}
+function turnsToAspTranscript(threadId, updatedAt, sourceTurns) {
   let sequence = 0;
-  const turns = thread.turns.map((turn, index) => ({ turn, index })).sort((a, b) => (a.turn.startedAt ?? a.turn.completedAt ?? Number.MAX_SAFE_INTEGER) - (b.turn.startedAt ?? b.turn.completedAt ?? Number.MAX_SAFE_INTEGER) || a.index - b.index).map(({ turn }) => {
+  const turns = sourceTurns.map((turn, index) => ({ turn, index })).sort((a, b) => (a.turn.startedAt ?? a.turn.completedAt ?? Number.MAX_SAFE_INTEGER) - (b.turn.startedAt ?? b.turn.completedAt ?? Number.MAX_SAFE_INTEGER) || a.index - b.index).map(({ turn }) => {
     const startedAt = timestampFromSeconds(turn.startedAt);
     const completedAt = turn.completedAt === null ? null : timestampFromSeconds(turn.completedAt);
     const itemTimestamp = completedAt ?? startedAt;
@@ -6080,8 +6057,8 @@ function threadToAspTranscript(thread) {
     };
   });
   return {
-    threadId: thread.id,
-    updatedAt: timestampFromSeconds(thread.updatedAt),
+    threadId,
+    updatedAt,
     turns
   };
 }
@@ -6403,7 +6380,7 @@ async function readCodexAspThreadHistory(threadId) {
     }
   }
   for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+    if (!entry.isFile() || !entry.name.endsWith(".jsonl") || entry.name.endsWith(".pages.jsonl")) continue;
     const history = await new CodexHistoryFile(join19(CODEX_HISTORY_DIR, entry.name)).load();
     const transcript = history.transcriptsByThreadId.get(threadId);
     if (transcript) {
@@ -6452,7 +6429,6 @@ var CodexAspManager = class extends CodingAgentManager {
   activeTurnId = null;
   threadAttached = false;
   historyFile;
-  historyEvents = [];
   codexAspTranscript = null;
   lastEmittedTranscripts = /* @__PURE__ */ new Map();
   codexAspSequence = 0;
@@ -6474,9 +6450,12 @@ var CodexAspManager = class extends CodingAgentManager {
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
+    if (this.initialSessionId) {
+      this.currentThreadId = this.initialSessionId;
+      return;
+    }
     const replayed = await this.historyFile?.load();
     if (replayed) {
-      this.historyEvents.push(...replayed.events);
       if (replayed.transcript) {
         this.mergeTranscriptSnapshot(replayed.transcript);
       }
@@ -6565,51 +6544,87 @@ var CodexAspManager = class extends CodingAgentManager {
     return true;
   }
   async getHistory(page = {}) {
-    if (!this.currentThreadId) {
-      return paginateChatHistory({ thread_id: null, events: [], goal: null }, page);
-    }
-    if (this.codexAspTranscript?.threadId === this.currentThreadId) {
-      if (page.beforeEvent === void 0 && page.beforeTurn === void 0) {
-        try {
-          const host = await getCodexAspHost();
-          await this.refreshThreadGoal(host, this.currentThreadId);
-        } catch {
-        }
-      }
-      return paginateChatHistory({
-        thread_id: this.currentThreadId,
-        events: [...this.historyEvents],
-        codexAspTranscript: this.codexAspTranscript,
-        goal: this.currentGoal
-      }, page);
-    }
-    try {
+    await this.historyFile?.flush();
+    if (page.limit === void 0) {
+      const local = async () => {
+        const history = await this.historyFile?.load();
+        return {
+          thread_id: this.currentThreadId,
+          events: history?.events ?? [],
+          codexAspTranscript: this.currentThreadId ? history?.transcriptsByThreadId.get(this.currentThreadId) ?? null : null,
+          goal: this.currentGoal
+        };
+      };
+      if (!this.currentThreadId) return local();
+      return this.readFullNativeHistory().catch(local);
+    }
+    const events = await this.historyFile?.loadEventsPage(page) ?? { events: [], beforeCursor: null };
+    if (!this.currentThreadId) return { thread_id: null, ...events, goal: this.currentGoal };
+    const cursor = parseChatHistoryCursor(page.beforeCursor);
+    if (page.beforeCursor !== void 0 && cursor?.mode !== "range") throw new RangeError("Invalid chat history cursor");
+    let transcript = null;
+    let turnsBefore = null;
+    if (cursor?.turns !== null) {
       const host = await getCodexAspHost();
-      const [response] = await Promise.all([
-        host.client.request(
-          THREAD_READ_METHOD,
-          { threadId: this.currentThreadId, includeTurns: true }
-        ),
-        this.refreshThreadGoal(host, this.currentThreadId)
-      ]);
-      const transcript = this.mergeTranscriptSnapshot(threadToAspTranscript(response.thread));
-      if (transcript) {
-        transcript.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      }
-      return paginateChatHistory({
-        thread_id: this.currentThreadId,
-        events: [...this.historyEvents],
-        codexAspTranscript: transcript,
-        goal: this.currentGoal
-      }, page);
-    } catch {
+      if (page.beforeCursor === void 0) await this.refreshThreadGoal(host, this.currentThreadId);
+      const turns = await this.readNativeTurnsPage(page.limit, cursor?.turns, host);
+      transcript = turns.transcript;
+      turnsBefore = turns.before;
     }
-    return paginateChatHistory({
+    const eventCursor = parseChatHistoryCursor(events.beforeCursor ?? void 0);
+    return {
+      thread_id: this.currentThreadId,
+      ...events,
+      codexAspTranscript: transcript,
+      goal: this.currentGoal,
+      beforeCursor: createChatHistoryCursor({
+        events: eventCursor?.events ?? null,
+        turns: turnsBefore
+      })
+    };
+  }
+  async readFullNativeHistory() {
+    if (!this.currentThreadId) {
+      return { thread_id: null, events: [], goal: this.currentGoal };
+    }
+    const host = await getCodexAspHost();
+    const [response, history] = await Promise.all([
+      host.client.request(
+        THREAD_READ_METHOD,
+        { threadId: this.currentThreadId, includeTurns: true }
+      ),
+      this.historyFile?.load()
+    ]);
+    const transcript = this.mergeTranscriptSnapshot(threadToAspTranscript(response.thread));
+    return {
       thread_id: this.currentThreadId,
-      events: [...this.historyEvents],
-      codexAspTranscript: this.codexAspTranscript,
+      events: history?.events ?? [],
+      codexAspTranscript: transcript,
       goal: this.currentGoal
-    }, page);
+    };
+  }
+  async readNativeTurnsPage(limit, cursor, host) {
+    if (!this.currentThreadId) throw new Error("A thread is required for native turn pagination");
+    const response = await host.client.request(
+      THREAD_TURNS_LIST_METHOD,
+      {
+        threadId: this.currentThreadId,
+        cursor: cursor ?? null,
+        limit,
+        sortDirection: "desc",
+        itemsView: "full"
+      }
+    );
+    const transcript = turnsToAspTranscript(
+      this.currentThreadId,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      response.data
+    );
+    if (cursor === void 0) {
+      this.codexAspTranscript = transcript;
+      this.syncTranscriptSequence(transcript);
+    }
+    return { transcript, before: response.nextCursor };
   }
   getGoal() {
     return this.currentGoal;
@@ -7538,7 +7553,6 @@ var CodexAspManager = class extends CodingAgentManager {
     return event;
   }
   trackHistoryEvent(event) {
-    this.historyEvents.push(event);
     this.historyFile?.append(event);
   }
   emitTranscriptUpdated(threadId, options = {}) {
@@ -10800,7 +10814,7 @@ async function reconcileCanvasItems(filenames) {
 // src/services/upload-chat-transcripts.ts
 import { createReadStream } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { readdir as readdir8, readFile as readFile14, stat as stat4 } from "fs/promises";
+import { readFile as readFile14, readdir as readdir8, stat as stat4 } from "fs/promises";
 import { basename as basename2, join as join27 } from "path";
 
 // src/services/chat/chat-senders.ts
@@ -10859,6 +10873,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), ca
 async function uploadChatTranscript(chatId, filePath, chat, capture) {
   const { size } = await stat4(filePath);
   if (size === 0) return null;
+  const historyPages = createChatTranscriptPages(await readFile14(filePath));
   const metadata = chat ? {
     provider: chat.provider,
     credential: ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[chat.provider],
@@ -10882,6 +10897,7 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
   } catch (error) {
     if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
   }
+  if (historyPages.index.codexAspTranscript) metadata.historyIndex = historyPages.index;
   const uploadRequest = { chatId, size, metadata };
   const prepareResponse = await monolithRequest("/v1/engine/chat-transcripts/upload-url", {
     body: uploadRequest
@@ -10890,11 +10906,25 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
     throw new Error(`prepare failed: ${prepareResponse.status} ${await prepareResponse.text()}`);
   }
   const prepareBody = await prepareResponse.json();
-  if (!isRecord(prepareBody) || typeof prepareBody.uploadUrl !== "string" && prepareBody.uploadUrl !== null) {
+  if (!isRecord(prepareBody) || typeof prepareBody.uploadUrl !== "string" && prepareBody.uploadUrl !== null || prepareBody.historyPagesUploadUrl !== void 0 && typeof prepareBody.historyPagesUploadUrl !== "string") {
     throw new Error("prepare failed: invalid response");
   }
   if (prepareBody.uploadUrl === null) return null;
-  await putPresignedFile(prepareBody.uploadUrl, filePath, size, "application/x-ndjson");
+  const uploads = [putPresignedFile(prepareBody.uploadUrl, filePath, size, "application/x-ndjson")];
+  const historyPagesSize = getChatTranscriptHistorySize(historyPages.index);
+  if (historyPagesSize > 0) {
+    if (typeof prepareBody.historyPagesUploadUrl !== "string") {
+      throw new Error("prepare failed: missing history pages upload URL");
+    }
+    uploads.push(fetch(prepareBody.historyPagesUploadUrl, {
+      method: "PUT",
+      headers: { "content-type": "application/x-ndjson" },
+      body: new Uint8Array(historyPages.bytes).buffer
+    }).then((response) => {
+      if (!response.ok) throw new Error(`history pages upload failed: ${response.status}`);
+    }));
+  }
+  await Promise.all(uploads);
   const finalizeResponse = await monolithRequest("/v1/engine/chat-transcripts/finalize", {
     body: uploadRequest
   });
@@ -11310,10 +11340,11 @@ var ChatService = class {
       }
       chat.persisted.acceptedSendResponses = Object.fromEntries(chat.acceptedSendResponses);
     }
+    const submittedAt = request.submittedAt ?? (/* @__PURE__ */ new Date()).toISOString();
     const acceptedEvent = createAcceptedUserMessageEvent(
       request.message,
       result.messageId,
-      request.submittedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      submittedAt,
       request.images
     );
     if (!chat.pendingMessageIds.includes(result.messageId)) {
@@ -11329,11 +11360,12 @@ var ChatService = class {
     let recordedSender;
     if (request.senderUserId && request.senderEmail) {
       recordedSender = {
+        messageId: result.messageId,
         senderUserId: request.senderUserId,
         senderEmail: request.senderEmail,
         ...request.senderDisplayName ? { senderDisplayName: request.senderDisplayName } : {},
         ...request.senderAvatarUrl ? { senderAvatarUrl: request.senderAvatarUrl } : {},
-        recordedAt: request.submittedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        recordedAt: submittedAt
       };
       await this.appendSender(chatId, recordedSender);
     }
@@ -11362,15 +11394,11 @@ var ChatService = class {
     }
   }
   async readSenders(chatId) {
-    try {
-      return parseChatMessageSendersJsonl(await readFile15(chatMessageSendersFilePath(chatId), "utf-8"));
-    } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-        return [];
-      }
+    return readFile15(chatMessageSendersFilePath(chatId), "utf-8").then(parseChatMessageSendersJsonl).catch((error) => {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return [];
       console.error("[ChatService] Failed to read sender records:", error);
       return [];
-    }
+    });
   }
   async interrupt(chatId) {
     const chat = this.requireChat(chatId);
@@ -11592,7 +11620,12 @@ var ChatService = class {
     return descendants;
   }
   async deleteHistoryFile(persisted) {
-    await rm2(join29(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`), { force: true });
+    const historyPath = join29(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`);
+    await Promise.all([
+      historyPath,
+      `${historyPath}.pages.jsonl`,
+      `${historyPath}.pages.index.json`
+    ].map((path6) => rm2(path6, { force: true })));
     await rm2(chatMessageSendersFilePath(persisted.id), { force: true });
   }
   async getChatHistory(chatId, page = {}) {
@@ -11606,10 +11639,23 @@ var ChatService = class {
         chat.acceptedUserEvents.delete(messageId);
       }
     }
-    const isLatestPage = page.beforeEvent === void 0 && page.beforeTurn === void 0;
+    const isLatestPage = isLatestChatHistoryPage(page);
     const queuedMessageIds = new Set(chat.provider.getQueue().map((message) => message.id));
     const acceptedEvents = (isLatestPage ? [...chat.acceptedUserEvents.entries()] : []).filter(([messageId]) => messageId === chat.activeMessageId || !chat.hasActiveTurn && chat.pendingMessageIds[0] === messageId && !queuedMessageIds.has(messageId)).map(([, acceptedEvent]) => acceptedEvent).filter((acceptedEvent) => !acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) && !history.events.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
     const events = [...history.events, ...acceptedEvents].sort((a, b) => getEventTimestampMs(a) - getEventTimestampMs(b));
+    if (page.limit !== void 0 && "beforeCursor" in history) {
+      const cursor = parseChatHistoryCursor(history.beforeCursor ?? void 0);
+      return {
+        ...history,
+        events,
+        goal: history.goal ?? chat.provider.getGoal?.() ?? null,
+        senders: getChatHistoryPageSenders(senders, page),
+        beforeCursor: createChatHistoryCursor({
+          events: cursor?.events ?? null,
+          turns: cursor?.turns ?? null
+        })
+      };
+    }
     if (history.eventsStartIndex !== void 0) {
       return {
         ...history,
@@ -12940,6 +12986,22 @@ function jsonError(message, details) {
 }
 function createV1Routes(deps) {
   const app2 = new Hono();
+  const loadChatHistory = async (c, chatId, page, failureMessage, unexpectedStatus, legacy = false) => {
+    try {
+      const history = await deps.chatService.getChatHistory(chatId, legacy && page.limit !== void 0 ? {} : page);
+      if (!legacy) return c.json(history);
+      return c.json(paginateChatHistory({
+        ...history,
+        senders: getChatHistoryPageSenders(history.senders, page)
+      }, page));
+    } catch (error) {
+      const status = error instanceof ChatNotFoundError ? 404 : unexpectedStatus;
+      return c.json(jsonError(
+        failureMessage,
+        error instanceof Error ? error.message : "Unknown error"
+      ), status);
+    }
+  };
   app2.get("/events", async () => {
     const encoder = new TextEncoder();
     let unsubscribe = null;
@@ -13059,19 +13121,23 @@ function createV1Routes(deps) {
       return c.json(jsonError("Failed to restore chat", details), 500);
     }
   });
-  app2.get("/chats/:chatId/history", async (c) => {
-    try {
-      const history = await deps.chatService.getChatHistory(
-        c.req.param("chatId"),
-        chatHistoryPageParamsFromQuery(c.req.query())
-      );
-      return c.json(history);
-    } catch (error) {
-      if (error instanceof ChatNotFoundError) {
-        return c.json(jsonError("Failed to load chat history", error.message), 404);
-      }
-      return c.json(jsonError("Failed to load chat history", error instanceof Error ? error.message : "Unknown error"), 404);
+  app2.get("/chats/:chatId/history", (c) => loadChatHistory(
+    c,
+    c.req.param("chatId"),
+    chatHistoryPageParamsFromQuery(c.req.query()),
+    "Failed to load chat history",
+    404,
+    true
+  ));
+  app2.get("/chats/:chatId/history-page", async (c) => {
+    const page = chatHistoryPageParamsFromQuery(c.req.query());
+    if (page.limit === void 0) {
+      return c.json(jsonError("Failed to load chat history page", "limit is required"), 400);
+    }
+    if (page.beforeCursor !== void 0 && !parseChatHistoryCursor(page.beforeCursor)) {
+      return c.json(jsonError("Failed to load chat history page", "invalid cursor"), 400);
     }
+    return loadChatHistory(c, c.req.param("chatId"), page, "Failed to load chat history page", 500);
   });
   app2.get("/chats/:chatId/slash-commands", async (c) => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.654",
+  "version": "0.1.656",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",
@@ -38,8 +38,8 @@
     "@anthropic-ai/claude-agent-sdk": "0.3.219",
     "@connectrpc/connect-node": "1.7.0",
     "@cursor/sdk": "1.0.19",
-    "@deepseek-ai/dsh": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-host-apiproxy": "0.1.0-rc.6",
+    "@deepseek-ai/dsh": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-host-apiproxy": "0.1.0-rc.7",
     "@earendil-works/pi-ai": "0.79.10",
     "@earendil-works/pi-coding-agent": "0.79.0",
     "@hono/node-server": "^1.19.5",
@@ -52,7 +52,7 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "node-pty": "1.2.0-beta.14"
+    "node-pty": "1.2.0-beta.15"
   },
   "devDependencies": {
     "@replicas/codex-asp-types": "file:../codex-asp-types",