teamshare-bridge 0.21.28 → 0.21.30

package/dist/cli/commands/browse.js

@@ -61,6 +61,7 @@ const launch_1 = require("../../lib/browser/launch");
 const session_1 = require("../../lib/browser/session");
 const personal_fields_1 = require("../../lib/browser/personal-fields");
 const human_input_guard_1 = require("../../lib/browser/human-input-guard");
+const screen_change_1 = require("../../lib/browser/screen-change");
 /** Create a fingerprint from the current element list. */
 function createFingerprint(elements) {
     const groups = new Map();
@@ -116,12 +117,51 @@ function calculateChangeScore(prev, curr) {
     }
     return score;
 }
+/**
+ * True when the QUESTION SET changed - a new/removed question, different
+ * question text, or different option text. This is the signal to abort a stale
+ * LLM call / discard its answer. It deliberately ignores checked-state-only
+ * changes (a human answering) and low-level noise (timers, animations) because
+ * those never alter question text or the group set - so a countdown can't
+ * trigger a false "screen changed".
+ */
+function questionSetChanged(prev, curr) {
+    const prevMap = new Map(prev.map((fp) => [fp.groupId, fp]));
+    const currMap = new Map(curr.map((fp) => [fp.groupId, fp]));
+    for (const gid of currMap.keys())
+        if (!prevMap.has(gid))
+            return true;
+    for (const gid of prevMap.keys())
+        if (!currMap.has(gid))
+            return true;
+    for (const [gid, c] of currMap) {
+        const p = prevMap.get(gid);
+        if (!p)
+            continue;
+        if (p.questionText !== c.questionText)
+            return true;
+        if (p.options.join('|') !== c.options.join('|'))
+            return true;
+    }
+    return false;
+}
 /** Fast path (easy objective questions): small reasoning budget. */
 const FAST_MAX_TOKENS = 2048;
 /** Deep path (hard coding questions): enough tokens to emit a full solution. */
 const DEEP_MAX_TOKENS = 16384;
