@myagentroam/node 0.9.5 → 0.9.6

package/dist/native-jsonl-reader.d.ts

@@ -3,6 +3,27 @@ export interface JsonlWindow {
     readonly truncated: boolean;
     readonly size: number;
 }
+export interface JsonlBackwardWindow extends JsonlWindow {
+    readonly pageContent: string;
+    readonly start: number;
+    readonly end: number;
+    readonly snapshotEnd: number;
+    readonly fileAnchor: string;
+    readonly anchorBytes: number;
+}
+export declare function readJsonlFileAnchor(path: string, anchorBytes: number): Promise<string | undefined>;
+/** Reads one newline-aligned window backwards from an opaque byte boundary. */
+export declare function readJsonlBackwardWindow(path: string, options: {
+    readonly headBytes: number;
+    readonly targetLines: number;
+    readonly maxBytes: number;
+    readonly page?: {
+        readonly snapshotEnd: number;
+        readonly nextEnd: number;
+        readonly fileAnchor: string;
+        readonly anchorBytes: number;
+    };
+}): Promise<JsonlBackwardWindow | undefined>;
 /** Reads bounded head/tail windows without ever loading an unbounded transcript. */
 export declare function readJsonlWindow(path: string, options: {
     readonly headBytes?: number;

package/dist/native-jsonl-reader.js

@@ -1,5 +1,94 @@
+import { createHash } from 'node:crypto';
 import { open, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
+export async function readJsonlFileAnchor(path, anchorBytes) {
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            if (anchorBytes < 0 || anchorBytes > metadata.size)
+                return undefined;
+            return createHash('sha256')
+                .update(await readAt(handle, anchorBytes, 0))
+                .digest('base64url');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Reads one newline-aligned window backwards from an opaque byte boundary. */
+export async function readJsonlBackwardWindow(path, options) {
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            const snapshotEnd = options.page?.snapshotEnd ?? metadata.size;
+            if (snapshotEnd > metadata.size)
+                return undefined;
+            const anchorBytes = options.page?.anchorBytes ?? Math.min(4096, snapshotEnd);
+            if (anchorBytes < 0 || anchorBytes > snapshotEnd)
+                return undefined;
+            const anchor = await readAt(handle, anchorBytes, 0);
+            const fileAnchor = createHash('sha256').update(anchor).digest('base64url');
+            if (options.page !== undefined && options.page.fileAnchor !== fileAnchor)
+                return undefined;
+            const headSize = Math.min(options.headBytes, snapshotEnd);
+            const end = Math.min(Math.max(options.page?.nextEnd ?? snapshotEnd, headSize), snapshotEnd);
+            const rawStart = Math.max(headSize, end - options.maxBytes);
+            const head = await readAt(handle, headSize, 0);
+            let tail = await readAt(handle, end - rawStart, rawStart);
+            let start = rawStart;
+            if (rawStart > headSize) {
+                const newline = tail.indexOf(0x0a);
+                if (newline < 0) {
+                    tail = Buffer.alloc(0);
+                    start = end;
+                }
+                else {
+                    start += newline + 1;
+                    tail = tail.subarray(newline + 1);
+                }
+            }
+            if (tail.length > 0) {
+                let lines = tail.at(-1) === 0x0a ? 0 : 1;
+                for (let index = tail.length - 1; index >= 0; index -= 1) {
+                    if (tail[index] !== 0x0a)
+                        continue;
+                    lines += 1;
+                    if (lines <= options.targetLines)
+                        continue;
+                    start += index + 1;
+                    tail = tail.subarray(index + 1);
+                    break;
+                }
+            }
+            const contiguous = start === headSize;
+            return {
+                content: contiguous
+                    ? Buffer.concat([head, tail]).toString('utf8')
+                    : `${head.toString('utf8')}${headSize > 0 && tail.length > 0 ? '\n' : ''}${tail.toString('utf8')}`,
+                truncated: start > headSize,
+                pageContent: tail.toString('utf8'),
+                size: metadata.size,
+                start,
+                end,
+                snapshotEnd,
+                fileAnchor,
+                anchorBytes
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Reads bounded head/tail windows without ever loading an unbounded transcript. */
 export async function readJsonlWindow(path, options) {
     try {

package/dist/native-session-history.d.ts

@@ -59,6 +59,16 @@ export interface NativeSessionHistory {
     readonly lastActivityAt: number;
     /** The bounded reader omitted bytes between its header and tail windows. */
     readonly truncated?: boolean;
+    /** Opaque paging facts for reading the preceding newline-aligned JSONL window. */
+    readonly windowStart?: number;
+    readonly windowEnd?: number;
+    readonly snapshotEnd?: number;
+    readonly fileAnchor?: string;
+    readonly anchorBytes?: number;
+    /** The supplied page cursor no longer matched this transcript. */
+    readonly cursorReset?: boolean;
+    /** Page-size input used to derive the stable JSONL line window. */
+    readonly windowReadLimit?: number;
 }
 /** Actual context-window facts emitted by the Codex native transcript. */
 export interface NativeCodexContextUsage {
@@ -84,7 +94,13 @@ export declare function discoverNativeSessions(runner: RunnerName, workspacePath
  */
 export declare function discoverAllNativeSessions(runner: RunnerName): Promise<readonly NativeSessionHistory[]>;
 /** Reads one already-discovered external session again to follow appended JSONL records. */
-export declare function readNativeSession(runner: RunnerName, workspacePath: string, externalSessionId: string): Promise<NativeSessionHistory | undefined>;
+export declare function readNativeSession(runner: RunnerName, workspacePath: string, externalSessionId: string, page?: {
+    readonly snapshotEnd: number;
+    readonly nextEnd: number;
+    readonly fileAnchor: string;
+    readonly anchorBytes: number;
+    readonly readLimit?: number;
+}, limit?: number): Promise<NativeSessionHistory | undefined>;
 /**
  * Codex records the most recent prompt token count alongside the model context
  * window in `event_msg/token_count`.  Read only the tail of an already

package/dist/native-session-history.js

@@ -2,11 +2,15 @@ import { createHash } from 'node:crypto';
 import { readFile, readdir, stat, unlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
-import { forEachJsonlRecord, listJsonlFiles, mapConcurrent, readJsonlWindow } from './native-jsonl-reader.js';
+import { forEachJsonlRecord, listJsonlFiles, mapConcurrent, readJsonlBackwardWindow, readJsonlFileAnchor, readJsonlWindow } from './native-jsonl-reader.js';
 import { nodeLog } from './operational.js';
 import { stripClaudePlanTag } from './runner-command-engine.js';
 const DISCOVERY_READ_BYTES = 32 * 1024;
-const TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
+const TRANSCRIPT_HEADER_READ_BYTES = 32 * 1024;
+const TRANSCRIPT_READ_MAX_BYTES = 16 * 1024 * 1024;
+const TRANSCRIPT_MIN_LINES = 256;
+const TRANSCRIPT_MAX_LINES = 4096;
+const TRANSCRIPT_LINES_PER_TURN = 32;
 const CONTEXT_USAGE_READ_BYTES = 256 * 1024;
 const CLAUDE_CONTEXT_USAGE_READ_BYTES = [CONTEXT_USAGE_READ_BYTES, 1024 * 1024, 4 * 1024 * 1024];
 const TRANSCRIPT_INDEX_TTL_MS = 60 * 60_000;
@@ -157,51 +161,68 @@ async function performNativeSessionDiscovery(runner, previous) {
     };
 }
 /** Reads one already-discovered external session again to follow appended JSONL records. */
-export async function readNativeSession(runner, workspacePath, externalSessionId) {
+export async function readNativeSession(runner, workspacePath, externalSessionId, page, limit = 30) {
     const wanted = canonical(workspacePath);
     const path = getTranscriptIndex(indexKey(runner, wanted, externalSessionId));
     if (path === undefined)
         return undefined;
-    const parsed = await readTranscriptDetail(path, runner);
+    const detail = await readTranscriptDetail(path, runner, page, page?.readLimit ?? limit);
+    const parsed = detail?.history;
     if (parsed === undefined ||
         parsed.externalSessionId !== externalSessionId ||
         canonical(parsed.cwd) !== wanted) {
         deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
         return undefined;
     }
-    return parsed;
+    return detail?.cursorAccepted === false ? { ...parsed, cursorReset: true } : parsed;
 }
-async function readTranscriptDetail(path, runner) {
-    const key = `${runner}\u0000${path}`;
+async function readTranscriptDetail(path, runner, page, limit) {
     let fingerprint;
     try {
         const metadata = await stat(path);
         fingerprint = `${metadata.size}:${metadata.mtimeMs}`;
     }
     catch {
-        transcriptDetailCache.delete(key);
-        transcriptDetailReads.delete(key);
         return undefined;
     }
+    const metadataSize = Number(fingerprint.slice(0, fingerprint.indexOf(':')));
+    const validPage = page !== undefined &&
+        page.snapshotEnd <= metadataSize &&
+        (await readJsonlFileAnchor(path, page.anchorBytes)) === page.fileAnchor
+        ? page
+        : undefined;
+    const targetLines = Math.min(TRANSCRIPT_MAX_LINES, Math.max(TRANSCRIPT_MIN_LINES, Math.max(1, limit) * TRANSCRIPT_LINES_PER_TURN));
+    const pageKey = `${validPage === undefined
+        ? 'latest'
+        : `${validPage.fileAnchor}:${validPage.snapshotEnd}:${validPage.nextEnd}`}:${targetLines}`;
+    const key = `${runner}\u0000${path}\u0000${pageKey}`;
+    const cacheFingerprint = validPage === undefined ? fingerprint : `${validPage.fileAnchor}:${validPage.snapshotEnd}`;
     const cached = transcriptDetailCache.get(key);
-    if (cached?.fingerprint === fingerprint && cached.expiresAt > Date.now()) {
+    if (cached?.fingerprint === cacheFingerprint && cached.expiresAt > Date.now()) {
         cached.expiresAt = Date.now() + TRANSCRIPT_DETAIL_CACHE_TTL_MS;
         transcriptDetailCache.delete(key);
         transcriptDetailCache.set(key, cached);
-        return cached.parsed;
+        return {
+            history: cached.parsed,
+            cursorAccepted: page === undefined || validPage !== undefined
+        };
     }
     transcriptDetailCache.delete(key);
     const current = transcriptDetailReads.get(key);
-    if (current?.fingerprint === fingerprint) {
+    if (current?.fingerprint === cacheFingerprint) {
         nodeLog('native.session.history.single-flight-joined', { runner });
-        return current.read;
+        return {
+            history: await current.read,
+            cursorAccepted: page === undefined || validPage !== undefined
+        };
     }
     const startedAt = performance.now();
-    const read = readTranscript(path, runner, TRANSCRIPT_READ_BYTES)
+    const read = readTranscript(path, runner, TRANSCRIPT_READ_MAX_BYTES, validPage, targetLines)
+        .then((parsed) => parsed === undefined ? undefined : { ...parsed, windowReadLimit: page?.readLimit ?? limit })
         .then((parsed) => {
         if (transcriptDetailReads.get(key)?.read === read) {
             transcriptDetailCache.set(key, {
-                fingerprint,
+                fingerprint: cacheFingerprint,
                 parsed,
                 expiresAt: Date.now() + TRANSCRIPT_DETAIL_CACHE_TTL_MS
             });
@@ -220,8 +241,8 @@ async function readTranscriptDetail(path, runner) {
         if (transcriptDetailReads.get(key)?.read === read)
             transcriptDetailReads.delete(key);
     });
-    transcriptDetailReads.set(key, { fingerprint, read });
-    return read;
+    transcriptDetailReads.set(key, { fingerprint: cacheFingerprint, read });
+    return { history: await read, cursorAccepted: page === undefined || validPage !== undefined };
 }
 function pruneTranscriptDetailCache() {
     const now = Date.now();
@@ -354,7 +375,7 @@ export async function removeNativeSession(runner, workspacePath, externalSession
     }
     if (path === undefined)
         throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
-    const parsed = await readTranscript(path, runner, TRANSCRIPT_READ_BYTES);
+    const parsed = await readTranscript(path, runner, DISCOVERY_READ_BYTES);
     if (parsed === undefined ||
         parsed.externalSessionId !== externalSessionId ||
         canonical(parsed.cwd) !== wanted) {
@@ -370,8 +391,13 @@ export async function removeNativeSession(runner, workspacePath, externalSession
         throw error;
     }
     deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
-    transcriptDetailCache.delete(`${runner}\u0000${path}`);
-    transcriptDetailReads.delete(`${runner}\u0000${path}`);
+    const detailKeyPrefix = `${runner}\u0000${path}\u0000`;
+    for (const key of transcriptDetailCache.keys())
+        if (key.startsWith(detailKeyPrefix))
+            transcriptDetailCache.delete(key);
+    for (const key of transcriptDetailReads.keys())
+        if (key.startsWith(detailKeyPrefix))
+            transcriptDetailReads.delete(key);
     invalidateNativeDiscovery(runner);
 }
 function transcriptRoot(runner) {
@@ -388,8 +414,13 @@ function invalidateNativeDiscovery(runner) {
     discoverySnapshots.delete(key);
     discoveryReads.delete(key);
 }
-async function readTranscript(path, runner, byteLimit) {
-    const window = await readJsonlWindow(path, { headBytes: byteLimit, tailBytes: byteLimit });
+async function readTranscript(path, runner, byteLimit, page, targetLines = Number.MAX_SAFE_INTEGER) {
+    const window = await readJsonlBackwardWindow(path, {
+        headBytes: Math.min(byteLimit, TRANSCRIPT_HEADER_READ_BYTES),
+        targetLines,
+        maxBytes: byteLimit,
+        ...(page === undefined ? {} : { page })
+    });
     if (window === undefined)
         return undefined;
     const { content, truncated } = window;
@@ -405,6 +436,8 @@ async function readTranscript(path, runner, byteLimit) {
             derivedSession = true;
         cwd ??= workspacePath(value);
         id ??= sessionId(value);
+    });
+    forEachJsonlRecord(truncated ? window.pageContent : content, (value) => {
         const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
         const parentId = typeof value['parentUuid'] === 'string' ? value['parentUuid'] : undefined;
         if (value['isMeta'] === true && recordId !== undefined)
@@ -470,7 +503,12 @@ async function readTranscript(path, runner, byteLimit) {
         digest: createHash('sha256').update(content).digest('hex'),
         items,
         lastActivityAt: Math.max(0, ...items.map((item) => item.createdAt ?? 0)),
-        truncated
+        truncated,
+        windowStart: window.start,
+        windowEnd: window.end,
+        snapshotEnd: window.snapshotEnd,
+        fileAnchor: window.fileAnchor,
+        anchorBytes: window.anchorBytes
     };
 }
 function derivedTranscriptRecord(runner, value) {

package/dist/runner/codex-runner.js

@@ -252,8 +252,9 @@ export class CodexRunner extends AbstractRunner {
     }
     async readConversationHistory(readers) {
         // Codex JSONL is the low-latency durable record for normal history reads,
-        // while thread/read can take seconds on large threads. Keep the official
-        // API as a fallback because a transcript can be missing or bounded/truncated.
+        // while thread/read can take seconds on large threads. A bounded tail is a
+        // valid recent-history page; use the official API only when JSONL is absent
+        // or cannot produce any visible history.
         const native = await readers.native();
         if (native !== undefined)
             return { ...native, source: 'native' };
@@ -272,7 +273,7 @@ export class CodexRunner extends AbstractRunner {
         }
     }
     acceptsTruncatedNativeHistory() {
-        return false;
+        return true;
     }
     async readManagedRunnerTitle(session, nativeSessionId) {
         void session;

package/dist/service/conversation-history-service.d.ts

@@ -31,7 +31,7 @@ export declare class ConversationHistoryService {
     private prefetchActiveHistory;
     private takeActiveHistoryRead;
     refreshExternalActivity(session: NodeAgentSession): Promise<void>;
-    readNative(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
+    readNative(session: NodeAgentSession, cursor?: string, limit?: number): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
     private attachNativeImages;
     readOfficial(session: NodeAgentSession, input: {
         readonly cursor?: string;

package/dist/service/conversation-history-service.js

@@ -158,7 +158,7 @@ export class ConversationHistoryService {
                 const startedAt = performance.now();
                 let history;
                 try {
-                    history = await this.readNative(session);
+                    history = await this.readNative(session, input.cursor, input.limit);
                 }
                 catch {
                     return undefined;
@@ -174,7 +174,8 @@ export class ConversationHistoryService {
                 }
                 if (history === undefined)
                     return undefined;
-                if (history.truncated === true && !runner.acceptsTruncatedNativeHistory()) {
+                if (history.truncated === true &&
+                    (!runner.acceptsTruncatedNativeHistory() || history.items.length === 0)) {
                     incompleteNative = true;
                     return undefined;
                 }
@@ -182,7 +183,11 @@ export class ConversationHistoryService {
                     ? []
                     : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 })
                         .turns;
-                const native = nativeConversationPage(session, history, input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
+                const native = nativeConversationPage(session, history, history.cursorReset === true
+                    ? input.limit === undefined
+                        ? {}
+                        : { limit: input.limit }
+                    : input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
                 return native;
             },
             official: () => this.readOfficial(session, input)
@@ -286,14 +291,15 @@ export class ConversationHistoryService {
         if (activity !== undefined)
             this.options.setExternalActivity(session.id, activity);
     }
-    async readNative(session) {
+    async readNative(session, cursor, limit = 30) {
         if (session.externalSessionId === null)
             return undefined;
-        const current = await readNativeSession(session.runner, session.cwd, session.externalSessionId);
+        const page = nativeHistoryPageCursor(cursor, session.id);
+        const current = await readNativeSession(session.runner, session.cwd, session.externalSessionId, page, limit);
         if (current !== undefined)
             return current;
         await discoverNativeSessions(session.runner, session.cwd);
-        return readNativeSession(session.runner, session.cwd, session.externalSessionId);
+        return readNativeSession(session.runner, session.cwd, session.externalSessionId, page, limit);
     }
     async attachNativeImages(session, turns) {
         const startedAt = performance.now();
@@ -364,6 +370,38 @@ export class ConversationHistoryService {
         };
     }
 }
+function nativeHistoryPageCursor(cursor, sessionId) {
+    if (cursor === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        return value.sessionId === sessionId &&
+            Number.isInteger(value.snapshotEnd) &&
+            Number.isInteger(value.nextEnd) &&
+            Number.isInteger(value.anchorBytes) &&
+            value.snapshotEnd >= 0 &&
+            value.nextEnd >= 0 &&
+            value.nextEnd <= value.snapshotEnd &&
+            value.anchorBytes >= 0 &&
+            value.anchorBytes <= value.snapshotEnd &&
+            (value.readLimit === undefined ||
+                (Number.isInteger(value.readLimit) &&
+                    value.readLimit >= 1 &&
+                    value.readLimit <= 500)) &&
+            typeof value.fileAnchor === 'string'
+            ? {
+                snapshotEnd: value.snapshotEnd,
+                nextEnd: value.nextEnd,
+                fileAnchor: value.fileAnchor,
+                anchorBytes: value.anchorBytes,
+                ...(value.readLimit === undefined ? {} : { readLimit: value.readLimit })
+            }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 const ACTIVE_HISTORY_CURSOR_PREFIX = 'mar-active-history:1:';
 function encodeActiveHistoryCursor(cursor) {
     return `${ACTIVE_HISTORY_CURSOR_PREFIX}${Buffer.from(JSON.stringify(cursor)).toString('base64url')}`;

package/dist/util/runner-native-session-parsers.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { stripClaudePlanTag } from '../runner-command-engine.js';
 import { compactRunnerText, isClaudeCommandTool, isPlainRecord, nativeClaudeCommand, nativePageEnd } from './node-operation-parsers.js';
@@ -152,26 +153,27 @@ export function deduplicateDirectSessions(sessions) {
 }
 export function nativeConversationPage(session, history, input, runtimeTurns = [], registerImages = () => []) {
     const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+    const effectiveCursor = history.cursorReset === true ? undefined : input.cursor;
     const nativeTurns = nativeTranscriptTurns(history.items);
+    const nativeTurnIds = nativeTranscriptTurnIds(session.id, nativeTurns);
     const representedClientMessageIds = new Set(nativeTurns.flatMap((entries) => entries.flatMap(({ entry, index }) => {
         if (entry.kind !== 'message' || entry.role !== 'USER')
             return [];
         const clientMessageId = nativeUserClientMessageId(entry, entry.createdAt ?? index, runtimeTurns);
         return clientMessageId === null ? [] : [clientMessageId];
     })));
-    const missingRuntimeErrorTurns = input.cursor === undefined
+    const missingRuntimeErrorTurns = effectiveCursor === undefined
         ? runtimeTurns.filter((turn) => {
             const clientMessageId = runtimeTurnClientMessageId(turn);
             return (turn.items.some((item) => item.kind === 'error') &&
                 (clientMessageId === undefined || !representedClientMessageIds.has(clientMessageId)));
         })
         : [];
-    const end = nativePageEnd(input.cursor, session.id, nativeTurns.length);
+    const end = nativePageEnd(effectiveCursor, session.id, nativeTurns.length);
     const start = Math.max(0, end - limit);
     const nativePageTurns = nativeTurns
         .slice(start, end)
         .map((entries, relativeIndex) => {
-        const firstIndex = entries[0]?.index ?? 0;
         const nativeUser = entries.find(({ entry }) => entry.kind === 'message' && entry.role === 'USER')?.entry;
         const matchedClientMessageId = nativeUser?.kind === 'message'
             ? nativeUserClientMessageId(nativeUser, nativeUser.createdAt, runtimeTurns)
@@ -179,9 +181,10 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         const runtimeTurn = typeof matchedClientMessageId === 'string'
             ? runtimeTurns.find((turn) => runtimeTurnClientMessageId(turn) === matchedClientMessageId)
             : undefined;
-        const turnId = runtimeTurn?.id ?? `${session.id}:native:${firstIndex}`;
-        const nativeItems = entries.map(({ entry, index }) => ({
-            ...nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages),
+        const turnId = runtimeTurn?.id ?? nativeTurnIds[start + relativeIndex];
+        const itemIdentities = nativeTranscriptItemIdentities(entries);
+        const nativeItems = entries.map(({ entry, index }, entryIndex) => ({
+            ...nativeTranscriptConversationItem(session, entry, index, itemIdentities[entryIndex], turnId, runtimeTurns, registerImages),
             runId: runtimeTurn?.runId ?? null
         }));
         const runtimeErrors = (runtimeTurn?.items ?? [])
@@ -221,11 +224,33 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
     const turns = combined.slice(-limit);
     const nativePageIds = new Set(nativePageTurns.map((turn) => turn.id));
     const nextEnd = start + dropped.filter((turn) => nativePageIds.has(turn.id)).length;
+    const cursorBase = {
+        sessionId: session.id,
+        ...(history.snapshotEnd === undefined ? {} : { snapshotEnd: history.snapshotEnd }),
+        ...(history.windowEnd === undefined ? {} : { nextEnd: history.windowEnd }),
+        ...(history.fileAnchor === undefined ? {} : { fileAnchor: history.fileAnchor }),
+        ...(history.anchorBytes === undefined ? {} : { anchorBytes: history.anchorBytes }),
+        readLimit: history.windowReadLimit ?? limit
+    };
+    const precedingWindow = history.truncated === true &&
+        history.windowStart !== undefined &&
+        history.snapshotEnd !== undefined &&
+        history.fileAnchor !== undefined &&
+        history.anchorBytes !== undefined
+        ? Buffer.from(JSON.stringify({
+            sessionId: session.id,
+            snapshotEnd: history.snapshotEnd,
+            nextEnd: history.windowStart,
+            fileAnchor: history.fileAnchor,
+            anchorBytes: history.anchorBytes,
+            readLimit: history.windowReadLimit ?? limit
+        })).toString('base64url')
+        : null;
     return {
         turns,
         nextCursor: nextEnd > 0
-            ? Buffer.from(JSON.stringify({ sessionId: session.id, end: nextEnd })).toString('base64url')
-            : null
+            ? Buffer.from(JSON.stringify({ ...cursorBase, end: nextEnd })).toString('base64url')
+            : precedingWindow
     };
 }
 function runtimeTurnClientMessageId(turn) {
@@ -237,6 +262,38 @@ function runtimeTurnClientMessageId(turn) {
 function lastNativeItemId(entries) {
     return entries.findLast(({ entry }) => entry.nativeId !== undefined)?.entry.nativeId;
 }
+function nativeTranscriptTurnIds(sessionId, turns) {
+    const occurrences = new Map();
+    return turns.map((entries) => {
+        const user = entries.find(({ entry }) => entry.kind === 'message' && entry.role === 'USER')?.entry;
+        const first = user ?? entries[0]?.entry;
+        const base = first?.nativeId ?? nativeTranscriptItemFingerprint(first);
+        const occurrence = occurrences.get(base) ?? 0;
+        occurrences.set(base, occurrence + 1);
+        return `${sessionId}:native:${base}${occurrence === 0 ? '' : `:${occurrence}`}`;
+    });
+}
+function nativeTranscriptItemIdentities(entries) {
+    const nativeIdCounts = new Map();
+    for (const { entry } of entries)
+        if (entry.nativeId !== undefined)
+            nativeIdCounts.set(entry.nativeId, (nativeIdCounts.get(entry.nativeId) ?? 0) + 1);
+    const occurrences = new Map();
+    return entries.map(({ entry }) => {
+        const base = entry.nativeId !== undefined && nativeIdCounts.get(entry.nativeId) === 1
+            ? entry.nativeId
+            : `${entry.nativeId === undefined ? '' : `${entry.nativeId}:`}${nativeTranscriptItemFingerprint(entry)}`;
+        const occurrence = occurrences.get(base) ?? 0;
+        occurrences.set(base, occurrence + 1);
+        return occurrence === 0 ? base : `${base}:${occurrence}`;
+    });
+}
+function nativeTranscriptItemFingerprint(entry) {
+    return createHash('sha256')
+        .update(JSON.stringify(entry ?? null))
+        .digest('base64url')
+        .slice(0, 24);
+}
 function nativeTranscriptTurns(items) {
     const turns = [];
     let current = [];
@@ -251,7 +308,7 @@ function nativeTranscriptTurns(items) {
         turns.push(current);
     return turns;
 }
-function nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages) {
+function nativeTranscriptConversationItem(session, entry, index, itemIdentity, turnId, runtimeTurns, registerImages) {
     const time = entry.createdAt;
     const isToolCall = entry.kind === 'tool_call';
     const isUnknown = entry.kind === 'unknown';
@@ -276,7 +333,7 @@ function nativeTranscriptConversationItem(session, entry, index, turnId, runtime
         : '';
     const planText = entry.kind === 'message' && entry.role !== 'USER' ? claudePlanText(entryText) : undefined;
     const item = {
-        id: `${turnId}:item:${index}`,
+        id: `${turnId}:item:${itemIdentity}`,
         sessionId: session.id,
         turnId,
         runId: null,
@@ -301,7 +358,7 @@ function nativeTranscriptConversationItem(session, entry, index, turnId, runtime
         status: 'COMPLETED',
         payload: isUserInputRequest
             ? {
-                requestId: `native:${entry.kind === 'tool_call' ? entry.toolUseId : `item-${index}`}`,
+                requestId: `native:${entry.kind === 'tool_call' ? entry.toolUseId : `item-${itemIdentity}`}`,
                 questions: userInputQuestions
             }
             : isReasoning

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.9.5"
+    "@myagentroam/protocol": "^0.9.6"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"