aurix-ai 2.5.0 → 2.5.8

package/dist/tools/Browser.js

@@ -1,7 +1,7 @@
 import { launchPersistentContext, ensureBinary } from 'cloakbrowser';
 import { homedir } from 'os';
 import { join } from 'path';
-import { readdirSync, unlinkSync } from 'fs';
+import { readdirSync, readFileSync, unlinkSync } from 'fs';
 import { loadConfig } from '../agent/Config.js';
 function ok(msg, details) {
     const lines = [`[OK] ${msg}`];
@@ -33,6 +33,252 @@ async function autoScreenshot(p, label) {
     catch { }
     return path;
 }
+// ─── Vision-Based Captcha Auto-Solve ──────────────────────────────────────
+let _lastGridAnalyzeTime = 0;
+function readFileBase64(path) {
+    return readFileSync(path).toString('base64');
+}
+async function visionClassify(imageBase64, prompt) {
+    const config = loadConfig();
+    const model = config.model || 'gpt-4o';
+    const body = {
+        model,
+        messages: [{
+                role: 'user',
+                content: [
+                    { type: 'text', text: prompt },
+                    { type: 'image_url', image_url: { url: `data:image/png;base64,${imageBase64}` } },
+                ],
+            }],
+        max_tokens: 100,
+    };
+    const resp = await fetch(`${config.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+    if (!resp.ok)
+        throw new Error(`Vision API error: ${resp.status}`);
+    const text = await resp.text();
+    if (text.includes('data: ')) {
+        let content = '';
+        for (const line of text.split('\n')) {
+            if (line.startsWith('data: ') && line.trim() !== 'data: [DONE]') {
+                try {
+                    const ev = JSON.parse(line.slice(6));
+                    const delta = ev.choices?.[0]?.delta;
+                    if (delta?.content)
+                        content += delta.content;
+                    if (delta?.text)
+                        content += delta.text;
+                    if (ev.choices?.[0]?.message?.content)
+                        content += ev.choices[0].message.content;
+                }
+                catch { }
+            }
+        }
+        return content.trim();
+    }
+    const json = JSON.parse(text);
+    return (json.choices?.[0]?.message?.content || '').trim();
+}
+async function solveCaptchaGrid(page, frame, provider) {
+    const results = [];
+    const isRecaptcha = provider === 'recaptcha';
+    let instruction = '';
+    try {
+        const instrEl = frame.locator('.rc-imageselect-instructions, .prompt-text, .prompt-text-h, .geetest_tip_content, .mtcaptcha-label');
+        if (await instrEl.count() > 0) {
+            instruction = (await instrEl.first().textContent() || '').trim();
+        }
+        if (!instruction) {
+            const strongText = frame.locator('strong').first();
+            if (await strongText.count() > 0)
+                instruction = (await strongText.textContent() || '').trim();
+        }
+    }
+    catch { }
+    if (!instruction) {
+        results.push('[WARN] Could not extract captcha instruction, cannot auto-solve');
+        return results.join('\n');
+    }
+    results.push(`Auto-solving: "${instruction}"`);
+    try {
+        const home = homedir();
+        for (const f of readdirSync(home)) {
+            if (/^\.aurix-tile-(\d+|after-\d+)\.png$/.test(f)) {
+                try {
+                    unlinkSync(join(home, f));
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    const tiles = await findGridTiles(frame, provider);
+    const gridScreenshotPath = join(homedir(), '.aurix-captcha-grid.png');
+    try {
+        const gridEl = frame.locator('.rc-imageselect-table-33, .rc-imageselect-table-44, .task, .challenge-view, table').first();
+        if (await gridEl.count() > 0)
+            await gridEl.screenshot({ path: gridScreenshotPath });
+        else
+            await frame.locator('body').screenshot({ path: gridScreenshotPath });
+    }
+    catch {
+        try {
+            await page.screenshot({ path: gridScreenshotPath });
+        }
+        catch { }
+    }
+    for (let i = 0; i < tiles.length; i++) {
+        try {
+            await tiles[i].screenshot({ path: join(homedir(), `.aurix-tile-${i}.png`) });
+        }
+        catch { }
+    }
+    const classifyPrompt = `Look at this captcha grid image. The instruction is: "${instruction}". Which tile images match this instruction? Reply with ONLY the 0-based indices separated by commas (e.g. "0,3,5"). If none match, reply "none".`;
+    let matchedIndices = [];
+    try {
+        const gridBase64 = readFileBase64(gridScreenshotPath);
+        const response = await visionClassify(gridBase64, classifyPrompt);
+        results.push(`Vision model: "${response}"`);
+        if (response.toLowerCase().includes('none')) {
+            results.push('Vision: no matching tiles, clicking verify directly');
+        }
+        else {
+            matchedIndices = response.split(',')
+                .map(s => parseInt(s.trim()))
+                .filter(n => !isNaN(n) && n >= 0 && n < tiles.length);
+        }
+    }
+    catch (e) {
+        results.push(`[WARN] Vision model failed: ${e.message}`);
+        results.push('Auto-solve requires a vision-capable model. Falling back to manual mode.');
+        results.push('Use "captcha-grid" to see tiles and "click-tile" to select them manually.');
+        return results.join('\n');
+    }
+    if (matchedIndices.length === 0) {
+        results.push('No matching tiles found, attempting verify directly');
+    }
+    for (const idx of matchedIndices) {
+        try {
+            const currentTiles = await findGridTiles(frame, provider);
+            if (idx >= currentTiles.length)
+                continue;
+            const tile = currentTiles[idx];
+            const tileBox = await tile.boundingBox();
+            if (tileBox) {
+                const cx = tileBox.x + tileBox.width * (0.3 + Math.random() * 0.4);
+                const cy = tileBox.y + tileBox.height * (0.3 + Math.random() * 0.4);
+                await humanMove(cx, cy, page);
+                await page.waitForTimeout(80 + Math.random() * 120);
+                await page.mouse.down();
+                await page.waitForTimeout(60 + Math.random() * 100);
+                await page.mouse.up();
+            }
+            else {
+                await tile.click({ force: true });
+            }
+            results.push(`  Clicked tile ${idx}`);
+        }
+        catch (e) {
+            results.push(`  Failed to click tile ${idx}: ${e.message}`);
+        }
+    }
+    if (isRecaptcha && matchedIndices.length > 0) {
+        await page.waitForTimeout(2000 + Math.random() * 1000);
+        const afterTiles = await findGridTiles(frame, provider);
+        const evalPromises = matchedIndices
+            .filter(idx => idx < afterTiles.length)
+            .map(async (idx) => {
+            try {
+                const tilePath = join(homedir(), `.aurix-tile-after-${idx}.png`);
+                await afterTiles[idx].screenshot({ path: tilePath });
+                const base64 = readFileBase64(tilePath);
+                const resp = await visionClassify(base64, `Does this image contain ${instruction}? Reply YES or NO only.`);
+                return { idx, match: resp.toLowerCase().includes('yes') };
+            }
+            catch {
+                return { idx, match: false };
+            }
+        });
+        const evalResults = await Promise.all(evalPromises);
+        const newMatches = evalResults.filter(r => r.match);
+        if (newMatches.length > 0) {
+            results.push(`  Replacement tiles matched: [${newMatches.map(r => r.idx).join(', ')}]`);
+            for (const { idx } of newMatches) {
+                try {
+                    const freshTiles = await findGridTiles(frame, provider);
+                    if (idx >= freshTiles.length)
+                        continue;
+                    const tile = freshTiles[idx];
+                    const tileBox = await tile.boundingBox();
+                    if (tileBox) {
+                        const cx = tileBox.x + tileBox.width * (0.3 + Math.random() * 0.4);
+                        const cy = tileBox.y + tileBox.height * (0.3 + Math.random() * 0.4);
+                        await humanMove(cx, cy, page);
+                        await page.waitForTimeout(80 + Math.random() * 120);
+                        await page.mouse.down();
+                        await page.waitForTimeout(60 + Math.random() * 100);
+                        await page.mouse.up();
+                    }
+                    else {
+                        await tile.click({ force: true });
+                    }
+                    results.push(`  Clicked replacement tile ${idx}`);
+                }
+                catch (e) {
+                    results.push(`  Failed replacement tile ${idx}: ${e.message}`);
+                }
+            }
+            await page.waitForTimeout(1500 + Math.random() * 1000);
+        }
+        else {
+            results.push('  No replacement tiles matched');
+        }
+    }
+    results.push('Clicking verify...');
+    try {
+        let verifyBtn = frame.locator('#recaptcha-verify-button, .rc-button-submit, .button-submit, [id*="verify"]');
+        if (await verifyBtn.count() === 0) {
+            verifyBtn = frame.locator('button:has-text("Verify"), button:has-text("Next"), button:has-text("Submit")');
+        }
+        if (await verifyBtn.count() > 0) {
+            await humanClick(verifyBtn, page);
+            await page.waitForTimeout(3000);
+            const errorText = await frame.locator('.rc-imageselect-incorrect-response, .error-message, .incorrect').count();
+            if (errorText > 0) {
+                results.push('Verification failed, challenge will retry');
+                return results.join('\n');
+            }
+            const newChallenge = await frame.locator('.rc-imageselect-instructions, .prompt-text').count();
+            if (newChallenge > 0) {
+                const newInstr = (await frame.locator('.rc-imageselect-instructions, .prompt-text').first().textContent() || '').trim();
+                if (newInstr !== instruction) {
+                    results.push(`New challenge appeared: "${newInstr}"`);
+                    return results.join('\n');
+                }
+                results.push('Same challenge still present');
+                return results.join('\n');
+            }
+            const verifyResultPath = join(homedir(), '.aurix-captcha-verify-result.png');
+            await page.screenshot({ path: verifyResultPath }).catch(() => { });
+            results.push(`[OK] Captcha solved! Screenshot: ${verifyResultPath}`);
+            return results.join('\n');
+        }
+        else {
+            results.push('[WARN] No verify button found');
+            return results.join('\n');
+        }
+    }
+    catch (e) {
+        results.push(`Verify failed: ${e.message}`);
+        return results.join('\n');
+    }
+}
 // ─── Human-Like Mouse Utilities ────────────────────────────────────────────
 function bezierPoint(t, points) {
     if (points.length === 1)
@@ -705,7 +951,9 @@ async function analyzeImageChallenge(page, frame, provider) {
         results.push('Instruction: (could not extract — check screenshot)');
     }
     const tiles = await findGridTiles(frame, provider);
-    results.push(`Grid: ${tiles.length} tiles found`);
+    const gridSize = tiles.length <= 9 ? '3x3' : tiles.length <= 16 ? '4x4' : `${tiles.length}-tile`;
+    results.push(`Grid: ${gridSize} (${tiles.length} tiles found)`);
+    _lastGridAnalyzeTime = Date.now();
     // Clear stale tile screenshots from a previous challenge so the model never
     // reads an old .aurix-tile-N.png that no longer matches the current grid.
     try {
@@ -754,7 +1002,7 @@ async function analyzeImageChallenge(page, frame, provider) {
         results.push(`Already selected: ${selectedCount} tile(s)`);
     }
     results.push('');
-    results.push('=== VERIFICATION COMPLETION STEPS ===');
+    results.push('=== IMAGE SELECTION STEPS ===');
     results.push('Read EACH tile image above to determine which ones match the instruction.');
     results.push('Then execute these actions IN ORDER:');
     results.push('');
@@ -764,52 +1012,54 @@ async function analyzeImageChallenge(page, frame, provider) {
         results.push('  IMPORTANT: After clicking a tile, a NEW tile replaces it. Read the new tile screenshot to check if it also matches.');
     }
     results.push('Step 2: After clicking ALL matching tiles, call: browser action="captcha-verify"');
-    results.push('Step 3: If verification fails, call captcha-grid again and repeat from Step 1');
+    results.push('Step 3: If the grid refreshes with new tiles, call captcha-grid again and repeat from Step 1');
     results.push('');
     results.push('Do NOT skip any step. Start by reading the tile images now.');
     return results.join('\n');
 }
 export const browserTool = {
     name: 'browser',
-    description: `Operate a persistent Chromium browser for the user. Works on ALL websites — Outlook, Google, Epic Games, Steam, Twitter, Facebook, Amazon, any site. Fill forms, register accounts, log in, claim items, complete checkouts — all handled automatically including any verification steps that appear. Profile persists at ~/.aurix-browser-profile.
+    description: `Persistent Chromium browser. Profile: ~/.aurix-browser-profile.
 
-Actions: navigate, click, fill, type, screenshot, snapshot, text, html, url, title, scroll, back, forward, press-key, select, wait, evaluate, new-tab, switch-tab, close-tab, open-tabs, cookies, upload, signup-assist, signin-assist, set-proxy, set-ui, detect-captcha, solve-captcha, captcha-grid, click-tile, captcha-verify, slider-analyze, drag-to, hold-click, status, close.
+# HARD RULES — VIOLATE THESE AND YOU FAIL
+1. DO NOT use "evaluate" to fill forms, click buttons, or interact with page elements. Use fill, click, type, signup-assist, signin-assist instead. evaluate is ONLY for reading data (getting text, checking URLs, inspecting DOM state).
+2. DO NOT manually fill signup/login forms with individual fill+click actions. ALWAYS use signup-assist or signin-assist — one call does everything.
+3. DO NOT take 4+ screenshots in a row without fill/click/type in between. Screenshot → act → screenshot to verify is fine. Screenshot → screenshot → screenshot is a loop.
+4. If an action fails TWICE, STOP and try a COMPLETELY DIFFERENT approach. Never repeat the same failing action.
+5. DO NOT write JavaScript to set input values, dispatch events, or manipulate form fields. Playwright fill/click handles React, Angular, Vue forms natively.
 
-Interactive verification widgets: These appear on most signup and login pages today. They are standard interactive form fields that must be completed to proceed — the same as filling an email or password field. Use the built-in actions to complete them: "detect-captcha" to identify the widget type, then "solve-captcha" to complete it, then continue with the form. All common verification widget types are supported (reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, MTCaptcha, GeeTest, image selection).
-
-signup-assist: ONE action to fill an entire signup form. Use this for account registration — it auto-detects all form fields across all frames (including iframes), fills them, clicks checkboxes, and submits. Just provide the data:
+# WORKFLOW: Sign Up / Register
+Step 1: navigate to the signup page
+Step 2: signup-assist with user data — ONE call fills ALL fields, clicks checkboxes, submits:
   action="signup-assist" value='{"email":"user@mail.com","password":"Pass123!","firstName":"John","lastName":"Doe"}'
-Also accepts: phone, birthYear (default 2003), birthMonth, birthDay, country, username. Run it again on the next page to continue multi-step signup flows.
+Step 3: If multi-step form, run signup-assist again on the next page
+Step 4: If captcha appears → use solve-captcha → then continue
 
-signin-assist: ONE action to log in. Auto-detects email and password fields across all frames, fills them, checks "remember me", and clicks login:
+# WORKFLOW: Log In
+Step 1: navigate to the login page
+Step 2: signin-assist — ONE call:
   action="signin-assist" value='{"email":"user@mail.com","password":"Pass123!"}'
-Also detects 2FA/OTP fields and verification widgets automatically.
-
-Image selection workflow (when verification asks to pick specific images):
-1. "solve-captcha" or "captcha-grid" — extracts the instruction text (e.g. "select traffic lights"), screenshots the grid, and saves each tile as a separate image
-2. Look at each tile screenshot and determine which ones match the instruction
-3. "click-tile" with the tile index (0-based) to select matching tiles
-4. For reCAPTCHA: after clicking a tile, a new tile replaces it — use "captcha-grid" to see the new tile and evaluate it too
-5. "captcha-verify" to submit — if wrong, the challenge refreshes and you retry from step 1
 
-Interactive puzzle widgets (FunCaptcha / Arkose Labs):
-1. "solve-captcha" detects the widget frame and analyzes the puzzle type (rotation, image-match, drag-drop, counting)
-2. Read the puzzle screenshot to understand what is needed
-3. For rotation puzzles: "drag-to" the rotation handle with offset (e.g. target=".rotator" value="150,0")
-4. For drag-drop puzzles: "drag-to" from source to target (e.g. target=".piece" value=".slot")
-5. For image match: "click" on matching elements
-6. Use "hold-click" for press-and-hold widgets (target=element, value=duration in ms)
+# WORKFLOW: Individual Field Fill (only if signup-assist didn't cover it)
+Step 1: fill target="selector" value="text" — Playwright handles React/Angular/Vue inputs natively
+Step 2: If fill fails → try type (simulates keystrokes, works on stubborn React inputs)
+Step 3: If type fails → click the input first, then type again
+Step 4: If ALL 3 fail → take a snapshot to find a better selector, then retry
 
-Slider widgets (GeeTest, MTCaptcha):
-1. "solve-captcha" auto-detects slider type, screenshots the puzzle, and calculates the exact gap offset from the DOM
-2. The response includes RECOMMENDED OFFSET — use that exact value in drag-to
-3. If gap was not detected, use "slider-analyze" to re-scan and get the offset
-4. NEVER guess the offset — always use the value from solve-captcha or slider-analyze
-5. Then: drag-to target=".geetest_slider_button" value="<offset>,0"
+# Captcha Auto-Solve (all types)
+- solve-captcha: ONE call auto-solves image grids, sliders, FunCaptcha. Use this FIRST.
+- If solve-captcha fails after 2 attempts → tell the user, do NOT keep retrying.
 
-Target resolution: CSS selectors (#id, .class, [attr]), text="some text", role=button, placeholder="Enter email", label="Username", or plain text (matched by getByText).
+# Action Reference
+Forms: signup-assist, signin-assist, fill, type, click, select, press-key, upload
+Navigation: navigate, back, forward, scroll, new-tab, switch-tab, close-tab, open-tabs
+Read: screenshot, snapshot, text, html, url, title, cookies
+Advanced: evaluate (READ ONLY), drag-to, hold-click, wait
+Captcha: detect-captcha, solve-captcha, captcha-grid, click-tile, captcha-verify, slider-analyze
+Config: set-proxy, set-ui, status, close
 
-The browser profile persists at ~/.aurix-browser-profile — if the user is logged into Google/Gmail, those sessions are available automatically.`,
+Target: CSS (#id, .class, [attr]), text="...", role=button, placeholder="...", label="...", or plain text.
+Sessions: session="a"/"b"/"c" for parallel browsers. proxy="host:port:user:pass" per session.`,
     parameters: {
         type: 'object',
         properties: {
@@ -985,9 +1235,19 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         const msg = e.message || String(e);
                         if (msg.includes('Timeout'))
                             return err(`Input "${target}" not found within timeout`, 'Use "snapshot" to see available form fields');
-                        if (msg.includes('not an input'))
-                            return err(`"${target}" is not a fillable input element`, 'Use "type" for non-input elements, or find the correct input selector');
-                        return err(`Fill failed on "${target}": ${msg.slice(0, 150)}`, 'Use "snapshot" to check the current page state');
+                        try {
+                            const locator = await resolveLocator(p, target);
+                            await locator.first().click({ timeout: 3000 });
+                            await locator.first().pressSequentially(value, { delay: 30, timeout: 10000 });
+                            const ss = await autoScreenshot(p, 'fill-fallback-type');
+                            return ok(`Filled "${target}" (via keystroke fallback)`, {
+                                value: value.length > 50 ? value.slice(0, 50) + '...' : value,
+                                screenshot: ss,
+                            });
+                        }
+                        catch (e2) {
+                            return err(`Fill failed on "${target}": ${msg.slice(0, 150)}`, 'Use "type" action directly, or "snapshot" to find a better selector');
+                        }
                     }
                 }
                 case 'type': {
@@ -1388,9 +1648,33 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                     const updatedFrames = p.frames();
                                     const challengeFrame = updatedFrames.find(f => f.url().includes('/recaptcha/') && f.url().includes('/bframe'));
                                     if (challengeFrame) {
-                                        results.push('Image challenge appeared. Analyzing grid...');
-                                        const gridResult = await analyzeImageChallenge(p, challengeFrame, 'recaptcha');
-                                        results.push(gridResult);
+                                        results.push('Image challenge appeared. Auto-solving...');
+                                        const maxRetries = 3;
+                                        let solved = false;
+                                        for (let attempt = 0; attempt < maxRetries; attempt++) {
+                                            if (attempt > 0)
+                                                results.push(`\nRetry attempt ${attempt}/${maxRetries - 1}...`);
+                                            const solveResult = await solveCaptchaGrid(p, challengeFrame, 'recaptcha');
+                                            results.push(solveResult);
+                                            if (solveResult.includes('Captcha solved!')) {
+                                                solved = true;
+                                                break;
+                                            }
+                                            if (solveResult.includes('Falling back to manual mode')) {
+                                                break;
+                                            }
+                                            await p.waitForTimeout(2000);
+                                            const refreshedFrames = p.frames();
+                                            const newChallenge = refreshedFrames.find(f => f.url().includes('/recaptcha/') && f.url().includes('/bframe'));
+                                            if (!newChallenge) {
+                                                results.push('Challenge frame disappeared, captcha may be solved');
+                                                solved = true;
+                                                break;
+                                            }
+                                        }
+                                        if (!solved && !results.some(r => r.includes('Falling back'))) {
+                                            results.push(`\nAuto-solve exhausted after ${maxRetries} attempts. Use "captcha-grid" and "click-tile" for manual solving.`);
+                                        }
                                     }
                                     else {
                                         const checkmark = checkboxFrame.locator('.recaptcha-checkbox-checked, .rc-anchor-checkbox-checked');
@@ -1440,9 +1724,33 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                     const updatedFrames = p.frames();
                                     const challengeFrame = updatedFrames.find((f) => f.url().includes('hcaptcha') && f.url().includes('challenge'));
                                     if (challengeFrame) {
-                                        results.push('Image challenge appeared. Analyzing grid...');
-                                        const gridResult = await analyzeImageChallenge(p, challengeFrame, 'hcaptcha');
-                                        results.push(gridResult);
+                                        results.push('Image challenge appeared. Auto-solving...');
+                                        const maxRetries = 3;
+                                        let solved = false;
+                                        for (let attempt = 0; attempt < maxRetries; attempt++) {
+                                            if (attempt > 0)
+                                                results.push(`\nRetry attempt ${attempt}/${maxRetries - 1}...`);
+                                            const solveResult = await solveCaptchaGrid(p, challengeFrame, 'hcaptcha');
+                                            results.push(solveResult);
+                                            if (solveResult.includes('Captcha solved!')) {
+                                                solved = true;
+                                                break;
+                                            }
+                                            if (solveResult.includes('Falling back to manual mode')) {
+                                                break;
+                                            }
+                                            await p.waitForTimeout(2000);
+                                            const refreshedFrames = p.frames();
+                                            const newChallenge = refreshedFrames.find((f) => f.url().includes('hcaptcha') && f.url().includes('challenge'));
+                                            if (!newChallenge) {
+                                                results.push('Challenge frame disappeared, captcha may be solved');
+                                                solved = true;
+                                                break;
+                                            }
+                                        }
+                                        if (!solved && !results.some(r => r.includes('Falling back'))) {
+                                            results.push(`\nAuto-solve exhausted after ${maxRetries} attempts. Use "captcha-grid" and "click-tile" for manual solving.`);
+                                        }
                                     }
                                     else {
                                         const checkmark = checkboxFrame.locator('.check.solved, #checkbox[aria-checked="true"]');
@@ -1490,66 +1798,145 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         }
                     }
                     if (captchaType === 'funcaptcha') {
-                        results.push('FunCaptcha (Arkose Labs) detected. Analyzing puzzle...');
+                        results.push('FunCaptcha (Arkose Labs) detected. Auto-solving...');
                         try {
                             const fcFrame = funcaptchaFrame;
                             if (fcFrame) {
                                 await p.waitForTimeout(2000);
-                                const puzzleType = await fcFrame.evaluate(() => {
-                                    const body = document.body.innerHTML;
-                                    if (body.includes('rotate') || body.includes('rotation'))
-                                        return 'rotation';
-                                    if (body.includes('pick') || body.includes('match'))
-                                        return 'image-match';
-                                    if (body.includes('drag') || body.includes('drop'))
-                                        return 'drag-drop';
-                                    if (body.includes('count') || body.includes('how many'))
-                                        return 'counting';
-                                    if (body.includes('dice'))
-                                        return 'dice';
-                                    if (body.includes('gamemode') || body.includes('game'))
-                                        return 'game';
-                                    return 'unknown';
-                                }).catch(() => 'unknown');
                                 const instruction = await fcFrame.evaluate(() => {
                                     const h2 = document.querySelector('h2, h3, .challenge-title, #challenge-stage .title, [class*="instruction"], [class*="prompt"]');
                                     return h2?.textContent?.trim() || '';
                                 }).catch(() => '');
-                                results.push(`Puzzle type: ${puzzleType}`);
                                 if (instruction)
                                     results.push(`Instruction: "${instruction}"`);
-                                const screenshotPath = join(homedir(), '.aurix-funcaptcha-puzzle.png');
-                                try {
-                                    await fcFrame.locator('#challenge-stage, .challenge-content, .game-content, body').first().screenshot({ path: screenshotPath });
-                                }
-                                catch {
-                                    await p.screenshot({ path: screenshotPath });
-                                }
-                                results.push(`Puzzle screenshot: ${screenshotPath}`);
-                                const interactiveEls = await fcFrame.evaluate(() => {
-                                    const els = [];
-                                    document.querySelectorAll('canvas, img, [class*="game"], [class*="challenge"], [class*="puzzle"], button, input[type="range"], .slider').forEach(el => {
-                                        els.push(`${el.tagName.toLowerCase()}.${el.className?.toString().slice(0, 60) || ''} [${el.getAttribute('role') || ''}]`);
-                                    });
-                                    return els;
-                                }).catch(() => []);
-                                if (interactiveEls.length > 0) {
-                                    results.push(`Interactive elements: ${interactiveEls.slice(0, 10).join(', ')}`);
+                                const maxAttempts = 3;
+                                for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                                    if (attempt > 0)
+                                        results.push(`\nRetry ${attempt}/${maxAttempts - 1}...`);
+                                    const screenshotPath = join(homedir(), '.aurix-funcaptcha-puzzle.png');
+                                    try {
+                                        await fcFrame.locator('#challenge-stage, .challenge-content, .game-content, body').first().screenshot({ path: screenshotPath });
+                                    }
+                                    catch {
+                                        await p.screenshot({ path: screenshotPath });
+                                    }
+                                    try {
+                                        const ssBase64 = readFileBase64(screenshotPath);
+                                        const prompt = instruction
+                                            ? `This is a FunCaptcha puzzle. The instruction is: "${instruction}". Analyze the image and tell me EXACTLY what to do. Reply in this format:\n- For clicking: "CLICK x,y" (pixel coordinates relative to the puzzle image)\n- For dragging: "DRAG fromX,fromY toX,toY"\n- For rotating: "ROTATE degrees" (estimated rotation angle in degrees)\n- For selecting an option: "CLICK x,y" on the correct answer\nBe precise with coordinates.`
+                                            : `This is a FunCaptcha puzzle. Analyze the image and determine what action is needed to solve it. Reply in this format:\n- For clicking: "CLICK x,y"\n- For dragging: "DRAG fromX,fromY toX,toY"\n- For rotating: "ROTATE degrees"\nBe precise with coordinates.`;
+                                        const visionResp = await visionClassify(ssBase64, prompt);
+                                        results.push(`Vision model: "${visionResp}"`);
+                                        const clickMatch = visionResp.match(/CLICK\s+([\d.]+)\s*,\s*([\d.]+)/i);
+                                        const dragMatch = visionResp.match(/DRAG\s+([\d.]+)\s*,\s*([\d.]+)\s+([\d.]+)\s*,\s*([\d.]+)/i);
+                                        const rotateMatch = visionResp.match(/ROTATE\s+(-?[\d.]+)/i);
+                                        const puzzleBox = await fcFrame.locator('#challenge-stage, .challenge-content, .game-content, body').first().boundingBox().catch(() => null);
+                                        const offsetX = puzzleBox?.x || 0;
+                                        const offsetY = puzzleBox?.y || 0;
+                                        if (clickMatch) {
+                                            const cx = offsetX + parseFloat(clickMatch[1]);
+                                            const cy = offsetY + parseFloat(clickMatch[2]);
+                                            await humanMove(cx, cy, p);
+                                            await p.waitForTimeout(100 + Math.random() * 150);
+                                            await p.mouse.down();
+                                            await p.waitForTimeout(60 + Math.random() * 80);
+                                            await p.mouse.up();
+                                            results.push(`Clicked at (${Math.round(cx)}, ${Math.round(cy)})`);
+                                            await p.waitForTimeout(2000);
+                                        }
+                                        else if (dragMatch) {
+                                            const fromX = offsetX + parseFloat(dragMatch[1]);
+                                            const fromY = offsetY + parseFloat(dragMatch[2]);
+                                            const toX = offsetX + parseFloat(dragMatch[3]);
+                                            const toY = offsetY + parseFloat(dragMatch[4]);
+                                            await humanMove(fromX, fromY, p);
+                                            await p.waitForTimeout(150 + Math.random() * 200);
+                                            await p.mouse.down();
+                                            await p.waitForTimeout(200 + Math.random() * 300);
+                                            const steps = 20 + Math.floor(Math.random() * 15);
+                                            for (let i = 1; i <= steps; i++) {
+                                                const progress = i / steps;
+                                                const eased = progress < 0.5 ? 2 * progress * progress : 1 - Math.pow(-2 * progress + 2, 2) / 2;
+                                                await p.mouse.move(fromX + (toX - fromX) * eased, fromY + (toY - fromY) * eased + (Math.random() - 0.5) * 2);
+                                                await p.waitForTimeout(10 + Math.random() * 15);
+                                            }
+                                            await p.mouse.move(toX, toY);
+                                            await p.waitForTimeout(150);
+                                            await p.mouse.up();
+                                            results.push(`Dragged from (${Math.round(fromX)},${Math.round(fromY)}) to (${Math.round(toX)},${Math.round(toY)})`);
+                                            await p.waitForTimeout(2000);
+                                        }
+                                        else if (rotateMatch) {
+                                            const degrees = parseFloat(rotateMatch[1]);
+                                            const rotator = fcFrame.locator('.rotator, [class*="rotate"], [class*="spinner"], canvas, .game-item').first();
+                                            if (await rotator.count() > 0) {
+                                                const rBox = await rotator.boundingBox();
+                                                if (rBox) {
+                                                    const cx = rBox.x + rBox.width / 2;
+                                                    const cy = rBox.y + rBox.height / 2;
+                                                    const radius = rBox.width / 2;
+                                                    const startX = cx + radius;
+                                                    const startY = cy;
+                                                    const endAngle = (degrees * Math.PI) / 180;
+                                                    const endX = cx + radius * Math.cos(endAngle);
+                                                    const endY = cy + radius * Math.sin(endAngle);
+                                                    await humanMove(startX, startY, p);
+                                                    await p.waitForTimeout(150);
+                                                    await p.mouse.down();
+                                                    await p.waitForTimeout(200);
+                                                    const steps = 30;
+                                                    for (let i = 1; i <= steps; i++) {
+                                                        const angle = (endAngle * i) / steps;
+                                                        await p.mouse.move(cx + radius * Math.cos(angle), cy + radius * Math.sin(angle));
+                                                        await p.waitForTimeout(15 + Math.random() * 10);
+                                                    }
+                                                    await p.mouse.move(endX, endY);
+                                                    await p.waitForTimeout(150);
+                                                    await p.mouse.up();
+                                                    results.push(`Rotated ${degrees}°`);
+                                                    await p.waitForTimeout(2000);
+                                                }
+                                            }
+                                            else {
+                                                results.push('[WARN] No rotatable element found');
+                                            }
+                                        }
+                                        else {
+                                            results.push(`Could not parse vision model response: "${visionResp}"`);
+                                            results.push('Falling back to manual mode. Read the puzzle screenshot and use click/drag-to/evaluate to solve.');
+                                            break;
+                                        }
+                                        const stillChallenge = await fcFrame.locator('#challenge-stage, .challenge-content').count();
+                                        const successIndicators = await fcFrame.locator('[class*="success"], [class*="correct"], [class*="verified"], .game-success').count();
+                                        if (successIndicators > 0) {
+                                            results.push('[OK] FunCaptcha solved!');
+                                            break;
+                                        }
+                                        if (stillChallenge === 0) {
+                                            results.push('[OK] FunCaptcha challenge dismissed — likely solved.');
+                                            break;
+                                        }
+                                        if (attempt === maxAttempts - 1) {
+                                            results.push(`Auto-solve exhausted after ${maxAttempts} attempts. Use click/drag-to/evaluate for manual solving.`);
+                                        }
+                                        else {
+                                            results.push('Attempt did not solve, retrying...');
+                                            await p.waitForTimeout(1500);
+                                        }
+                                    }
+                                    catch (e) {
+                                        results.push(`Vision model failed: ${e.message}`);
+                                        results.push('Auto-solve requires a vision-capable model. Read the puzzle screenshot at .aurix-funcaptcha-puzzle.png and use click/drag-to/evaluate to solve manually.');
+                                        break;
+                                    }
                                 }
-                                results.push('');
-                                results.push('To solve FunCaptcha:');
-                                results.push('1. Read the puzzle screenshot to understand the challenge');
-                                results.push('2. For rotation puzzles: use "drag-to" to rotate the object to the correct position');
-                                results.push('3. For image match: use "click" on matching images');
-                                results.push('4. For drag-drop: use "drag-to" with source and target coordinates');
-                                results.push('5. Use "evaluate" with JavaScript if puzzle needs programmatic interaction');
                             }
                             else {
                                 results.push(err('FunCaptcha frame not found', 'Use "detect-captcha" to scan the page first'));
                             }
                         }
                         catch (e) {
-                            results.push(err(`FunCaptcha analysis failed: ${e.message}`));
+                            results.push(err(`FunCaptcha auto-solve failed: ${e.message}`));
                         }
                     }
                     if (captchaType === 'mtcaptcha' || captchaType === 'geetest') {
@@ -1558,37 +1945,6 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         const hasSlider = await targetFrame.locator('.geetest_slider_button, .geetest_slider, [class*="slider_button"], [class*="slider-track"]').count();
                         if (hasSlider > 0) {
                             results.push('Type: SLIDER puzzle');
-                            results.push('The puzzle requires dragging a piece to fill a gap.');
-                            results.push('');
-                            const sliderInfo = await targetFrame.evaluate(() => {
-                                const info = {};
-                                const cut = document.querySelector('.geetest_cut, .geetest_piece_bg, [class*="geetest_cut"], [class*="slider_cut"], [class*="puzzle-gap"]');
-                                if (cut) {
-                                    const cutRect = cut.getBoundingClientRect();
-                                    const style = window.getComputedStyle(cut);
-                                    info.cut = { left: cutRect.left, width: cutRect.width, styleLeft: parseFloat(style.left) || null, transform: style.transform || null };
-                                }
-                                const bg = document.querySelector('.geetest_canvas_bg, .geetest_bg, [class*="geetest_canvas"], canvas[class*="bg"]');
-                                if (bg) {
-                                    const bgRect = bg.getBoundingClientRect();
-                                    info.bg = { left: bgRect.left, width: bgRect.width };
-                                }
-                                const piece = document.querySelector('.geetest_piece, .geetest_slider_piece, [class*="slider_piece"]');
-                                if (piece) {
-                                    const pieceRect = piece.getBoundingClientRect();
-                                    info.piece = { left: pieceRect.left, width: pieceRect.width };
-                                }
-                                const slider = document.querySelector('.geetest_slider_button, .geetest_slider_knob, [class*="slider_button"]');
-                                if (slider) {
-                                    const sliderRect = slider.getBoundingClientRect();
-                                    info.slider = { left: sliderRect.left, width: sliderRect.width };
-                                }
-                                const track = document.querySelector('.geetest_slider_track, .geetest_slider, [class*="slider_track"]');
-                                if (track) {
-                                    info.track = { width: track.getBoundingClientRect().width };
-                                }
-                                return info;
-                            });
                             const puzzleEl = targetFrame.locator('.geetest_panel, .geetest_widget, [class*="geetest_container"]').first();
                             const screenshotPath = join(homedir(), '.aurix-slider-puzzle.png');
                             try {
@@ -1601,44 +1957,136 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                 await p.screenshot({ path: screenshotPath });
                             }
                             results.push(`Puzzle screenshot: ${screenshotPath}`);
-                            let gapOffset = null;
-                            if (sliderInfo.cut && sliderInfo.bg) {
-                                if (sliderInfo.cut.styleLeft && sliderInfo.cut.styleLeft > 0) {
-                                    gapOffset = Math.round(sliderInfo.cut.styleLeft);
-                                    results.push(`Gap position (CSS left): ${gapOffset}px from puzzle left edge`);
+                            const maxAttempts = 3;
+                            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                                if (attempt > 0)
+                                    results.push(`\nSlider retry ${attempt}/${maxAttempts - 1}...`);
+                                const sliderInfo = await targetFrame.evaluate(() => {
+                                    const info = {};
+                                    const cut = document.querySelector('.geetest_cut, .geetest_piece_bg, [class*="geetest_cut"], [class*="slider_cut"], [class*="puzzle-gap"]');
+                                    if (cut) {
+                                        const cutRect = cut.getBoundingClientRect();
+                                        const style = window.getComputedStyle(cut);
+                                        info.cut = { left: cutRect.left, width: cutRect.width, styleLeft: parseFloat(style.left) || null, transform: style.transform || null };
+                                    }
+                                    const bg = document.querySelector('.geetest_canvas_bg, .geetest_bg, [class*="geetest_canvas"], canvas[class*="bg"]');
+                                    if (bg) {
+                                        const bgRect = bg.getBoundingClientRect();
+                                        info.bg = { left: bgRect.left, width: bgRect.width };
+                                    }
+                                    const piece = document.querySelector('.geetest_piece, .geetest_slider_piece, [class*="slider_piece"]');
+                                    if (piece) {
+                                        const pieceRect = piece.getBoundingClientRect();
+                                        info.piece = { left: pieceRect.left, width: pieceRect.width };
+                                    }
+                                    const slider = document.querySelector('.geetest_slider_button, .geetest_slider_knob, [class*="slider_button"]');
+                                    if (slider) {
+                                        const sliderRect = slider.getBoundingClientRect();
+                                        info.slider = { left: sliderRect.left, width: sliderRect.width, centerX: sliderRect.left + sliderRect.width / 2, centerY: sliderRect.top + sliderRect.height / 2 };
+                                    }
+                                    const track = document.querySelector('.geetest_slider_track, .geetest_slider, [class*="slider_track"]');
+                                    if (track)
+                                        info.track = { width: track.getBoundingClientRect().width };
+                                    return info;
+                                });
+                                let gapOffset = null;
+                                if (sliderInfo.cut && sliderInfo.bg) {
+                                    if (sliderInfo.cut.styleLeft && sliderInfo.cut.styleLeft > 0) {
+                                        gapOffset = Math.round(sliderInfo.cut.styleLeft);
+                                    }
+                                    else {
+                                        gapOffset = Math.round(sliderInfo.cut.left - sliderInfo.bg.left);
+                                    }
                                 }
-                                else {
-                                    gapOffset = Math.round(sliderInfo.cut.left - sliderInfo.bg.left);
-                                    results.push(`Gap position (rect): ${gapOffset}px from puzzle left edge`);
+                                if (gapOffset === null && sliderInfo.cut?.transform && sliderInfo.cut.transform !== 'none') {
+                                    const match = sliderInfo.cut.transform.match(/matrix\(.*?,\s*([\d.]+)/);
+                                    if (match)
+                                        gapOffset = Math.round(parseFloat(match[1]));
                                 }
-                            }
-                            if (gapOffset === null && sliderInfo.cut?.transform && sliderInfo.cut.transform !== 'none') {
-                                const match = sliderInfo.cut.transform.match(/matrix\(.*?,\s*([\d.]+)/);
-                                if (match) {
-                                    gapOffset = Math.round(parseFloat(match[1]));
-                                    results.push(`Gap position (transform): ${gapOffset}px from puzzle left edge`);
+                                if (gapOffset === null) {
+                                    results.push('DOM gap detection failed, using vision model...');
+                                    try {
+                                        const ssBase64 = readFileBase64(screenshotPath);
+                                        const visionResp = await visionClassify(ssBase64, 'This is a slider puzzle captcha. There is a gap/hole in the background image where a puzzle piece needs to go. Estimate the horizontal pixel position of the CENTER of the gap, measured from the LEFT edge of the puzzle image. Reply with ONLY the number (e.g. "145").');
+                                        const parsed = parseInt(visionResp.replace(/[^\d]/g, ''));
+                                        if (!isNaN(parsed) && parsed > 10 && parsed < 500) {
+                                            gapOffset = parsed;
+                                            results.push(`Vision model: gap at ~${gapOffset}px`);
+                                        }
+                                        else {
+                                            results.push(`Vision model returned: "${visionResp}" — could not parse gap position`);
+                                        }
+                                    }
+                                    catch (e) {
+                                        results.push(`Vision model failed: ${e.message}`);
+                                    }
+                                }
+                                if (gapOffset === null) {
+                                    results.push('[WARN] Could not determine gap position. Use "slider-analyze" for manual analysis, then "drag-to" to slide.');
+                                    break;
                                 }
-                            }
-                            if (sliderInfo.slider)
-                                results.push(`Slider handle: x=${Math.round(sliderInfo.slider.left)}, width=${Math.round(sliderInfo.slider.width)}`);
-                            if (sliderInfo.track)
-                                results.push(`Track width: ${Math.round(sliderInfo.track.width)}px`);
-                            if (gapOffset !== null) {
                                 const pieceHalf = Math.round((sliderInfo.piece?.width || 44) / 2);
                                 const adjusted = gapOffset - pieceHalf;
-                                results.push('');
-                                results.push(`[OK] RECOMMENDED: drag-to target=".geetest_slider_button" value="${adjusted},0"`);
-                                results.push(`(gap ${gapOffset}px - half piece ${pieceHalf}px = ${adjusted}px drag distance)`);
-                            }
-                            else {
-                                results.push('');
-                                results.push('[WARN] Could not auto-detect gap. Look at the puzzle screenshot, find the gap/hole, and estimate the pixel offset.');
-                                results.push('Then: drag-to target=".geetest_slider_button" value="<estimated_px>,0"');
+                                results.push(`Gap: ${gapOffset}px, piece half: ${pieceHalf}px, drag distance: ${adjusted}px`);
+                                if (sliderInfo.slider) {
+                                    try {
+                                        const startX = sliderInfo.slider.centerX;
+                                        const startY = sliderInfo.slider.centerY;
+                                        const endX = startX + adjusted;
+                                        await humanMove(startX, startY, p);
+                                        await p.waitForTimeout(150 + Math.random() * 250);
+                                        await p.mouse.down();
+                                        await p.waitForTimeout(200 + Math.random() * 300);
+                                        const steps = 25 + Math.floor(Math.random() * 20);
+                                        for (let i = 1; i <= steps; i++) {
+                                            const progress = i / steps;
+                                            const eased = progress < 0.5 ? 2 * progress * progress : 1 - Math.pow(-2 * progress + 2, 2) / 2;
+                                            const x = startX + adjusted * eased + (Math.random() - 0.5) * 2;
+                                            const y = startY + (Math.random() - 0.5) * 2;
+                                            await p.mouse.move(x, y);
+                                            await p.waitForTimeout(10 + Math.random() * 20);
+                                        }
+                                        await p.mouse.move(endX, startY);
+                                        await p.waitForTimeout(150);
+                                        await p.mouse.up();
+                                        await p.waitForTimeout(2000);
+                                        results.push('Slider dragged, checking result...');
+                                        const successEl = await targetFrame.locator('.geetest_success, .geetest_tip_success, [class*="success"], [class*="verified"]').count();
+                                        if (successEl > 0) {
+                                            results.push('[OK] Slider captcha solved!');
+                                            break;
+                                        }
+                                        const failEl = await targetFrame.locator('.geetest_fail, .geetest_tip_fail, [class*="fail"], [class*="error"], [class*="retry"]').count();
+                                        if (failEl > 0) {
+                                            results.push('Slider attempt failed, retrying...');
+                                            const refreshBtn = targetFrame.locator('.geetest_refresh, [class*="refresh"], [class*="retry"]').first();
+                                            if (await refreshBtn.count() > 0)
+                                                await refreshBtn.click().catch(() => { });
+                                            await p.waitForTimeout(1500);
+                                            try {
+                                                if (await puzzleEl.count() > 0)
+                                                    await puzzleEl.screenshot({ path: screenshotPath });
+                                            }
+                                            catch { }
+                                            continue;
+                                        }
+                                        results.push('[OK] Slider dragged — outcome unconfirmed, check page state.');
+                                        break;
+                                    }
+                                    catch (e) {
+                                        results.push(`Drag failed: ${e.message}`);
+                                        break;
+                                    }
+                                }
+                                else {
+                                    results.push('[WARN] Slider handle not found in DOM.');
+                                    break;
+                                }
                             }
                         }
                         else {
                             results.push('Type: IMAGE challenge');
-                            const gridResult = await analyzeImageChallenge(p, targetFrame, captchaType);
+                            const gridResult = await solveCaptchaGrid(p, targetFrame, captchaType);
                             results.push(gridResult);
                         }
                     }
@@ -1649,11 +2097,32 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                             const screenshotPath = join(homedir(), '.aurix-captcha-challenge.png');
                             await imgCaptcha.first().screenshot({ path: screenshotPath });
                             results.push(`Captcha image saved: ${screenshotPath}`);
-                            results.push('Read the text from the screenshot and use "fill" to type it into the captcha input field.');
-                            const input = p.locator('input[name*="captcha"], input[id*="captcha"], input[placeholder*="captcha" i], input[placeholder*="code" i]');
-                            if (await input.count() > 0) {
-                                const name = await input.first().getAttribute('name') || await input.first().getAttribute('id') || 'captcha input';
-                                results.push(`Captcha input field found: ${name}`);
+                            try {
+                                const ssBase64 = readFileBase64(screenshotPath);
+                                const visionResp = await visionClassify(ssBase64, 'Read the text/numbers in this captcha image. Reply with ONLY the exact text shown, nothing else.');
+                                const captchaText = visionResp.replace(/[^a-zA-Z0-9]/g, '').trim();
+                                if (captchaText.length >= 2) {
+                                    const input = p.locator('input[name*="captcha"], input[id*="captcha"], input[placeholder*="captcha" i], input[placeholder*="code" i]');
+                                    if (await input.count() > 0) {
+                                        await input.first().click();
+                                        await input.first().fill('');
+                                        for (const char of captchaText) {
+                                            await input.first().type(char, { delay: 80 + Math.random() * 120 });
+                                        }
+                                        results.push(`[OK] Auto-filled captcha text: "${captchaText}"`);
+                                    }
+                                    else {
+                                        results.push(`Vision model read: "${captchaText}" — but no captcha input field found. Use "fill" to type it manually.`);
+                                    }
+                                }
+                                else {
+                                    results.push(`Vision model returned: "${visionResp}" — could not read captcha text`);
+                                    results.push('Read the screenshot and use "fill" to type the captcha text manually.');
+                                }
+                            }
+                            catch (e) {
+                                results.push(`Vision auto-fill failed: ${e.message}`);
+                                results.push('Read the captcha screenshot and use "fill" to type it manually.');
                             }
                         }
                         else {
@@ -1712,7 +2181,8 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                 }
                 case 'click-tile': {
                     const p = await ensureBrowser();
-                    const tileIndex = parseInt(value || target || '0');
+                    const rawValue = (value || target || '0').toString();
+                    const tileIndices = rawValue.split(',').map(s => parseInt(s.trim())).filter(n => !isNaN(n));
                     const frames = p.frames();
                     let challengeFrame = null;
                     let provider = 'unknown';
@@ -1736,59 +2206,111 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     }
                     if (!challengeFrame)
                         challengeFrame = p;
-                    const tiles = await findGridTiles(challengeFrame, provider);
-                    if (tiles.length === 0)
+                    const initialTiles = await findGridTiles(challengeFrame, provider);
+                    if (initialTiles.length === 0)
                         return err('No grid tiles found', 'Use "captcha-grid" to scan the challenge first');
-                    if (tileIndex < 0 || tileIndex >= tiles.length)
-                        return err(`Tile index ${tileIndex} out of range (0-${tiles.length - 1})`);
-                    try {
-                        const tile = tiles[tileIndex];
-                        const isRecaptcha = provider === 'recaptcha';
-                        const selectedClass = isRecaptcha
-                            ? '.rc-imageselect-tileselected, .rc-imageselect-dynamic-selected, .rc-imageselect-tile.rc-imageselect-tileselected'
-                            : '.task-image.selected, .task .selected';
-                        const selectedBefore = await challengeFrame.locator(selectedClass).count().catch(() => 0);
-                        const tileBox = await tile.boundingBox();
-                        if (tileBox) {
-                            const clickX = tileBox.x + tileBox.width * (0.3 + Math.random() * 0.4);
-                            const clickY = tileBox.y + tileBox.height * (0.3 + Math.random() * 0.4);
-                            await humanMove(clickX, clickY, p);
-                            await p.waitForTimeout(80 + Math.random() * 120);
-                            await p.mouse.down();
-                            await p.waitForTimeout(60 + Math.random() * 100);
-                            await p.mouse.up();
+                    for (const idx of tileIndices) {
+                        if (idx < 0 || idx >= initialTiles.length)
+                            return err(`Tile index ${idx} out of range (0-${initialTiles.length - 1})`);
+                    }
+                    const isRecaptcha = provider === 'recaptcha';
+                    const selectedClass = isRecaptcha
+                        ? '.rc-imageselect-tileselected, .rc-imageselect-dynamic-selected, .rc-imageselect-tile.rc-imageselect-tileselected'
+                        : '.task-image.selected, .task .selected';
+                    let instruction = '';
+                    if (isRecaptcha) {
+                        try {
+                            const instrEl = challengeFrame.locator('.rc-imageselect-instructions, .prompt-text, .prompt-text-h');
+                            if (await instrEl.count() > 0)
+                                instruction = (await instrEl.first().textContent() || '').trim();
+                            if (!instruction) {
+                                const st = challengeFrame.locator('strong').first();
+                                if (await st.count() > 0)
+                                    instruction = (await st.textContent() || '').trim();
+                            }
                         }
-                        else {
-                            await tile.click({ force: true });
-                        }
-                        await p.waitForTimeout(500 + Math.random() * 400);
-                        const selectedCount = await challengeFrame.locator(selectedClass).count().catch(() => 0);
-                        const selectionChanged = selectedCount !== selectedBefore;
-                        const clickStatus = selectionChanged
-                            ? `selection changed (${selectedBefore} → ${selectedCount})`
-                            : `selection unchanged (${selectedCount}) — click may not have registered, or this tile toggled off`;
-                        if (isRecaptcha) {
-                            await p.waitForTimeout(1500 + Math.random() * 1000);
-                            const newTiles = await findGridTiles(challengeFrame, provider);
-                            const screenshotPath = join(homedir(), `.aurix-tile-after-${tileIndex}.png`);
-                            await challengeFrame.locator('.rc-imageselect-table-33, .rc-imageselect-table-44, table').first().screenshot({ path: screenshotPath }).catch(() => p.screenshot({ path: screenshotPath }));
-                            return ok(`Clicked tile ${tileIndex}`, {
-                                selection: clickStatus,
-                                'new tile': 'appeared — check screenshot and evaluate',
-                                screenshot: screenshotPath,
-                                next: 'Use "click-tile" for next matching tile, or "captcha-verify" when done',
-                            });
+                        catch { }
+                    }
+                    const results = [];
+                    results.push(`Clicking ${tileIndices.length} tile(s): [${tileIndices.join(', ')}]`);
+                    for (const tileIndex of tileIndices) {
+                        try {
+                            const currentTiles = await findGridTiles(challengeFrame, provider);
+                            if (tileIndex >= currentTiles.length) {
+                                results.push(`  Tile ${tileIndex}: out of range (${currentTiles.length} tiles now), skipping`);
+                                continue;
+                            }
+                            const tile = currentTiles[tileIndex];
+                            const selectedBefore = await challengeFrame.locator(selectedClass).count().catch(() => 0);
+                            const tileBox = await tile.boundingBox();
+                            if (tileBox) {
+                                const clickX = tileBox.x + tileBox.width * (0.3 + Math.random() * 0.4);
+                                const clickY = tileBox.y + tileBox.height * (0.3 + Math.random() * 0.4);
+                                await humanMove(clickX, clickY, p);
+                                await p.waitForTimeout(80 + Math.random() * 120);
+                                await p.mouse.down();
+                                await p.waitForTimeout(60 + Math.random() * 100);
+                                await p.mouse.up();
+                            }
+                            else {
+                                await tile.click({ force: true });
+                            }
+                            await p.waitForTimeout(500 + Math.random() * 400);
+                            const selectedCount = await challengeFrame.locator(selectedClass).count().catch(() => 0);
+                            const clickStatus = selectedCount !== selectedBefore
+                                ? `selected (${selectedBefore} → ${selectedCount})`
+                                : `unchanged (${selectedCount})`;
+                            results.push(`  Tile ${tileIndex}: ${clickStatus}`);
+                            if (isRecaptcha) {
+                                await p.waitForTimeout(1500 + Math.random() * 1000);
+                                const newTiles = await findGridTiles(challengeFrame, provider);
+                                const afterPath = join(homedir(), `.aurix-tile-after-${tileIndex}.png`);
+                                try {
+                                    await challengeFrame.locator('.rc-imageselect-table-33, .rc-imageselect-table-44, table').first().screenshot({ path: afterPath }).catch(() => p.screenshot({ path: afterPath }));
+                                }
+                                catch { }
+                                if (tileIndex < newTiles.length && instruction) {
+                                    try {
+                                        await newTiles[tileIndex].screenshot({ path: afterPath });
+                                        const newBase64 = readFileBase64(afterPath);
+                                        const newResp = await visionClassify(newBase64, `Does this image contain ${instruction}? Reply YES or NO only.`);
+                                        if (newResp.toLowerCase().includes('yes')) {
+                                            const newTile = newTiles[tileIndex];
+                                            const newBox = await newTile.boundingBox();
+                                            if (newBox) {
+                                                const nx = newBox.x + newBox.width * (0.3 + Math.random() * 0.4);
+                                                const ny = newBox.y + newBox.height * (0.3 + Math.random() * 0.4);
+                                                await humanMove(nx, ny, p);
+                                                await p.waitForTimeout(80 + Math.random() * 120);
+                                                await p.mouse.down();
+                                                await p.waitForTimeout(60 + Math.random() * 100);
+                                                await p.mouse.up();
+                                                results.push(`  → Replacement tile ${tileIndex} also matched, clicked`);
+                                                await p.waitForTimeout(1500 + Math.random() * 1000);
+                                            }
+                                        }
+                                        else {
+                                            results.push(`  → Replacement tile ${tileIndex} doesn't match`);
+                                        }
+                                    }
+                                    catch { }
+                                }
+                            }
+                        }
+                        catch (e) {
+                            results.push(`  Tile ${tileIndex}: FAILED — ${e.message}`);
                         }
