@weavetab/mcp 2.5.0-beta.5 → 2.5.1

package/dist/state/delta.test.js

@@ -1,279 +0,0 @@
-/**
- * delta.test.ts — Phase 1.1
- * Unit tests for snapshot diffing and delta computation.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { storeSnapshot, computeDelta, seedRichSnapshot, computeRichDelta, clearAllSnapshots, } from "./delta.js";
-test("delta: first visit returns null (no baseline)", () => {
-    const targetId = "tab-1";
-    clearAllSnapshots();
-    const refs = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-    ];
-    const result = computeDelta(targetId, 'http://test.com', refs);
-    assert.equal(result, null, "First visit should return null");
-});
-test("delta: detects added elements", () => {
-    const targetId = "tab-2";
-    clearAllSnapshots();
-    const initial = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-        { id: "w:2", role: "link", label: "Home", fingerprint: "link:home:nav:1" },
-    ];
-    const result = computeDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.equal(result?.added.length, 1, "One element added");
-    assert.equal(result?.added[0]?.id, "w:2");
-    assert.equal(result?.removed.length, 0);
-    assert.equal(result?.changed.length, 0);
-});
-test("delta: detects removed elements", () => {
-    const targetId = "tab-3";
-    clearAllSnapshots();
-    const initial = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-        { id: "w:2", role: "link", label: "Home", fingerprint: "link:home:nav:1" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-    ];
-    const result = computeDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.equal(result?.added.length, 0);
-    assert.equal(result?.removed.length, 1, "One element removed");
-    assert.equal(result?.removed[0], "w:2");
-    assert.equal(result?.changed.length, 0);
-});
-test("delta: detects changed elements (label)", () => {
-    const targetId = "tab-4";
-    clearAllSnapshots();
-    const initial = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        { id: "w:1", role: "button", label: "Cancel", fingerprint: "button:cancel:div:0" },
-    ];
-    const result = computeDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.equal(result?.added.length, 0);
-    assert.equal(result?.removed.length, 0);
-    assert.equal(result?.changed.length, 1, "One element changed");
-    assert.equal(result?.changed[0]?.id, "w:1");
-    assert.equal(result?.changed[0]?.label, "Cancel");
-});
-test("delta: detects changed elements (disabled)", () => {
-    const targetId = "tab-5";
-    clearAllSnapshots();
-    const initial = [
-        { id: "w:1", role: "button", label: "Submit", disabled: false, fingerprint: "button:submit:div:0" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        { id: "w:1", role: "button", label: "Submit", disabled: true, fingerprint: "button:submit:div:0" },
-    ];
-    const result = computeDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.equal(result?.changed.length, 1, "Disabled state change detected");
-    assert.equal(result?.changed[0]?.disabled, true);
-});
-test("delta: detects changed elements (value)", () => {
-    const targetId = "tab-6";
-    clearAllSnapshots();
-    const initial = [
-        { id: "w:1", role: "textbox", label: "Email", value: "", fingerprint: "textbox:email:form:0" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        { id: "w:1", role: "textbox", label: "Email", value: "test@example.com", fingerprint: "textbox:email:form:0" },
-    ];
-    const result = computeDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.equal(result?.changed.length, 1, "Value change detected");
-    assert.equal(result?.changed[0]?.value, "test@example.com");
-});
-test("delta: counts stable elements", () => {
-    const targetId = "tab-7";
-    clearAllSnapshots();
-    const initial = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-        { id: "w:2", role: "link", label: "Home", fingerprint: "link:home:nav:1" },
-        { id: "w:3", role: "textbox", label: "Email", fingerprint: "textbox:email:form:0" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-        { id: "w:2", role: "link", label: "Home", fingerprint: "link:home:nav:1" },
-        { id: "w:3", role: "textbox", label: "Email", value: "test@example.com", fingerprint: "textbox:email:form:0" },
-    ];
-    const result = computeDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.equal(result?.stable_count, 2, "Two stable elements");
-    assert.equal(result?.changed.length, 1);
-});
-test("delta: updates stored snapshot", () => {
-    const targetId = "tab-8";
-    clearAllSnapshots();
-    const initial = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-        { id: "w:2", role: "link", label: "Home", fingerprint: "link:home:nav:1" },
-    ];
-    computeDelta(targetId, 'http://test.com', updated);
-    // Second call should see no changes since snapshot was updated
-    const secondCall = computeDelta(targetId, 'http://test.com', updated);
-    assert.ok(secondCall !== null);
-    assert.equal(secondCall?.added.length, 0);
-    assert.equal(secondCall?.removed.length, 0);
-    assert.equal(secondCall?.changed.length, 0);
-    assert.equal(secondCall?.stable_count, 2);
-});
-test("delta: rich delta - first visit returns null", async () => {
-    const targetId = "tab-9";
-    clearAllSnapshots();
-    const elements = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0", group: "utility", depth: 0 },
-    ];
-    const result = await computeRichDelta(targetId, 'http://test.com', elements);
-    assert.equal(result, null, "First visit rich delta returns null");
-});
-test("delta: rich delta - basic changed properties", async () => {
-    const targetId = "tab-10";
-    clearAllSnapshots();
-    const initial = [
-        {
-            id: "w:1",
-            role: "button",
-            label: "Submit",
-            value: "",
-            disabled: false,
-            fingerprint: "button:submit:div:0",
-            group: "utility",
-            depth: 0
-        },
-    ];
-    // Seed the snapshot first
-    seedRichSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        {
-            id: "w:1",
-            role: "button",
-            label: "Submit",
-            value: "",
-            disabled: true,
-            fingerprint: "button:submit:div:0",
-            group: "utility",
-            depth: 0
-        },
-    ];
-    const result = await computeRichDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.ok(!("delta_timeout" in result));
-    const diff = result;
-    assert.equal(diff.changed.length, 1);
-    assert.equal(diff.changed[0]?.ref, "w:1");
-    assert.ok("disabled" in diff.changed[0]?.changes);
-    assert.equal(diff.changed[0]?.changes?.disabled?.from, "false");
-    assert.equal(diff.changed[0]?.changes?.disabled?.to, "true");
-});
-test("delta: rich delta - marks interactive elements as actionable", async () => {
-    const targetId = "tab-11";
-    clearAllSnapshots();
-    const initial = [
-        {
-            id: "w:1",
-            role: "button",
-            label: "Submit",
-            fingerprint: "button:submit:div:0",
-            group: "utility",
-            depth: 0
-        },
-    ];
-    // Seed the snapshot first
-    seedRichSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        {
-            id: "w:1",
-            role: "button",
-            label: "Submit",
-            value: "",
-            disabled: false, // Changed from undefined/missing to false
-            fingerprint: "button:submit:div:0",
-            group: "utility",
-            depth: 0
-        },
-    ];
-    const result = await computeRichDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.ok(!("delta_timeout" in result));
-    const diff = result;
-    assert.equal(diff.changed.length, 1);
-    assert.equal(diff.changed[0]?.actionable, true);
-    assert.equal(diff.changed[0]?.recommended_action, "click");
-});
-test("delta: rich delta - iframe tracking", async () => {
-    const targetId = "tab-12";
-    clearAllSnapshots();
-    const initial = [
-        {
-            id: "w:1",
-            role: "button",
-            label: "Submit",
-            frameUrl: "https://example.com",
-            fingerprint: "button:submit:div:0",
-            group: "utility",
-            depth: 0
-        },
-    ];
-    // Seed the snapshot first
-    seedRichSnapshot(targetId, 'http://test.com', initial);
-    const updated = [
-        {
-            id: "w:1",
-            role: "button",
-            label: "Submit",
-            frameUrl: "https://example.com",
-            fingerprint: "button:submit:div:0",
-            group: "utility",
-            depth: 0
-        },
-        {
-            id: "w:2",
-            role: "link",
-            label: "Home",
-            frameUrl: "https://iframe.com",
-            fingerprint: "link:home:nav:1",
-            group: "navigation",
-            depth: 1
-        },
-    ];
-    const result = await computeRichDelta(targetId, 'http://test.com', updated);
-    assert.ok(result !== null);
-    assert.ok(!("delta_timeout" in result));
-    const diff = result;
-    assert.ok(diff.iframes !== undefined);
-    assert.equal(diff.iframes?.length, 1);
-    assert.equal(diff.iframes?.[0]?.status, "added");
-    assert.equal(diff.iframes?.[0]?.frameUrl, "https://iframe.com");
-});
-test("delta: clearSnapshot removes all data", () => {
-    const targetId = "tab-13";
-    const refs = [
-        { id: "w:1", role: "button", label: "Submit", fingerprint: "button:submit:div:0" },
-    ];
-    storeSnapshot(targetId, 'http://test.com', refs);
-    seedRichSnapshot(targetId, 'http://test.com', []);
-    clearAllSnapshots();
-    const result = computeDelta(targetId, 'http://test.com', refs);
-    assert.equal(result, null, "Cache cleared");
-});
-//# sourceMappingURL=delta.test.js.map

package/dist/state/groups.d.ts

@@ -1,15 +0,0 @@
-import CDP from "chrome-remote-interface";
-interface GroupEntry {
-    groupName: string;
-    tabIds: string[];
-}
-interface GroupStore {
-    [windowId: number]: GroupEntry[];
-}
-export declare function saveGroup(windowId: number, groupName: string, tabIds: string[]): void;
-export declare function removeTabFromGroups(tabId: string): void;
-export declare function clearStore(): void;
-export declare function getStore(): GroupStore;
-export declare function restoreGroups(session: CDP.Client): Promise<void>;
-export {};
-//# sourceMappingURL=groups.d.ts.map

package/dist/state/groups.js

@@ -1,80 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-const GROUPS_DIR = path.join(os.homedir(), ".Weavetab-system", "groups");
-const GROUPS_FILE = path.join(GROUPS_DIR, "groups.json");
-function ensureDir() {
-    if (!fs.existsSync(GROUPS_DIR)) {
-        fs.mkdirSync(GROUPS_DIR, { recursive: true });
-    }
-}
-function readStore() {
-    try {
-        if (fs.existsSync(GROUPS_FILE)) {
-            return JSON.parse(fs.readFileSync(GROUPS_FILE, "utf-8"));
-        }
-    }
-    catch {
-        // corrupted — reset
-    }
-    return {};
-}
-function writeStore(store) {
-    ensureDir();
-    fs.writeFileSync(GROUPS_FILE, JSON.stringify(store), "utf-8");
-}
-export function saveGroup(windowId, groupName, tabIds) {
-    const store = readStore();
-    if (!store[windowId])
-        store[windowId] = [];
-    const existing = store[windowId].find(g => g.groupName === groupName);
-    if (existing) {
-        existing.tabIds = tabIds;
-    }
-    else {
-        store[windowId].push({ groupName, tabIds });
-    }
-    writeStore(store);
-}
-export function removeTabFromGroups(tabId) {
-    const store = readStore();
-    let changed = false;
-    for (const windowId of Object.keys(store)) {
-        const groups = store[Number(windowId)];
-        for (const group of groups) {
-            const idx = group.tabIds.indexOf(tabId);
-            if (idx !== -1) {
-                group.tabIds.splice(idx, 1);
-                changed = true;
-            }
-        }
-        store[Number(windowId)] = groups.filter(g => g.tabIds.length > 0);
-    }
-    if (changed)
-        writeStore(store);
-}
-export function clearStore() {
-    try {
-        if (fs.existsSync(GROUPS_FILE))
-            fs.unlinkSync(GROUPS_FILE);
-    }
-    catch { /* ignore */ }
-}
-export function getStore() {
-    return readStore();
-}
-export async function restoreGroups(session) {
-    const store = readStore();
-    const entries = Object.entries(store).flatMap(([windowId, groups]) => groups.map(g => ({ windowId: Number(windowId), groupName: g.groupName, tabIds: g.tabIds })));
-    if (entries.length === 0)
-        return;
-    try {
-        const { sendToExtension } = await import("../cdp/helpers.js");
-        await sendToExtension(session, {
-            type: "Weavetab_RESTORE_GROUPS",
-            groups: entries,
-        });
-    }
-    catch { /* best-effort */ }
-}
-//# sourceMappingURL=groups.js.map

