cursorconnect 0.1.8 → 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

package/bridge-runtime/connector-version.json

@@ -1 +1 @@
-{"cliVersion":"0.1.8","bundledAt":"2026-05-26T06:15:47Z"}
+{"cliVersion":"0.1.9","bundledAt":"2026-05-26T11:11:21Z"}

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

@@ -1,3 +1,4 @@
+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;
@@ -7,29 +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 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.
+ * Push when sidebar loader off + archive/lenta ready for open-from-push.
  */
 export declare class AgentCompletionPush {
     private emit;
     private agentsIndex;
+    private getState;
+    private deps;
     private prevWorking;
     private workingPolls;
-    /** Agent had a real generation episode this bridge session (not open-chat flicker). */
     private confirmedWorking;
     private idlePolls;
     private lastEmitAt;
     private emittedThisSession;
-    /** ~3 × 400ms — ignore brief spinner when opening a finished chat. */
+    private pendingContent;
+    private contentTimers;
+    private lastSkipLogAt;
     private static readonly WORKING_POLLS_REQUIRED;
-    /** ~2 × 400ms idle before push. */
     private static readonly IDLE_POLLS_REQUIRED;
     private static readonly MIN_EMIT_GAP_MS;
-    constructor(emit: AgentCompletionPushEmit, agentsIndex: () => AgentsIndex | null);
+    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;
+    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) {
@@ -15,8 +17,57 @@ function isStableComposerId(id) {
     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)
@@ -25,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;
@@ -46,26 +103,33 @@ function resolveAgentChatTitle(agentId, state, agentsIndex) {
     }
     return 'Чат';
 }
-/** Active + background sidebar tabs that show generation. */
-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.agentWorking &&
-        !!activeId &&
-        isStableComposerId(activeId) &&
-        !agentPausedForInput(state, 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;
-        if (agentPausedForInput(state, 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;
 }
@@ -76,7 +140,8 @@ function agentPausedForInput(state, agentId) {
     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 isStillWorkingWithTitle(title, now) {
     const norm = normalizeTitle(title);
@@ -89,27 +154,32 @@ function isStillWorkingWithTitle(title, now) {
     return false;
 }
 /**
- * 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.
+ * Push when sidebar loader off + archive/lenta ready for open-from-push.
  */
 export class AgentCompletionPush {
     emit;
     agentsIndex;
+    getState;
+    deps;
     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();
     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;
+    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;
-    constructor(emit, agentsIndex) {
+    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;
     }
     observe(state) {
         if (isSuppressed()) {
@@ -117,18 +187,38 @@ export class AgentCompletionPush {
             return;
         }
         const index = this.agentsIndex();
-        const now = snapshotWorkingAgents(state, index);
-        this.trackWorkingSessions(now);
+        const now = snapshotSidebarWorkingAgents(state, index);
+        this.trackWorkingSessions(now, state);
         this.detectIdleCompletions(now, state);
+        this.retryPendingContent(state);
     }
-    trackWorkingSessions(now) {
+    retryPendingContent(state) {
+        for (const agentId of [...this.pendingContent]) {
+            this.tryEmit(agentId, state, { sidebarIdle: true });
+        }
+    }
+    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);
+        }
         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)) {
+            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);
             }
         }
         for (const id of this.workingPolls.keys()) {
@@ -147,13 +237,16 @@ export class AgentCompletionPush {
                 this.idlePolls.delete(agentId);
                 continue;
             }
-            if (!this.confirmedWorking.has(agentId))
+            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;
-            this.tryEmit(agentId, state);
+            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))
@@ -162,24 +255,57 @@ export class AgentCompletionPush {
         this.prevWorking = new Map(now);
     }
     syncPrevWorking(state) {
-        this.prevWorking = snapshotWorkingAgents(state, this.agentsIndex());
+        this.prevWorking = snapshotSidebarWorkingAgents(state, this.agentsIndex());
     }
-    tryEmit(agentId, state) {
-        if (agentPausedForInput(state, agentId))
+    tryEmit(agentId, state, opts) {
+        if (agentPausedForInput(state, agentId)) {
+            this.logSkip(agentId, 'paused-for-input');
             return;
-        if (this.emittedThisSession.has(agentId))
+        }
+        if (this.emittedThisSession.has(agentId)) {
+            this.logSkip(agentId, 'already-emitted');
             return;
-        if (!this.confirmedWorking.has(agentId))
+        }
+        if (!this.confirmedWorking.has(agentId)) {
+            this.logSkip(agentId, 'no-confirmed-working');
             return;
-        const now = snapshotWorkingAgents(state, this.agentsIndex());
-        if (now.has(agentId))
+        }
+        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, this.agentsIndex())) || 'Чат';
-        if (isStillWorkingWithTitle(title, now))
+        }
+        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;
+        }
         this.emit({
             agentId,
             chatTitle: title,
@@ -190,6 +316,25 @@ export class AgentCompletionPush {
         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)}`);
+        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' };
+}

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

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