-                        const ss = await autoScreenshot(p, 'click-tile');
-                        return ok(`Clicked tile ${tileIndex}`, {
-                            selection: clickStatus,
-                            screenshot: ss,
-                            next: 'Continue clicking matching tiles, then use "captcha-verify"',
-                        });
                     }
-                    catch (e) {
-                        return err(`Failed to click tile ${tileIndex}: ${e.message}`, 'Use "captcha-grid" to re-scan the challenge');
+                    if (isRecaptcha) {
+                        results.push('');
+                        results.push('Use "captcha-verify" when all matching tiles are clicked, or "captcha-grid" to re-analyze.');
                     }
+                    else {
+                        const ss = await autoScreenshot(p, 'click-tile');
+                        results.push(`Screenshot: ${ss}`);
+                        results.push('Continue clicking matching tiles, then use "captcha-verify"');
+                    }
+                    return results.join('\n');
                 }
                 case 'captcha-verify': {
                     const p = await ensureBrowser();
@@ -1815,6 +2337,18 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     }
                     if (!challengeFrame)
                         challengeFrame = p;
+                    const timeSinceAnalyze = _lastGridAnalyzeTime > 0 ? Date.now() - _lastGridAnalyzeTime : 0;
+                    if (timeSinceAnalyze > 90_000 && _lastGridAnalyzeTime > 0) {
+                        const results = [];
+                        results.push(`[WARN] Grid was analyzed ${Math.round(timeSinceAnalyze / 1000)}s ago — challenge likely refreshed.`);
+                        results.push('Re-analyzing before verify...');
+                        try {
+                            const reAnalyze = await analyzeImageChallenge(p, challengeFrame, provider);
+                            results.push(reAnalyze);
+                        }
+                        catch { }
+                        return results.join('\n');
+                    }
                     try {
                         let verifyBtn = challengeFrame.locator('#recaptcha-verify-button, .rc-button-submit, .button-submit, [id*="verify"]');
                         if (await verifyBtn.count() === 0) {
@@ -1830,25 +2364,71 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         if (errorText > 0) {
                             const errorMsg = await challengeFrame.locator('.rc-imageselect-incorrect-response, .error-message').first().textContent().catch(() => 'Incorrect answer');
                             await p.screenshot({ path: screenshotPath });
-                            return err(`Verification failed: "${errorMsg}"`, `Challenge refreshed. Use "captcha-grid" to re-analyze, then click matching tiles again. Screenshot: ${screenshotPath}`);
+                            const results = [];
+                            results.push(`Verification failed: "${errorMsg}". Auto-retrying...`);
+                            const maxRetries = 3;
+                            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                                results.push(`\nRetry ${attempt + 1}/${maxRetries}...`);
+                                await p.waitForTimeout(2000);
+                                const currentFrames = p.frames();
+                                const retryFrame = currentFrames.find((f) => {
+                                    const u = f.url();
+                                    return (u.includes('/recaptcha/') && u.includes('/bframe')) ||
+                                        (u.includes('hcaptcha') && u.includes('challenge'));
+                                });
+                                if (!retryFrame) {
+                                    results.push('Challenge frame gone — captcha may be solved');
+                                    await p.screenshot({ path: screenshotPath });
+                                    return results.join('\n');
+                                }
+                                const retryProvider = retryFrame.url().includes('hcaptcha') ? 'hcaptcha' : 'recaptcha';
+                                const solveResult = await solveCaptchaGrid(p, retryFrame, retryProvider);
+                                results.push(solveResult);
+                                if (solveResult.includes('Captcha solved!')) {
+                                    return results.join('\n');
+                                }
+                            }
+                            results.push(`\nAuto-retry exhausted after ${maxRetries} attempts. Use "captcha-grid" and "click-tile" for manual solving.`);
+                            return results.join('\n');
                         }
                         const newChallenge = await challengeFrame.locator('.rc-imageselect-instructions, .prompt-text').count();
                         if (newChallenge > 0) {
                             const instruction = await challengeFrame.locator('.rc-imageselect-instructions, .prompt-text').first().textContent().catch(() => '');
                             await p.screenshot({ path: screenshotPath });
-                            return warn(`New challenge appeared: "${instruction}"`, {
-                                screenshot: screenshotPath,
-                                next: 'Use "captcha-grid" to analyze and "click-tile" to solve',
-                            });
+                            const results = [];
+                            results.push(`New challenge appeared: "${instruction}". Auto-solving...`);
+                            const maxRetries = 3;
+                            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                                if (attempt > 0)
+                                    results.push(`\nRetry ${attempt}/${maxRetries - 1}...`);
+                                const currentFrames = p.frames();
+                                const retryFrame = currentFrames.find((f) => {
+                                    const u = f.url();
+                                    return (u.includes('/recaptcha/') && u.includes('/bframe')) ||
+                                        (u.includes('hcaptcha') && u.includes('challenge'));
+                                });
+                                if (!retryFrame) {
+                                    results.push('Challenge frame gone — captcha may be solved');
+                                    return results.join('\n');
+                                }
+                                const retryProvider = retryFrame.url().includes('hcaptcha') ? 'hcaptcha' : 'recaptcha';
+                                const solveResult = await solveCaptchaGrid(p, retryFrame, retryProvider);
+                                results.push(solveResult);
+                                if (solveResult.includes('Captcha solved!'))
+                                    return results.join('\n');
+                                await p.waitForTimeout(2000);
+                            }
+                            results.push(`\nAuto-solve exhausted. Use "captcha-grid" and "click-tile" manually.`);
+                            return results.join('\n');
                         }
                         await p.screenshot({ path: screenshotPath });
                         return ok('Verification submitted', {
                             screenshot: screenshotPath,
-                            note: 'Check if the form/page progressed. If verification widget reappears, use "captcha-grid" again.',
+                            note: 'Check if the form/page progressed. If verification widget reappears, use "solve-captcha" again.',
                         });
                     }
                     catch (e) {
-                        return err(`Verify failed: ${e.message}`, 'Use "captcha-grid" to re-scan and retry');
+                        return err(`Verify failed: ${e.message}`, 'Use "solve-captcha" to retry automatically');
                     }
                 }
                 case 'slider-analyze': {
@@ -1940,19 +2520,63 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         const pieceHalfWidth = Math.round((sliderInfo.piece.width || 44) / 2);
                         const adjustedOffset = gapOffset - pieceHalfWidth;
                         results.push('');
-                        results.push(`[OK] RECOMMENDED OFFSET: drag-to value="${adjustedOffset},0"`);
-                        results.push(`(gap at ${gapOffset}px minus half piece width ${pieceHalfWidth}px = ${adjustedOffset}px)`);
+                        results.push(`[OK] Gap at ${gapOffset}px, piece half ${pieceHalfWidth}px, drag distance ${adjustedOffset}px`);
+                        gapOffset = adjustedOffset;
                     }
                     else if (gapOffset !== null) {
                         results.push('');
-                        results.push(`[OK] RECOMMENDED OFFSET: drag-to value="${gapOffset},0"`);
+                        results.push(`[OK] Gap at ${gapOffset}px`);
                     }
                     else {
                         results.push('');
-                        results.push('[WARN] Could not auto-detect gap position from DOM.');
-                        results.push('Look at the puzzle screenshot to find where the gap/hole is.');
-                        results.push('Estimate the pixel distance from the LEFT edge of the puzzle to the CENTER of the gap.');
-                        results.push('Then use: drag-to target=".geetest_slider_button" value="<estimated_px>,0"');
+                        results.push('DOM gap detection failed, trying vision model...');
+                        try {
+                            const ssBase64 = readFileBase64(screenshotPath);
+                            const visionResp = await visionClassify(ssBase64, 'This is a slider puzzle captcha. There is a gap/hole in the background image where a puzzle piece needs to go. Estimate the horizontal pixel position of the CENTER of the gap, measured from the LEFT edge of the puzzle image. Reply with ONLY the number (e.g. "145").');
+                            const parsed = parseInt(visionResp.replace(/[^\d]/g, ''));
+                            if (!isNaN(parsed) && parsed > 10 && parsed < 500) {
+                                gapOffset = parsed;
+                                results.push(`Vision model: gap at ~${gapOffset}px`);
+                            }
+                            else {
+                                results.push(`Vision model returned: "${visionResp}" — could not parse`);
+                            }
+                        }
+                        catch (e) {
+                            results.push(`Vision model failed: ${e.message}`);
+                        }
+                    }
+                    if (gapOffset !== null && sliderInfo.slider) {
+                        results.push('Auto-dragging slider...');
+                        try {
+                            const startX = sliderInfo.slider.centerX || (sliderInfo.slider.left + sliderInfo.slider.width / 2);
+                            const startY = sliderInfo.slider.centerY || (sliderInfo.slider.top + sliderInfo.slider.height / 2);
+                            const endX = startX + gapOffset;
+                            await humanMove(startX, startY, p);
+                            await p.waitForTimeout(150 + Math.random() * 250);
+                            await p.mouse.down();
+                            await p.waitForTimeout(200 + Math.random() * 300);
+                            const steps = 25 + Math.floor(Math.random() * 20);
+                            for (let i = 1; i <= steps; i++) {
+                                const progress = i / steps;
+                                const eased = progress < 0.5 ? 2 * progress * progress : 1 - Math.pow(-2 * progress + 2, 2) / 2;
+                                const x = startX + gapOffset * eased + (Math.random() - 0.5) * 2;
+                                const y = startY + (Math.random() - 0.5) * 2;
+                                await p.mouse.move(x, y);
+                                await p.waitForTimeout(10 + Math.random() * 20);
+                            }
+                            await p.mouse.move(endX, startY);
+                            await p.waitForTimeout(150);
+                            await p.mouse.up();
+                            await p.waitForTimeout(2000);
+                            results.push('[OK] Slider auto-dragged. Check page state to confirm.');
+                        }
+                        catch (e) {
+                            results.push(`Auto-drag failed: ${e.message}. Use: drag-to target=".geetest_slider_button" value="${gapOffset},0"`);
+                        }
+                    }
+                    else if (gapOffset === null) {
+                        results.push('Could not determine gap position. Use "drag-to" manually with estimated offset.');
                     }
                     if (sliderInfo.allGeeTestClasses?.length > 0) {
                         results.push('');
@@ -2007,7 +2631,13 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                         results.push(`  ✓ ${label}: already filled`);
                                         return true;
                                     }
-                                    await loc.fill(val, { timeout: 3000 });
+                                    try {
+                                        await loc.fill(val, { timeout: 3000 });
+                                    }
+                                    catch {
+                                        await loc.click({ timeout: 3000 });
+                                        await loc.pressSequentially(val, { delay: 30, timeout: 10000 });
+                                    }
                                     results.push(`  ✓ ${label}: filled`);
                                     return true;
                                 }
@@ -2290,7 +2920,13 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                         results.push(`  ✓ ${label}: already filled`);
                                         return true;
                                     }
-                                    await loc.fill(val, { timeout: 3000 });
+                                    try {
+                                        await loc.fill(val, { timeout: 3000 });
+                                    }
+                                    catch {
+                                        await loc.click({ timeout: 3000 });
+                                        await loc.pressSequentially(val, { delay: 30, timeout: 10000 });
+                                    }
                                     results.push(`  ✓ ${label}: filled`);
                                     return true;
                                 }