cursorconnect 0.1.7 → 0.1.9

package/bridge-runtime/.env.example

@@ -3,6 +3,8 @@ SERVER_HOST=127.0.0.1
 SERVER_PORT=3847
 POLL_INTERVAL_MS=400
 DEBOUNCE_MS=150
+# Coalesce socket agent:messages for DOM overlay (store ingest is immediate)
+# DOM_OVERLAY_EMIT_MS=50
 # JSONL live lenta: poll subscribed (120ms), live watcher on subscribe (immediate), debounce off for live
 # JSONL_POLL_MS=120
 # JSONL_EMIT_DEBOUNCE_MS=0
@@ -13,7 +15,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 +27,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.9","bundledAt":"2026-05-26T11:11:21Z"}

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

@@ -1,4 +1,5 @@
-import type { AgentsIndex, CursorState, HistoryMessage } from './types.js';
+import { type AgentCompletionReadinessDeps } from './agent-completion-readiness.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 {
@@ -7,36 +8,40 @@ export interface AgentCompletionPushPayload {
     body: string;
 }
 export type AgentCompletionPushEmit = (payload: AgentCompletionPushPayload) => void;
+export interface AgentCompletionPushDeps {
+    readiness: AgentCompletionReadinessDeps;
+    requestContentSync(agentId: string, state: CursorState): 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 when sidebar loader off + archive/lenta ready for open-from-push.
  */
 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 deps;
     private prevWorking;
+    private workingPolls;
+    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;
+    private pendingContent;
+    private contentTimers;
+    private lastSkipLogAt;
+    private static readonly WORKING_POLLS_REQUIRED;
+    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". */
+    private static readonly CONTENT_WAIT_MAX_MS;
+    private static readonly SKIP_LOG_GAP_MS;
+    constructor(emit: AgentCompletionPushEmit, agentsIndex: () => AgentsIndex | null, getState: () => CursorState, deps: AgentCompletionPushDeps);
     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;
+    retryPendingContent(state: CursorState): void;
+    private logSkip;
+    private trackWorkingSessions;
+    private detectIdleCompletions;
+    private syncPrevWorking;
     private tryEmit;
+    private scheduleContentTimeout;
+    private clearContentTimer;
 }

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

@@ -1,3 +1,5 @@
+import { isComposerUuid, normalizeAgentTitle } from './chat-sync.js';
+import { assessAgentCompletionReadiness, } from './agent-completion-readiness.js';
 export const AGENT_COMPLETION_PUSH_BODY = 'Агент завершил работу';
 let suppressUntil = 0;
 export function suppressAgentCompletionPush(ms = 6000) {
@@ -9,15 +11,63 @@ 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;
     const t = id.trim();
     if (t.startsWith('tab-'))
         return false;
+    if (t.startsWith('sidebar-'))
+        return false;
     return t.length >= 8;
 }
