teamshare-bridge 0.19.22 → 0.20.0

package/dist/cli/commands/browse.js

@@ -299,7 +299,7 @@ async function cmdBrowse(flags) {
     const modelSpec = flags.get('model') ?? 'mimo:mimo-v2.5';
     const timeoutSec = Math.min(Math.max(parseInt(flags.get('timeout') ?? '300', 10), 30), 600);
     const timeoutMs = timeoutSec * 1000;
-    const quality = Math.min(Math.max(parseInt(flags.get('quality') ?? '92', 10), 50), 100);
+    const quality = Math.min(Math.max(parseInt(flags.get('quality') ?? '78', 10), 50), 100);
     const maxConsecutiveFailures = parseInt(flags.get('max-consecutive-failures') ?? '0', 10); // 0 = unlimited
     const charDelayMs = Math.min(Math.max(parseInt(flags.get('char-delay') ?? '150', 10), 5), 200);
     const optimize = flags.has('optimize');
@@ -352,6 +352,117 @@ async function cmdBrowse(flags) {
     catch (err) {
         console.error(`[browse] Page.enable failed: ${(0, config_1.msg)(err)}`);
     }
+    // Stealth: install stack trace sanitization to hide CDP frames
+    installStackTraceStealth();
+    // Stealth: suppress console serialization leak caused by CDP's Runtime.enable.
+    // Anti-bot probe: Object.defineProperty(obj,'x',{get(){window.__detected=1}});
+    //   console.debug(obj); if(window.__detected) → CDP is serializing args
+    // Countermeasure: wrap console methods to prevent deep serialization.
+    try {
+        await cdpEval(page, `
+      (() => {
+        const CK = Symbol('__ts_cp');
+        if (window[CK]) return;
+        const wrap = (fn) => function(...args) {
+          return fn.apply(console, args.map(a => {
+            if (a && typeof a === 'object' && typeof a !== 'function') {
+              try { return Object.assign(Array.isArray(a) ? [] : {}, a); } catch { return a; }
+            }
+            return a;
+          }));
+        };
+        console.debug = wrap(console.debug);
+        console.log = wrap(console.log);
+        console.warn = wrap(console.warn);
+        console.error = wrap(console.error);
+        window[CK] = true;
+      })()
+    `);
+    }
+    catch { /* non-critical */ }
+    // Register CDP event: Page.frameNavigated (URL/navigation changes)
+    onCdpEvent(page, 'Page.frameNavigated', () => {
+        page._cdpNavigated = Date.now();
+    });
+    // Inject MutationObserver: watches DOM for significant content changes
+    // Uses same fingerprint comparison as Node.js side to prevent false positives.
+    // Filters out: timers, animations, scripts, styles, notifications, toasts.
+    // Debounces mutations (500ms) to batch rapid changes.
+    // Stealth: uses Symbol-keyed property (invisible to Object.keys / anti-bot scans).
+    try {
+        await cdpEval(page, `
+      (() => {
+        const KEY = Symbol('__ts_obs');
+        if (window[KEY]) return 'already attached';
+        const IGNORE = /timer|countdown|elapsed|clock|animation|animate|transition|spinner|progress|loading|toast|notification|alert|banner|snackbar|cookie|consent|modal|overlay|popup|tooltip|badge|tag|avatar|icon|svg|img|video|audio|canvas|font|stylesheet|script|meta|link|head/i;
+        let timer = null;
+        let lastText = '';
+        function getText() {
+          const els = document.querySelectorAll('input[type="radio"],input[type="checkbox"],input[type="text"],input[type="email"],input[type="password"],textarea,label,button');
+          return [...els].map(e => {
+            const t = (e.innerText || e.textContent || '').trim().replace(/\\s+/g, ' ').slice(0, 200);
+            return e.type + '|' + t + '|' + (e.checked || false);
+          }).join('\\n');
+        }
+        function check() {
+          try {
+            const curr = getText();
+            if (curr === lastText) return;
+            const prev = lastText;
+            lastText = curr;
+            const prevGroups = prev ? prev.split('\\n').filter(Boolean) : [];
+            const currGroups = curr.split('\\n').filter(Boolean);
+            const prevSet = new Set(prevGroups);
+            const currSet = new Set(currGroups);
+            let removed = 0, changed = 0;
+            for (const g of prevGroups) {
+              if (!currSet.has(g)) {
+                if (prevGroups.indexOf(g) < currGroups.length) changed++;
+                else removed++;
+              }
+            }
+            const added = currGroups.filter(g => !prevSet.has(g)).length;
+            const score = added * 10 + removed * 10 + changed * 8;
+            if (score >= 15) {
+              window[KEY].changed = Date.now();
+            }
+          } catch {}
+        }
+        const obs = new MutationObserver((mutations) => {
+          let hasRelevant = false;
+          for (const m of mutations) {
+            if (m.target instanceof Element) {
+              const tag = m.target.tagName;
+              if (tag === 'SCRIPT' || tag === 'STYLE' || tag === 'HEAD') continue;
+              const cls = m.target.className || '';
+              if (typeof cls === 'string' && IGNORE.test(cls)) continue;
+              const id = m.target.id || '';
+              if (IGNORE.test(id)) continue;
+              if (m.type === 'characterData' && m.target.parentElement) {
+                const ptag = m.target.parentElement.tagName;
+                if (ptag === 'SCRIPT' || ptag === 'STYLE') continue;
+              }
+            }
+            hasRelevant = true;
+          }
+          if (hasRelevant) {
+            clearTimeout(timer);
+            timer = setTimeout(check, 500);
+          }
+        });
+        obs.observe(document.body || document.documentElement, {
+          childList: true, subtree: true, characterData: true
+        });
+        window[KEY] = { observer: obs, changed: 0 };
+        lastText = getText();
+        return 'ok';
+      })()
+    `);
+        console.log('[browse] MutationObserver injected (stealth, debounced, filtered)');
+    }
+    catch (err) {
+        console.error(`[browse] MutationObserver injection failed: ${(0, config_1.msg)(err)}`);
+    }
     // Agent loop
     let actionCount = 0;
     let llmCallCount = 0;
@@ -381,10 +492,12 @@ async function cmdBrowse(flags) {
                 continue;
             }
             // Detect screen change via question fingerprint comparison
+            // Threshold 15: requires ≥1 new/removed question (10) + text change (8) = 18,
+            // or 2 text changes (16). Score of 5 (single option change) is too sensitive.
             const currentFingerprint = createFingerprint(elements);
             if (lastFingerprint) {
                 const changeScore = calculateChangeScore(lastFingerprint, currentFingerprint);
-                if (changeScore >= 5) {
+                if (changeScore >= 15) {
                     console.log(`[browse] Screen changed (score: ${changeScore}) — resetting state`);
                     codeConfirmedOptimal = false;
                     consecutiveFailures = 0;
@@ -398,7 +511,7 @@ async function cmdBrowse(flags) {
             console.log(`[browse] [${actionLabel}] Analyzing screenshot...`);
             let result = null;
             for (let attempt = 1; attempt <= maxRetries; attempt++) {
-                result = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, pageContext, timeoutMs, attempt, maxRetries);
+                result = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, pageContext, timeoutMs, attempt, maxRetries, page, lastFingerprint);
                 llmCallCount++;
                 if (llmCallCount > 50 && llmCallCount % 25 === 0) {
                     console.log(`[browse] Warning: ${llmCallCount} LLM calls made — may hit rate limits`);
@@ -445,7 +558,7 @@ async function cmdBrowse(flags) {
                     const freshFingerprint = createFingerprint(freshElements);
                     if (lastFingerprint) {
                         const changeScore = calculateChangeScore(lastFingerprint, freshFingerprint);
-                        if (changeScore >= 5) {
+                        if (changeScore >= 15) {
                             console.log(`[browse] Screen changed during LLM call (score: ${changeScore}) — skipping actions, re-analyzing`);
                             lastFingerprint = freshFingerprint;
                             lastScreenshot = freshScreenshot;
@@ -471,7 +584,7 @@ async function cmdBrowse(flags) {
                     if (hasUnansweredQuestions(elements)) {
                         console.log(`[browse] LLM says done but unanswered questions remain — retrying...`);
                         // Force retry with stronger prompt
-                        result = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, pageContext, timeoutMs, 1, 1);
+                        result = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, pageContext, timeoutMs, 1, 1, page, lastFingerprint);
                         if (result.actions.length > 0 && result.actions[0].action !== 'done') {
                             // LLM returned actual actions — re-process from the start of this loop
                             executedAny = false;
@@ -615,6 +728,10 @@ async function cmdBrowse(flags) {
                 else {
                     console.log(`[browse] Action: ${act.action} - ${act.reasoning || ''}`);
                 }
+                // Human-like hesitation before acting (200-600ms)
+                if (act.action === 'click' || act.action === 'type' || act.action === 'write_code') {
+                    await sleep(200 + Math.random() * 400);
+                }
                 await (hybrid ? executeActionHybrid : executeAction)(page, act, elements, charDelayMs);
                 actionCount++;
                 executedAny = true;
@@ -646,7 +763,7 @@ Review the code and check:
 If the code is ALREADY optimal (top-tier efficiency), return: [{"action":"done","summary":"Code is already optimal"}]
 
 If you can optimize it, return the FULL optimized code using write_code. Focus ONLY on performance — do not change correctness.
-Do NOT simplify variable names or change the function signature. Only optimize the algorithm.`);
+Do NOT simplify variable names or change the function signature. Only optimize the algorithm.`, page);
                     if (optResult.actions.length > 0 && optResult.actions[0].action !== 'done') {
                         const optAct = optResult.actions[0];
                         if ((optAct.action === 'write_code' || optAct.action === 'type') && optAct.code) {
@@ -732,6 +849,7 @@ async function connectToPage(port) {
             title: pageTarget.title || pageTarget.url,
             msgId: 1,
             pending: new Map(),
+            eventListeners: new Map(),
         };
         const timeout = setTimeout(() => {
             ws.close();
@@ -748,6 +866,20 @@ async function connectToPage(port) {
         ws.on('message', (data) => {
             try {
                 const msg = JSON.parse(data.toString());
+                // Handle CDP events (have method, no id)
+                if (msg.method && !msg.id) {
+                    const listeners = page.eventListeners.get(msg.method);
+                    if (listeners) {
+                        for (const cb of listeners) {
+                            try {
+                                cb(msg.params || {});
+                            }
+                            catch { /* listener error */ }
+                        }
+                    }
+                    return;
+                }
+                // Handle request/response (have id)
                 if (msg.id && page.pending.has(msg.id)) {
                     const p = page.pending.get(msg.id);
                     page.pending.delete(msg.id);
@@ -772,6 +904,48 @@ async function connectToPage(port) {
         });
     });
 }
+/** Register a listener for a CDP event (e.g. 'Page.frameNavigated'). */
+function onCdpEvent(page, event, cb) {
+    if (!page.eventListeners.has(event))
+        page.eventListeners.set(event, new Set());
+    page.eventListeners.get(event).add(cb);
+}
+// ── Stealth: Stack trace sanitization ────────────────────────────────────────
+// Anti-bot detection: try { throw new Error('probe') } catch(e) {
+//   if (e.stack.includes('Runtime.evaluate')) { /* DETECTED */ }
+// }
+// Countermeasure: override Error.prepareStackTrace to strip CDP frames,
+// and add sourceURL to make injected scripts look like Chrome extensions.
+const CDP_STACK_RE = /Runtime\.evaluate|at\s+.*?CDP|__cdp/i;
+const STEALTH_SOURCE_URL = '//# sourceURL=chrome-extension://pbjikgmbmlelhpamhfbhjnknahkdbcm/inject.js';
+/** Override Error.prepareStackTrace to strip CDP-related frames from stack traces. */
+function installStackTraceStealth() {
+    if (typeof Error.prepareStackTrace === 'function')
+        return; // already installed
+    const origPrepare = Error.prepareStackTrace;
+    Error.prepareStackTrace = (error, structuredStackTrace) => {
+        // Filter out frames that contain CDP markers
+        const filtered = structuredStackTrace.filter((callSite) => {
+            const name = callSite.toString();
+            return !CDP_STACK_RE.test(name);
+        });
+        // If we filtered everything, fall back to original
+        if (filtered.length === 0) {
+            return origPrepare ? origPrepare(error, structuredStackTrace) : structuredStackTrace.map(s => s.toString()).join('\n');
+        }
+        return filtered.map(s => s.toString()).join('\n');
+    };
+}
+/**
+ * Stealth wrapper for Runtime.evaluate.
+ * Adds sourceURL marker (makes stack traces look like a Chrome extension)
+ * and sanitizes stack traces to hide CDP frames.
+ */
+function cdpEval(page, expression, returnByValue = true) {
+    // Add sourceURL to disguise the injection origin
+    const wrapped = expression.trimEnd() + '\n' + STEALTH_SOURCE_URL;
+    return cdpSend(page, 'Runtime.evaluate', { expression: wrapped, returnByValue });
+}
 function cdpSend(page, method, params) {
     return new Promise((resolve, reject) => {
         const id = page.msgId++;
@@ -955,10 +1129,7 @@ async function extractElements(page) {
     })()
   `;
     try {
-        const result = await cdpSend(page, 'Runtime.evaluate', {
-            expression: js,
-            returnByValue: true,
-        });
+        const result = await cdpEval(page, js);
         return result?.result?.value || [];
     }
     catch {
@@ -988,12 +1159,15 @@ async function executeAction(page, act, elements, charDelayMs) {
                         console.log(`[browse] Scrolled — element now at index ${el.i}, position (${el.x},${el.y})`);
                     }
                 }
-                console.log(`[browse] Clicking [${el.i}] ${el.tag} "${el.text.slice(0, 60)}" at (${el.x},${el.y})`);
+                // Human-like click: offset ±2-5px from center (humans never click exact center)
+                const clickX = el.x + Math.round((Math.random() - 0.5) * 8);
+                const clickY = el.y + Math.round((Math.random() - 0.5) * 6);
+                console.log(`[browse] Clicking [${el.i}] ${el.tag} "${el.text.slice(0, 60)}" at (${clickX},${clickY})`);
                 await cdpSend(page, 'Input.dispatchMouseEvent', {
-                    type: 'mousePressed', x: el.x, y: el.y, button: 'left', clickCount: 1,
+                    type: 'mousePressed', x: clickX, y: clickY, button: 'left', clickCount: 1,
                 });
                 await cdpSend(page, 'Input.dispatchMouseEvent', {
-                    type: 'mouseReleased', x: el.x, y: el.y, button: 'left', clickCount: 1,
+                    type: 'mouseReleased', x: clickX, y: clickY, button: 'left', clickCount: 1,
                 });
                 return true;
             }
@@ -1113,8 +1287,10 @@ async function executeActionHybrid(page, act, elements, charDelayMs) {
                         console.log(`[browse] Scrolled — element now at index ${el.i}, position (${el.x},${el.y})`);
                     }
                 }
-                console.log(`[browse] Clicking [${el.i}] ${el.tag} "${el.text.slice(0, 60)}" at (${el.x},${el.y})`);
-                clickOS(el.x, el.y);
+                const clickX = el.x + Math.round((Math.random() - 0.5) * 8);
+                const clickY = el.y + Math.round((Math.random() - 0.5) * 6);
+                console.log(`[browse] Clicking [${el.i}] ${el.tag} "${el.text.slice(0, 60)}" at (${clickX},${clickY})`);
+                clickOS(clickX, clickY);
                 return true;
             }
             case 'type': {
@@ -1300,8 +1476,7 @@ async function clearEditor(page) {
 /** Read current editor content from Monaco/CM5/CM6/Ace. */
 async function readEditorContent(page) {
     try {
-        const result = await cdpSend(page, 'Runtime.evaluate', {
-            expression: `
+        const result = await cdpEval(page, `
         (() => {
           const monacoNs = typeof monaco !== 'undefined' ? monaco : window.monaco;
           const editors = monacoNs?.editor?.getEditors?.() || [];
@@ -1314,9 +1489,7 @@ async function readEditorContent(page) {
           if (ace) return ace.getValue();
           return '';
         })()
-      `,
-            returnByValue: true,
-        });
+      `);
         return result?.result?.value ?? '';
     }
     catch {
@@ -1326,8 +1499,7 @@ async function readEditorContent(page) {
 /** Scroll an off-screen element into view before clicking. */
 async function scrollElementIntoView(page, el) {
     const textSlice = el.text?.slice(0, 100) || '';
-    await cdpSend(page, 'Runtime.evaluate', {
-        expression: `
+    await cdpEval(page, `
       (() => {
         const sels = [
           'input[type="radio"]', 'input[type="checkbox"]',
@@ -1347,9 +1519,7 @@ async function scrollElementIntoView(page, el) {
         }
         return false;
       })()
-    `,
-        returnByValue: true,
-    });
+    `);
     await sleep(300);
 }
 /** Check if there are genuinely unanswered questions — catches premature 'done' from LLM. */
@@ -1515,19 +1685,36 @@ async function waitForScreenChange(page, previousScreenshot, intervalMs, quality
     }
     return false;
 }
-/** Variable typing delay — random variation for natural feel. Never faster than 70% of base. */
+/** Box-Muller transform: Gaussian-distributed random number (mean 0, stddev 1). */
+function gaussianRandom() {
+    let u = 0, v = 0;
+    while (u === 0)
+        u = Math.random();
+    while (v === 0)
+        v = Math.random();
+    return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+}
+/** Variable typing delay — Gaussian distribution with character-specific offsets. */
 function variableDelay(baseMs, char, index, total) {
-    let delay = baseMs + (Math.random() - 0.5) * baseMs * 0.6;
+    // Gaussian delay centered on baseMs, stddev = 30% of base
+    let delay = baseMs + gaussianRandom() * baseMs * 0.3;
+    // Space bar: longer pause (word boundary)
     if (char === ' ')
-        delay += 20 + Math.random() * 60;
+        delay += 30 + Math.random() * 80;
+    // Digits: slight pause
     if (/[0-9]/.test(char))
-        delay += 10 + Math.random() * 30;
+        delay += 15 + Math.random() * 40;
+    // Special chars: longer pause (reaching for symbol)
     if (/^[{}():"<>!@#$%^&*_+|~`?\[\]]$/.test(char))
-        delay += 50 + Math.random() * 120;
-    if (index > 0 && index % (15 + Math.floor(Math.random() * 10)) === 0) {
-        delay += 200 + Math.random() * 500;
-    }
-    return Math.max(delay, baseMs * 0.7);
+        delay += 60 + Math.random() * 150;
+    // Occasional "thinking" pause (burst typing pattern)
+    if (index > 0 && index % (12 + Math.floor(Math.random() * 8)) === 0) {
+        delay += 300 + Math.random() * 700;
+    }
+    // Newline: longer pause (reading/thinking)
+    if (char === '\n')
+        delay += 80 + Math.random() * 200;
+    return Math.max(delay, baseMs * 0.5);
 }
 /**
  * Detect and remove extra trailing closing brackets in the editor.
@@ -1593,8 +1780,7 @@ async function insertIntoCodeEditor(page, selector, text, charDelayMs) {
     });
     await sleep(100);
     // Disable ALL auto-formatting to prevent cascading indentation
-    await cdpSend(page, 'Runtime.evaluate', {
-        expression: `
+    await cdpEval(page, `
       (() => {
         const monacoNs = typeof monaco !== 'undefined' ? monaco : window.monaco;
         monacoNs?.editor?.getEditors?.().forEach(e => e.updateOptions({
@@ -1613,8 +1799,7 @@ async function insertIntoCodeEditor(page, selector, text, charDelayMs) {
           ace.setOption(' behavioursEnabled', false);
         }
       })()
-    `,
-    });
+    `);
     // Smart retry: check if editor already has the correct code
     const currentContent = await readEditorContent(page);
     if (currentContent === text) {
@@ -1675,8 +1860,7 @@ async function insertIntoCodeEditor(page, selector, text, charDelayMs) {
     // Post-typing: detect and remove extra trailing brackets
     await removeTrailingBrackets(page);
     // Re-enable auto-formatting
-    await cdpSend(page, 'Runtime.evaluate', {
-        expression: `
+    await cdpEval(page, `
       (() => {
         const monacoNs = typeof monaco !== 'undefined' ? monaco : window.monaco;
         monacoNs?.editor?.getEditors?.().forEach(e => e.updateOptions({
@@ -1689,8 +1873,7 @@ async function insertIntoCodeEditor(page, selector, text, charDelayMs) {
         const cm5 = document.querySelector('.CodeMirror')?.CodeMirror;
         if (cm5) cm5.setOption('electricChars', true);
       })()
-    `,
-    });
+    `);
     console.log(`[browse] Typing complete (${text.length} chars)`);
 }
 /** Insert text into a generic input — click focus + char-by-char typing. */
@@ -1831,10 +2014,7 @@ async function extractPageContext(page) {
     })()
   `;
     try {
-        const result = await cdpSend(page, 'Runtime.evaluate', {
-            expression: js,
-            returnByValue: true,
-        });
+        const result = await cdpEval(page, js);
         return result?.result?.value ?? '';
     }
     catch {
@@ -1869,10 +2049,7 @@ async function detectEditor(page) {
     })()
   `;
     try {
-        const result = await cdpSend(page, 'Runtime.evaluate', {
-            expression: js,
-            returnByValue: true,
-        });
+        const result = await cdpEval(page, js);
         return result?.result?.value ?? null;
     }
     catch {
@@ -1885,10 +2062,7 @@ async function detectEditor(page) {
  */
 async function focusSelector(page, selector) {
     try {
-        await cdpSend(page, 'Runtime.evaluate', {
-            expression: `document.querySelector('${selector}')?.focus()`,
-            returnByValue: true,
-        });
+        await cdpEval(page, `document.querySelector('${selector}')?.focus()`);
         return true;
     }
     catch {
@@ -2057,7 +2231,7 @@ function extractScatteredActions(str) {
     }
     return actions;
 }
-async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, elements, pageContext, timeoutMs, attempt, maxAttempts) {
+async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, elements, pageContext, timeoutMs, attempt, maxAttempts, page, lastFingerprint) {
     const startTime = Date.now();
     // Format element list grouped by question
     const groups = new Map();
@@ -2131,11 +2305,62 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
     };
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    // Heartbeat: log progress every 30s while waiting
-    const heartbeat = setInterval(() => {
+    // Heartbeat: check for screen changes every 5s, abort LLM if page changed
+    const heartbeat = setInterval(async () => {
         const elapsed = Math.round((Date.now() - startTime) / 1000);
+        // Check for screen change via CDP navigation event or MutationObserver flag
+        let screenChanged = false;
+        if (page?._cdpNavigated && page._cdpNavigated > startTime) {
+            screenChanged = true;
+            console.log(`[browse] CDP navigation detected (${elapsed}s) — aborting LLM`);
+        }
+        if (!screenChanged) {
+            try {
+                const flagResult = await cdpEval(page, `
+            (() => {
+              const syms = Object.getOwnPropertySymbols(window);
+              for (const s of syms) {
+                if (s.description === '__ts_obs') return window[s]?.changed || 0;
+              }
+              return 0;
+            })()
+          `);
+                const flagTs = flagResult?.result?.value;
+                if (flagTs && flagTs > startTime) {
+                    screenChanged = true;
+                    console.log(`[browse] DOM mutation detected (${elapsed}s) — aborting LLM`);
+                    // Reset flag
+                    await cdpEval(page, `
+              (() => {
+                const syms = Object.getOwnPropertySymbols(window);
+                for (const s of syms) {
+                  if (s.description === '__ts_obs') { window[s].changed = 0; return; }
+                }
+              })()
+            `);
+                }
+            }
+            catch { /* page disconnected */ }
+        }
+        if (screenChanged && lastFingerprint && page) {
+            // Verify with fingerprint comparison before aborting
+            try {
+                const freshElements = await extractElements(page);
+                const freshFingerprint = createFingerprint(freshElements);
+                const changeScore = calculateChangeScore(lastFingerprint, freshFingerprint);
+                if (changeScore >= 15) {
+                    console.log(`[browse] Fingerprint confirms change (score: ${changeScore}) — aborting LLM (${elapsed}s)`);
+                    controller.abort();
+                    return;
+                }
+                else {
+                    console.log(`[browse] Fingerprint says no significant change (score: ${changeScore}) — ignoring (${elapsed}s)`);
+                }
+            }
+            catch { /* extraction failed, skip */ }
+        }
         console.log(`[browse] Waiting for LLM... (${elapsed}s elapsed, attempt ${attempt}/${maxAttempts})`);
-    }, 30000);
+    }, 5000);
     const screenshotKB = Math.round((screenshotBase64.length * 3 / 4) / 1024);
     const contextKB = Math.round(pageContext.length / 1024);
     console.log(`[browse] LLM request: ${model} | ${screenshotKB}KB image | ${contextKB}KB context | ${elements.length} elements | timeout ${Math.round(timeoutMs / 1000)}s | attempt ${attempt}/${maxAttempts}`);
@@ -2195,7 +2420,7 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
     }
 }
 /** Like analyzeScreenshot but accepts a custom system prompt (for optimization pass). */
-async function analyzeScreenshotWithPrompt(baseUrl, apiKey, model, screenshotBase64, elements, pageContext, timeoutMs, attempt, maxAttempts, customSystemPrompt) {
+async function analyzeScreenshotWithPrompt(baseUrl, apiKey, model, screenshotBase64, elements, pageContext, timeoutMs, attempt, maxAttempts, customSystemPrompt, page) {
     const startTime = Date.now();
     const userText = [
         pageContext ? `<page_context>\n${pageContext}\n</page_context>\n` : '',
@@ -2219,6 +2444,29 @@ async function analyzeScreenshotWithPrompt(baseUrl, apiKey, model, screenshotBas
     };
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    // Heartbeat: check for screen changes every 5s, abort if page changed
+    const heartbeat = setInterval(async () => {
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        try {
+            const flagResult = await cdpEval(page, `
+          (() => {
+            const syms = Object.getOwnPropertySymbols(window);
+            for (const s of syms) {
+              if (s.description === '__ts_obs') return window[s]?.changed || 0;
+            }
+            return 0;
+          })()
+        `);
+            const flagTs = flagResult?.result?.value;
+            if (flagTs && flagTs > startTime) {
+                console.log(`[browse] DOM mutation detected in opt pass (${elapsed}s) — aborting`);
+                controller.abort();
+                return;
+            }
+        }
+        catch { /* page disconnected */ }
+        console.log(`[browse] Optimization pass waiting... (${elapsed}s)`);
+    }, 5000);
     try {
         const res = await fetch(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
             method: 'POST',
@@ -2261,6 +2509,7 @@ async function analyzeScreenshotWithPrompt(baseUrl, apiKey, model, screenshotBas
     }
     finally {
         clearTimeout(timeout);
+        clearInterval(heartbeat);
     }
 }
 function sleep(ms) {