teamshare-bridge 0.19.17 → 0.19.18

package/dist/cli/commands/browse.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -12,11 +45,70 @@ exports.cmdBrowse = cmdBrowse;
  * answers questions/forms on screen.
  *
  * Usage:
- *   teamshare-agent browse --auto-answer [--port 9222] [--model mimo-v2.5] [--max-actions 50]
+ *   teamshare-agent browse --auto-answer [--port 9222] [--model mimo-v2.5] [--max-actions 50] [--continuous]
  */
 const ws_1 = __importDefault(require("ws"));
 const models_1 = require("../../lib/llm/models");
 const config_1 = require("../../lib/config");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+/** Create a fingerprint from the current element list. */
+function createFingerprint(elements) {
+    const groups = new Map();
+    for (const el of elements) {
+        if (!groups.has(el.group))
+            groups.set(el.group, []);
+        groups.get(el.group).push(el);
+    }
+    const fp = [];
+    for (const [gid, els] of groups) {
+        fp.push({
+            groupId: gid,
+            questionText: els[0]?.questionText || '',
+            options: els.map((e) => e.text || ''),
+            optionTypes: els.map((e) => e.type || e.tag),
+            checkedStates: els.map((e) => e.checked),
+            elementCount: els.length,
+        });
+    }
+    return fp;
+}
+/** Weighted comparison of two fingerprints. Returns change score. */
+function calculateChangeScore(prev, curr) {
+    let score = 0;
+    const prevMap = new Map(prev.map((fp) => [fp.groupId, fp]));
+    const currMap = new Map(curr.map((fp) => [fp.groupId, fp]));
+    // New questions appeared (weight: 10)
+    for (const [gid] of currMap) {
+        if (!prevMap.has(gid))
+            score += 10;
+    }
+    // Questions removed (weight: 10)
+    for (const [gid] of prevMap) {
+        if (!currMap.has(gid))
+            score += 10;
+    }
+    // Compare matching questions
+    for (const [gid, currFp] of currMap) {
+        const prevFp = prevMap.get(gid);
+        if (!prevFp)
+            continue;
+        // Question text changed (weight: 8)
+        if (prevFp.questionText !== currFp.questionText)
+            score += 8;
+        // Options changed (weight: 5)
+        if (prevFp.options.join('|') !== currFp.options.join('|'))
+            score += 5;
+        // Checked states changed (weight: 2 — user answering, not screen change)
+        for (let i = 0; i < Math.min(prevFp.checkedStates.length, currFp.checkedStates.length); i++) {
+            if (prevFp.checkedStates[i] !== currFp.checkedStates[i])
+                score += 2;
+        }
+    }
+    return score;
+}
 const SYSTEM_PROMPT = `You are a browser automation agent. A screenshot and a grouped list of interactive elements are attached.
 
 Your task: identify unanswered questions and answer them by clicking the correct elements.
@@ -25,7 +117,16 @@ RULES (STRICT):
 1. NEVER click Next, Submit, Back, Save, Continue, or any navigation. ONLY answer questions on the current screen.
 2. NEVER ask for help. If uncertain, pick the BEST GUESS. Always decide — never wait.
 3. Handle MULTIPLE unanswered questions in a SINGLE response.
-4. If ALL questions are already answered correctly: [{"action":"done","summary":"All visible questions answered"}]
+4. NEVER return done unless you have VERIFIED every single question is answered. See VERIFICATION CHECKLIST below.
+5. NEVER answer personal questions — see PERSONAL QUESTIONS section below.
+
+VERIFICATION CHECKLIST (MANDATORY before returning done):
+Before returning done, you MUST check EVERY question group:
+- Radio questions: exactly ONE option must be selected (checked). If none selected → you MUST pick an answer.
+- Checkbox questions: ALL correct options must be checked. If any correct option is missing → you MUST check it.
+- Text input questions: the input must have a non-empty value. If empty → you MUST type an answer.
+If ANY question fails this check, you MUST answer it — NEVER return done with unanswered questions.
+If you return done while questions are unanswered, the task will FAIL. You will be retried.
 
 QUESTION TYPES AND STATUS:
 - radio (single answer): Only ONE option can be correct.
@@ -57,15 +158,86 @@ COMBINED EXAMPLE:
  {"action":"type","elementIndex":9,"text":"42","reason":"Q3: fill answer"}]
 
 CODE TYPE EXAMPLE (typing code into an editor — note escaped newlines and quotes):
-[{"action":"type","elementIndex":5,"text":"function twoSum(nums, target) {\\n  const map = new Map();\\n  for (let i = 0; i < nums.length; i++) {\\n    const complement = target - nums[i];\\n    if (map.has(complement)) return [map.get(complement), i];\\n    map.set(nums[i], i);\\n  }\\n  return [];\\n}","reason":"Type the solution function"}]
+[{"action":"type","elementIndex":5,"text":"function twoSum(nums: number[], target: number): number[] {\\n  const map = new Map<number, number>();\\n  for (let i = 0; i < nums.length; i++) {\\n    const complement = target - nums[i];\\n    if (map.has(complement)) {\\n      return [map.get(complement), i];\\n    }\\n    map.set(nums[i], i);\\n  }\\n  return [];\\n}","reason":"Type the solution function"}]
+
+WRITE_CODE EXAMPLE (large code blocks — preferred for code > 100 chars):
+[{"action":"write_code","elementIndex":5,"code":"function twoSum(nums: number[], target: number): number[] {\\n  const map = new Map<number, number>();\\n  for (let i = 0; i < nums.length; i++) {\\n    const complement = target - nums[i];\\n    if (map.has(complement)) {\\n      return [map.get(complement), i];\\n    }\\n    map.set(nums[i], i);\\n  }\\n  return [];\\n}","reason":"Type the solution function"}]
+
+WHEN TO USE write_code vs type:
+- "write_code" for code blocks, functions, classes, multi-line snippets (> 100 chars)
+- "type" for short answers: numbers, single words, short strings (< 100 chars)
+- "write_code" preserves exact indentation and newlines — no formatting changes
+
+CODE FORMATTING RULES (CRITICAL):
+- Use 2-space indentation. Each nesting level adds exactly 2 more spaces.
+- Function body = 2 spaces, loop body = 4 spaces, if-body = 6 spaces.
+- NEVER use tabs or 4/8-space indentation.
+- Keep code compact: single-line statements when appropriate.
+
+CODE OPTIMIZATION RULES (CRITICAL — for coding problems):
+1. ALWAYS write the most time-efficient solution. Correctness alone is NOT enough.
+2. Prefer O(n) or O(n log n) over O(n²). Never write O(n²) if an O(n) approach exists.
+3. Use HashMap/Set for O(1) lookups instead of nested loops for searching/matching.
+4. Consider space-time tradeoffs — a HashMap is worth the O(n) space for O(n) time.
+5. Avoid unnecessary re-computation — cache results in variables.
+6. Use sliding window, two pointers, or binary search where applicable.
+7. Pre-compute prefix sums, frequency maps, or lookup tables when helpful.
+8. Choose the right data structure:
+   - Deque for sliding window problems
+   - Heap/priority queue for top-K problems
+   - Trie for prefix/string matching problems
+   - Union-Find for connected components
+   - BFS for shortest path, DFS for exploration
+9. NEVER write brute force if an optimized approach exists.
+10. If the problem has constraints (e.g., n <= 10^5), ensure your solution runs within limits.
+
+OPTIMIZATION EXAMPLE:
+Problem: "Given an array of integers, return indices of two numbers that add up to target."
+
+NAIVE (WRONG for efficiency — O(n²) time):
+for (let i = 0; i < nums.length; i++) {
+  for (let j = i + 1; j < nums.length; j++) {
+    if (nums[i] + nums[j] === target) return [i, j];
+  }
+}
+
+OPTIMIZED (CORRECT — O(n) time, O(n) space):
+const map = new Map();
+for (let i = 0; i < nums.length; i++) {
+  const complement = target - nums[i];
+  if (map.has(complement)) return [map.get(complement), i];
+  map.set(nums[i], i);
+}
+return [];
 
 Available actions:
 - click: {action:"click", elementIndex:number} — click to check/uncheck/select
-- type: {action:"type", elementIndex:number, text:string} — type into input
+- type: {action:"type", elementIndex:number, text:string} — type short input (< 100 chars)
+- write_code: {action:"write_code", elementIndex:number, code:string} — write code block (> 100 chars), preserves exact indentation
 - scroll: {action:"scroll", delta:number} — scroll up (-) or down (+)
 - press: {action:"press", key:string} — press Enter, Tab, etc.
 - done: {action:"done", summary:string} — all visible questions answered correctly
 
+ERROR CORRECTION (CRITICAL):
+- Check <page_context> for "Errors on screen" after each action
+- If errors are visible (wrong answer, validation error, "Incorrect", "Wrong Answer", "Error"), FIX THEM immediately
+- For text inputs with errors: clear and retype the correct answer
+- For code editors with errors: retype the correct code using write_code
+- For radio/checkbox with errors: click the correct option
+- NEVER return "done" if errors are visible on screen
+- Keep running until ALL questions are answered correctly with NO errors
+
+CORRECTION MODE:
+- The <page_context> block shows the current editor content — compare it to the expected answer
+- If editor content is WRONG or INCOMPLETE, type the CORRECT code to replace it
+- If you previously typed wrong code, use write_code to replace with correct code
+- You may be asked the same question multiple times — each time, check if the current answer is correct before acting
+
+PERSONAL QUESTIONS — SKIP THEM:
+- NEVER type answers for questions asking: name, email, phone, address, SSN, password, credit card, date of birth, or any personal information
+- If a question asks for personal info, do NOT click or type — skip it entirely
+- If ALL remaining questions are personal, return done
+
 RESPONSE FORMAT RULES (CRITICAL — follow exactly):
 - Return ONLY a valid JSON array. No explanations, no markdown fences, no extra text.
 - The response MUST be parseable by JSON.parse(). Test mentally: is your output valid JSON?
@@ -121,11 +293,18 @@ async function cmdBrowse(flags) {
         return;
     }
     const port = parseInt(flags.get('port') ?? '9222', 10);
-    const maxActions = parseInt(flags.get('max-actions') ?? '50', 10);
+    const continuous = flags.has('continuous');
+    const maxActions = continuous ? Number.MAX_SAFE_INTEGER : parseInt(flags.get('max-actions') ?? '50', 10);
     const intervalMs = parseInt(flags.get('interval') ?? '2000', 10);
     const modelSpec = flags.get('model') ?? 'mimo:mimo-v2.5';
-    const timeoutSec = Math.min(Math.max(parseInt(flags.get('timeout') ?? '180', 10), 30), 600);
+    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 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');
+    const stealth = flags.has('stealth');
+    const hybrid = flags.has('hybrid');
     // Resolve LLM endpoint
     const resolved = (0, models_1.resolveModel)(modelSpec, process.env.LLM_BASE_URL);
     const apiKey = (0, models_1.resolveApiKeyForProvider)(modelSpec);
@@ -138,9 +317,21 @@ async function cmdBrowse(flags) {
     const model = resolved.model;
     console.log(`[browse] Model: ${modelSpec} -> ${model} @ ${baseUrl}`);
     console.log(`[browse] Chrome port: ${port}`);
-    console.log(`[browse] Max actions: ${maxActions}`);
+    console.log(`[browse] Mode: ${stealth ? 'STEALTH (OS-level, no CDP)' : hybrid ? 'HYBRID (CDP reads + OS-level writes)' : continuous ? 'continuous (runs until Ctrl+C)' : `capped at ${maxActions} actions`}`);
     console.log(`[browse] LLM timeout: ${timeoutSec}s`);
+    if (!stealth) {
+        console.log(`[browse] Screenshot quality: ${quality}`);
+    }
+    console.log(`[browse] Char delay: ${charDelayMs}ms`);
     console.log(`[browse] Screenshot interval: ${intervalMs}ms`);
+    if (!stealth) {
+        console.log(`[browse] Max consecutive failures: ${maxConsecutiveFailures === 0 ? 'unlimited' : maxConsecutiveFailures}`);
+    }
+    // ── Stealth mode: bypass CDP entirely ──
+    if (stealth) {
+        await runStealthLoop(baseUrl, apiKey, model, maxActions, intervalMs, timeoutMs, charDelayMs, continuous);
+        return;
+    }
     // Connect directly to the page's WebSocket (not browser-level)
     let page;
     try {
@@ -163,79 +354,344 @@ async function cmdBrowse(flags) {
     }
     // Agent loop
     let actionCount = 0;
+    let llmCallCount = 0;
     let stopped = false;
     let consecutiveFailures = 0;
-    const maxRetries = 3;
-    const maxConsecutiveFailures = 10;
+    let lastScreenshot = null;
+    let lastFingerprint = null;
+    let codeConfirmedOptimal = false;
+    const maxRetries = 5;
     process.on('SIGINT', () => {
         console.log('\n[browse] Stopped by user');
         stopped = true;
     });
     process.on('SIGTERM', () => { stopped = true; });
-    console.log('[browse] Agent started. Press Ctrl+C to stop.\n');
+    console.log(`[browse] Agent started. ${continuous ? 'Running until Ctrl+C.' : `Max ${maxActions} actions.`} Press Ctrl+C to stop.\n`);
     while (!stopped && actionCount < maxActions) {
         try {
             // Take screenshot and extract elements in parallel
-            const [screenshot, elements] = await Promise.all([
-                captureScreenshot(page),
+            const [screenshot, elements, pageContext] = await Promise.all([
+                captureScreenshot(page, quality),
                 extractElements(page),
+                extractPageContext(page),
             ]);
             if (!screenshot) {
                 console.error('[browse] Failed to capture screenshot, retrying...');
                 await sleep(intervalMs);
                 continue;
             }
+            // Detect screen change via question fingerprint comparison
+            const currentFingerprint = createFingerprint(elements);
+            if (lastFingerprint) {
+                const changeScore = calculateChangeScore(lastFingerprint, currentFingerprint);
+                if (changeScore >= 5) {
+                    console.log(`[browse] Screen changed (score: ${changeScore}) — resetting state`);
+                    codeConfirmedOptimal = false;
+                    consecutiveFailures = 0;
+                }
+            }
+            lastFingerprint = currentFingerprint;
+            lastScreenshot = screenshot;
             console.log(`[browse] Found ${elements.length} interactive elements`);
             // Send to vision LLM with retry logic
-            console.log(`[browse] [${actionCount + 1}/${maxActions}] Analyzing screenshot...`);
+            const actionLabel = continuous ? `${actionCount + 1}/∞` : `${actionCount + 1}/${maxActions}`;
+            console.log(`[browse] [${actionLabel}] Analyzing screenshot...`);
             let result = null;
             for (let attempt = 1; attempt <= maxRetries; attempt++) {
-                result = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, timeoutMs, attempt, maxRetries);
+                result = await analyzeScreenshot(baseUrl, apiKey, model, screenshot, elements, pageContext, timeoutMs, attempt, maxRetries);
+                llmCallCount++;
+                if (llmCallCount > 50 && llmCallCount % 25 === 0) {
+                    console.log(`[browse] Warning: ${llmCallCount} LLM calls made — may hit rate limits`);
+                }
                 if (result.actions.length > 0)
                     break; // success
+                // Timeout → exponential backoff, keep retrying (never count as failure)
+                if (result.error === 'timeout') {
+                    const backoff = Math.min(30 * Math.pow(2, attempt - 1), 300); // 30, 60, 120, 240, 300
+                    console.log(`[browse] LLM timed out — retrying in ${backoff}s (attempt ${attempt}/${maxRetries})...`);
+                    await sleep(backoff * 1000);
+                    continue;
+                }
+                // Other errors → short backoff
                 if (attempt < maxRetries) {
                     const backoff = attempt === 1 ? 3 : 5;
-                    console.log(`[browse] ${result.error === 'timeout' ? 'LLM timed out' : result.error === 'empty' ? 'Empty response' : 'Parse failed'} (attempt ${attempt}/${maxRetries}), retrying in ${backoff}s...`);
+                    console.log(`[browse] ${result.error === 'empty' ? 'Empty response' : 'Parse failed'} (attempt ${attempt}/${maxRetries}), retrying in ${backoff}s...`);
                     await sleep(backoff * 1000);
                 }
             }
             if (!result || result.actions.length === 0) {
                 consecutiveFailures++;
                 console.log(`[browse] No valid response after ${maxRetries} attempts (${consecutiveFailures} consecutive failures)`);
-                if (consecutiveFailures >= maxConsecutiveFailures) {
+                if (maxConsecutiveFailures > 0 && consecutiveFailures >= maxConsecutiveFailures) {
                     console.error(`[browse] Too many consecutive failures (${consecutiveFailures}), stopping agent`);
                     break;
                 }
-                if (consecutiveFailures >= 5) {
-                    console.log(`[browse] Warning: ${consecutiveFailures} consecutive failures — agent may be stuck`);
+                if (consecutiveFailures >= 5 && consecutiveFailures % 5 === 0) {
+                    console.log(`[browse] Warning: ${consecutiveFailures} consecutive failures — still running`);
                 }
                 await sleep(intervalMs);
                 continue;
             }
             // Success — reset consecutive failure counter
             consecutiveFailures = 0;
-            // Process all actions with 2s natural delay between clicks
-            let allAnswered = false;
+            // Pre-execution check: detect if screen changed during LLM call
+            const preActions = result.actions.filter((a) => a.action !== 'done');
+            if (preActions.length > 0) {
+                const [freshScreenshot, freshElements] = await Promise.all([
+                    captureScreenshot(page, quality),
+                    extractElements(page),
+                ]);
+                if (freshScreenshot) {
+                    const freshFingerprint = createFingerprint(freshElements);
+                    if (lastFingerprint) {
+                        const changeScore = calculateChangeScore(lastFingerprint, freshFingerprint);
+                        if (changeScore >= 5) {
+                            console.log(`[browse] Screen changed during LLM call (score: ${changeScore}) — skipping actions, re-analyzing`);
+                            lastFingerprint = freshFingerprint;
+                            lastScreenshot = freshScreenshot;
+                            await sleep(intervalMs);
+                            continue;
+                        }
+                    }
+                }
+            }
+            // Batch multiple write_code actions — use last one (complete solution)
+            const writeCodeActions = result.actions.filter((a) => a.action === 'write_code');
+            if (writeCodeActions.length > 1) {
+                result.actions = result.actions.filter((a) => a.action !== 'write_code');
+                result.actions.push(writeCodeActions[writeCodeActions.length - 1]);
+                console.log(`[browse] ${writeCodeActions.length} write_code actions — using last one (complete solution)`);
+            }
+            // Process all actions
+            let executedAny = false;
+            let wroteCode = false;
             for (const act of result.actions) {
                 if (act.action === 'done') {
-                    console.log(`[browse] Done: ${act.summary || 'All questions answered'}`);
-                    allAnswered = true;
-                    break;
+                    // 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);
+                        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;
+                            }
+                        }
+                        continue;
+                    }
+                    // All questions genuinely answered
+                    if (continuous && !executedAny) {
+                        console.log(`[browse] LLM reports done: ${act.summary || 'All questions answered'}`);
+                        // Log correctness indicators from page context
+                        const correctIndicators = pageContext.match(/correct|accepted|✓|passed|success|well done/gi);
+                        const wrongIndicators = pageContext.match(/incorrect|wrong|✗|failed|error|try again/gi);
+                        if (wrongIndicators) {
+                            console.log(`[browse] Errors detected on screen: ${wrongIndicators.join(', ')} — should be fixed`);
+                        }
+                        else if (correctIndicators) {
+                            console.log(`[browse] Answer verified correct: ${correctIndicators.join(', ')}`);
+                        }
+                        const changed = await waitForScreenChange(page, lastScreenshot ?? screenshot, intervalMs, quality, () => stopped);
+                        if (!changed)
+                            break;
+                        executedAny = false;
+                    }
+                    else {
+                        console.log(`[browse] LLM reports done: ${act.summary || 'All questions answered'} — continuing to verify...`);
+                    }
+                    continue;
+                }
+                // Skip if code was already confirmed optimal (prevents re-typing after optimization pass)
+                if ((act.action === 'write_code' || act.action === 'type') && codeConfirmedOptimal) {
+                    console.log(`[browse] Skipping ${act.action} — code already confirmed optimal`);
+                    continue;
+                }
+                // Ask LLM to decide if action is redundant
+                const redundancy = await isActionRedundant(baseUrl, apiKey, model, page, elements, act, timeoutMs);
+                if (redundancy.decision === 'skip') {
+                    continue;
                 }
-                console.log(`[browse] Action: ${act.action} - ${act.reasoning || ''}`);
-                await executeAction(page, act, elements);
+                if (redundancy.decision === 'partial' && (act.action === 'write_code' || act.action === 'type')) {
+                    // Partial update — only retype the different part
+                    const targetCode = act.action === 'write_code' ? act.code : act.text;
+                    if (targetCode) {
+                        console.log(`[browse] Partial update — only retying changed portion...`);
+                        const currentContent = await readEditorContent(page);
+                        const normCurrent = normalizeCode(currentContent);
+                        const normTarget = normalizeCode(targetCode);
+                        const commonLen = findCommonPrefix(normCurrent, normTarget);
+                        // Find position in original code that corresponds to end of common prefix
+                        const suffix = targetCode.slice(Math.min(commonLen, targetCode.length));
+                        if (suffix.length > 0) {
+                            // Position cursor at end, type only the suffix
+                            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                type: 'keyDown', key: 'End', code: 'End', modifiers: 2,
+                                windowsVirtualKeyCode: 35, nativeVirtualKeyCode: 35,
+                            });
+                            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                type: 'keyUp', key: 'End', code: 'End', modifiers: 2,
+                                windowsVirtualKeyCode: 35, nativeVirtualKeyCode: 35,
+                            });
+                            await sleep(100);
+                            // Select from cursor to end and overwrite
+                            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                type: 'keyDown', key: 'Shift', code: 'ShiftRight', modifiers: 2,
+                                windowsVirtualKeyCode: 16, nativeVirtualKeyCode: 16,
+                            });
+                            // Move to end of document
+                            for (let i = 0; i < 50; i++) {
+                                await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                    type: 'keyDown', key: 'ArrowRight', code: 'ArrowRight',
+                                    windowsVirtualKeyCode: 39, nativeVirtualKeyCode: 39,
+                                });
+                            }
+                            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                type: 'keyUp', key: 'Shift', code: 'ShiftRight', modifiers: 2,
+                                windowsVirtualKeyCode: 16, nativeVirtualKeyCode: 16,
+                            });
+                            // Delete selection
+                            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                type: 'keyDown', key: 'Backspace', code: 'Backspace',
+                                windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
+                            });
+                            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                type: 'keyUp', key: 'Backspace', code: 'Backspace',
+                                windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
+                            });
+                            await sleep(100);
+                            // Type the suffix
+                            for (let i = 0; i < suffix.length; i++) {
+                                const char = suffix[i];
+                                if (char === '\n') {
+                                    await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                        type: 'keyDown', key: 'Enter', code: 'Enter', text: '\r',
+                                        windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+                                    });
+                                    await cdpSend(page, 'Input.dispatchKeyEvent', {
+                                        type: 'keyUp', key: 'Enter', code: 'Enter',
+                                        windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+                                    });
+                                }
+                                else {
+                                    const k = charToKey(char);
+                                    const mods = k.shift ? 2 : undefined;
+                                    const downParams = { type: 'keyDown', key: k.key, code: k.code, text: char };
+                                    const upParams = { type: 'keyUp', key: k.key, code: k.code };
+                                    if (mods !== undefined) {
+                                        downParams.modifiers = mods;
+                                        upParams.modifiers = mods;
+                                    }
+                                    await cdpSend(page, 'Input.dispatchKeyEvent', downParams);
+                                    await cdpSend(page, 'Input.dispatchKeyEvent', upParams);
+                                }
+                                await sleep(variableDelay(charDelayMs, char, i, suffix.length));
+                            }
+                            console.log(`[browse] Partial update complete (${suffix.length} chars typed)`);
+                        }
+                        actionCount++;
+                        executedAny = true;
+                        wroteCode = true;
+                    }
+                    continue;
+                }
+                // Full update — execute the action normally
+                if (act.action === 'type') {
+                    console.log(`[browse] Action: type — ${act.text?.slice(0, 120)}${(act.text?.length ?? 0) > 120 ? '...' : ''}`);
+                }
+                else if (act.action === 'write_code') {
+                    console.log(`[browse] Action: write_code — ${act.code?.slice(0, 120)}${(act.code?.length ?? 0) > 120 ? '...' : ''}`);
+                }
+                else {
+                    console.log(`[browse] Action: ${act.action} - ${act.reasoning || ''}`);
+                }
+                await (hybrid ? executeActionHybrid : executeAction)(page, act, elements, charDelayMs);
                 actionCount++;
-                // 2s delay between clicks for natural feel
-                if (act.action === 'click' || act.action === 'type') {
+                executedAny = true;
+                if (act.action === 'write_code' || act.action === 'type') {
+                    wroteCode = true;
+                }
+                // Natural delay between actions
+                if (act.action === 'click' || act.action === 'type' || act.action === 'write_code') {
                     await sleep(2000);
                 }
             }
-            // Wait between LLM calls
-            if (allAnswered) {
-                console.log('[browse] All answered, waiting for page change...');
-                await sleep(1500);
+            // Optimization pass: if --optimize and code was written, ask LLM to optimize it
+            if (optimize && wroteCode) {
+                console.log('[browse] Running optimization pass...');
+                const [newScreenshot, newElements, newPageContext] = await Promise.all([
+                    captureScreenshot(page, quality),
+                    extractElements(page),
+                    extractPageContext(page),
+                ]);
+                if (newScreenshot) {
+                    const optResult = await analyzeScreenshotWithPrompt(baseUrl, apiKey, model, newScreenshot, newElements, newPageContext, timeoutMs, 1, 1, `You are a code optimization expert. The code in the editor is CORRECT but may not be EFFICIENT.
+
+Review the code and check:
+1. Is it the most time-efficient approach? (O(n log n) or better?)
+2. Are there better data structures to use?
+3. Can nested loops be replaced with HashMap/Set lookups?
+4. Can the solution be optimized with sliding window, two pointers, or binary search?
+
+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.`);
+                    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) {
+                            console.log(`[browse] Optimization found — rewriting code...`);
+                            await (hybrid ? executeActionHybrid : executeAction)(page, { action: 'click', elementIndex: optAct.elementIndex ?? result.actions[0].elementIndex }, newElements, charDelayMs);
+                            await sleep(500);
+                            await (hybrid ? executeActionHybrid : executeAction)(page, optAct, newElements, charDelayMs);
+                            actionCount++;
+                            await sleep(2000);
+                        }
+                        else {
+                            console.log('[browse] No actionable optimization returned — keeping original');
+                        }
+                    }
+                    else {
+                        console.log('[browse] Code is already optimal — no changes needed');
+                        codeConfirmedOptimal = true;
+                    }
+                }
+            }
+            // Cooldown after code was written — give user time to see result and navigate
+            if (wroteCode) {
+                console.log('[browse] Code written — cooling down 30s before next check...');
+                await sleep(30000);
+                // After cooldown, check for test results on screen
+                const [, postElements, postContext] = await Promise.all([
+                    captureScreenshot(page, quality),
+                    extractElements(page),
+                    extractPageContext(page),
+                ]);
+                if (postContext) {
+                    const failedIndicators = postContext.match(/wrong answer|time limit exceeded|runtime error|compile error|undefined is not|cannot read property|segmentation fault|n\s*\/\s*m/gi);
+                    const passedIndicators = postContext.match(/accepted|all test cases passed|✓ passed|runtime:\s*\d+\s*ms/gi);
+                    if (failedIndicators) {
+                        console.log(`[browse] Test FAILED: ${failedIndicators.join(', ')} — will retry this question`);
+                        codeConfirmedOptimal = false; // allow re-typing with fix
+                        // Don't wait for screen change — loop again to fix the error
+                    }
+                    else if (passedIndicators) {
+                        console.log(`[browse] Test PASSED: ${passedIndicators.join(', ')}`);
+                    }
+                }
             }
             else {
+                // Wait between LLM calls
                 await sleep(2000);
             }
         }
@@ -244,7 +700,7 @@ async function cmdBrowse(flags) {
             await sleep(intervalMs);
         }
     }
-    if (actionCount >= maxActions) {
+    if (actionCount >= maxActions && !continuous) {
         console.log(`[browse] Reached max actions (${maxActions})`);
     }
     console.log(`[browse] Agent finished. ${actionCount} actions performed.`);
@@ -330,9 +786,9 @@ function cdpSend(page, method, params) {
         page.ws.send(JSON.stringify({ id, method, params }));
     });
 }
-async function captureScreenshot(page) {
+async function captureScreenshot(page, quality) {
     try {
-        const result = await cdpSend(page, 'Page.captureScreenshot', { format: 'jpeg', quality: 70 });
+        const result = await cdpSend(page, 'Page.captureScreenshot', { format: 'jpeg', quality });
         return result?.data ?? null;
     }
     catch (err) {
@@ -383,6 +839,7 @@ async function extractElements(page) {
           checked: el.checked || el.getAttribute('aria-checked') === 'true' || false,
           x: Math.round(rect.x + rect.width / 2),
           y: Math.round(rect.y + rect.height / 2),
+          inViewport: rect.bottom >= 0 && rect.top <= window.innerHeight && rect.right >= 0 && rect.left <= window.innerWidth,
           groupId: null,
         });
       });
@@ -490,6 +947,7 @@ async function extractElements(page) {
           x: item.x,
           y: item.y,
           group: item.groupId,
+          inViewport: item.inViewport,
         });
       });
 
@@ -507,17 +965,29 @@ async function extractElements(page) {
         return [];
     }
 }
-async function executeAction(page, act, elements) {
+async function executeAction(page, act, elements, charDelayMs) {
     try {
         switch (act.action) {
             case 'click': {
                 if (act.elementIndex === undefined)
                     return false;
-                const el = elements.find((e) => e.i === act.elementIndex);
+                let el = elements.find((e) => e.i === act.elementIndex);
                 if (!el) {
                     console.log(`[browse] Element index ${act.elementIndex} not found, will retry`);
                     return false;
                 }
+                // Scroll off-screen element into view before clicking
+                if (!el.inViewport) {
+                    console.log(`[browse] Element ${el.i} off-screen — scrolling to "${el.text?.slice(0, 30)}"...`);
+                    await scrollElementIntoView(page, el);
+                    // Re-extract elements to get updated coordinates
+                    const updatedElements = await extractElements(page);
+                    const updatedEl = updatedElements.find((e) => e.text === el.text && e.type === el.type && e.group === el.group);
+                    if (updatedEl) {
+                        el = updatedEl;
+                        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})`);
                 await cdpSend(page, 'Input.dispatchMouseEvent', {
                     type: 'mousePressed', x: el.x, y: el.y, button: 'left', clickCount: 1,
@@ -537,140 +1007,52 @@ async function executeAction(page, act, elements) {
                 }
                 // 1. Detect editor type
                 const editor = await detectEditor(page);
-                const isMonaco = editor?.type === 'monaco';
                 const isCodeEditor = editor !== null;
                 if (editor)
                     console.log(`[browse] Detected editor: ${editor.type}`);
                 // 2. Unescape LLM text: convert literal \n, \t, \\", etc. to real characters
-                const text = act.text
+                const rawText = act.text
                     .replace(/\\n/g, '\n')
                     .replace(/\\t/g, '\t')
                     .replace(/\\"/g, '"')
                     .replace(/\\\\/g, '\\');
+                // 3. Normalize indentation for code editors (LLM often adds extra indent)
+                const text = isCodeEditor ? normalizeCodeIndent(rawText) : rawText;
                 console.log(`[browse] Typing ${text.length} characters...`);
-                if (isMonaco) {
-                    // ── Monaco path: keyboard-only, no mouse clicks (clicks select content) ──
-                    // 1. Focus the hidden textarea via JS
-                    await focusSelector(page, editor.selector);
-                    await sleep(200);
-                    // 2. Clear: Ctrl+A → wait → Backspace (works when textarea has focus)
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyDown', key: 'a', code: 'KeyA', modifiers: 2,
-                        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyUp', key: 'a', code: 'KeyA', modifiers: 2,
-                        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
-                    });
-                    await sleep(200);
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyDown', key: 'Backspace', code: 'Backspace',
-                        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyUp', key: 'Backspace', code: 'Backspace',
-                        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
-                    });
-                    await sleep(200);
-                    // 3. Re-focus textarea (Monaco may have stolen focus during Ctrl+A/Backspace)
-                    await focusSelector(page, editor.selector);
-                    await sleep(100);
-                    // 4. Insert full text via Input.insertText — works for ALL chars including \n
-                    await cdpSend(page, 'Input.insertText', { text });
+                if (isCodeEditor) {
+                    await insertIntoCodeEditor(page, editor.selector, text, charDelayMs);
+                }
+                else {
+                    await insertIntoGenericInput(page, el, text, charDelayMs);
                 }