+function lookupComposerIdByTitle(title, map) {
+    if (!title?.trim() || !map)
+        return undefined;
+    return map[normalizeAgentTitle(title)];
+}
+function resolveAgentIdFromIndex(title, agentsIndex) {
+    const norm = normalizeAgentTitle(title);
+    if (!norm || !agentsIndex)
+        return undefined;
+    for (const repo of agentsIndex.repos) {
+        for (const agent of repo.agents) {
+            if (normalizeAgentTitle(agent.title) !== norm)
+                continue;
+            if (isStableComposerId(agent.id) || isComposerUuid(agent.id))
+                return agent.id.trim();
+        }
+    }
+    return undefined;
+}
+function resolveSidebarAgentId(rawId, title, state, agentsIndex) {
+    if (isStableComposerId(rawId))
+        return rawId.trim();
+    if (isComposerUuid(rawId))
+        return rawId.trim();
+    const activeId = state.activeComposerId?.trim();
+    const activeTab = state.tabs.find((t) => t.active);
+    if (activeTab?.isWorking && activeId && isStableComposerId(activeId)) {
+        const raw = String(rawId).trim();
+        const tabComposer = activeTab.composerId ? String(activeTab.composerId).trim() : '';
+        const tabTitle = normalizeAgentTitle(activeTab.title ?? '');
+        const titleNorm = normalizeAgentTitle(title);
+        const sameRow = raw === activeTab.id ||
+            (tabComposer && raw === tabComposer) ||
+            !titleNorm ||
+            tabTitle === titleNorm;
+        if (sameRow && (!titleNorm || tabTitle === titleNorm || !tabTitle)) {
+            return activeId;
+        }
+    }
+    const fromTitle = lookupComposerIdByTitle(title, state.composerIdByTitle);
+    if (fromTitle && isStableComposerId(fromTitle))
+        return fromTitle;
+    const fromIndex = resolveAgentIdFromIndex(title, agentsIndex);
+    if (fromIndex)
+        return fromIndex;
+    return undefined;
+}
 function titleForComposerId(agentId, state) {
     const activeTitle = state.activeChatTitle?.trim();
     if (state.activeComposerId === agentId && activeTitle)
@@ -26,11 +76,17 @@ function titleForComposerId(agentId, state) {
         const id = tab.composerId ?? tab.id;
         if (id === agentId)
             return tab.title?.trim() || undefined;
+        const resolved = resolveSidebarAgentId(tab.composerId ?? tab.id, tab.title ?? '', state);
+        if (resolved === agentId)
+            return tab.title?.trim() || undefined;
     }
     for (const repo of state.sidebarRepos ?? []) {
         for (const agent of repo.agents) {
             if (agent.id === agentId)
                 return agent.title?.trim() || undefined;
+            const resolved = resolveSidebarAgentId(agent.id, agent.title, state);
+            if (resolved === agentId)
+                return agent.title?.trim() || undefined;
         }
     }
     return undefined;
@@ -47,174 +103,238 @@ 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).
- */
-function snapshotWorkingAgents(state, agentsIndex) {
+/** Sidebar loading-indicator on list rows (`tabs` + `sidebarRepos`). */
+function snapshotSidebarWorkingAgents(state, agentsIndex) {
     const map = new Map();
-    const activeId = state.activeComposerId;
-    const activeGenerating = state.agentStatus === 'working' &&
-        !!activeId &&
-        isStableComposerId(activeId);
-    if (activeGenerating && activeId) {
-        map.set(activeId, resolveAgentChatTitle(activeId, state, agentsIndex));
+    const add = (rawId, title) => {
+        const id = resolveSidebarAgentId(rawId, title, state, agentsIndex);
+        if (!id)
+            return;
+        if (agentPausedForInput(state, id))
+            return;
+        map.set(id, title.trim() || resolveAgentChatTitle(id, state, agentsIndex));
+    };
+    const activeId = state.activeComposerId?.trim();
+    const activeTab = state.tabs.find((t) => t.active);
+    if (activeTab?.isWorking && activeId && isStableComposerId(activeId)) {
+        add(activeId, activeTab.title ?? state.activeChatTitle ?? '');
     }
     for (const tab of state.tabs) {
         if (!tab.isWorking)
             continue;
-        const id = tab.composerId?.trim();
-        if (!id || !isStableComposerId(id))
-            continue;
-        map.set(id, tab.title?.trim() || resolveAgentChatTitle(id, state, agentsIndex));
+        add(tab.composerId ?? tab.id, tab.title ?? '');
+    }
+    for (const repo of state.sidebarRepos ?? []) {
+        for (const agent of repo.agents) {
+            if (!agent.isWorking)
+                continue;
+            add(agent.id, agent.title);
+        }
     }
     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');
+        state.agentStatus === 'waiting_questionnaire' ||
+        (state.agentStatus === 'background_shell' && state.agentWorking !== true));
 }
-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 when sidebar loader off + archive/lenta ready for open-from-push.
  */
 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();
+    deps;
+    prevWorking = null;
+    workingPolls = new Map();
+    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();
+    pendingContent = new Set();
+    contentTimers = new Map();
+    lastSkipLogAt = new Map();
+    static WORKING_POLLS_REQUIRED = 2;
+    static IDLE_POLLS_REQUIRED = 1;
+    static MIN_EMIT_GAP_MS = 8_000;
+    static CONTENT_WAIT_MAX_MS = 12_000;
+    static SKIP_LOG_GAP_MS = 5_000;
+    constructor(emit, agentsIndex, getState, deps) {
         this.emit = emit;
         this.agentsIndex = agentsIndex;
         this.getState = getState;
+        this.deps = deps;
     }
-    /** 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 = snapshotSidebarWorkingAgents(state, index);
+        this.trackWorkingSessions(now, state);
+        this.detectIdleCompletions(now, state);
+        this.retryPendingContent(state);
+    }
+    retryPendingContent(state) {
+        for (const agentId of [...this.pendingContent]) {
+            this.tryEmit(agentId, state, { sidebarIdle: true });
         }
-        this.prevWorking = nowWorking;
     }
-    /**
-     * 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);
+    logSkip(agentId, reason) {
+        const last = this.lastSkipLogAt.get(agentId) ?? 0;
+        if (Date.now() - last < AgentCompletionPush.SKIP_LOG_GAP_MS)
             return;
+        this.lastSkipLogAt.set(agentId, Date.now());
+        console.log(`[agent-completion-push] skip agentId=${agentId.slice(0, 12)} reason=${reason}`);
+    }
+    trackWorkingSessions(now, state) {
+        const activeId = state.activeComposerId?.trim();
+        if (activeId && isStableComposerId(activeId) && now.has(activeId)) {
+            this.confirmedWorking.add(activeId);
+            this.emittedThisSession.delete(activeId);
         }
-        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 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.add(id);
+                this.emittedThisSession.delete(id);
+                this.idlePolls.delete(id);
+                this.pendingContent.delete(id);
+                this.clearContentTimer(id);
             }
-            this.scheduleDeferTimeout(agentId);
-            console.log(`[agent-completion-push] defer agentId=${agentId.slice(0, 12)} line=${lineKey} (dom still working)`);
-            return;
         }
-        this.clearDeferTimer(agentId);
-        this.pendingDeferSince.delete(agentId);
-        this.tryEmit(agentId, messages, state, 'jsonl');
+        for (const id of this.workingPolls.keys()) {
+            if (!now.has(id))
+                this.workingPolls.delete(id);
+        }
     }
-    scheduleDeferTimeout(agentId) {
-        if (this.deferTimers.has(agentId))
+    detectIdleCompletions(now, state) {
+        const prev = this.prevWorking;
+        if (prev === null) {
+            this.prevWorking = new Map(now);
             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 [agentId] of prev) {
+            if (now.has(agentId)) {
+                this.idlePolls.delete(agentId);
+                continue;
+            }
+            if (!this.confirmedWorking.has(agentId)) {
+                this.logSkip(agentId, 'no-confirmed-working');
+                continue;
+            }
+            const polls = (this.idlePolls.get(agentId) ?? 0) + 1;
+            this.idlePolls.set(agentId, polls);
+            if (polls < AgentCompletionPush.IDLE_POLLS_REQUIRED)
+                continue;
+            console.log(`[agent-completion-push] sidebar idle agentId=${agentId.slice(0, 12)} title=${(prev.get(agentId) ?? '').slice(0, 40)}`);
+            this.tryEmit(agentId, state, { sidebarIdle: true });
+        }
+        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 = snapshotSidebarWorkingAgents(state, this.agentsIndex());
     }
-    tryEmit(agentId, messages, state, reason) {
-        const lineKey = lastAssistantLineKey(messages);
-        if (!lineKey)
+    tryEmit(agentId, state, opts) {
+        if (agentPausedForInput(state, agentId)) {
+            this.logSkip(agentId, 'paused-for-input');
             return;
-        const nowWorking = snapshotWorkingAgents(state, this.agentsIndex());
-        if (reason !== 'defer-timeout' && nowWorking.has(agentId))
+        }
+        if (this.emittedThisSession.has(agentId)) {
+            this.logSkip(agentId, 'already-emitted');
             return;
-        const isCurrentTask = state.activeComposerId === agentId ||
-            this.prevWorking.has(agentId) ||
-            this.pendingAfterIdle.has(agentId);
-        if (!isCurrentTask)
+        }
+        if (!this.confirmedWorking.has(agentId)) {
+            this.logSkip(agentId, 'no-confirmed-working');
             return;
+        }
+        const index = this.agentsIndex();
+        const now = snapshotSidebarWorkingAgents(state, index);
+        if (now.has(agentId)) {
+            this.pendingContent.delete(agentId);
+            this.clearContentTimer(agentId);
+            this.logSkip(agentId, 'sidebar-still-working');
+            return;
+        }
+        const title = normalizeTitle(resolveAgentChatTitle(agentId, state, index)) || 'Чат';
+        if (isStillWorkingWithTitle(title, now)) {
+            this.logSkip(agentId, 'same-title-still-working');
+            return;
+        }
+        const sidebarIdle = opts?.sidebarIdle === true;
+        let contentDetail = 'no-check';
+        if (!opts?.forceContent) {
+            const readiness = assessAgentCompletionReadiness(agentId, state, this.deps.readiness, { sidebarIdle });
+            contentDetail = readiness.detail;
+            if (!readiness.ready) {
+                if (!this.pendingContent.has(agentId)) {
+                    this.pendingContent.add(agentId);
+                    console.log(`[agent-completion-push] wait content agentId=${agentId.slice(0, 12)} detail=${readiness.detail}`);
+                    this.deps.requestContentSync(agentId, state);
+                    this.scheduleContentTimeout(agentId);
+                }
+                return;
+            }
+        }
+        else {
+            contentDetail = 'content-timeout';
+        }
         const last = this.lastEmitAt.get(agentId) ?? 0;
-        if (Date.now() - last < AgentCompletionPush.MIN_EMIT_GAP_MS)
+        if (Date.now() - last < AgentCompletionPush.MIN_EMIT_GAP_MS) {
+            this.logSkip(agentId, 'emit-gap');
             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);
+        this.pendingContent.delete(agentId);
+        this.clearContentTimer(agentId);
+        console.log(`[agent-completion-push] → relay reason=sidebar-idle+${contentDetail} agentId=${agentId.slice(0, 12)} title=${title.slice(0, 48)}`);
+    }
+    scheduleContentTimeout(agentId) {
+        this.clearContentTimer(agentId);
+        const timer = setTimeout(() => {
+            this.contentTimers.delete(agentId);
+            if (!this.pendingContent.has(agentId))
+                return;
+            console.log(`[agent-completion-push] content wait timeout agentId=${agentId.slice(0, 12)} — push anyway`);
+            this.tryEmit(agentId, this.getState(), { forceContent: true, sidebarIdle: true });
+        }, AgentCompletionPush.CONTENT_WAIT_MAX_MS);
+        this.contentTimers.set(agentId, timer);
+    }
+    clearContentTimer(agentId) {
+        const t = this.contentTimers.get(agentId);
+        if (t)
+            clearTimeout(t);
+        this.contentTimers.delete(agentId);
     }
 }

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

@@ -0,0 +1,19 @@
+import type { ChatMessage, CursorState } from './types.js';
+export interface AgentCompletionReadinessDeps {
+    isSubscribed(agentId: string): boolean;
+    getSubscribeTitle(agentId: string): string | undefined;
+    getDisplayMessages(agentId: string): ChatMessage[];
+    getJsonlHistory(agentId: string): ChatMessage[];
+}
+export interface AgentCompletionReadinessOpts {
+    /** Sidebar loader already off for this agent (DOM list). */
+    sidebarIdle?: boolean;
+}
+/**
+ * Push when opening the chat shows a complete turn.
+ * When sidebar is idle, do not block on `lenta-pending` (DOM overlay may still churn seq).
+ */
+export declare function assessAgentCompletionReadiness(agentId: string, state: CursorState, deps: AgentCompletionReadinessDeps, opts?: AgentCompletionReadinessOpts): {
+    ready: boolean;
+    detail: string;
+};

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

