fix(sessions): fall back to reset archive for missing async transcripts

openclaw-clownfish[bot] · CadanHu · openclaw-clownfish[bot] · commit caeb344bdecf · 2026-06-14T05:26:53.000Z
Co-authored-by: Masato Hoshino &lt;246810661+masatohoshino@users.noreply.github.com&gt;

Co-authored-by: Hu Yitao &lt;39733381+CadanHu@users.noreply.github.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -26,6 +26,7 @@ Docs: https://docs.openclaw.ai
 - Channels and delivery: preserve account-scoped DM channel send policy, rich Telegram final replies, rich Telegram tables and lists, Telegram thread-create CLI remapping, Slack outbound `message_sent` hooks, contributed message-tool schema optionality, same-channel generated media completions, and channel chunking around surrogate pairs and Infinity limits. (#92788, #92679, #89421, #89943, #91137, #91246, #92735) Thanks @yetval, @obviyus, @spacegeologist, @rishitamrakar, @lundog, @TurboTheTurtle, and @yhterrance.
 - Discord: give generated auto-thread titles a 60-second timeout and 4,096-token reasoning-model output budget, clamped to the selected model output cap. (#64734) Thanks @hanamizuki.
 - Agent, cron, and Gateway runtime: mark active main sessions before restart shutdown aborts, pause yielded subagent runs whose terminal also signals abort, preserve yielded media completions, de-duplicate main-session heartbeat events, expose session identity in runtime prompts, reject unknown OpenAI agent selectors, keep generated media completions in WebChat, and require admin privileges for HTTP session/model override surfaces. (#91357, #92631, #92146, #91287, #92468, #92510, #91246, #92651, #92646) Thanks @ooiuuii, @openperf, @IWhatsskill, @ZengWen-DT, @zhangguiping-xydt, and @TurboTheTurtle.
+- Gateway/Sessions: let `chat.history` and HTTP session-history reads recover from the newest `.jsonl.reset.*` archive when the active transcript is missing, restoring reset-archived history snapshots and message counts. (#45003, #56131, #60409, #76134) Thanks @masatohoshino and @CadanHu.
 - Providers and model replay: preserve storeless OpenAI Responses replay compatibility, avoid eager tool streaming for Claude 4.5 in Copilot, honor profile auth for SecretRef model entries, bound model browsing, strip provider prefixes where runtimes need bare IDs, and surface nested embedding fetch failures. (#90706, #75393, #90686, #92247, #92627, #91218, #92628) Thanks @snowzlm, @Kailigithub, @rohitjavvadi, @samson910022, @liuhao1024, @bymle, and @mushuiyu886.
 - Memory, state, diagnostics, and config: split header-too-large embedding batches, keep QMD memory search enabled in transient mode, avoid SQLite WAL on NFS volumes, preserve recovery scheduling outside stuck-session warning backoff, and keep shell environment fallbacks contained in config write tests. (#92650, #92618, #92639, #91247, #92752) Thanks @mushuiyu886, @TurboTheTurtle, @849261680, and @gnanam1990.
 - UI/mobile/TUI: preserve dashboard session parent lineage, WebChat backscroll, reset soft command args, sidebar session picker interactivity, collapsed workspace files, resolved `/model` confirmation refs, and stale foreground iOS Gateway reconnects. (#90658, #92622, #91353, #92705, #92779, #92773, #92552) Thanks @luoyanglang, @TurboTheTurtle, @zhouhe-xydt, @NianJiuZst, @shakkernerd, @NarahariRaghava, and @Solvely-Colin.
diff --git a/src/gateway/session-transcript-files.fs.ts b/src/gateway/session-transcript-files.fs.ts
@@ -129,6 +129,52 @@ export function resolveSessionTranscriptCandidates(
   return uniqueStrings(candidates);
 }
 
+function resolveLatestResetArchiveForTranscript(transcriptPath: string): string | undefined {
+  const base = path.basename(transcriptPath);
+  if (!base.endsWith(".jsonl")) {
+    return undefined;
+  }
+  const dir = path.dirname(transcriptPath);
+  let latest: { name: string; timestamp: number } | undefined;
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.startsWith(`${base}.reset.`)) {
+        continue;
+      }
+      const timestamp = parseSessionArchiveTimestamp(entry.name, "reset");
+      if (timestamp == null) {
+        continue;
+      }
+      if (
+        !latest ||
+        timestamp > latest.timestamp ||
+        (timestamp === latest.timestamp && entry.name > latest.name)
+      ) {
+        latest = { name: entry.name, timestamp };
+      }
+    }
+  } catch {
+    return undefined;
+  }
+  return latest ? path.join(dir, latest.name) : undefined;
+}
+
+export function resolveSessionTranscriptResetArchiveCandidates(
+  sessionId: string,
+  storePath: string | undefined,
+  sessionFile?: string,
+  agentId?: string,
+): string[] {
+  return uniqueStrings(
+    resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId).flatMap(
+      (candidate) => {
+        const archive = resolveLatestResetArchiveForTranscript(candidate);
+        return archive ? [archive] : [];
+      },
+    ),
+  );
+}
+
 export function archiveFileOnDisk(filePath: string, reason: ArchiveFileReason): string {
   const ts = formatSessionArchiveTimestamp();
   const archived = `${filePath}.${reason}.${ts}`;
diff --git a/src/gateway/session-utils.fs.test.ts b/src/gateway/session-utils.fs.test.ts
@@ -79,6 +79,17 @@ function writeTranscript(tmpDir: string, sessionId: string, lines: unknown[]): s
   return transcriptPath;
 }
 
+function writeResetArchive(
+  tmpDir: string,
+  sessionId: string,
+  timestamp: string,
+  lines: unknown[],
+): string {
+  const archivePath = path.join(tmpDir, `${sessionId}.jsonl.reset.${timestamp}`);
+  fs.writeFileSync(archivePath, lines.map((line) => JSON.stringify(line)).join("\n"), "utf-8");
+  return archivePath;
+}
+
 function appendBlockedUserMessageWithSessionManager(params: {
   sessionFile: string;
   originalText?: string;
@@ -782,6 +793,42 @@ describe("readSessionMessages", () => {
     }
   });
 
+  test("falls back to the latest reset archive when the active transcript is missing", async () => {
+    const sessionId = "test-session-reset-archive-fallback";
+    writeResetArchive(tmpDir, sessionId, "2026-02-16T22-26-33.000Z", [
+      { type: "session", version: 1, id: sessionId },
+      { message: { role: "assistant", content: "older archive" } },
+    ]);
+    writeResetArchive(tmpDir, sessionId, "2026-02-16T22-26-34.000Z", [
+      { type: "session", version: 1, id: sessionId },
+      { message: { role: "user", content: "restored prompt" } },
+      { message: { role: "assistant", content: "restored archive" } },
+    ]);
+    clearSessionTranscriptIndexCache();
+
+    const fullMessages = await readSessionMessagesAsync(sessionId, storePath, undefined, {
+      mode: "full",
+      reason: "test reset archive fallback",
+    });
+    expect(fullMessages.map((message) => (message as { content?: unknown }).content)).toEqual([
+      "restored prompt",
+      "restored archive",
+    ]);
+    await expect(readSessionMessageCountAsync(sessionId, storePath)).resolves.toBe(2);
+
+    const recent = await readRecentSessionMessagesWithStatsAsync(sessionId, storePath, undefined, {
+      maxMessages: 1,
+      maxBytes: 2048,
+    });
+    expect(recent.totalMessages).toBe(2);
+    expect(recent.messages).toHaveLength(1);
+    expectMessageFields(recent.messages[0], {
+      role: "assistant",
+      content: "restored archive",
+      openclaw: { seq: 2 },
+    });
+  });
+
   test("keeps async active branch rows when imported parent links are incomplete", async () => {
     const sessionId = "test-session-tree-async-incomplete-parent";
     writeTranscript(tmpDir, sessionId, [
diff --git a/src/gateway/session-utils.fs.ts b/src/gateway/session-utils.fs.ts
@@ -16,7 +16,10 @@ import { estimateStringChars, estimateTokensFromChars } from "../utils/cjk-chars
 import { stripInlineDirectiveTagsForDisplay } from "../utils/directive-tags.js";
 import { extractToolCallNames, hasToolCall } from "../utils/transcript-tools.js";
 import { stripEnvelope } from "./chat-sanitize.js";
-import { resolveSessionTranscriptCandidates } from "./session-transcript-files.fs.js";
+import {
+  resolveSessionTranscriptCandidates,
+  resolveSessionTranscriptResetArchiveCandidates,
+} from "./session-transcript-files.fs.js";
 import {
   readSessionTranscriptIndex,
   type IndexedTranscriptEntry,
@@ -153,9 +156,7 @@ export function readSessionMessages(
   storePath: string | undefined,
   sessionFile?: string,
 ): unknown[] {
-  const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile);
-
-  const filePath = candidates.find((p) => fs.existsSync(p));
+  const filePath = findExistingTranscriptPath(sessionId, storePath, sessionFile);
   if (!filePath) {
     return [];
   }
@@ -820,6 +821,7 @@ export {
   archiveSessionTranscripts,
   cleanupArchivedSessionTranscripts,
   resolveSessionTranscriptCandidates,
+  resolveSessionTranscriptResetArchiveCandidates,
 } from "./session-transcript-files.fs.js";
 
 export function capArrayByJsonBytes<T>(
@@ -855,8 +857,7 @@ export function readSessionTitleFieldsFromTranscript(
   agentId?: string,
   opts?: { includeInterSession?: boolean },
 ): SessionTitleFields {
-  const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId);
-  const filePath = candidates.find((p) => fs.existsSync(p));
+  const filePath = findExistingTranscriptPath(sessionId, storePath, sessionFile, agentId);
   if (!filePath) {
     return { firstUserMessage: null, lastMessagePreview: null };
   }
@@ -927,8 +928,7 @@ export async function readSessionTitleFieldsFromTranscriptAsync(
   agentId?: string,
   opts?: { includeInterSession?: boolean },
 ): Promise<SessionTitleFields> {
-  const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId);
-  const filePath = candidates.find((p) => fs.existsSync(p));
+  const filePath = findExistingTranscriptPath(sessionId, storePath, sessionFile, agentId);
   if (!filePath) {
     return { firstUserMessage: null, lastMessagePreview: null };
   }
@@ -1065,7 +1065,15 @@ function findExistingTranscriptPath(
   agentId?: string,
 ): string | null {
   const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId);
-  return candidates.find((p) => fs.existsSync(p)) ?? null;
+  const activePath = candidates.find((p) => fs.existsSync(p));
+  if (activePath) {
+    return activePath;
+  }
+  return (
+    resolveSessionTranscriptResetArchiveCandidates(sessionId, storePath, sessionFile, agentId).find(
+      (p) => fs.existsSync(p),
+    ) ?? null
+  );
 }
 
 function withOpenTranscriptFd<T>(filePath: string, read: (fd: number) => T | null): T | null {
diff --git a/src/gateway/sessions-history-http.test.ts b/src/gateway/sessions-history-http.test.ts
@@ -67,6 +67,26 @@ async function seedSession(params?: { text?: string }) {
   return { storePath };
 }
 
+async function writeResetArchiveTranscript(params: {
+  dir: string;
+  sessionId: string;
+  timestamp: string;
+  texts: string[];
+}) {
+  await fs.writeFile(
+    path.join(params.dir, `${params.sessionId}.jsonl.reset.${params.timestamp}`),
+    [
+      JSON.stringify({ type: "session", version: 1, id: params.sessionId }),
+      ...params.texts.map((text) =>
+        JSON.stringify({
+          message: { role: "assistant", content: [{ type: "text", text }] },
+        }),
+      ),
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
 function makeTranscriptAssistantMessage(params: {
   text: string;
   content?: AssistantMessage["content"];
@@ -369,6 +389,45 @@ describe("session history HTTP endpoints", () => {
     });
   });
 
+  test("returns session history from the latest reset archive when the active transcript is missing", async () => {
+    const storePath = await createSessionStoreFile();
+    const sessionId = "sess-reset-main";
+    const dir = path.dirname(storePath);
+    await writeResetArchiveTranscript({
+      dir,
+      sessionId,
+      timestamp: "2026-02-16T22-26-33.000Z",
+      texts: ["older archived history"],
+    });
+    await writeResetArchiveTranscript({
+      dir,
+      sessionId,
+      timestamp: "2026-02-16T22-26-34.000Z",
+      texts: ["restored first", "restored latest"],
+    });
+    await writeSessionStoreForTestAsync(storePath, {
+      "agent:main:main": {
+        sessionId,
+        updatedAt: 1,
+      },
+    });
+
+    await withGatewayHarness(async (harness) => {
+      const body = await readSessionHistoryBody(harness.port, "agent:main:main", {
+        query: "?limit=1",
+      });
+      expect(body.sessionKey).toBe("agent:main:main");
+      expect(body.messages?.map((message) => message.content?.[0]?.text)).toEqual([
+        "restored latest",
+      ]);
+      expect(body.hasMore).toBe(true);
+      expect(body.nextCursor).toBe("2");
+      expectOpenClawMetadata(body.messages?.[0]?.["__openclaw"], {
+        seq: 2,
+      });
+    });
+  });
+
   test("matches direct REST history paths without trusting malformed Host headers", async () => {
     await seedSession({ text: "history with bad host" });
     await withGatewayHarness(async (harness) => {