package/dist/tools/accessibility.d.ts

@@ -1,14 +0,0 @@
-/**
- * Weavetab — tools/accessibility.ts
- * browser_accessibility: returns the full Chrome accessibility tree via Accessibility.getFullAXTree.
- *
- * Use this to understand ARIA-heavy UIs when the standard DOM map is insufficient.
- * Weavetab by fy2ne
- */
-import CDP from "chrome-remote-interface";
-import type { Config } from "../config/loader.js";
-export interface AccessibilityResult {
-    success: boolean;
-    tree: any;
-}
-export declare function browserAccessibility(session: CDP.Client, _config: Config): Promise<AccessibilityResult>;

package/dist/tools/accessibility.js

@@ -1,32 +0,0 @@
-export async function browserAccessibility(session, _config) {
-    try {
-        // Enable Accessibility domain
-        await session.Accessibility.enable();
-        const tree = await session.Accessibility.getFullAXTree();
-        // Simplify tree for LLM consumption
-        const simplify = (node) => {
-            if (node.ignored)
-                return null;
-            const role = node.role?.value;
-            const name = node.name?.value;
-            const value = node.value?.value;
-            const children = (node.children || []).map(simplify).filter(Boolean);
-            if (!name && children.length === 0 && !value)
-                return null; // skip noise
-            return {
-                role,
-                name: name || undefined,
-                value: value || undefined,
-                nodeId: node.nodeId,
-                backendDOMNodeId: node.backendDOMNodeId,
-                children: children.length > 0 ? children : undefined
-            };
-        };
-        const root = tree.nodes.find((n) => !n.parentId);
-        const simplifiedTree = simplify(root);
-        return { success: true, tree: simplifiedTree };
-    }
-    catch (error) {
-        throw new Error(`Failed to get accessibility tree: ${error}`);
-    }
-}