-/** Attempt-1 ceiling: abandon a slow easy answer and escalate to the deep path. */
-const FAST_ATTEMPT_TIMEOUT_MS = 45_000;
+/** Attempt-1 ceiling: most calls finish in 28-60s, so 120s avoids escalating. */
+const FAST_ATTEMPT_TIMEOUT_MS = 120_000;
+/**
+ * Streaming watchdogs. `firstToken` = nothing arrived at all (a silently
+ * stalled request); `idle` = the stream went quiet mid-answer. Tuned to match
+ * the attempt budget so a slow-but-working call is never killed early.
+ */
+const FAST_FIRST_TOKEN_TIMEOUT_MS = 60_000;
+const FAST_IDLE_TIMEOUT_MS = 60_000;
+const DEEP_FIRST_TOKEN_TIMEOUT_MS = 90_000;
+const DEEP_IDLE_TIMEOUT_MS = 60_000;
+/** Pause after an answering action, so the human can see/navigate (ms). */
+const ANSWER_PAUSE_MS = 6_000;
 /**
  * Rule 0 is swapped per attempt: the fast path forbids long deliberation, the
  * deep path (entered when the fast attempt fails) explicitly allows it so hard
@@ -316,90 +356,55 @@ async function instrumentPage(page) {
     `);
     }
     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).
+    // Register CDP event: Page.frameNavigated (URL/navigation changes). Bind
+    // ONCE per page object - instrumentPage also runs on re-attach.
+    //
+    // The MutationObserver is DOCUMENT-scoped: a full navigation wipes it. It used
+    // to be injected only here (attach time, frequently on about:blank), so after
+    // the human navigated to the real page the heartbeat's DOM-change path was
+    // dead for the rest of the run - a question swap during a 50-120s vision call
+    // went undetected and its stale answer was applied to the next screen. We now
+    // re-inject whenever the MAIN frame finishes navigating; subframe/iframe
+    // navigations (ads, widgets) are ignored.
+    if (!page._frameNavBound) {
+        page._frameNavBound = true;
+        onCdpEvent(page, 'Page.frameNavigated', (params) => {
+            if (!(0, screen_change_1.isMainFrameNavigation)(params))
+                return;
+            page._cdpNavigated = Date.now();
+            scheduleObserverReinject(page);
+        });
+    }
+    await reinjectObserver(page);
+}
+/**
+ * Re-inject the document-scoped MutationObserver into the page's CURRENT
+ * document. Idempotent: the injected script early-returns when its Symbol key
+ * already exists. Must run again after every (main-frame) navigation.
+ */
+async function reinjectObserver(page) {
     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';
-      })()
-    `);
+        await cdpEval(page, (0, screen_change_1.buildObserverScript)());
         console.log('[browse] MutationObserver injected (stealth, debounced, filtered)');
     }
     catch (err) {
         console.error(`[browse] MutationObserver injection failed: ${(0, config_1.msg)(err)}`);
     }
 }
+/**
+ * Debounced observer re-inject after a main-frame navigation: `frameNavigated`
+ * can fire before the new document is ready, and rapid redirects would
+ * otherwise inject several times.
+ */
+function scheduleObserverReinject(page) {
+    if (page._reinjectTimer)
+        clearTimeout(page._reinjectTimer);
+    page._reinjectTimer = setTimeout(() => {
+        page._reinjectTimer = undefined;
+        if (!page.disconnected)
+            void reinjectObserver(page);
+    }, 600);
+}
 async function cmdBrowse(flags) {
     const autoAnswer = flags.get('auto-answer') === 'true';
     if (!autoAnswer) {
@@ -464,16 +469,26 @@ async function cmdBrowse(flags) {
     // the fast retry below abandons a slow easy answer at ~45s and escalates.
     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') ?? '70', 10), 50), 100);
+    const quality = Math.min(Math.max(parseInt(flags.get('quality') ?? '82', 10), 50), 100);
     /**
-     * Downscale the FAST-path screenshot (attempt 1) to keep easy questions
-     * quick. The deep retry re-captures at full resolution so code/text stays
-     * legible. Clicks are unaffected either way (actions use element coords).
+     * Screenshot detail: the viewport is captured at native resolution and only
+     * scaled down when BOTH sides exceed this many px. Default 1600 keeps
+     * question/option text crisp for the vision model; pass `--max-edge 0` for
+     * native full resolution, or a smaller value for speed. Clicks are unaffected
+     * (actions use element coordinates, not image pixels).
      */
-    const SCREENSHOT_MAX_EDGE = 1024;
+    const maxEdgeRaw = parseInt(flags.get('max-edge') ?? '1600', 10);
+    const SCREENSHOT_MAX_EDGE = Number.isFinite(maxEdgeRaw)
+        ? Math.max(0, Math.min(maxEdgeRaw, 4096))
+        : 1600;
     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');
+    /**
+     * Redundancy pre-check off by default: it costs an EXTRA LLM round-trip per
+     * action (a big latency tax). Opt in with --verify-actions.
+     */
+    const verifyActions = flags.has('verify-actions');
     const stealth = flags.has('stealth');
     const hybrid = flags.has('hybrid');
     const autoLaunch = flags.has('auto-launch');
@@ -577,19 +592,28 @@ async function cmdBrowse(flags) {
     /** A 401/403 from the model API: terminal, retrying cannot succeed. */
     let fatalAuthError = false;
     const maxRetries = 5;
+    /**
+     * Click health. Some custom widgets ignore synthetic CDP mouse events; we
+     * detect "no visible change" and retry with a real DOM click, then cool the
+     * element down (it is still retried on a later pass).
+     */
+    const clickFailures = new Map();
+    const clickCooldown = new Map();
+    /** "done but unanswered" verification retries for the current screen. */
+    let doneRetries = 0;
     /** How often to re-check which tab is active (ms). */
     const TAB_CHECK_MS = 2000;
     let lastTabCheck = 0;
     let consecutiveScreenshotFailures = 0;
     let reattachFailures = 0;
     // Latency observability: rolling average of vision-call latency plus
-    // abort/timeout counts, so the operator can see how slow the model is.
-    const llmStats = { calls: 0, ok: 0, screenAborts: 0, timeouts: 0, totalMs: 0 };
+    // abort/timeout/stall counts, so the operator can see how slow the model is.
+    const llmStats = { calls: 0, ok: 0, screenAborts: 0, timeouts: 0, stalls: 0, totalMs: 0 };
     const logLlmStats = () => {
         if (llmStats.calls === 0 || llmStats.calls % 5 !== 0)
             return;
         const avg = Math.round(llmStats.totalMs / llmStats.calls / 1000);
-        console.log(`[browse] LLM latency: avg ${avg}s over ${llmStats.calls} call(s) — ${llmStats.ok} ok, ${llmStats.screenAborts} screen-abort, ${llmStats.timeouts} timeout`);
+        console.log(`[browse] LLM latency: avg ${avg}s over ${llmStats.calls} call(s) — ${llmStats.ok} ok, ${llmStats.screenAborts} screen-abort, ${llmStats.timeouts} timeout, ${llmStats.stalls} stall`);
     };
     /**
      * (Re)attach to a tab. A closed or switched tab used to leave the loop
@@ -686,10 +710,14 @@ async function cmdBrowse(flags) {
             const currentFingerprint = createFingerprint(elements);
             if (lastFingerprint) {
                 const changeScore = calculateChangeScore(lastFingerprint, currentFingerprint);
-                if (changeScore >= 15) {
+                if (questionSetChanged(lastFingerprint, currentFingerprint) || changeScore >= 15) {
                     console.log(`[browse] Screen changed (score: ${changeScore}) — resetting state`);
                     codeConfirmedOptimal = false;
                     consecutiveFailures = 0;
+                    // A new screen resets per-screen bookkeeping.
+                    doneRetries = 0;
+                    clickFailures.clear();
+                    clickCooldown.clear();
                 }
             }
             lastFingerprint = currentFingerprint;
@@ -702,20 +730,17 @@ async function cmdBrowse(flags) {
             /** The page changed under the LLM: re-analyze immediately, no backoff. */
             let screenChangedDuringLlm = false;
             for (let attempt = 1; attempt <= maxRetries; attempt++) {
-                // Fast-first ladder: attempt 1 uses a small budget + downscaled shot so
-                // easy objective questions answer quickly. If it fails, attempts 2+
-                // switch to the DEEP budget (full timeout + tokens, full-res capture)
-                // for hard coding questions. `max_tokens`/timeout are ceilings, so the
+                // Fast-first ladder: attempt 1 uses a small token budget; attempts 2+
+                // switch to the DEEP budget (full timeout + tokens) for hard coding
+                // questions. Both use the SAME full-detail screenshot (maxEdge/quality)
+                // so text is always legible; `max_tokens`/timeout are ceilings, so the
                 // deep path never slows a question that answers on the fast path.
                 const deep = attempt > 1;
                 const attemptTimeoutMs = deep ? timeoutMs : Math.min(FAST_ATTEMPT_TIMEOUT_MS, timeoutMs);
                 if (deep && attempt === 2) {
                     console.log('[browse] Fast attempt did not answer — escalating to the deep budget (more time + tokens)');
                 }
-                const attemptShot = deep
-                    ? ((await captureScreenshot(page, quality)) ?? screenshot)
-                    : screenshot;
-                result = await analyzeScreenshot(baseUrl, apiKey, model, attemptShot, elements, pageContext, attemptTimeoutMs, attempt, maxRetries, page, lastFingerprint, { maxTokens: deep ? DEEP_MAX_TOKENS : FAST_MAX_TOKENS, deep });
+                result = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, pageContext, attemptTimeoutMs, attempt, maxRetries, page, lastFingerprint, { maxTokens: deep ? DEEP_MAX_TOKENS : FAST_MAX_TOKENS, deep });
                 llmCallCount++;
                 llmStats.calls++;
                 llmStats.totalMs += result.durationMs;
@@ -793,8 +818,12 @@ async function cmdBrowse(flags) {
                     const freshFingerprint = createFingerprint(freshElements);
                     if (lastFingerprint) {
                         const changeScore = calculateChangeScore(lastFingerprint, freshFingerprint);
-                        if (changeScore >= 15) {
-                            console.log(`[browse] Screen changed during LLM call (score: ${changeScore}) — skipping actions, re-analyzing`);
+                        // Discard a (costly) LLM answer when the QUESTION SET changed under
+                        // it (its answer is stale), or on a material whole-screen change.
+                        // A pure question-text swap scores only 8 on the generic scale, so
+                        // the targeted check catches what the score alone missed.
+                        if (questionSetChanged(lastFingerprint, freshFingerprint) || changeScore >= 40) {
+                            console.log(`[browse] Question set changed during LLM call (score: ${changeScore}) — skipping actions, re-analyzing`);
                             lastFingerprint = freshFingerprint;
                             lastScreenshot = freshScreenshot;
                             await sleep(intervalMs);
@@ -815,28 +844,33 @@ async function cmdBrowse(flags) {
             let wroteCode = false;
             for (const act of result.actions) {
                 if (act.action === 'done') {
-                    // Validate: are there actually unanswered questions?
-                    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, page, lastFingerprint, { maxTokens: DEEP_MAX_TOKENS, deep: true });
-                        if (result.actions.length > 0 && result.actions[0].action !== 'done') {
-                            // LLM returned actual actions — re-process from the start of this loop
-                            executedAny = false;
-                            wroteCode = false;
-                            // Fall through to process new actions below
-                        }
-                        else {
-                            // LLM still says done — trust it this time and continue
-                            console.log(`[browse] LLM confirms done after verification`);
-                            if (continuous && !executedAny) {
-                                const changed = await waitForScreenChange(page, lastScreenshot ?? screenshot, intervalMs, quality, () => stopped);
-                                if (!changed)
-                                    break;
-                                executedAny = false;
+                    // Validate: are there actually unanswered questions? (The heuristic is
+                    // authoritative — a "done" while questions are open means the earlier
+                    // clicks did not register, NOT that the gate is wrong.)
+                    if (hasUnansweredQuestions(elements) && doneRetries < 1) {
+                        doneRetries++;
+                        console.log(`[browse] LLM says done but questions remain unanswered — asking once more`);
+                        const followUp = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, pageContext, timeoutMs, 1, 1, page, lastFingerprint, 
+                        // Fast budget: this is a short "act now" nudge, not a hard problem.
+                        { maxTokens: FAST_MAX_TOKENS, deep: false });
+                        const followActions = followUp.actions.filter((a) => a.action !== 'done');
+                        if (followActions.length > 0) {
+                            // Execute the follow-up actions here — the old code reassigned
+                            // `result` inside the for-of, so these were silently discarded and
+                            // the loop spun on the same unanswered question forever.
+                            console.log(`[browse] Follow-up: executing ${followActions.length} action(s)`);
+                            for (const fa of followActions) {
+                                await (hybrid ? executeActionHybrid : executeAction)(page, fa, elements, charDelayMs);
+                                actionCount++;
+                                executedAny = true;
+                                await sleep(ANSWER_PAUSE_MS);
                             }
+                            continue; // re-analyze the screen after acting
                         }
-                        continue;
+                        console.log(`[browse] LLM confirms done after verification`);
+                    }
+                    else if (hasUnansweredQuestions(elements)) {
+                        console.log(`[browse] Questions still open after verification — leaving them for the model/next screen`);
                     }
                     // All questions genuinely answered
                     if (continuous && !executedAny) {
@@ -877,8 +911,10 @@ async function cmdBrowse(flags) {
                         continue;
                     }
                 }
-                // Ask LLM to decide if action is redundant
-                const redundancy = await isActionRedundant(baseUrl, apiKey, model, page, elements, act, timeoutMs);
+                // Redundancy pre-check (extra LLM round-trip) — only when opted in.
+                const redundancy = verifyActions
+                    ? await isActionRedundant(baseUrl, apiKey, model, page, elements, act, timeoutMs)
+                    : { decision: 'proceed' };
                 if (redundancy.decision === 'skip') {
                     continue;
                 }
@@ -975,6 +1011,15 @@ async function cmdBrowse(flags) {
                 else {
                     console.log(`[browse] Action: ${act.action} - ${act.reasoning || ''}`);
                 }
+                // Element cooled down after repeated non-responsive clicks: skip it for
+                // this pass (it is retried on a later pass).
+                if (act.action === 'click' && act.elementIndex !== undefined) {
+                    const coolUntil = clickCooldown.get(act.elementIndex) ?? 0;
+                    if (coolUntil > Date.now()) {
+                        console.log(`[browse] Skipping element ${act.elementIndex} — no response to earlier clicks (will retry later)`);
+                        continue;
+                    }
+                }
                 // Human-like hesitation before acting (200-600ms)
                 if (act.action === 'click' || act.action === 'type' || act.action === 'write_code') {
                     await sleep(200 + Math.random() * 400);
@@ -985,9 +1030,42 @@ async function cmdBrowse(flags) {
                 if (act.action === 'write_code' || act.action === 'type') {
                     wroteCode = true;
                 }
-                // Natural delay between actions
+                // Verify a click actually changed something. Some custom widgets ignore
+                // synthetic CDP mouse events, which is why a question stayed "unanswered"
+                // no matter how often the model clicked it. Retry with a real DOM click,
+                // then cool the element down after 3 fruitless attempts (retried later).
+                if (act.action === 'click' && act.elementIndex !== undefined) {
+                    const idx = act.elementIndex;
+                    await sleep(400);
+                    try {
+                        const after = await extractElements(page);
+                        const score = calculateChangeScore(createFingerprint(elements), createFingerprint(after));
+                        if (score < 15) {
+                            const n = (clickFailures.get(idx) ?? 0) + 1;
+                            clickFailures.set(idx, n);
+                            console.log(`[browse] Click on element ${idx} produced no visible change (${n}/3)`);
+                            const el = elements.find((e) => e.i === idx);
+                            if (el && n <= 2) {
+                                const ok = await domClickAt(page, el.x, el.y);
+                                console.log(`[browse] DOM-click fallback on element ${idx}: ${ok ? 'dispatched' : 'failed'}`);
+                            }
+                            else if (el && n >= 3) {
+                                clickCooldown.set(idx, Date.now() + 30_000);
+                                clickFailures.delete(idx);
+                                console.log(`[browse] Element ${idx} not responding — skipping for 30s`);
+                            }
+                        }
+                        else {
+                            clickFailures.delete(idx);
+                        }
+                    }
+                    catch {
+                        /* verification is best-effort */
+                    }
+                }
+                // Pause after answering so the human can read/navigate (was 2s: too short).
                 if (act.action === 'click' || act.action === 'type' || act.action === 'write_code') {
-                    await sleep(2000);
+                    await sleep(ANSWER_PAUSE_MS);
                 }
             }
             // Optimization pass: if --optimize and code was written, ask LLM to optimize it
@@ -1559,6 +1637,32 @@ async function extractElements(page) {
         return [];
     }
 }
+/**
+ * Fallback click: dispatch a REAL DOM click at (x, y) via
+ * document.elementFromPoint + the nearest interactive ancestor. Custom widgets
+ * that ignore synthetic CDP mouse events usually respond to this.
+ */
+async function domClickAt(page, x, y) {
+    try {
+        const r = await cdpEval(page, `
+      (() => {
+        const el = document.elementFromPoint(${Math.round(x)}, ${Math.round(y)});
+        if (!el) return false;
+        const t = (el.closest && el.closest('button,label,a,[role],[onclick],input,li,span')) || el;
+        try { if (t.focus) t.focus(); } catch (e) {}
+        try {
+          if (typeof t.click === 'function') { t.click(); return true; }
+        } catch (e) {}
+        t.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+        return true;
+      })()
+    `);
+        return r?.result?.value === true;
+    }
+    catch {
+        return false;
+    }
+}
 async function executeAction(page, act, elements, charDelayMs) {
     try {
         switch (act.action) {
@@ -2519,6 +2623,26 @@ async function extractPageContext(page) {
           break;
         }
       }
+      // FULL PAGE CONTENT (2026-09): the model must be fully informed from the
+      // PAGE TEXT, not just the screenshot or the element list. Prefer the main
+      // content region, else the body; collapse whitespace and cap the size.
+      try {
+        const root =
+          document.querySelector('main, article, [role="main"]') || document.body;
+        let text = (root && (root.innerText || root.textContent)) || '';
+        text = text
+          .replace(/[ \\t\\u00a0]+/g, ' ')
+          .replace(/\\n\\s*\\n+/g, '\\n')
+          .trim();
+        if (text) {
+          const CAP = 12000;
+          ctx.push('Page content:');
+          ctx.push(text.slice(0, CAP));
+          if (text.length > CAP) {
+            ctx.push('... (page content truncated at ' + CAP + ' chars)');
+          }
+        }
+      } catch (e) { /* best-effort */ }
       return ctx.join('\\n');
     })()
   `;
