@weavetab/mcp 2.5.0-beta.1 → 2.5.0-beta.4

package/dist/tools/checkpoint.js

@@ -0,0 +1,271 @@
+/**
+ * Weavetab — tools/checkpoint.ts
+ * browser_checkpoint: Session time-travel and rollback.
+ *
+ * Captures and restores named checkpoints of browser state:
+ *   - Cookies (HttpOnly and Secure via CDP Network)
+ *   - LocalStorage & SessionStorage
+ *   - URL, page title, and viewport scroll position
+ *   - Optional lightweight DOM snapshot
+ *
+ * Saves tokens and time when trial-and-error automation branches fail.
+ *
+ * Weavetab by fy2ne
+ */
+import { logAction } from "../audit/logger.js";
+import { recordAction } from "../intelligence/trail.js";
+import { clearTabCache } from "../state/cache.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId } from "../config/loader.js";
+// In-memory checkpoint registry keyed by targetId -> name -> CheckpointData
+const checkpointRegistry = new Map();
+export function getCheckpointsForTarget(targetId) {
+    let map = checkpointRegistry.get(targetId);
+    if (!map) {
+        map = new Map();
+        checkpointRegistry.set(targetId, map);
+    }
+    return map;
+}
+export function clearAllCheckpoints() {
+    checkpointRegistry.clear();
+}
+export async function browserCheckpoint(session, args, config) {
+    let targetId = "default";
+    const active = sessionRegistry.getActive(getConfigAgentId(config));
+    if (active)
+        targetId = active.targetId;
+    const targetCheckpoints = getCheckpointsForTarget(targetId);
+    // ── ACTION: LIST ─────────────────────────────────────────────────────────────
+    if (args.action === "list") {
+        const list = Array.from(targetCheckpoints.values()).map((cp) => ({
+            name: cp.name,
+            url: cp.url,
+            title: cp.title,
+            timestamp: cp.timestamp,
+            cookiesCount: cp.cookies.length,
+            localStorageKeys: Object.keys(cp.localStorage).length,
+            sessionStorageKeys: Object.keys(cp.sessionStorage).length,
+            hasDomSnapshot: !!cp.domSnapshot,
+        }));
+        return {
+            success: true,
+            action: "list",
+            count: list.length,
+            checkpoints: list,
+        };
+    }
+    // ── ACTION: DELETE ───────────────────────────────────────────────────────────
+    if (args.action === "delete") {
+        if (!args.name) {
+            return {
+                success: false,
+                error_code: "INVALID_ARGS",
+                message: "Checkpoint 'name' is required for action 'delete'.",
+            };
+        }
+        const existed = targetCheckpoints.delete(args.name);
+        return {
+            success: existed,
+            action: "delete",
+            name: args.name,
+            message: existed
+                ? `Checkpoint '${args.name}' deleted.`
+                : `Checkpoint '${args.name}' not found.`,
+        };
+    }
+    // ── ACTION: SAVE ─────────────────────────────────────────────────────────────
+    if (args.action === "save") {
+        if (!args.name) {
+            return {
+                success: false,
+                error_code: "INVALID_ARGS",
+                message: "Checkpoint 'name' is required for action 'save'.",
+            };
+        }
+        const { Page, Network, Runtime } = session;
+        const { frameTree } = await Page.getFrameTree();
+        const currentUrl = frameTree.frame.url;
+        // 1. Snapshot cookies
+        let cookies = [];
+        try {
+            if (typeof Network.getCookies === "function") {
+                const res = await Network.getCookies({ urls: [currentUrl] });
+                cookies = res.cookies || [];
+            }
+            else if (typeof Network.getAllCookies === "function") {
+                const res = await Network.getAllCookies();
+                cookies = res.cookies || [];
+            }
+        }
+        catch {
+            // Cookies best-effort
+        }
+        // 2. Snapshot LocalStorage, SessionStorage, Scroll, and Title
+        let storageData = {
+            localStorage: {},
+            sessionStorage: {},
+            scroll: { x: 0, y: 0 },
+            title: "",
+        };
+        try {
+            const evalRes = await Runtime.evaluate({
+                expression: `(function() {
+          var ls = {};
+          try {
+            for (var i = 0; i < localStorage.length; i++) {
+              var k = localStorage.key(i);
+              if (k) ls[k] = localStorage.getItem(k);
+            }
+          } catch(e) {}
+          var ss = {};
+          try {
+            for (var j = 0; j < sessionStorage.length; j++) {
+              var sk = sessionStorage.key(j);
+              if (sk) ss[sk] = sessionStorage.getItem(sk);
+            }
+          } catch(e) {}
+          return {
+            localStorage: ls,
+            sessionStorage: ss,
+            scroll: { x: window.scrollX || 0, y: window.scrollY || 0 },
+            title: document.title || ""
+          };
+        })()`,
+                returnByValue: true,
+            });
+            if (evalRes?.result?.value) {
+                storageData = evalRes.result.value;
+            }
+        }
+        catch {
+            // Runtime best-effort
+        }
+        // 3. Optional lightweight DOM capture
+        let domSnapshot;
+        if (args.includeDom) {
+            try {
+                const domRes = await Runtime.evaluate({
+                    expression: `document.documentElement.outerHTML.slice(0, 100000)`,
+                    returnByValue: true,
+                });
+                domSnapshot = domRes?.result?.value;
+            }
+            catch {
+                // ignore
+            }
+        }
+        const checkpoint = {
+            name: args.name,
+            url: currentUrl,
+            title: storageData.title,
+            timestamp: new Date().toISOString(),
+            cookies,
+            localStorage: storageData.localStorage,
+            sessionStorage: storageData.sessionStorage,
+            scroll: storageData.scroll,
+            domSnapshot,
+        };
+        targetCheckpoints.set(args.name, checkpoint);
+        logAction("browser_checkpoint", args.name, `Saved checkpoint at ${currentUrl}`);
+        recordAction({
+            timestamp: checkpoint.timestamp,
+            tool: "browser_checkpoint",
+            input: { action: "save", name: args.name, url: currentUrl },
+            result: { success: true },
+        });
+        return {
+            success: true,
+            action: "save",
+            name: args.name,
+            url: currentUrl,
+            title: storageData.title,
+            timestamp: checkpoint.timestamp,
+            cookiesCount: cookies.length,
+            localStorageKeysCount: Object.keys(storageData.localStorage).length,
+            sessionStorageKeysCount: Object.keys(storageData.sessionStorage).length,
+        };
+    }
+    // ── ACTION: RESTORE ──────────────────────────────────────────────────────────
+    if (args.action === "restore") {
+        if (!args.name) {
+            return {
+                success: false,
+                error_code: "INVALID_ARGS",
+                message: "Checkpoint 'name' is required for action 'restore'.",
+            };
+        }
+        const checkpoint = targetCheckpoints.get(args.name);
+        if (!checkpoint) {
+            return {
+                success: false,
+                error_code: "CHECKPOINT_NOT_FOUND",
+                message: `No checkpoint found with name '${args.name}'. Use action: 'list' to see available checkpoints.`,
+            };
+        }
+        const { Page, Network, Runtime } = session;
+        const { frameTree } = await Page.getFrameTree();
+        const currentUrl = frameTree.frame.url;
+        // 1. Navigate to checkpoint URL if different
+        if (currentUrl !== checkpoint.url) {
+            await Page.navigate({ url: checkpoint.url });
+            await Page.loadEventFired().catch(() => { });
+            await new Promise((r) => setTimeout(r, 400));
+        }
+        // 2. Restore Cookies
+        if (checkpoint.cookies && checkpoint.cookies.length > 0) {
+            try {
+                if (typeof Network.setCookies === "function") {
+                    await Network.setCookies({ cookies: checkpoint.cookies });
+                }
+            }
+            catch {
+                // Cookies best-effort
+            }
+        }
+        // 3. Restore LocalStorage, SessionStorage, and Scroll position
+        try {
+            await Runtime.evaluate({
+                expression: `(function(ls, ss, scroll) {
+          try {
+            localStorage.clear();
+            for (var k in ls) { localStorage.setItem(k, ls[k]); }
+          } catch(e) {}
+          try {
+            sessionStorage.clear();
+            for (var sk in ss) { sessionStorage.setItem(sk, ss[sk]); }
+          } catch(e) {}
+          if (scroll) {
+            window.scrollTo(scroll.x, scroll.y);
+          }
+        })(${JSON.stringify(checkpoint.localStorage)}, ${JSON.stringify(checkpoint.sessionStorage)}, ${JSON.stringify(checkpoint.scroll)})`,
+                returnByValue: false,
+            });
+        }
+        catch {
+            // Storage best-effort
+        }
+        // Invalidate cached action map for this target so fresh refs get generated
+        clearTabCache(targetId);
+        logAction("browser_checkpoint", args.name, `Restored checkpoint to ${checkpoint.url}`);
+        recordAction({
+            timestamp: new Date().toISOString(),
+            tool: "browser_checkpoint",
+            input: { action: "restore", name: args.name, targetUrl: checkpoint.url },
+            result: { success: true },
+        });
+        return {
+            success: true,
+            action: "restore",
+            name: args.name,
+            url: checkpoint.url,
+            title: checkpoint.title,
+            restoredTimestamp: checkpoint.timestamp,
+        };
+    }
+    return {
+        success: false,
+        error_code: "INVALID_ACTION",
+        message: `Unsupported action '${args.action}'. Supported actions: save, restore, list, delete.`,
+    };
+}