package/dist/tools/ask.d.ts

@@ -1,14 +0,0 @@
-import CDP from "chrome-remote-interface";
-export interface AskResult {
-    success: true;
-    response: string;
-    timeout?: boolean;
-}
-export declare function browserAsk(session: CDP.Client, args: {
-    question: string;
-}): Promise<AskResult | {
-    success: false;
-    error_code: string;
-    message: string;
-}>;
-//# sourceMappingURL=ask.d.ts.map

package/dist/tools/ask.js

@@ -1,49 +0,0 @@
-// src/tools/ask.ts
-// browser_ask — renders ask UI in content.js via sendToExtension, polls result
-import { logAction } from "../audit/logger.js";
-import { sendToExtension } from "../cdp/helpers.js";
-function sleep(ms) {
-    return new Promise(r => setTimeout(r, ms));
-}
-export async function browserAsk(session, args) {
-    const { question } = args;
-    const ASK_TIMEOUT_MS = 300000;
-    const COUNTDOWN_SEC = 300;
-    logAction("browser_ask", "prompting", question);
-    // Show HUD hint + waiting state
-    await sendToExtension(session, { type: 'Weavetab_STATE', state: 'waiting', hud: { action: question.slice(0, 40) + (question.length > 40 ? '...' : '') } });
-    // Show ask UI via content.js
-    await sendToExtension(session, { type: 'Weavetab_ASK', question }).catch(() => { });
-    // Poll for result via DOM bridge (shared between isolated & main worlds)
-    const start = Date.now();
-    while (Date.now() - start < ASK_TIMEOUT_MS) {
-        await sleep(500);
-        try {
-            const { result } = await session.Runtime.evaluate({
-                expression: `(() => { try {
-          var el = document.getElementById('__wt_ask_bridge');
-          if (!el || el.dataset.status === 'pending') return null;
-          return JSON.stringify({ status: el.dataset.status, result: el.dataset.result });
-        } catch(e) { return null; } })()`,
-                returnByValue: true,
-            });
-            if (result?.value) {
-                const data = JSON.parse(result.value);
-                if (data.status === 'submitted') {
-                    logAction("browser_ask", "answered", data.result);
-                    return { success: true, response: data.result };
-                }
-                if (data.status === 'cancelled' || data.status === 'timeout') {
-                    logAction("browser_ask", data.status, "");
-                    return { success: true, response: "", timeout: true };
-                }
-            }
-        }
-        catch {
-            // polling error — retry
-        }
-    }
-    logAction("browser_ask", "timeout", "");
-    return { success: true, response: "", timeout: true };
-}
-//# sourceMappingURL=ask.js.map

