cursorconnect 0.1.7 → 0.1.9

package/bridge-runtime/dist/chat-display-store.d.ts

@@ -1,25 +1,50 @@
 import type { ChatMessage, HistoryMessage } from './types.js';
 /**
- * Chat UI store: JSONL baseline for `agent:messages` (client lenta).
- * DOM transcript kept for debug snapshot only — not sent as liveMessages.
+ * Chat UI store: JSONL baseline + DOM overlay tail.
+ *
+ * Invariant:
+ * - JSONL baseline = everything already in `.jsonl` (monotonic archive order).
+ * - DOM overlay = viewport rows **not covered** by JSONL (`archiveCoversOverlay`).
+ * - While a row streams in DOM but JSONL is shorter → overlay keeps it; when JSONL catches up → overlay drops (no duplicate).
+ * - App lenta = `[...jsonlHistory, ...domOverlay]` — never sort both by DOM flatIndex.
  */
 export declare class ChatDisplayStore {
     private readonly domTranscript;
+    /** Last CDP viewport extract per agent — sole source for live overlay. */
+    private readonly latestDomViewport;
     private readonly jsonlBaseline;
     /** Raw JSONL row count per agent — incremental display merge during streaming. */
     private readonly jsonlRowCount;
+    /** While true, bridge pushes lenta on DOM ingest (emit path); overlay filter unchanged. */
+    private readonly generatingByAgent;
     clearAgent(agentId: string): void;
+    setAgentGenerating(agentId: string, generating: boolean): void;
+    isAgentGenerating(agentId: string): boolean;
     getJsonlHistory(agentId: string): ChatMessage[];
     getDomLive(agentId: string): ChatMessage[];
-    /** Reload JSONL; prune DOM rows now covered by archive. */
+    /** Reload JSONL; drop viewport rows now covered by archive. */
     setJsonlBaseline(agentId: string, rows: HistoryMessage[]): void;
     /** Append JSONL rows during live stream; returns new/updated bubbles for socket `append` emit. */
     appendJsonlRows(agentId: string, deltaRows: HistoryMessage[]): ChatMessage[];
-    /** Ingest DOM extract; overlay keeps only rows not in JSONL. */
+    /** Ingest DOM extract; overlay = viewport minus JSONL-covered rows. */
     mergeLiveForAgent(agentId: string, rawDom: ChatMessage[]): void;
-    /** Debug / snapshot: combined view. */
+    /** Canonical UI lenta: archive then live tail (append-only, no cross-sort). */
     getDisplayMessages(agentId: string): ChatMessage[];
-    getDomTranscript(agentId: string): ChatMessage[];
-    private domOverlayOnly;
+    /** Raw DOM ingest before JSONL filter / stamp (debug only). */
+    getDomTranscriptRaw(agentId: string): ChatMessage[];
+    /** Snapshot for `/debug/lenta` and lenta:watch. */
+    getLentaDebug(agentId: string): {
+        jsonlRowCount: number;
+        jsonlHistory: ChatMessage[];
+        domOverlay: ChatMessage[];
+        domRaw: ChatMessage[];
+        messages: ChatMessage[];
+        source: 'jsonl' | 'hybrid';
+        agentGenerating: boolean;
+    };
+    /** JSONL rows used to suppress DOM overlay (baseline + displayed archive). */
+    private archiveForOverlayMatch;
+    /** Shrink cached viewport to rows still missing from JSONL (handoff DOM → JSONL). */
+    private reconcileDomViewportToArchive;
     private pruneDomOverlay;
 }

package/bridge-runtime/dist/chat-display-store.js

