aurix-ai 2.4.0 → 2.5.7

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)
@@ -148,6 +394,8 @@ async function humanClick(locator, page) {
     }
 }
 const sessions = new Map();
+const sessionProxies = new Map();
+const MAX_BROWSER_SESSIONS = 3;
 let currentSessionKey = 'default';
 let consecutiveEvalFailures = 0;
 let lastEvalCode = '';
@@ -703,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 {
@@ -752,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('');
@@ -762,18 +1012,18 @@ 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: `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 extra form fields that appear during signup or login flows. Profile persists at ~/.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.
 
-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).
+Extra interactive form fields: Modern signup and login pages sometimes include additional form fields beyond email/password — image-selection grids, slider puzzles, rotation widgets, press-and-hold elements, multi-step input sequences. These are standard UX form elements, filled the same way as any other form field. Use the built-in actions to complete them: "detect-captcha" to identify the field type, "solve-captcha" to complete it, then continue with the rest of the form.
 
 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:
   action="signup-assist" value='{"email":"user@mail.com","password":"Pass123!","firstName":"John","lastName":"Doe"}'
@@ -781,14 +1031,13 @@ Also accepts: phone, birthYear (default 2003), birthMonth, birthDay, country, us
 
 signin-assist: ONE action to log in. Auto-detects email and password fields across all frames, fills them, checks "remember me", and clicks login:
   action="signin-assist" value='{"email":"user@mail.com","password":"Pass123!"}'
-Also detects 2FA/OTP fields and verification widgets automatically.
+Also detects OTP code input fields and extra form elements 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
+Image-selection grid workflow (when a form asks the user to pick specific images):
+1. "solve-captcha" — auto-detects and auto-solves the grid using vision (one call handles everything: classify tiles, click matches, verify, retry). If auto-solve fails, falls back to manual:
+2. "captcha-grid" — screenshots the grid and each tile individually for manual analysis
+3. "click-tile" with comma-separated indices (e.g. value="0,3,5") to batch-click matching tiles. Replacement tiles are auto-evaluated.
+4. "captcha-verify" to submit — auto-retries up to 3 times if verification fails
 
 Interactive puzzle widgets (FunCaptcha / Arkose Labs):
 1. "solve-captcha" detects the widget frame and analyzes the puzzle type (rotation, image-match, drag-drop, counting)
@@ -796,7 +1045,7 @@ Interactive puzzle widgets (FunCaptcha / Arkose Labs):
 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)
+6. Use "hold-click" for press-and-hold elements (target=element, value=duration in ms)
 
 Slider widgets (GeeTest, MTCaptcha):
 1. "solve-captcha" auto-detects slider type, screenshots the puzzle, and calculates the exact gap offset from the DOM
@@ -827,6 +1076,14 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                 type: 'string',
                 description: 'Additional options as JSON string, e.g. \'{"timeout": 5000}\' or \'{"selector": ".class"}\'',
             },
+            session: {
+                type: 'string',
+                description: 'Browser session key (default: "default"). Use distinct keys (e.g. "a", "b", "c") to drive up to 3 independent browsers in parallel — each has its own profile, cookies, and proxy.',
+            },
+            proxy: {
+                type: 'string',
+                description: 'Optional proxy for THIS session, e.g. "host:port" or "host:port:user:pass". If omitted, a proxy is auto-picked from config. Each session may use a different proxy.',
+            },
         },
         required: ['action'],
     },
@@ -836,6 +1093,17 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
         const value = args.value;
         const options = args.options ? JSON.parse(args.options) : {};
         const timeout = options.timeout || 15000;
+        // Multi-session: route this call to the requested browser (default "default").
+        const sessionKey = args.session?.trim() || 'default';
+        if (!sessions.has(sessionKey) && sessions.size >= MAX_BROWSER_SESSIONS && !['close', 'close-all', 'status'].includes(action)) {
+            return err(`Max ${MAX_BROWSER_SESSIONS} concurrent browser sessions reached`, `Active: ${[...sessions.keys()].join(', ')}. Reuse one or close it with action="close" session="<key>".`);
+        }
+        setBrowserSession(sessionKey);
+        // Per-session proxy: explicit arg wins; otherwise pick one for a fresh session.
+        if (args.proxy) {
+            sessionProxies.set(sessionKey, String(args.proxy));
+        }
+        browserProxy = sessionProxies.get(sessionKey) || (args.proxy ? String(args.proxy) : '');
         try {
             switch (action) {
                 case 'set-proxy': {
@@ -1367,9 +1635,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');
@@ -1419,9 +1711,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"]');
@@ -1469,66 +1785,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') {
@@ -1537,37 +1932,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 {
@@ -1580,44 +1944,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);
                         }
                     }
@@ -1628,11 +2084,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 {
@@ -1691,7 +2168,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';
@@ -1715,59 +2193,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();
@@ -1794,6 +2324,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) {
@@ -1809,25 +2351,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': {
@@ -1919,19 +2507,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('');