@@ -0,0 +1,42 @@
+import { isChatSyncedWithCursor } from './chat-sync.js';
+import { isLentaDeliveryPending } from './lenta-delivery.js';
+function hasAssistantTail(history) {
+    const last = history[history.length - 1];
+    return !!last && last.role === 'assistant' && !!(last.text?.trim() || last.html?.trim());
+}
+/**
+ * Push when opening the chat shows a complete turn.
+ * When sidebar is idle, do not block on `lenta-pending` (DOM overlay may still churn seq).
+ */
+export function assessAgentCompletionReadiness(agentId, state, deps, opts) {
+    const messages = deps.getDisplayMessages(agentId);
+    const history = deps.getJsonlHistory(agentId);
+    const subscribed = deps.isSubscribed(agentId);
+    const title = deps.getSubscribeTitle(agentId);
+    const sidebarIdle = opts?.sidebarIdle === true;
+    if (sidebarIdle && hasAssistantTail(history)) {
+        if (subscribed && title && isChatSyncedWithCursor(agentId, title, state)) {
+            if (isLentaDeliveryPending(agentId, messages)) {
+                return { ready: true, detail: 'jsonl-ready-sidebar-idle' };
+            }
+            return { ready: true, detail: 'lenta-delivered' };
+        }
+        return { ready: true, detail: 'jsonl-archive' };
+    }
+    if (subscribed && title && isChatSyncedWithCursor(agentId, title, state)) {
+        if (!messages.length && !history.length) {
+            return { ready: false, detail: 'lenta-empty' };
+        }
+        if (isLentaDeliveryPending(agentId, messages)) {
+            return { ready: false, detail: 'lenta-pending' };
+        }
+        return { ready: true, detail: 'lenta-delivered' };
+    }
+    if (hasAssistantTail(history)) {
+        if (subscribed && messages.length && isLentaDeliveryPending(agentId, messages)) {
+            return { ready: false, detail: 'lenta-pending-bg' };
+        }
+        return { ready: true, detail: 'jsonl-archive' };
+    }
+    return { ready: false, detail: 'no-archive' };
+}