cursorconnect 0.1.7 → 0.1.8

package/bridge-runtime/.env.example

@@ -13,7 +13,7 @@ WEBAPP_PASSWORD=
 # CURSOR_PROJECTS_DIR=
 LOG_LEVEL=info
 
-# Chat lenta: JSONL → agent:messages (liveMessages always []). DOM = state:patch (working, approve).
+# Chat lenta: JSONL → agent:messages; liveMessages = DOM overlay until turn is in .jsonl.
 # CHAT_HISTORY_JSONL=1 — extra socket agent:history on app (legacy).
 # CHAT_HISTORY_JSONL=1
 # Follow active Cursor window in CDP (1.5s poll). Set FOCUS_SYNC_ENABLED=0 to disable.
@@ -25,3 +25,7 @@ LOG_LEVEL=info
 # RELAY_URL=https://your-domain.example
 # RELAY_TOKEN=same-as-relay-.env
 # RELAY_ROOM_ID=default
+# macOS: не давать Mac уснуть, пока bridge запущен (cursorconnect start). Выключить: KEEP_AWAKE=0
+# KEEP_AWAKE=0
+# Периодический ping relay upstream (NAT/idle). 0 = выкл.
+# RELAY_KEEPALIVE_MS=20000

package/bridge-runtime/connector-version.json

@@ -1 +1 @@
-{"cliVersion":"0.1.7","bundledAt":"2026-05-25T18:20:35Z"}
+{"cliVersion":"0.1.8","bundledAt":"2026-05-26T06:15:47Z"}

package/bridge-runtime/dist/agent-completion-push.d.ts

