@weavetab/mcp 2.5.0-beta.0

package/dist/state/delta.test.js

@@ -0,0 +1,279 @@
+/**
+ * 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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,80 @@
+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/state/session.d.ts

@@ -0,0 +1,30 @@
+import { BrowserClient } from "../cdp/connector.js";
+export declare class SessionRegistry {
+    private sessions;
+    private activeTargetIdByAgent;
+    private onNewTabCallbacks;
+    private heartbeatTimestamps;
+    private heartbeatIntervals;
+    private browserContextsByAgent;
+    constructor();
+    private loadPersistence;
+    private savePersistence;
+    getBrowserContextIdForAgent(agentId: string): string | undefined;
+    getAgentForBrowserContextId(contextId: string): string | undefined;
+    setBrowserContextIdForAgent(agentId: string, contextId: string): void;
+    getActive(agentId?: string): BrowserClient | null;
+    getMostRecent(agentId?: string): BrowserClient | null;
+    setActive(targetId: string, agentId: string): void;
+    getAll(): BrowserClient[];
+    getAllForAgent(agentId: string): BrowserClient[];
+    register(targetId: string, client: BrowserClient): void;
+    unregister(targetId: string): void;
+    getHealth(targetId: string): "alive" | "dead" | "unreachable";
+    beatHeartbeat(targetId: string): void;
+    private startHeartbeat;
+    private stopHeartbeat;
+    onNewTab(callback: (targetId: string) => void): void;
+    offNewTab(callback: (targetId: string) => void): void;
+    notifyNewTab(targetId: string): void;
+}
+export declare const sessionRegistry: SessionRegistry;

package/dist/state/session.js

@@ -0,0 +1,155 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getGlobalSystemDir } from "../config/loader.js";
+const HEARTBEAT_INTERVAL_MS = 5000;
+const HEARTBEAT_MISSED_LIMIT = 3;
+const HEARTBEAT_TIMEOUT_MS = HEARTBEAT_INTERVAL_MS * HEARTBEAT_MISSED_LIMIT;
+const REGISTRY_FILE = path.join(getGlobalSystemDir("registry"), "contexts.json");
+export class SessionRegistry {
+    sessions = new Map();
+    activeTargetIdByAgent = new Map(); // agentId -> targetId
+    onNewTabCallbacks = [];
+    heartbeatTimestamps = new Map();
+    heartbeatIntervals = new Map();
+    browserContextsByAgent = new Map(); // agentId -> browserContextId
+    constructor() {
+        this.loadPersistence();
+    }
+    loadPersistence() {
+        try {
+            if (fs.existsSync(REGISTRY_FILE)) {
+                const data = JSON.parse(fs.readFileSync(REGISTRY_FILE, "utf-8"));
+                for (const [agentId, contextId] of Object.entries(data)) {
+                    this.browserContextsByAgent.set(agentId, contextId);
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+    savePersistence() {
+        try {
+            const data = {};
+            for (const [agentId, contextId] of this.browserContextsByAgent.entries()) {
+                data[agentId] = contextId;
+            }
+            fs.writeFileSync(REGISTRY_FILE, JSON.stringify(data, null, 2), "utf-8");
+        }
+        catch { /* non-fatal */ }
+    }
+    getBrowserContextIdForAgent(agentId) {
+        return this.browserContextsByAgent.get(agentId);
+    }
+    getAgentForBrowserContextId(contextId) {
+        for (const [agentId, cid] of this.browserContextsByAgent.entries()) {
+            if (cid === contextId)
+                return agentId;
+        }
+        return undefined;
+    }
+    setBrowserContextIdForAgent(agentId, contextId) {
+        this.browserContextsByAgent.set(agentId, contextId);
+        this.savePersistence();
+    }
+    getActive(agentId) {
+        if (!agentId)
+            return null;
+        const targetId = this.activeTargetIdByAgent.get(agentId);
+        if (!targetId)
+            return null;
+        return this.sessions.get(targetId) || null;
+    }
+    getMostRecent(agentId) {
+        const values = Array.from(this.sessions.values()).filter(c => c.agentId === agentId);
+        return values.length > 0 ? values[values.length - 1] : null;
+    }
+    setActive(targetId, agentId) {
+        if (this.sessions.has(targetId)) {
+            this.activeTargetIdByAgent.set(agentId, targetId);
+        }
+    }
+    getAll() {
+        return Array.from(this.sessions.values());
+    }
+    getAllForAgent(agentId) {
+        return Array.from(this.sessions.values()).filter(c => c.agentId === agentId);
+    }
+    register(targetId, client) {
+        this.sessions.set(targetId, client);
+        this.heartbeatTimestamps.set(targetId, Date.now());
+        this.startHeartbeat(targetId, client.session);
+        if (!this.activeTargetIdByAgent.has(client.agentId)) {
+            this.activeTargetIdByAgent.set(client.agentId, targetId);
+        }
+    }
+    unregister(targetId) {
+        this.stopHeartbeat(targetId);
+        const client = this.sessions.get(targetId);
+        if (client) {
+            client.session.close().catch(() => { });
+            this.sessions.delete(targetId);
+            const activeForAgent = this.activeTargetIdByAgent.get(client.agentId);
+            if (activeForAgent === targetId) {
+                const agentTabs = Array.from(this.sessions.values()).filter(c => c.agentId === client.agentId);
+                if (agentTabs.length > 0) {
+                    this.activeTargetIdByAgent.set(client.agentId, agentTabs[agentTabs.length - 1].targetId);
+                }
+                else {
+                    this.activeTargetIdByAgent.delete(client.agentId);
+                }
+            }
+        }
+        this.heartbeatTimestamps.delete(targetId);
+    }
+    getHealth(targetId) {
+        if (!this.sessions.has(targetId))
+            return "unreachable";
+        const lastBeat = this.heartbeatTimestamps.get(targetId);
+        if (!lastBeat)
+            return "unreachable";
+        const elapsed = Date.now() - lastBeat;
+        if (elapsed > HEARTBEAT_TIMEOUT_MS)
+            return "dead";
+        return "alive";
+    }
+    beatHeartbeat(targetId) {
+        this.heartbeatTimestamps.set(targetId, Date.now());
+    }
+    startHeartbeat(targetId, session) {
+        if (this.heartbeatIntervals.has(targetId))
+            return;
+        const interval = setInterval(async () => {
+            try {
+                const { result } = await session.Runtime.evaluate({
+                    expression: `document.readyState`,
+                    returnByValue: true,
+                });
+                if (result?.value) {
+                    this.beatHeartbeat(targetId);
+                }
+            }
+            catch {
+                // heartbeat failed — tab may be dead, will be caught by getHealth()
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+        this.heartbeatIntervals.set(targetId, interval);
+    }
+    stopHeartbeat(targetId) {
+        const interval = this.heartbeatIntervals.get(targetId);
+        if (interval) {
+            clearInterval(interval);
+            this.heartbeatIntervals.delete(targetId);
+        }
+    }
+    onNewTab(callback) {
+        this.onNewTabCallbacks.push(callback);
+    }
+    offNewTab(callback) {
+        this.onNewTabCallbacks = this.onNewTabCallbacks.filter(cb => cb !== callback);
+    }
+    notifyNewTab(targetId) {
+        for (const cb of this.onNewTabCallbacks) {
+            cb(targetId);
+        }
+    }
+}
+export const sessionRegistry = new SessionRegistry();

package/dist/tools/accessibility.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,49 @@
+// 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