npm - @yeaft/webchat-agent - Versions diffs - 1.0.364 → 1.0.366 - Mend

@yeaft/webchat-agent 1.0.364 → 1.0.366

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/local-runtime/server/handlers/agent-output.js +3 -0
package/local-runtime/server/handlers/client-conversation.js +4 -0
package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +93 -93
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/conversation/persist.js +223 -14
package/yeaft/web-bridge.js +71 -7

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=2cd941bb"></script>
+  <script type="module" src="app.bundle.js?v=86aebbdf"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.364",
+  "version": "1.0.366",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/conversation/persist.js CHANGED Viewed

@@ -18,6 +18,7 @@
  */
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, renameSync, unlinkSync, statSync, appendFileSync } from 'fs';
+import { createHash, randomUUID } from 'node:crypto';
 import { join, basename } from 'path';
 import { isPermissionError } from '../init.js';
 import { writeAtomic } from '../storage/atomic.js';
@@ -71,6 +72,7 @@ const DELTA_TOOL_PAIR_EXTENSION_CAP = 500;
 const SEGMENT_INDEX_FILE = 'index.json';
+const SEGMENT_LINEAGE_FILE = 'lineage.json';
 const SEGMENT_DIR = 'segments';
 const SEGMENT_TARGET_BYTES = 1024 * 1024;
 const SEGMENT_FIRST_NAME = '000001.jsonl';
@@ -98,7 +100,9 @@ function projectAssistantToolsForVisibleHistory(message) {
 function emptySegmentIndex() {
   return {
-    version: 1,
+    version: 2,
+    streamId: null,
+    revision: 0,
     nextSeq: 1,
     totalMessages: 0,
     lastMessageId: null,
@@ -700,7 +704,9 @@ class SegmentStore {
     this.rootDir = rootDir;
     this.segmentDir = join(rootDir, SEGMENT_DIR);
     this.indexPath = join(rootDir, SEGMENT_INDEX_FILE);
+    this.lineagePath = join(rootDir, SEGMENT_LINEAGE_FILE);
     this.index = null;
+    this.lineage = null;
   }
   ensure() {
@@ -727,8 +733,18 @@ class SegmentStore {
       }
     }
     const indexWasStale = idx && !this.#indexMatchesDisk(idx);
-    this.index = this.#normalizeIndex(!idx || indexWasStale ? this.#rebuildIndex() : idx);
-    if ((!existsSync(this.indexPath) || indexWasStale) && this.hasData()) this.saveIndex();
+    const normalizedSource = !idx || indexWasStale ? this.#rebuildIndex() : idx;
+    this.index = this.#normalizeIndex(normalizedSource);
+    this.lineage = this.#resolveLineage(this.index, {
+      verifyAnchor: !idx || !normalizedSource?.streamId,
+    });
+    this.index.streamId = this.lineage.streamId;
+    this.index.revision = this.lineage.revision;
+    const needsMetadataUpgrade = !normalizedSource?.streamId
+      || normalizedSource.streamId !== this.lineage.streamId
+      || !Number.isFinite(Number(normalizedSource?.revision))
+      || Number(normalizedSource.revision) !== this.lineage.revision;
+    if ((!existsSync(this.indexPath) || indexWasStale || needsMetadataUpgrade) && this.hasData()) this.saveIndex();
     return this.index;
   }
@@ -737,9 +753,20 @@ class SegmentStore {
     writeFileSync(this.indexPath, `${JSON.stringify(this.index || emptySegmentIndex(), null, 2)}\n`, { encoding: 'utf8', mode: 0o644 });
   }
