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

package/dist/cdp/bridge.js

@@ -13,7 +13,7 @@ import { fileURLToPath } from "node:url";
 import CDP from "chrome-remote-interface";
 import { readLock, writeLock, clearLock, isLockValid, isLockPending } from "./lock.js";
 import { getSessionProfile } from "./profiles.js";
-import { getOutputDir, getDownloadDir, getConfigHeadless, getConfigProxy, getConfigDisableExtensions, getConfigDevMode, getConfigBlock, getConfigAllow, getConfigBrowserType, getConfigBrowserPath, getConfigBrowserFlags, getConfigCookies, getConfigProfileDir } from "../config/loader.js";
+import { getOutputDir, getDownloadDir, getConfigHeadless, getConfigProxy, getConfigDisableExtensions, getConfigDevMode, getConfigBlock, getConfigAllow, getConfigBrowserType, getConfigBrowserPath, getConfigBrowserFlags, getConfigCookies, getConfigProfileDir, getSystemDir } from "../config/loader.js";
 import { createBrowserFingerprint } from "./security.js";
 function withCDPTimeout(promise, ms, label) {
     return Promise.race([
@@ -524,10 +524,24 @@ export async function launchWithBridge(config) {
             await new Promise(r => setTimeout(r, 1500));
         }
         try {
-            const extPath = path.resolve(__dirname, "../../ext-dist");
-            // Verify extension directory exists
-            if (!fs.existsSync(extPath)) {
-                throw new Error(`[Weavetab] Extension directory does not exist: ${extPath}. Build the extension first.`);
+            let extPath = path.resolve(__dirname, "../../ext-dist");
+            const systemExtPath = getSystemDir("extension");
+            if (fs.existsSync(extPath)) {
+                try {
+                    fs.cpSync(extPath, systemExtPath, { recursive: true, force: true });
+                }
+                catch (e) {
+                    logDebug(`[Weavetab] Failed to sync extension to system directory: ${e}`);
+                }
+            }
+            else {
+                if (fs.existsSync(systemExtPath)) {
+                    logDebug(`[Weavetab] Local extension missing. Falling back to system extension directory.`);
+                    extPath = systemExtPath;
+                }
+                else {
+                    throw new Error(`[Weavetab] Extension directory does not exist: ${extPath}. Build the extension first.`);
+                }
             }
             const manifestPath = path.join(extPath, "manifest.json");
             const contentPath = path.join(extPath, "content.js");

package/dist/cdp/connector.js

@@ -150,9 +150,6 @@ async function initSession(session, targetId, port, config) {
                 if (clientRef)
                     clientRef.overlayInstalled = false;
                 await ensureVisualLayer(session, cfg, clientRef ?? undefined);
-                // Re-inject active plan into the new page
-                const { restoreActivePlanIntoPage } = await import("../tools/plan.js");
-                await restoreActivePlanIntoPage(session);
             }
             catch { /* ignore */ }
         }

package/dist/cdp/extension.js

@@ -55,7 +55,6 @@ export async function extensionHealth(session) {
         if (document.querySelector('weavetab-host') || document.getElementById('__Weavetab_cursor_host')) features.push('cursor');
         if (document.querySelector('[data-wt-internal]') || document.getElementById('wt-ui-styles')) features.push('styles');
         if (document.querySelector('.wt-bubble')) features.push('bubble');
-        if (document.getElementById('wt-plan-panel')) features.push('plan');
         return JSON.stringify({
           loaded: ${loaded},
           features

package/dist/cdp/helpers.js

@@ -164,7 +164,6 @@ export async function hideWeaveTabOverlay(session) {
       //  - [data-wt-ignore]     : any element flagged as agent-invisible
       //  - .wt-bubble           : thought bubble / action text popups
       //  - #__wt_ask_bridge     : question input bridge element
-      //  - #wt-plan-dashboard   : mission plan dashboard
       //  - #wt-debug-overlay    : debug overlay panel
       //  - #wt-main-container   : WeaveTab OS panel (todos + chat)
       style.textContent = [
@@ -175,7 +174,6 @@ export async function hideWeaveTabOverlay(session) {
         '[data-wt-ignore]',
         '.wt-bubble',
         '#__wt_ask_bridge',
-        '#wt-plan-dashboard',
         '#wt-debug-overlay',
         '#wt-main-container',
       ].join(', ') + ' { display: none !important; visibility: hidden !important; opacity: 0 !important; }';

package/dist/lifecycle/mission_manager.d.ts

@@ -9,7 +9,6 @@ export interface MissionState {
     agentId: string;
     status: "active" | "suspended" | "completed";
     timestamp: number;
-    plan: any;
     tabs: any[];
 }
 export declare function suspendMission(agentId: string, missionId: string): Promise<void>;

package/dist/lifecycle/mission_manager.js

@@ -4,7 +4,6 @@
  * Handles suspension, hibernation, and resumption of Weavetab missions.
  * Weavetab by fy2ne
  */
-import { getActivePlan } from "../tools/plan.js";
 import { getTabList } from "../cdp/connector.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -17,14 +16,12 @@ export async function suspendMission(agentId, missionId) {
     if (!fs.existsSync(stateDir)) {
         fs.mkdirSync(stateDir, { recursive: true });
     }
-    const plan = getActivePlan();
     const tabs = await getTabList(agentId).catch(() => []);
     const state = {
         missionId,
         agentId,
         status: "suspended",
         timestamp: Date.now(),
-        plan,
         tabs
     };
     fs.writeFileSync(getMissionPath(missionId), JSON.stringify(state, null, 2));

package/dist/overlay/ghost.d.ts

@@ -5,6 +5,10 @@ export interface CursorOptions {
     opacity?: number;
     speed?: "human" | "fast" | "instant";
 }
+export declare function ensureInitialCursorPosition(session: CDP.Client): Promise<{
+    x: number;
+    y: number;
+}>;
 export interface BurstProfile {
     groupSize: [number, number];
     interCharMin: number;

package/dist/overlay/ghost.js

@@ -22,42 +22,87 @@ function wtCursor(session, x, y, state, opts) {
     const trail = opts?.trail && opts.trail !== "off" ? getCursorTrail(opts.trail === "full" ? 20 : 8) : undefined;
     sendToExtension(session, { type: 'Weavetab_STATE', cursor: { x, y, trail }, state }).catch(() => { });
 }
+let _wanderActive = false;
+export async function ensureInitialCursorPosition(session) {
+    if (currentX >= 0 && currentY >= 0) {
+        return { x: currentX, y: currentY };
+    }
+    try {
+        const layout = await session.Page.getLayoutMetrics().catch(() => null);
+        if (layout?.visualViewport?.clientWidth && layout?.visualViewport?.clientHeight) {
+            currentX = Math.round(layout.visualViewport.clientWidth / 2);
+            currentY = Math.round(layout.visualViewport.clientHeight / 2);
+        }
+        else {
+            const evalRes = await session.Runtime.evaluate({
+                expression: `({ x: Math.round(window.innerWidth / 2), y: Math.round(window.innerHeight / 2) })`,
+                returnByValue: true
+            }).catch(() => null);
+            if (evalRes?.result?.value?.x && evalRes?.result?.value?.y) {
+                currentX = evalRes.result.value.x;
+                currentY = evalRes.result.value.y;
+            }
+            else {
+                currentX = 640;
+                currentY = 400;
+            }
+        }
+    }
+    catch {
+        currentX = 640;
+        currentY = 400;
+    }
+    wtCursor(session, currentX, currentY, "idle");
+    return { x: currentX, y: currentY };
+}
 async function wtThought(session, text) {
     await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: text } }).catch(() => { });
-    // Add realistic wandering movement connected to thoughts
-    if (currentX > 0 && currentY > 0 && Math.random() > 0.2) {
-        const wanderDistance = 15 + Math.random() * 35;
+    if (currentX < 0 || currentY < 0) {
+        await ensureInitialCursorPosition(session);
+    }
+    // Add realistic wandering movement connected to thoughts (non-racing)
+    if (currentX > 0 && currentY > 0 && !_wanderActive && Math.random() > 0.3) {
+        _wanderActive = true;
+        const startX = currentX;
+        const startY = currentY;
+        const wanderDistance = 10 + Math.random() * 25;
         const angle = Math.random() * Math.PI * 2;
-        const tx = Math.max(0, currentX + Math.cos(angle) * wanderDistance);
-        const ty = Math.max(0, currentY + Math.sin(angle) * wanderDistance);
-        const steps = 15;
+        const tx = Math.max(20, startX + Math.cos(angle) * wanderDistance);
+        const ty = Math.max(20, startY + Math.sin(angle) * wanderDistance);
+        const steps = 12;
         const waypoints = [];
-        const cp1X = currentX + (tx - currentX) * 0.3 + (Math.random() - 0.5) * 15;
-        const cp1Y = currentY + (ty - currentY) * 0.3 + (Math.random() - 0.5) * 15;
-        const cp2X = currentX + (tx - currentX) * 0.7 + (Math.random() - 0.5) * 15;
-        const cp2Y = currentY + (ty - currentY) * 0.7 + (Math.random() - 0.5) * 15;
+        const cp1X = startX + (tx - startX) * 0.3;
+        const cp1Y = startY + (ty - startY) * 0.3;
+        const cp2X = startX + (tx - startX) * 0.7;
+        const cp2Y = startY + (ty - startY) * 0.7;
         for (let i = 1; i <= steps; i++) {
             let t = i / steps;
             t = 1 - Math.pow(1 - t, 3);
             waypoints.push({
-                x: cubicBezier(t, currentX, cp1X, cp2X, tx),
-                y: cubicBezier(t, currentY, cp1Y, cp2Y, ty)
+                x: Math.round(cubicBezier(t, startX, cp1X, cp2X, tx)),
+                y: Math.round(cubicBezier(t, startY, cp1Y, cp2Y, ty))
             });
         }
         sendToExtension(session, {
             type: 'Weavetab_STATE',
-            cursor: { waypoints, duration_ms: steps * 20, x: currentX, y: currentY },
+            cursor: { waypoints, duration_ms: steps * 25, x: startX, y: startY },
             state: "thinking"
         }).catch(() => { });
-        // Async physical dispatch to not block the main logic flow
         (async () => {
-            for (let i = 1; i <= steps; i++) {
-                const x = waypoints[i - 1].x;
-                const y = waypoints[i - 1].y;
-                await session.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" }).catch(() => { });
-                currentX = x;
-                currentY = y;
-                await new Promise(r => setTimeout(r, 20));
+            try {
+                for (let i = 1; i <= steps; i++) {
+                    if (!_wanderActive)
+                        break;
+                    const x = waypoints[i - 1].x;
+                    const y = waypoints[i - 1].y;
+                    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" }).catch(() => { });
+                    currentX = x;
+                    currentY = y;
+                    await new Promise(r => setTimeout(r, 25));
+                }
+            }
+            finally {
+                _wanderActive = false;
             }
         })();
     }
@@ -139,6 +184,9 @@ targetSelector, profileName) {
     let wordsSinceBreak = 0;
     let wordCharCount = 0;
     let prevChar = '';
+    if (currentX < 0 || currentY < 0) {
+        await ensureInitialCursorPosition(session);
+    }
     wtCursor(session, currentX, currentY, "typing");
     let currentGroupSize = Math.floor(Math.random() * (p.groupSize[1] - p.groupSize[0] + 1)) + p.groupSize[0];
     let charsTypedInGroup = 0;
@@ -271,6 +319,10 @@ function cubicBezier(t, p0, p1, p2, p3) {
 }
 let _firstMoveDone = false;
 export async function ghostMove(session, targetX, targetY, config, label, profile, cursorOpts) {
+    _wanderActive = false; // Stop any ongoing thought wander immediately
+    if (currentX < 0 || currentY < 0) {
+        await ensureInitialCursorPosition(session);
+    }
     const resolvedProfile = profile || (getConfigHeadless(config) ? "instant" : "human");
     if (resolvedProfile === "instant") {
         await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
@@ -290,9 +342,9 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
         return;
     }
     if (resolvedProfile === "fast") {
-        const steps = 4;
-        const startX = currentX === -1 ? targetX : currentX;
-        const startY = currentY === -1 ? targetY : currentY;
+        const steps = 6;
+        const startX = currentX;
+        const startY = currentY;
         for (let i = 1; i <= steps; i++) {
             const t = i / steps;
             const x = Math.round(startX + (targetX - startX) * t);
@@ -301,7 +353,7 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
             currentX = x;
             currentY = y;
             wtCursor(session, x, y, "moving", cursorOpts);
-            await sleep(5);
+            await sleep(6);
         }
         currentX = targetX;
         currentY = targetY;
@@ -311,93 +363,61 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
         return;
     }
     if (!_firstMoveDone) {
-        logDebug(`[Weavetab Ghost] First mouse move → (${targetX}, ${targetY}) — CDP session active`);
+        logDebug(`[Weavetab Ghost] First mouse move from (${currentX}, ${currentY}) → (${targetX}, ${targetY}) — CDP session active`);
         _firstMoveDone = true;
     }
-    // Don't fake-init cursor position — injector.ts hides cursor until first real move
-    if (currentX === -1 && currentY === -1) {
-        currentX = targetX;
-        currentY = targetY;
-        wtCursor(session, targetX, targetY, "hover", cursorOpts);
-        recordCursorPosition(targetX, targetY);
-        await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
-        await session.Runtime.evaluate({
-            expression: `(function(){
-        var el = document.elementFromPoint(${targetX}, ${targetY});
-        if (el) {
-          el.dispatchEvent(new MouseEvent('mouseover', {bubbles:true,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-          el.dispatchEvent(new MouseEvent('mouseenter', {bubbles:false,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-        }
-      })()`
-        }).catch(() => { });
-        return;
-    }
     const dx = targetX - currentX;
     const dy = targetY - currentY;
     const distance = Math.sqrt(dx * dx + dy * dy);
-    wtCursor(session, currentX, currentY, label && distance >= 150 ? "searching" : "idle", cursorOpts);
-    if (label && distance >= 150 && getConfigVisuals(config) !== false) {
-        wtThought(session, `moving to ${label.slice(0, 40)}...`);
-        await sleep(80 + Math.random() * 120);
-    }
-    if (distance < 150) {
+    if (distance < 4) {
         currentX = targetX;
         currentY = targetY;
         await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
         wtCursor(session, targetX, targetY, "hover", cursorOpts);
         recordCursorPosition(targetX, targetY);
-        await session.Runtime.evaluate({
-            expression: `(function(){
-        var el = document.elementFromPoint(${targetX}, ${targetY});
-        if (el) {
-          el.dispatchEvent(new MouseEvent('mouseover', {bubbles:true,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-          el.dispatchEvent(new MouseEvent('mouseenter', {bubbles:false,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-        }
-      })()`
-        }).catch(() => { });
         return;
     }
-    const duration = Math.max(80, Math.min(300, distance * 0.6));
-    let steps = Math.floor(duration / 16);
-    if (steps > 10)
-        steps = 10;
-    if (steps < 3)
-        steps = 3;
-    const cp1X = currentX + dx * 0.2 + randomGaussian(0, distance * 0.2);
-    const cp1Y = currentY + dy * 0.2 + randomGaussian(0, distance * 0.2);
-    const cp2X = currentX + dx * 0.8 + randomGaussian(0, distance * 0.2);
-    const cp2Y = currentY + dy * 0.8 + randomGaussian(0, distance * 0.2);
-    const doOvershoot = distance >= 300 && Math.random() > 0.3;
-    const overshootAmount = doOvershoot ? randomGaussian(10, 5) : 0;
-    const angle = Math.atan2(dy, dx);
-    const overshootX = targetX + Math.cos(angle) * overshootAmount;
-    const overshootY = targetY + Math.sin(angle) * overshootAmount;
-    wtCursor(session, targetX, targetY, "idle", cursorOpts);
+    wtCursor(session, currentX, currentY, label && distance >= 150 ? "searching" : "idle", cursorOpts);
+    if (label && distance >= 150 && getConfigVisuals(config) !== false) {
+        wtThought(session, `moving to ${label.slice(0, 40)}...`);
+        await sleep(60 + Math.random() * 80);
+    }
+    // Smooth, natural human hand curve
+    const duration = Math.max(120, Math.min(380, 80 + Math.sqrt(distance) * 12));
+    const steps = Math.max(8, Math.min(24, Math.floor(duration / 16)));
+    const stepDelay = Math.max(10, Math.floor(duration / steps));
+    // Gentle perpendicular curvature (arcing motion)
+    const nx = -dy / distance;
+    const ny = dx / distance;
+    const maxArc = Math.min(45, distance * 0.15);
+    const arcSign = (Math.random() > 0.5 ? 1 : -1);
+    const arcAmount = maxArc * arcSign * (0.4 + Math.random() * 0.6);
+    const cp1X = currentX + dx * 0.3 + nx * arcAmount;
+    const cp1Y = currentY + dy * 0.3 + ny * arcAmount;
+    const cp2X = currentX + dx * 0.7 + nx * (arcAmount * 0.6);
+    const cp2Y = currentY + dy * 0.7 + ny * (arcAmount * 0.6);
     const waypoints = [];
     for (let i = 1; i <= steps; i++) {
-        let t = i / steps;
-        t = 1 - Math.pow(1 - t, 4);
-        const actualTargetX = doOvershoot && i < steps * 0.8 ? overshootX : targetX;
-        const actualTargetY = doOvershoot && i < steps * 0.8 ? overshootY : targetY;
+        const rawT = i / steps;
+        // Cubic ease-out for natural deceleration
+        const t = 1 - Math.pow(1 - rawT, 3);
         waypoints.push({
-            x: cubicBezier(t, currentX, cp1X, cp2X, actualTargetX),
-            y: cubicBezier(t, currentY, cp1Y, cp2Y, actualTargetY)
+            x: Math.round(cubicBezier(t, currentX, cp1X, cp2X, targetX)),
+            y: Math.round(cubicBezier(t, currentY, cp1Y, cp2Y, targetY))
         });
     }
-    // Pre-announce the move
+    // Pre-announce waypoints for smooth client-side interpolation
     sendToExtension(session, {
         type: 'Weavetab_STATE',
-        cursor: { waypoints, duration_ms: steps * 8, x: currentX, y: currentY },
+        cursor: { waypoints, duration_ms: steps * stepDelay, x: currentX, y: currentY },
         state: "moving"
     }).catch(() => { });
     for (let i = 1; i <= steps; i++) {
-        const x = waypoints[i - 1].x;
-        const y = waypoints[i - 1].y;
-        await session.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" });
-        currentX = x;
-        currentY = y;
-        wtCursor(session, x, y, "moving", cursorOpts);
-        await sleep(8);
+        const pt = waypoints[i - 1];
+        await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: pt.x, y: pt.y, button: "none" }).catch(() => { });
+        currentX = pt.x;
+        currentY = pt.y;
+        await sleep(stepDelay);
     }
     currentX = targetX;
     currentY = targetY;
@@ -405,7 +425,7 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
     recordCursorPosition(targetX, targetY);
     if (label)
         wtClearThought(session);
-    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
+    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" }).catch(() => { });
     await session.Runtime.evaluate({
         expression: `(function(){
       var el = document.elementFromPoint(${targetX}, ${targetY});
@@ -501,8 +521,12 @@ export async function ghostClick(session, x, y, options) {
     }).catch(() => { });
 }
 export function ghostWait(session) {
-    wtCursor(session, currentX, currentY, "waiting");
+    const x = currentX >= 0 ? currentX : 640;
+    const y = currentY >= 0 ? currentY : 400;
+    wtCursor(session, x, y, "waiting");
 }
 export function ghostIdle(session) {
-    wtCursor(session, currentX, currentY, "idle");
+    const x = currentX >= 0 ? currentX : 640;
+    const y = currentY >= 0 ? currentY : 400;
+    wtCursor(session, x, y, "idle");
 }

package/dist/overlay/injector.d.ts

@@ -2,7 +2,7 @@
  * src/overlay/injector.ts
  * Weavetab — Browser Presence Layer v3 (stripped)
  *
- * Kept:     __wt_plan (mission dashboard), SPA nav detection,
+ * Kept:     SPA nav detection,
  *           __wt_setConfig, __wt_status, favicon state.
  * Removed:  cursor (moved to content.js), chat panel, thought bubble,
  *           ask modal, screen glow, CSS keyframes, emoji system.

package/dist/overlay/injector.js

@@ -52,23 +52,11 @@ export function getMinimalOverlayScript() {
       document.addEventListener('NavigationEnd', function() { em('angular', location.href); });
     }
 
-    // ── Mission plan dashboard ──────────────────────────────────────────────
-    window.__wt_plan_comments = window.__wt_plan_comments || [];
-    window.__wt_plan = function(action, goal, tasks) {
-      window.postMessage({ type: '__WT_PLAN', action: action, goal: goal, tasks: tasks }, '*');
-    };
-
     // The message listeners below are guarded so they are registered exactly once
     // per page, even when __wt_install_minimal() is called repeatedly (e.g. SPAs
     // with frequent navigations).
     if (!window.__wt_msg_installed) {
       window.__wt_msg_installed = true;
-      window.addEventListener("message", function(e) {
-        if (e.data && e.data.type === "__WT_PLAN_COMMENT") {
-          window.__wt_plan_comments.push({ taskId: Number(e.data.taskId), comment: e.data.comment, time: Date.now() });
-        }
-      });
-
       window.__wt_chat_queue = window.__wt_chat_queue || [];
       window.addEventListener("message", function(e) {
         if (e.data && e.data.type === "__WT_FEEDBACK") {

package/dist/server.js

@@ -11,7 +11,6 @@ import { checkRateLimit } from "./security/ratelimit.js";
 import { checkDomain, isToolAllowedInMode } from "./security/blacklist.js";
 import { logAction, logActionStructured } from "./audit/logger.js";
 import { recordToolUsage, broadcastTelemetry } from "./audit/telemetry.js";
-import { clearLock } from "./cdp/lock.js";
 import { browserMap } from "./tools/read.js";
 import { weaveNavigate } from "./tools/navigate.js";
 import { weaveClick } from "./tools/click.js";
@@ -25,7 +24,6 @@ import { browserWait } from "./tools/wait.js";
 import { browserPointer } from "./tools/pointer.js";
 import { browserSelect } from "./tools/select.js";
 import { browserFill } from "./tools/fill.js";
-import { weavePlan } from "./tools/plan.js";
 import { browserHighlight } from "./tools/highlight.js";
 import { browserUpload } from "./tools/upload.js";
 import { browserFind } from "./tools/find.js";
@@ -794,28 +792,6 @@ export async function startServer(config, transportMode = "stdio", wsPort = 3000
             return wrapError(e);
         }
     });
-    // ── 15. browser_plan ───────────────────────────────────────────────────────
-    server.tool("browser_plan", "Create a live task panel in the browser.", {
-        action: z.enum(["create", "update", "comments", "hide"]).describe("Action to perform."),
-        goal: z.string().optional().describe("Mission goal description (required for create)."),
-        tasks: z.array(z.object({
-            id: z.number(),
-            description: z.string(),
-            status: z.enum(["pending", "in-progress", "done", "failed"]),
-        })).optional().describe("Task list with statuses (required for create)."),
-        taskId: z.number().optional().describe("Task ID to update (required for update)."),
-        status: z.enum(["pending", "in-progress", "done", "failed"]).optional().describe("New status (required for update)."),
-    }, async (args) => {
-        try {
-            return await withSecurity(config, "browser_plan", async (session, liveConfig) => {
-                const result = await weavePlan(session, args, liveConfig);
-                return { content: [{ type: "text", text: JSON.stringify(result) }] };
-            });
-        }
-        catch (e) {
-            return wrapError(e);
-        }
-    });
     // ── 18. browser_highlight ───────────────────────────────────────────────────
     server.tool("browser_highlight", "Highlight an element with a colored overlay.", {
         selector: z.string().optional().describe("CSS Selector of the element to highlight."),
@@ -1678,10 +1654,8 @@ process.on("SIGTERM", async () => {
     process.exit(0);
 });
 process.on("exit", () => {
-    if (global.__wt_is_server)
-        return;
-    try {
-        clearLock();
-    }
-    catch { /* ignore */ }
+    // We purposefully do NOT clear the lock file here.
+    // Weavetab launches the browser detached, so it survives the server dying.
+    // Leaving the lock file allows the next MCP server run to find and reuse
+    // the existing browser instead of launching a duplicate.
 });

package/dist/tools/browser_detect.js

@@ -9,7 +9,6 @@ const ENGINE_COVERAGE = {
             "browser_network_intercept",
             "browser_viewport",
             "browser_recording",
-            "browser_plan",
             "browser_thought",
             "browser_highlight",
             "browser_inspect",
@@ -24,7 +23,6 @@ const ENGINE_COVERAGE = {
             "browser_network_intercept",
             "browser_viewport",
             "browser_recording",
-            "browser_plan",
             "browser_thought",
             "browser_highlight",
             "browser_inspect",

package/dist/tools/read.js

@@ -484,5 +484,5 @@ export async function browserMap(session, options = {}, targetId = "default", co
     sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } }).catch(() => { });
     return output;
 }
-// Keep backward-compat alias used by plan.ts
+// Backward-compat alias
 export { browserMap as weaveRead };

package/ext-dist/content.js

@@ -164,7 +164,9 @@ function __wt_safeAppendToBody(el) {
     }
     if (typeof __weaveCursor !== 'undefined' && __weaveCursor) {
       __weaveCursor.setVisible(__wt_masterVisualsEnabled);
-      if (__weaveCursor._canvas) {
+      if (__weaveCursor._cursor) {
+        __weaveCursor._cursor.style.display = __wt_masterVisualsEnabled ? 'block' : 'none';
+      } else if (__weaveCursor._canvas) {
         __weaveCursor._canvas.style.display = __wt_masterVisualsEnabled ? 'block' : 'none';
       }
     }
@@ -213,8 +215,13 @@ function __wt_safeAppendToBody(el) {
     if (msg.type === 'WT_TOGGLE_MASTER_VISUALS') {
       __wt_applyMasterVisuals(msg.enabled);
     }
-    if (msg.type === 'GHOST_CURSOR_MOVE' && iframe && iframe.contentWindow) {
-      iframe.contentWindow.postMessage({ type: 'RT_CURSOR_MOVE', x: msg.x, y: msg.y, phase: msg.phase }, '*');
+    if (msg.type === 'GHOST_CURSOR_MOVE') {
+      if (typeof msg.x === 'number' && typeof msg.y === 'number') {
+        moveCursor(msg.x, msg.y, msg.phase);
+      }
+      if (iframe && iframe.contentWindow) {
+        iframe.contentWindow.postMessage({ type: 'RT_CURSOR_MOVE', x: msg.x, y: msg.y, phase: msg.phase }, '*');
+      }
     }
     if (msg.type === 'TOOL_CALL_EVENT' && iframe && iframe.contentWindow) {
       iframe.contentWindow.postMessage({ type: 'TOOL_CALL_EVENT', payload: msg.payload }, '*');
@@ -932,71 +939,88 @@ window.__Weavetab_readConsole = function({ since = 'last', level = null } = {})
   return level ? entries.filter(e => e.level === level) : entries;
 };
 
-// ── PREMIUM WEAVE CURSOR (Phase 5.1 / 5.3) ─────────────────────
-// Shadow-DOM-isolated, canvas-based, with cognitive-load speed scaling
-// and state-driven visual transitions: idle, moving, reading, typing, clicking, thinking
+// ── BLUE SVG WEAVE CURSOR ───────────────────────────────────────
+// Shadow-DOM-isolated, hardware-accelerated SVG cursor with smooth interpolation
 class WeaveCursor {
   constructor() {
     // Attach a shadow host that sits above all page content
     this._host = document.createElement('div');
     this._host.id = '__Weavetab_cursor_host';
+    this._host.setAttribute('data-wt-ignore', 'true');
     Object.assign(this._host.style, {
       position: 'fixed',
       top: '0',
       left: '0',
       width: '0',
       height: '0',
-      zIndex: '2147483640',
+      zIndex: '2147483647',
       pointerEvents: 'none',
       overflow: 'visible',
     });
 
     const shadow = this._host.attachShadow({ mode: 'closed' });
 
-    // Canvas layer
-    this._canvas = document.createElement('canvas');
-    this._canvas.width = 64;
-    this._canvas.height = 64;
-    Object.assign(this._canvas.style, {
+    // Hotspot aligned with the top-left pointer tip (3.0, 5.0 in 32x32 viewBox)
+    this._hotX = 3.0;
+    this._hotY = 5.0;
+    this._scale = 0.4;
+
+    const initX = typeof window !== 'undefined' && window.innerWidth ? Math.round(window.innerWidth / 2) : 640;
+    const initY = typeof window !== 'undefined' && window.innerHeight ? Math.round(window.innerHeight / 2) : 400;
+
+    // Exact vector SVG cursor matching user design
+    this._cursor = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    this._cursor.setAttribute('class', 'cursor');
+    this._cursor.setAttribute('viewBox', '0 0 32 32');
+    this._cursor.setAttribute('width', '32');
+    this._cursor.setAttribute('height', '32');
+    this._cursor.setAttribute('aria-hidden', 'true');
+    Object.assign(this._cursor.style, {
       position: 'fixed',
       top: '0',
       left: '0',
-      width: '64px',
-      height: '64px',
+      width: '32px',
+      height: '32px',
+      display: 'block',
+      transformOrigin: `${this._hotX}px ${this._hotY}px`,
+      transform: `translate3d(${initX - this._hotX}px, ${initY - this._hotY}px, 0) scale(${this._scale})`,
+      overflow: 'visible',
       pointerEvents: 'none',
-      transform: 'translate(-9999px,-9999px)',
       willChange: 'transform',
-      transition: 'opacity 0.15s ease-out',
+      transition: 'opacity 0.2s ease-out',
+      opacity: '1',
+      zIndex: '2147483647',
+      filter: 'drop-shadow(0 2px 4px rgba(0,0,0,0.35))',
     });
-    shadow.appendChild(this._canvas);
-
-    this._ctx = this._canvas.getContext('2d');
-    this._x = -9999;
-    this._y = -9999;
-    this._targetX = -9999;
-    this._targetY = -9999;
-    this._lerpX = -9999;
-    this._lerpY = -9999;
+
+    const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+    path.setAttribute('class', 'cursor-shape');
+    path.setAttribute('d', 'M 6.1,4.7 C 4.5,4.1 3.0,5.0 3.0,6.7 C 3.0,7.1 3.1,7.5 3.3,8.0 L 10.2,27.0 C 10.8,28.7 12.0,29.6 13.6,29.5 C 15.1,29.4 16.0,28.5 16.5,27.0 L 19.4,18.8 L 25.9,17.0 C 27.7,16.5 28.9,15.2 28.9,13.6 C 28.9,12.1 28.0,10.9 26.4,10.3 Z');
+    path.setAttribute('fill', '#1268ff');
+    path.setAttribute('stroke', '#ffffff');
+    path.setAttribute('stroke-width', '3.1');
+    path.setAttribute('stroke-linejoin', 'round');
+    path.setAttribute('stroke-linecap', 'round');
+
+    this._cursor.appendChild(path);
+    shadow.appendChild(this._cursor);
+
+    // Alias _canvas to _cursor for backward compatibility
+    this._canvas = this._cursor;
+
+    this._x = initX;
+    this._y = initY;
+    this._targetX = initX;
+    this._targetY = initY;
+    this._lerpX = initX;
+    this._lerpY = initY;
     this._state = 'idle';
-    this._visible = false;
+    this._visible = true;
     this._animFrame = null;
-    this._lastMoveTime = 0;
     this._lastTime = performance.now();
     this._waypointQueue = [];
     this._playingQueue = false;
 
-    this._hotX = 0;
-    this._hotY = 0;
-
-    // Sharp precision arrow pointer path (tip at 0,0)
-    this._outerPath = new Path2D("M 0 0 L 0 16 L 4.2 12.2 L 7.5 19 L 10.2 17.6 L 6.8 10.8 L 11.8 10.8 Z");
-    this._innerPath = new Path2D("M 1.2 2.5 L 1.2 13.5 L 3.8 10.8 L 6.6 16.5 L 8.2 15.6 L 5.4 9.8 L 9.8 9.8 Z");
-
-    // Vivid linear gradient (#06B6D4 -> #3B82F6)
-    this._blueGrad = this._ctx.createLinearGradient(0, 0, 12, 19);
-    this._blueGrad.addColorStop(0, '#06B6D4');
-    this._blueGrad.addColorStop(1, '#3B82F6');
-
     __wt_safeAppendToBody(this._host);
     this._startLoop();
   }
@@ -1018,23 +1042,25 @@ class WeaveCursor {
   setVisible(visible) {
     if (typeof __wt_masterVisualsEnabled !== 'undefined' && !__wt_masterVisualsEnabled) {
       this._visible = false;
-      this._canvas.style.opacity = '0';
+      this._cursor.style.opacity = '0';
       return;
     }
     this._visible = visible;
-    this._canvas.style.opacity = visible ? '1' : '0';
+    this._cursor.style.opacity = visible ? '1' : '0';
   }
 
   moveTo(x, y) {
     if (typeof __wt_masterVisualsEnabled !== 'undefined' && !__wt_masterVisualsEnabled) return;
-    if (this._playingQueue) return;
+    if (typeof x !== 'number' || typeof y !== 'number' || isNaN(x) || isNaN(y)) return;
     this._targetX = x;
     this._targetY = y;
-    if (this._lerpX === -9999) { this._lerpX = x; this._lerpY = y; }
-    this._lastMoveTime = Date.now();
+    if (this._lerpX === -9999) {
+      this._lerpX = x;
+      this._lerpY = y;
+    }
     if (!this._visible) {
       this._visible = true;
-      this._canvas.style.opacity = '1';
+      this._cursor.style.opacity = '1';
     }
     if (!this._animFrame) {
       this._startLoop();
@@ -1043,20 +1069,23 @@ class WeaveCursor {
 
   setWaypoints(waypoints, durationMs) {
     if (typeof __wt_masterVisualsEnabled !== 'undefined' && !__wt_masterVisualsEnabled) return;
+    if (!waypoints || !waypoints.length) return;
     this._waypointQueue = waypoints;
     this._playingQueue = true;
     this._waypointStartTime = performance.now();
-    this._waypointDuration = durationMs;
+    this._waypointDuration = durationMs || (waypoints.length * 16);
     if (waypoints.length > 0 && this._lerpX === -9999) {
       this._lerpX = waypoints[0].x;
       this._lerpY = waypoints[0].y;
     }
-    if (!this._visible) { this._visible = true; this._canvas.style.opacity = '1'; }
+    if (!this._visible) {
+      this._visible = true;
+      this._cursor.style.opacity = '1';
+    }
     if (!this._animFrame) this._startLoop();
   }
 
   _startLoop() {
-    this._idleFrames = 0;
     this._lastTime = performance.now();
     const draw = (currentTime) => {
       const dt = Math.min((currentTime - this._lastTime) / 1000, 0.1);
@@ -1064,89 +1093,86 @@ class WeaveCursor {
 
       if (this._playingQueue && this._waypointQueue.length > 0) {
         const elapsed = currentTime - this._waypointStartTime;
-        const progress = Math.min(elapsed / this._waypointDuration, 1);
-        const idx = Math.min(Math.floor(progress * this._waypointQueue.length), this._waypointQueue.length - 1);
-        const pt = this._waypointQueue[idx];
-        if (pt) {
-          this._targetX = pt.x;
-          this._targetY = pt.y;
-          this._lastMoveTime = Date.now();
+        const progress = Math.max(0, Math.min(elapsed / (this._waypointDuration || 1), 1));
+        const totalSegments = this._waypointQueue.length - 1;
+
+        if (totalSegments <= 0) {
+          this._targetX = this._waypointQueue[0].x;
+          this._targetY = this._waypointQueue[0].y;
+        } else {
+          const floatIdx = progress * totalSegments;
+          const i0 = Math.floor(floatIdx);
+          const i1 = Math.min(i0 + 1, totalSegments);
+          const t = floatIdx - i0;
+
+          const p0 = this._waypointQueue[i0];
+          const p1 = this._waypointQueue[i1];
+          if (p0 && p1) {
+            this._targetX = p0.x + (p1.x - p0.x) * t;
+            this._targetY = p0.y + (p1.y - p0.y) * t;
+          }
         }
+
         if (progress >= 1) {
           this._playingQueue = false;
           this._waypointQueue = [];
         }
       }
 
-      // Smooth lerp (k = 14)
-      const lerpFactor = 1 - Math.exp(-14 * dt);
+      // Smooth exponential lerp (k = 24 for fluid human-smooth tracking)
+      const lerpFactor = 1 - Math.exp(-24 * dt);
       if (this._targetX !== -9999) {
         this._lerpX += (this._targetX - this._lerpX) * lerpFactor;
         this._lerpY += (this._targetY - this._lerpY) * lerpFactor;
-        if (Math.abs(this._targetX - this._lerpX) < 0.3) this._lerpX = this._targetX;
-        if (Math.abs(this._targetY - this._lerpY) < 0.3) this._lerpY = this._targetY;
-      }
-
-      const hasRecentMove = (Date.now() - this._lastMoveTime) < 1200;
-      if (hasRecentMove && (typeof __wt_masterVisualsEnabled === 'undefined' || __wt_masterVisualsEnabled)) {
-        if (!this._visible) {
-          this._visible = true;
-          this._canvas.style.opacity = '1';
-        }
-        this._idleFrames = 0;
-      } else {
-        this._idleFrames++;
-        if (this._idleFrames > 90 || !__wt_masterVisualsEnabled) {
+        if (Math.abs(this._targetX - this._lerpX) < 0.1) this._lerpX = this._targetX;
+        if (Math.abs(this._targetY - this._lerpY) < 0.1) this._lerpY = this._targetY;
+
+        // "always show in browser" - stays visible once loaded and active
+        if (typeof __wt_masterVisualsEnabled === 'undefined' || __wt_masterVisualsEnabled) {
+          if (!this._visible) {
+            this._visible = true;
+            this._cursor.style.opacity = '1';
+          }
+        } else {
           if (this._visible) {
             this._visible = false;
-            this._canvas.style.opacity = '0';
+            this._cursor.style.opacity = '0';
           }
         }
+
+        this._render();
       }
 
-      this._render();
       this._animFrame = requestAnimationFrame(draw);
     };
+    if (this._animFrame) cancelAnimationFrame(this._animFrame);
     this._animFrame = requestAnimationFrame(draw);
   }
 
   _render() {
     if (typeof __wt_masterVisualsEnabled !== 'undefined' && !__wt_masterVisualsEnabled) {
-      this._canvas.style.opacity = '0';
+      this._cursor.style.opacity = '0';
       return;
     }
-
-    const { _ctx: ctx, _lerpX: x, _lerpY: y } = this;
-
-    this._canvas.style.transform = `translate(${x - this._hotX}px, ${y - this._hotY}px)`;
-    ctx.clearRect(0, 0, 64, 64);
-
-    ctx.save();
-    ctx.translate(2, 2);
-
-    // Sharp outer stroke — White
-    ctx.fillStyle = '#FFFFFF';
-    ctx.strokeStyle = '#FFFFFF';
-    ctx.lineWidth = 2;
-    ctx.lineJoin = 'miter';
-    ctx.miterLimit = 3;
-    ctx.fill(this._outerPath);
-    ctx.stroke(this._outerPath);
-
-    // Sharp inner core — Gradient
-    ctx.fillStyle = this._blueGrad;
-    ctx.fill(this._innerPath);
-
-    ctx.restore();
+    const x = this._lerpX;
+    const y = this._lerpY;
+    if (x === -9999 || y === -9999) return;
+    this._cursor.style.transform = `translate3d(${x - this._hotX}px, ${y - this._hotY}px, 0) scale(${this._scale})`;
   }
 }
 
-// Instantiate the premium cursor
-let __weaveCursor = { setState: function(){}, moveTo: function(){}, destroy: function(){}, setVisible: function(){}, setWaypoints: function(){} };
+// Instantiate the active cursor
+let __weaveCursor = new WeaveCursor();
 window.__weaveCursor_instance = __weaveCursor;
 
 function moveCursor(x, y, state) {
-  // Cursor visuals disabled
+  if (typeof __wt_masterVisualsEnabled !== 'undefined' && !__wt_masterVisualsEnabled) return;
+  if (__weaveCursor && typeof __weaveCursor.moveTo === 'function') {
+    if (typeof x === 'number' && typeof y === 'number' && x >= 0 && y >= 0) {
+      __weaveCursor.moveTo(x, y);
+    }
+    if (state) __weaveCursor.setState(state);
+  }
 }
 
 

package/mcp.json

@@ -1,7 +1,7 @@
 {
   "name": "@weavetab/mcp",
   "mcpName": "io.github.weavetab/mcp",
-  "version": "2.5.0-beta.0",
+  "version": "2.5.0-beta.1",
   "description": "Weavetab MCP — Production-grade browser automation MCP server with direct Chrome DevTools Protocol (CDP) control. Direct socket transport, zero WebDriver/Node.js wrapper overhead, deterministic state execution.",
   "icon": "icon.png",
   "author": "fy2ne",
@@ -185,15 +185,6 @@
           "Optional form submission click step"
         ]
       },
-      "browser_plan": {
-        "category": "mission_execution",
-        "description": "Create or update a live task panel in the browser. Renders a real-time task dashboard within a Shadow DOM overlay displaying goal progress and step status.",
-        "features": [
-          "Real-time task state and progress display",
-          "Isolated Shadow DOM layout structure",
-          "Structured task state tracking (pending, in-progress, done, failed)"
-        ]
-      },
       "browser_highlight": {
         "category": "canvas_and_visual",
         "description": "Highlight an element with a colored overlay. Renders temporary visual CDP overlay highlights over target elements without DOM tree mutations.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weavetab/mcp",
-  "version": "2.5.0-beta.0",
+  "version": "2.5.0-beta.1",
   "description": "A production-grade local MCP server for AI browser automation via Chrome DevTools Protocol. No extensions. No cloud. Full control.",
   "author": "fy2ne",
   "license": "AGPL-3.0-only",

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/weavetab/mcp",
     "source": "github"
   },
-  "version": "2.5.0-beta.0",
+  "version": "2.5.0-beta.1",
   "packages": [
     {
       "registryType": "npm",

package/dist/tools/plan.d.ts

@@ -1,39 +0,0 @@
-import CDP from "chrome-remote-interface";
-import type { Config } from "../config/loader.js";
-interface PlanTask {
-    id: number;
-    description: string;
-    status: "pending" | "in-progress" | "done" | "failed";
-    comment?: string;
-}
-export interface PlanOptions {
-    action: "create" | "update" | "comments" | "hide";
-    goal?: string;
-    tasks?: PlanTask[];
-    taskId?: number;
-    status?: PlanTask["status"];
-}
-interface PlanComment {
-    taskId: number;
-    comment: string;
-    time: number;
-}
-export declare function weavePlan(session: CDP.Client, options: PlanOptions, _config: Config): Promise<{
-    success: boolean;
-    plan?: {
-        goal: string;
-        tasks: PlanTask[];
-    };
-    comments?: PlanComment[];
-    error?: string;
-}>;
-export declare function addPlanComment(taskId: number, comment: string): void;
-/** Returns current in-memory plan (goal + tasks) — used to re-inject on page navigation */
-export declare function getActivePlan(): {
-    goal: string;
-    tasks: PlanTask[];
-} | null;
-export declare function setActivePlan(goal: string, tasks: PlanTask[]): void;
-/** Re-inject plan into a (possibly fresh) page session — used after navigation / reconnect */
-export declare function restoreActivePlanIntoPage(session: CDP.Client): Promise<void>;
-export {};

package/dist/tools/plan.js

@@ -1,161 +0,0 @@
-import { logAction } from "../audit/logger.js";
-import { sendToExtension } from "../cdp/helpers.js";
-// In-memory comment store (agent-side)
-const planComments = [];
-let activeGoal = "";
-let activeTasks = [];
-// Dormant Guard (Layer 1)
-let dormantTimer = null;
-const DORMANT_TIMEOUT_MS = 45000;
-function resetDormantGuard(session) {
-    if (dormantTimer)
-        clearTimeout(dormantTimer);
-    dormantTimer = setTimeout(async () => {
-        try {
-            await session.Runtime.evaluate({
-                expression: `(function() { if (typeof window.__wt_plan === 'function') window.__wt_plan('hide'); })()`
-            });
-        }
-        catch { /* session may be dead */ }
-    }, DORMANT_TIMEOUT_MS);
-}
-/** Poll the page for new user comments on plan tasks */
-async function pollComments(session) {
-    try {
-        const { result } = await session.Runtime.evaluate({
-            expression: `(function() {
-        var q = window.__wt_plan_comments || [];
-        if (q.length > 0) { window.__wt_plan_comments = []; return JSON.stringify(q); }
-        return '[]';
-      })()`,
-            returnByValue: true,
-        });
-        if (result?.value && result.value !== '[]') {
-            return JSON.parse(result.value);
-        }
-    }
-    catch { /* non-fatal */ }
-    return [];
-}
-export async function weavePlan(session, options, _config) {
-    const { action, goal, tasks, taskId, status } = options;
-    // Always poll for new user comments from the overlay
-    const newComments = await pollComments(session);
-    for (const c of newComments) {
-        planComments.push(c);
-        const task = activeTasks.find(t => t.id === c.taskId);
-        if (task) {
-            task.comment = c.comment;
-            logAction("browser_plan", "comment", `task ${c.taskId}: ${c.comment}`);
-        }
-    }
-    if (action === "create") {
-        activeGoal = goal || "";
-        activeTasks = tasks || [];
-        // Use sendToExtension for reliable delivery to content script
-        await sendToExtension(session, {
-            type: 'Weavetab_STATE',
-            plan: { action: 'create', goal: activeGoal, tasks: activeTasks },
-        }).catch(() => { });
-        // Also try direct injection as fallback
-        await session.Runtime.evaluate({
-            expression: `(function() {
-        if (typeof window.__wt_plan === 'function') {
-          window.__wt_plan('create', ${JSON.stringify(activeGoal)}, ${JSON.stringify(activeTasks)});
-        }
-      })()`,
-            returnByValue: true,
-        }).catch(() => { });
-        resetDormantGuard(session);
-        logAction("browser_plan", "create", `goal: ${activeGoal}, ${activeTasks.length} tasks`);
-        return { success: true, plan: { goal: activeGoal, tasks: activeTasks } };
-    }
-    if (action === "update") {
-        if (taskId === undefined || !status) {
-            return { success: false, error: "browser_plan update requires taskId and status" };
-        }
-        const task = activeTasks.find(t => t.id === taskId);
-        if (!task) {
-            return { success: false, error: `Task ${taskId} not found` };
-        }
-        task.status = status;
-        // Use sendToExtension for reliable delivery
-        await sendToExtension(session, {
-            type: 'Weavetab_STATE',
-            plan: { action: 'update', goal: activeGoal, tasks: activeTasks },
-        }).catch(() => { });
-        // Also try direct injection as fallback
-        await session.Runtime.evaluate({
-            expression: `(function() {
-        if (typeof window.__wt_plan === 'function') {
-          window.__wt_plan('update', ${JSON.stringify(activeGoal)}, ${JSON.stringify(activeTasks)});
-        }
-      })()`,
-            returnByValue: true,
-        }).catch(() => { });
-        resetDormantGuard(session);
-        logAction("browser_plan", "update", `task ${taskId} \u2192 ${status}`);
-        return { success: true, plan: { goal: activeGoal, tasks: activeTasks } };
-    }
-    if (action === "hide") {
-        if (dormantTimer) {
-            clearTimeout(dormantTimer);
-            dormantTimer = null;
-        }
-        // Use sendToExtension for reliable delivery
-        await sendToExtension(session, {
-            type: 'Weavetab_STATE',
-            plan: { action: 'hide', goal: '', tasks: [] },
-        }).catch(() => { });
-        // Also try direct injection as fallback
-        await session.Runtime.evaluate({
-            expression: `(function() {
-        if (typeof window.__wt_plan === 'function') window.__wt_plan('hide');
-      })()`,
-            returnByValue: true,
-        }).catch(() => { });
-        return { success: true };
-    }
-    if (action === "comments") {
-        return { success: true, comments: planComments.slice(), plan: { goal: activeGoal, tasks: activeTasks } };
-    }
-    return { success: false, error: `Unknown action: ${action}` };
-}
-export function addPlanComment(taskId, comment) {
-    planComments.push({ taskId, comment, time: Date.now() });
-}
-/** Returns current in-memory plan (goal + tasks) — used to re-inject on page navigation */
-export function getActivePlan() {
-    if (!activeGoal && activeTasks.length === 0)
-        return null;
-    return { goal: activeGoal, tasks: activeTasks };
-}
-export function setActivePlan(goal, tasks) {
-    activeGoal = goal || "";
-    activeTasks = tasks || [];
-}
-/** Re-inject plan into a (possibly fresh) page session — used after navigation / reconnect */
-export async function restoreActivePlanIntoPage(session) {
-    if (!activeGoal && activeTasks.length === 0)
-        return;
-    // Use sendToExtension for reliable delivery
-    try {
-        await sendToExtension(session, {
-            type: 'Weavetab_STATE',
-            plan: { action: 'create', goal: activeGoal, tasks: activeTasks },
-        });
-    }
-    catch { /* non-fatal */ }
-    // Also try direct injection as fallback
-    try {
-        await session.Runtime.evaluate({
-            expression: `(function() {
-        if (typeof window.__wt_plan === 'function') {
-          window.__wt_plan('create', ${JSON.stringify(activeGoal)}, ${JSON.stringify(activeTasks)});
-        }
-      })()`,
-            returnByValue: true,
-        });
-    }
-    catch { /* page may not be ready */ }
-}