@@ -2740,6 +2864,169 @@ function extractScatteredActions(str) {
     }
     return actions;
 }
+/**
+ * Extract the model text from a non-streaming chat-completions JSON body
+ * (handles content arrays and reasoning_content on reasoning models).
+ */
+function extractModelText(json) {
+    let content = json?.choices?.[0]?.message?.content;
+    if (Array.isArray(content)) {
+        content = content.filter((c) => c?.type === 'text').map((c) => c.text).join('');
+    }
+    if (typeof content !== 'string' || !content) {
+        const reasoning = json?.choices?.[0]?.message?.reasoning_content;
+        if (typeof reasoning === 'string' && reasoning)
+            content = reasoning;
+    }
+    return typeof content === 'string' ? content : '';
+}
+/**
+ * POST /chat/completions with `stream: true` and read the SSE body.
+ *
+ * Non-streaming never resolves until the provider finishes the whole answer, so
+ * a long reasoning response looked like a 150s+ "hang" with zero feedback. With
+ * streaming we see the first token, log its latency, and can catch a genuinely
+ * stalled request (no bytes on the wire at all). `: PROCESSING` keepalives are
+ * NOT tokens but DO prove the connection is alive, so they reset the watchdog;
+ * only real wire silence trips it.
+ *
+ * The caller's `signal` (screen-change / overall timeout) still aborts this.
+ */
+async function streamChatCompletion(opts) {
+    const ac = new AbortController();
+    const forwardAbort = () => ac.abort();
+    if (opts.signal.aborted)
+        ac.abort();
+    else
+        opts.signal.addEventListener('abort', forwardAbort, { once: true });
+    let stalled = null;
+    let sawToken = false;
+    let watchdog = null;
+    const start = Date.now();
+    /**
+     * Any bytes on the wire (including `: PROCESSING` keepalive comments) prove
+     * the connection is alive, so they RESET the watchdog. This provider sends
+     * keepalives every few seconds and only emits real tokens much later - the
+     * old watchdog ignored comments and killed a healthy request at 60s
+     * ("LLM stalled (no token received)" while the model was actively working).
+     * The stall now means genuine wire silence: no bytes at all.
+     */
+    const arm = () => {
+        if (watchdog)
+            clearTimeout(watchdog);
+        watchdog = setTimeout(() => {
+            stalled = sawToken ? 'idle' : 'first-token';
+            ac.abort();
+        }, sawToken ? opts.idleTimeoutMs : opts.firstTokenTimeoutMs);
+    };
+    const cleanup = () => {
+        if (watchdog)
+            clearTimeout(watchdog);
+        watchdog = null;
+        opts.signal.removeEventListener('abort', forwardAbort);
+    };
+    arm();
+    try {
+        const res = await fetch(opts.url, {
+            method: 'POST',
+            signal: ac.signal,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${opts.apiKey}`,
+                'api-key': opts.apiKey,
+                Accept: 'text/event-stream',
+            },
+            body: JSON.stringify(opts.body),
+        });
+        if (!res.ok) {
+            const errorText = await res.text().catch(() => '');
+            cleanup();
+            return { kind: 'http', status: res.status, errorText };
+        }
+        const contentType = (res.headers.get('content-type') ?? '').toLowerCase();
+        // Provider ignored stream:true (plain JSON) — parse it whole.
+        if (!contentType.includes('event-stream') || !res.body) {
+            const json = await res.json().catch(() => null);
+            cleanup();
+            return { kind: 'ok', content: extractModelText(json) };
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let content = '';
+        let reasoning = '';
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            // Any bytes at all (comment keepalives included) = the connection is
+            // alive, so reset the stall watchdog.
+            arm();
+            buffer += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buffer.indexOf('\n')) >= 0) {
+                const raw = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (!raw || raw.startsWith(':'))
+                    continue; // ": PROCESSING" keepalive
+                if (!raw.startsWith('data:'))
+                    continue;
+                const data = raw.slice(5).trim();
+                if (data === '[DONE]') {
+                    cleanup();
+                    return { kind: 'ok', content: content || reasoning };
+                }
+                let j;
+                try {
+                    j = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                const delta = j?.choices?.[0]?.delta;
+                const dc = delta?.content;
+                const dr = delta?.reasoning_content;
+                if (typeof dc === 'string' && dc) {
+                    content += dc;
+                    if (!sawToken) {
+                        sawToken = true;
+                        opts.onFirstToken?.(Date.now() - start);
+                    }
+                }
+                else if (Array.isArray(dc)) {
+                    const t = dc.map((x) => x?.text ?? '').join('');
+                    if (t) {
+                        content += t;
+                        if (!sawToken) {
+                            sawToken = true;
+                            opts.onFirstToken?.(Date.now() - start);
+                        }
+                    }
+                }
+                if (typeof dr === 'string' && dr) {
+                    reasoning += dr;
+                    if (!sawToken) {
+                        sawToken = true;
+                        opts.onFirstToken?.(Date.now() - start);
+                    }
+                }
+            }
+        }
+        cleanup();
+        return { kind: 'ok', content: content || reasoning };
+    }
+    catch (err) {
+        cleanup();
+        if (stalled) {
+            return {
+                kind: 'stalled',
+                phase: stalled,
+                elapsedMs: Date.now() - start,
+            };
+        }
+        throw err; // caller abort (screen change / timeout) or network error
+    }
+}
 async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, elements, pageContext, timeoutMs, attempt, maxAttempts, page, lastFingerprint, budget = {
     maxTokens: DEEP_MAX_TOKENS,
     deep: false,
@@ -2822,7 +3109,7 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
         ],
         temperature: 0.1,
         max_tokens: budget.maxTokens,
-        stream: false,
+        stream: true,
     };
     const controller = new AbortController();
     // Distinguish a genuine timeout from the heartbeat cancelling a stale request
@@ -2835,6 +3122,7 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
         controller.abort();
     }, timeoutMs);
     // Heartbeat: check for screen changes every 5s, abort LLM if page changed
+    let heartbeatTicks = 0;
     const heartbeat = setInterval(async () => {
         const elapsed = Math.round((Date.now() - startTime) / 1000);
         // Check for screen change via CDP navigation event or MutationObserver flag
@@ -2871,14 +3159,26 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
             }
             catch { /* page disconnected */ }
         }
-        if (screenChanged && lastFingerprint && page) {
+        // Fallback (2026-09): the in-page observer is document-scoped (re-injected on
+        // navigation, but a same-document SPA swap may not have ticked it yet) and a
+        // continuously-mutating page can starve its debounce. So every ~10s verify the
+        // fingerprint directly even when no flag fired - a question swap during a
+        // 50-120s vision call must never slip through unnoticed.
+        heartbeatTicks++;
+        const periodicCheck = !screenChanged && heartbeatTicks % 2 === 0;
+        if ((screenChanged || periodicCheck) && 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)`);
+                // Abort on a real question change even when the aggregate score is below
+                // the generic threshold (a pure question-text swap scores only 8), while
+                // still ignoring checked-only / timer noise.
+                if (questionSetChanged(lastFingerprint, freshFingerprint) || changeScore >= 15) {
+                    console.log(screenChanged
+                        ? `[browse] Fingerprint confirms change (score: ${changeScore}) — aborting LLM (${elapsed}s)`
+                        : `[browse] Periodic fingerprint found change (score: ${changeScore}) — aborting LLM (${elapsed}s)`);
                     abortReason = 'screen_change';
                     controller.abort();
                     return;
@@ -2895,22 +3195,27 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
     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}`);
     try {
-        const res = await fetch(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
-            method: 'POST',
+        const outcome = await streamChatCompletion({
+            url: `${baseUrl.replace(/\/$/, '')}/chat/completions`,
+            apiKey,
+            body,
             signal: controller.signal,
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${apiKey}`,
-                'api-key': apiKey,
-            },
-            body: JSON.stringify(body),
+            firstTokenTimeoutMs: budget.deep
+                ? DEEP_FIRST_TOKEN_TIMEOUT_MS
+                : FAST_FIRST_TOKEN_TIMEOUT_MS,
+            idleTimeoutMs: budget.deep ? DEEP_IDLE_TIMEOUT_MS : FAST_IDLE_TIMEOUT_MS,
+            onFirstToken: (ms) => console.log(`[browse] first token in ${Math.round(ms / 1000)}s (${budget.deep ? 'deep' : 'fast'})`),
         });