-                else if (isCodeEditor) {
-                    // ── Other code editors: focus via JS .focus(), char-by-char ──
-                    await focusSelector(page, editor.selector);
-                    await sleep(200);
-                    // Ctrl+A + Backspace to clear
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyDown', key: 'a', code: 'KeyA', modifiers: 2,
-                        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyUp', key: 'a', code: 'KeyA', modifiers: 2,
-                        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyDown', key: 'Backspace', code: 'Backspace',
-                        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyUp', key: 'Backspace', code: 'Backspace',
-                        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
-                    });
-                    await sleep(200);
-                    // Type entire text via insertText
-                    await cdpSend(page, 'Input.insertText', { text });
+                return true;
+            }
+            case 'write_code': {
+                if (act.elementIndex === undefined || !act.code)
+                    break;
+                const el = elements.find((e) => e.i === act.elementIndex);
+                if (!el) {
+                    console.log(`[browse] Element index ${act.elementIndex} not found, will retry`);
+                    return false;
+                }
+                // 1. Detect editor type
+                const editor = await detectEditor(page);
+                const isCodeEditor = editor !== null;
+                if (editor)
+                    console.log(`[browse] Detected editor: ${editor.type}`);
+                // 2. Unescape LLM code: convert literal \n, \t, \\", etc. to real characters
+                const text = act.code
+                    .replace(/\\n/g, '\n')
+                    .replace(/\\t/g, '\t')
+                    .replace(/\\"/g, '"')
+                    .replace(/\\\\/g, '\\');
+                console.log(`[browse] Writing code (${text.length} chars)...`);
+                // 3. write_code inserts EXACTLY as-is — no normalizeCodeIndent
+                if (isCodeEditor) {
+                    await insertIntoCodeEditor(page, editor.selector, text, charDelayMs);
                 }
                 else {
-                    // ── Generic inputs: click to focus, char-by-char with keyDown/keyUp ──
-                    await cdpSend(page, 'Input.dispatchMouseEvent', {
-                        type: 'mousePressed', x: el.x, y: el.y, button: 'left', clickCount: 1,
-                    });
-                    await cdpSend(page, 'Input.dispatchMouseEvent', {
-                        type: 'mouseReleased', x: el.x, y: el.y, button: 'left', clickCount: 1,
-                    });
-                    await sleep(200);
-                    // Ctrl+A + Backspace to clear
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyDown', key: 'a', code: 'KeyA', modifiers: 2,
-                        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyUp', key: 'a', code: 'KeyA', modifiers: 2,
-                        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyDown', key: 'Backspace', code: 'Backspace',
-                        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
-                    });
-                    await cdpSend(page, 'Input.dispatchKeyEvent', {
-                        type: 'keyUp', key: 'Backspace', code: 'Backspace',
-                        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
-                    });
-                    await sleep(200);
-                    // Char-by-char typing with natural timing
-                    for (let i = 0; i < text.length; i++) {
-                        const char = text[i];
-                        if (char === '\n') {
-                            await cdpSend(page, 'Input.dispatchKeyEvent', {
-                                type: 'keyDown', key: 'Enter', code: 'Enter',
-                                windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
-                            });
-                            await cdpSend(page, 'Input.dispatchKeyEvent', {
-                                type: 'keyUp', key: 'Enter', code: 'Enter',
-                                windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
-                            });
-                        }
-                        else if (char === '\t') {
-                            await cdpSend(page, 'Input.dispatchKeyEvent', {
-                                type: 'keyDown', key: 'Tab', code: 'Tab',
-                                windowsVirtualKeyCode: 9, nativeVirtualKeyCode: 9,
-                            });
-                            await cdpSend(page, 'Input.dispatchKeyEvent', {
-                                type: 'keyUp', key: 'Tab', code: 'Tab',
-                                windowsVirtualKeyCode: 9, nativeVirtualKeyCode: 9,
-                            });
-                        }
-                        else {
-                            const k = charToKey(char);
-                            const mods = k.shift ? 2 : undefined;
-                            const downParams = {
-                                type: 'keyDown', key: k.key, code: k.code, text: char,
-                            };
-                            const upParams = {
-                                type: 'keyUp', key: k.key, code: k.code,
-                            };
-                            if (mods !== undefined) {
-                                downParams.modifiers = mods;
-                                upParams.modifiers = mods;
-                            }
-                            await cdpSend(page, 'Input.dispatchKeyEvent', downParams);
-                            await cdpSend(page, 'Input.dispatchKeyEvent', upParams);
-                        }
-                        await sleep(charDelay(char, i, text.length));
-                    }
+                    await insertIntoGenericInput(page, el, text, charDelayMs);
                 }
                 return true;
             }
