aurix-ai 2.0.0 → 2.3.1

package/dist/tools/Browser.js

@@ -1,6 +1,7 @@
 import { launchPersistentContext, ensureBinary } from 'cloakbrowser';
 import { homedir } from 'os';
 import { join } from 'path';
+import { readdirSync, unlinkSync } from 'fs';
 import { loadConfig } from '../agent/Config.js';
 function ok(msg, details) {
     const lines = [`[OK] ${msg}`];
@@ -12,7 +13,7 @@ function ok(msg, details) {
 function err(msg, suggestion) {
     const lines = [`[ERROR] ${msg}`];
     if (suggestion)
-        lines.push(`  suggestion: ${suggestion}`);
+        lines.push(`  fix: ${suggestion}`);
     return lines.join('\n');
 }
 function warn(msg, details) {
@@ -22,6 +23,130 @@ function warn(msg, details) {
             lines.push(`  ${k}: ${v}`);
     return lines.join('\n');
 }
+let _lastActionScreenshot = '';
+async function autoScreenshot(p, label) {
+    const path = join(homedir(), '.aurix-last-action.png');
+    try {
+        await p.screenshot({ path });
+        _lastActionScreenshot = path;
+    }
+    catch { }
+    return path;
+}
+// ─── Human-Like Mouse Utilities ────────────────────────────────────────────
+function bezierPoint(t, points) {
+    if (points.length === 1)
+        return points[0];
+    const next = [];
+    for (let i = 0; i < points.length - 1; i++) {
+        next.push([
+            points[i][0] + (points[i + 1][0] - points[i][0]) * t,
+            points[i][1] + (points[i + 1][1] - points[i][1]) * t,
+        ]);
+    }
+    return bezierPoint(t, next);
+}
+function easeInOut(t) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+async function humanMove(x, y, page) {
+    const mouse = page.mouse;
+    const vp = page.viewportSize() || { width: 1280, height: 720 };
+    // Start from a random position if we don't know current pos
+    const startX = Math.random() * vp.width * 0.3;
+    const startY = Math.random() * vp.height * 0.3;
+    // Generate 2-4 control points for bezier curve
+    const numControls = 2 + Math.floor(Math.random() * 3);
+    const controlPoints = [[startX, startY]];
+    for (let i = 0; i < numControls; i++) {
+        const frac = (i + 1) / (numControls + 1);
+        const cx = startX + (x - startX) * frac + (Math.random() - 0.5) * 80;
+        const cy = startY + (y - startY) * frac + (Math.random() - 0.5) * 60;
+        controlPoints.push([cx, cy]);
+    }
+    controlPoints.push([x, y]);
+    // Step through the curve with eased timing
+    const totalSteps = 25 + Math.floor(Math.random() * 20);
+    for (let step = 0; step <= totalSteps; step++) {
+        const rawT = step / totalSteps;
+        const t = easeInOut(rawT);
+        const [px, py] = bezierPoint(t, controlPoints);
+        // Sine-wave micro-tremor (not uniform random)
+        const tremor = Math.sin(step * 0.3 + Math.random() * 0.5) * 0.4;
+        const tremorY = Math.cos(step * 0.25 + Math.random() * 0.5) * 0.3;
+        await mouse.move(px + tremor, py + tremorY);
+        // Variable step delay: faster in middle, slower at start/end
+        const speedFactor = 1 - Math.abs(rawT - 0.5) * 2;
+        const delay = 8 + Math.random() * 12 + speedFactor * 5;
+        await page.waitForTimeout(delay);
+    }
+    // Occasional overshoot + correction
+    if (Math.random() > 0.6) {
+        const overX = x + (Math.random() - 0.5) * 8;
+        const overY = y + (Math.random() - 0.5) * 8;
+        await mouse.move(overX, overY);
+        await page.waitForTimeout(30 + Math.random() * 40);
+        await mouse.move(x, y);
+        await page.waitForTimeout(20 + Math.random() * 30);
+    }
+}
+let lastWarmupTime = 0;
+async function warmupBehavior(page) {
+    const now = Date.now();
+    if (now - lastWarmupTime < 30000)
+        return;
+    lastWarmupTime = now;
+    const vp = page.viewportSize() || { width: 1280, height: 720 };
+    const spots = 1 + Math.floor(Math.random() * 2);
+    for (let i = 0; i < spots; i++) {
+        const rx = Math.random() * vp.width;
+        const ry = Math.random() * vp.height;
+        await humanMove(rx, ry, page);
+        await page.waitForTimeout(150 + Math.random() * 300);
+    }
+    if (Math.random() > 0.5) {
+        const scrollDelta = Math.floor(Math.random() * 150) - 75;
+        await page.mouse.wheel(0, scrollDelta);
+        await page.waitForTimeout(200 + Math.random() * 300);
+    }
+}
+async function humanHold(x, y, duration, page) {
+    const mouse = page.mouse;
+    const holdSteps = Math.floor(duration / 80);
+    const breathFreq = 0.15 + Math.random() * 0.1;
+    const breathAmpX = 0.3 + Math.random() * 0.4;
+    const breathAmpY = 0.2 + Math.random() * 0.3;
+    await mouse.down();
+    for (let i = 0; i < holdSteps; i++) {
+        // Sine-wave breathing movement (natural hand tremor)
+        const breathX = Math.sin(i * breathFreq) * breathAmpX;
+        const breathY = Math.cos(i * breathFreq * 0.7) * breathAmpY;
+        // Occasional micro-adjustment
+        const adjX = Math.random() > 0.95 ? (Math.random() - 0.5) * 2 : 0;
+        const adjY = Math.random() > 0.95 ? (Math.random() - 0.5) * 2 : 0;
+        await mouse.move(x + breathX + adjX, y + breathY + adjY);
+        await page.waitForTimeout(60 + Math.random() * 40);
+    }
+    // Release with slight upward drift
+    await mouse.move(x + (Math.random() - 0.5) * 3, y - 1 - Math.random() * 2);
+    await page.waitForTimeout(30 + Math.random() * 50);
+    await mouse.up();
+}
+async function humanClick(locator, page) {
+    const box = await locator.first().boundingBox();
+    if (box) {
+        const clickX = box.x + box.width * (0.3 + Math.random() * 0.4);
+        const clickY = box.y + box.height * (0.3 + Math.random() * 0.4);
+        await humanMove(clickX, clickY, page);
+        await page.waitForTimeout(60 + Math.random() * 100);
+        await page.mouse.down();
+        await page.waitForTimeout(50 + Math.random() * 80);
+        await page.mouse.up();
+    }
+    else {
+        await locator.first().click({ force: true });
+    }
+}
 const sessions = new Map();
 let currentSessionKey = 'default';
 let consecutiveEvalFailures = 0;
@@ -394,7 +519,15 @@ async function autoSolveCaptcha(p) {
             if (await checkbox.count() > 0) {
                 await checkbox.click({ timeout: 5000 });
                 await p.waitForTimeout(3000);
-                results.push('Auto-solved: Turnstile verification completed');
+                // Don't claim "solved" — verify the widget actually reported success.
+                const tsOk = await turnstileFrame.locator('input[type="hidden"][name="cf-turnstile-response"], [data-state="success"], .success').count().catch(() => 0);
+                const tsError = await turnstileFrame.locator('.error, [data-state="error"], [data-state="failed"]').count().catch(() => 0);
+                if (tsOk > 0)
+                    results.push('Turnstile: checkbox clicked, widget reports success');
+                else if (tsError > 0)
+                    results.push('Turnstile: checkbox clicked but widget shows an error — may need a screenshot to inspect');
+                else
+                    results.push('Turnstile: checkbox clicked, outcome unconfirmed — take a screenshot to verify the page advanced before submitting');
             }
         }
         catch (e) {
@@ -407,7 +540,16 @@ async function autoSolveCaptcha(p) {
             if (await checkbox.count() > 0) {
                 await checkbox.click({ timeout: 5000 });
                 await p.waitForTimeout(2000);
-                results.push('Auto-solved: reCAPTCHA checkbox clicked');
+                // The checkbox click may pass instantly OR pop an image challenge.
+                // Report which actually happened instead of claiming success.
+                const checked = await recaptchaAnchor.locator('.recaptcha-checkbox-checked, .rc-anchor-checkbox-checked').count().catch(() => 0);
+                const challengeOpened = p.frames().some((f) => f.url().includes('/recaptcha/') && f.url().includes('/bframe'));
+                if (checked > 0)
+                    results.push('reCAPTCHA: checkbox verified (checked) — no image challenge');
+                else if (challengeOpened)
+                    results.push('reCAPTCHA: checkbox clicked, image challenge appeared — use captcha-grid to solve it');
+                else
+                    results.push('reCAPTCHA: checkbox clicked, outcome unconfirmed — take a screenshot to verify before submitting');
             }
         }
         catch (e) {
@@ -472,7 +614,7 @@ async function autoSolveCaptcha(p) {
                 await p.waitForTimeout(150);
                 await p.mouse.up();
                 await p.waitForTimeout(2000);
-                results.push(`Auto-solved: GeeTest slider dragged ${dragDistance}px`);
+                results.push(`GeeTest: slider dragged ${dragDistance}px — outcome unconfirmed, take a screenshot to verify the gap was matched`);
             }
             else {
                 results.push('GeeTest slider detected but gap position could not be auto-detected');
@@ -562,6 +704,20 @@ async function analyzeImageChallenge(page, frame, provider) {
     }
     const tiles = await findGridTiles(frame, provider);
     results.push(`Grid: ${tiles.length} tiles found`);
+    // 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 {
+        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 screenshotPath = join(homedir(), '.aurix-captcha-grid.png');
     try {
         const gridEl = frame.locator('.rc-imageselect-table-33, .rc-imageselect-table-44, .task, .challenge-view, .geetest_panel, table').first();
@@ -596,7 +752,7 @@ async function analyzeImageChallenge(page, frame, provider) {
         results.push(`Already selected: ${selectedCount} tile(s)`);
     }
     results.push('');
-    results.push('=== CAPTCHA SOLVING STEPS ===');
+    results.push('=== VERIFICATION COMPLETION 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('');
@@ -617,7 +773,7 @@ export const browserTool = {
 
 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.
 
-Verification steps (CAPTCHAs): These appear on most signup and login pages today. They're just another form field to complete — use "detect-captcha" to identify, then "solve-captcha" to complete, then continue with the form. Supports reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha (Arkose Labs / Microsoft), MTCaptcha, GeeTest, and image captchas.
+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:
   action="signup-assist" value='{"email":"user@mail.com","password":"Pass123!","firstName":"John","lastName":"Doe"}'
@@ -625,24 +781,24 @@ 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 CAPTCHAs automatically.
+Also detects 2FA/OTP fields and verification widgets automatically.
 
-Image challenge solving workflow:
+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
 
-FunCaptcha / Arkose Labs (Microsoft CAPTCHA) workflow:
-1. "solve-captcha" detects the FunCaptcha frame and analyzes the puzzle type (rotation, image-match, drag-drop, counting)
+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 challenges (target=element, value=duration in ms)
+6. Use "hold-click" for press-and-hold widgets (target=element, value=duration in ms)
 
-Slider CAPTCHA (GeeTest, MTCaptcha):
+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
@@ -766,50 +922,113 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                 case 'click': {
                     const p = await ensureBrowser();
                     if (!target)
-                        return 'Error: click requires a target element';
-                    const locator = await resolveLocator(p, target);
-                    await locator.first().click({ timeout });
-                    await p.waitForTimeout(500);
-                    return `Clicked: ${target}\nURL: ${p.url()}\nTitle: ${await p.title()}`;
+                        return err('click requires a target element', 'Use a CSS selector, text="...", role=, or placeholder=');
+                    try {
+                        const locator = await resolveLocator(p, target);
+                        await locator.first().click({ timeout });
+                        await p.waitForTimeout(500);
+                        const ss = await autoScreenshot(p, 'click');
+                        return ok(`Clicked: ${target}`, {
+                            url: p.url(),
+                            title: await p.title(),
+                            screenshot: ss,
+                        });
+                    }
+                    catch (e) {
+                        const msg = e.message || String(e);
+                        if (msg.includes('Timeout'))
+                            return err(`Element "${target}" not found within timeout`, 'Use "snapshot" to see available elements, or "wait" to wait for page load');
+                        if (msg.includes('not visible') || msg.includes('intercepts pointer'))
+                            return err(`Element "${target}" is hidden or covered by another element`, 'Try a different selector, use "evaluate" with JS click, or scroll to the element first');
+                        if (msg.includes('strict mode') || msg.includes('more than one'))
+                            return err(`Multiple elements matched "${target}"`, 'Use a more specific selector or add .first()/.nth(0)');
+                        return err(`Click failed on "${target}": ${msg.slice(0, 150)}`, 'Use "snapshot" to check the current page state');
+                    }
                 }
                 case 'fill': {
                     const p = await ensureBrowser();
                     if (!target)
-                        return 'Error: fill requires a target element';
+                        return err('fill requires a target element', 'Use a CSS selector, placeholder="...", or label="..."');
                     if (value === undefined)
-                        return 'Error: fill requires a value';
-                    const locator = await resolveLocator(p, target);
-                    await locator.first().fill(value, { timeout });
-                    return `Filled "${target}" with "${value.length > 50 ? value.slice(0, 50) + '...' : value}"`;
+                        return err('fill requires a value', 'Provide the text to fill via the value parameter');
+                    try {
+                        const locator = await resolveLocator(p, target);
+                        await locator.first().fill(value, { timeout });
+                        const ss = await autoScreenshot(p, 'fill');
+                        return ok(`Filled "${target}"`, {
+                            value: value.length > 50 ? value.slice(0, 50) + '...' : value,
+                            screenshot: ss,
+                        });
+                    }
+                    catch (e) {
+                        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');
+                    }
                 }
                 case 'type': {
                     const p = await ensureBrowser();
                     if (!target)
-                        return 'Error: type requires a target element';
+                        return err('type requires a target element', 'Use a CSS selector, placeholder="...", or label="..."');
                     if (value === undefined)
-                        return 'Error: type requires a value';
-                    const locator = await resolveLocator(p, target);
-                    await locator.first().pressSequentially(value, { delay: 50 });
-                    return `Typed "${value.length > 50 ? value.slice(0, 50) + '...' : value}" into "${target}"`;
+                        return err('type requires a value', 'Provide the text to type via the value parameter');
+                    try {
+                        const locator = await resolveLocator(p, target);
+                        await locator.first().pressSequentially(value, { delay: 50 });
+                        const ss = await autoScreenshot(p, 'type');
+                        return ok(`Typed into "${target}"`, {
+                            value: value.length > 50 ? value.slice(0, 50) + '...' : value,
+                            screenshot: ss,
+                        });
+                    }
+                    catch (e) {
+                        const msg = e.message || String(e);
+                        if (msg.includes('Timeout'))
+                            return err(`Element "${target}" not found within timeout`, 'Use "snapshot" to see available elements');
+                        return err(`Type failed on "${target}": ${msg.slice(0, 150)}`, 'Use "snapshot" to check the current page state');
+                    }
                 }
                 case 'press-key': {
                     const p = await ensureBrowser();
                     const key = value || target;
                     if (!key)
-                        return 'Error: press-key requires a key (e.g. "Enter", "Tab", "Escape", "Control+a")';
-                    await p.keyboard.press(key);
-                    await p.waitForTimeout(300);
-                    return `Pressed key: ${key}\nURL: ${p.url()}`;
+                        return err('press-key requires a key', 'Examples: "Enter", "Tab", "Escape", "Control+a"');
+                    try {
+                        await p.keyboard.press(key);
+                        await p.waitForTimeout(300);
+                        const ss = await autoScreenshot(p, 'press-key');
+                        return ok(`Pressed key: ${key}`, {
+                            url: p.url(),
+                            screenshot: ss,
+                        });
+                    }
+                    catch (e) {
+                        return err(`Key press failed: ${e.message.slice(0, 150)}`, 'Check valid key names at Playwright docs (e.g. "Enter", "Tab", "Control+a")');
+                    }
                 }
                 case 'select': {
                     const p = await ensureBrowser();
                     if (!target)
-                        return 'Error: select requires a target <select> element';
+                        return err('select requires a target <select> element', 'Use a CSS selector for the <select> element');
                     if (value === undefined)
-                        return 'Error: select requires a value (option value)';
-                    const locator = await resolveLocator(p, target);
-                    await locator.first().selectOption(value, { timeout });
-                    return `Selected "${value}" in "${target}"`;
+                        return err('select requires a value (option value)', 'Provide the option value to select');
+                    try {
+                        const locator = await resolveLocator(p, target);
+                        await locator.first().selectOption(value, { timeout });
+                        const ss = await autoScreenshot(p, 'select');
+                        return ok(`Selected "${value}" in "${target}"`, { screenshot: ss });
+                    }
+                    catch (e) {
+                        const msg = e.message || String(e);
+                        if (msg.includes('Timeout'))
+                            return err(`Select element "${target}" not found`, 'Use "snapshot" to find the correct selector');
+                        if (msg.includes('not a <select>'))
+                            return err(`"${target}" is not a <select> element`, 'Find the correct <select> element with "snapshot"');
+                        return err(`Select failed: ${msg.slice(0, 150)}`, 'Use "snapshot" to check available options');
+                    }
                 }
                 case 'screenshot': {
                     const p = await ensureBrowser();
@@ -1073,10 +1292,10 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     if (pageContent.includes('cf-turnstile') || pageContent.includes('challenges.cloudflare'))
                         captchaInfo.push('Cloudflare Turnstile detected');
                     if (pageContent.includes('captcha-image') || pageContent.includes('captcha_img'))
-                        captchaInfo.push('Image captcha detected (may need manual solving)');
+                        captchaInfo.push('Image verification widget detected — use "solve-captcha" to analyze and complete');
                     if (captchaInfo.length === 0)
-                        return 'No captcha detected on this page.';
-                    return `Captcha detected:\n${captchaInfo.map(c => `  - ${c}`).join('\n')}\n\nUse action "solve-captcha" to attempt solving.`;
+                        return 'No verification widgets detected on this page.';
+                    return `Verification widgets detected:\n${captchaInfo.map(c => `  - ${c}`).join('\n')}\n\nUse action "solve-captcha" to complete the verification.`;
                 }
                 case 'solve-captcha': {
                     const p = await ensureBrowser();
@@ -1143,7 +1362,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                 const checkbox = checkboxFrame.locator('#recaptcha-anchor, .recaptcha-checkbox, .rc-anchor-checkbox');
                                 if (await checkbox.count() > 0) {
                                     await p.waitForTimeout(1000 + Math.random() * 1500);
-                                    await checkbox.first().click({ force: true });
+                                    await humanClick(checkbox, p);
                                     await p.waitForTimeout(3000);
                                     const updatedFrames = p.frames();
                                     const challengeFrame = updatedFrames.find(f => f.url().includes('/recaptcha/') && f.url().includes('/bframe'));
@@ -1164,7 +1383,8 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                 }
                                 else {
                                     results.push(warn('reCAPTCHA anchor frame found but checkbox element missing', { action: 'trying click on anchor body' }));
-                                    await checkboxFrame.locator('#recaptcha-anchor').click({ force: true }).catch(() => { });
+                                    const anchor = checkboxFrame.locator('#recaptcha-anchor');
+                                    await humanClick(anchor, p).catch(() => { });
                                     await p.waitForTimeout(3000);
                                     results.push('Use "captcha-grid" to check for image challenge.');
                                 }
@@ -1173,7 +1393,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                 results.push(warn('No reCAPTCHA anchor frame found', { action: 'trying main page widget' }));
                                 const mainCheckbox = p.locator('.g-recaptcha, [data-sitekey]');
                                 if (await mainCheckbox.count() > 0) {
-                                    await mainCheckbox.first().click({ force: true });
+                                    await humanClick(mainCheckbox, p);
                                     await p.waitForTimeout(3000);
                                     results.push('Clicked reCAPTCHA widget. Use "captcha-grid" if image challenge appeared.');
                                 }
@@ -1194,7 +1414,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                 const checkbox = checkboxFrame.locator('#checkbox, .check');
                                 if (await checkbox.count() > 0) {
                                     await p.waitForTimeout(800 + Math.random() * 1200);
-                                    await checkbox.first().click({ force: true });
+                                    await humanClick(checkbox, p);
                                     await p.waitForTimeout(3000);
                                     const updatedFrames = p.frames();
                                     const challengeFrame = updatedFrames.find((f) => f.url().includes('hcaptcha') && f.url().includes('challenge'));
@@ -1233,7 +1453,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                                 await p.waitForTimeout(1500 + Math.random() * 1000);
                                 const cb = turnstileFrame.locator('input[type="checkbox"], .cb-lb');
                                 if (await cb.count() > 0) {
-                                    await cb.first().click({ force: true });
+                                    await humanClick(cb, p);
                                     await p.waitForTimeout(3000);
                                     results.push(ok('Turnstile checkbox clicked'));
                                 }
@@ -1435,7 +1655,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     let provider = 'unknown';
                     for (const frame of frames) {
                         const url = frame.url();
-                        if (url.includes('bframe') || url.includes('recaptcha')) {
+                        if (url.includes('/recaptcha/') && url.includes('/bframe')) {
                             challengeFrame = frame;
                             provider = 'recaptcha';
                             break;
@@ -1477,7 +1697,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     let provider = 'unknown';
                     for (const frame of frames) {
                         const url = frame.url();
-                        if (url.includes('bframe') || url.includes('recaptcha')) {
+                        if (url.includes('/recaptcha/') && url.includes('/bframe')) {
                             challengeFrame = frame;
                             provider = 'recaptcha';
                             break;
@@ -1502,25 +1722,46 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         return err(`Tile index ${tileIndex} out of range (0-${tiles.length - 1})`);
                     try {
                         const tile = tiles[tileIndex];
-                        await tile.click({ force: true });
-                        await p.waitForTimeout(500 + Math.random() * 400);
                         const isRecaptcha = provider === 'recaptcha';
-                        const selectedClass = isRecaptcha ? '.rc-imageselect-dynamic-selected' : '.task-image.selected, .task .selected';
-                        const selectedCount = await challengeFrame.locator(selectedClass).count();
+                        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();
+                        }
+                        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}`, {
-                                selected: `${selectedCount} tile(s)`,
+                                selection: clickStatus,
                                 'new tile': 'appeared — check screenshot and evaluate',
                                 screenshot: screenshotPath,
                                 next: 'Use "click-tile" for next matching tile, or "captcha-verify" when done',
                             });
                         }
+                        const ss = await autoScreenshot(p, 'click-tile');
                         return ok(`Clicked tile ${tileIndex}`, {
-                            selected: `${selectedCount} tile(s)`,
+                            selection: clickStatus,
+                            screenshot: ss,
                             next: 'Continue clicking matching tiles, then use "captcha-verify"',
                         });
                     }
@@ -1535,7 +1776,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     let provider = 'unknown';
                     for (const frame of frames) {
                         const url = frame.url();
-                        if (url.includes('bframe') || url.includes('recaptcha')) {
+                        if (url.includes('/recaptcha/') && url.includes('/bframe')) {
                             challengeFrame = frame;
                             provider = 'recaptcha';
                             break;
@@ -1561,7 +1802,7 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         if (await verifyBtn.count() === 0) {
                             return err('No verify button found', 'Use "captcha-grid" to analyze the challenge first');
                         }
-                        await verifyBtn.first().click({ force: true });
+                        await humanClick(verifyBtn, p);
                         await p.waitForTimeout(3000);
                         const screenshotPath = join(homedir(), '.aurix-captcha-verify-result.png');
                         const errorText = await challengeFrame.locator('.rc-imageselect-incorrect-response, .error-message, .incorrect').count();
@@ -1580,9 +1821,9 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                             });
                         }
                         await p.screenshot({ path: screenshotPath });
-                        return ok('CAPTCHA verification submitted', {
+                        return ok('Verification submitted', {
                             screenshot: screenshotPath,
-                            note: 'Check if the form/page progressed. If CAPTCHA reappears, use "captcha-grid" again.',
+                            note: 'Check if the form/page progressed. If verification widget reappears, use "captcha-grid" again.',
                         });
                     }
                     catch (e) {
@@ -1938,14 +2179,18 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         results.push('Attempting to complete automatically...');
                         const solveResults = await autoSolveCaptcha(p);
                         solveResults.forEach(r => results.push(`  ${r}`));
-                        const needsVision = solveResults.some(r => r.includes('CAPTCHA SOLVING STEPS') || r.includes('REQUIRES_VISION'));
-                        if (!needsVision) {
-                            await p.waitForTimeout(2000);
-                            results.push('Verification completed. Continuing form submission...');
+                        const needsVision = solveResults.some(r => r.includes('VERIFICATION COMPLETION STEPS') || r.includes('REQUIRES_VISION'));
+                        const unconfirmed = solveResults.some(r => /unconfirmed|shows an error/i.test(r));
+                        if (needsVision) {
+                            results.push('');
+                            results.push('⚠ Verification widget analysis is above. Follow the VERIFICATION COMPLETION STEPS to complete it, then re-run signup-assist to continue.');
+                        }
+                        else if (unconfirmed) {
+                            results.push('Verification attempted but NOT confirmed — take a screenshot to check the widget passed before relying on submission.');
                         }
                         else {
-                            results.push('');
-                            results.push('⚠ CAPTCHA grid analysis is above. Follow the CAPTCHA SOLVING STEPS to complete it, then re-run signup-assist to continue.');
+                            await p.waitForTimeout(2000);
+                            results.push('Verification confirmed. Continuing form submission...');
                         }
                     }
                     const clicked = await clickField([
@@ -2094,14 +2339,18 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         results.push('Attempting to complete automatically...');
                         const solveResults = await autoSolveCaptcha(p);
                         solveResults.forEach(r => results.push(`  ${r}`));
-                        const needsVision = solveResults.some(r => r.includes('CAPTCHA SOLVING STEPS') || r.includes('REQUIRES_VISION'));
-                        if (!needsVision) {
-                            await p.waitForTimeout(2000);
-                            results.push('Verification completed. Continuing login...');
+                        const needsVision = solveResults.some(r => r.includes('VERIFICATION COMPLETION STEPS') || r.includes('REQUIRES_VISION'));
+                        const unconfirmed = solveResults.some(r => /unconfirmed|shows an error/i.test(r));
+                        if (needsVision) {
+                            results.push('');
+                            results.push('⚠ Verification widget analysis is above. Follow the VERIFICATION COMPLETION STEPS to complete it, then re-run signin-assist to continue.');
+                        }
+                        else if (unconfirmed) {
+                            results.push('Verification attempted but NOT confirmed — take a screenshot to check the widget passed before relying on login.');
                         }
                         else {
-                            results.push('');
-                            results.push('⚠ CAPTCHA grid analysis is above. Follow the CAPTCHA SOLVING STEPS to complete it, then re-run signin-assist to continue.');
+                            await p.waitForTimeout(2000);
+                            results.push('Verification confirmed. Continuing login...');
                         }
                     }
                     await clickField([
@@ -2151,8 +2400,8 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                         const sourceBox = await sourceEl.boundingBox();
                         if (!sourceBox)
                             return err(`Source element "${target}" not found or not visible`);
-                        const startX = sourceBox.x + sourceBox.width / 2;
-                        const startY = sourceBox.y + sourceBox.height / 2;
+                        const startX = sourceBox.x + sourceBox.width * (0.3 + Math.random() * 0.4);
+                        const startY = sourceBox.y + sourceBox.height * (0.3 + Math.random() * 0.4);
                         let endX, endY;
                         const coords = value.split(',').map(s => parseInt(s.trim()));
                         if (coords.length === 2 && !isNaN(coords[0]) && !isNaN(coords[1])) {
@@ -2164,28 +2413,52 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                             const targetBox = await targetEl.boundingBox();
                             if (!targetBox)
                                 return err(`Target element "${value}" not found or not visible`);
-                            endX = targetBox.x + targetBox.width / 2;
-                            endY = targetBox.y + targetBox.height / 2;
+                            endX = targetBox.x + targetBox.width * (0.3 + Math.random() * 0.4);
+                            endY = targetBox.y + targetBox.height * (0.3 + Math.random() * 0.4);
                         }
-                        await p.mouse.move(startX, startY);
-                        await p.waitForTimeout(100 + Math.random() * 150);
+                        await warmupBehavior(p);
+                        await humanMove(startX, startY, p);
+                        await p.waitForTimeout(150 + Math.random() * 250);
                         await p.mouse.down();
-                        await p.waitForTimeout(200 + Math.random() * 200);
-                        const steps = 15 + Math.floor(Math.random() * 10);
-                        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 + (endX - startX) * eased + (Math.random() - 0.5) * 2;
-                            const y = startY + (endY - startY) * eased + (Math.random() - 0.5) * 2;
-                            await p.mouse.move(x, y);
-                            await p.waitForTimeout(10 + Math.random() * 25);
-                        }
-                        await p.mouse.move(endX, endY);
-                        await p.waitForTimeout(100 + Math.random() * 200);
+                        await p.waitForTimeout(200 + Math.random() * 300);
+                        const distance = Math.sqrt((endX - startX) ** 2 + (endY - startY) ** 2);
+                        const numControls = distance > 200 ? 3 : 2;
+                        const dragPoints = [[startX, startY]];
+                        for (let i = 0; i < numControls; i++) {
+                            const frac = (i + 1) / (numControls + 1);
+                            const perpX = -(endY - startY) / distance;
+                            const perpY = (endX - startX) / distance;
+                            const offset = (Math.random() - 0.5) * Math.min(distance * 0.15, 40);
+                            const cx = startX + (endX - startX) * frac + perpX * offset;
+                            const cy = startY + (endY - startY) * frac + perpY * offset;
+                            dragPoints.push([cx, cy]);
+                        }
+                        dragPoints.push([endX, endY]);
+                        const dragSteps = 25 + Math.floor(Math.random() * 20);
+                        for (let step = 0; step <= dragSteps; step++) {
+                            const rawT = step / dragSteps;
+                            const t = easeInOut(rawT);
+                            const [px, py] = bezierPoint(t, dragPoints);
+                            const tremor = Math.sin(step * 0.35 + Math.random() * 0.5) * 0.5;
+                            const tremorY = Math.cos(step * 0.3 + Math.random() * 0.5) * 0.4;
+                            await p.mouse.move(px + tremor, py + tremorY);
+                            const speedFactor = 1 - Math.abs(rawT - 0.5) * 2;
+                            const delay = 10 + Math.random() * 15 + speedFactor * 8;
+                            await p.waitForTimeout(delay);
+                        }
+                        if (Math.random() > 0.5) {
+                            const overX = endX + (Math.random() - 0.5) * 6;
+                            const overY = endY + (Math.random() - 0.5) * 6;
+                            await p.mouse.move(overX, overY);
+                            await p.waitForTimeout(40 + Math.random() * 60);
+                            await p.mouse.move(endX, endY);
+                            await p.waitForTimeout(30 + Math.random() * 50);
+                        }
+                        await p.waitForTimeout(80 + Math.random() * 150);
+                        await p.mouse.move(endX + (Math.random() - 0.5) * 2, endY - 1 - Math.random());
+                        await p.waitForTimeout(30 + Math.random() * 40);
                         await p.mouse.up();
-                        await p.waitForTimeout(500);
+                        await p.waitForTimeout(400 + Math.random() * 300);
                         const screenshotPath = join(homedir(), '.aurix-drag-result.png');
                         await p.screenshot({ path: screenshotPath });
                         return ok(`Dragged "${target}" to (${Math.round(endX)}, ${Math.round(endY)})`, {
@@ -2203,29 +2476,26 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     const p = await ensureBrowser();
                     if (!target)
                         return err('hold-click requires a target element');
-                    const duration = parseInt(value) || 3000;
+                    const baseDuration = Math.min(parseInt(value) || 5000, 12000);
+                    const duration = Math.max(2000, baseDuration + Math.floor(Math.random() * 2000) - 1000);
                     try {
                         const el = p.locator(target).first();
                         const box = await el.boundingBox();
                         if (!box)
                             return err(`Element "${target}" not found or not visible`);
-                        const x = box.x + box.width / 2;
-                        const y = box.y + box.height / 2;
-                        await p.mouse.move(x, y);
-                        await p.waitForTimeout(100 + Math.random() * 100);
-                        await p.mouse.down();
-                        const holdSteps = Math.floor(duration / 100);
-                        for (let i = 0; i < holdSteps; i++) {
-                            const jitterX = x + (Math.random() - 0.5) * 3;
-                            const jitterY = y + (Math.random() - 0.5) * 3;
-                            await p.mouse.move(jitterX, jitterY);
-                            await p.waitForTimeout(80 + Math.random() * 40);
-                        }
-                        await p.mouse.up();
-                        await p.waitForTimeout(500);
+                        const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.3;
+                        const y = box.y + box.height / 2 + (Math.random() - 0.5) * box.height * 0.3;
+                        // Pre-interaction warmup: move mouse around naturally
+                        await warmupBehavior(p);
+                        // Bezier curve approach to target
+                        await humanMove(x, y, p);
+                        await p.waitForTimeout(100 + Math.random() * 200);
+                        // Human-like hold with breathing movements
+                        await humanHold(x, y, duration, p);
+                        await p.waitForTimeout(300 + Math.random() * 400);
                         const screenshotPath = join(homedir(), '.aurix-hold-result.png');
                         await p.screenshot({ path: screenshotPath });
-                        return ok(`Held click on "${target}" for ${duration}ms`, {
+                        return ok(`Held click on "${target}" for ${Math.round(duration)}ms (human-like)`, {
                             position: `(${Math.round(x)}, ${Math.round(y)})`,
                             screenshot: screenshotPath,
                         });
@@ -2235,18 +2505,42 @@ The browser profile persists at ~/.aurix-browser-profile — if the user is logg
                     }
                 }
                 default:
-                    return `Unknown action: "${action}". Available: 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, close, status`;
+                    return err(`Unknown action: "${action}"`, `Available: 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, close, status`);
             }
         }
         catch (e) {
             const msg = e.message || String(e);
-            if (msg.includes('Timeout')) {
-                return `Browser timeout: ${msg}\n\nTry: increase timeout in options, use "wait" action first, or check if the element exists with "snapshot".`;
+            if (msg.includes('Timeout') || msg.includes('timeout')) {
+                return err(`Timeout waiting for element or page load: ${msg.slice(0, 120)}`, 'Use "wait" to wait for page load, "snapshot" to check current state, or verify the element exists');
             }
             if (msg.includes('strict mode') || msg.includes('more than one')) {
-                return `Multiple elements matched "${target}". Use a more specific selector (CSS, role=, placeholder=) or add .first()/.nth(0).`;
+                return err(`Multiple elements matched "${target || '(unknown)'}"`, 'Use a more specific selector (CSS #id, [attr]), or .first()/.nth(0)');
+            }
+            if (msg.includes('not visible') || msg.includes('element is not visible')) {
+                return err(`Element "${target || '(unknown)'}" is not visible on the page`, 'Scroll to the element, wait for it to appear, or use "evaluate" for JS-based interaction');
+            }
+            if (msg.includes('detached') || msg.includes('was removed')) {
+                return err(`Element was removed from the page during interaction`, 'The page updated while interacting. Use "snapshot" to get fresh elements and retry');
+            }
+            if (msg.includes('intercepts pointer') || msg.includes('overlapped')) {
+                return err(`Another element is covering "${target || '(unknown)'}"`, 'Use "evaluate" with JavaScript click: document.querySelector(selector).click(), or scroll to reveal the element');
+            }
+            if (msg.includes('frame was detached') || msg.includes('Frame was detached')) {
+                return err('The iframe was detached or reloaded during interaction', 'Re-detect frames with "detect-captcha" or "snapshot" and retry');
+            }
+            if (msg.includes('Navigation') || msg.includes('navigated')) {
+                return err(`Page navigation interrupted the action: ${msg.slice(0, 120)}`, 'Wait for navigation to complete with "wait" action, then retry');
+            }
+            if (msg.includes('closed') || msg.includes('Target closed') || msg.includes('browser has been closed')) {
+                return err('Browser or page was closed unexpectedly', 'Re-open the browser with action="navigate" to the target URL');
+            }
+            if (msg.includes('net::') || msg.includes('ERR_')) {
+                return err(`Network error: ${msg.slice(0, 150)}`, 'Check internet connection, proxy settings (action="set-proxy"), or if the URL is accessible');
+            }
+            if (msg.includes('Execution context was destroyed')) {
+                return err('Page JavaScript context was destroyed (page navigated or reloaded)', 'Use "wait" to let the page settle, then "snapshot" to check state before retrying');
             }
-            return `Browser error: ${msg}`;
+            return err(`Browser error: ${msg.slice(0, 200)}`, 'Use "snapshot" to check current page state, or "screenshot" to see what the page looks like');
         }
     },
 };