@moxt-ai/mobius 0.0.188 → 0.0.189

package/dist/runtime.js

@@ -23332,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));
@@ -24406,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) => {
@@ -24508,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;