cursorconnect 0.1.7 → 0.1.9

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';
@@ -6,9 +7,9 @@ import { readAllowedMediaFile, resolveMediaPathParam } from './media-path.js';
 import { Server as SocketServer } from 'socket.io';
 import { resolveJsonlFilePath } from './agent-title-match.js';
 import { ChatDisplayStore } from './chat-display-store.js';
-import { AGENT_HISTORY_DEFAULT_LIMIT } from './history-limit.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,7 +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 { 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;
@@ -44,6 +50,16 @@ export class Relay {
     chatDisplay = new ChatDisplayStore();
     /** Raw JSONL row count last sent per agent (live `append` emits). */
     lastEmittedJsonlRows = new Map();
+    /** Last display tail pushed to app — re-emit when user/assistant tail changes. */
+    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;
@@ -67,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.stateManager.getState());
+                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();
             }
         }
@@ -75,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);
@@ -83,15 +108,22 @@ export class Relay {
     flushPendingPushPayloads() {
         if (!this.upstream?.connected || !this.pendingPushPayloads.length)
             return;
-        const batch = this.pendingPushPayloads.splice(0);
-        for (const payload of batch) {
+        const byAgent = new Map();
+        for (const payload of this.pendingPushPayloads.splice(0)) {
+            byAgent.set(payload.agentId, payload);
+        }
+        for (const payload of byAgent.values()) {
             this.upstream.emit('push:agent-completed', payload);
         }
-        console.log(`[agent-completion-push] flushed ${batch.length} queued push(es) to relay`);
+        console.log(`[agent-completion-push] flushed ${byAgent.size} queued push(es) to 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, () => {
@@ -103,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(),
@@ -129,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,
@@ -139,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. */
@@ -163,47 +280,262 @@ export class Relay {
             this.emitJsonlLiveForAgent(agentId, messages, totalMessages);
         }
     }
-    /** Live JSONL: push display deltas to app; `totalMessages` = raw `.jsonl` line count. */
+    /** 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,
+            totalMessages: totalMessages ?? messages.length,
+            source: source,
+        };
+    }
+    emitLentaForAgent(agentId, opts) {
+        const snap = this.lentaSnapshot(agentId, opts.totalMessages);
+        const historyOut = opts.historyPayload ?? snap.historyMessages;
+        if (!historyOut.length && !snap.liveMessages.length)
+            return;
+        this.emitAgentMessages(agentId, historyOut, snap.liveMessages, snap.source, {
+            totalMessages: opts.totalMessages,
+            append: opts.append,
+            reason: opts.reason,
+            forceSeq: opts.forceSeq,
+        });
+    }
+    lentaTailSignature(messages) {
+        return messages
+            .slice(-4)
+            .map((m) => `${m.role}:${m.id ?? ''}:${(m.text ?? '').length}:${(m.text ?? '').slice(-48)}`)
+            .join('|');
+    }
+    /** Live JSONL → `agent:messages` for subscribed chats (phone lenta). */
     emitJsonlLiveForAgent(agentId, rows, totalMessages) {
-        const prevDisplay = this.chatDisplay.getJsonlHistory(agentId);
-        const prevLen = prevDisplay.length;
-        const prevLast = prevLen ? prevDisplay[prevLen - 1] : undefined;
+        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)
+        const liveN = this.chatDisplay.getDomLive(agentId).length;
+        if (!historyMessages.length && !liveN)
             return;
-        if (!prevLen) {
-            this.emitAgentMessages(agentId, historyMessages, [], 'jsonl', totalMessages, this.nextHistorySeq(agentId), false);
+        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;
+        const generating = isAgentGenerating(agentId, state);
+        if (!deliveryPending && !generating && !totalGrew && sig === prevSig && prevSig)
+            return;
+        const histLen = historyMessages.length;
+        const prevHistLen = this.lastEmittedHistLen.get(agentId) ?? 0;
+        if (prevHistLen > 24 && histLen < prevHistLen - 12) {
+            bridgePipelineLog({
+                dir: 'internal',
+                event: 'agent:messages:SKIP_REGRESSION',
+                agentId,
+                msgs: histLen,
+                detail: `prev=${prevHistLen} total=${totalMessages}`,
+            });
             return;
         }
-        const appended = historyMessages.slice(prevLen);
-        if (appended.length) {
-            this.emitAgentMessages(agentId, appended, [], 'jsonl', totalMessages, this.nextHistorySeq(agentId), true);
+        this.emitLentaForAgent(agentId, {
+            totalMessages,
+            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);
+    }
+    /** 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');
         }
-        const last = historyMessages[historyMessages.length - 1];
-        if (prevLast &&
-            last &&
-            last.role === prevLast.role &&
-            (last.text ?? '') !== (prevLast.text ?? '')) {
-            this.emitAgentMessages(agentId, [last], [], 'jsonl', totalMessages, this.nextHistorySeq(agentId), true);
+    }
+    /** 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;
+            const snap = this.lentaSnapshot(subId, this.lastEmittedJsonlRows.get(subId) ?? undefined);
+            const deliveryPending = isLentaDeliveryPending(subId, snap.messages);
+            if (!snap.liveMessages.length && !state.agentWorking && !deliveryPending)
+                continue;
+            this.lastEmittedLentaSig.delete(subId);
+            this.emitLentaForAgent(subId, {
+                totalMessages: snap.totalMessages,
+                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',
+            });
         }
-        if (prevLen !== historyMessages.length || !this.jsonlIndex.getSubscribedAgents().has(agentId)) {
-            this.emitAgentMessages(agentId, historyMessages, [], 'jsonl', totalMessages, this.nextHistorySeq(agentId), false);
+    }
+    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;
     }
-    /** Client lenta: JSONL only (`liveMessages` always empty). DOM stays in debug snapshot. */
-    agentMessagesSnapshot(agentId, totalMessages) {
-        const historyMessages = this.chatDisplay.getJsonlHistory(agentId);
+    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 {
-            historyMessages,
-            liveMessages: [],
-            messages: historyMessages,
-            totalMessages: totalMessages ?? historyMessages.length,
+            title: this.jsonlIndex.getSubscribedAgents().get(agentId)?.title,
+            composerIdByTitle: state.composerIdByTitle,
+            activeComposerId: state.activeComposerId,
+            activeTabTitle: activeTab?.title,
         };
     }
+    agentMessagesSnapshot(agentId, totalMessages) {
+        return this.lentaSnapshot(agentId, totalMessages);
+    }
     checkMediaAuth(req) {
         if (!this.authEnabled)
             return true;
@@ -218,8 +550,11 @@ export class Relay {
             res.json({
                 ok: true,
                 cdp: this.cdpBridge.getClient()?.isConnected() ?? false,
+                keepAwake: isKeepAwakeActive(),
                 debugChats: '/debug/chats',
                 debugSnapshot: '/debug/chat-snapshot',
+                debugLenta: '/debug/lenta?agentId=',
+                debugLentaSeq: '/debug/lenta-seq?agentId=',
                 debugJsonlLive: '/debug/jsonl-live',
             });
         });
@@ -239,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' });
@@ -342,29 +738,24 @@ export class Relay {
                 detail: `limit=${limit ?? 'all'} title=${title?.slice(0, 32) ?? '-'}`,
             });
             try {
+                const full = await this.jsonlIndex.loadHistory(agentId, {
+                    title,
+                    composerIdByTitle: this.stateManager.getState().composerIdByTitle,
+                    offset,
+                });
+                this.chatDisplay.setJsonlBaseline(agentId, full.messages);
+                const history = limit > 0 && full.messages.length > limit
+                    ? { ...full, messages: full.messages.slice(-limit) }
+                    : full;
                 if (!isChatHistoryFromJsonl()) {
-                    const history = await this.jsonlIndex.loadHistory(agentId, {
-                        title,
-                        composerIdByTitle: this.stateManager.getState().composerIdByTitle,
-                        limit,
-                        offset,
-                    });
-                    this.chatDisplay.setJsonlBaseline(agentId, history.messages);
                     res.json({
                         agentId,
-                        ...this.agentMessagesSnapshot(agentId, history.totalMessages),
+                        ...this.agentMessagesSnapshot(agentId, full.totalMessages),
                         requestId,
                         updatedAt: Date.now(),
                     });
                     return;
                 }
-                const history = await this.jsonlIndex.loadHistory(agentId, {
-                    title,
-                    composerIdByTitle: this.stateManager.getState().composerIdByTitle,
-                    limit,
-                    offset,
-                });
-                this.chatDisplay.setJsonlBaseline(agentId, history.messages);
                 const snap = this.agentMessagesSnapshot(agentId, history.totalMessages);
                 const body = { ...history, ...snap, requestId, updatedAt: Date.now() };
                 const bytes = JSON.stringify(body).length;
@@ -528,6 +919,16 @@ export class Relay {
         this.io.on('connection', (socket) => this.onConnect(socket));
     }
     broadcast(event, payload) {
+        if (event === 'agent:messages') {
+            const p = payload;
+            bridgePipelineLog({
+                dir: 'out',
+                event: 'broadcast:agent:messages',
+                agentId: p?.agentId,
+                msgs: p?.historyMessages?.length ?? 0,
+                detail: `live=${p?.liveMessages?.length ?? 0} append=${!!p?.append} seq=${p?.seq ?? '-'} upstream=${this.upstream?.connected ?? false}`,
+            });
+        }
         if (event === 'agents:history' || event === 'agent:history') {
             const h = payload;
             const bytes = JSON.stringify(payload ?? {}).length;
@@ -550,22 +951,60 @@ 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();
     }
-    /** DOM messages in state:patch — debug/UI chrome only; chat lenta is JSONL via agent:messages. */
     prepareStateMessages(raw) {
         return filterClientDisplayList(prepareChatMessagesForDisplay(raw));
     }
@@ -577,15 +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();
+            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) {
@@ -605,7 +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.agentCompletionPush?.onJsonlUpdated(payload.agentId, payload.messages, this.stateManager.getState());
+            this.writeLentaCapture(payload.agentId, 'jsonl_file');
         });
         this.jsonlIndex.on('agent:history', (history) => {
             const total = history.totalMessages ?? history.messages.length;
@@ -655,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;
@@ -692,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));
         };
@@ -795,36 +1344,28 @@ export class Relay {
             detail: `limit=${socketLimit} title=${title?.slice(0, 32) ?? '-'} upstream=${viaUpstream}`,
         });
         try {
+            const full = await this.jsonlIndex.loadHistory(agentId, {
+                title,
+                composerIdByTitle: this.stateManager.getState().composerIdByTitle,
+                offset,
+            });
+            this.emitJsonlLiveForAgent(agentId, full.messages, full.totalMessages);
+            const snap = this.agentMessagesSnapshot(agentId, full.totalMessages);
             if (!isChatHistoryFromJsonl()) {
-                const history = await this.jsonlIndex.loadHistory(agentId, {
-                    title,
-                    composerIdByTitle: this.stateManager.getState().composerIdByTitle,
-                    limit: socketLimit,
-                    offset,
-                });
-                this.emitJsonlLiveForAgent(agentId, history.messages, history.totalMessages);
-                const snap = this.agentMessagesSnapshot(agentId, history.totalMessages);
-                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=${history.totalMessages} ms=${ms} rid=${requestId ?? '-'}`);
+                console.log(`[relay] agents:history jsonl agentId=${agentId} hist=${snap.historyMessages.length} total=${full.totalMessages} ms=${ms} rid=${requestId ?? '-'}`);
                 reply('agents:history', {
                     agentId,
                     ...snap,
-                    totalMessages: history.totalMessages,
+                    totalMessages: full.totalMessages,
                     requestId,
                     updatedAt: Date.now(),
                     seq,
                 });
                 return;
             }
-            const history = await this.jsonlIndex.loadHistory(agentId, {
-                title,
-                composerIdByTitle: this.stateManager.getState().composerIdByTitle,
-                limit: socketLimit,
-                offset,
-            });
-            this.emitJsonlLiveForAgent(agentId, history.messages, history.totalMessages);
-            const snap = this.agentMessagesSnapshot(agentId, history.totalMessages);
+            const history = full;
             const ms = Date.now() - t0;
             const bytes = JSON.stringify(snap.messages).length;
             console.log(`[relay] agents:history ok agentId=${history.agentId} msgs=${history.messages?.length ?? 0}/${history.totalMessages ?? '?'} bytes=${bytes} ms=${ms} rid=${requestId ?? '-'}`);
@@ -837,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,
@@ -872,11 +1413,12 @@ export class Relay {
     async runAgentsSubscribe({ agentId, title, focus, }) {
         if (!agentId)
             return;
-        this.jsonlIndex.subscribe(agentId, title, { emitHistory: true });
+        const alreadySubscribed = this.jsonlIndex.getSubscribedAgents().has(agentId);
+        this.jsonlIndex.subscribe(agentId, title, { emitHistory: !alreadySubscribed });
         this.stateManager.patchNow({ lastError: undefined });
         await this.trySwitchWindowForAgent(agentId);
         if (focus === false) {
-            void this.refreshDomChatOnSubscribe(agentId, title);
+            void this.refreshDomChatOnSubscribe(agentId, title, { clear: !alreadySubscribed });
             return;
         }
         const result = await this.commandExecutor.execute({
@@ -888,18 +1430,43 @@ export class Relay {
         if (!result.ok) {
             console.warn('[relay] subscribe focus (non-fatal):', result.error);
         }
-        void this.refreshDomChatOnSubscribe(agentId, title);
+        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) {
+    async refreshDomChatOnSubscribe(agentId, title, opts) {
         try {
-            this.chatDisplay.clearAgent(agentId);
-            this.lastEmittedJsonlRows.delete(agentId);
+            if (opts?.clear !== false) {
+                this.chatDisplay.clearAgent(agentId);
+                this.lastEmittedJsonlRows.delete(agentId);
+                this.lastEmittedLentaSig.delete(agentId);
+                this.lastEmittedHistLen.delete(agentId);
+                this.lentaPendingSince.delete(agentId);
+            }
             const history = await this.jsonlIndex.loadHistory(agentId, {
                 title,
                 composerIdByTitle: this.stateManager.getState().composerIdByTitle,
-                limit: AGENT_HISTORY_DEFAULT_LIMIT,
             });
+            this.lastEmittedLentaSig.delete(agentId);
             this.emitJsonlLiveForAgent(agentId, history.messages, history.totalMessages);
             await this.commandExecutor.scrollChatToBottom();
             this.domExtractor.pollNow();
@@ -913,6 +1480,10 @@ export class Relay {
             this.jsonlIndex.unsubscribe(agentId);
             this.chatDisplay.clearAgent(agentId);
             this.lastEmittedJsonlRows.delete(agentId);
+            this.lastEmittedLentaSig.delete(agentId);
+            this.lastEmittedHistLen.delete(agentId);
+            this.lentaPendingSince.delete(agentId);
+            this.refreshLentaPendingPatch();
         }
     }
     async runAgentsFocus({ agentId, title }, reply) {