@@ -704,6 +1086,115 @@ async function executeAction(page, act, elements) {
         return false;
     }
 }
+/**
+ * Hybrid action executor: OS-level keyboard/mouse for writing (invisible to detection).
+ * Same logic as executeAction but uses clickOS/typeHumanLike/scrollOS/pressKeyOS.
+ */
+async function executeActionHybrid(page, act, elements, charDelayMs) {
+    try {
+        switch (act.action) {
+            case 'click': {
+                if (act.elementIndex === undefined)
+                    return false;
+                let el = elements.find((e) => e.i === act.elementIndex);
+                if (!el) {
+                    console.log(`[browse] Element index ${act.elementIndex} not found, will retry`);
+                    return false;
+                }
+                // Scroll off-screen element into view before clicking
+                if (!el.inViewport) {
+                    console.log(`[browse] Element ${el.i} off-screen — scrolling to "${el.text?.slice(0, 30)}"...`);
+                    await scrollElementIntoView(page, el);
+                    // Re-extract elements to get updated coordinates
+                    const updatedElements = await extractElements(page);
+                    const updatedEl = updatedElements.find((e) => e.text === el.text && e.type === el.type && e.group === el.group);
+                    if (updatedEl) {
+                        el = updatedEl;
+                        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);
+                return true;
+            }
+            case 'type': {
+                if (act.elementIndex === undefined || !act.text)
+                    break;
+                const el = elements.find((e) => e.i === act.elementIndex);
+                if (!el) {
+                    console.log(`[browse] Element index ${act.elementIndex} not found, will retry`);
+                    return false;
+                }
+                const editor = await detectEditor(page);
+                const isCodeEditor = editor !== null;
+                if (editor)
+                    console.log(`[browse] Detected editor: ${editor.type}`);
+                const rawText = act.text
+                    .replace(/\\n/g, '\n')
+                    .replace(/\\t/g, '\t')
+                    .replace(/\\"/g, '"')
+                    .replace(/\\\\/g, '\\');
+                const text = isCodeEditor ? normalizeCodeIndent(rawText) : rawText;
+                console.log(`[browse] Typing ${text.length} characters (OS-level)...`);
+                await sleep(randomInt(200, 400));
+                clickOS(el.x, el.y);
+                await sleep(randomInt(100, 200));
+                if (isCodeEditor) {
+                    pressKeyOS('ctrl+a');
+                    await sleep(randomInt(50, 100));
+                }
+                await typeHumanLike(text, charDelayMs);
+                return true;
+            }
+            case 'write_code': {
+                if (act.elementIndex === undefined || !act.code)
+                    break;
+                const el = elements.find((e) => e.i === act.elementIndex);
+                if (!el) {
+                    console.log(`[browse] Element index ${act.elementIndex} not found, will retry`);
+                    return false;
+                }
+                const editor = await detectEditor(page);
+                const isCodeEditor = editor !== null;
+                if (editor)
+                    console.log(`[browse] Detected editor: ${editor.type}`);
+                const text = act.code
+                    .replace(/\\n/g, '\n')
+                    .replace(/\\t/g, '\t')
+                    .replace(/\\"/g, '"')
+                    .replace(/\\\\/g, '\\');
+                console.log(`[browse] Writing code (${text.length} chars, OS-level)...`);
+                await sleep(randomInt(200, 400));
+                clickOS(el.x, el.y);
+                await sleep(randomInt(100, 200));
+                if (isCodeEditor) {
+                    pressKeyOS('ctrl+a');
+                    await sleep(randomInt(50, 100));
+                }
+                await typeHumanLike(text, charDelayMs);
+                return true;
+            }
+            case 'scroll': {
+                const delta = act.delta ?? 3;
+                console.log(`[browse] Scrolling ${delta > 0 ? 'down' : 'up'} (${Math.abs(delta)} clicks, OS-level)...`);
+                scrollOS(-delta);
+                break;
+            }
+            case 'press': {
+                if (!act.key)
+                    break;
+                console.log(`[browse] Pressing ${act.key} (OS-level)...`);
+                pressKeyOS(act.key.toLowerCase());
+                break;
+            }
+        }
+        return true;
+    }
+    catch (err) {
+        console.error(`[browse] Action error: ${(0, config_1.msg)(err)}`);
+        return false;
+    }
+}
 // ── Key mapping for CDP keyboard events ──────────────────────────────────────
 /** Maps a character to its CDP key/code/shift properties. */
 function charToKey(c) {
@@ -759,24 +1250,596 @@ function charToKey(c) {
     // Fallback — use the char itself
     return { key: c, code: c, shift: false };
 }
-// ── Natural typing timing ────────────────────────────────────────────────────
-/** Delay in ms before typing the next character (average typer profile). */
-function charDelay(char, index, total) {
-    const base = 80 + Math.random() * 90; // 80-170ms (35-55 WPM)
-    // Spaces — micro-pause at word boundary
+// ── Code indentation normalization ─────────────────────────────────────────
+/**
+ * Strips the common leading whitespace from all non-empty lines.
+ * Fixes LLM output that has consistent extra indentation (e.g. 8 spaces
+ * instead of 4). The relative indentation between lines is preserved.
+ */
+function normalizeCodeIndent(text) {
+    const lines = text.split('\n');
+    const nonEmpty = lines.filter((l) => l.trim().length > 0);
+    if (nonEmpty.length <= 1)
+        return text;
+    // Find the minimum leading whitespace across all non-empty lines
+    const minIndent = nonEmpty.reduce((min, line) => {
+        const match = line.match(/^(\s*)/);
+        return Math.min(min, match?.[1]?.length ?? 0);
+    }, Infinity);
+    if (minIndent === 0 || minIndent === Infinity)
+        return text;
+    return lines
+        .map((line) => {
+        if (line.trim().length === 0)
+            return line;
+        return line.slice(minIndent);
+    })
+        .join('\n');
+}
+// ── Editor insertion helpers ───────────────────────────────────────────────
+/** Clear editor content: Ctrl+A → Backspace. */
+async function clearEditor(page) {
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyDown', key: 'a', code: 'KeyA', modifiers: 2,
+        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
+    });
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyUp', key: 'a', code: 'KeyA', modifiers: 2,
+        windowsVirtualKeyCode: 65, nativeVirtualKeyCode: 65,
+    });
+    await sleep(100);
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyDown', key: 'Backspace', code: 'Backspace',
+        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
+    });
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyUp', key: 'Backspace', code: 'Backspace',
+        windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
+    });
+}
+/** Read current editor content from Monaco/CM5/CM6/Ace. */
+async function readEditorContent(page) {
+    try {
+        const result = await cdpSend(page, 'Runtime.evaluate', {
+            expression: `
+        (() => {
+          const monacoNs = typeof monaco !== 'undefined' ? monaco : window.monaco;
+          const editors = monacoNs?.editor?.getEditors?.() || [];
+          if (editors.length > 0) return editors[0].getValue();
+          const cm6 = document.querySelector('.cm-content');
+          if (cm6?.cmView?.view) return cm6.cmView.view.state.doc.toString();
+          const cm5 = document.querySelector('.CodeMirror')?.CodeMirror;
+          if (cm5) return cm5.getValue();
+          const ace = document.querySelector('.ace_editor')?.env?.editor;
+          if (ace) return ace.getValue();
+          return '';
+        })()
+      `,
+            returnByValue: true,
+        });
+        return result?.result?.value ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+/** 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: `
+      (() => {
+        const sels = [
+          'input[type="radio"]', 'input[type="checkbox"]',
+          'input[type="text"]', 'input[type="email"]', 'input[type="password"]',
+          'input:not([type])', 'textarea', 'select', 'button', 'a',
+          '[role="radio"]', '[role="checkbox"]', '[role="button"]',
+          '[role="option"]', '[role="tab"]', '[role="menuitem"]', 'label',
+        ];
+        const all = [...document.querySelectorAll(sels.join(','))];
+        const target = all.find(el => {
+          const t = (el.innerText || el.textContent || '').trim().replace(/\\s+/g, ' ').slice(0, 100);
+          return t === ${JSON.stringify(textSlice)};
+        });
+        if (target) {
+          target.scrollIntoView({ behavior: 'instant', block: 'center' });
+          return true;
+        }
+        return false;
+      })()
+    `,
+        returnByValue: true,
+    });
+    await sleep(300);
+}
+/** Check if there are genuinely unanswered questions — catches premature 'done' from LLM. */
+function hasUnansweredQuestions(elements) {
+    const groups = new Map();
+    for (const el of elements) {
+        if (!groups.has(el.group))
+            groups.set(el.group, []);
+        groups.get(el.group).push(el);
+    }
+    for (const [, els] of groups) {
+        const types = els.map((e) => e.type);
+        const isRadio = types.some((t) => t === 'radio');
+        const isCheckbox = types.some((t) => t === 'checkbox');
+        const hasInput = els.some((e) => e.tag === 'input' || e.tag === 'textarea');
+        const checkedCount = els.filter((e) => e.checked).length;
+        if (isRadio && checkedCount === 0)
+            return true;
+        if (isCheckbox && checkedCount < els.length)
+            return true;
+        if (hasInput && !els.some((e) => e.text && e.tag === 'input'))
+            return true;
+    }
+    return false;
+}
+/** Normalize code for fuzzy comparison — strip whitespace, normalize quotes. */
+function normalizeCode(code) {
+    return code
+        .replace(/\s+/g, '')
+        .replace(/['`]/g, '"')
+        .replace(/;$/gm, '')
+        .trim();
+}
+/** Find how many leading characters two strings share. */
+function findCommonPrefix(a, b) {
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i])
+        i++;
+    return i;
+}
+/** Ask the LLM to decide if an action is redundant — is the current code already correct? */
+async function isActionRedundant(baseUrl, apiKey, model, page, elements, action, timeoutMs) {
+    // Click on already-selected radio → definitely redundant
+    if (action.action === 'click' && action.elementIndex !== undefined) {
+        const el = elements[action.elementIndex];
+        if (el?.type === 'radio' && el.checked) {
+            console.log(`[browse] Skipping click — radio already selected: "${el.text?.slice(0, 40)}"`);
+            return { decision: 'skip', reason: 'Radio already selected' };
+        }
+        return { decision: 'full', reason: 'Action needed' };
+    }
+    // For write_code/type → read current content and ask LLM
+    const targetCode = action.action === 'write_code' ? action.code : action.text;
+    if (!targetCode || targetCode.length < 20) {
+        return { decision: 'full', reason: 'Short input, always type' };
+    }
+    const currentContent = await readEditorContent(page);
+    if (!currentContent) {
+        return { decision: 'full', reason: 'Editor empty' };
+    }
+    // Quick exact check first
+    if (currentContent === targetCode) {
+        console.log(`[browse] Skipping ${action.action} — code is identical`);
+        return { decision: 'skip', reason: 'Identical' };
+    }
+    // Quick normalized check (fast fallback, no API call needed)
+    const normCurrent = normalizeCode(currentContent);
+    const normTarget = normalizeCode(targetCode);
+    if (normCurrent === normTarget) {
+        console.log(`[browse] Skipping ${action.action} — code is semantically identical (formatting only)`);
+        return { decision: 'skip', reason: 'Semantically identical' };
+    }
+    // Calculate match percentage for prefix check
+    const commonLen = findCommonPrefix(normCurrent, normTarget);
+    const matchPercent = Math.round((commonLen / Math.max(normCurrent.length, normTarget.length)) * 100);
+    // If >90% match, it's likely just a small change → partial update
+    if (matchPercent > 90) {
+        console.log(`[browse] Code is ${matchPercent}% similar — partial update possible`);
+        return { decision: 'partial', reason: `${matchPercent}% match`, matchPercent };
+    }
+    // Ask the LLM to judge
+    console.log(`[browse] Code is ${matchPercent}% similar — asking LLM to judge...`);
+    const prompt = `You are a code comparison expert. Two versions of code are provided.
+
+CURRENT editor content (truncated to first 500 chars):
+\`\`\`
+${currentContent.slice(0, 500)}
+\`\`\`
+
+TARGET code to write (truncated to first 500 chars):
+\`\`\`
+${targetCode.slice(0, 500)}
+\`\`\`
+
+The user wants to write the TARGET code into the editor.
+
+TASK: Compare these two code versions. Are they semantically the same (same logic, same algorithm)? Ignore whitespace, formatting, variable naming differences. Focus on LOGIC.
+
+Return EXACTLY one JSON object:
+- {"decision":"skip","reason":"..."} — if the current code is already correct (same logic)
+- {"decision":"partial","reason":"..."} — if mostly correct, only small changes needed
+- {"decision":"full","reason":"..."} — if completely different code is needed
+
+Return ONLY the JSON. No other text.`;
+    try {
+        const body = {
+            model,
+            messages: [
+                { role: 'system', content: prompt },
+                { role: 'user', content: 'Compare the two code versions and return your decision as JSON.' },
+            ],
+            temperature: 0.1,
+            max_tokens: 200,
+            stream: false,
+        };
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 30000));
+        const res = await fetch(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+                'api-key': apiKey,
+            },
+            body: JSON.stringify(body),
+        });
+        clearTimeout(timeout);
+        if (!res.ok) {
+            console.log(`[browse] Redundancy check API failed (${res.status}) — defaulting to full update`);
+            return { decision: 'full', reason: 'API failed', matchPercent };
+        }
+        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('');
+        }
+        // Parse the JSON response
+        const match = content.match(/\{[^}]+\}/);
+        if (match) {
+            const parsed = JSON.parse(match[0]);
+            console.log(`[browse] LLM decision: ${parsed.decision} — ${parsed.reason}`);
+            return { ...parsed, matchPercent };
+        }
+    }
+    catch (err) {
+        console.log(`[browse] Redundancy check failed: ${(0, config_1.msg)(err)} — defaulting to full update`);
+    }
+    return { decision: 'full', reason: 'Fallback', matchPercent };
+}
+/** Wait for the page to change by comparing screenshots periodically. Returns true if changed, false if stopped. */
+async function waitForScreenChange(page, previousScreenshot, intervalMs, quality, stopped) {
+    console.log('[browse] Waiting for screen change... (Ctrl+C to stop)');
+    while (!stopped()) {
+        await sleep(intervalMs);
+        if (stopped())
+            break;
+        const newScreenshot = await captureScreenshot(page, quality);
+        if (newScreenshot && newScreenshot !== previousScreenshot) {
+            console.log('[browse] Screen changed — resuming...');
+            return true;
+        }
+    }
+    return false;
+}
+/** Variable typing delay — random variation for natural feel. Never faster than 70% of base. */
+function variableDelay(baseMs, char, index, total) {
+    let delay = baseMs + (Math.random() - 0.5) * baseMs * 0.6;
     if (char === ' ')
-        return base + 20 + Math.random() * 60;
-    // Numbers — slightly slower
+        delay += 20 + Math.random() * 60;
     if (/[0-9]/.test(char))
-        return base + 10 + Math.random() * 30;
-    // Shift characters — shift key overhead
+        delay += 10 + Math.random() * 30;
     if (/^[{}():"<>!@#$%^&*_+|~`?\[\]]$/.test(char))
-        return base + 50 + Math.random() * 120;
-    // Occasional "think" pause every 15-25 chars
+        delay += 50 + Math.random() * 120;
     if (index > 0 && index % (15 + Math.floor(Math.random() * 10)) === 0) {
-        return 200 + Math.random() * 300;
+        delay += 200 + Math.random() * 500;
+    }
+    return Math.max(delay, baseMs * 0.7);
+}
+/**
+ * Detect and remove extra trailing closing brackets in the editor.
+ * Handles: } } } → removes extras, keeps correct one.
+ */
+async function removeTrailingBrackets(page) {
+    const content = await readEditorContent(page);
+    if (!content)
+        return;
+    // Count trailing closing brackets
+    const trailing = content.match(/[\}\)\]]+$/)?.[0] ?? '';
+    if (!trailing || trailing.length === 0)
+        return;
+    // Count opening brackets in the full content
+    let opens = 0;
+    let closes = 0;
+    for (const c of content) {
+        if (c === '{' || c === '(' || c === '[')
+            opens++;
+        if (c === '}' || c === ')' || c === ']')
+            closes++;
+    }
+    const extra = closes - opens;
+    if (extra <= 0)
+        return;
+    // Move to end of editor
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyDown', key: 'End', code: 'End', modifiers: 2,
+        windowsVirtualKeyCode: 35, nativeVirtualKeyCode: 35,
+    });
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyUp', key: 'End', code: 'End', modifiers: 2,
+        windowsVirtualKeyCode: 35, nativeVirtualKeyCode: 35,
+    });
+    await sleep(100);
+    // Press Backspace extra times
+    for (let i = 0; i < extra; i++) {
+        await cdpSend(page, 'Input.dispatchKeyEvent', {
+            type: 'keyDown', key: 'Backspace', code: 'Backspace',
+            windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
+        });
+        await cdpSend(page, 'Input.dispatchKeyEvent', {
+            type: 'keyUp', key: 'Backspace', code: 'Backspace',
+            windowsVirtualKeyCode: 8, nativeVirtualKeyCode: 8,
+        });
+        await sleep(50);
+    }
+    console.log(`[browse] Removed ${extra} extra trailing bracket(s)`);
+}
+/** Insert text into ANY code editor — character-by-character typing, no pasting. */
+async function insertIntoCodeEditor(page, selector, text, charDelayMs) {
+    // Focus the editor
+    await focusSelector(page, selector);
+    await sleep(100);
+    // Dismiss any autocomplete popup
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyDown', key: 'Escape', code: 'Escape',
+        windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 27,
+    });
+    await cdpSend(page, 'Input.dispatchKeyEvent', {
+        type: 'keyUp', key: 'Escape', code: 'Escape',
+        windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 27,
+    });
+    await sleep(100);
+    // Disable ALL auto-formatting to prevent cascading indentation
+    await cdpSend(page, 'Runtime.evaluate', {
+        expression: `
+      (() => {
+        const monacoNs = typeof monaco !== 'undefined' ? monaco : window.monaco;
+        monacoNs?.editor?.getEditors?.().forEach(e => e.updateOptions({
+          autoIndent: false,
+          formatOnType: false,
+          autoClosingBrackets: 'never',
+          autoSurround: 'never',
+          tabSize: 2,
+          detectIndentation: false,
+        }));
+        const cm5 = document.querySelector('.CodeMirror')?.CodeMirror;
+        if (cm5) cm5.setOption('electricChars', false);
+        const ace = document.querySelector('.ace_editor')?.env?.editor;
+        if (ace) {
+          ace.setOption('autoScrollEditorIntoView', false);
+          ace.setOption(' behavioursEnabled', false);
+        }
+      })()
+    `,
+    });
+    // Smart retry: check if editor already has the correct code
+    const currentContent = await readEditorContent(page);
+    if (currentContent === text) {
+        console.log('[browse] Code already correct — skipping re-type');
+        return;
+    }
+    // Focus + clear existing content
+    await focusSelector(page, selector);
+    await sleep(100);
+    await clearEditor(page);
+    await sleep(100);
+    // Re-focus after clear
+    await focusSelector(page, selector);
+    await sleep(100);
+    // Type character by character — NO pasting
+    const est = Math.round(text.length * charDelayMs / 1000);
+    console.log(`[browse] Typing ${text.length} chars (~${est}s est.)...`);
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === '\n') {
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyDown', key: 'Enter', code: 'Enter', text: '\r',
+                windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+            });
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyUp', key: 'Enter', code: 'Enter',
+                windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+            });
+        }
+        else if (char === '\t') {
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyDown', key: 'Tab', code: 'Tab', text: '\t',
+                windowsVirtualKeyCode: 9, nativeVirtualKeyCode: 9,
+            });
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyUp', key: 'Tab', code: 'Tab',
+                windowsVirtualKeyCode: 9, nativeVirtualKeyCode: 9,
+            });
+        }
+        else {
+            const k = charToKey(char);
+            const mods = k.shift ? 2 : undefined;
+            const downParams = {
+                type: 'keyDown', key: k.key, code: k.code, text: char,
+            };
+            const upParams = {
+                type: 'keyUp', key: k.key, code: k.code,
+            };
+            if (mods !== undefined) {
+                downParams.modifiers = mods;
+                upParams.modifiers = mods;
+            }
+            await cdpSend(page, 'Input.dispatchKeyEvent', downParams);
+            await cdpSend(page, 'Input.dispatchKeyEvent', upParams);
+        }
+        await sleep(variableDelay(charDelayMs, char, i, text.length));
+    }
+    // Post-typing: detect and remove extra trailing brackets
+    await removeTrailingBrackets(page);
+    // Re-enable auto-formatting
+    await cdpSend(page, 'Runtime.evaluate', {
+        expression: `
+      (() => {
+        const monacoNs = typeof monaco !== 'undefined' ? monaco : window.monaco;
+        monacoNs?.editor?.getEditors?.().forEach(e => e.updateOptions({
+          autoIndent: true,
+          formatOnType: true,
+          autoClosingBrackets: 'languageDefined',
+          autoSurround: 'languageDefined',
+          detectIndentation: true,
+        }));
+        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. */
+async function insertIntoGenericInput(page, el, text, charDelayMs) {
+    await cdpSend(page, 'Input.dispatchMouseEvent', {
+        type: 'mousePressed', x: el.x, y: el.y, button: 'left', clickCount: 1,
+    });
+    await cdpSend(page, 'Input.dispatchMouseEvent', {
+        type: 'mouseReleased', x: el.x, y: el.y, button: 'left', clickCount: 1,
+    });
+    await sleep(200);
+    await clearEditor(page);
+    await sleep(200);
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === '\n') {
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyDown', key: 'Enter', code: 'Enter', text: '\r',
+                windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+            });
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyUp', key: 'Enter', code: 'Enter',
+                windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+            });
+        }
+        else if (char === '\t') {
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyDown', key: 'Tab', code: 'Tab', text: '\t',
+                windowsVirtualKeyCode: 9, nativeVirtualKeyCode: 9,
+            });
+            await cdpSend(page, 'Input.dispatchKeyEvent', {
+                type: 'keyUp', key: 'Tab', code: 'Tab',
+                windowsVirtualKeyCode: 9, nativeVirtualKeyCode: 9,
+            });
+        }
+        else {
+            const k = charToKey(char);
+            const mods = k.shift ? 2 : undefined;
+            const downParams = {
+                type: 'keyDown', key: k.key, code: k.code, text: char,
+            };
+            const upParams = {
+                type: 'keyUp', key: k.key, code: k.code,
+            };
+            if (mods !== undefined) {
+                downParams.modifiers = mods;
+                upParams.modifiers = mods;
+            }
+            await cdpSend(page, 'Input.dispatchKeyEvent', downParams);
+            await cdpSend(page, 'Input.dispatchKeyEvent', upParams);
+        }
+        await sleep(variableDelay(charDelayMs, char, i, text.length));
+    }
+}
+/**
+ * Extract page context for the LLM: title, URL, headings, errors, editor content.
+ * This gives the LLM full visibility into what's on screen.
+ */
+async function extractPageContext(page) {
+    const js = `
+    (() => {
+      const ctx = [];
+      // Title + URL
+      ctx.push('Title: ' + (document.title || 'unknown'));
+      ctx.push('URL: ' + window.location.href);
+      // Headings
+      const headings = [...document.querySelectorAll('h1,h2,h3,h4,h5,h6')]
+        .map(h => h.textContent?.trim())
+        .filter(Boolean)
+        .slice(0, 10);
+      if (headings.length) ctx.push('Headings: ' + JSON.stringify(headings));
+      // Errors / alerts / toasts / notifications
+      const errSels = [
+        '[role="alert"]', '[role="status"]',
+        '[class*="error"]', '[class*="Error"]',
+        '[class*="toast"]', '[class*="Toast"]',
+        '[class*="alert"]', '[class*="Alert"]',
+        '[class*="banner"]', '[class*="Banner"]',
+        '[class*="notification"]', '[class*="Notification"]',
+        '[class*="danger"]', '[class*="warning"]',
+        '[class*="inline-error"]', '[class*="field-error"]',
+        '[class*="form-error"]', '[class*="validation-error"]',
+        '[data-sonner-toaster] [data-sonner-toast]',
+        '.alert-danger', '.alert-warning', '.alert-error',
+        '.text-red', '.text-danger', '.text-error',
+        '[class*="err-msg"]', '[class*="error-msg"]', '[class*="error-message"]',
+      ];
+      const errors = [];
+      document.querySelectorAll(errSels.join(',')).forEach(el => {
+        const text = el.innerText?.trim().replace(/\\s+/g, ' ').slice(0, 200);
+        if (text && text.length > 2) errors.push(text);
+      });
+      if (errors.length) {
+        ctx.push('Errors on screen:');
+        errors.slice(0, 5).forEach(e => ctx.push('  - ' + e));
+      }
+      // Code editor content
+      let editorContent = null;
+      // Monaco
+      const monacoNs = typeof monaco !== 'undefined' ? monaco : window.monaco;
+      const editors = monacoNs?.editor?.getEditors?.() || [];
+      if (editors.length > 0) editorContent = editors[0].getValue();
+      // CodeMirror 6
+      if (!editorContent) {
+        const cm6 = document.querySelector('.cm-content');
+        if (cm6?.cmView?.view) editorContent = cm6.cmView.view.state.doc.toString();
+      }
+      // CodeMirror 5
+      if (!editorContent) {
+        const cm5 = document.querySelector('.CodeMirror')?.CodeMirror;
+        if (cm5) editorContent = cm5.getValue();
+      }
+      // Ace
+      if (!editorContent) {
+        const ace = document.querySelector('.ace_editor')?.env?.editor;
+        if (ace) editorContent = ace.getValue();
+      }
+      if (editorContent && editorContent.trim().length > 0) {
+        ctx.push('Editor content (' + editorContent.length + ' chars):');
+        ctx.push(editorContent.slice(0, 1500));
+        if (editorContent.length > 1500) ctx.push('... (truncated)');
+      }
+      // Problem description (LeetCode, HackerRank, etc.)
+      const descSels = [
+        '[class*="problem-description"]', '[class*="question-text"]',
+        '[data-track-load="description_content"]', '.markdown-body',
+        '[class*="content"]', '[class*="prose"]', '[class*="description"]',
+      ];
+      for (const sel of descSels) {
+        const el = document.querySelector(sel);
+        if (el && el.innerText && el.innerText.trim().length > 20) {
+          ctx.push('Problem description:');
+          ctx.push(el.innerText.trim().slice(0, 3000));
+          break;
+        }
+      }
+      return ctx.join('\\n');
+    })()
+  `;
+    try {
+        const result = await cdpSend(page, 'Runtime.evaluate', {
+            expression: js,
+            returnByValue: true,
+        });
+        return result?.result?.value ?? '';
+    }
+    catch {
+        return '';
     }
-    return base;
 }
 /**
  * Detect which code/rich-text editor is active on the page.
@@ -890,6 +1953,8 @@ function validateActions(actions) {
             return typeof a.elementIndex === 'number';
         if (a.action === 'type')
             return typeof a.elementIndex === 'number' && typeof a.text === 'string';
+        if (a.action === 'write_code')
+            return typeof a.elementIndex === 'number' && typeof a.code === 'string';
         if (a.action === 'scroll')
             return typeof a.delta === 'number';
         if (a.action === 'press')
@@ -992,7 +2057,7 @@ function extractScatteredActions(str) {
     }
     return actions;
 }
-async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, elements, timeoutMs, attempt, maxAttempts) {
+async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, elements, pageContext, timeoutMs, attempt, maxAttempts) {
     const startTime = Date.now();
     // Format element list grouped by question
     const groups = new Map();
@@ -1038,11 +2103,16 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
         }
         for (const el of els) {
             const checked = el.checked ? ' [CHECKED]' : '';
-            lines.push(`  ${el.i}: [${el.type || el.tag}] "${el.text}"${checked}`);
+            const visibility = el.inViewport ? '' : ' [OFF-SCREEN]';
+            lines.push(`  ${el.i}: [${el.type || el.tag}] "${el.text}"${checked}${visibility}`);
         }
         lines.push('');
     }
-    const userText = `Interactive elements on screen:\n${lines.join('\n')}\nAnalyze the screenshot. For each UNANSWERED question, return the element INDEX to click. For checkbox questions, return ONE action per correct answer (multiple clicks).`;
+    const userText = [
+        pageContext ? `<page_context>\n${pageContext}\n</page_context>\n` : '',
+        `Interactive elements on screen:\n${lines.join('\n')}`,
+        `Analyze the screenshot. For each UNANSWERED question, return the element INDEX to click. For checkbox questions, return ONE action per correct answer (multiple clicks). If you see ERRORS in <page_context>, fix them by retyping the correct answer.`,
+    ].filter(Boolean).join('\n\n');
     const body = {
         model,
         messages: [
@@ -1056,7 +2126,7 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
             },
         ],
         temperature: 0.1,
-        max_tokens: 8192,
+        max_tokens: 16384,
         stream: false,
     };
     const controller = new AbortController();
@@ -1067,7 +2137,8 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
         console.log(`[browse] Waiting for LLM... (${elapsed}s elapsed, attempt ${attempt}/${maxAttempts})`);
     }, 30000);
     const screenshotKB = Math.round((screenshotBase64.length * 3 / 4) / 1024);
-    console.log(`[browse] LLM request: ${model} | ${screenshotKB}KB image | ${elements.length} elements | timeout ${Math.round(timeoutMs / 1000)}s | attempt ${attempt}/${maxAttempts}`);
+    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',
@@ -1123,7 +2194,508 @@ async function analyzeScreenshot(baseUrl, apiKey, model, screenshotBase64, eleme
         clearInterval(heartbeat);
     }
 }
+/** Like analyzeScreenshot but accepts a custom system prompt (for optimization pass). */
+async function analyzeScreenshotWithPrompt(baseUrl, apiKey, model, screenshotBase64, elements, pageContext, timeoutMs, attempt, maxAttempts, customSystemPrompt) {
+    const startTime = Date.now();
+    const userText = [
+        pageContext ? `<page_context>\n${pageContext}\n</page_context>\n` : '',
+        `Analyze the screenshot and respond according to the system instructions.`,
+    ].filter(Boolean).join('\n\n');
+    const body = {
+        model,
+        messages: [
+            { role: 'system', content: customSystemPrompt },
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: userText },
+                    { type: 'image_url', image_url: { url: `data:image/jpeg;base64,${screenshotBase64}` } },
+                ],
+            },
+        ],
+        temperature: 0.1,
+        max_tokens: 16384,
+        stream: false,
+    };
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+                'api-key': apiKey,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            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('');
+        }
+        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) {
+            return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'empty' };
+        }
+        const parsed = extractJsonActions(content);
+        if (parsed.length === 0) {
+            return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'parse_error' };
+        }
+        console.log(`[browse] Optimization pass: ${parsed.length} action(s) returned`);
+        return { actions: parsed, attempt, durationMs: Date.now() - startTime };
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'timeout' };
+        }
+        return { actions: [], attempt, durationMs: Date.now() - startTime, error: 'http_error' };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+// ── Stealth mode: OS-level automation (no CDP) ──────────────────────────────
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * OS-level screen capture using PowerShell.
+ * Returns path to screenshot PNG.
+ */
+function captureScreenStealth() {
+    const outPath = path.join(os.tmpdir(), `stealth_${Date.now()}.png`);
+    const ps = [
+        'Add-Type -AssemblyName System.Windows.Forms',
+        'Add-Type -AssemblyName System.Drawing',
+        '$screen = [System.Windows.Forms.Screen]::PrimaryScreen',
+        '$bitmap = New-Object System.Drawing.Bitmap($screen.Bounds.Width, $screen.Bounds.Height)',
+        '$graphics = [System.Drawing.Graphics]::FromImage($bitmap)',
+        '$graphics.CopyFromScreen($screen.Bounds.Location, [System.Drawing.Point]::Empty, $screen.Bounds.Size)',
+        `$bitmap.Save('${outPath.replace(/\\/g, '\\\\')}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+        '$graphics.Dispose()',
+        '$bitmap.Dispose()',
+    ].join('; ');
+    (0, child_process_1.execSync)(`powershell -ExecutionPolicy Bypass -Command "${ps}"`, { stdio: 'pipe', timeout: 10000 });
+    return outPath;
+}
+/**
+ * Compare two screenshots to detect screen change.
+ * Returns true if screens are different (pixel diff > threshold).
+ */
+function screensChanged(prevPath, currPath) {
+    try {
+        const prevBuf = fs.readFileSync(prevPath);
+        const currBuf = fs.readFileSync(currPath);
+        if (prevBuf.length === currBuf.length) {
+            let diff = 0;
+            for (let i = 0; i < prevBuf.length; i += 100) {
+                if (prevBuf[i] !== currBuf[i])
+                    diff++;
+            }
+            return diff > 50;
+        }
+        return true;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * OS-level keyboard character input using PowerShell SendKeys.
+ */
+function typeCharOS(char) {
+    // Map special characters to SendKeys syntax
+    const sendKeysMap = {
+        '\n': '{ENTER}',
+        '\r': '{ENTER}',
+        '\t': '{TAB}',
+        '\b': '{BACKSPACE}',
+        '+': '{+}',
+        '^': '{^}',
+        '%': '{%}',
+        '~': '{~}',
+        '(': '{(}',
+        ')': '{)}',
+        '{': '{{}',
+        '}': '{}}',
+        '[': '{[}',
+        ']': '{]}',
+    };
+    const escaped = sendKeysMap[char] ?? char;
+    const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${escaped.replace(/'/g, "''")}')`;
+    (0, child_process_1.execSync)(`powershell -ExecutionPolicy Bypass -Command "${ps}"`, { stdio: 'pipe', timeout: 5000 });
+}
+/**
+ * OS-level mouse click at specific screen coordinates.
+ * Writes C# to temp file, loads via Add-Type -Path, calls user32.dll.
+ */
+function clickOS(x, y) {
+    const csCode = [
+        'using System;',
+        'using System.Runtime.InteropServices;',
+        'public class MouseOps {',
+        '    [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, IntPtr dwExtraInfo);',
+        '    [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);',
+        '}',
+    ].join('\n');
+    const csPath = path.join(os.tmpdir(), 'ts_mouse_ops.cs');
+    fs.writeFileSync(csPath, csCode, 'utf8');
+    const ps = [
+        `Add-Type -Path '${csPath.replace(/\\/g, '\\\\')}'`,
+        `[MouseOps]::SetCursorPos(${Math.round(x)}, ${Math.round(y)})`,
+        'Start-Sleep -Milliseconds 50',
+        '[MouseOps]::mouse_event(0x0002, 0, 0, 0, [IntPtr]::Zero)',
+        'Start-Sleep -Milliseconds 30',
+        '[MouseOps]::mouse_event(0x0004, 0, 0, 0, [IntPtr]::Zero)',
+    ].join('; ');
+    (0, child_process_1.execSync)(`powershell -ExecutionPolicy Bypass -Command "${ps}"`, { stdio: 'pipe', timeout: 5000 });
+}
+/**
+ * OS-level scroll using mouse wheel.
+ * positive = up, negative = down.
+ */
+function scrollOS(clicks) {
+    const delta = clicks * 120; // WHEEL_DELTA = 120
+    const csCode = [
+        'using System;',
+        'using System.Runtime.InteropServices;',
+        'public class ScrollOps {',
+        '    [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, IntPtr dwExtraInfo);',
+        '}',
+    ].join('\n');
+    const csPath = path.join(os.tmpdir(), 'ts_scroll_ops.cs');
+    fs.writeFileSync(csPath, csCode, 'utf8');
+    const ps = [
+        `Add-Type -Path '${csPath.replace(/\\/g, '\\\\')}'`,
+        `[ScrollOps]::mouse_event(0x0800, 0, 0, ${delta}, [IntPtr]::Zero)`,
+    ].join('; ');
+    (0, child_process_1.execSync)(`powershell -ExecutionPolicy Bypass -Command "${ps}"`, { stdio: 'pipe', timeout: 5000 });
+}
+/**
+ * OS-level keyboard shortcut (e.g., Ctrl+A, Tab, Enter).
+ */
+function pressKeyOS(key) {
+    const keyMap = {
+        'enter': '{ENTER}',
+        'tab': '{TAB}',
+        'escape': '{ESC}',
+        'backspace': '{BACKSPACE}',
+        'delete': '{DELETE}',
+        'space': ' ',
+        'up': '{UP}',
+        'down': '{DOWN}',
+        'left': '{LEFT}',
+        'right': '{RIGHT}',
+        'home': '{HOME}',
+        'end': '{END}',
+        'pageup': '{PGUP}',
+        'pagedown': '{PGDN}',
+        'ctrl+a': '^a',
+        'ctrl+c': '^c',
+        'ctrl+v': '^v',
+        'ctrl+z': '^z',
+    };
+    const escaped = keyMap[key.toLowerCase()] ?? key;
+    const ps = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${escaped.replace(/'/g, "''")}')`;
+    (0, child_process_1.execSync)(`powershell -ExecutionPolicy Bypass -Command "${ps}"`, { stdio: 'pipe', timeout: 5000 });
+}
+/**
+ * Keyboard proximity map for generating realistic typos.
+ */
+const ADJACENT_KEYS = {
+    'a': ['s', 'q', 'w', 'z'], 'b': ['v', 'g', 'h', 'n'],
+    'c': ['x', 'd', 'f', 'v'], 'd': ['s', 'f', 'e', 'c', 'r'],
+    'e': ['w', 'r', 'd', 's'], 'f': ['d', 'g', 'r', 'v', 't'],
+    'g': ['f', 'h', 't', 'b', 'y'], 'h': ['g', 'j', 'y', 'n', 'u'],
+    'i': ['u', 'o', 'k', 'j'], 'j': ['h', 'k', 'n', 'u', 'm'],
+    'k': ['j', 'l', 'm', 'i', 'o'], 'l': ['k', 'o', 'p'],
+    'm': ['n', 'j', 'k'], 'n': ['b', 'm', 'h', 'j'],
+    'o': ['i', 'p', 'l', 'k'], 'p': ['o', 'l'],
+    'q': ['w', 'a'], 'r': ['e', 't', 'f', 'd'],
+    's': ['a', 'd', 'w', 'x', 'z'], 't': ['r', 'y', 'g', 'f'],
+    'u': ['y', 'i', 'j', 'h'], 'v': ['c', 'b', 'f', 'g'],
+    'w': ['q', 'e', 's', 'a'], 'x': ['z', 'c', 's', 'd'],
+    'y': ['t', 'u', 'g', 'h'], 'z': ['x', 'a', 's'],
+    '0': ['9', '1'], '1': ['0', '2', 'q'], '2': ['1', '3', 'w'],
+    '3': ['2', '4', 'e'], '4': ['3', '5', 'r'], '5': ['4', '6', 't'],
+    '6': ['5', '7', 'y'], '7': ['6', '8', 'u'], '8': ['7', '9', 'i'],
+    '9': ['8', '0', 'o'],
+};
+/**
+ * Generate a realistic typo by picking an adjacent key.
+ */
+function getAdjacentKey(char) {
+    const lower = char.toLowerCase();
+    const keys = ADJACENT_KEYS[lower];
+    if (!keys)
+        return char;
+    const wrong = keys[Math.floor(Math.random() * keys.length)];
+    return char === char.toUpperCase() ? wrong.toUpperCase() : wrong;
+}
+/**
+ * Type text with human-like patterns: variable speed, occasional typos,
+ * backspaces, natural pauses. Uses OS-level keyboard (no CDP).
+ */
+async function typeHumanLike(text, baseDelayMs = 120) {
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        // 1. Occasional typo (2% chance) — then backspace to correct
+        if (char !== '\n' && char !== '\t' && Math.random() < 0.02) {
+            const wrong = getAdjacentKey(char);
+            typeCharOS(wrong);
+            await sleep(randomInt(40, 120));
+            typeCharOS('\b'); // backspace
+            await sleep(randomInt(25, 70));
+        }
+        // 2. Type the correct character
+        typeCharOS(char);
+        // 3. Variable delay based on character type (human rhythm)
+        let delay = baseDelayMs + randomInt(-Math.floor(baseDelayMs * 0.3), Math.floor(baseDelayMs * 0.4));
+        if (char === ' ')
+            delay += randomInt(30, 120); // pause at word boundary
+        else if (char === '\n')
+            delay += randomInt(100, 350); // pause at line end
+        else if (char === '.')
+            delay += randomInt(80, 200); // pause at sentence end
+        else if (char === ',')
+            delay += randomInt(40, 100); // pause at comma
+        else if (/[A-Z]/.test(char))
+            delay += randomInt(15, 50); // hesitate before uppercase
+        else if (/[0-9]/.test(char))
+            delay += randomInt(10, 35); // hesitate before number
+        else if (/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(char))
+            delay += randomInt(20, 60); // hesitate before symbol
+        // 4. Occasional longer pause (thinking) — 3% chance
+        if (Math.random() < 0.03) {
+            await sleep(randomInt(200, 600));
+        }
+        await sleep(Math.max(delay, 30));
+    }
+}
+/**
+ * Wait for the screen to change by comparing screenshots.
+ * Returns the new screenshot path, or null if timed out.
+ */
+function waitForScreenChangeStealth(prevPath, intervalMs = 2000, maxWaitMs = 60000, shouldStop = () => false) {
+    const deadline = Date.now() + maxWaitMs;
+    while (Date.now() < deadline && !shouldStop()) {
+        sleep(intervalMs); // sync-ish wait
+        const currPath = captureScreenStealth();
+        if (screensChanged(prevPath, currPath)) {
+            return currPath;
+        }
+    }
+    return null;
+}
+/**
+ * Stealth LLM call: send screenshot to vision LLM, get structured action.
+ * Returns JSON: { action, coordinates?, text?, scroll?, reasoning }
+ */
+async function callStealthLLM(baseUrl, apiKey, model, screenshotPath, timeoutMs, promptOverride) {
+    const imageData = fs.readFileSync(screenshotPath).toString('base64');
+    const systemPrompt = promptOverride ?? [
+        'You are a test-taking assistant analyzing a screenshot of a test/assessment.',
+        '',
+        'Analyze the screenshot and return a JSON object with the correct action.',
+        '',
+        'For MULTIPLE-CHOICE questions (radio buttons, checkboxes, A/B/C/D options):',
+        '  Return: {"action":"click","x":<center_x_of_correct_option>,"y":<center_y_of_correct_option>,"reasoning":"why this option"}',
+        '  Look at the screenshot carefully. The x,y coordinates should be the CENTER of the radio button or checkbox for the correct answer.',
+        '',
+        'For CODING questions (code editor visible, need to write code):',
+        '  Return: {"action":"type","text":"<the complete code>","reasoning":"why this code"}',
+        '',
+        'For FILL-IN-THE-BLANK (text input field visible):',
+        '  Return: {"action":"type","text":"<the answer text>","reasoning":"why this answer"}',
+        '',
+        'For questions that need SCROLLING (answer options are cut off at bottom):',
+        '  Return: {"action":"scroll","scroll":-3,"reasoning":"need to see more options"}',
+        '  scroll: negative = scroll down, positive = scroll up. Use -2 to -5 for typical scroll.',
+        '',
+        'For DONE (all questions answered, no more questions visible):',
+        '  Return: {"action":"done","reasoning":"all questions answered"}',
+        '',
+        'Rules:',
+        '- Return ONLY valid JSON, nothing else. No markdown, no explanation outside the JSON.',
+        '- For click actions, the x,y must be PIXEL COORDINATES on the screen where the correct option is.',
+        '- Read the question carefully. Think step by step before answering.',
+        '- If you need to scroll to see all options, return scroll action first.',
+    ].join('\n');
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    {
+                        role: 'user',
+                        content: [
+                            { type: 'text', text: 'Analyze this screenshot. Return the JSON action to take.' },
+                            { type: 'image_url', image_url: { url: `data:image/png;base64,${imageData}` } },
+                        ],
+                    },
+                ],
+                max_tokens: 4096,
+                temperature: 0.1,
+            }),
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        const content = (data.choices?.[0]?.message?.content ?? '').trim();
+        // Parse JSON response
+        try {
+            // Extract JSON from possible markdown code block
+            const jsonMatch = content.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                return {
+                    action: parsed.action ?? 'type',
+                    x: parsed.x,
+                    y: parsed.y,
+                    text: parsed.text,
+                    scroll: parsed.scroll,
+                    reasoning: parsed.reasoning,
+                };
+            }
+        }
+        catch {
+            // JSON parse failed — treat as plain text answer (type action)
+        }
+        // Fallback: treat entire response as text to type
+        return { action: 'type', text: content, reasoning: 'fallback: plain text response' };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Stealth agent loop: OS-level screen capture → vision LLM → OS-level keyboard/mouse.
+ * No CDP connection, no clipboard, no DevTools detection.
+ */
+async function runStealthLoop(baseUrl, apiKey, model, maxActions, intervalMs, timeoutMs, charDelayMs, continuous) {
+    let actionCount = 0;
+    let llmCallCount = 0;
+    let stopped = false;
+    process.on('SIGINT', () => {
+        console.log('\n[stealth] Stopped by user');
+        stopped = true;
+    });
+    process.on('SIGTERM', () => { stopped = true; });
+    const limit = continuous ? Number.MAX_SAFE_INTEGER : maxActions;
+    console.log(`[stealth] Agent started. ${continuous ? 'Running until Ctrl+C.' : `Max ${limit} actions.`}`);
+    console.log('[stealth] OS-level automation — no CDP, no clipboard, no DevTools');
+    console.log('[stealth] Make sure the target window (browser/editor) is focused\n');
+    // Take initial screenshot
+    let prevScreenshot = captureScreenStealth();
+    console.log('[stealth] Initial screenshot captured — waiting for screen change...\n');
+    while (!stopped && actionCount < limit) {
+        try {
+            // Wait for screen to change (new question appears)
+            const currScreenshot = captureScreenStealth();
+            if (!screensChanged(prevScreenshot, currScreenshot)) {
+                // No change — wait and retry
+                await sleep(intervalMs);
+                continue;
+            }
+            console.log(`[stealth] Screen changed — analyzing...`);
+            prevScreenshot = currScreenshot;
+            // Send to vision LLM
+            const actionLabel = continuous ? `${actionCount + 1}/∞` : `${actionCount + 1}/${limit}`;
+            console.log(`[stealth] [${actionLabel}] Calling vision LLM...`);
+            const result = await callStealthLLM(baseUrl, apiKey, model, currScreenshot, timeoutMs);
+            llmCallCount++;
+            console.log(`[stealth] LLM returned: action="${result.action}" reasoning="${result.reasoning?.slice(0, 60) ?? ''}"`);
+            // Execute the action
+            switch (result.action) {
+                case 'click': {
+                    if (result.x !== undefined && result.y !== undefined) {
+                        console.log(`[stealth] Clicking at (${Math.round(result.x)}, ${Math.round(result.y)})...`);
+                        await sleep(randomInt(200, 500)); // natural pause before click
+                        clickOS(result.x, result.y);
+                        actionCount++;
+                    }
+                    else {
+                        console.log('[stealth] Click action missing coordinates — skipping');
+                    }
+                    break;
+                }
+                case 'type': {
+                    if (result.text && result.text.length > 0) {
+                        console.log(`[stealth] Typing ${result.text.length} chars...`);
+                        await sleep(randomInt(300, 700)); // natural pause before typing
+                        await typeHumanLike(result.text, charDelayMs);
+                        actionCount++;
+                    }
+                    else {
+                        console.log('[stealth] Type action missing text — skipping');
+                    }
+                    break;
+                }
+                case 'scroll': {
+                    const clicks = result.scroll ?? -3;
+                    console.log(`[stealth] Scrolling ${clicks > 0 ? 'up' : 'down'} (${Math.abs(clicks)} clicks)...`);
+                    await sleep(randomInt(200, 400));
+                    scrollOS(clicks);
+                    actionCount++;
+                    // Wait for scroll to settle
+                    await sleep(randomInt(500, 1000));
+                    break;
+                }
+                case 'done': {
+                    console.log(`[stealth] LLM says done: ${result.reasoning ?? 'All questions answered'}`);
+                    if (!continuous) {
+                        stopped = true;
+                    }
+                    else {
+                        // In continuous mode, wait for next screen change
+                        console.log('[stealth] Waiting for next question...');
+                        await sleep(randomInt(3000, 6000));
+                    }
+                    break;
+                }
+                default: {
+                    console.log(`[stealth] Unknown action: ${result.action} — treating as type`);
+                    if (result.text) {
+                        await typeHumanLike(result.text, charDelayMs);
+                        actionCount++;
+                    }
+                }
+            }
+            // Log progress
+            if (llmCallCount > 50 && llmCallCount % 25 === 0) {
+                console.log(`[stealth] Warning: ${llmCallCount} LLM calls made — may hit rate limits`);
+            }
+            // Natural pause before next question
+            const pause = randomInt(1500, 3500);
+            console.log(`[stealth] Waiting ${pause}ms for next question...\n`);
+            await sleep(pause);
+        }
+        catch (err) {
+            console.error(`[stealth] Error: ${(0, config_1.msg)(err)}`);
+            await sleep(intervalMs);
+        }
+    }
+    console.log(`[stealth] Agent stopped. ${actionCount} actions completed, ${llmCallCount} LLM calls.`);
+}
 //# sourceMappingURL=browse.js.map