+  metadata() {
+    const idx = this.loadIndex();
+    return {
+      streamId: idx.streamId,
+      revision: Number(idx.revision) || 0,
+      headSeq: Math.max(0, (Number(idx.nextSeq) || 1) - 1),
+    };
+  }
   append(msg) {
     this.ensure();
     const idx = this.loadIndex();
+    const establishesAnchor = (Number(idx.totalMessages) || 0) === 0
+      && (!Array.isArray(idx.segments) || idx.segments.length === 0);
     let segment = idx.segments[idx.segments.length - 1] || null;
     let active = segment?.file || idx.activeSegment || SEGMENT_FIRST_NAME;
     let activePath = join(this.segmentDir, active);
@@ -765,12 +792,24 @@ class SegmentStore {
     idx.totalMessages = (idx.totalMessages || 0) + 1;
     idx.lastMessageId = msg.id || null;
     idx.nextSeq = Math.max(Number(idx.nextSeq) || 1, seq + 1);
+    const invalidatesEarlierRows = msg._reflection
+      || (Array.isArray(msg.foldedMessageIds) && msg.foldedMessageIds.length > 0);
+    // Ordinary appends are recoverable through afterSeq. Only an append that
+    // invalidates older visible rows (fold reflection/tombstones) advances the
+    // mutation revision and forces the browser to rebuild its snapshot.
+    if (invalidatesEarlierRows) {
+      idx.revision = (Number(idx.revision) || 0) + 1;
+    }
     if (msg._reflection && Array.isArray(msg.foldedMessageIds)) {
       idx.foldedMessageIds = Array.from(new Set([
         ...(Array.isArray(idx.foldedMessageIds) ? idx.foldedMessageIds : []),
         ...msg.foldedMessageIds.filter(id => typeof id === 'string' && id),
       ]));
     }
+    this.#persistCurrentLineage({
+      revision: idx.revision,
+      anchor: establishesAnchor ? this.#lineageAnchorForLine(line) : undefined,
+    });
     this.saveIndex();
   }
@@ -846,10 +885,16 @@ class SegmentStore {
     if (!next || typeof next !== 'object') return null;
     const updated = { ...next, id: rows[rowIndex].id };
     rows[rowIndex] = updated;
+    const updatesAnchor = rowIndex === 0 && segment.file === idx.segments[0]?.file;
     const body = rows.map(row => JSON.stringify(row)).join('\n') + (rows.length > 0 ? '\n' : '');
     writeAtomic(path, body);
     segment.bytes = Buffer.byteLength(body);
+    idx.revision = (Number(idx.revision) || 0) + 1;
+    this.#persistCurrentLineage({
+      revision: idx.revision,
+      anchor: updatesAnchor ? this.#lineageAnchorForLine(JSON.stringify(updated)) : undefined,
+    });
     this.saveIndex();
     return updated;
   }
@@ -865,7 +910,10 @@ class SegmentStore {
       }
     }
     if (existsSync(this.indexPath)) unlinkSync(this.indexPath);
-    this.index = emptySegmentIndex();
+    this.lineage = { streamId: randomUUID(), revision: 0, anchor: null };
+    this.#writeLineage(this.lineage);
+    this.index = { ...emptySegmentIndex(), streamId: this.lineage.streamId };
+    this.saveIndex();
   }
   #indexMatchesDisk(idx) {
@@ -881,8 +929,128 @@ class SegmentStore {
     });
   }