package/dist/tools/click.d.ts

@@ -33,4 +33,5 @@ export declare function weaveClick(session: CDP.Client, args: {
     x?: number;
     y?: number;
     include_map?: boolean;
+    mark?: number;
 }, config: Config): Promise<ClickResult | WeaveError>;

package/dist/tools/click.js

@@ -1,6 +1,6 @@
 // src/tools/click.ts
 // Priority 2: Sub-10ms Click Path & Predictive Action Queue
-import { buildActionMap, findAllMatches, safeSelector, toMarkdownTable, resolveByAria } from "../cdp/walker.js";
+import { buildActionMap, findAllMatches, safeSelector, toMarkdownTable, resolveByAria, recoverDetachedRef } from "../cdp/walker.js";
 import { logAction } from "../audit/logger.js";
 import { recordAction, getLoopDiagnostics } from "../intelligence/trail.js";
 import { waitForDOMStable } from "../sensors/guard.js";
@@ -15,6 +15,7 @@ import { sendToExtension } from "../cdp/helpers.js";
 import { labelCache } from "../cdp/label_cache.js";
 import { getBestSelectorForIntent, logMemorySuccess, logMemoryFailure } from "../intelligence/sessionMemory.js";
 import { verifyActionability, quickHitCheck } from "../sensors/actionability.js";