package/dist/tools/click_and_wait.d.ts

@@ -1,33 +0,0 @@
-import CDP from "chrome-remote-interface";
-import type { Config } from "../config/loader.js";
-import type { ClickResult, WeaveError } from "./click.js";
-export interface ClickAndWaitOptions {
-    /** Element identifier - can be id, label, intent, or selector */
-    id?: string;
-    label?: string;
-    intent?: string;
-    /** Direct coordinates bypass */
-    x?: number;
-    y?: number;
-    /** Time to wait after click for page response (ms) */
-    waitAfter?: number;
-    /** Whether to wait for network idle after click */
-    waitForNetwork?: boolean;
-    /** Whether to return the page map after click */
-    includeMap?: boolean;
-    /** Fast mode - skip stability checks */
-    fast?: boolean;
-    /** Execute in a specific tab instead of active */
-    tab_id?: string;
-}
-export interface ClickAndWaitResult extends ClickResult {
-    /** Time waited after click */
-    waited_ms: number;
-    /** Whether network was idle after wait */
-    network_idle?: boolean;
-}
-/**
- * Consolidated tool that combines element resolution, clicking, and waiting.
- * Eliminates 2-3 tool calls in the common pattern: find → click → wait
- */
-export declare function weaveClickAndWait(session: CDP.Client, args: ClickAndWaitOptions, config: Config): Promise<ClickAndWaitResult | WeaveError>;