+  #readLineage() {
+    if (!existsSync(this.lineagePath)) return null;
+    try {
+      const parsed = JSON.parse(readFileSync(this.lineagePath, 'utf8') || '{}');
+      if (!parsed || typeof parsed !== 'object'
+          || typeof parsed.streamId !== 'string' || !parsed.streamId
+          || !Number.isFinite(Number(parsed.revision))
+          || (parsed.anchor !== null && typeof parsed.anchor !== 'string')) return null;
+      return {
+        streamId: parsed.streamId,
+        revision: Math.max(0, Number(parsed.revision)),
+        anchor: parsed.anchor,
+      };
+    } catch {
+      return null;
+    }
+  }
+  #writeLineage(lineage) {
+    this.ensure();
+    const normalized = {
+      version: 1,
+      streamId: lineage.streamId,
+      revision: Math.max(0, Number(lineage.revision) || 0),
+      anchor: typeof lineage.anchor === 'string' ? lineage.anchor : null,
+    };
+    writeAtomic(this.lineagePath, `${JSON.stringify(normalized, null, 2)}\n`);
+    this.lineage = normalized;
+    return normalized;
+  }
+  #currentLineageAnchor() {
+    if (!existsSync(this.segmentDir)) return null;
+    const files = readdirSync(this.segmentDir).filter(file => file.endsWith('.jsonl')).sort();
+    for (const file of files) {
+      const path = join(this.segmentDir, file);
+      if (!existsSync(path)) continue;
+      let raw;
+      try {
+        raw = readFileSync(path, 'utf8');
+      } catch (error) {
+        if (isPermissionError(error)) return null;
+        throw error;
+      }
+      for (const line of raw.split('\n')) {
+        if (!parseJsonLine(line)) continue;
+        return this.#lineageAnchorForLine(line);
+      }
+    }
+    return null;
+  }
+  #lineageAnchorForLine(line) {
+    return createHash('sha256').update(String(line || '').trim()).digest('hex');
+  }
+  #legacyLineageId(anchor) {
+    return `legacy-${createHash('sha256')
+      .update(this.rootDir)
+      .update('\0')
+      .update(anchor || '<empty>')
+      .digest('hex')}`;
+  }
+  #resolveLineage(idx, { verifyAnchor = false } = {}) {
+    const persisted = this.#readLineage();
+    const anchor = !persisted || verifyAnchor ? this.#currentLineageAnchor() : persisted.anchor;
+    if (!persisted) {
+      const initialStreamId = anchor ? this.#legacyLineageId(anchor) : randomUUID();
+      const indexStreamId = typeof idx?.streamId === 'string' && idx.streamId ? idx.streamId : null;
+      // Missing sidecar is a rolling-upgrade boundary. Recompute from the
+      // immutable first row for existing data. A truly empty store starts a
+      // new random lifetime so delete + same-id recreation cannot collide.
+      const streamId = verifyAnchor ? initialStreamId : (indexStreamId || initialStreamId);
+      return this.#writeLineage({
+        streamId,
+        revision: Number.isFinite(Number(idx?.revision)) ? Number(idx.revision) : 0,
+        anchor,
+      });
+    }
+    if (persisted.anchor !== anchor) {
+      // A reader/writer that predates lineage.json can still clear, recreate,
+      // or rewrite the first durable row. The anchor detects that mutation
+      // without relying on metadata fields the old index writer discards.
+      return this.#writeLineage({ streamId: randomUUID(), revision: 0, anchor });
+    }
+    const indexRevision = (!idx?.streamId || idx.streamId === persisted.streamId)
+      && Number.isFinite(Number(idx?.revision))
+      ? Math.max(0, Number(idx.revision))
+      : 0;
+    const revision = Math.max(persisted.revision, indexRevision);
+    if (revision !== persisted.revision) return this.#writeLineage({ ...persisted, revision });
+    return persisted;
+  }
+  #persistCurrentLineage({ revision = null, anchor = undefined } = {}) {
+    const current = this.lineage || this.#readLineage() || {
+      streamId: this.index?.streamId || this.#legacyLineageId(this.#currentLineageAnchor()),
+      revision: Number(this.index?.revision) || 0,
+      anchor: this.#currentLineageAnchor(),
+    };
+    const nextRevision = Number.isFinite(Number(revision)) ? Number(revision) : current.revision;
+    const nextAnchor = typeof anchor === 'string' && anchor ? anchor : current.anchor;
+    const needsWrite = !this.lineage
+      || current.revision !== nextRevision
+      || current.anchor !== nextAnchor;
+    const next = needsWrite
+      ? this.#writeLineage({ ...current, revision: nextRevision, anchor: nextAnchor })
+      : current;
+    this.lineage = next;
+    if (this.index) {
+      this.index.streamId = next.streamId;
+      this.index.revision = next.revision;
+    }
+    return next;
+  }
   #normalizeIndex(idx) {
     const out = { ...emptySegmentIndex(), ...(idx || {}) };
+    out.version = 2;
+    out.streamId = typeof out.streamId === 'string' && out.streamId ? out.streamId : null;
+    out.revision = Number.isFinite(Number(out.revision)) ? Math.max(0, Number(out.revision)) : 0;
     out.segments = Array.isArray(out.segments) ? out.segments.filter(s => s && s.file) : [];
     out.segments.sort((a, b) => (Number(a.firstSeq) || 0) - (Number(b.firstSeq) || 0));
     const maxSeq = out.segments.reduce((max, seg) => Math.max(max, Number(seg.lastSeq) || 0), 0);