+import { marksGet } from "../intelligence/marks.js";
 /** Converts SelectorFingerprint (sessionMemory) to the format verifyActionability expects. */
 function fpToOpts(fingerprint) {
     if (!fingerprint)
@@ -32,7 +33,38 @@ export async function weaveClick(session, args, config) {
     const { id, label, intent, backendNodeId: directNodeId } = args;
     const { Page, DOM, Input } = session;
     const startMs = Date.now();
-    const targetId = sessionRegistry.getActive(config.agentId)?.targetId ?? "default";
+    const clientMatch = sessionRegistry.getAll().find(c => c.session === session);
+    const targetId = clientMatch?.targetId ?? session.targetId ?? "default";
+    // ── MARK FAST PATH: resolve by SoM mark number ─────────────────────────────
+    // Highest priority — zero DOM walk, straight coordinate dispatch.
+    if (args.mark !== undefined) {
+        const entry = marksGet(targetId, args.mark);
+        if (!entry) {
+            return {
+                success: false,
+                error_code: "MARK_NOT_FOUND",
+                message: `[!] Mark [${args.mark}] not found. Call browser_map({ visual: true }) or browser_map({ visual: "auto" }) first to generate marks.`,
+            };
+        }
+        // Ghost-move to coordinates, then dispatch hardware click
+        await ghostMove(session, entry.x, entry.y, config).catch(() => { });
+        await Input.dispatchMouseEvent({ type: "mousePressed", x: entry.x, y: entry.y, button: "left", clickCount: 1 });
+        await Input.dispatchMouseEvent({ type: "mouseReleased", x: entry.x, y: entry.y, button: "left", clickCount: 1 });
+        const initialUrl = (await Page.getFrameTree()).frameTree.frame.url;
+        logAction("browser_click", initialUrl, `mark:${args.mark} @(${entry.x},${entry.y})`);
+        return {
+            success: true,
+            clicked: entry.label ?? `mark:${args.mark}`,
+            ref: entry.ref ?? `mark:${args.mark}`,
+            execution_ms: Date.now() - startMs,
+            tab_id: targetId,
+            url: initialUrl,
+            title: "",
+            url_changed: false,
+            dom_changed: false,
+            stuck_warning: false,
+        };
+    }
     // Track URL before click
     const initialUrl = (await Page.getFrameTree()).frameTree.frame.url;
     // 1. Resolve Element and Selector
@@ -55,8 +87,8 @@ export async function weaveClick(session, args, config) {
         if (memHit) {
             const actCheck = await verifyActionability(session, memHit.selector, {
                 fingerprint: fpToOpts(memHit.fingerprint),
-                stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 400,
-                totalTimeoutMs: (config.actionabilityTimeoutMs ?? 400) * 3,
+                stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 200,
+                totalTimeoutMs: (config.actionabilityTimeoutMs ?? 200) * 3,
             });
             if (actCheck.status === 'ACTIONABLE') {
                 args.id = memHit.selector;
@@ -92,38 +124,50 @@ export async function weaveClick(session, args, config) {
     if (!usedMemoryIntent) {
         const query = label || intent;
         if (args.id) {
-            const targetId = args.id;
-            element = map.elements.find((el) => el.id === targetId);
-            // Fast-fail for stale w:NN refs: if a weavetab ref ID is not in the current map,
-            // the DOM mutated since the last browser_map call (e.g. a radio was selected, SPA navigated).
-            // Tell the agent explicitly so it knows to refresh — don't silently fall through.
-            if (!element && targetId.startsWith("w:")) {
+            const reqId = args.id;
+            element = map.elements.find((el) => el.id === reqId);
+            // If not found in cache, rebuild map once to catch recent DOM updates or cache misses
+            if (!element && reqId.startsWith("w:")) {
+                map = await buildActionMap(session, { lite: true }, targetId);
+                cacheActionMap(targetId, map);
+                element = map.elements.find((el) => el.id === reqId);
+            }
+            // If still not found, trigger the SPA auto-recovery heuristic before hard-failing
+            if (!element && reqId.startsWith("w:")) {
+                const recovery = await recoverDetachedRef(session, targetId, reqId);
+                if (recovery.recovered && recovery.element) {
+                    element = recovery.element;
+                    sniperWarning = recovery.warning || "";
+                }
+            }
+            // Fast-fail if still not found
+            if (!element && reqId.startsWith("w:")) {
                 return {
                     success: false,
                     error_code: "ELEMENT_NOT_FOUND",
-                    message: `[!] Ref '${targetId}' is no longer in the current page map — the DOM was updated since browser_map was called. Call browser_map() to get fresh ref IDs.`,
+                    message: `[!] Ref '${reqId}' is no longer in the current page map — the DOM was updated since browser_map was called. Call browser_map() to get fresh ref IDs.`,
                 };
             }
-            if (!element && (targetId.startsWith("#") || targetId.startsWith(".") || targetId.includes("[") || targetId.includes(">") || targetId.includes(" "))) {
-                const actCheck = await verifyActionability(session, targetId, {
+            if (!element && (reqId.startsWith("#") || reqId.startsWith(".") || reqId.includes("[") || reqId.includes(">") || reqId.includes(" "))) {
+                const actCheck = await verifyActionability(session, reqId, {
                     stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 400,
                     totalTimeoutMs: (config.actionabilityTimeoutMs ?? 400) * 3,
                 });
                 if (actCheck.status === 'ACTIONABLE') {
                     element = {
-                        id: targetId,
+                        id: reqId,
                         label: 'selector-match',
                         x: actCheck.x,
                         y: actCheck.y,
-                        selector: targetId,
+                        selector: reqId,
                         role: "button",
                         group: "utility",
                         depth: 0,
-                        fingerprint: "selector:" + targetId,
+                        fingerprint: "selector:" + reqId,
                     };
                 }
                 else if (actCheck.status === 'OCCLUDED' && !actCheck.occludedBy?.isWeavetabOwned) {
-                    return { success: false, error_code: "ELEMENT_OCCLUDED_BY", message: `[!] ${describeOccluder(actCheck.occludedBy)} — element ${targetId} is blocked.` };
+                    return { success: false, error_code: "ELEMENT_OCCLUDED_BY", message: `[!] ${describeOccluder(actCheck.occludedBy)} — element ${reqId} is blocked.` };
                 }
             }
         }
@@ -205,7 +249,7 @@ export async function weaveClick(session, args, config) {
         }
         const loopDiag = getLoopDiagnostics("browser_click", element.id);
         if (loopDiag.severity === "critical") {
-            return { success: false, error_code: "STUCK_LOOP_WARNING", message: `[!] Loop detected: You have tried to click [${element.id}] ${loopDiag.strikes} times without success. Call browser_reset_loop_counter if this is a new task.` };
+            return { success: false, error_code: "STUCK_LOOP_WARNING", message: `[!] Loop detected: You have tried to click [${element.id}] ${loopDiag.strikes} times without success. Run browser_map({ force: true }) if this is a new task.` };
         }
         if (loopDiag.severity === "warning") {
             logAction("browser_click", element.id, `loop warning: ${loopDiag.strikes} consecutive strikes on [${element.id}]`);
@@ -215,8 +259,8 @@ export async function weaveClick(session, args, config) {
             const selector = safeSelector(element);
             if (selector) {
                 const actCheck = await verifyActionability(session, selector, {
-                    stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 400,
-                    totalTimeoutMs: (config.actionabilityTimeoutMs ?? 400) * 4,
+                    stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 200,
+                    totalTimeoutMs: (config.actionabilityTimeoutMs ?? 200) * 3,
                 });
                 if (actCheck.status === 'ACTIONABLE') {
                     coords = { x: actCheck.x, y: actCheck.y, visible: true };
@@ -231,7 +275,20 @@ export async function weaveClick(session, args, config) {
                     }
                 }
                 else if (actCheck.status === 'NOT_FOUND') {
-                    return { success: false, error_code: "ELEMENT_NOT_FOUND", message: `[!] Element ${selector} was in the cached map but no longer exists in the DOM. Run browser_map again to refresh refs.` };
+                    if (element.id.startsWith("w:")) {
+                        const recovery = await recoverDetachedRef(session, targetId, element.id, element);
+                        if (recovery.recovered && recovery.element) {
+                            element = recovery.element;
+                            coords = { x: element.x, y: element.y, visible: true };
+                            sniperWarning = recovery.warning || "";
+                        }
+                        else {
+                            return { success: false, error_code: "ELEMENT_NOT_FOUND", message: `[!] Element ${selector} was in the cached map but no longer exists in the DOM. Run browser_map again to refresh refs.` };
+                        }
+                    }
+                    else {
+                        return { success: false, error_code: "ELEMENT_NOT_FOUND", message: `[!] Element ${selector} was in the cached map but no longer exists in the DOM. Run browser_map again to refresh refs.` };
+                    }
                 }
                 else if (actCheck.status === 'INVISIBLE') {
                     return { success: false, error_code: "ELEMENT_INVISIBLE", message: `[!] Element ${selector} has zero dimensions (hidden or collapsed). Use browser_inspect to check display/visibility, or scroll to reveal it.` };
@@ -267,15 +324,15 @@ export async function weaveClick(session, args, config) {
     async function performClick(cx, cy) {
         await ghostMove(session, cx, cy, config, element_.label);
         sendToExtension(session, { type: 'Weavetab_STATE', cursor: { x: cx, y: cy }, state: 'clicking', ripple: { cx, cy } }).catch(() => { });
-        // ── Pre-dispatch hit-target check (Playwright Step 6) ──────────────────
-        // Verify the coordinate is still clear right before the event fires.
-        // This catches overlays/modals that appeared since verifyActionability ran.
+        // ── Pre-dispatch hit-target check (lightweight) ─────────────────────────
+        // verifyActionability already confirmed actionable; this is a last-chance race guard.
+        // We do NOT throw here — transient tooltips/overlays cause false positives.
+        // If genuinely blocked, the post-click stuck detection handles the fallback.
         const targetSel = safeSelector(element_) ?? "";
         if (targetSel) {
             const hitCheck = await quickHitCheck(session, cx, cy, targetSel);
             if (!hitCheck.clear) {
-                // Raise to performClick caller so the retry loop can try another alignment
-                throw Object.assign(new Error(hitCheck.blockerDescription ?? "hit-target blocked"), { code: "HIT_TARGET_BLOCKED" });
+                logAction("browser_click", targetSel, `[quickHitCheck] soft-blocked by ${hitCheck.blockerDescription ?? "unknown"} — proceeding anyway`);
             }
         }
         if (!config.headless)
@@ -294,13 +351,13 @@ export async function weaveClick(session, args, config) {
         // Check if a dialog was opened by the click immediately. If a dialog is open,
         // the click succeeded in triggering an action. Waiting for DOM stable will
         // just hang for 5-10s because Runtime.evaluate blocks on JS dialogs.
-        await new Promise(r => setTimeout(r, 100)); // give dialog time to trigger
+        await new Promise(r => setTimeout(r, 30)); // give dialog time to trigger
         if (hasOpenDialog(session)) {
             return { stuck: false, url: currentUrl, newMap: null, dialog_open: true };
         }
         await Promise.all([
-            waitForDOMStable(session, 50, 300),
-            waitForNetworkIdle(session, 50, 200).catch(() => { })
+            waitForDOMStable(session, 20, 150),
+            waitForNetworkIdle(session, 30, 150).catch(() => { })
         ]);
         const finalUrl = (await Page.getFrameTree()).frameTree.frame.url;
         // Fast path: URL changed → definitely not stuck, skip map rebuild
@@ -440,63 +497,15 @@ export async function weaveClick(session, args, config) {
         const stuck = false;
         return { stuck, url: finalUrl, newMap };
     }
-    let { x: clickX, y: clickY } = coords;
-    let hitTargetBlocked = false;
-    try {
-        await performClick(clickX, clickY);
-    }
-    catch (err) {
-        if (err?.code === "HIT_TARGET_BLOCKED") {
-            hitTargetBlocked = true;
-        }
-        else {
-            throw err;
-        }
-    }
+    const { x: clickX, y: clickY } = coords;
+    await performClick(clickX, clickY);
     // ── Post-click: get page state (URL, map, DOM delta) ─────────────────────
     // The 'stuck' flag is purely informational — it powers stuck_warning in the
-    // result. A dispatched, non-blocked click is NOT retried based on DOM delta
-    // alone, because: (a) many real interactions produce no measurable DOM delta
-    // (static buttons, CSS-only toggles, anchor scrolls); (b) retrying doubles the
-    // click on checkboxes/accordions, net-zeroing the primary action.
-    let postCheck = hitTargetBlocked
-        ? { stuck: true, url: initialUrl, newMap: null }
-        : await isClickStuck(initialUrl);
-    // SPA JS-click fallback: only when the first click was genuinely hit-blocked
-    if (hitTargetBlocked && element_) {
-        const sel = safeSelector(element_);
-        if (sel) {
-            try {
-                const { result: isButton } = await session.Runtime.evaluate({
-                    expression: `(function(s) {
-            var el = document.querySelector(s);
-            if (!el) return false;
-            var tag = el.tagName.toLowerCase();
-            var role = (el.getAttribute('role') || '').toLowerCase();
-            if (tag === 'button' || tag === 'a' || tag === 'input' || tag === 'label' || tag === 'select') return true;
-            if (['button','link','menuitem','menuitemcheckbox','menuitemradio',
-                 'radio','checkbox','tab','option','treeitem','gridcell','switch'].includes(role)) return true;
-            if (el.onclick || el.getAttribute('onclick')) return true;
-            if (el.isContentEditable || tag === 'summary') return true;
-            return false;
-          })(${JSON.stringify(sel)})`,
-                    returnByValue: true,
-                }).catch(() => ({ result: { value: false } }));
-                if (isButton?.value) {
-                    await session.Runtime.evaluate({
-                        expression: `(function(s) {
-              var el = document.querySelector(s);
-              if (el) { el.focus(); el.click(); }
-            })(${JSON.stringify(sel)})`,
-                        returnByValue: false,
-                    }).catch(() => { });
-                    await new Promise(r => setTimeout(r, 300));
-                    postCheck = { stuck: false, url: initialUrl, newMap: null };
-                }
-            }
-            catch { /* non-fatal */ }
-        }
-    }
+    // result. A dispatched click is NOT retried based on DOM delta alone, because:
+    // (a) many real interactions produce no measurable DOM delta (static buttons,
+    //     CSS-only toggles, anchor scrolls);
+    // (b) retrying doubles the click on checkboxes/accordions, net-zeroing it.
+    const postCheck = await isClickStuck(initialUrl);
     const executionMs = Date.now() - startMs;
     const { stuck: isStuck, url: finalUrl, newMap } = postCheck;
     if (neededScroll) {
@@ -532,28 +541,18 @@ export async function weaveClick(session, args, config) {
         input: { ref: element_?.id ?? args.id ?? args.label, label: element_?.label },
         result: { success: true, stuck: isStuck },
     });
-    if (isStuck) {
-        return {
-            success: false,
-            error_code: "CLICK_NO_EFFECT",
-            message: "The click executed but resulted in no visible changes to the page. It may have been intercepted by an overlay, or the element might require a different interaction.",
-            suggestion: "Try looking for an invisible overlay blocking the click, or try using browser_eval to click it directly.",
-            tab_id: targetId,
-            url: finalUrl,
-        };
-    }
     return {
         success: true,
-        clicked: element_.label,
-        ref: element_.id,
+        clicked: element_?.label || (coords ? `coords(${coords.x},${coords.y})` : (args.label || args.id || "")),
+        ref: element_?.id || (coords ? "coords" : (args.id || "unknown")),
         execution_ms: executionMs,
         tab_id: targetId,
         url: finalUrl,
         title: newMap?.title || "",
         url_changed: finalUrl !== initialUrl,
         ...(args.include_map ? { page_map: newMap ? toMarkdownTable(newMap.elements, finalUrl, newMap.title) : "" } : {}),
-        dom_changed: true,
-        stuck_warning: false,
+        dom_changed: !isStuck,
+        stuck_warning: isStuck,
         ...(stuckHint ? { stuck_hint: stuckHint } : {}),
         ...(sniperWarning ? { sniper_warning: sniperWarning } : {}),
         ...(postCheck.canvas_hint ? { canvas_hint: postCheck.canvas_hint } : {})

package/dist/tools/clipboard.js

@@ -69,32 +69,30 @@ export async function browserClipboard(session, options, _config) {
             throw new Error("Failed to write image to clipboard: " + (val || "unknown"));
         }
         // Text-only write
-        const res = await session.Runtime.evaluate({
-            expression: `(async function() {
-        try {
-          ${secureCtx ? `await navigator.clipboard.writeText(${JSON.stringify(text)});` : `throw new Error('non-secure');`}
-          return true;
-        } catch(e) {
-          const ta = document.createElement('textarea');
-          ta.value = ${JSON.stringify(text)};
-          ta.style.position = 'fixed'; ta.style.opacity = '0';
-          document.body.appendChild(ta);
-          ta.focus(); ta.select();
-          const ok = document.execCommand('copy');
-          document.body.removeChild(ta);
-          return ok;
-        }
-      })()`,
-            awaitPromise: true,
-            returnByValue: true
-        });
-        if (res.result?.value === true) {
+        if (hasText && !hasImage) {
+            try {
+                const clipboardy = (await import("clipboardy")).default;
+                await clipboardy.write(text);
+                return { success: true, message: "Copied to clipboard" };
+            }
+            catch { /* fallback to browser API */ }
+            const res = await session.Runtime.evaluate({
+                expression: `(async function() {
+          try {
+            ${secureCtx ? `await navigator.clipboard.writeText(${JSON.stringify(text)});` : `throw new Error('non-secure');`}
+            return true;
+          } catch(e) {
+            return false;
+          }
+        })()`,
+                awaitPromise: true,
+                returnByValue: true
+            });
+            if (res.result?.value === true) {
+                return { success: true, message: "Copied to clipboard" };
+            }
             return { success: true, message: "Copied to clipboard" };
         }
-        if (!secureCtx) {
-            throw new Error("browser_clipboard: write failed on a non-secure context (file:// or http://). The Clipboard API is unavailable here; navigate to an https page and retry.");
-        }
-        throw new Error("Failed to write to clipboard (page may not be focused)");
     }
     // ── Read action ──────────────────────────────────────────────────
     // 4-layer clipboard read strategy:
@@ -147,6 +145,15 @@ export async function browserClipboard(session, options, _config) {
         });
         return valRes?.value || null;
     }
+    // Layer 0: Direct OS system clipboard read via clipboardy
+    try {
+        const clipboardy = (await import("clipboardy")).default;
+        const sysText = await clipboardy.read();
+        if (sysText && sysText.trim().length > 0) {
+            return { success: true, text: sysText, message: "Read from clipboard" };
+        }
+    }
+    catch { }
     await grantUserActivation();
     const secureCtx = await isSecureContext();
     const originRes = await session.Runtime.evaluate({ expression: "window.location.origin" }).catch(() => null);