-        if (!res.ok) {
-            const errText = await res.text().catch(() => '');
-            console.error(`[browse] LLM HTTP ${res.status}: ${errText.slice(0, 200)}`);
+        if (outcome.kind === 'stalled') {
+            console.error(`[browse] LLM stalled (${outcome.phase === 'first-token' ? 'no token received' : 'stream went idle'}) after ${Math.round((outcome.elapsedMs ?? 0) / 1000)}s — aborting`);
+            return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'stalled' };
+        }
+        if (outcome.kind === 'http') {
+            const status = outcome.status ?? 0;
+            console.error(`[browse] LLM HTTP ${status}: ${(outcome.errorText ?? '').slice(0, 200)}`);
             // 401/403 will never succeed on retry — surface a clear, actionable
             // diagnosis instead of burning 5 attempts x N rounds.
-            if (res.status === 401 || res.status === 403) {
+            if (status === 401 || status === 403) {
                 console.error(`[browse] Model auth failed for ${baseUrl} (model ${model}). The API key is invalid, ` +
                     `expired, or belongs to a different provider. Fix the provider key on the run form ` +
                     `(or the agent's provider key) and re-run.`);
@@ -2918,19 +3223,8 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
             }
             return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'http_error' };
         }
-        const json = (await res.json());
-        let content = json.choices?.[0]?.message?.content;
-        if (Array.isArray(content)) {
-            content = content.filter((c) => c.type === 'text').map((c) => c.text).join('');
-        }
-        // Reasoning models (MiMo) put thinking in reasoning_content; fall back to it
-        if (typeof content !== 'string' || !content) {
-            const reasoning = json.choices?.[0]?.message?.reasoning_content;
-            if (typeof reasoning === 'string' && reasoning) {
-                content = reasoning;
-            }
-        }
-        if (typeof content !== 'string' || !content) {
+        const content = outcome.content ?? '';
+        if (!content) {
             console.error('[browse] Empty content from LLM');
             return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'empty' };
         }
@@ -2993,9 +3287,17 @@ async function analyzeScreenshotWithPrompt(baseUrl, apiKey, model, screenshotBas
         optAbortReason = 'timeout';
         controller.abort();
     }, timeoutMs);
-    // Heartbeat: check for screen changes every 5s, abort if page changed
+    // Heartbeat: check for screen changes every 5s, abort if page changed.
+    // The observer flag lives in the current document, so any navigation (which
+    // wipes it) must also abort - check `_cdpNavigated` too, as in the main call.
     const heartbeat = setInterval(async () => {
         const elapsed = Math.round((Date.now() - startTime) / 1000);
+        if (page?._cdpNavigated && page._cdpNavigated > startTime) {
+            console.log(`[browse] CDP navigation detected in opt pass (${elapsed}s) — aborting`);
+            optAbortReason = 'screen_change';
+            controller.abort();
+            return;
+        }
         try {
             const flagResult = await cdpEval(page, `
           (() => {