@@ -1460,6 +1628,18 @@ export class ConversationStore {
   // ─── Read API ───────────────────────────────────────────
+  /**
+   * Return the durable identity of one Session transcript. `streamId`
+   * changes on clear/recreate; `revision` changes on append/update/fold.
+   * Browser caches use both values to detect non-append mutations before
+   * trusting an `afterSeq` delta cursor.
+   */
+  getSessionHistoryMetadata(sessionId) {
+    if (!sessionId) return null;
+    const store = this.#segmentStoreForConversationDir(this.#sessionConversationDir(sessionId));
+    return store.metadata();
+  }
   /**
    * Load recent hot messages, sliced to the last `turnsLimit` TURNS and
    * sorted chronologically.
@@ -1740,17 +1920,21 @@ export class ConversationStore {
    * without downgrading the client to a cursor-less loaded state. Hidden rows
    * advance the cursor only at pair-safe boundaries; a cursor must never cross
    * an assistant tool call before all of that call's result rows are included.
+   * Both row and byte budgets cut only at those safe boundaries. `hasMoreAfter`
+   * tells the Web client to keep draining long offline gaps without waiting for
+   * another reconnect or Session activation.
    *
    * @param {string} sessionId
    * @param {number|null} afterSeq — exclusive lower bound
-   * @param {{ limit?: number }} [opts]
-   * @returns {{ messages: object[], latestSeq: number|null }}
+   * @param {{ limit?: number, maxBytes?: number }} [opts]
+   * @returns {{ messages: object[], latestSeq: number|null, hasMoreAfter: boolean }}
    */
   loadAfterSeqByGroup(sessionId, afterSeq, opts = {}) {
-    if (!sessionId) return { messages: [], latestSeq: null };
+    if (!sessionId) return { messages: [], latestSeq: null, hasMoreAfter: false };
     const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? opts.limit : 500;
+    const maxBytes = Number.isFinite(opts.maxBytes) && opts.maxBytes > 0 ? opts.maxBytes : Infinity;
     const cutoff = Number.isFinite(afterSeq) && afterSeq >= 0 ? afterSeq : null;
-    if (cutoff === null) return { messages: [], latestSeq: null };
+    if (cutoff === null) return { messages: [], latestSeq: null, hasMoreAfter: false };
     const after = [];
     const pendingToolResultIds = new Set();
     const completedBeforeCursor = new Set();
@@ -1788,8 +1972,14 @@ export class ConversationStore {
       ? Math.max(0, earliestBoundarySeq - 1)
       : cutoff;
     let visibleRows = after.length;
+    let visibleBytes = after.reduce((sum, message) => sum + Buffer.byteLength(JSON.stringify(message)), 0);
+    let stoppedAtBudget = false;
     let extensionRows = 0;
-    for (const m of this.#iterateSessionRows(sessionId, { afterSeq: cutoff, desc: false })) {
+    const deltaRows = this.#iterateSessionRows(sessionId, { afterSeq: cutoff, desc: false });
+    while (true) {
+      const step = deltaRows.next();
+      if (step.done) break;
+      const m = step.value;
       if (!m || m.sessionId !== sessionId) continue;
       const seq = parseSeqFromId(m.id);
       const hidden = !isVisibleConversationRow(m);
@@ -1799,6 +1989,7 @@ export class ConversationStore {
         // messages between an assistant call and that call's result.
         after.push(m);
         visibleRows += 1;
+        visibleBytes += Buffer.byteLength(JSON.stringify(m));
         if (m.role === 'assistant' && Array.isArray(m.toolCalls)) {
           for (const toolCall of m.toolCalls) {
             if (typeof toolCall?.id === 'string' && toolCall.id) pendingToolResultIds.add(toolCall.id);
@@ -1807,11 +1998,19 @@ export class ConversationStore {
           pendingToolResultIds.delete(m.toolCallId);
         }
       }
-      if (pendingToolResultIds.size === 0 && Number.isFinite(seq)) safeCursorSeq = seq;
-      if (visibleRows < limit) continue;
-      if (pendingToolResultIds.size === 0) break;
+      if (pendingToolResultIds.size === 0 && Number.isFinite(seq)) {
+        safeCursorSeq = seq;
+        if (visibleRows >= limit || visibleBytes >= maxBytes) {
+          stoppedAtBudget = true;
+          break;
+        }
+      }
+      if (visibleRows < limit && visibleBytes < maxBytes) continue;
       extensionRows += 1;
-      if (extensionRows >= DELTA_TOOL_PAIR_EXTENSION_CAP) break;
+      if (extensionRows >= DELTA_TOOL_PAIR_EXTENSION_CAP) {
+        stoppedAtBudget = true;
+        break;
+      }
     }
     // If the extension cap stopped inside a malformed arc, return only the
     // prefix covered by the safe cursor. Returning later rows with an earlier
@@ -1823,10 +2022,20 @@ export class ConversationStore {
           return Number.isFinite(seq) && seq <= safeCursorSeq;
         });
     const sliced = pairSanitize(pairSafeRows);
+    let hasMoreAfter = false;
+    if (stoppedAtBudget) {
+      hasMoreAfter = !deltaRows.next().done;
+    } else if (typeof deltaRows.return === 'function') {
+      deltaRows.return();
+    }
     // Never advance past a row the sanitizer had to drop. A malformed or
     // over-cap tool arc must be retried from its assistant call rather than
     // turning the following result into a permanent orphan on the next page.
-    return { messages: projectVisibleSessionMessages(sliced), latestSeq: safeCursorSeq };
+    return {
+      messages: projectVisibleSessionMessages(sliced),
+      latestSeq: safeCursorSeq,
+      hasMoreAfter,
+    };
   }
   /**

package/yeaft/web-bridge.js CHANGED Viewed

@@ -1421,7 +1421,7 @@ function projectVisibleHistoryChunkMessages(messages = []) {
     }));
 }
-function emitHistoryChunk({ sessionId, messages, mode = 'older', oldestSeq = null, nextBeforeSeq = null, hasMore = false, latestSeq = null, afterSeq = null, turns = null, pageKind = null, gapStopAtSeq = null, cacheEpoch = null, requestId = null, requestClientId = null, perfTraceId = null }) {
+function emitHistoryChunk({ sessionId, messages, mode = 'older', oldestSeq = null, nextBeforeSeq = null, hasMore = false, latestSeq = null, afterSeq = null, hasMoreAfter = false, streamId = null, revision = null, turns = null, pageKind = null, gapStopAtSeq = null, cacheEpoch = null, requestId = null, requestClientId = null, perfTraceId = null }) {
   const projectedMessages = projectVisibleHistoryChunkMessages(messages);
   // Empty deltas still carry the authoritative safe cursor and clear the
   // browser's syncingAfterSeq fence. Dropping this envelope leaves Session
@@ -1440,6 +1440,9 @@ function emitHistoryChunk({ sessionId, messages, mode = 'older', oldestSeq = nul
     hasMore: !!hasMore,
     latestSeq,
     afterSeq,
+    hasMoreAfter: !!hasMoreAfter,
+    streamId,
+    revision,
     turns,
     ...(pageKind ? { pageKind } : {}),
     ...(Number.isFinite(gapStopAtSeq) ? { gapStopAtSeq } : {}),
@@ -1499,6 +1502,9 @@ function emitLegacyHistoryOutputFrames(replayEntries) {
 }
 function emitVisibleHistoryReplay({ store, sessionId, limit, beforeSeq = null, mode = 'recent', requestId = null, requestClientId = null, perfTraceId = null }) {
+  const historyMetadata = sessionId && typeof store.getSessionHistoryMetadata === 'function'
+    ? store.getSessionHistoryMetadata(sessionId)
+    : null;
   const visiblePage = sessionId
     ? loadVisibleGroupHistoryPage(store, sessionId, limit, beforeSeq)
     : { messages: limit > 0 ? (store.loadRecent?.(limit) || []) : [], oldestSeq: null, hasMore: false };
@@ -1520,6 +1526,8 @@ function emitVisibleHistoryReplay({ store, sessionId, limit, beforeSeq = null, m
       nextBeforeSeq: visiblePage.nextBeforeSeq,
       hasMore: visiblePage.hasMore,
       latestSeq: Number.isFinite(latestSeq) ? latestSeq : null,
+      streamId: historyMetadata?.streamId || null,
+      revision: historyMetadata?.revision ?? null,
       turns: limit,
       requestId,
       requestClientId,
@@ -6762,7 +6770,20 @@ export async function handleYeaftLoadHistory(msg) {
     // and wants only the messages that arrived after that cursor. Returns
     // mode:'delta' so the frontend can append+dedupe instead of replacing
     // the pane.
-    const afterSeqRaw = (msg && Number.isFinite(msg.afterSeq)) ? msg.afterSeq : null;
+    const deltaLimit = Number.isFinite(msg?.maxRows)
+      ? Math.min(500, Math.max(1, Math.floor(msg.maxRows)))
+      : 100;
+    const deltaMaxBytes = Number.isFinite(msg?.maxBytes)
+      ? Math.min(2 * 1024 * 1024, Math.max(32 * 1024, Math.floor(msg.maxBytes)))
+      : 512 * 1024;
+    const historyMetadata = typeof session.conversationStore.getSessionHistoryMetadata === 'function'
+      ? session.conversationStore.getSessionHistoryMetadata(sessionId)
+      : null;
+    const cacheIdentityMatches = !msg?.streamId || (
+      msg.streamId === historyMetadata?.streamId
+      && Number(msg.revision) === Number(historyMetadata?.revision)
+    );
+    const afterSeqRaw = cacheIdentityMatches && msg && Number.isFinite(msg.afterSeq) ? msg.afterSeq : null;
     const afterMessageId = (msg && typeof msg.afterMessageId === 'string') ? msg.afterMessageId : null;
     let afterSeq = afterSeqRaw;
     if (afterSeq === null && afterMessageId && typeof session.conversationStore.getMessageSeqById === 'function') {
@@ -6770,7 +6791,10 @@ export async function handleYeaftLoadHistory(msg) {
     }
     if (sessionId && afterSeq !== null && typeof session.conversationStore.loadAfterSeqByGroup === 'function') {
       const loadStart = perfNowMs();
-      const delta = session.conversationStore.loadAfterSeqByGroup(sessionId, afterSeq);
+      const delta = session.conversationStore.loadAfterSeqByGroup(sessionId, afterSeq, {
+        limit: deltaLimit,
+        maxBytes: deltaMaxBytes,
+      });
       traceDuration('history.store_load_delta', loadStart, { detail: { count: delta.messages?.length || 0, afterSeq } });
       const emitStart = perfNowMs();
       const projectedMessages = emitHistoryChunk({
@@ -6779,6 +6803,9 @@ export async function handleYeaftLoadHistory(msg) {
         mode: 'delta',
         latestSeq: delta.latestSeq,
         afterSeq,
+        hasMoreAfter: delta.hasMoreAfter,
+        streamId: historyMetadata?.streamId || null,
+        revision: historyMetadata?.revision ?? null,
         requestId,
         requestClientId,
         perfTraceId,
@@ -6792,6 +6819,9 @@ export async function handleYeaftLoadHistory(msg) {
         requestId,
         latestSeq: delta.latestSeq,
         afterSeq,
+        hasMoreAfter: !!delta.hasMoreAfter,
+        streamId: historyMetadata?.streamId || null,
+        revision: historyMetadata?.revision ?? null,
       }, { sessionId, requestId, requestClientId, perfTraceId });
       return;
     }
@@ -6832,6 +6862,8 @@ export async function handleYeaftLoadHistory(msg) {
         nextBeforeSeq: visiblePage.nextBeforeSeq,
         hasMore: visiblePage.hasMore,
         latestSeq,
+        streamId: historyMetadata?.streamId || null,
+        revision: historyMetadata?.revision ?? null,
         turns: limit,
         requestId,
         requestClientId,
@@ -6874,12 +6906,19 @@ export async function handleYeaftLoadHistory(msg) {
       oldestSeq,
       nextBeforeSeq: visiblePage.nextBeforeSeq,
       latestSeq,
+      streamId: historyMetadata?.streamId || null,
+      revision: historyMetadata?.revision ?? null,
     }, { sessionId, requestId, requestClientId, perfTraceId });
   };
   if (!session) {
     const yeaftDir = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
-    const afterSeqRaw = (msg && Number.isFinite(msg.afterSeq)) ? msg.afterSeq : null;
+    const deltaLimit = Number.isFinite(msg?.maxRows)
+      ? Math.min(500, Math.max(1, Math.floor(msg.maxRows)))
+      : 100;
+    const deltaMaxBytes = Number.isFinite(msg?.maxBytes)
+      ? Math.min(2 * 1024 * 1024, Math.max(32 * 1024, Math.floor(msg.maxBytes)))
+      : 512 * 1024;
     const afterMessageId = (msg && typeof msg.afterMessageId === 'string') ? msg.afterMessageId : null;
     const limit = (typeof msg.limit === 'number') ? msg.limit : 10;
     ensureYeaftConversationId();
@@ -6902,6 +6941,14 @@ export async function handleYeaftLoadHistory(msg) {
     // window immediately, then finish loadSession below for actual turns.
     const coldStoreStart = perfNowMs();
     const coldStore = new ConversationStore(historyYeaftDir);
+    const historyMetadata = sessionId && typeof coldStore.getSessionHistoryMetadata === 'function'
+      ? coldStore.getSessionHistoryMetadata(sessionId)
+      : null;
+    const cacheIdentityMatches = !msg?.streamId || (
+      msg.streamId === historyMetadata?.streamId
+      && Number(msg.revision) === Number(historyMetadata?.revision)
+    );
+    const afterSeqRaw = cacheIdentityMatches && msg && Number.isFinite(msg.afterSeq) ? msg.afterSeq : null;
     traceDuration('history.cold_store_open', coldStoreStart);
     if (sessionId && (afterSeqRaw !== null || afterMessageId)) {
       let afterSeq = afterSeqRaw;
@@ -6910,8 +6957,11 @@ export async function handleYeaftLoadHistory(msg) {
       }
       const loadStart = perfNowMs();
       const delta = afterSeq !== null && typeof coldStore.loadAfterSeqByGroup === 'function'
-        ? coldStore.loadAfterSeqByGroup(sessionId, afterSeq)
-        : { messages: [], latestSeq: null };
+        ? coldStore.loadAfterSeqByGroup(sessionId, afterSeq, {
+            limit: deltaLimit,
+            maxBytes: deltaMaxBytes,
+          })
+        : { messages: [], latestSeq: null, hasMoreAfter: false };
       traceDuration('history.store_load_delta', loadStart, { detail: { count: delta.messages?.length || 0, afterSeq, cold: true } });
       const emitStart = perfNowMs();
       const projectedMessages = emitHistoryChunk({
@@ -6920,12 +6970,26 @@ export async function handleYeaftLoadHistory(msg) {
         mode: 'delta',
         latestSeq: delta.latestSeq,
         afterSeq,
+        hasMoreAfter: delta.hasMoreAfter,
+        streamId: historyMetadata?.streamId || null,
+        revision: historyMetadata?.revision ?? null,
         requestId,
         requestClientId,
         perfTraceId,
       });
       traceDuration('history.emit_chunk', emitStart, { detail: { mode: 'delta', count: projectedMessages.length, cold: true } });
-      sendSessionEvent({ type: 'history_loaded', mode: 'delta', count: projectedMessages.length, sessionId, requestId, latestSeq: delta.latestSeq, afterSeq }, { sessionId, requestId, requestClientId, perfTraceId });
+      sendSessionEvent({
+        type: 'history_loaded',
+        mode: 'delta',
+        count: projectedMessages.length,
+        sessionId,
+        requestId,
+        latestSeq: delta.latestSeq,
+        afterSeq,
+        hasMoreAfter: !!delta.hasMoreAfter,
+        streamId: historyMetadata?.streamId || null,
+        revision: historyMetadata?.revision ?? null,
+      }, { sessionId, requestId, requestClientId, perfTraceId });
     } else if (!metadataOnly) {
       const replayStart = perfNowMs();
       emitVisibleHistoryReplay({ store: coldStore, sessionId, limit, mode: 'recent', requestId, requestClientId, perfTraceId });