cursorconnect 0.1.0 → 0.1.2

package/bridge-runtime/dist/extract-page.js

@@ -0,0 +1,1202 @@
+/**
+ * Runs inside Cursor renderer — must be self-contained.
+ */
+export function extractionFunction(containerSelectors, tabSelectors, inputSelectors, approveSelectors, approveTextMatch, rejectSelectors, rejectTextMatch) {
+    function findFirst(sels) {
+        for (const sel of sels) {
+            try {
+                const el = document.querySelector(sel);
+                if (el)
+                    return el;
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return null;
+    }
+    function buildSelectorPath(el) {
+        const parts = [];
+        let cur = el;
+        while (cur && cur !== document.body) {
+            let seg = cur.tagName.toLowerCase();
+            if (cur.id) {
+                seg += `#${cur.id.replace(/([.:])/g, '\\$1')}`;
+                parts.unshift(seg);
+                break;
+            }
+            const parent = cur.parentElement;
+            if (parent) {
+                const siblings = Array.from(parent.children).filter((c) => c.tagName === cur.tagName);
+                if (siblings.length > 1) {
+                    seg += `:nth-of-type(${siblings.indexOf(cur) + 1})`;
+                }
+            }
+            parts.unshift(seg);
+            cur = parent;
+        }
+        return parts.join(' > ');
+    }
+    try {
+        const container = findFirst(containerSelectors);
+        if (!container)
+            return null;
+        const chatRoot = container;
+        const messages = [];
+        const flatEls = chatRoot.querySelectorAll('[data-flat-index]');
+        const messageDebug = {
+            at: Date.now(),
+            flatNodes: flatEls.length,
+            extracted: 0,
+            dropped: {
+                tool: 0,
+                userNoise: 0,
+                userEmpty: 0,
+                assistantWorking: 0,
+                assistantNotMeaningful: 0,
+                assistantNoMarkdown: 0,
+            },
+            droppedSamples: [],
+            messagePreviews: [],
+        };
+        function previewText(el, max = 90) {
+            const md = el.querySelector('.markdown-root');
+            const human = el.querySelector('.aislash-editor-input-readonly');
+            const raw = (human?.textContent || md?.textContent || el.textContent || '')
+                .trim()
+                .replace(/\s+/g, ' ');
+            return raw.slice(0, max);
+        }
+        function recordDrop(reason, el) {
+            const key = reason;
+            if (key in messageDebug.dropped)
+                messageDebug.dropped[key]++;
+            if (messageDebug.droppedSamples.length < 14) {
+                messageDebug.droppedSamples.push({
+                    reason,
+                    preview: previewText(el),
+                    flatIndex: el.getAttribute('data-flat-index') ?? undefined,
+                });
+            }
+        }
+        function todoStatusFromRow(row) {
+            const cls = row.className?.toString() ?? '';
+            if (cls.includes('completed') || cls.includes('done'))
+                return 'completed';
+            if (cls.includes('cancelled'))
+                return 'cancelled';
+            if (cls.includes('in-progress') ||
+                cls.includes('in_progress') ||
+                cls.includes('active') ||
+                !!row.querySelector('[class*="loading"], [class*="spinner"], [class*="progress"], [class*="arrow-circle"], [class*="in-progress-circle"]')) {
+                return 'in_progress';
+            }
+            if (row.querySelector('[class*="check"], [class*="completed"]'))
+                return 'completed';
+            return 'pending';
+        }
+        function todoStatusFromUiItem(row) {
+            if (row.classList.contains('ui-todo-item--completed'))
+                return 'completed';
+            if (row.classList.contains('ui-todo-item--cancelled'))
+                return 'cancelled';
+            if (row.querySelector('.ui-todo-item__content--in-progress'))
+                return 'in_progress';
+            return 'pending';
+        }
+        function todoStatusFromPlanItem(row) {
+            const ind = row.querySelector('.composer-plan-todo-indicator');
+            if (!ind)
+                return todoStatusFromRow(row);
+            const cls = ind.className?.toString() ?? '';
+            if (cls.includes('loading') || cls.includes('in-progress'))
+                return 'in_progress';
+            if (cls.includes('completed'))
+                return 'completed';
+            if (cls.includes('cancelled'))
+                return 'cancelled';
+            if (cls.includes('pending'))
+                return 'pending';
+            return 'pending';
+        }
+        function todoStatusFromToolbarItem(row) {
+            if (row.querySelector('.composer-toolbar-todo-in-progress-circle, .composer-plan-todo-in-progress-circle')) {
+                return 'in_progress';
+            }
+            return todoStatusFromRow(row);
+        }
+        function isInsideChatHistory(el) {
+            return !!el.closest('[data-flat-index]');
+        }
+        function hasShortTodosHeader(panel) {
+            for (const h of panel.querySelectorAll('[class*="collapsible"] [class*="header"], [class*="tool-call"] [class*="header"], span, div, button, .ui-todo-list-header')) {
+                if (h.children.length > 3)
+                    continue;
+                const t = (h.textContent ?? '').trim();
+                if (/^To-?dos(\s+\d+)?$/i.test(t) && t.length < 24)
+                    return true;
+                if (/^To-?dos\s/i.test(t) && t.length < 32)
+                    return true;
+            }
+            return false;
+        }
+        function extractTodoHeaderMeta(panel) {
+            let total;
+            const countEl = panel.querySelector('.ui-todo-list-header__count, .composer-create-plan-todos-count, .todo-list-header-left-count');
+            if (countEl) {
+                const n = parseInt(countEl.textContent?.trim() || '', 10);
+                if (!isNaN(n))
+                    total = n;
+            }
+            if (total === undefined) {
+                const header = panel.querySelector('.ui-todo-list-header, .composer-create-plan-todos-header, .todo-list-header-left-title');
+                const m = (header?.textContent || panel.textContent || '').match(/\bTo-?dos\s*(\d+)/i);
+                if (m)
+                    total = parseInt(m[1], 10);
+            }
+            let viewAllPath;
+            for (const btn of panel.querySelectorAll('button, a, [role="button"]')) {
+                if (/view\s+all/i.test(btn.textContent || '')) {
+                    viewAllPath = buildSelectorPath(btn);
+                    break;
+                }
+            }
+            return { total, viewAllPath };
+        }
+        function extractTodosFromPanel(panel, prefix) {
+            const todos = [];
+            const seen = new Set();
+            const meta = extractTodoHeaderMeta(panel);
+            function pushTodo(text, status, idx) {
+                const t = text.trim().replace(/\s+/g, ' ');
+                if (!t || t.length < 4 || t.length > 280)
+                    return;
+                if (/^to-?dos$/i.test(t) || /^to-?dos\s+\d+$/i.test(t))
+                    return;
+                if (/^view\s+all$/i.test(t))
+                    return;
+                if (/^\d+\s+more$/i.test(t))
+                    return;
+                if (seen.has(t))
+                    return;
+                seen.add(t);
+                todos.push({ id: `todo-${prefix}-${idx}`, text: t, status });
+            }
+            const uiItems = panel.querySelectorAll('.ui-todo-item');
+            if (uiItems.length) {
+                uiItems.forEach((row, i) => {
+                    const label = row.querySelector('.ui-todo-item__label')?.textContent?.trim() ||
+                        row.textContent?.trim() ||
+                        '';
+                    pushTodo(label, todoStatusFromUiItem(row), i);
+                });
+                return { todos, ...meta };
+            }
+            const planItems = panel.querySelectorAll('.composer-create-plan-todo-item');
+            if (planItems.length) {
+                planItems.forEach((row, i) => {
+                    if (row.querySelector('.composer-plan-todo-more-text'))
+                        return;
+                    const label = row.querySelector('.composer-create-plan-todo-content')?.textContent?.trim() ||
+                        row.textContent?.trim().replace(/\s*more\s*$/i, '') ||
+                        '';
+                    pushTodo(label, todoStatusFromPlanItem(row), i);
+                });
+                return { todos, ...meta };
+            }
+            const toolbarItems = panel.querySelectorAll('.composer-toolbar-todo-item');
+            if (toolbarItems.length) {
+                toolbarItems.forEach((row, i) => {
+                    const label = row.querySelector('.composer-toolbar-todo-item-text')?.textContent?.trim() ||
+                        row.textContent?.trim() ||
+                        '';
+                    pushTodo(label, todoStatusFromToolbarItem(row), i);
+                });
+                return { todos, ...meta };
+            }
+            const rowSelectors = [
+                '[class*="todo-item"]',
+                '[class*="TodoItem"]',
+                '[class*="task-item"]',
+                '[data-todo-id]',
+                '.ui-todo-list-item',
+            ];
+            for (const sel of rowSelectors) {
+                panel.querySelectorAll(sel).forEach((row, i) => {
+                    if (isInsideChatHistory(row) &&
+                        row.closest('[data-message-kind]')?.getAttribute('data-message-kind') !== 'tool') {
+                        return;
+                    }
+                    const label = row.querySelector('[class*="label"], [class*="title"], [class*="content"]')
+                        ?.textContent?.trim() ||
+                        row.textContent?.trim() ||
+                        '';
+                    pushTodo(label, todoStatusFromRow(row), i);
+                });
+                if (todos.length > 0)
+                    return { todos, ...meta };
+            }
+            panel.querySelectorAll('li, [class*="item"], [class*="row"]').forEach((row, i) => {
+                const text = row.textContent?.trim() ?? '';
+                if (!text || /^to-?dos/i.test(text))
+                    return;
+                if (text.length > 280)
+                    return;
+                pushTodo(text, todoStatusFromRow(row), i);
+            });
+            return { todos, ...meta };
+        }
+        function extractTodosCursor() {
+            const roots = new Set();
+            const rootSelectors = [
+                '.ui-todo-list-container',
+                '.composer-create-plan-todos',
+                '.composer-toolbar-todos-item-list',
+                '.composer-plan-todos',
+                '.todo-list-container',
+            ];
+            for (const sel of rootSelectors) {
+                document.querySelectorAll(sel).forEach((el) => roots.add(el));
+                chatRoot.querySelectorAll(sel).forEach((el) => roots.add(el));
+            }
+            let best = { todos: [] };
+            for (const root of roots) {
+                const hit = extractTodosFromPanel(root, 'cursor');
+                if (hit.todos.length > best.todos.length) {
+                    best = {
+                        todos: hit.todos,
+                        total: hit.total,
+                        viewAllPath: hit.viewAllPath,
+                    };
+                }
+            }
+            return best;
+        }
+        let todos = [];
+        let todosTotalCount;
+        let todosViewAllSelectorPath;
+        const cursorTodos = extractTodosCursor();
+        if (cursorTodos.todos.length > 0) {
+            todos = cursorTodos.todos;
+            todosTotalCount = cursorTodos.total;
+            todosViewAllSelectorPath = cursorTodos.viewAllPath;
+        }
+        else {
+            const toolBlocks = Array.from(chatRoot.querySelectorAll('[data-flat-index][data-message-kind="tool"]'));
+            for (let i = toolBlocks.length - 1; i >= 0; i--) {
+                const block = toolBlocks[i];
+                if (!hasShortTodosHeader(block))
+                    continue;
+                const hit = extractTodosFromPanel(block, `tool-${i}`);
+                todos = hit.todos;
+                todosTotalCount = hit.total;
+                todosViewAllSelectorPath = hit.viewAllPath;
+                if (todos.length > 0)
+                    break;
+            }
+            if (todos.length === 0) {
+                for (const panel of chatRoot.querySelectorAll('[class*="collapsible"], [class*="tool-call"]')) {
+                    if (!hasShortTodosHeader(panel))
+                        continue;
+                    if (isInsideChatHistory(panel)) {
+                        const kind = panel.closest('[data-flat-index]')?.getAttribute('data-message-kind');
+                        if (kind && kind !== 'tool')
+                            continue;
+                    }
+                    const hit = extractTodosFromPanel(panel, 'panel');
+                    todos = hit.todos;
+                    todosTotalCount = hit.total;
+                    todosViewAllSelectorPath = hit.viewAllPath;
+                    if (todos.length > 0)
+                        break;
+                }
+            }
+        }
+        function getComposerScope() {
+            const input = findFirst(inputSelectors);
+            if (!input)
+                return null;
+            const candidates = [
+                input.closest('[class*="agent-panel"]'),
+                input.closest('[class*="composer-panel"]'),
+                input.closest('.composer-bar, [class*="composer-bar"]'),
+                findFirst(containerSelectors),
+            ];
+            for (const el of candidates) {
+                if (el?.querySelector('[class*="ui-tray--queued"], [class*="queue-item"], [class*="queue-sortable-row"]')) {
+                    return el;
+                }
+            }
+            return (input.closest('.composer-bar, [class*="composer-bar"], [class*="composer-panel"]') ||
+                input.parentElement?.parentElement?.parentElement ||
+                null);
+        }
+        function extractQueuedMessages(scope) {
+            const items = [];
+            const seen = new Set();
+            function isA11yDragHint(text) {
+                return (/to pick up a draggable item/i.test(text) ||
+                    /press space again to drop/i.test(text) ||
+                    /while dragging, use the arrow keys/i.test(text));
+            }
+            function removePathFor(el) {
+                const btn = el.querySelector('button[aria-label="Remove"]');
+                if (!btn)
+                    return undefined;
+                const path = buildSelectorPath(btn);
+                return path || undefined;
+            }
+            function extractQueuedRowText(row) {
+                const textRoot = row.querySelector('[class*="ui-tray-row"]') ||
+                    row.querySelector('[class*="queue-sortable-row"]') ||
+                    row;
+                const clone = textRoot.cloneNode(true);
+                clone
+                    .querySelectorAll('img, button, [class*="icon"], [aria-hidden="true"], [class*="image-pill"]')
+                    .forEach((el) => el.remove());
+                return (clone.textContent || '').trim().replace(/\s+/g, ' ');
+            }
+            function extractQueuedRowImages(row) {
+                const seenImg = new Set();
+                const out = [];
+                for (const img of row.querySelectorAll('img.image-pill-img, .image-pill-container img, img[alt="Attached image"], img[src]')) {
+                    const src = img.getAttribute('src');
+                    if (!src)
+                        continue;
+                    const path = normalizeImageSrc(src);
+                    if (!path || seenImg.has(path))
+                        continue;
+                    seenImg.add(path);
+                    out.push(path);
+                }
+                return out;
+            }
+            function pushQueuedRow(row, idx) {
+                const images = extractQueuedRowImages(row);
+                const t = extractQueuedRowText(row);
+                if ((!t || t.length < 2) && images.length === 0)
+                    return;
+                if (t.length > 600)
+                    return;
+                if (t && isA11yDragHint(t))
+                    return;
+                if (/^\d+\s+queued$/i.test(t))
+                    return;
+                if (/^(queued|to\s+send|start\s+multitasking)$/i.test(t))
+                    return;
+                if (t && /\bqueued\b/i.test(t) && /to\s+send/i.test(t) && t.length < 48)
+                    return;
+                if (/^start\s+multitasking/i.test(t))
+                    return;
+                const dedupeKey = `${t}|${images.join(',')}`;
+                if (seen.has(dedupeKey))
+                    return;
+                seen.add(dedupeKey);
+                const removeSelectorPath = removePathFor(row);
+                items.push({
+                    id: `q-${idx}-${items.length}`,
+                    text: t,
+                    hasImage: images.length > 0,
+                    images: images.length ? images : undefined,
+                    removeSelectorPath,
+                });
+            }
+            function pushQueuedLine(text, idx) {
+                const t = text.trim().replace(/\s+/g, ' ');
+                if (!t || t.length < 2 || t.length > 600)
+                    return;
+                if (isA11yDragHint(t))
+                    return;
+                if (/^\d+\s+queued$/i.test(t))
+                    return;
+                if (/^(queued|to\s+send|start\s+multitasking)$/i.test(t))
+                    return;
+                if (/\bqueued\b/i.test(t) && /to\s+send/i.test(t) && t.length < 48)
+                    return;
+                if (/^start\s+multitasking/i.test(t))
+                    return;
+                if (seen.has(t))
+                    return;
+                seen.add(t);
+                items.push({ id: `q-line-${idx}-${items.length}`, text: t });
+            }
+            const itemSelectors = [
+                '[class*="ui-tray--queued"] [class*="queue-sortable-row"]',
+                '[class*="ui-tray--queued"] [class*="ui-tray-row"]',
+                '[class*="queue-sortable-row"]',
+                '[class*="ui-tray-row"]',
+                '[class*="queued-message"]',
+                '[class*="QueueItem"]',
+                '[class*="composer-queue"]',
+                '[data-queued-message]',
+                '[class*="pending-message"]',
+            ];
+            for (const sel of itemSelectors) {
+                scope.querySelectorAll(sel).forEach((row, i) => {
+                    if (isInsideChatHistory(row))
+                        return;
+                    pushQueuedRow(row, i);
+                });
+                if (items.length > 0)
+                    return items;
+            }
+            scope.querySelectorAll('[class*="queue-item"]').forEach((item, i) => {
+                if (isInsideChatHistory(item))
+                    return;
+                const row = item.querySelector('[class*="queue-sortable-row"], [class*="ui-tray-row"]');
+                pushQueuedRow(row ?? item, i);
+            });
+            if (items.length > 0)
+                return items;
+            for (const panel of scope.querySelectorAll('div, section')) {
+                if (isInsideChatHistory(panel))
+                    continue;
+                const raw = panel.textContent?.trim() ?? '';
+                if (raw.length > 400)
+                    continue;
+                const firstLine = raw.split('\n').map((l) => l.trim()).find(Boolean) ?? '';
+                if (!/^\d+\s+Queued\b/i.test(firstLine))
+                    continue;
+                let foundRow = false;
+                panel
+                    .querySelectorAll('[class*="item"], [class*="row"], [class*="preview"], li')
+                    .forEach((row, i) => {
+                    if (isInsideChatHistory(row))
+                        return;
+                    const text = row.textContent?.trim() ?? '';
+                    if (text.length < 4 || text === raw)
+                        return;
+                    if (/queued|multitasking/i.test(text) && text.length < 50)
+                        return;
+                    pushQueuedRow(row, i);
+                    foundRow = true;
+                });
+                if (!foundRow) {
+                    let afterHeader = false;
+                    for (const line of raw.split('\n')) {
+                        const l = line.trim();
+                        if (!l)
+                            continue;
+                        if (/^\d+\s+Queued\b/i.test(l)) {
+                            afterHeader = true;
+                            continue;
+                        }
+                        if (/start\s+multitasking/i.test(l))
+                            continue;
+                        if (afterHeader)
+                            pushQueuedLine(l, items.length);
+                    }
+                }
+                if (items.length > 0)
+                    return items;
+            }
+            return items;
+        }
+        let queuedMessages = [];
+        const composerScope = getComposerScope();
+        if (composerScope) {
+            queuedMessages = extractQueuedMessages(composerScope);
+        }
+        function isNoiseChatText(text) {
+            const t = text.trim().replace(/\s+/g, ' ');
+            if (!t || t.length < 2)
+                return true;
+            if (/^(Editing|Edited|Ran|Thought\s+(briefly|for\s)|Explored|Listed|Grepped|Searched|Read|Loading|Planning|Generating|Running|Finished|Cancelled|Using image)\b/i.test(t))
+                return true;
+            if (/^Edited\s+.+\s*\+\d+/i.test(t))
+                return true;
+            if (/\.[a-z0-9]+\s*[+-]\d+/i.test(t) && t.length < 120)
+                return true;
+            if (/^(cd |npm |npx |curl |git |node )/i.test(t) && t.length < 160)
+                return true;
+            if (/^Thought\s*for\s*\d/i.test(t) && t.length < 40)
+                return true;
+            if (/^Thought\s+\w+$/i.test(t) && t.length < 40)
+                return true;
+            if (/^Explored\d/i.test(t))
+                return true;
+            if (matchBackgroundStatusLine(t))
+                return true;
+            return false;
+        }
+        function matchBackgroundStatusLine(text) {
+            const t = text.trim().replace(/\s+/g, ' ');
+            if (!t || t.length > 100)
+                return undefined;
+            if (/will resume when|background work finishes|background shell|resuming when|paused while|waiting for background/i.test(t)) {
+                return t;
+            }
+            if (/^working\.?$/i.test(t))
+                return t;
+            return undefined;
+        }
+        function textImpliesAgentWorking(text) {
+            return matchBackgroundStatusLine(text) !== undefined;
+        }
+        function isBackgroundStatusRow(row) {
+            const md = row?.querySelector('.markdown-root');
+            const rowText = (md?.textContent || row?.textContent || '').trim();
+            const hit = matchBackgroundStatusLine(rowText);
+            if (!hit)
+                return undefined;
+            if (isMeaningfulAssistantText(rowText))
+                return undefined;
+            return hit;
+        }
+        function isMeaningfulAssistantText(text) {
+            const t = text.trim();
+            if (!t || isNoiseChatText(t))
+                return false;
+            if (t.length >= 20 && /\s/.test(t))
+                return true;
+            if (t.length >= 6 && /[.!?…]$/.test(t))
+                return true;
+            return t.length >= 50;
+        }
+        function cleanUserText(text) {
+            return text
+                .replace(/<user_query>\s*/gi, '')
+                .replace(/<\/user_query>/gi, '')
+                .replace(/([.!?…])(\d+\.\s*)/g, '$1\n$2')
+                .replace(/([^\n\d\s])(\d+\.\s+)/g, '$1\n$2')
+                .trim();
+        }
+        function normalizeImageSrc(src) {
+            const raw = src.trim();
+            if (!raw)
+                return null;
+            if (/^https?:\/\//i.test(raw))
+                return raw;
+            if (raw.startsWith('vscode-file://vscode-app')) {
+                const rest = raw.slice('vscode-file://vscode-app'.length);
+                const q = rest.indexOf('?');
+                try {
+                    return decodeURIComponent(q >= 0 ? rest.slice(0, q) : rest);
+                }
+                catch {
+                    return null;
+                }
+            }
+            if (raw.startsWith('file://')) {
+                try {
+                    return decodeURIComponent(raw.replace(/^file:\/\//, ''));
+                }
+                catch {
+                    return null;
+                }
+            }
+            return null;
+        }
+        function extractRowImages(row) {
+            const seen = new Set();
+            const out = [];
+            for (const img of row.querySelectorAll('img.image-pill-img, .image-pill-container img, img[alt="Attached image"]')) {
+                const src = img.getAttribute('src');
+                if (!src)
+                    continue;
+                const path = normalizeImageSrc(src);
+                if (!path || seen.has(path))
+                    continue;
+                seen.add(path);
+                out.push(path);
+            }
+            return out;
+        }
+        function isToolNoiseElement(el, msgKind) {
+            if (msgKind === 'tool')
+                return true;
+            if (el.querySelector('.loading-indicator-v3'))
+                return true;
+            if (el.querySelector('.composer-tool-former-message'))
+                return true;
+            if (el.querySelector('.composer-terminal-tool-call-block-container'))
+                return true;
+            if (el.querySelector('.composer-edit-file-review-wrapper'))
+                return true;
+            if (el.querySelector('.ui-edit-tool-call__filename'))
+                return true;
+            if (el.querySelector('[data-tool-status]'))
+                return true;
+            if (el.querySelector('.ui-tool-call-line-action'))
+                return true;
+            return false;
+        }
+        let flatOrder = 0;
+        flatEls.forEach((el) => {
+            const idxRaw = el.getAttribute('data-flat-index') ?? '';
+            const idxParsed = Number.parseInt(idxRaw, 10);
+            const flatIndex = Number.isFinite(idxParsed) ? idxParsed : flatOrder++;
+            const role = el.getAttribute('data-message-role') ?? '';
+            const kind = el.getAttribute('data-message-kind') ?? '';
+            const id = `${idxRaw || flatIndex}-${role || 'x'}-${kind || 'x'}`;
+            if (isToolNoiseElement(el, kind)) {
+                recordDrop('tool', el);
+                return;
+            }
+            const humanEl = el.querySelector('.aislash-editor-input-readonly, .composer-human-tiptap-readonly-editor, .composer-human-message-content, .composer-human-message');
+            const mdRoot = el.querySelector('.markdown-root');
+            const isHuman = role === 'human' || !!humanEl;
+            if (isHuman) {
+                const images = extractRowImages(el);
+                const text = cleanUserText(humanEl?.textContent?.trim() ?? el.textContent?.trim() ?? '');
+                const hasText = Boolean(text) && !isNoiseChatText(text);
+                if (!hasText && images.length === 0) {
+                    recordDrop(text && isNoiseChatText(text) ? 'userNoise' : 'userEmpty', el);
+                    return;
+                }
+                if (text && isNoiseChatText(text) && images.length > 0) {
+                    recordDrop('userNoise', el);
+                }
+                const displayText = hasText
+                    ? text
+                    : images.length > 0
+                        ? 'Изображение'
+                        : '';
+                messages.push({
+                    id,
+                    role: 'user',
+                    text: displayText,
+                    images: images.length ? images : undefined,
+                    flatIndex,
+                });
+                messageDebug.extracted++;
+                return;
+            }
+            const text = mdRoot?.textContent?.trim() ?? '';
+            if (text && textImpliesAgentWorking(text)) {
+                recordDrop('assistantWorking', el);
+                return;
+            }
+            if (!mdRoot || !text) {
+                recordDrop('assistantNoMarkdown', el);
+                return;
+            }
+            if (!isMeaningfulAssistantText(text)) {
+                recordDrop('assistantNotMeaningful', el);
+                return;
+            }
+            messages.push({
+                id,
+                role: 'assistant',
+                text,
+                html: mdRoot.innerHTML || undefined,
+                flatIndex,
+            });
+            messageDebug.extracted++;
+        });
+        messages.sort((a, b) => (a.flatIndex ?? 0) - (b.flatIndex ?? 0));
+        let containerComposerId = container.getAttribute('data-composer-id') ||
+            container.closest('[data-composer-id]')?.getAttribute('data-composer-id') ||
+            '';
+        if (!containerComposerId && flatEls.length > 0) {
+            containerComposerId =
+                flatEls[0].closest('[data-composer-id]')?.getAttribute('data-composer-id') || '';
+        }
+        function cleanSidebarTitle(btn) {
+            const label = btn.querySelector('.ui-sidebar-menu-button-label');
+            let t = (label?.textContent || btn.textContent || '').trim().replace(/\s+/g, ' ');
+            t = t.replace(/\d+\s*(?:s|m|h|d|w)\b/gi, '').replace(/\d+[smhdw]$/i, '').trim();
+            return t.slice(0, 120);
+        }
+        function readAgentBtnMeta(btn) {
+            const title = cleanSidebarTitle(btn);
+            if (!title || /^more$/i.test(title) || /^less$/i.test(title))
+                return null;
+            const composerId = btn.getAttribute('data-composer-id') ||
+                btn.closest('li')?.getAttribute('data-composer-id') ||
+                btn.closest('[data-composer-id]')?.getAttribute('data-composer-id') ||
+                '';
+            const active = btn.getAttribute('data-active') === 'true';
+            const isWorking = !!btn.querySelector('.loading-indicator-v3, [class*="loading-indicator"]');
+            const cls = btn.className?.toString() ?? '';
+            const hasUnread = cls.includes('unread') || !!btn.querySelector('[class*="unread"]');
+            const needsAttention = !!btn.querySelector('.agent-status-dot--needs-attention');
+            return { title, composerId, active, isWorking, hasUnread, needsAttention };
+        }
+        const tabs = [];
+        const glassTabs = document.querySelectorAll('.glass-sidebar-agent-list-container li.ui-sidebar-menu-item > div.glass-sidebar-agent-menu-btn');
+        if (glassTabs.length > 0) {
+            glassTabs.forEach((cell, i) => {
+                const meta = readAgentBtnMeta(cell);
+                if (!meta)
+                    return;
+                tabs.push({
+                    id: meta.composerId || `tab-${i}`,
+                    composerId: meta.composerId || undefined,
+                    title: meta.title,
+                    active: meta.active,
+                    isWorking: meta.isWorking,
+                    hasUnread: meta.hasUnread,
+                    needsAttention: meta.needsAttention,
+                });
+            });
+        }
+        else {
+            for (const sel of tabSelectors) {
+                document.querySelectorAll(sel).forEach((cell, i) => {
+                    const title = cell.getAttribute('aria-label') ??
+                        cell.getAttribute('title') ??
+                        cell.textContent?.trim() ??
+                        `Chat ${i + 1}`;
+                    const composerId = cell.getAttribute('data-composer-id') ||
+                        cell.closest('[data-composer-id]')?.getAttribute('data-composer-id') ||
+                        '';
+                    const active = cell.classList.contains('active') ||
+                        cell.getAttribute('aria-selected') === 'true' ||
+                        cell.getAttribute('data-selected') === 'true' ||
+                        cell.matches('.selected');
+                    tabs.push({
+                        id: composerId || `tab-${i}`,
+                        composerId: composerId || undefined,
+                        title: title.replace(/\s+/g, ' ').slice(0, 120),
+                        active,
+                    });
+                });
+                if (tabs.length)
+                    break;
+            }
+        }
+        const pendingApprovals = [];
+        function isMenuTrigger(btn) {
+            const p = btn.getAttribute('aria-haspopup');
+            return p === 'menu' || p === 'true' || p === 'listbox';
+        }
+        function cleanLabel(raw) {
+            return raw.replace(/\s*(Shift\+)?⏎\s*/g, '').replace(/\s+/g, ' ').trim();
+        }
+        function extractPendingQuestionnaire() {
+            const toolbar = document.querySelector('.composer-questionnaire-toolbar');
+            if (!toolbar)
+                return undefined;
+            const title = toolbar.querySelector('.composer-questionnaire-toolbar-title')?.textContent?.trim() ||
+                'Questions';
+            const questions = [];
+            let qEls = toolbar.querySelectorAll('.composer-questionnaire-toolbar-question-active');
+            if (!qEls.length) {
+                qEls = toolbar.querySelectorAll('.composer-questionnaire-toolbar-question');
+            }
+            qEls.forEach((qEl, qi) => {
+                const prompt = qEl.querySelector('.composer-questionnaire-toolbar-question-label')?.textContent?.trim() ||
+                    '';
+                const options = [];
+                qEl.querySelectorAll('.composer-questionnaire-toolbar-option').forEach((optEl, oi) => {
+                    const letter = optEl.querySelector('.composer-questionnaire-toolbar-option-letter')?.textContent?.trim() ||
+                        '';
+                    const label = optEl.querySelector('.composer-questionnaire-toolbar-option-label')?.textContent?.trim() ||
+                        '';
+                    const selected = optEl.classList.contains('composer-questionnaire-toolbar-option-focused') ||
+                        !!optEl.querySelector('.composer-questionnaire-toolbar-option-label-selected');
+                    options.push({
+                        id: `q${qi}-o${oi}`,
+                        letter,
+                        label,
+                        selected,
+                        selectorPath: buildSelectorPath(optEl),
+                    });
+                });
+                if (prompt || options.length) {
+                    questions.push({ id: `q${qi}`, prompt, options });
+                }
+            });
+            const actions = [];
+            const actionRoot = toolbar.querySelector('.composer-questionnaire-toolbar-actions') || toolbar;
+            actionRoot.querySelectorAll('button').forEach((btn) => {
+                const label = cleanLabel(btn.textContent || '');
+                if (!label)
+                    return;
+                let type = 'other';
+                if (/^skip$/i.test(label))
+                    type = 'skip';
+                else if (/^continue$/i.test(label))
+                    type = 'continue';
+                actions.push({ label, type, selectorPath: buildSelectorPath(btn) });
+            });
+            if (!questions.length && !actions.length)
+                return undefined;
+            return {
+                id: `questionnaire:${buildSelectorPath(toolbar)}`,
+                title,
+                questions,
+                actions,
+            };
+        }
+        for (const row of Array.from(container.querySelectorAll('.ui-shell-tool-call__approval-row'))) {
+            const card = row.closest('.ui-tool-call-card') || row.closest('.ui-shell-tool-call');
+            if (!card)
+                continue;
+            const actions = [];
+            const runBtn = row.querySelector('button.ui-shell-tool-call__run-btn');
+            if (runBtn && !isMenuTrigger(runBtn)) {
+                actions.push({
+                    label: cleanLabel(runBtn.textContent || '') || 'Run',
+                    type: 'approve',
+                    selectorPath: buildSelectorPath(runBtn),
+                });
+            }
+            const skipBtn = row.querySelector('button.ui-shell-tool-call__skip-btn');
+            if (skipBtn && !isMenuTrigger(skipBtn)) {
+                actions.push({
+                    label: cleanLabel(skipBtn.textContent || '') || 'Skip',
+                    type: 'reject',
+                    selectorPath: buildSelectorPath(skipBtn),
+                });
+            }
+            if (!actions.some((a) => a.type === 'approve'))
+                continue;
+            const cmd = card.querySelector('.ui-shell-tool-call__command')?.textContent?.trim();
+            pendingApprovals.push({
+                id: `tool:${buildSelectorPath(card)}`,
+                description: (cmd || 'Pending approval').slice(0, 240),
+                actions,
+            });
+        }
+        if (pendingApprovals.length === 0) {
+            const approveBtns = [];
+            const rejectBtns = [];
+            const seenA = new Set();
+            const seenR = new Set();
+            for (const sel of approveSelectors) {
+                try {
+                    for (const btn of Array.from(container.querySelectorAll(sel))) {
+                        if (seenA.has(btn) || isMenuTrigger(btn))
+                            continue;
+                        const label = btn.textContent?.trim() || btn.getAttribute('aria-label') || '';
+                        if (label) {
+                            seenA.add(btn);
+                            approveBtns.push({ label, selector: buildSelectorPath(btn) });
+                        }
+                    }
+                }
+                catch {
+                    /* skip */
+                }
+            }
+            if (approveBtns.length === 0) {
+                for (const btn of Array.from(container.querySelectorAll('button'))) {
+                    if (seenA.has(btn) || isMenuTrigger(btn))
+                        continue;
+                    const text = `${btn.textContent || ''} ${btn.getAttribute('aria-label') || ''}`.toLowerCase();
+                    for (const pat of approveTextMatch) {
+                        if (text.includes(pat.toLowerCase())) {
+                            seenA.add(btn);
+                            approveBtns.push({
+                                label: btn.textContent?.trim() || pat,
+                                selector: buildSelectorPath(btn),
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+            for (const sel of rejectSelectors) {
+                try {
+                    for (const btn of Array.from(container.querySelectorAll(sel))) {
+                        if (seenR.has(btn) || isMenuTrigger(btn))
+                            continue;
+                        const label = btn.textContent?.trim() || btn.getAttribute('aria-label') || '';
+                        if (label) {
+                            seenR.add(btn);
+                            rejectBtns.push({ label, selector: buildSelectorPath(btn) });
+                        }
+                    }
+                }
+                catch {
+                    /* skip */
+                }
+            }
+            if (approveBtns.length > 0 || rejectBtns.length > 0) {
+                const actions = [];
+                for (const b of approveBtns) {
+                    actions.push({
+                        label: b.label,
+                        type: b.label.toLowerCase().includes('all') ? 'approve_all' : 'approve',
+                        selectorPath: b.selector,
+                    });
+                }
+                for (const b of rejectBtns) {
+                    actions.push({ label: b.label, type: 'reject', selectorPath: b.selector });
+                }
+                pendingApprovals.push({
+                    id: approveBtns.map((b) => b.label).join(','),
+                    description: approveBtns[0]?.label || 'Pending approval',
+                    actions,
+                });
+            }
+        }
+        let activeTab = tabs.find((t) => t.active);
+        if (!activeTab) {
+            const headerTitle = document.querySelector('span.auxiliary-bar-chat-title')?.textContent?.trim() ?? '';
+            if (headerTitle) {
+                const norm = headerTitle
+                    .replace(/\s+/g, ' ')
+                    .replace(/\d+\s*(?:s|m|h|d|w)\b/gi, '')
+                    .replace(/\d+[smhdw]$/i, '')
+                    .trim()
+                    .toLowerCase();
+                activeTab = tabs.find((t) => {
+                    const tNorm = (t.title || '')
+                        .replace(/\s+/g, ' ')
+                        .replace(/\d+\s*(?:s|m|h|d|w)\b/gi, '')
+                        .replace(/\d+[smhdw]$/i, '')
+                        .trim()
+                        .toLowerCase();
+                    return tNorm === norm || tNorm.includes(norm) || norm.includes(tNorm);
+                });
+            }
+        }
+        const modeEl = document.querySelector('.composer-unified-dropdown[data-mode]');
+        const mode = modeEl?.getAttribute('data-mode') ?? undefined;
+        const model = document.querySelector('.composer-unified-dropdown-model')?.textContent?.trim() ??
+            undefined;
+        function composerScopes(r) {
+            return [
+                document.querySelector('[class*="agent-panel"]'),
+                document.querySelector('[class*="composer-panel"]'),
+                r.closest('.composer-bar'),
+                document.querySelector('.composer-bar'),
+                document.querySelector('[class*="composer-bar"]'),
+                r,
+            ].filter((el) => Boolean(el));
+        }
+        /** Active generation — Stop in composer (not stale loading dots in the thread). */
+        function detectAgentWorking(root) {
+            const stopSel = 'button[data-state="stop"], button[aria-label="Stop generation"], button[aria-label*="Stop"], a.codicon-debug-stop, [class*="stop-button"]';
+            const sendSel = 'button[data-state="submit"], button.ui-prompt-input-submit-button[data-state="submit"], button[aria-label*="Send"]';
+            for (const scope of composerScopes(root)) {
+                const stopBtn = scope.querySelector(stopSel);
+                if (stopBtn) {
+                    const disabled = stopBtn.hasAttribute('disabled') ||
+                        stopBtn.getAttribute('aria-disabled') === 'true';
+                    if (!disabled)
+                        return true;
+                }
+            }
+            for (const scope of composerScopes(root)) {
+                const sendBtn = scope.querySelector(sendSel);
+                if (sendBtn && sendBtn.getAttribute('data-state') !== 'stop') {
+                    const disabled = sendBtn.hasAttribute('disabled') ||
+                        sendBtn.getAttribute('aria-disabled') === 'true';
+                    if (!disabled)
+                        return false;
+                }
+            }
+            const title = document.querySelector('span.auxiliary-bar-chat-title')?.textContent?.trim() || '';
+            if (/generat|working|thinking|running|в работе/i.test(title) && !/waiting|approval/i.test(title)) {
+                return true;
+            }
+            return false;
+        }
+        function findBackgroundWorkStatusText(root) {
+            const flats = root.querySelectorAll('[data-flat-index]');
+            for (let i = flats.length - 1; i >= Math.max(0, flats.length - 3); i--) {
+                const hit = isBackgroundStatusRow(flats[i]);
+                if (hit)
+                    return hit;
+            }
+            const composer = root.closest('.composer-bar') ||
+                document.querySelector('[class*="composer-bar"]');
+            if (!composer)
+                return undefined;
+            for (const el of composer.querySelectorAll('span, p, div')) {
+                if (el.closest('[data-flat-index]'))
+                    continue;
+                if (el.closest('.composer-human-message, .markdown-root, .aislash-editor-input-readonly')) {
+                    continue;
+                }
+                if (el.querySelector('span, p, div'))
+                    continue;
+                const t = (el.textContent || '').trim().replace(/\s+/g, ' ');
+                const hit = matchBackgroundStatusLine(t);
+                if (hit)
+                    return hit;
+            }
+            return undefined;
+        }
+        const pendingQuestionnaire = extractPendingQuestionnaire();
+        const backgroundStatusText = pendingApprovals.length === 0 && !pendingQuestionnaire
+            ? findBackgroundWorkStatusText(container)
+            : undefined;
+        const agentWorking = pendingApprovals.length === 0 &&
+            !pendingQuestionnaire &&
+            (detectAgentWorking(container) || !!backgroundStatusText);
+        let agentStatus = document.querySelector('span.auxiliary-bar-chat-title')?.textContent?.trim() ||
+            undefined;
+        let agentStatusMessage;
+        if (pendingQuestionnaire)
+            agentStatus = 'waiting_questionnaire';
+        else if (pendingApprovals.length > 0)
+            agentStatus = 'waiting_approval';
+        else if (agentWorking && backgroundStatusText) {
+            agentStatus = 'background_shell';
+            agentStatusMessage = backgroundStatusText;
+        }
+        else if (agentWorking)
+            agentStatus = 'working';
+        let contextPercent;
+        let terminalCount;
+        for (const el of Array.from(document.querySelectorAll('button, span, div'))) {
+            const t = el.textContent?.trim() ?? '';
+            if (contextPercent === undefined) {
+                const m = t.match(/^(\d+)%\s*context$/i);
+                if (m)
+                    contextPercent = Number(m[1]);
+            }
+            if (terminalCount === undefined) {
+                const tm = t.match(/^(\d+)\s+Terminals?$/i);
+                if (tm)
+                    terminalCount = Number(tm[1]);
+            }
+        }
+        let workspace = '';
+        try {
+            const g = globalThis;
+            const path = g.vscode?.context?.configuration?.()?.workspace?.uri?.path;
+            if (path)
+                workspace = path.split('/').filter(Boolean).pop() || '';
+        }
+        catch {
+            /* ignore */
+        }
+        const sidebarRepos = [];
+        const sidebarScroll = document.querySelector('[class*="glass-sidebar-scroll"]') ||
+            document.querySelector('[class*="glass-sidebar-body"]') ||
+            document.querySelector('[class*="glass-sidebar"]');
+        if (sidebarScroll) {
+            let section = null;
+            for (const el of sidebarScroll.querySelectorAll('.ui-sidebar-section-head, li.ui-sidebar-menu-item > div.glass-sidebar-agent-menu-btn')) {
+                if (el.classList.contains('ui-sidebar-section-head')) {
+                    const name = (el.textContent || '').trim().replace(/\s+/g, ' ').slice(0, 120);
+                    if (!name)
+                        continue;
+                    section = {
+                        id: name,
+                        name,
+                        path: '',
+                        agents: [],
+                    };
+                    sidebarRepos.push(section);
+                    continue;
+                }
+                const meta = readAgentBtnMeta(el);
+                if (!meta || !section)
+                    continue;
+                section.agents.push({
+                    id: meta.composerId || `sidebar-${section.agents.length}`,
+                    title: meta.title,
+                    updatedAt: Date.now(),
+                    messageCount: 0,
+                    isWorking: meta.isWorking,
+                    hasUnread: meta.hasUnread,
+                    needsAttention: meta.needsAttention,
+                });
+            }
+        }
+        function extractComposerDraftText() {
+            const input = findFirst(inputSelectors);
+            if (!input)
+                return undefined;
+            const t = ((input instanceof HTMLElement ? input.innerText : '') ||
+                input.textContent ||
+                '')
+                .replace(/\u200b/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            return t || undefined;
+        }
+        function extractComposerDraftImages() {
+            const scopes = [
+                findFirst(containerSelectors)?.closest('[class*="agent-panel"]'),
+                document.querySelector('[class*="agent-panel"]'),
+                document.querySelector('[class*="composer-panel"]'),
+                findFirst(containerSelectors),
+            ].filter(Boolean);
+            const seen = new Set();
+            const out = [];
+            for (const scope of scopes) {
+                for (const img of scope.querySelectorAll('img.image-pill-img, .image-pill-container img, img[alt="Attached image"]')) {
+                    if (img.closest('[data-flat-index]'))
+                        continue;
+                    const src = img.getAttribute('src');
+                    if (!src)
+                        continue;
+                    const raw = src.trim();
+                    let path = null;
+                    if (/^https?:\/\//i.test(raw))
+                        path = raw;
+                    else if (raw.startsWith('vscode-file://vscode-app')) {
+                        const rest = raw.slice('vscode-file://vscode-app'.length);
+                        const q = rest.indexOf('?');
+                        try {
+                            path = decodeURIComponent(q >= 0 ? rest.slice(0, q) : rest);
+                        }
+                        catch {
+                            path = null;
+                        }
+                    }
+                    else if (raw.startsWith('file://')) {
+                        try {
+                            path = decodeURIComponent(raw.replace(/^file:\/\//, ''));
+                        }
+                        catch {
+                            path = null;
+                        }
+                    }
+                    if (!path || seen.has(path))
+                        continue;
+                    seen.add(path);
+                    out.push(path);
+                }
+            }
+            return out.length ? out : undefined;
+        }
+        const composerDraft = extractComposerDraftText();
+        const composerDraftImages = extractComposerDraftImages();
+        const activeChatTitle = document.querySelector('span.auxiliary-bar-chat-title')?.textContent?.trim() ||
+            undefined;
+        const resolvedComposerId = (() => {
+            if (containerComposerId && /^[0-9a-f-]{36}$/i.test(containerComposerId)) {
+                return containerComposerId;
+            }
+            return activeTab?.composerId || activeTab?.id || containerComposerId || undefined;
+        })();
+        messageDebug.extracted = messages.length;
+        messageDebug.containerComposerId = containerComposerId || activeTab?.composerId;
+        messageDebug.messagePreviews = messages.slice(-24).map((m) => ({
+            id: m.id,
+            role: m.role,
+            len: m.text.length,
+            flatIndex: m.flatIndex,
+        }));
+        return {
+            workspace,
+            tabs,
+            sidebarRepos,
+            activeTabId: activeTab?.id ?? tabs[0]?.id,
+            activeComposerId: resolvedComposerId,
+            activeChatTitle,
+            messageDebug,
+            messages,
+            todos,
+            todosTotalCount,
+            todosViewAllSelectorPath,
+            queuedMessages,
+            pendingApprovals,
+            pendingQuestionnaire,
+            agentWorking,
+            agentStatus,
+            agentStatusMessage,
+            contextPercent,
+            terminalCount,
+            mode,
+            model,
+            composerDraft,
+            composerDraftImages,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function extractPageState(client, selectors) {
+    return (await client.callFunction(extractionFunction, selectors.chatContainer.strategies, selectors.chatTabList.strategies, selectors.chatInput.strategies, selectors.approveButton.strategies, selectors.approveButton.textMatch ?? [], selectors.rejectButton.strategies, selectors.rejectButton.textMatch ?? []));
+}