@@ -1,4 +1,4 @@
-import type { AgentsIndex, CursorState, HistoryMessage } from './types.js';
+import type { AgentsIndex, CursorState } from './types.js';
 export declare const AGENT_COMPLETION_PUSH_BODY = "\u0410\u0433\u0435\u043D\u0442 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B \u0440\u0430\u0431\u043E\u0442\u0443";
 export declare function suppressAgentCompletionPush(ms?: number): void;
 export interface AgentCompletionPushPayload {
@@ -8,35 +8,28 @@ export interface AgentCompletionPushPayload {
 }
 export type AgentCompletionPushEmit = (payload: AgentCompletionPushPayload) => void;
 /**
- * Push when a new assistant row lands in JSONL for the current/recent task.
- * If JSONL flushes while DOM still shows "working", retry when DOM goes idle.
+ * Push once per real generation session: agent must be stably working (≥3 DOM polls),
+ * then stably idle (≥2 polls). Opening a finished chat may flicker isWorking for 1 poll — ignored.
  */
 export declare class AgentCompletionPush {
     private emit;
     private agentsIndex;
-    private getState;
-    /** Last seen assistant line id in JSONL (line number / ts). */
-    private lastJsonlAssistantKey;
-    /** Agents that were generating on previous DOM poll. */
     private prevWorking;
+    private workingPolls;
+    /** Agent had a real generation episode this bridge session (not open-chat flicker). */
+    private confirmedWorking;
+    private idlePolls;
     private lastEmitAt;
-    /** JSONL had a new assistant line while DOM was still working — emit after idle. */
-    private pendingAfterIdle;
-    private pendingDeferSince;
-    private deferTimers;
-    private lastJsonlMessages;
+    private emittedThisSession;
+    /** ~3 × 400ms — ignore brief spinner when opening a finished chat. */
+    private static readonly WORKING_POLLS_REQUIRED;
+    /** ~2 × 400ms idle before push. */
+    private static readonly IDLE_POLLS_REQUIRED;
     private static readonly MIN_EMIT_GAP_MS;
-    /** DOM can lie "working" after JSONL finished — emit anyway after this. */
-    private static readonly MAX_DEFER_MS;
-    constructor(emit: AgentCompletionPushEmit, agentsIndex: () => AgentsIndex | null, getState: () => CursorState);
-    /** Sync working snapshot; flush pending push when a task leaves DOM "working". */
+    constructor(emit: AgentCompletionPushEmit, agentsIndex: () => AgentsIndex | null);
     observe(state: CursorState): void;
-    /**
-     * JSONL file updated — push if a new assistant message was appended for this task
-     * and DOM no longer shows generation for that composer.
-     */
-    onJsonlUpdated(agentId: string, messages: HistoryMessage[], state: CursorState): void;
-    private scheduleDeferTimeout;
-    private clearDeferTimer;
+    private trackWorkingSessions;
+    private detectIdleCompletions;
+    private syncPrevWorking;
     private tryEmit;
 }

package/bridge-runtime/dist/agent-completion-push.js

@@ -9,7 +9,6 @@ function isSuppressed() {
 function normalizeTitle(title) {
     return title.trim().replace(/\s+/g, ' ');
 }
-/** Ephemeral sidebar ids (tab-0) must not drive push — composerId can appear next poll. */
 function isStableComposerId(id) {
     if (!id?.trim())
         return false;
@@ -47,16 +46,14 @@ function resolveAgentChatTitle(agentId, state, agentsIndex) {
     }
     return 'Чат';
 }
-/**
- * Working agents for correlating JSONL flush with the task that was running.
- * Sidebar: stable composerId only (no tab-N flicker).
- */
+/** Active + background sidebar tabs that show generation. */
 function snapshotWorkingAgents(state, agentsIndex) {
     const map = new Map();
     const activeId = state.activeComposerId;
-    const activeGenerating = state.agentStatus === 'working' &&
+    const activeGenerating = !!state.agentWorking &&
         !!activeId &&
-        isStableComposerId(activeId);
+        isStableComposerId(activeId) &&
+        !agentPausedForInput(state, activeId);
     if (activeGenerating && activeId) {
         map.set(activeId, resolveAgentChatTitle(activeId, state, agentsIndex));
     }
@@ -66,155 +63,133 @@ function snapshotWorkingAgents(state, agentsIndex) {
         const id = tab.composerId?.trim();
         if (!id || !isStableComposerId(id))
             continue;
+        if (agentPausedForInput(state, id))
+            continue;
         map.set(id, tab.title?.trim() || resolveAgentChatTitle(id, state, agentsIndex));
     }
     return map;
 }
-function agentPausedForInput(state) {
+function agentPausedForInput(state, agentId) {
+    const isActive = state.activeComposerId === agentId;
+    if (!isActive)
+        return false;
     return ((state.pendingApprovals?.length ?? 0) > 0 ||
         !!state.pendingQuestionnaire ||
         state.agentStatus === 'waiting_approval' ||
         state.agentStatus === 'waiting_questionnaire');
 }
-function lastAssistantLineKey(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const m = messages[i];
-        if (m.role === 'assistant')
-            return m.ts ?? i;
+function isStillWorkingWithTitle(title, now) {
+    const norm = normalizeTitle(title);
+    if (!norm)
+        return false;
+    for (const t of now.values()) {
+        if (normalizeTitle(t) === norm)
+            return true;
     }
-    return 0;
+    return false;
 }
 /**
- * Push when a new assistant row lands in JSONL for the current/recent task.
- * If JSONL flushes while DOM still shows "working", retry when DOM goes idle.
+ * Push once per real generation session: agent must be stably working (≥3 DOM polls),
+ * then stably idle (≥2 polls). Opening a finished chat may flicker isWorking for 1 poll — ignored.
  */
 export class AgentCompletionPush {
     emit;
     agentsIndex;
-    getState;
-    /** Last seen assistant line id in JSONL (line number / ts). */
-    lastJsonlAssistantKey = new Map();
-    /** Agents that were generating on previous DOM poll. */
-    prevWorking = new Map();
+    prevWorking = null;
+    workingPolls = new Map();
+    /** Agent had a real generation episode this bridge session (not open-chat flicker). */
+    confirmedWorking = new Set();
+    idlePolls = new Map();
     lastEmitAt = new Map();
-    /** JSONL had a new assistant line while DOM was still working — emit after idle. */
-    pendingAfterIdle = new Set();
-    pendingDeferSince = new Map();
-    deferTimers = new Map();
-    lastJsonlMessages = new Map();
-    static MIN_EMIT_GAP_MS = 45_000;
-    /** DOM can lie "working" after JSONL finished — emit anyway after this. */
-    static MAX_DEFER_MS = 12_000;
-    constructor(emit, agentsIndex, getState) {
+    emittedThisSession = new Set();
+    /** ~3 × 400ms — ignore brief spinner when opening a finished chat. */
+    static WORKING_POLLS_REQUIRED = 3;
+    /** ~2 × 400ms idle before push. */
+    static IDLE_POLLS_REQUIRED = 2;
+    static MIN_EMIT_GAP_MS = 8_000;
+    constructor(emit, agentsIndex) {
         this.emit = emit;
         this.agentsIndex = agentsIndex;
-        this.getState = getState;
     }
-    /** Sync working snapshot; flush pending push when a task leaves DOM "working". */
     observe(state) {
-        const index = this.agentsIndex();
-        if (isSuppressed() || agentPausedForInput(state)) {
-            this.prevWorking = snapshotWorkingAgents(state, index);
+        if (isSuppressed()) {
+            this.syncPrevWorking(state);
             return;
         }
-        const nowWorking = snapshotWorkingAgents(state, index);
-        for (const agentId of this.pendingAfterIdle) {
-            if (nowWorking.has(agentId))
-                continue;
-            const messages = this.lastJsonlMessages.get(agentId);
-            if (messages?.length) {
-                this.tryEmit(agentId, messages, state, 'dom-idle');
+        const index = this.agentsIndex();
+        const now = snapshotWorkingAgents(state, index);
+        this.trackWorkingSessions(now);
+        this.detectIdleCompletions(now, state);
+    }
+    trackWorkingSessions(now) {
+        for (const id of now.keys()) {
+            const polls = (this.workingPolls.get(id) ?? 0) + 1;
+            this.workingPolls.set(id, polls);
+            if (polls >= AgentCompletionPush.WORKING_POLLS_REQUIRED && !this.confirmedWorking.has(id)) {
+                this.confirmedWorking.add(id);
+                this.emittedThisSession.delete(id);
+                this.idlePolls.delete(id);
             }
         }
-        this.prevWorking = nowWorking;
+        for (const id of this.workingPolls.keys()) {
+            if (!now.has(id))
+                this.workingPolls.delete(id);
+        }
     }
-    /**
-     * JSONL file updated — push if a new assistant message was appended for this task
-     * and DOM no longer shows generation for that composer.
-     */
-    onJsonlUpdated(agentId, messages, state) {
-        if (isSuppressed() || agentPausedForInput(state))
-            return;
-        if (!isStableComposerId(agentId))
-            return;
-        const lineKey = lastAssistantLineKey(messages);
-        if (!lineKey)
-            return;
-        const prevKey = this.lastJsonlAssistantKey.get(agentId);
-        if (prevKey === undefined) {
-            this.lastJsonlAssistantKey.set(agentId, lineKey);
-            this.lastJsonlMessages.set(agentId, messages);
+    detectIdleCompletions(now, state) {
+        const prev = this.prevWorking;
+        if (prev === null) {
+            this.prevWorking = new Map(now);
             return;
         }
-        if (lineKey <= prevKey)
-            return;
-        this.lastJsonlAssistantKey.set(agentId, lineKey);
-        this.lastJsonlMessages.set(agentId, messages);
-        const nowWorking = snapshotWorkingAgents(state, this.agentsIndex());
-        if (nowWorking.has(agentId)) {
-            this.pendingAfterIdle.add(agentId);
-            if (!this.pendingDeferSince.has(agentId)) {
-                this.pendingDeferSince.set(agentId, Date.now());
+        for (const [agentId] of prev) {
+            if (now.has(agentId)) {
+                this.idlePolls.delete(agentId);
+                continue;
             }
-            this.scheduleDeferTimeout(agentId);
-            console.log(`[agent-completion-push] defer agentId=${agentId.slice(0, 12)} line=${lineKey} (dom still working)`);
-            return;
+            if (!this.confirmedWorking.has(agentId))
+                continue;
+            const polls = (this.idlePolls.get(agentId) ?? 0) + 1;
+            this.idlePolls.set(agentId, polls);
+            if (polls < AgentCompletionPush.IDLE_POLLS_REQUIRED)
+                continue;
+            this.tryEmit(agentId, state);
         }
-        this.clearDeferTimer(agentId);
-        this.pendingDeferSince.delete(agentId);
-        this.tryEmit(agentId, messages, state, 'jsonl');
-    }
-    scheduleDeferTimeout(agentId) {
-        if (this.deferTimers.has(agentId))
-            return;
-        const timer = setTimeout(() => {
-            this.deferTimers.delete(agentId);
-            const since = this.pendingDeferSince.get(agentId) ?? 0;
-            if (!this.pendingAfterIdle.has(agentId))
-                return;
-            if (Date.now() - since < AgentCompletionPush.MAX_DEFER_MS - 100)
-                return;
-            const messages = this.lastJsonlMessages.get(agentId);
-            if (!messages?.length)
-                return;
-            console.log(`[agent-completion-push] defer timeout agentId=${agentId.slice(0, 12)} (dom still working, jsonl done)`);
-            this.tryEmit(agentId, messages, this.getState(), 'defer-timeout');
-        }, AgentCompletionPush.MAX_DEFER_MS);
-        this.deferTimers.set(agentId, timer);
+        for (const id of this.idlePolls.keys()) {
+            if (now.has(id))
+                this.idlePolls.delete(id);
+        }
+        this.prevWorking = new Map(now);
     }
-    clearDeferTimer(agentId) {
-        const t = this.deferTimers.get(agentId);
-        if (t)
-            clearTimeout(t);
-        this.deferTimers.delete(agentId);
+    syncPrevWorking(state) {
+        this.prevWorking = snapshotWorkingAgents(state, this.agentsIndex());
     }
-    tryEmit(agentId, messages, state, reason) {
-        const lineKey = lastAssistantLineKey(messages);
-        if (!lineKey)
+    tryEmit(agentId, state) {
+        if (agentPausedForInput(state, agentId))
+            return;
+        if (this.emittedThisSession.has(agentId))
+            return;
+        if (!this.confirmedWorking.has(agentId))
             return;
-        const nowWorking = snapshotWorkingAgents(state, this.agentsIndex());
-        if (reason !== 'defer-timeout' && nowWorking.has(agentId))
+        const now = snapshotWorkingAgents(state, this.agentsIndex());
+        if (now.has(agentId))
             return;
-        const isCurrentTask = state.activeComposerId === agentId ||
-            this.prevWorking.has(agentId) ||
-            this.pendingAfterIdle.has(agentId);
-        if (!isCurrentTask)
+        const title = normalizeTitle(resolveAgentChatTitle(agentId, state, this.agentsIndex())) || 'Чат';
+        if (isStillWorkingWithTitle(title, now))
             return;
         const last = this.lastEmitAt.get(agentId) ?? 0;
         if (Date.now() - last < AgentCompletionPush.MIN_EMIT_GAP_MS)
             return;
-        const chatTitle = normalizeTitle(this.prevWorking.get(agentId) ??
-            resolveAgentChatTitle(agentId, state, this.agentsIndex())) || 'Чат';
         this.emit({
             agentId,
-            chatTitle,
+            chatTitle: title,
             body: AGENT_COMPLETION_PUSH_BODY,
         });
         this.lastEmitAt.set(agentId, Date.now());
-        this.pendingAfterIdle.delete(agentId);
-        this.pendingDeferSince.delete(agentId);
-        this.clearDeferTimer(agentId);
-        this.prevWorking.delete(agentId);
-        console.log(`[agent-completion-push] → relay reason=${reason} agentId=${agentId.slice(0, 12)} title=${chatTitle.slice(0, 48)} line=${lineKey}`);
+        this.emittedThisSession.add(agentId);
+        this.confirmedWorking.delete(agentId);
+        this.idlePolls.delete(agentId);
+        this.workingPolls.delete(agentId);
+        console.log(`[agent-completion-push] → relay dom-idle agentId=${agentId.slice(0, 12)} title=${title.slice(0, 48)}`);
     }
 }

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

@@ -1,7 +1,7 @@
 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.
+ * DOM overlay → `liveMessages` in `agent:messages` until JSONL has the same turn.
  */
 export declare class ChatDisplayStore {
     private readonly domTranscript;

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

@@ -2,7 +2,7 @@ import { filterClientDisplayList, historyRowsToChat, mergeHistoryTail, messagesE
 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.
+ * DOM overlay → `liveMessages` in `agent:messages` until JSONL has the same turn.
  */
 export class ChatDisplayStore {
     domTranscript = new DomTranscriptStore();
@@ -24,6 +24,9 @@ export class ChatDisplayStore {
     /** Reload JSONL; prune DOM 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) {

package/bridge-runtime/dist/config.js

@@ -29,6 +29,8 @@ export function loadConfig() {
         relayToken: process.env.RELAY_TOKEN?.trim() ?? '',
         relayRoomId: identity?.roomId ?? relayRoomFromEnv,
         pairingClientToken: identity?.clientToken,
+        keepAwakeEnabled: process.platform === 'darwin' && process.env.KEEP_AWAKE?.trim() !== '0',
+        relayKeepaliveMs: Math.max(0, parseInt(process.env.RELAY_KEEPALIVE_MS ?? '20000', 10) || 0),
     };
 }
 export function loadSelectors() {

package/bridge-runtime/dist/connector-client-version.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-const MIN_FALLBACK = '0.1.5';
+const MIN_FALLBACK = '0.1.7';
 function readJsonVersion(path) {
     if (!existsSync(path))
         return null;

package/bridge-runtime/dist/dom-transcript-store.d.ts

@@ -1,7 +1,7 @@
 import type { ChatMessage } from './types.js';
 /**
  * Append-only per-agent transcript built from DOM snapshots.
- * Debug-only DOM transcript; not used for client chat lenta (JSONL-only).
+ * DOM transcript for live overlay until JSONL covers the same turn.
  */
 export declare class DomTranscriptStore {
     private rowsByAgent;

package/bridge-runtime/dist/dom-transcript-store.js

@@ -7,7 +7,7 @@ function transcriptKey(m) {
 }
 /**
  * Append-only per-agent transcript built from DOM snapshots.
- * Debug-only DOM transcript; not used for client chat lenta (JSONL-only).
+ * DOM transcript for live overlay until JSONL covers the same turn.
  */
 export class DomTranscriptStore {
     rowsByAgent = new Map();

package/bridge-runtime/dist/index.js

@@ -8,8 +8,11 @@ import { WindowMonitor } from './window-monitor.js';
 import { Relay } from './relay.js';
 import { MessageDebugStore } from './message-debug-store.js';
 import { connectorClientVersion } from './connector-client-version.js';
+import { installKeepAwakeShutdown, startKeepAwake } from './keep-awake.js';
 async function main() {
     const config = loadConfig();
+    startKeepAwake(config.keepAwakeEnabled);
+    installKeepAwakeShutdown();
     const selectors = loadSelectors();
     const connectorVersion = connectorClientVersion();
     console.log('=== CursorConnect Bridge ===');
@@ -18,6 +21,12 @@ async function main() {
     console.log(`Server: http://${config.serverHost}:${config.serverPort}`);
     if (config.relayUrl) {
         console.log(`Relay upstream: ${config.relayUrl} (room=${config.relayRoomId})`);
+        if (config.relayKeepaliveMs > 0) {
+            console.log(`Relay keepalive: every ${config.relayKeepaliveMs}ms`);
+        }
+    }
+    if (config.keepAwakeEnabled) {
+        console.log('Keep-awake: on (macOS caffeinate)');
     }
     console.log(`Projects: ${config.cursorProjectsDir}`);
     const stateManager = new StateManager(config.debounceMs);

package/bridge-runtime/dist/keep-awake.d.ts

@@ -0,0 +1,5 @@
+/** macOS: `caffeinate -w <pid>` — Mac не уходит в сон, пока живёт bridge. */
+export declare function startKeepAwake(enabled: boolean): void;
+export declare function stopKeepAwake(): void;
+export declare function isKeepAwakeActive(): boolean;
+export declare function installKeepAwakeShutdown(): void;

package/bridge-runtime/dist/keep-awake.js

@@ -0,0 +1,48 @@
+import { spawn } from 'child_process';
+let caffeinate = null;
+/** macOS: `caffeinate -w <pid>` — Mac не уходит в сон, пока живёт bridge. */
+export function startKeepAwake(enabled) {
+    if (!enabled || process.platform !== 'darwin')
+        return;
+    if (caffeinate)
+        return;
+    try {
+        caffeinate = spawn('caffeinate', ['-w', String(process.pid)], {
+            stdio: 'ignore',
+        });
+        caffeinate.on('error', (err) => {
+            console.warn(`[keep-awake] caffeinate error: ${err.message}`);
+            caffeinate = null;
+        });
+        caffeinate.on('exit', (code, signal) => {
+            if (code != null && code !== 0) {
+                console.warn(`[keep-awake] caffeinate exited code=${code} signal=${signal ?? '-'}`);
+            }
+            caffeinate = null;
+        });
+        console.log('[keep-awake] macOS sleep prevention on (caffeinate -w bridge)');
+    }
+    catch (e) {
+        console.warn(`[keep-awake] start failed: ${e.message}`);
+    }
+}
+export function stopKeepAwake() {
+    if (!caffeinate)
+        return;
+    try {
+        caffeinate.kill('SIGTERM');
+    }
+    catch {
+        /* already dead */
+    }
+    caffeinate = null;
+}
+export function isKeepAwakeActive() {
+    return caffeinate != null && caffeinate.exitCode == null;
+}
+export function installKeepAwakeShutdown() {
+    const stop = () => stopKeepAwake();
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+    process.once('exit', stop);
+}

package/bridge-runtime/dist/relay-upstream.d.ts

@@ -5,9 +5,12 @@ export declare class RelayUpstream {
     private onClientEvent;
     private onConnect?;
     private socket;
+    private keepaliveTimer;
     constructor(config: ServerConfig, onClientEvent: UpstreamCommandHandler, onConnect?: (() => void) | undefined);
     private registerPairing;
     connect(): void;
+    private startKeepalive;
+    private stopKeepalive;
     emit(event: string, ...args: unknown[]): void;
     get connected(): boolean;
     private handleHttpProxy;

package/bridge-runtime/dist/relay-upstream.js

@@ -14,6 +14,7 @@ export class RelayUpstream {
     onClientEvent;
     onConnect;
     socket = null;
+    keepaliveTimer = null;
     constructor(config, onClientEvent, onConnect) {
         this.config = config;
         this.onClientEvent = onClientEvent;
@@ -85,6 +86,26 @@ export class RelayUpstream {
         this.socket.on('relay:http', (req) => {
             void this.handleHttpProxy(req);
         });
+        this.startKeepalive();
+    }
+    startKeepalive() {
+        this.stopKeepalive();
+        const ms = this.config.relayKeepaliveMs;
+        if (!this.config.relayUrl || ms <= 0)
+            return;
+        this.keepaliveTimer = setInterval(() => {
+            if (!this.socket?.connected)
+                return;
+            this.socket.emit('relay:connector-ping', {
+                roomId: this.config.relayRoomId,
+                ts: Date.now(),
+            });
+        }, ms);
+    }
+    stopKeepalive() {
+        if (this.keepaliveTimer)
+            clearInterval(this.keepaliveTimer);
+        this.keepaliveTimer = null;
     }
     emit(event, ...args) {
         if (this.socket?.connected)

package/bridge-runtime/dist/relay.d.ts

@@ -28,6 +28,11 @@ export declare class Relay {
     private readonly chatDisplay;
     /** Raw JSONL row count last sent per agent (live `append` emits). */
     private readonly lastEmittedJsonlRows;
+    /** Last display tail pushed to app — re-emit when user/assistant tail changes. */
+    private readonly lastEmittedLentaSig;
+    /** Display bubble count last sent — block regression 214→74 style wipes on phone. */
+    private readonly lastEmittedHistLen;
+    private domOverlayTimer;
     constructor(config: ServerConfig, stateManager: StateManager, commandExecutor: CommandExecutor, cdpBridge: CDPBridge, jsonlIndex: JsonlIndex, messageDebugStore: MessageDebugStore, domExtractor: DOMExtractor);
     private emitAgentCompletedPush;
     private flushPendingPushPayloads;
@@ -38,9 +43,15 @@ export declare class Relay {
     private readOnlyChatSnapshot;
     /** Push JSONL file updates to every subscribed route id (e.g. sidebar-0) for that composer. */
     private syncJsonlToSubscribedAgents;
-    /** Live JSONL: push display deltas to app; `totalMessages` = raw `.jsonl` line count. */
+    /** JSONL baseline + DOM rows not yet in file (`liveMessages`). */
+    private lentaSnapshot;
+    private emitLentaForAgent;
+    private lentaTailSignature;
+    /** Live JSONL → `agent:messages` for subscribed chats (phone lenta). */
     private emitJsonlLiveForAgent;
-    /** Client lenta: JSONL only (`liveMessages` always empty). DOM stays in debug snapshot. */
+    private scheduleDomOverlayEmit;
+    /** DOM poll while agent works — overlay until the same turn lands in JSONL. */
+    private emitDomOverlayForSyncedSubscribers;
     private agentMessagesSnapshot;
     private checkMediaAuth;
     private setupHttp;
@@ -49,7 +60,6 @@ export declare class Relay {
     private historySeqByAgent;
     private nextHistorySeq;
     private emitAgentMessages;
-    /** DOM messages in state:patch — debug/UI chrome only; chat lenta is JSONL via agent:messages. */
     private prepareStateMessages;
     private withDisplayState;
     private wireEvents;

package/bridge-runtime/dist/relay.js

@@ -6,9 +6,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 { isKeepAwakeActive } from './keep-awake.js';
 function sleepMs(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -20,6 +20,7 @@ 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 { readJsonlLiveSnapshot } from './jsonl-live-debug.js';
 export class Relay {
     stateManager;
@@ -44,6 +45,11 @@ 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();
+    domOverlayTimer = null;
     constructor(config, stateManager, commandExecutor, cdpBridge, jsonlIndex, messageDebugStore, domExtractor) {
         this.stateManager = stateManager;
         this.commandExecutor = commandExecutor;
@@ -67,7 +73,7 @@ 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.upstream.connect();
             }
         }
@@ -83,11 +89,14 @@ 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());
@@ -163,46 +172,96 @@ export class Relay {
             this.emitJsonlLiveForAgent(agentId, messages, totalMessages);
         }
     }
-    /** Live JSONL: push display deltas to app; `totalMessages` = raw `.jsonl` line count. */
+    /** JSONL baseline + DOM rows not yet in file (`liveMessages`). */
+    lentaSnapshot(agentId, totalMessages) {
+        const historyMessages = this.chatDisplay.getJsonlHistory(agentId);
+        const liveMessages = this.chatDisplay.getDomLive(agentId);
+        const source = liveMessages.length ? 'hybrid' : 'jsonl';
+        return {
+            historyMessages,
+            liveMessages,
+            messages: [...historyMessages, ...liveMessages],
+            totalMessages: totalMessages ?? historyMessages.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, opts.totalMessages, opts.seq, opts.append);
+    }
+    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);
         this.chatDisplay.setJsonlBaseline(agentId, rows);
         this.lastEmittedJsonlRows.set(agentId, totalMessages);
         const historyMessages = this.chatDisplay.getJsonlHistory(agentId);
-        if (!historyMessages.length)
+        if (!historyMessages.length && !this.chatDisplay.getDomLive(agentId).length)
             return;
-        if (!prevLen) {
-            this.emitAgentMessages(agentId, historyMessages, [], 'jsonl', totalMessages, this.nextHistorySeq(agentId), false);
+        if (!this.jsonlIndex.getSubscribedAgents().has(agentId))
             return;
-        }
-        const appended = historyMessages.slice(prevLen);
-        if (appended.length) {
-            this.emitAgentMessages(agentId, appended, [], 'jsonl', totalMessages, this.nextHistorySeq(agentId), true);
+        const sig = this.lentaTailSignature(historyMessages);
+        const totalGrew = totalMessages > prevTotal;
+        if (!totalGrew && sig === prevSig && prevSig)
             return;
-        }
-        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);
+        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;
         }
-        if (prevLen !== historyMessages.length || !this.jsonlIndex.getSubscribedAgents().has(agentId)) {
-            this.emitAgentMessages(agentId, historyMessages, [], 'jsonl', totalMessages, this.nextHistorySeq(agentId), false);
+        this.lastEmittedLentaSig.set(agentId, sig);
+        this.lastEmittedHistLen.set(agentId, Math.max(prevHistLen, histLen));
+        this.emitLentaForAgent(agentId, {
+            totalMessages,
+            seq: this.nextHistorySeq(agentId),
+        });
+    }
+    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();
+        if (!state.messages?.length)
+            return;
+        const domRows = this.prepareStateMessages(state.messages);
+        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)
+                continue;
+            this.lastEmittedLentaSig.delete(subId);
+            this.emitLentaForAgent(subId, {
+                totalMessages: snap.totalMessages,
+                seq: this.nextHistorySeq(subId),
+            });
         }
     }
-    /** Client lenta: JSONL only (`liveMessages` always empty). DOM stays in debug snapshot. */
     agentMessagesSnapshot(agentId, totalMessages) {
-        const historyMessages = this.chatDisplay.getJsonlHistory(agentId);
-        return {
-            historyMessages,
-            liveMessages: [],
-            messages: historyMessages,
-            totalMessages: totalMessages ?? historyMessages.length,
-        };
+        return this.lentaSnapshot(agentId, totalMessages);
     }
     checkMediaAuth(req) {
         if (!this.authEnabled)
@@ -218,6 +277,7 @@ export class Relay {
             res.json({
                 ok: true,
                 cdp: this.cdpBridge.getClient()?.isConnected() ?? false,
+                keepAwake: isKeepAwakeActive(),
                 debugChats: '/debug/chats',
                 debugSnapshot: '/debug/chat-snapshot',
                 debugJsonlLive: '/debug/jsonl-live',
@@ -342,29 +402,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 +583,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;
@@ -565,7 +630,6 @@ export class Relay {
             append: append || undefined,
         });
     }
-    /** DOM messages in state:patch — debug/UI chrome only; chat lenta is JSONL via agent:messages. */
     prepareStateMessages(raw) {
         return filterClientDisplayList(prepareChatMessagesForDisplay(raw));
     }
@@ -586,6 +650,9 @@ export class Relay {
         this.stateManager.on('state:patch', (patch) => {
             this.broadcast('state:patch', this.withDisplayState(patch));
             this.observeAgentCompletionForPush();
+            if (patch.messages?.length) {
+                this.scheduleDomOverlayEmit();
+            }
             if (patch.sidebarRepos || patch.composerIdByTitle) {
                 const key = JSON.stringify([patch.sidebarRepos, patch.composerIdByTitle]);
                 if (key !== this.lastSidebarIndexKey) {
@@ -605,7 +672,6 @@ 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.jsonlIndex.on('agent:history', (history) => {
             const total = history.totalMessages ?? history.messages.length;
@@ -795,36 +861,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 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 ?? '-'}`);
@@ -872,11 +930,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 +947,22 @@ 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 });
     }
     /** Открытие чата: 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);
+            }
             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 +976,8 @@ export class Relay {
             this.jsonlIndex.unsubscribe(agentId);
             this.chatDisplay.clearAgent(agentId);
             this.lastEmittedJsonlRows.delete(agentId);
+            this.lastEmittedLentaSig.delete(agentId);
+            this.lastEmittedHistLen.delete(agentId);
         }
     }
     async runAgentsFocus({ agentId, title }, reply) {

package/bridge-runtime/dist/types.d.ts

@@ -33,6 +33,10 @@ export interface ServerConfig {
     relayUrl: string;
     relayToken: string;
     relayRoomId: string;
+    /** macOS: prevent system sleep while bridge runs (`KEEP_AWAKE=0` to disable). */
+    keepAwakeEnabled: boolean;
+    /** Periodic upstream ping when `relayUrl` set; `0` = off. */
+    relayKeepaliveMs: number;
     /** Client token from ~/.cursorconnect/identity.json (relay room pairing). */
     pairingClientToken?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursorconnect",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "CLI: Cursor Connect on Mac + relay pairing — install once, run from anywhere",
   "license": "MIT",
   "type": "module",

package/version-policy.json

@@ -1,7 +1,7 @@
 {
-  "minCliVersion": "0.1.4",
+  "minCliVersion": "0.1.7",
   "minAppVersion": "0.2.2",
-  "latestCliVersion": "0.1.7",
+  "latestCliVersion": "0.1.8",
   "latestAppVersion": "0.2.2",
   "updateCliCommand": "npm install -g cursorconnect@latest",
   "updateAppHint": "Обновите CursorConnect в App Store / TestFlight до последней сборки."