package/dist/tools/click_and_wait.js

@@ -1,149 +0,0 @@
-// src/tools/click_and_wait.ts
-// Consolidated tool: find element + click + wait for response in one CDP round-trip
-// Eliminates the common pattern: browser_map → browser_click → browser_wait
-import { buildActionMap, findBestMatch, safeSelector, toMarkdownTable } from "../cdp/walker.js";
-import { recordAction, trackToolCall, detectStuckLoop } from "../intelligence/trail.js";
-import { waitForDOMStable } from "../sensors/guard.js";
-import { waitForNetworkIdle } from "../sensors/wait.js";
-import { ghostMove, ghostClick } from "../overlay/ghost.js";
-import { cacheActionMap, getCachedActionMap } from "../state/cache.js";
-import { storeSnapshot, computeDelta } from "../state/delta.js";
-import { sessionRegistry } from "../state/session.js";
-import { getConfigAgentId } from "../config/loader.js";
-import { operationMonitor } from "../sensors/operation_monitor.js";
-/**
- * Consolidated tool that combines element resolution, clicking, and waiting.
- * Eliminates 2-3 tool calls in the common pattern: find → click → wait
- */
-export async function weaveClickAndWait(session, args, config) {
-    const { id, label, intent, x, y, waitAfter = 500, waitForNetwork = true, includeMap = false, fast = false, tab_id } = args;
-    const { Page, DOM, Input } = session;
-    const startMs = Date.now();
-    const targetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId ?? "default";
-    const operationId = `clickAndWait-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    operationMonitor.startOperation(operationId, 'browser_click_and_wait');
-    // Handle tab switching if tab_id is provided
-    let targetSession = session;
-    if (tab_id) {
-        const { connectToTab } = await import("../cdp/connector.js");
-        const client = await connectToTab(tab_id);
-        targetSession = client.session;
-    }
-    // Check for stuck loop before processing
-    const stuckCheck = detectStuckLoop();
-    if (stuckCheck.stuck) {
-        return {
-            success: false,
-            error_code: "STUCK_LOOP",
-            message: stuckCheck.diagnosis || "Agent is stuck in a loop",
-            suggestion: "Try a different approach or reset the loop counter",
-        };
-    }
-    // Get initial URL
-    const initialUrl = (await targetSession.Page.getFrameTree()).frameTree.frame.url;
-    // Build or get cached action map
-    let map = getCachedActionMap(targetId, initialUrl);
-    if (!map) {
-        map = await buildActionMap(targetSession, { lite: true }, targetId);
-        cacheActionMap(targetId, map);
-    }
-    await storeSnapshot(targetId, initialUrl, map.elements);
-    // Resolve element
-    let element;
-    if (id) {
-        element = map.elements.find((el) => el.id === id || el.id.endsWith(id));
-    }
-    if (!element && label) {
-        element = findBestMatch(map.elements, label);
-    }
-    if (!element && intent) {
-        element = findBestMatch(map.elements, intent);
-    }
-    if (!element && !x && !y) {
-        return {
-            success: false,
-            error_code: "ELEMENT_NOT_FOUND",
-            message: `Element not found with id="${id}", label="${label}", or intent="${intent}"`,
-            suggestion: "Try browser_map to see available elements, or use x/y coordinates",
-        };
-    }
-    const clickX = x ?? element?.x;
-    const clickY = y ?? element?.y;
-    const selector = element ? safeSelector(element) : undefined;
-    if (!clickX || !clickY) {
-        return {
-            success: false,
-            error_code: "NO_COORDINATES",
-            message: "Could not determine click coordinates",
-            suggestion: "Provide explicit x/y coordinates or ensure element has position data",
-        };
-    }
-    // Perform click with ghost move
-    await ghostMove(targetSession, clickX, clickY, config, element?.label || "target");
-    await ghostClick(targetSession, clickX, clickY, { pointerType: 'mouse' });
-    await new Promise(r => setTimeout(r, 30 + Math.random() * 40));
-    await targetSession.Input.dispatchMouseEvent({
-        type: 'mouseReleased',
-        x: clickX,
-        y: clickY,
-        button: 'left',
-        clickCount: 1,
-        pointerType: 'mouse'
-    });
-    // Wait for response
-    const waitStart = Date.now();
-    if (waitForNetwork) {
-        await Promise.all([
-            waitForDOMStable(targetSession, 50, 300),
-            waitForNetworkIdle(targetSession, waitAfter, waitAfter * 2).catch(() => { })
-        ]);
-    }
-    else {
-        await new Promise(r => setTimeout(r, waitAfter));
-    }
-    const waitedMs = Date.now() - waitStart;
-    // Check result
-    const finalUrl = (await targetSession.Page.getFrameTree()).frameTree.frame.url;
-    const urlChanged = finalUrl !== initialUrl;
-    let newMap = map;
-    let domChanged = false;
-    if (urlChanged || includeMap) {
-        newMap = await buildActionMap(targetSession, { lite: true }, targetId);
-        cacheActionMap(targetId, newMap);
-        const delta = computeDelta(targetId, initialUrl, newMap.elements);
-        domChanged = delta ? delta.added.length + delta.removed.length + delta.changed.length > 0 : urlChanged;
-    }
-    else {
-        const delta = computeDelta(targetId, initialUrl, map.elements);
-        domChanged = delta ? delta.added.length + delta.removed.length + delta.changed.length > 0 : false;
-    }
-    const executionMs = Date.now() - startMs;
-    // Track tool call
-    trackToolCall("browser_click_and_wait", element?.id || id || label || "coordinates", {
-        success: true,
-        urlChanged
-    });
-    recordAction({
-        timestamp: new Date().toISOString(),
-        tool: "browser_click_and_wait",
-        input: { ref: element?.id || id || label, waitAfter, waitForNetwork },
-        result: { success: true, urlChanged, domChanged, waitedMs },
-    });
-    operationMonitor.endOperation(operationId);
-    const result = {
-        success: true,
-        clicked: element?.label || "coordinates",
-        ref: element?.id || id || "coordinates",
-        execution_ms: executionMs,
-        tab_id: targetId,
-        url: finalUrl,
-        title: newMap?.title || "",
-        url_changed: urlChanged,
-        ...(includeMap ? { page_map: newMap ? toMarkdownTable(newMap.elements, finalUrl, newMap.title) : "" } : {}),
-        dom_changed: domChanged,
-        stuck_warning: false,
-        waited_ms: waitedMs,
-        network_idle: waitForNetwork,
-    };
-    return result;
-}