@@ -1,29 +1,63 @@
-import { filterClientDisplayList, historyRowsToChat, mergeHistoryTail, messagesEquivalent, prepareChatMessagesForDisplay, } from './chat-display.js';
+import { archiveOrderFloor, filterClientDisplayList, historyRowsToChat, mergeHistoryTail, prepareChatMessagesForDisplay, prepareDomOverlayForDisplay, selectDomOverlayFromViewport, stampOverlayAfterArchive, } from './chat-display.js';
 import { DomTranscriptStore } from './dom-transcript-store.js';
 /**
- * Chat UI store: JSONL baseline for `agent:messages` (client lenta).
- * DOM transcript kept for debug snapshot only — not sent as liveMessages.
+ * Chat UI store: JSONL baseline + DOM overlay tail.
+ *
+ * Invariant:
+ * - JSONL baseline = everything already in `.jsonl` (monotonic archive order).
+ * - DOM overlay = viewport rows **not covered** by JSONL (`archiveCoversOverlay`).
+ * - While a row streams in DOM but JSONL is shorter → overlay keeps it; when JSONL catches up → overlay drops (no duplicate).
+ * - App lenta = `[...jsonlHistory, ...domOverlay]` — never sort both by DOM flatIndex.
  */
 export class ChatDisplayStore {
     domTranscript = new DomTranscriptStore();
+    /** Last CDP viewport extract per agent — sole source for live overlay. */
+    latestDomViewport = new Map();
     jsonlBaseline = new Map();
     /** Raw JSONL row count per agent — incremental display merge during streaming. */
     jsonlRowCount = new Map();
+    /** While true, bridge pushes lenta on DOM ingest (emit path); overlay filter unchanged. */
+    generatingByAgent = new Map();
     clearAgent(agentId) {
         this.domTranscript.clear(agentId);
+        this.latestDomViewport.delete(agentId);
         this.jsonlBaseline.delete(agentId);
         this.jsonlRowCount.delete(agentId);
+        this.generatingByAgent.delete(agentId);
+    }
+    setAgentGenerating(agentId, generating) {
+        if (generating)
+            this.generatingByAgent.set(agentId, true);
+        else {
+            this.generatingByAgent.delete(agentId);
+            this.reconcileDomViewportToArchive(agentId);
+            this.pruneDomOverlay(agentId);
+        }
+    }
+    isAgentGenerating(agentId) {
+        return this.generatingByAgent.get(agentId) ?? false;
     }
     getJsonlHistory(agentId) {
         return filterClientDisplayList(this.jsonlBaseline.get(agentId) ?? []);
     }
     getDomLive(agentId) {
-        const history = this.jsonlBaseline.get(agentId) ?? [];
-        return filterClientDisplayList(this.domOverlayOnly(agentId, history));
+        const archive = this.archiveForOverlayMatch(agentId);
+        const dom = selectDomOverlayFromViewport(this.latestDomViewport.get(agentId) ?? [], archive);
+        if (!dom.length)
+            return [];
+        if (!archive.length) {
+            return filterClientDisplayList(prepareChatMessagesForDisplay(dom));
+        }
+        const floor = archiveOrderFloor(archive, this.jsonlRowCount.get(agentId) ?? 0);
+        const stamped = stampOverlayAfterArchive(floor, dom);
+        return filterClientDisplayList(prepareDomOverlayForDisplay(stamped));
     }
-    /** Reload JSONL; prune DOM rows now covered by archive. */
+    /** Reload JSONL; drop viewport rows now covered by archive. */
     setJsonlBaseline(agentId, rows) {
         const prevRows = this.jsonlRowCount.get(agentId) ?? 0;
+        if (rows.length > 0 && prevRows > 24 && rows.length < prevRows - 12) {
+            return;
+        }
         const prev = this.jsonlBaseline.get(agentId) ?? [];
         let prepared;
         if (rows.length > prevRows && prevRows > 0 && prev.length && rows.length - prevRows <= 128) {
@@ -38,6 +72,7 @@ export class ChatDisplayStore {
         }
         this.jsonlRowCount.set(agentId, rows.length);
         this.jsonlBaseline.set(agentId, prepared);
+        this.reconcileDomViewportToArchive(agentId);
         this.pruneDomOverlay(agentId);
     }
     /** Append JSONL rows during live stream; returns new/updated bubbles for socket `append` emit. */
@@ -50,6 +85,7 @@ export class ChatDisplayStore {
         const prepared = mergeHistoryTail(prev, deltaChat);
         this.jsonlRowCount.set(agentId, (this.jsonlRowCount.get(agentId) ?? 0) + deltaRows.length);
         this.jsonlBaseline.set(agentId, prepared);
+        this.reconcileDomViewportToArchive(agentId);
         this.pruneDomOverlay(agentId);
         if (prepared.length > prevLen)
             return prepared.slice(prevLen);
@@ -69,32 +105,74 @@ export class ChatDisplayStore {
             return prepared;
         return deltaChat.length ? deltaChat : [];
     }
-    /** Ingest DOM extract; overlay keeps only rows not in JSONL. */
+    /** Ingest DOM extract; overlay = viewport minus JSONL-covered rows. */
     mergeLiveForAgent(agentId, rawDom) {
         const live = prepareChatMessagesForDisplay(rawDom);
-        if (live.length)
+        if (live.length) {
+            this.latestDomViewport.set(agentId, live);
             this.domTranscript.ingest(agentId, live);
+            this.domTranscript.reconcileToViewport(agentId, live);
+        }
+        else {
+            this.latestDomViewport.delete(agentId);
+            this.domTranscript.reconcileToViewport(agentId, []);
+        }
+        this.reconcileDomViewportToArchive(agentId);
         this.pruneDomOverlay(agentId);
     }
-    /** Debug / snapshot: combined view. */
+    /** Canonical UI lenta: archive then live tail (append-only, no cross-sort). */
     getDisplayMessages(agentId) {
         return [...this.getJsonlHistory(agentId), ...this.getDomLive(agentId)];
     }
-    getDomTranscript(agentId) {
-        return this.getDisplayMessages(agentId);
+    /** Raw DOM ingest before JSONL filter / stamp (debug only). */
+    getDomTranscriptRaw(agentId) {
+        return this.domTranscript.list(agentId);
     }
-    domOverlayOnly(agentId, history) {
-        const dom = this.domTranscript.list(agentId);
-        if (!dom.length)
-            return [];
-        if (!history.length)
-            return dom;
-        return dom.filter((d) => !history.some((h) => messagesEquivalent(h, d)));
+    /** Snapshot for `/debug/lenta` and lenta:watch. */
+    getLentaDebug(agentId) {
+        const jsonlHistory = this.getJsonlHistory(agentId);
+        const domOverlay = this.getDomLive(agentId);
+        return {
+            jsonlRowCount: this.jsonlRowCount.get(agentId) ?? 0,
+            jsonlHistory,
+            domOverlay,
+            domRaw: this.getDomTranscriptRaw(agentId),
+            messages: this.getDisplayMessages(agentId),
+            source: domOverlay.length ? 'hybrid' : 'jsonl',
+            agentGenerating: this.isAgentGenerating(agentId),
+        };
+    }
+    /** JSONL rows used to suppress DOM overlay (baseline + displayed archive). */
+    archiveForOverlayMatch(agentId) {
+        const baseline = this.jsonlBaseline.get(agentId) ?? [];
+        const displayed = this.getJsonlHistory(agentId);
+        const seen = new Set();
+        const out = [];
+        for (const m of [...baseline, ...displayed]) {
+            const key = `${m.role}:${m.id ?? ''}:${m.flatIndex ?? ''}:${(m.text ?? '').slice(0, 48)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(m);
+        }
+        return out;
+    }
+    /** Shrink cached viewport to rows still missing from JSONL (handoff DOM → JSONL). */
+    reconcileDomViewportToArchive(agentId) {
+        const dom = this.latestDomViewport.get(agentId);
+        if (!dom?.length)
+            return;
+        const archive = this.archiveForOverlayMatch(agentId);
+        const kept = selectDomOverlayFromViewport(dom, archive);
+        if (kept.length)
+            this.latestDomViewport.set(agentId, kept);
+        else
+            this.latestDomViewport.delete(agentId);
     }
     pruneDomOverlay(agentId) {
-        const history = this.jsonlBaseline.get(agentId) ?? [];
-        if (!history.length)
+        const archive = this.archiveForOverlayMatch(agentId);
+        if (!archive.length)
             return;
-        this.domTranscript.pruneCoveredBy(agentId, history);
+        this.domTranscript.pruneCoveredBy(agentId, archive);
     }
 }

package/bridge-runtime/dist/chat-display.d.ts

@@ -2,11 +2,47 @@ import type { ChatMessage, HistoryMessage } from './types.js';
 export declare function compareUserText(text: string): string;
 export declare function userTextsEquivalent(ta: string, tb: string): boolean;
 export declare function userMessagesEquivalent(a: ChatMessage, b: ChatMessage): boolean;
+/**
+ * JSONL `flatIndex` = file line number (~1..N); Cursor DOM = `data-flat-index` (often 1000+).
+ * When DOM is ahead of the archive tail, fuzzy cover hid live rows (debug: NEEDS_DOM_OVERLAY, overlay 0).
+ */
+export declare const JSONL_DOM_ORDER_GAP = 32;
+export declare function maxArchiveOrderKey(archive: ChatMessage[]): number;
+export declare function isDomOrderAheadOfJsonlArchive(overlay: ChatMessage, maxArchiveKey: number): boolean;
+/** Exact / near-exact match only — no word-bag (safe when DOM timeline > JSONL tail). */
+export declare function archiveCoversOverlayStrict(archive: ChatMessage, overlay: ChatMessage): boolean;
+/**
+ * Viewport rows for the live tail: not yet represented in JSONL archive.
+ * Uses `archiveCoversOverlay` (strict / fuzzy / streaming) — same rule for idle and generating.
+ */
+export declare function selectDomOverlayFromViewport(viewport: ChatMessage[], archive: ChatMessage[]): ChatMessage[];
+/** JSONL archive covers a DOM overlay row (DOM may be a truncated viewport). */
+export declare function archiveCoversOverlay(archive: ChatMessage, overlay: ChatMessage, opts?: {
+    maxArchiveKey?: number;
+}): boolean;
 export declare function messagesEquivalent(a: ChatMessage, b: ChatMessage): boolean;
 export declare function pickPreferredMessage(prev: ChatMessage, next: ChatMessage, preferNext: boolean): ChatMessage;
+export declare function messageOrderKey(m: ChatMessage): number;
+/** DOM flat-index vs JSONL line ts — see app `anchorDomOverlaySortKeys`. */
+export declare function anchorDomOverlaySortKeys(history: ChatMessage[], live: ChatMessage[]): ChatMessage[];
 export declare function sortMessagesChronologically(messages: ChatMessage[]): ChatMessage[];
 export declare function prepareChatMessagesForDisplay(messages: ChatMessage[]): ChatMessage[];
 export declare function mergeHistoryTail(prev: ChatMessage[], incoming: ChatMessage[]): ChatMessage[];
+/** Document order inside one DOM extract — never Cursor viewport flatIndex alone. */
+export declare function sortByDomDocumentOrder(messages: ChatMessage[]): ChatMessage[];
+/** Force overlay keys above archive so any sort by flatIndex stays below JSONL tail. */
+export declare function stampOverlayAfterArchive(archiveFloor: number, overlay: ChatMessage[]): ChatMessage[];
+export declare function archiveOrderFloor(jsonlHistory: ChatMessage[], rawJsonlRows: number): number;
+/** Dedupe/collapse overlay only; order = domSeq (then stamped flatIndex). */
+export declare function prepareDomOverlayForDisplay(overlay: ChatMessage[]): ChatMessage[];
+/**
+ * Lenta for app: JSONL archive first, DOM overlay append-only.
+ * Order = array order here; app must not re-sort by flatIndex across the join.
+ */
+export declare function composeDisplayLenta(jsonlHistory: ChatMessage[], domOverlay: ChatMessage[]): ChatMessage[];
+/** Dev: warn if composed lenta inverts archive keys. */
+export declare function assertMonotonicLenta(messages: ChatMessage[], label: string): void;
+/** @deprecated Use `composeDisplayLenta` — kept for tests/tools. */
 export declare function mergeDomWithHistory(history: ChatMessage[], live: ChatMessage[]): ChatMessage[];
 export declare function historyRowsToChat(rows: HistoryMessage[]): ChatMessage[];
 export declare function filterClientDisplayList(messages: ChatMessage[]): ChatMessage[];

package/bridge-runtime/dist/chat-display.js

@@ -49,6 +49,13 @@ export function userTextsEquivalent(ta, tb) {
     if (short.length < 12)
         return false;
     if (long.includes(short)) {
+        // Новый user_query, цитирующий старый внутри длинного текста — не дедупить.
+        if (long.length > short.length * 1.2 &&
+            /<user_query>/i.test(long) &&
+            !long.startsWith(short) &&
+            !long.endsWith(short)) {
+            return false;
+        }
         if (long.endsWith(short) || long.startsWith(short))
             return true;
         if (short.length / long.length >= 0.4)
@@ -118,6 +125,9 @@ function pickPreferredUserMessage(a, b, preferB) {
 /** DOM textContent vs JSONL markdown — same turn, different surface form. */
 function normalizeAssistantCompareText(text) {
     return text
+        .replace(/[\u2013\u2014\u2212]/g, '-')
+        .replace(/\*\*/g, '')
+        .replace(/`+/g, '')
         .replace(/^#+\s*/gm, '')
         .replace(/\|/g, ' ')
         .replace(/[-]{3,}/g, ' ')
@@ -125,6 +135,18 @@ function normalizeAssistantCompareText(text) {
         .trim()
         .toLowerCase();
 }
+function wordBagOverlapRatio(textA, textB) {
+    const wa = new Set((textA.match(/[\p{L}\p{N}]{3,}/gu) ?? []).map((w) => w.toLowerCase()));
+    const wb = new Set((textB.match(/[\p{L}\p{N}]{3,}/gu) ?? []).map((w) => w.toLowerCase()));
+    if (!wa.size || !wb.size)
+        return 0;
+    let shared = 0;
+    for (const w of wa) {
+        if (wb.has(w))
+            shared++;
+    }
+    return shared / Math.min(wa.size, wb.size);
+}
 function assistantTextsEquivalent(a, b) {
     if (a.role !== 'assistant' || b.role !== 'assistant')
         return false;
@@ -140,7 +162,167 @@ function assistantTextsEquivalent(a, b) {
         return false;
     if (!long.includes(short))
         return false;
-    return short.length / long.length >= 0.35;
+    if (long.startsWith(short) && short.length >= 32)
+        return true;
+    return short.length / Math.min(long.length, 1200) >= 0.35;
+}
+/** Same idea as `/debug/chats` compare — DOM textContent vs JSONL markdown. */
+function compactOverlayMatchText(text, role) {
+    const base = role === 'assistant' ? normalizeAssistantCompareText(text) : compareUserText(text);
+    return base.replace(/\s/g, '');
+}
+function overlaySurfaceText(m) {
+    const t = (m.text ?? '').trim();
+    if (t)
+        return t;
+    return (m.html ?? '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function compactTextsMatchArchiveOverlay(archive, overlay) {
+    const role = archive.role;
+    const ta = compactOverlayMatchText(overlaySurfaceText(archive), role);
+    const tb = compactOverlayMatchText(overlaySurfaceText(overlay), role);
+    if (!ta || !tb)
+        return false;
+    if (ta === tb)
+        return true;
+    const short = ta.length <= tb.length ? ta : tb;
+    const long = ta.length <= tb.length ? tb : ta;
+    if (short.length < 24)
+        return false;
+    if (long.startsWith(short))
+        return true;
+    if (long.includes(short) && short.length / Math.min(long.length, 1600) >= 0.28) {
+        return true;
+    }
+    return false;
+}
+function assistantArchiveCoversOverlay(archive, overlay) {
+    if (assistantTextsEquivalent(archive, overlay) || messagesEquivalent(archive, overlay)) {
+        return true;
+    }
+    if (compactTextsMatchArchiveOverlay(archive, overlay))
+        return true;
+    const ta = normalizeAssistantCompareText(overlaySurfaceText(archive));
+    const tb = normalizeAssistantCompareText(overlaySurfaceText(overlay));
+    if (!ta || !tb)
+        return false;
+    const head = 72;
+    if (ta.slice(0, head) === tb.slice(0, head) && head >= 40)
+        return true;
+    const short = ta.length <= tb.length ? ta : tb;
+    const long = ta.length <= tb.length ? tb : ta;
+    if (short.length >= 48 && long.includes(short))
+        return true;
+    // DOM textContent vs JSONL markdown: таблицы/тире дают 1–2 отличия на тысячи символов.
+    if (ta.length >= 120 && tb.length >= 120) {
+        if (wordBagOverlapRatio(ta, tb) >= 0.88)
+            return true;
+        if (wordBagOverlapRatio(ta.slice(0, 420), tb.slice(0, 420)) >= 0.92 &&
+            ta.slice(0, 56) === tb.slice(0, 56)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * JSONL `flatIndex` = file line number (~1..N); Cursor DOM = `data-flat-index` (often 1000+).
+ * When DOM is ahead of the archive tail, fuzzy cover hid live rows (debug: NEEDS_DOM_OVERLAY, overlay 0).
+ */
+export const JSONL_DOM_ORDER_GAP = 32;
+export function maxArchiveOrderKey(archive) {
+    let max = 0;
+    for (const m of archive)
+        max = Math.max(max, messageOrderKey(m));
+    return max;
+}
+function isCursorDomOverlayRow(overlay) {
+    const id = overlay.id ?? '';
+    if (id.startsWith('hist-'))
+        return false;
+    const flat = overlay.flatIndex;
+    return flat != null && Number.isFinite(flat) && flat >= 64;
+}
+export function isDomOrderAheadOfJsonlArchive(overlay, maxArchiveKey) {
+    if (!isCursorDomOverlayRow(overlay))
+        return false;
+    return (overlay.flatIndex ?? 0) > maxArchiveKey + JSONL_DOM_ORDER_GAP;
+}
+/** Exact / near-exact match only — no word-bag (safe when DOM timeline > JSONL tail). */
+export function archiveCoversOverlayStrict(archive, overlay) {
+    if (archive.role !== overlay.role)
+        return false;
+    if (archive.role === 'user') {
+        if (compactTextsMatchArchiveOverlay(archive, overlay))
+            return true;
+        return userMessagesEquivalent(archive, overlay);
+    }
+    if (archive.role === 'assistant') {
+        return (assistantTextsEquivalent(archive, overlay) ||
+            messagesEquivalent(archive, overlay) ||
+            compactTextsMatchArchiveOverlay(archive, overlay));
+    }
+    return messagesEquivalent(archive, overlay);
+}
+/** Fuzzy match (markdown vs DOM textContent, word-bag, prefixes). */
+function archiveCoversOverlayFuzzy(archive, overlay) {
+    if (archive.role !== overlay.role)
+        return false;
+    if (archive.role === 'user') {
+        if (compactTextsMatchArchiveOverlay(archive, overlay))
+            return true;
+        const a = compareUserText(overlaySurfaceText(archive));
+        const b = compareUserText(overlaySurfaceText(overlay));
+        if (!a || !b)
+            return false;
+        if (a === b)
+            return true;
+        const short = a.length <= b.length ? a : b;
+        const long = a.length <= b.length ? b : a;
+        return short.length >= 24 && long.includes(short);
+    }
+    if (archive.role === 'assistant') {
+        return assistantArchiveCoversOverlay(archive, overlay);
+    }
+    return messagesEquivalent(archive, overlay);
+}
+/**
+ * When DOM flat-index is ahead of JSONL line keys, allow fuzzy dedupe once JSONL caught up,
+ * but keep overlay if DOM body is still growing (streaming).
+ */
+const DOM_AHEAD_STREAM_MARGIN = { assistant: 48, user: 24 };
+function overlayStillStreamingPastArchive(archive, overlay) {
+    const aLen = (archive.text ?? '').trim().length;
+    const oLen = (overlay.text ?? '').trim().length;
+    if (!aLen || !oLen)
+        return false;
+    const margin = overlay.role === 'user' ? DOM_AHEAD_STREAM_MARGIN.user : DOM_AHEAD_STREAM_MARGIN.assistant;
+    return oLen > aLen + margin;
+}
+/**
+ * Viewport rows for the live tail: not yet represented in JSONL archive.
+ * Uses `archiveCoversOverlay` (strict / fuzzy / streaming) — same rule for idle and generating.
+ */
+export function selectDomOverlayFromViewport(viewport, archive) {
+    if (!viewport.length)
+        return [];
+    if (!archive.length)
+        return viewport;
+    const maxArchiveKey = maxArchiveOrderKey(archive);
+    return viewport.filter((d) => !archive.some((h) => archiveCoversOverlay(h, d, { maxArchiveKey })));
+}
+/** JSONL archive covers a DOM overlay row (DOM may be a truncated viewport). */
+export function archiveCoversOverlay(archive, overlay, opts) {
+    const maxKey = opts?.maxArchiveKey;
+    if (maxKey != null && isDomOrderAheadOfJsonlArchive(overlay, maxKey)) {
+        if (archiveCoversOverlayStrict(archive, overlay))
+            return true;
+        if (!archiveCoversOverlayFuzzy(archive, overlay))
+            return false;
+        if (overlayStillStreamingPastArchive(archive, overlay))
+            return false;
+        return true;
+    }
+    return archiveCoversOverlayFuzzy(archive, overlay);
 }
 function messageKey(m) {
     const n = normalizeMessage(m);
@@ -195,16 +377,30 @@ export function pickPreferredMessage(prev, next, preferNext) {
         pick = preferNext ? next : prev;
     return mergeTimelineFields(prev, next, pick);
 }
-function messageOrderKey(m) {
+export function messageOrderKey(m) {
     if (m.flatIndex != null && Number.isFinite(m.flatIndex))
         return m.flatIndex;
     if (m.domSeq != null && Number.isFinite(m.domSeq))
         return m.domSeq;
-    const hist = /^hist-(\d+)/.exec(m.id);
+    const hist = /^hist-(\d+)/.exec(m.id ?? '');
     if (hist)
         return Number(hist[1]);
     return 0;
 }
+/** DOM flat-index vs JSONL line ts — see app `anchorDomOverlaySortKeys`. */
+export function anchorDomOverlaySortKeys(history, live) {
+    if (!live.length)
+        return live;
+    let maxKey = -1;
+    for (const m of history) {
+        maxKey = Math.max(maxKey, messageOrderKey(m));
+    }
+    const sortedLive = sortMessagesChronologically(live);
+    return sortedLive.map((m, i) => ({
+        ...m,
+        flatIndex: maxKey + 1 + i,
+    }));
+}
 export function sortMessagesChronologically(messages) {
     return [...messages].sort((a, b) => {
         const ka = messageOrderKey(a);
@@ -331,6 +527,25 @@ function collapseAssistantBursts(messages) {
 export function prepareChatMessagesForDisplay(messages) {
     return collapseAssistantBursts(dedupeUserMessages(fixAssistantFragmentSandwich(messages)));
 }
+/** Tail overlap for JSONL incremental merge — user rows only on exact text (duplicate line in file). */
+function tailOverlapForMerge(prev, incoming) {
+    const max = Math.min(prev.length, incoming.length, 40);
+    let overlap = 0;
+    for (let n = 1; n <= max; n++) {
+        const a = prev.slice(-n);
+        const b = incoming.slice(0, n);
+        if (a.every((m, i) => {
+            const o = b[i];
+            if (m.role === 'user' && o.role === 'user') {
+                return compareUserText(m.text ?? '') === compareUserText(o.text ?? '');
+            }
+            return messagesEquivalent(m, o);
+        })) {
+            overlap = n;
+        }
+    }
+    return overlap;
+}
 function tailOverlap(history, live) {
     const max = Math.min(history.length, live.length, 40);
     let overlap = 0;
@@ -342,6 +557,13 @@ function tailOverlap(history, live) {
     }
     return overlap;
 }
+function mergeOverlappingBoundary(prev, incoming, overlap) {
+    let picked = prev[prev.length - overlap];
+    for (let i = 0; i < overlap; i++) {
+        picked = pickPreferredMessage(picked, incoming[i], true);
+    }
+    return picked;
+}
 function upsertLiveMessage(merged, m, live, overlap, preferNext) {
     const tailWindow = Math.max(live.length - overlap, 0) + 6;
     const searchFrom = Math.max(0, merged.length - tailWindow);
@@ -364,35 +586,76 @@ export function mergeHistoryTail(prev, incoming) {
         return prepareChatMessagesForDisplay(incoming);
     const prevN = normalizeAll(prev);
     const inc = normalizeAll(incoming);
-    let overlap = 0;
-    const maxOverlap = Math.min(prevN.length, inc.length, 40);
-    for (let n = 1; n <= maxOverlap; n++) {
-        const a = prevN.slice(-n);
-        const b = inc.slice(0, n);
-        if (a.every((m, i) => messagesEquivalent(m, b[i])))
-            overlap = n;
-    }
+    const overlap = tailOverlapForMerge(prevN, inc);
     const prefix = prevN.slice(0, Math.max(0, prevN.length - overlap));
     const merged = [...prefix];
+    if (overlap > 0) {
+        upsertLiveMessage(merged, mergeOverlappingBoundary(prevN, inc, overlap), inc, overlap, true);
+    }
     for (const m of inc.slice(overlap)) {
         upsertLiveMessage(merged, m, inc, overlap, true);
     }
     return prepareChatMessagesForDisplay(merged);
 }
-export function mergeDomWithHistory(history, live) {
-    const hist = dedupeUserMessages(history);
-    const collapsedLive = collapseAssistantBursts(live);
-    if (!collapsedLive.length)
-        return prepareChatMessagesForDisplay(hist);
-    if (!hist.length)
-        return prepareChatMessagesForDisplay(collapsedLive);
-    const overlap = tailOverlap(hist, collapsedLive);
-    const prefix = hist.slice(0, Math.max(0, hist.length - overlap));
-    const merged = [...prefix];
-    for (let i = overlap; i < collapsedLive.length; i++) {
-        upsertLiveMessage(merged, collapsedLive[i], collapsedLive, overlap, true);
+/** Document order inside one DOM extract — never Cursor viewport flatIndex alone. */
+export function sortByDomDocumentOrder(messages) {
+    return [...messages].sort((a, b) => {
+        const da = a.domSeq ?? 0;
+        const db = b.domSeq ?? 0;
+        if (da !== db)
+            return da - db;
+        return (a.flatIndex ?? 0) - (b.flatIndex ?? 0);
+    });
+}
+/** Force overlay keys above archive so any sort by flatIndex stays below JSONL tail. */
+export function stampOverlayAfterArchive(archiveFloor, overlay) {
+    let seq = Math.max(archiveFloor, 0);
+    return overlay.map((m) => {
+        seq += 1;
+        return { ...m, flatIndex: seq };
+    });
+}
+export function archiveOrderFloor(jsonlHistory, rawJsonlRows) {
+    let floor = Math.max(rawJsonlRows, 0);
+    for (const m of jsonlHistory) {
+        floor = Math.max(floor, messageOrderKey(m));
     }
-    return prepareChatMessagesForDisplay(merged);
+    return floor;
+}
+/** Dedupe/collapse overlay only; order = domSeq (then stamped flatIndex). */
+export function prepareDomOverlayForDisplay(overlay) {
+    if (!overlay.length)
+        return [];
+    return collapseAssistantBursts(dedupeUserMessages(sortByDomDocumentOrder(overlay)));
+}
+/**
+ * Lenta for app: JSONL archive first, DOM overlay append-only.
+ * Order = array order here; app must not re-sort by flatIndex across the join.
+ */
+export function composeDisplayLenta(jsonlHistory, domOverlay) {
+    if (!domOverlay.length)
+        return [...jsonlHistory];
+    if (!jsonlHistory.length)
+        return [...domOverlay];
+    return [...jsonlHistory, ...domOverlay];
+}
+/** Dev: warn if composed lenta inverts archive keys. */
+export function assertMonotonicLenta(messages, label) {
+    if (process.env.LENTA_ORDER_ASSERT !== '1')
+        return;
+    for (let i = 1; i < messages.length; i++) {
+        const prev = messageOrderKey(messages[i - 1]);
+        const cur = messageOrderKey(messages[i]);
+        if (cur < prev) {
+            console.warn(`[lenta-order] inversion ${label} i=${i} ${prev}>${cur}`);
+        }
+    }
+}
+/** @deprecated Use `composeDisplayLenta` — kept for tests/tools. */
+export function mergeDomWithHistory(history, live) {
+    const hist = prepareChatMessagesForDisplay(dedupeUserMessages(history));
+    const collapsedLive = prepareChatMessagesForDisplay(collapseAssistantBursts(live));
+    return composeDisplayLenta(hist, collapsedLive);
 }
 export function historyRowsToChat(rows) {
     return rows.map((m, i) => {

package/bridge-runtime/dist/chat-sync.d.ts

@@ -1,6 +1,8 @@
 import type { CursorState } from './types.js';
 export declare function normalizeAgentTitle(title: string): string;
-export declare function isComposerUuid(id: string | undefined): boolean;
+export declare function isComposerUuid(id: string | undefined): id is string;
 export declare function resolveCursorActiveComposerId(state: CursorState): string | undefined;
+/** Cursor is generating for this composer (active tab or sidebar spinner). */
+export declare function isAgentGenerating(agentId: string, state: CursorState): boolean;
 /** Live DOM applies only when the subscribed app chat matches Cursor's active composer. */
 export declare function isChatSyncedWithCursor(selectedAgentId: string | undefined, selectedTitle: string | undefined, state: Pick<CursorState, 'activeComposerId' | 'tabs' | 'composerIdByTitle' | 'activeChatTitle'>): boolean;