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

package/dist/tools/github/index.d.ts

@@ -1,4 +1,19 @@
-export { githubAnalyze } from "./analyze.js";
-export { githubRead } from "./read.js";
-export { githubIssues } from "./issues.js";
-export { githubGetPr } from "./pr.js";
+import CDP from "chrome-remote-interface";
+import type { Config } from "../../config/loader.js";
+import { githubAnalyze } from "./analyze.js";
+import { githubRead } from "./read.js";
+import { githubIssues } from "./issues.js";
+import { githubGetPr } from "./pr.js";
+export { githubAnalyze, githubRead, githubIssues, githubGetPr };
+export interface BrowserGithubArgs {
+    action: "analyze" | "read" | "issues" | "pr";
+    repo?: string;
+    paths?: string[];
+    line_range?: [number, number];
+    number?: number;
+    search?: string;
+    labels?: string[];
+    state?: "open" | "closed" | "all";
+    limit?: number;
+}
+export declare function browserGithub(session: CDP.Client, args: BrowserGithubArgs, cfg: Config): Promise<any>;

package/dist/tools/github/index.js

@@ -1,4 +1,40 @@
-export { githubAnalyze } from "./analyze.js";
-export { githubRead } from "./read.js";
-export { githubIssues } from "./issues.js";
-export { githubGetPr } from "./pr.js";
+import { githubAnalyze } from "./analyze.js";
+import { githubRead } from "./read.js";
+import { githubIssues } from "./issues.js";
+import { githubGetPr } from "./pr.js";
+export { githubAnalyze, githubRead, githubIssues, githubGetPr };
+export async function browserGithub(session, args, cfg) {
+    switch (args.action) {
+        case "analyze":
+            return await githubAnalyze(session, cfg, args.repo);
+        case "read": {
+            const paths = args.paths || [];
+            if (!paths.length) {
+                return {
+                    error: "MISSING_PATHS",
+                    message: "action 'read' requires 'paths' parameter with at least one file path."
+                };
+            }
+            return await githubRead(session, { repo: args.repo, paths, line_range: args.line_range }, cfg);
+        }
+        case "issues":
+            return await githubIssues(session, {
+                repo: args.repo,
+                search: args.search,
+                number: args.number,
+                labels: args.labels,
+                state: args.state,
+                limit: args.limit
+            });
+        case "pr":
+            return await githubGetPr(session, {
+                repo: args.repo,
+                number: args.number
+            });
+        default:
+            return {
+                error: "INVALID_ACTION",
+                message: `Unknown action: ${args.action}. Must be 'analyze', 'read', 'issues', or 'pr'.`
+            };
+    }
+}

package/dist/tools/highlight.d.ts

@@ -1,18 +1,22 @@
 /**
  * Weavetab — tools/highlight.ts
- * browser_highlight: draws a CSS shimmer animation over the element that auto-fades.
- * Falls back through 5 strategies so w:NN refs always resolve.
+ * browser_highlight: draws visual consideration, target lock, danger/success or shimmer overlays.
+ * Supports multiple candidate refs, custom styles, floating labels, and multi-tier fallbacks.
  */
 import CDP from "chrome-remote-interface";
 import type { Config } from "../config/loader.js";
