cursorconnect 0.1.8 → 0.1.10

package/bridge-runtime/dist/relay.js

@@ -1,3 +1,4 @@
+import { mkdirSync } from 'fs';
 import express from 'express';
 import { createServer } from 'http';
 import { randomBytes, timingSafeEqual } from 'crypto';
@@ -7,7 +8,7 @@ import { Server as SocketServer } from 'socket.io';
 import { resolveJsonlFilePath } from './agent-title-match.js';
 import { ChatDisplayStore } from './chat-display-store.js';
 import { resolveHistoryLimit } from './history-request.js';
-import { filterClientDisplayList, prepareChatMessagesForDisplay, } from './chat-display.js';
+import { assertMonotonicLenta, filterClientDisplayList, prepareChatMessagesForDisplay, } from './chat-display.js';
 import { isKeepAwakeActive } from './keep-awake.js';
 function sleepMs(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -20,8 +21,12 @@ import { RelayUpstream } from './relay-upstream.js';
 import { bridgePipelineLog, bridgePipelineReportLines, bridgePipelineSnapshot, } from './history-pipeline-log.js';
 import { DEBUG_CHATS_PAGE_HTML } from './debug-chats-page.js';
 import { isChatHistoryFromJsonl } from './chat-history-mode.js';
-import { isChatSyncedWithCursor } from './chat-sync.js';
+import { isAgentGenerating, isChatSyncedWithCursor, isComposerUuid, resolveCursorActiveComposerId, } from './chat-sync.js';
 import { readJsonlLiveSnapshot } from './jsonl-live-debug.js';
+import { checkMonotonicOrder, checkOverlayAfterArchive, checkOverlayDuplicatesArchive, checkPayloadCompose, checkStoreCompose, checkSyncGate, compareDomTailToLenta, previewRow, } from './lenta-debug.js';
+import { getLastLentaEmit, getLentaSeqJournal, getLentaSeqLogPath, messagesFingerprint, recordLentaSeqEmit, } from './lenta-seq-journal.js';
+import { isLentaDeliveryPending } from './lenta-delivery.js';
+import { captureLentaIfEnabled, captureSessionDir, listCaptureSteps, readCaptureConfig, writeCaptureConfig, clearCaptureConfig, } from './lenta-capture.js';
 export class Relay {
     stateManager;
     commandExecutor;
@@ -49,7 +54,12 @@ export class Relay {
     lastEmittedLentaSig = new Map();
     /** Display bubble count last sent — block regression 214→74 style wipes on phone. */
     lastEmittedHistLen = new Map();
+    lentaPendingSince = new Map();
+    static LENTA_PENDING_FORCE_MS = 12_000;
+    /** Socket `agent:messages` coalesce — store ingest is immediate (see ingestDomOverlayFromState). */
+    static DOM_OVERLAY_EMIT_MS = parseInt(process.env.DOM_OVERLAY_EMIT_MS ?? '50', 10);
     domOverlayTimer = null;
+    cachedLentaPendingByAgent = {};
     constructor(config, stateManager, commandExecutor, cdpBridge, jsonlIndex, messageDebugStore, domExtractor) {
         this.stateManager = stateManager;
         this.commandExecutor = commandExecutor;
@@ -73,7 +83,15 @@ export class Relay {
                 this.upstream = new RelayUpstream(this.config, (event, ...args) => {
                     this.handleRemoteClientEvent(event, ...args);
                 }, () => this.flushPendingPushPayloads());
-                this.agentCompletionPush = new AgentCompletionPush((payload) => this.emitAgentCompletedPush(payload), () => this.lastJsonlIndex);
+                this.agentCompletionPush = new AgentCompletionPush((payload) => this.emitAgentCompletedPush(payload), () => this.lastJsonlIndex, () => this.stateManager.getState(), {
+                    readiness: {
+                        isSubscribed: (agentId) => this.jsonlIndex.getSubscribedAgents().has(agentId),
+                        getSubscribeTitle: (agentId) => this.jsonlIndex.getSubscribedAgents().get(agentId)?.title,
+                        getDisplayMessages: (agentId) => this.chatDisplay.getDisplayMessages(agentId),
+                        getJsonlHistory: (agentId) => this.chatDisplay.getJsonlHistory(agentId),
+                    },
+                    requestContentSync: (agentId, state) => this.requestAgentCompletionContentSync(agentId, state),
+                });
                 this.upstream.connect();
             }
         }
@@ -81,6 +99,7 @@ export class Relay {
     emitAgentCompletedPush(payload) {
         if (this.upstream?.connected) {
             this.upstream.emit('push:agent-completed', payload);
+            console.log(`[agent-completion-push] upstream emit agentId=${payload.agentId.slice(0, 12)} title=${payload.chatTitle.slice(0, 40)}`);
             return;
         }
         this.pendingPushPayloads.push(payload);
@@ -101,6 +120,10 @@ export class Relay {
     observeAgentCompletionForPush() {
         this.agentCompletionPush?.observe(this.stateManager.getState());
     }
+    requestAgentCompletionContentSync(agentId, state) {
+        void this.ensureJsonlBaselineForAgent(agentId, state);
+        this.flushLentaDelivery(agentId, 'push_ready');
+    }
     listen() {
         return new Promise((resolve) => {
             this.httpServer.listen(this.config.serverPort, this.config.serverHost, () => {
@@ -112,23 +135,33 @@ export class Relay {
     get authEnabled() {
         return this.config.webappPassword.length > 0;
     }
+    lentaAgentIds(state) {
+        const subscribed = [...this.jsonlIndex.getSubscribedAgents().keys()];
+        return new Set([
+            ...subscribed,
+            ...(state.activeComposerId ? [state.activeComposerId] : []),
+        ]);
+    }
     /** Read-only view of in-memory bridge state (no writes to stores). */
     readOnlyChatSnapshot() {
         const state = this.stateManager.getState();
         const subscribed = [...this.jsonlIndex.getSubscribedAgents().entries()].map(([agentId, meta]) => ({ agentId, title: meta.title }));
         const displayCache = {};
-        const cacheIds = new Set([
-            ...subscribed.map((s) => s.agentId),
-            ...(state.activeComposerId ? [state.activeComposerId] : []),
-        ]);
-        const domTranscript = {};
-        for (const agentId of cacheIds) {
-            const dom = this.chatDisplay.getDomTranscript(agentId);
-            if (dom.length)
-                domTranscript[agentId] = dom;
-            const jsonl = this.chatDisplay.getJsonlHistory(agentId);
-            if (jsonl.length)
-                displayCache[agentId] = jsonl;
+        const domOverlay = {};
+        const displayMessages = {};
+        const domRaw = {};
+        const lentaByAgent = {};
+        for (const agentId of this.lentaAgentIds(state)) {
+            const lenta = this.chatDisplay.getLentaDebug(agentId);
+            lentaByAgent[agentId] = lenta;
+            if (lenta.jsonlHistory.length)
+                displayCache[agentId] = lenta.jsonlHistory;
+            if (lenta.domOverlay.length)
+                domOverlay[agentId] = lenta.domOverlay;
+            if (lenta.messages.length)
+                displayMessages[agentId] = lenta.messages;
+            if (lenta.domRaw.length)
+                domRaw[agentId] = lenta.domRaw;
         }
         return {
             at: Date.now(),
@@ -138,6 +171,7 @@ export class Relay {
                 activeChatTitle: state.activeChatTitle,
                 updatedAt: state.updatedAt,
                 lastError: state.lastError,
+                agentWorking: state.agentWorking,
                 tabs: state.tabs,
                 composerIdByTitle: state.composerIdByTitle,
                 domMessageCount: state.messages.length,
@@ -148,9 +182,83 @@ export class Relay {
                 ringSize: this.messageDebugStore.list().length,
             },
             subscribed,
+            lentaByAgent,
             displayCache,
+            domOverlay,
+            displayMessages,
+            domRaw,
+            /** @deprecated use `domOverlay` */
+            domTranscript: domOverlay,
             chatHistoryJsonl: isChatHistoryFromJsonl(),
-            domTranscript,
+        };
+    }
+    async buildLentaDebugReport(agentId, title, opts) {
+        const state = this.stateManager.getState();
+        const subMeta = this.jsonlIndex.getSubscribedAgents().get(agentId);
+        const subTitle = title ?? subMeta?.title;
+        const synced = isChatSyncedWithCursor(agentId, subTitle, state);
+        if (opts?.reloadJsonl) {
+            const history = await this.jsonlIndex.loadHistory(agentId, {
+                title: subTitle,
+                composerIdByTitle: state.composerIdByTitle,
+            });
+            this.chatDisplay.setJsonlBaseline(agentId, history.messages);
+        }
+        this.syncGeneratingFlags(state);
+        if (state.messages?.length)
+            this.ingestDomOverlayFromState(state);
+        const lenta = this.chatDisplay.getLentaDebug(agentId);
+        const snap = this.agentMessagesSnapshot(agentId);
+        const issues = [
+            ...checkStoreCompose(lenta.jsonlHistory, lenta.domOverlay, lenta.messages),
+            ...checkPayloadCompose(snap.messages, snap.historyMessages, snap.liveMessages),
+            ...checkMonotonicOrder(lenta.messages, 'store'),
+            ...checkOverlayAfterArchive(lenta.jsonlHistory, lenta.domOverlay),
+            ...checkOverlayDuplicatesArchive(lenta.jsonlHistory, lenta.domOverlay),
+            ...checkSyncGate(synced, lenta.domOverlay, lenta.domRaw.length),
+        ];
+        const activeId = state.activeComposerId;
+        const domViewport = activeId && activeId !== agentId
+            ? []
+            : state.messages.map((m) => previewRow(m, 'dom-viewport'));
+        const domNote = activeId && activeId !== agentId
+            ? `DOM viewport is active ${activeId.slice(0, 8)}, not ${agentId.slice(0, 8)}`
+            : null;
+        const domCmp = synced
+            ? compareDomTailToLenta(domViewport, lenta.messages.map((m) => previewRow(m, 'lenta')), 12, {
+                hasDomOverlay: lenta.domOverlay.length > 0,
+                hasJsonlArchive: lenta.jsonlHistory.length > 0,
+                agentWorking: state.agentWorking,
+            })
+            : { issues: [], domTail: [], lentaTail: [] };
+        issues.push(...domCmp.issues);
+        return {
+            at: new Date().toISOString(),
+            agentId,
+            synced,
+            domNote,
+            health: { cdp: this.cdpBridge.getClient()?.isConnected() ?? false },
+            activeComposerId: activeId,
+            activeChatTitle: state.activeChatTitle,
+            agentWorking: state.agentWorking,
+            agentGenerating: lenta.agentGenerating,
+            jsonlRowCount: lenta.jsonlRowCount,
+            counts: {
+                jsonl: lenta.jsonlHistory.length,
+                domOverlay: lenta.domOverlay.length,
+                domRaw: lenta.domRaw.length,
+                messages: lenta.messages.length,
+                domViewport: domViewport.length,
+            },
+            lenta,
+            emitSnapshot: snap,
+            issues,
+            match: issues.length === 0,
+            domTail: domCmp.domTail,
+            lentaTail: domCmp.lentaTail,
+            seqJournal: getLentaSeqJournal(agentId).slice(-24),
+            seqLogFile: getLentaSeqLogPath(),
+            currentSeq: this.historySeqByAgent.get(agentId) ?? 0,
         };
     }
     /** Push JSONL file updates to every subscribed route id (e.g. sidebar-0) for that composer. */
@@ -172,16 +280,18 @@ export class Relay {
             this.emitJsonlLiveForAgent(agentId, messages, totalMessages);
         }
     }
-    /** JSONL baseline + DOM rows not yet in file (`liveMessages`). */
+    /** JSONL baseline + DOM tail (`liveMessages`); `messages` = append-only compose. */
     lentaSnapshot(agentId, totalMessages) {
         const historyMessages = this.chatDisplay.getJsonlHistory(agentId);
         const liveMessages = this.chatDisplay.getDomLive(agentId);
+        const messages = this.chatDisplay.getDisplayMessages(agentId);
+        assertMonotonicLenta(messages, agentId.slice(0, 8));
         const source = liveMessages.length ? 'hybrid' : 'jsonl';
         return {
             historyMessages,
             liveMessages,
-            messages: [...historyMessages, ...liveMessages],
-            totalMessages: totalMessages ?? historyMessages.length,
+            messages,
+            totalMessages: totalMessages ?? messages.length,
             source: source,
         };
     }
@@ -190,7 +300,12 @@ export class Relay {
         const historyOut = opts.historyPayload ?? snap.historyMessages;
         if (!historyOut.length && !snap.liveMessages.length)
             return;
-        this.emitAgentMessages(agentId, historyOut, snap.liveMessages, snap.source, opts.totalMessages, opts.seq, opts.append);
+        this.emitAgentMessages(agentId, historyOut, snap.liveMessages, snap.source, {
+            totalMessages: opts.totalMessages,
+            append: opts.append,
+            reason: opts.reason,
+            forceSeq: opts.forceSeq,
+        });
     }
     lentaTailSignature(messages) {
         return messages
@@ -202,16 +317,23 @@ export class Relay {
     emitJsonlLiveForAgent(agentId, rows, totalMessages) {
         const prevTotal = this.lastEmittedJsonlRows.get(agentId) ?? 0;
         const prevSig = this.lastEmittedLentaSig.get(agentId);
+        const state = this.stateManager.getState();
+        this.chatDisplay.setAgentGenerating(agentId, isAgentGenerating(agentId, state));
         this.chatDisplay.setJsonlBaseline(agentId, rows);
         this.lastEmittedJsonlRows.set(agentId, totalMessages);
+        this.writeLentaCapture(agentId, 'jsonl_file');
         const historyMessages = this.chatDisplay.getJsonlHistory(agentId);
-        if (!historyMessages.length && !this.chatDisplay.getDomLive(agentId).length)
+        const liveN = this.chatDisplay.getDomLive(agentId).length;
+        if (!historyMessages.length && !liveN)
             return;
         if (!this.jsonlIndex.getSubscribedAgents().has(agentId))
             return;
+        const storeMessages = this.chatDisplay.getDisplayMessages(agentId);
+        const deliveryPending = isLentaDeliveryPending(agentId, storeMessages);
         const sig = this.lentaTailSignature(historyMessages);
         const totalGrew = totalMessages > prevTotal;
-        if (!totalGrew && sig === prevSig && prevSig)
+        const generating = isAgentGenerating(agentId, state);
+        if (!deliveryPending && !generating && !totalGrew && sig === prevSig && prevSig)
             return;
         const histLen = historyMessages.length;
         const prevHistLen = this.lastEmittedHistLen.get(agentId) ?? 0;
@@ -225,40 +347,191 @@ export class Relay {
             });
             return;
         }
-        this.lastEmittedLentaSig.set(agentId, sig);
-        this.lastEmittedHistLen.set(agentId, Math.max(prevHistLen, histLen));
         this.emitLentaForAgent(agentId, {
             totalMessages,
-            seq: this.nextHistorySeq(agentId),
+            reason: 'jsonl_live',
+            forceSeq: deliveryPending || generating,
         });
+        this.lastEmittedLentaSig.set(agentId, sig);
+        this.lastEmittedHistLen.set(agentId, Math.max(prevHistLen, histLen));
+        if (isLentaDeliveryPending(agentId, this.chatDisplay.getDisplayMessages(agentId))) {
+            this.flushLentaDelivery(agentId, 'delivery_flush');
+        }
+        this.agentCompletionPush?.retryPendingContent(state);
     }
-    scheduleDomOverlayEmit() {
-        if (this.domOverlayTimer)
-            clearTimeout(this.domOverlayTimer);
-        this.domOverlayTimer = setTimeout(() => {
-            this.domOverlayTimer = null;
-            this.emitDomOverlayForSyncedSubscribers();
-        }, 120);
-    }
-    /** DOM poll while agent works — overlay until the same turn lands in JSONL. */
-    emitDomOverlayForSyncedSubscribers() {
-        const state = this.stateManager.getState();
+    /** Ingest CDP viewport into ChatDisplayStore — no debounce (debug + compose). */
+    ingestDomOverlayFromState(state) {
         if (!state.messages?.length)
             return;
         const domRows = this.prepareStateMessages(state.messages);
+        const targets = this.resolveDomOverlayAgentIds(state);
+        if (!targets.size)
+            return;
+        for (const agentId of targets) {
+            this.chatDisplay.setAgentGenerating(agentId, isAgentGenerating(agentId, state));
+            if (!this.chatDisplay.getJsonlHistory(agentId).length) {
+                void this.ensureJsonlBaselineForAgent(agentId, state);
+            }
+            const prevLive = this.chatDisplay.getDomLive(agentId).length;
+            this.chatDisplay.mergeLiveForAgent(agentId, domRows);
+            const liveN = this.chatDisplay.getDomLive(agentId).length;
+            if (liveN > 0 && liveN !== prevLive) {
+                bridgePipelineLog({
+                    dir: 'internal',
+                    event: 'dom:overlay:ingest',
+                    agentId,
+                    msgs: liveN,
+                    detail: `domRows=${domRows.length} generating=${isAgentGenerating(agentId, state)} viewport=${domRows.length}`,
+                });
+            }
+            this.writeLentaCapture(agentId, 'dom_ingest');
+        }
+    }
+    /** Push lenta with DOM live to clients while generation is in flight. */
+    emitDomLiveWhileGenerating(state) {
+        for (const agentId of this.resolveDomOverlayAgentIds(state)) {
+            if (!isAgentGenerating(agentId, state))
+                continue;
+            if (!this.jsonlIndex.getSubscribedAgents().has(agentId))
+                continue;
+            const meta = this.jsonlIndex.getSubscribedAgents().get(agentId);
+            if (!meta || !isChatSyncedWithCursor(agentId, meta.title, state))
+                continue;
+            const snap = this.lentaSnapshot(agentId, this.lastEmittedJsonlRows.get(agentId) ?? undefined);
+            if (!snap.liveMessages.length)
+                continue;
+            this.lastEmittedLentaSig.delete(agentId);
+            this.emitLentaForAgent(agentId, {
+                totalMessages: snap.totalMessages,
+                reason: 'dom_overlay',
+                forceSeq: true,
+            });
+        }
+    }
+    syncGeneratingFlags(state) {
+        const targets = this.resolveDomOverlayAgentIds(state);
+        for (const agentId of targets) {
+            this.chatDisplay.setAgentGenerating(agentId, isAgentGenerating(agentId, state));
+        }
+    }
+    /** Push composed lenta to subscribed clients (debounced). */
+    emitDomOverlaySocketForSubscribers(state) {
         for (const [subId, meta] of this.jsonlIndex.getSubscribedAgents()) {
             if (!isChatSyncedWithCursor(subId, meta.title, state))
                 continue;
-            this.chatDisplay.mergeLiveForAgent(subId, domRows);
             const snap = this.lentaSnapshot(subId, this.lastEmittedJsonlRows.get(subId) ?? undefined);
-            if (!snap.liveMessages.length && !state.agentWorking)
+            const deliveryPending = isLentaDeliveryPending(subId, snap.messages);
+            if (!snap.liveMessages.length && !state.agentWorking && !deliveryPending)
                 continue;
             this.lastEmittedLentaSig.delete(subId);
             this.emitLentaForAgent(subId, {
                 totalMessages: snap.totalMessages,
-                seq: this.nextHistorySeq(subId),
+                reason: 'dom_overlay',
+                forceSeq: deliveryPending,
+            });
+        }
+    }
+    /** While generating, push overlay growth without waiting for emit debounce tail. */
+    maybeEmitDomOverlayLeading(state) {
+        if (!state.agentWorking)
+            return;
+        for (const [subId, meta] of this.jsonlIndex.getSubscribedAgents()) {
+            if (!isChatSyncedWithCursor(subId, meta.title, state))
+                continue;
+            if (!this.chatDisplay.getDomLive(subId).length)
+                continue;
+            const snap = this.lentaSnapshot(subId, this.lastEmittedJsonlRows.get(subId) ?? undefined);
+            const sig = messagesFingerprint(snap.messages);
+            const last = getLastLentaEmit(subId);
+            if (last?.messagesSig === sig)
+                continue;
+            this.emitLentaForAgent(subId, {
+                totalMessages: snap.totalMessages,
+                reason: 'dom_overlay',
+            });
+        }
+    }
+    applyDomOverlayFromState(state) {
+        this.syncGeneratingFlags(state);
+        this.ingestDomOverlayFromState(state);
+        this.emitDomLiveWhileGenerating(state);
+        this.maybeEmitDomOverlayLeading(state);
+        this.scheduleDomOverlayEmit();
+    }
+    scheduleDomOverlayEmit() {
+        if (this.domOverlayTimer)
+            clearTimeout(this.domOverlayTimer);
+        this.domOverlayTimer = setTimeout(() => {
+            this.domOverlayTimer = null;
+            this.emitDomOverlaySocketForSubscribers(this.stateManager.getState());
+        }, Relay.DOM_OVERLAY_EMIT_MS);
+    }
+    /**
+     * Agent ids that should receive DOM ingest: active Cursor composer + synced subscriptions.
+     * Store must update even without phone subscribe (debug/lenta, later subscribe).
+     */
+    resolveDomOverlayAgentIds(state) {
+        const targets = new Set();
+        const activeTab = state.tabs.find((t) => t.active);
+        const activeId = resolveCursorActiveComposerId(state);
+        if (isComposerUuid(activeId))
+            targets.add(activeId);
+        for (const [subId, meta] of this.jsonlIndex.getSubscribedAgents()) {
+            if (!isChatSyncedWithCursor(subId, meta.title, state))
+                continue;
+            targets.add(subId);
+            if (isComposerUuid(subId))
+                continue;
+            const path = resolveJsonlFilePath(this.config.cursorProjectsDir, subId, {
+                title: meta.title,
+                composerIdByTitle: state.composerIdByTitle,
+                activeComposerId: state.activeComposerId,
+                activeTabTitle: activeTab?.title,
             });
+            if (path)
+                targets.add(basename(path, '.jsonl'));
         }
+        return targets;
+    }
+    writeLentaCapture(agentId, reason, extra) {
+        const state = this.stateManager.getState();
+        const lenta = this.chatDisplay.getLentaDebug(agentId);
+        const activeTab = state.tabs.find((t) => t.active);
+        const jsonlPath = resolveJsonlFilePath(this.config.cursorProjectsDir, agentId, {
+            title: this.jsonlIndex.getSubscribedAgents().get(agentId)?.title,
+            composerIdByTitle: state.composerIdByTitle,
+            activeComposerId: state.activeComposerId,
+            activeTabTitle: activeTab?.title,
+        });
+        const domViewport = resolveCursorActiveComposerId(state) === agentId
+            ? this.prepareStateMessages(state.messages)
+            : [];
+        captureLentaIfEnabled(agentId, {
+            reason,
+            source: lenta.source,
+            emitSeq: extra?.emitSeq,
+            seqHeld: extra?.seqHeld,
+            transition: extra?.transition,
+            jsonlRowCount: lenta.jsonlRowCount,
+            historyMessages: lenta.jsonlHistory,
+            liveMessages: lenta.domOverlay,
+            messages: lenta.messages,
+            domRaw: lenta.domRaw,
+            domViewport,
+            jsonlFilePath: jsonlPath ?? undefined,
+            activeComposerId: state.activeComposerId,
+            agentWorking: state.agentWorking,
+        });
+    }
+    resolveHistoryOpts(agentId) {
+        const state = this.stateManager.getState();
+        const activeTab = state.tabs.find((t) => t.active);
+        return {
+            title: this.jsonlIndex.getSubscribedAgents().get(agentId)?.title,
+            composerIdByTitle: state.composerIdByTitle,
+            activeComposerId: state.activeComposerId,
+            activeTabTitle: activeTab?.title,
+        };
     }
     agentMessagesSnapshot(agentId, totalMessages) {
         return this.lentaSnapshot(agentId, totalMessages);
@@ -280,6 +553,8 @@ export class Relay {
                 keepAwake: isKeepAwakeActive(),
                 debugChats: '/debug/chats',
                 debugSnapshot: '/debug/chat-snapshot',
+                debugLenta: '/debug/lenta?agentId=',
+                debugLentaSeq: '/debug/lenta-seq?agentId=',
                 debugJsonlLive: '/debug/jsonl-live',
             });
         });
@@ -299,6 +574,67 @@ export class Relay {
         this.app.get('/debug/chat-snapshot', (_req, res) => {
             res.json(this.readOnlyChatSnapshot());
         });
+        this.app.get('/debug/lenta', async (req, res) => {
+            const agentId = typeof req.query.agentId === 'string' ? req.query.agentId.trim() : '';
+            if (!agentId) {
+                res.status(400).json({ error: 'agentId required' });
+                return;
+            }
+            const title = typeof req.query.title === 'string' ? req.query.title.trim() : undefined;
+            const reloadJsonl = req.query.reloadJsonl === '1' || req.query.reloadJsonl === 'true';
+            try {
+                const report = await this.buildLentaDebugReport(agentId, title, { reloadJsonl });
+                res.json(report);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        this.app.post('/debug/lenta-capture/start', express.json(), (req, res) => {
+            const body = (req.body ?? {});
+            const agentId = String(body.agentId ?? (typeof req.query.agentId === 'string' ? req.query.agentId : '') ?? '').trim();
+            if (!agentId) {
+                res.status(400).json({ error: 'agentId required' });
+                return;
+            }
+            writeCaptureConfig({
+                enabled: true,
+                agentId,
+                title: body?.title?.trim(),
+            });
+            mkdirSync(captureSessionDir(agentId), { recursive: true });
+            res.json({
+                ok: true,
+                agentId,
+                sessionDir: captureSessionDir(agentId),
+                hint: 'Reproduce chat activity; snapshots append under sessionDir',
+            });
+        });
+        this.app.post('/debug/lenta-capture/stop', (_req, res) => {
+            const cfg = readCaptureConfig();
+            clearCaptureConfig();
+            res.json({ ok: true, stopped: cfg?.agentId ?? null });
+        });
+        this.app.get('/debug/lenta-capture/status', (_req, res) => {
+            const cfg = readCaptureConfig();
+            res.json({
+                config: cfg,
+                sessionDir: cfg ? captureSessionDir(cfg.agentId) : null,
+                steps: cfg ? listCaptureSteps(cfg.agentId) : [],
+            });
+        });
+        this.app.get('/debug/lenta-seq', (req, res) => {
+            const agentId = typeof req.query.agentId === 'string' ? req.query.agentId.trim() : undefined;
+            const journal = getLentaSeqJournal(agentId || undefined);
+            res.json({
+                at: new Date().toISOString(),
+                agentId: agentId ?? null,
+                logFile: getLentaSeqLogPath(),
+                currentSeq: agentId ? this.historySeqByAgent.get(agentId) ?? 0 : undefined,
+                journal,
+                handoffs: journal.filter((e) => e.transition === 'dom_to_jsonl'),
+            });
+        });
         this.app.get('/debug/jsonl-live', async (req, res) => {
             if (!this.checkMediaAuth(req)) {
                 res.status(401).json({ error: 'Unauthorized' });
@@ -615,20 +951,59 @@ export class Relay {
         this.historySeqByAgent.set(agentId, n);
         return n;
     }
-    emitAgentMessages(agentId, historyMessages, liveMessages, source, totalMessages, seq, append = false) {
-        const outSeq = seq ?? this.nextHistorySeq(agentId);
+    emitAgentMessages(agentId, historyMessages, liveMessages, source, opts) {
         const messages = [...historyMessages, ...liveMessages];
+        const sig = messagesFingerprint(messages);
+        const prevSeq = this.historySeqByAgent.get(agentId) ?? 0;
+        const prevHeld = getLastLentaEmit(agentId);
+        let outSeq;
+        let seqHeld = false;
+        if (opts?.forceSeq) {
+            outSeq = this.nextHistorySeq(agentId);
+        }
+        else if (prevHeld && prevHeld.messagesSig === sig) {
+            outSeq = prevHeld.seq;
+            seqHeld = true;
+            this.historySeqByAgent.set(agentId, outSeq);
+        }
+        else {
+            outSeq = this.nextHistorySeq(agentId);
+        }
+        const entry = recordLentaSeqEmit(agentId, outSeq, prevSeq, seqHeld, messages, {
+            reason: opts?.reason ?? 'emit',
+            source,
+            historyLen: historyMessages.length,
+            liveLen: liveMessages.length,
+            messagesLen: messages.length,
+            append: opts?.append,
+        });
+        bridgePipelineLog({
+            dir: 'out',
+            event: 'lenta:seq',
+            agentId,
+            msgs: messages.length,
+            detail: `seq=${outSeq} prev=${prevSeq} held=${seqHeld ? 1 : 0} ` +
+                `reason=${entry.reason} transition=${entry.transition} ` +
+                `hist=${entry.historyLen} live=${entry.liveLen} src=${source}`,
+        });
         this.broadcast('agent:messages', {
             agentId,
             historyMessages,
             liveMessages,
             messages,
-            totalMessages: totalMessages ?? messages.length,
+            totalMessages: opts?.totalMessages ?? messages.length,
             source,
             updatedAt: Date.now(),
             seq: outSeq,
-            append: append || undefined,
+            append: opts?.append || undefined,
+        });
+        this.writeLentaCapture(agentId, 'emit_agent_messages', {
+            emitSeq: outSeq,
+            seqHeld,
+            transition: entry.transition,
         });
+        this.noteLentaDelivery(agentId, messages);
+        this.refreshLentaPendingPatch();
     }
     prepareStateMessages(raw) {
         return filterClientDisplayList(prepareChatMessagesForDisplay(raw));
@@ -641,18 +1016,125 @@ export class Relay {
             messages: this.prepareStateMessages(payload.messages),
         };
     }
+    buildLentaPendingByAgent() {
+        const state = this.stateManager.getState();
+        const out = {};
+        for (const [agentId, meta] of this.jsonlIndex.getSubscribedAgents()) {
+            if (!isChatSyncedWithCursor(agentId, meta.title, state))
+                continue;
+            const messages = this.chatDisplay.getDisplayMessages(agentId);
+            if (isLentaDeliveryPending(agentId, messages))
+                out[agentId] = true;
+        }
+        return out;
+    }
+    refreshLentaPendingCache() {
+        this.cachedLentaPendingByAgent = this.buildLentaPendingByAgent();
+    }
+    withRelayState(payload) {
+        const base = this.withDisplayState(payload);
+        if (payload.messages?.length) {
+            this.refreshLentaPendingCache();
+        }
+        return {
+            ...base,
+            lentaPendingByAgent: this.cachedLentaPendingByAgent,
+            updatedAt: base.updatedAt ?? Date.now(),
+        };
+    }
+    refreshLentaPendingPatch() {
+        this.refreshLentaPendingCache();
+        this.broadcast('state:patch', {
+            lentaPendingByAgent: this.cachedLentaPendingByAgent,
+            updatedAt: Date.now(),
+        });
+    }
+    noteLentaDelivery(agentId, storeMessages) {
+        if (isLentaDeliveryPending(agentId, storeMessages)) {
+            if (!this.lentaPendingSince.has(agentId)) {
+                this.lentaPendingSince.set(agentId, Date.now());
+            }
+            return;
+        }
+        this.lentaPendingSince.delete(agentId);
+        this.agentCompletionPush?.retryPendingContent(this.stateManager.getState());
+    }
+    /** Push `agent:messages` when store is ahead of last emit (subscribed + synced). */
+    flushLentaDelivery(agentId, reason) {
+        if (!this.jsonlIndex.getSubscribedAgents().has(agentId))
+            return false;
+        const state = this.stateManager.getState();
+        const meta = this.jsonlIndex.getSubscribedAgents().get(agentId);
+        if (!meta || !isChatSyncedWithCursor(agentId, meta.title, state))
+            return false;
+        const messages = this.chatDisplay.getDisplayMessages(agentId);
+        if (!isLentaDeliveryPending(agentId, messages)) {
+            this.lentaPendingSince.delete(agentId);
+            return false;
+        }
+        const since = this.lentaPendingSince.get(agentId) ?? Date.now();
+        if (!this.lentaPendingSince.has(agentId))
+            this.lentaPendingSince.set(agentId, since);
+        bridgePipelineLog({
+            dir: 'internal',
+            event: 'lenta:delivery:FLUSH',
+            agentId,
+            msgs: messages.length,
+            detail: `reason=${reason} ageMs=${Date.now() - since}`,
+        });
+        this.emitLentaForAgent(agentId, {
+            totalMessages: this.lastEmittedJsonlRows.get(agentId) ?? messages.length,
+            reason,
+            forceSeq: true,
+        });
+        this.agentCompletionPush?.retryPendingContent(this.stateManager.getState());
+        return true;
+    }
+    flushPendingLentaForSubscribers(reason) {
+        for (const agentId of this.jsonlIndex.getSubscribedAgents().keys()) {
+            this.flushLentaDelivery(agentId, reason);
+        }
+        this.refreshLentaPendingPatch();
+    }
+    maybeForceStaleLentaDelivery() {
+        const now = Date.now();
+        for (const agentId of this.jsonlIndex.getSubscribedAgents().keys()) {
+            const since = this.lentaPendingSince.get(agentId);
+            if (since == null)
+                continue;
+            if (now - since < Relay.LENTA_PENDING_FORCE_MS)
+                continue;
+            this.flushLentaDelivery(agentId, 'delivery_flush');
+        }
+    }
     wireEvents() {
         this.stateManager.on('state:full', (state) => {
-            this.broadcast('state:full', this.withDisplayState(state));
+            this.refreshLentaPendingCache();
+            this.broadcast('state:full', this.withRelayState(state));
             this.emitAgentsIndex();
             this.observeAgentCompletionForPush();
+            if (state.messages?.length)
+                this.applyDomOverlayFromState(state);
+            if (!state.agentWorking)
+                this.flushPendingLentaForSubscribers('dom_overlay');
+            this.maybeForceStaleLentaDelivery();
         });
         this.stateManager.on('state:patch', (patch) => {
-            this.broadcast('state:patch', this.withDisplayState(patch));
+            this.broadcast('state:patch', this.withRelayState(patch));
             this.observeAgentCompletionForPush();
-            if (patch.messages?.length) {
-                this.scheduleDomOverlayEmit();
+            const state = this.stateManager.getState();
+            if (patch.messages?.length || state.messages?.length) {
+                this.applyDomOverlayFromState(state);
+            }
+            if (patch.agentWorking === false || (!state.agentWorking && patch.agentWorking !== true)) {
+                this.syncGeneratingFlags(state);
+                this.flushPendingLentaForSubscribers('jsonl_live');
+                this.refreshLentaPendingCache();
+            }
+            else if (state.agentWorking) {
+                this.syncGeneratingFlags(state);
             }
+            this.maybeForceStaleLentaDelivery();
             if (patch.sidebarRepos || patch.composerIdByTitle) {
                 const key = JSON.stringify([patch.sidebarRepos, patch.composerIdByTitle]);
                 if (key !== this.lastSidebarIndexKey) {
@@ -672,6 +1154,7 @@ export class Relay {
         this.jsonlIndex.on('agent:jsonl:updated', (payload) => {
             const total = payload.totalMessages ?? payload.messages.length;
             this.syncJsonlToSubscribedAgents(payload.agentId, payload.messages, total);
+            this.writeLentaCapture(payload.agentId, 'jsonl_file');
         });
         this.jsonlIndex.on('agent:history', (history) => {
             const total = history.totalMessages ?? history.messages.length;
@@ -721,7 +1204,7 @@ export class Relay {
         });
     }
     pushFullStateToRemote() {
-        this.broadcast('state:full', this.withDisplayState(this.stateManager.getState()));
+        this.broadcast('state:full', this.withRelayState(this.stateManager.getState()));
         if (this.lastJsonlIndex.updatedAt > 0) {
             this.emitAgentsIndex(true);
             return;
@@ -758,7 +1241,7 @@ export class Relay {
         this.dispatchClientEvent(event, args, reply);
     }
     onConnect(socket) {
-        socket.emit('state:full', this.withDisplayState(this.stateManager.getState()));
+        socket.emit('state:full', this.withRelayState(this.stateManager.getState()));
         const sendIndex = (index) => {
             socket.emit('agents:index', mergeSidebarWithJsonl(this.stateManager.getState().sidebarRepos, index, this.stateManager.getState().composerIdByTitle));
         };
@@ -869,7 +1352,7 @@ export class Relay {
             this.emitJsonlLiveForAgent(agentId, full.messages, full.totalMessages);
             const snap = this.agentMessagesSnapshot(agentId, full.totalMessages);
             if (!isChatHistoryFromJsonl()) {
-                const seq = this.historySeqByAgent.get(agentId) ?? this.nextHistorySeq(agentId);
+                const seq = this.historySeqByAgent.get(agentId) ?? 0;
                 const ms = Date.now() - t0;
                 console.log(`[relay] agents:history jsonl agentId=${agentId} hist=${snap.historyMessages.length} total=${full.totalMessages} ms=${ms} rid=${requestId ?? '-'}`);
                 reply('agents:history', {
@@ -895,7 +1378,7 @@ export class Relay {
                 msgs: history.messages?.length ?? 0,
                 detail: `total=${history.totalMessages ?? '?'} ms=${ms}`,
             });
-            const seq = this.nextHistorySeq(history.agentId);
+            const seq = this.historySeqByAgent.get(history.agentId) ?? 0;
             reply('agents:history', {
                 ...history,
                 historyMessages: snap.historyMessages,
@@ -949,6 +1432,26 @@ export class Relay {
         }
         void this.refreshDomChatOnSubscribe(agentId, title, { clear: !alreadySubscribed });
     }
+    /** Load JSONL into store when DOM ingest runs but baseline empty (e.g. after bridge restart). */
+    async ensureJsonlBaselineForAgent(agentId, state) {
+        if (this.chatDisplay.getJsonlHistory(agentId).length > 0)
+            return;
+        const sub = this.jsonlIndex.getSubscribedAgents().get(agentId);
+        try {
+            const history = await this.jsonlIndex.loadHistory(agentId, {
+                title: sub?.title,
+                composerIdByTitle: state.composerIdByTitle,
+            });
+            if (!history.messages.length)
+                return;
+            this.chatDisplay.setJsonlBaseline(agentId, history.messages);
+            this.lastEmittedJsonlRows.set(agentId, history.totalMessages);
+            this.domExtractor.pollNow();
+        }
+        catch (err) {
+            console.warn('[relay] ensureJsonlBaseline (non-fatal):', err.message);
+        }
+    }
     /** Открытие чата: JSONL baseline + focus/scroll (DOM poll только для state: working/approve). */
     async refreshDomChatOnSubscribe(agentId, title, opts) {
         try {
@@ -957,6 +1460,7 @@ export class Relay {
                 this.lastEmittedJsonlRows.delete(agentId);
                 this.lastEmittedLentaSig.delete(agentId);
                 this.lastEmittedHistLen.delete(agentId);
+                this.lentaPendingSince.delete(agentId);
             }
             const history = await this.jsonlIndex.loadHistory(agentId, {
                 title,
@@ -978,6 +1482,8 @@ export class Relay {
             this.lastEmittedJsonlRows.delete(agentId);
             this.lastEmittedLentaSig.delete(agentId);
             this.lastEmittedHistLen.delete(agentId);
+            this.lentaPendingSince.delete(agentId);
+            this.refreshLentaPendingPatch();
         }
     }
     async runAgentsFocus({ agentId, title }, reply) {