+export type HighlightStyle = "consideration" | "target" | "danger" | "success" | "shimmer";
 export interface HighlightOptions {
     selector?: string;
     id?: string;
     ref?: string;
+    refs?: string[];
     target?: string;
     label?: string;
     nodeId?: number;
     color?: string;
+    style?: HighlightStyle;
+    duration?: number;
 }
 export declare function browserHighlight(session: CDP.Client, options: HighlightOptions, _config: Config): Promise<{
     success: boolean;

package/dist/tools/highlight.js

@@ -1,31 +1,95 @@
 import { getConfigAgentId } from "../config/loader.js";
 export async function browserHighlight(session, options, _config) {
-    const { selector, nodeId } = options;
-    // Inject shimmer keyframe once
+    const style = options.style || (options.refs && options.refs.length > 0 ? "consideration" : "shimmer");
+    const defaultDuration = style === "shimmer" ? 600 : 2000;
+    const duration = typeof options.duration === "number" && options.duration > 0 ? options.duration : defaultDuration;
+    const customLabel = options.label || "";
+    const customColor = options.color;
+    // Inject required keyframes once
     await session.Runtime.evaluate({
         expression: `(function(){
-      if (!document.getElementById('wt-shimmer-style')) {
+      if (!document.getElementById('wt-highlight-styles')) {
         var s = document.createElement('style');
-        s.id = 'wt-shimmer-style';
-        s.textContent = '@keyframes wt-shimmer{0%{opacity:0;background-position:-200% 0}15%{opacity:0.9}40%{opacity:0.7}85%{opacity:0.3}100%{opacity:0;background-position:200% 0}}';
+        s.id = 'wt-highlight-styles';
+        s.textContent = \`
+          @keyframes wt-shimmer {
+            0% { opacity: 0; background-position: -200% 0; }
+            15% { opacity: 0.9; }
+            40% { opacity: 0.7; }
+            85% { opacity: 0.3; }
+            100% { opacity: 0; background-position: 200% 0; }
+          }
+          @keyframes wt-consider-pulse {
+            0%, 100% { box-shadow: 0 0 0 1px rgba(56,189,248,0.7), 0 0 14px rgba(56,189,248,0.35); opacity: 0.92; }
+            50% { box-shadow: 0 0 0 2px rgba(56,189,248,0.95), 0 0 22px rgba(56,189,248,0.6); opacity: 1; }
+          }
+          @keyframes wt-target-lock {
+            0% { transform: scale(1.05); opacity: 0.5; }
+            100% { transform: scale(1); opacity: 1; }
+          }
+          @keyframes wt-danger-pulse {
+            0%, 100% { box-shadow: 0 0 0 1px rgba(239,68,68,0.7), 0 0 14px rgba(239,68,68,0.35); opacity: 0.92; }
+            50% { box-shadow: 0 0 0 2px rgba(239,68,68,0.95), 0 0 22px rgba(239,68,68,0.6); opacity: 1; }
+          }
+          @keyframes wt-success-glow {
+            0% { opacity: 0.6; box-shadow: 0 0 0 1px rgba(16,185,129,0.7); }
+            100% { opacity: 1; box-shadow: 0 0 0 2px rgba(16,185,129,0.9), 0 0 18px rgba(16,185,129,0.45); }
+          }
+        \`;
         (document.head || document.documentElement).appendChild(s);
       }
     })()`,
         returnByValue: true,
     }).catch(() => { });
-    // Draw shimmer overlay at raw coordinates — works without any DOM query
-    function makeCoordShimmer(x, y, w, h) {
+    function getOverlayCss(styleName, durMs, colorOverride) {
+        if (colorOverride) {
+            return `border:2px solid ${colorOverride};box-shadow:0 0 14px ${colorOverride};background:${colorOverride}1a;border-radius:4px;transition:opacity 0.2s ease-out;`;
+        }
+        switch (styleName) {
+            case "consideration":
+                return `border:1.5px solid rgba(56,189,248,0.9);background:rgba(56,189,248,0.08);box-shadow:0 0 14px rgba(56,189,248,0.4);border-radius:4px;animation:wt-consider-pulse 1.4s ease-in-out infinite;`;
+            case "target":
+                return `border:2px solid rgba(245,158,11,0.95);background:rgba(245,158,11,0.12);box-shadow:0 0 16px rgba(245,158,11,0.45);border-radius:4px;animation:wt-target-lock 0.2s cubic-bezier(0.16,1,0.3,1);`;
+            case "danger":
+                return `border:1.5px solid rgba(239,68,68,0.95);background:rgba(239,68,68,0.1);box-shadow:0 0 16px rgba(239,68,68,0.45);border-radius:4px;animation:wt-danger-pulse 1.4s ease-in-out infinite;`;
+            case "success":
+                return `border:1.5px solid rgba(16,185,129,0.95);background:rgba(16,185,129,0.1);box-shadow:0 0 16px rgba(16,185,129,0.45);border-radius:4px;animation:wt-success-glow 0.3s ease-out forwards;`;
+            case "shimmer":
+            default:
+                return `background:linear-gradient(120deg,transparent 30%,rgba(139,92,246,0.3) 50%,transparent 70%);background-size:200% 100%;animation:wt-shimmer ${durMs / 1000}s ease-out forwards;border:1.5px solid rgba(139,92,246,0.6);border-radius:3px;box-shadow:0 0 8px rgba(139,92,246,0.25);`;
+        }
+    }
+    // Draw overlay at raw coordinates
+    function makeCoordOverlay(x, y, w, h, badgeLabel) {
+        const styleCss = getOverlayCss(style, duration, customColor);
+        const escapedBadge = badgeLabel ? badgeLabel.replace(/"/g, '"') : '';
+        const badgeHtml = escapedBadge
+            ? `<span style="position:absolute;top:-20px;left:0;background:#09090b;border:1px solid #27272a;color:#f4f4f5;font-size:10px;font-family:-apple-system,BlinkMacSystemFont,\\'Segoe UI\\',sans-serif;font-weight:500;padding:1px 6px;border-radius:4px;white-space:nowrap;pointer-events:none;box-shadow:0 2px 6px rgba(0,0,0,0.5);">${escapedBadge}</span>`
+            : '';
         return `(function(){
       var div = document.createElement('div');
-      div.style.cssText = 'position:fixed;left:${x}px;top:${y}px;width:${w}px;height:${h}px;z-index:2147483647;pointer-events:none;background:linear-gradient(120deg,transparent 30%,rgba(139,92,246,0.3) 50%,transparent 70%);background-size:200% 100%;animation:wt-shimmer 0.5s ease-out forwards;border:1.5px solid rgba(139,92,246,0.6);border-radius:3px;box-shadow:0 0 8px rgba(139,92,246,0.25);';
+      div.setAttribute('data-wt-ignore', 'true');
+      div.style.cssText = 'position:fixed;left:${x}px;top:${y}px;width:${w}px;height:${h}px;z-index:2147483647;pointer-events:none;${styleCss}';
+      if (${JSON.stringify(badgeHtml)}) {
+        div.innerHTML = ${JSON.stringify(badgeHtml)};
+      }
       (document.getElementById('Weavetab-root')?.shadowRoot || document.getElementById('Weavetab-root') || document.body).appendChild(div);
-      setTimeout(function(){ if(div.parentNode) div.parentNode.removeChild(div); }, 600);
+      setTimeout(function(){
+        div.style.transition = 'opacity 0.2s ease-out';
+        div.style.opacity = '0';
+        setTimeout(function(){ if(div.parentNode) div.parentNode.removeChild(div); }, 220);
+      }, ${duration});
       return true;
     })()`;
     }
-    // Draw shimmer by querying a CSS selector
-    function makeSelectorShimmer(sel) {
+    // Draw overlay by querying selector
+    function makeSelectorOverlay(sel, badgeLabel) {
         const escaped = sel.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        const styleCss = getOverlayCss(style, duration, customColor);
+        const escapedBadge = badgeLabel ? badgeLabel.replace(/"/g, '&quot;') : '';
+        const badgeHtml = escapedBadge
+            ? `<span style="position:absolute;top:-20px;left:0;background:#09090b;border:1px solid #27272a;color:#f4f4f5;font-size:10px;font-family:-apple-system,BlinkMacSystemFont,\\'Segoe UI\\',sans-serif;font-weight:500;padding:1px 6px;border-radius:4px;white-space:nowrap;pointer-events:none;box-shadow:0 2px 6px rgba(0,0,0,0.5);">${escapedBadge}</span>`
+            : '';
         return `(function(){
       var el;
       try { el = document.querySelector('${escaped}'); } catch(e) {}
@@ -36,19 +100,26 @@ export async function browserHighlight(session, options, _config) {
       var r = el.getBoundingClientRect();
       if (r.width === 0 && r.height === 0) return false;
       var div = document.createElement('div');
-      div.style.cssText = 'position:fixed;left:'+r.left+'px;top:'+r.top+'px;width:'+r.width+'px;height:'+r.height+'px;z-index:2147483647;pointer-events:none;background:linear-gradient(120deg,transparent 30%,rgba(139,92,246,0.3) 50%,transparent 70%);background-size:200% 100%;animation:wt-shimmer 0.5s ease-out forwards;border:1.5px solid rgba(139,92,246,0.6);border-radius:3px;box-shadow:0 0 8px rgba(139,92,246,0.25);';
+      div.setAttribute('data-wt-ignore', 'true');
+      div.style.cssText = 'position:fixed;left:'+r.left+'px;top:'+r.top+'px;width:'+r.width+'px;height:'+r.height+'px;z-index:2147483647;pointer-events:none;${styleCss}';
+      if (${JSON.stringify(badgeHtml)}) {
+        div.innerHTML = ${JSON.stringify(badgeHtml)};
+      }
       (document.getElementById('Weavetab-root')?.shadowRoot || document.getElementById('Weavetab-root') || document.body).appendChild(div);
-      setTimeout(function(){ if(div.parentNode) div.parentNode.removeChild(div); }, 600);
+      setTimeout(function(){
+        div.style.transition = 'opacity 0.2s ease-out';
+        div.style.opacity = '0';
+        setTimeout(function(){ if(div.parentNode) div.parentNode.removeChild(div); }, 220);
+      }, ${duration});
       return true;
     })()`;
     }
-    async function trySelector(sel) {
-        const r = await session.Runtime.evaluate({ expression: makeSelectorShimmer(sel), returnByValue: true })
+    async function trySelector(sel, badgeLabel) {
+        const r = await session.Runtime.evaluate({ expression: makeSelectorOverlay(sel, badgeLabel), returnByValue: true })
             .catch(() => ({ result: { value: false } }));
         return !!r?.result?.value;
     }
-    // Use CDP DOM.getBoxModel to get coordinates for a backendNodeId — no DOM query needed
-    async function tryNodeHighlight(bnId) {
+    async function tryNodeHighlight(bnId, badgeLabel) {
         try {
             const { nodeIds } = await session.DOM.pushNodesByBackendIdsToFrontend({ backendNodeIds: [bnId] });
             if (!nodeIds?.[0])
@@ -60,81 +131,96 @@ export async function browserHighlight(session, options, _config) {
             const x = q[0], y = q[1], w = q[2] - q[0], h = q[5] - q[1];
             if (w <= 0 || h <= 0)
                 return false;
-            const r = await session.Runtime.evaluate({ expression: makeCoordShimmer(x, y, w, h), returnByValue: true });
+            const r = await session.Runtime.evaluate({ expression: makeCoordOverlay(x, y, w, h, badgeLabel), returnByValue: true });
             return !!r?.result?.value;
         }
         catch {
             return false;
         }
     }
-    // ── Resolve params ─────────────────────────────────────────────────────────
-    let resolvedSelector = selector;
-    let numericId = null;
-    if (!resolvedSelector) {
-        const refId = options.id || options.ref || options.target;
-        if (refId) {
-            const stripped = refId.replace(/^w:/, '');
+    async function highlightSingleTarget(targetIdentifier, badge) {
+        let sel = targetIdentifier;
+        let numericId = null;
+        if (targetIdentifier.startsWith("w:")) {
+            const stripped = targetIdentifier.slice(2);
             numericId = parseInt(stripped, 10);
-            resolvedSelector = `[data-wt-id="${stripped}"]`;
+            sel = `[data-wt-id="${stripped}"]`;
         }
-        else if (options.label) {
-            resolvedSelector = `[aria-label="${options.label.replace(/"/g, '\\"')}"]`;
-        }
-    }
-    // Strategy 1: CSS selector query
-    if (resolvedSelector && await trySelector(resolvedSelector)) {
-        return { success: true, message: `Highlighted ${resolvedSelector}` };
-    }
-    // Strategy 2: Extension oracle coords (__Weavetab_getCoords)
-    if (resolvedSelector) {
+        if (await trySelector(sel, badge))
+            return true;
+        // Extension oracle coords fallback
         const coordsRes = await session.Runtime.evaluate({
-            expression: `(window.__Weavetab_getCoords || window.__Weavetab_getCoords || function(){return null;})(${JSON.stringify(resolvedSelector)})`,
+            expression: `(window.__Weavetab_getCoords || function(){return null;})(${JSON.stringify(sel)})`,
             returnByValue: true,
         }).catch(() => null);
         const cv = coordsRes?.result?.value;
         if (cv?.raw) {
             const { left, top, w, h } = cv.raw;
-            const r = await session.Runtime.evaluate({ expression: makeCoordShimmer(left, top, w, h), returnByValue: true });
+            const r = await session.Runtime.evaluate({ expression: makeCoordOverlay(left, top, w, h, badge), returnByValue: true });
             if (r?.result?.value)
-                return { success: true, message: `Highlighted ${resolvedSelector} via coords` };
+                return true;
         }
-    }
-    // Strategy 3: CDP DOM by backendNodeId (for explicit nodeId param)
-    if (nodeId && await tryNodeHighlight(nodeId)) {
-        return { success: true, message: `Highlighted backendNodeId ${nodeId}` };
-    }
-    // Strategy 4: Walk action map cache to find the backendNodeId for a w:NN ref
-    if (numericId !== null) {
-        try {
-            const { getCachedActionMap } = await import('../state/cache.js');
-            const { sessionRegistry } = await import('../state/session.js');
-            const activeClient = sessionRegistry.getActive(getConfigAgentId(_config));
-            const targetId = activeClient?.targetId || 'default';
-            const cachedMap = activeClient?.url ? getCachedActionMap(targetId, activeClient.url) : null;
-            if (cachedMap?.elements) {
-                const el = cachedMap.elements.find(e => {
-                    const n = parseInt(String(e.id).replace(/^w:/, ''), 10);
-                    return n === numericId;
-                });
-                if (el?.selector && await trySelector(el.selector)) {
-                    return { success: true, message: `Highlighted w:${numericId} via cache selector` };
-                }
-                if (el?.backendNodeId && await tryNodeHighlight(el.backendNodeId)) {
-                    return { success: true, message: `Highlighted w:${numericId} via action map backendNodeId` };
-                }
-                // Strategy 5: coordinate fallback from cached element position
-                if (el?.x !== undefined && el?.y !== undefined) {
-                    const ew = el.width ?? 80, eh = el.height ?? 24;
-                    const r = await session.Runtime.evaluate({
-                        expression: makeCoordShimmer(el.x - ew / 2, el.y - eh / 2, ew, eh),
-                        returnByValue: true,
+        // Action map cache fallback
+        if (numericId !== null) {
+            try {
+                const { getCachedActionMap } = await import('../state/cache.js');
+                const { sessionRegistry } = await import('../state/session.js');
+                const activeClient = sessionRegistry.getActive(getConfigAgentId(_config));
+                const targetId = activeClient?.targetId || 'default';
+                const cachedMap = activeClient?.url ? getCachedActionMap(targetId, activeClient.url) : null;
+                if (cachedMap?.elements) {
+                    const el = cachedMap.elements.find(e => {
+                        const n = parseInt(String(e.id).replace(/^w:/, ''), 10);
+                        return n === numericId;
                     });
-                    if (r?.result?.value)
-                        return { success: true, message: `Highlighted w:${numericId} via cache coords` };
+                    if (el?.selector && await trySelector(el.selector, badge))
+                        return true;
+                    if (el?.backendNodeId && await tryNodeHighlight(el.backendNodeId, badge))
+                        return true;
+                    if (el?.x !== undefined && el?.y !== undefined) {
+                        const ew = el.width ?? 80, eh = el.height ?? 24;
+                        const r = await session.Runtime.evaluate({
+                            expression: makeCoordOverlay(el.x - ew / 2, el.y - eh / 2, ew, eh, badge),
+                            returnByValue: true,
+                        });
+                        if (r?.result?.value)
+                            return true;
+                    }
                 }
             }
+            catch { /* ignore */ }
+        }
+        return false;
+    }
+    // ── Multi-ref consideration overlay ───────────────────────────────────────
+    if (options.refs && Array.isArray(options.refs) && options.refs.length > 0) {
+        let successCount = 0;
+        for (let i = 0; i < options.refs.length; i++) {
+            const refItem = options.refs[i];
+            const itemBadge = customLabel ? (options.refs.length > 1 ? `${customLabel} [${i + 1}]` : customLabel) : refItem;
+            const ok = await highlightSingleTarget(refItem, itemBadge);
+            if (ok)
+                successCount++;
+        }
+        return {
+            success: successCount > 0,
+            message: `Highlighted ${successCount}/${options.refs.length} element(s) with style '${style}' (${duration}ms)`
+        };
+    }
+    // ── Single target resolution ──────────────────────────────────────────────
+    if (options.nodeId && await tryNodeHighlight(options.nodeId, customLabel)) {
+        return { success: true, message: `Highlighted backendNodeId ${options.nodeId} with style '${style}'` };
+    }
+    let singleRef = options.selector || options.id || options.ref || options.target;
+    if (!singleRef && options.label) {
+        singleRef = `[aria-label="${options.label.replace(/"/g, '\\"')}"]`;
+    }
+    if (singleRef) {
+        const badgeText = customLabel || (singleRef.startsWith("w:") ? singleRef : undefined);
+        const ok = await highlightSingleTarget(singleRef, badgeText);
+        if (ok) {
+            return { success: true, message: `Highlighted ${singleRef} with style '${style}' (${duration}ms)` };
         }
-        catch { /* no cache */ }
     }
     return { success: false, message: `Could not find element to highlight` };
 }

package/dist/tools/inspect.js

@@ -121,5 +121,5 @@ export async function browserInspect(session, options, _config) {
         computedStyles: computedStylesData,
         eventListeners: listeners
     };
-    return { success: true, data, message: "Inspected element successfully" };
+    return { success: true, data, message: "inspected element" };
 }

package/dist/tools/key.js

@@ -4,11 +4,8 @@
  * Weavetab by fy2ne
  */
 import { recordAction } from "../intelligence/trail.js";
-import { waitForDOMStable } from "../sensors/guard.js";
-import { waitForNetworkIdle } from "../sensors/wait.js";
 import { buildActionMap, toRefEntries } from "../cdp/walker.js";
-import { cacheActionMap, cacheBoxModel } from "../state/cache.js";
-import { computeDelta, storeSnapshot } from "../state/delta.js";
+import { computeDelta } from "../state/delta.js";
 import { sessionRegistry } from "../state/session.js";
 import { getConfigAgentId } from "../config/loader.js";
 import { sendToExtension } from "../cdp/helpers.js";
@@ -20,36 +17,74 @@ const ALLOWED_KEYS = new Set([
 ]);
 export async function weaveKey(session, args, _config) {
     const { key, modifiers } = args;
+    let effectiveKey = key.trim();
+    const effectiveModifiers = [...(modifiers || [])];
+    // Auto-parse combo strings e.g. "Ctrl+A", "Control+Shift+P", "Cmd+K", "Alt+ArrowDown"
+    if (effectiveKey.includes("+")) {
+        const parts = effectiveKey.split("+").map(p => p.trim());
+        effectiveKey = parts[parts.length - 1] || "Enter";
+        for (let i = 0; i < parts.length - 1; i++) {
+            const mod = parts[i].toLowerCase();
+            if ((mod === "ctrl" || mod === "control") && !effectiveModifiers.includes("Ctrl"))
+                effectiveModifiers.push("Ctrl");
+            else if (mod === "shift" && !effectiveModifiers.includes("Shift"))
+                effectiveModifiers.push("Shift");
+            else if ((mod === "alt" || mod === "option") && !effectiveModifiers.includes("Alt"))
+                effectiveModifiers.push("Alt");
+            else if ((mod === "meta" || mod === "cmd" || mod === "command" || mod === "win") && !effectiveModifiers.includes("Meta"))
+                effectiveModifiers.push("Meta");
+        }
+    }
+    // Capitalize common key names if needed (e.g. "enter" -> "Enter", "escape" -> "Escape", "tab" -> "Tab")
+    const keyMap = {
+        enter: "Enter",
+        escape: "Escape",
+        esc: "Escape",
+        tab: "Tab",
+        backspace: "Backspace",
+        delete: "Delete",
+        space: "Space",
+        arrowup: "ArrowUp",
+        arrowdown: "ArrowDown",
+        arrowleft: "ArrowLeft",
+        arrowright: "ArrowRight",
+        up: "ArrowUp",
+        down: "ArrowDown",
+        left: "ArrowLeft",
+        right: "ArrowRight",
+        home: "Home",
+        end: "End",
+        pageup: "PageUp",
+        pagedown: "PageDown",
+    };
+    if (keyMap[effectiveKey.toLowerCase()]) {
+        effectiveKey = keyMap[effectiveKey.toLowerCase()];
+    }
     // Allow single printable chars or control keys from the allowlist
-    if (key.length > 1 && !ALLOWED_KEYS.has(key)) {
+    if (effectiveKey.length > 1 && !ALLOWED_KEYS.has(effectiveKey)) {
         return {
             success: false,
             error_code: "INVALID_KEY",
-            message: `[!] Key "${key}" is not a valid control key. Use single characters or: ${[...ALLOWED_KEYS].join(", ")}`,
+            message: `[!] Key "${effectiveKey}" is not a valid control key. Use single characters or: ${[...ALLOWED_KEYS].join(", ")}`,
         };
     }
     let modMask = 0;
-    if (modifiers) {
-        if (modifiers.includes("Alt"))
-            modMask |= 1;
-        if (modifiers.includes("Ctrl"))
-            modMask |= 2;
-        if (modifiers.includes("Meta"))
-            modMask |= 4;
-        if (modifiers.includes("Shift"))
-            modMask |= 8;
-    }
-    const label = modifiers && modifiers.length > 0 ? `${modifiers.join("+")}+${key}` : key;
+    if (effectiveModifiers.includes("Alt"))
+        modMask |= 1;
+    if (effectiveModifiers.includes("Ctrl"))
+        modMask |= 2;
+    if (effectiveModifiers.includes("Meta"))
+        modMask |= 4;
+    if (effectiveModifiers.includes("Shift"))
+        modMask |= 8;
+    const label = effectiveModifiers.length > 0 ? `${effectiveModifiers.join("+")}+${effectiveKey}` : effectiveKey;
     await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: `pressing ${label}` } });
-    const { frameTree: beforeFrameTree } = await session.Page.getFrameTree();
+    const { frameTree: beforeFrameTree } = await session.Page.getFrameTree().catch(() => ({ frameTree: { frame: { url: '' } } }));
     const urlBefore = beforeFrameTree.frame.url;
-    // Track map before for delta if Enter is pressed
     let targetId = "default";
     const active = sessionRegistry.getActive(getConfigAgentId(_config));
     if (active)
         targetId = active.targetId;
-    const mapBefore = await buildActionMap(session, { lite: true }, targetId);
-    storeSnapshot(targetId, urlBefore, toRefEntries(mapBefore.elements));
     // We removed the direct toast injection here because the extension handles HUD display via Weavetab_STATE (line 66)
     await session.Input.dispatchKeyEvent({ type: "rawKeyDown", key, modifiers: modMask, windowsVirtualKeyCode: key === "Enter" ? 13 : undefined, nativeVirtualKeyCode: key === "Enter" ? 13 : undefined });
     if (key === "Enter") {
@@ -92,49 +127,23 @@ export async function weaveKey(session, args, _config) {
       })();
     ` }).catch(() => { });
     }
-    await session.Input.dispatchKeyEvent({ type: "keyUp", key, modifiers: modMask, windowsVirtualKeyCode: key === "Enter" ? 13 : undefined, nativeVirtualKeyCode: key === "Enter" ? 13 : undefined });
-    // ── Post-Action Pipeline & Predictive Action Queue ────────────────────────
-    const predictiveQueue = async () => {
-        try {
-            const nextMap = await buildActionMap(session, { lite: true }, targetId);
-            cacheActionMap(targetId, nextMap);
-            for (const el of nextMap.elements.slice(0, 10)) {
-                if (el.backendNodeId) {
-                    const { nodeIds } = await session.DOM.pushNodesByBackendIdsToFrontend({ backendNodeIds: [el.backendNodeId] }).catch(() => ({ nodeIds: [] }));
-                    if (nodeIds[0]) {
-                        const box = await session.DOM.getBoxModel({ nodeId: nodeIds[0] }).catch(() => null);
-                        if (box)
-                            cacheBoxModel(targetId, el.backendNodeId, box.model);
-                    }
-                }
-            }
-        }
-        catch { /* ignore pre-fetch errors */ }
-    };
-    const settleTimeout = key === "Enter" ? 5000 : 2500;
-    await Promise.all([
-        waitForDOMStable(session, 50, settleTimeout),
-        waitForNetworkIdle(session, 50, settleTimeout).catch(() => { }),
-        predictiveQueue()
-    ]);
+    await session.Input.dispatchKeyEvent({ type: "keyUp", key: effectiveKey, modifiers: modMask, windowsVirtualKeyCode: effectiveKey === "Enter" ? 13 : undefined, nativeVirtualKeyCode: effectiveKey === "Enter" ? 13 : undefined });
+    // Fast return for non-submission keys (Tab, Escape, Arrows, Shortcuts)
+    if (effectiveKey === "Enter") {
+        await new Promise(r => setTimeout(r, 60));
+    }
+    else {
+        await new Promise(r => setTimeout(r, 15));
+    }
     // Post-key location context
     let postUrl = "";
     let postTitle = "";
     try {
         const { frameTree } = await session.Page.getFrameTree();
         postUrl = frameTree.frame.url;
-        try {
-            const titleRes = await session.Runtime.evaluate({ expression: 'document.title', returnByValue: true });
-            postTitle = titleRes?.result?.value || postUrl;
-        }
-        catch {
-            postTitle = postUrl;
-        }
         const activeSession = sessionRegistry.getActive(getConfigAgentId(_config));
-        if (activeSession) {
+        if (activeSession)
             activeSession.url = postUrl;
-            activeSession.title = postTitle;
-        }
     }
     catch { /* ignore */ }
     const urlChanged = postUrl !== urlBefore;

package/dist/tools/navigate.d.ts

@@ -12,5 +12,5 @@ interface NavigateResult {
     title: string;
     tab_id: string;
 }
-export declare function weaveNavigate(session: CDP.Client, url: string, config: Config, targetId?: string, force?: boolean, fast?: boolean): Promise<NavigateResult | WeaveError>;
+export declare function weaveNavigate(session: CDP.Client, url: string, config: Config, targetId?: string, force?: boolean, fast?: boolean, appName?: string): Promise<NavigateResult | WeaveError>;
 export {};