@weavetab/mcp 2.5.0-beta.0

package/dist/intelligence/trail.d.ts

@@ -0,0 +1,64 @@
+export type TrailEntry = {
+    sessionId: string;
+    timestamp: string;
+    tool: string;
+    url?: string;
+    tabId?: string;
+    input: Record<string, unknown>;
+    result: Record<string, unknown>;
+};
+export declare function recordAction(entry: Omit<TrailEntry, "sessionId">): void;
+export declare function getLastAction(): TrailEntry | null;
+export declare function getTrail(): TrailEntry[];
+export declare function clearTrail(): void;
+export interface LoopDiagnostics {
+    looped: boolean;
+    strikes: number;
+    severity: "none" | "warning" | "critical";
+}
+export declare function detectLoop(tool: string, ref: string): boolean;
+export declare function getLoopDiagnostics(tool: string, ref: string): LoopDiagnostics;
+export declare function resetLoopCounter(reason?: string): void;
+/**
+ * Reset loop detection for a single tool+ref pair only.
+ * Does not affect other refs or the trail history.
+ */
+export declare function resetLoopCounterForRef(tool: string, ref: string): void;
+export interface ToolCallTracking {
+    tool: string;
+    target: string;
+    timestamp: string;
+    result: Record<string, unknown>;
+}
+/**
+ * Track a tool call for loop detection
+ * Maintains a rolling window of the last 5 tool calls
+ */
+export declare function trackToolCall(tool: string, target: string, result: Record<string, unknown>): void;
+/**
+ * Check if the agent is stuck in a loop using rolling window detection
+ * Returns STUCK signal with diagnosis if loop detected
+ */
+export declare function detectStuckLoop(): {
+    stuck: boolean;
+    diagnosis?: string;
+};
+/**
+ * Clear the tool call window (useful when starting a new task).
+ * Also called by navigate.ts on every navigation to prevent cross-page STUCK_LOOP.
+ */
+export declare function clearToolCallWindow(): void;
+/**
+ * Get the current tool call window (for debugging)
+ */
+export declare function getToolCallWindow(): ToolCallTracking[];
+/**
+ * Detect cross-tool loops — e.g. click→fill→click→fill repeating with no success.
+ * Catches cases where the agent alternates between tools on the same target
+ * without making progress, which single-tool detection misses entirely.
+ */
+export declare function detectCrossToolLoop(): {
+    stuck: boolean;
+    pattern?: string;
+    diagnosis?: string;
+};

package/dist/intelligence/trail.js

@@ -0,0 +1,233 @@
+import { logDebug } from "../audit/logger.js";
+// src/intelligence/trail.ts
+// Lightweight action trail — keeps last 50 actions in memory.
+// Used by tools to record what happened for context and audit.
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+// Generate a unique session ID for this process run
+const SESSION_ID = crypto.randomUUID();
+let trail = [];
+// Per-ref loop reset registry.
+// Maps "tool:ref" or "__global__" → ISO timestamp of the last explicit reset.
+// getLoopDiagnostics / detectLoop only count trail entries recorded AFTER this timestamp.
+// Trail history itself is NEVER wiped by resetLoopCounter — context is preserved.
+const loopResets = new Map();
+const SESSIONS_DIR = path.join(os.homedir(), ".weavetab-system", "sessions");
+const CONTEXT_FILE = path.join(SESSIONS_DIR, "context.json");
+function ensureContextFile() {
+    if (!fs.existsSync(SESSIONS_DIR)) {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(CONTEXT_FILE)) {
+        fs.writeFileSync(CONTEXT_FILE, JSON.stringify([]));
+    }
+}
+try {
+    if (fs.existsSync(CONTEXT_FILE)) {
+        trail = JSON.parse(fs.readFileSync(CONTEXT_FILE, 'utf-8'));
+    }
+}
+catch (e) { }
+export function recordAction(entry) {
+    const fullEntry = { ...entry, sessionId: SESSION_ID };
+    trail.push(fullEntry);
+    // Cap at 20 entries to reduce stale cross-session disk poisoning
+    if (trail.length > 20)
+        trail.shift();
+    try {
+        ensureContextFile();
+        fs.writeFileSync(CONTEXT_FILE, JSON.stringify(trail, null, 2));
+    }
+    catch (e) {
+        logDebug("[Weavetab] Failed to save session context", e);
+    }
+}
+export function getLastAction() {
+    return trail.length > 0 ? trail[trail.length - 1] : null;
+}
+export function getTrail() {
+    return [...trail];
+}
+export function clearTrail() {
+    trail = [];
+    try {
+        if (fs.existsSync(CONTEXT_FILE)) {
+            fs.writeFileSync(CONTEXT_FILE, JSON.stringify([]));
+        }
+    }
+    catch (e) { }
+}
+const LOOP_LIMIT = 10;
+export function detectLoop(tool, ref) {
+    const resetAt = loopResets.get(`${tool}:${ref}`) ?? loopResets.get("__global__");
+    // Only consider entries after the last reset boundary and from this session
+    const relevant = trail.filter(e => e.sessionId === SESSION_ID && (!resetAt || e.timestamp > resetAt));
+    if (relevant.length < LOOP_LIMIT)
+        return false;
+    const lastN = relevant.slice(-LOOP_LIMIT);
+    return lastN.every(entry => entry.tool === tool && entry.input.ref === ref &&
+        (entry.result?.success === false || entry.result?.stuck === true));
+}
+export function getLoopDiagnostics(tool, ref) {
+    // Per-ref reset takes priority over global reset
+    const resetAt = loopResets.get(`${tool}:${ref}`) ?? loopResets.get("__global__");
+    let strikes = 0;
+    for (let i = trail.length - 1; i >= 0; i--) {
+        const entry = trail[i];
+        // Stop counting if we hit a different session or the reset boundary
+        if (entry.sessionId !== SESSION_ID)
+            break;
+        if (resetAt && entry.timestamp <= resetAt)
+            break;
+        if (entry.tool === tool && entry.input.ref === ref &&
+            (entry.result?.success === false || entry.result?.stuck === true)) {
+            strikes++;
+        }
+        else
+            break;
+    }
+    let severity = "none";
+    if (strikes >= LOOP_LIMIT)
+        severity = "critical";
+    else if (strikes >= Math.ceil(LOOP_LIMIT / 2))
+        severity = "warning";
+    return { looped: strikes >= LOOP_LIMIT, strikes, severity };
+}
+export function resetLoopCounter(reason = "manual") {
+    // Record a global reset timestamp. Loop detection ignores all trail entries
+    // recorded before this moment. Trail history is intentionally preserved —
+    // burst, delta, and memory all depend on it staying intact.
+    loopResets.clear(); // also clears any per-ref markers
+    loopResets.set("__global__", new Date().toISOString());
+    // Also clear the rolling toolCallWindow — it is session-global and survives
+    // navigation, causing false STUCK_LOOP bricks across different pages/tasks.
+    toolCallWindow.length = 0;
+    logDebug(`[Weavetab] Loop counter reset (reason: ${reason}) — trail history preserved, strike window cleared`);
+}
+/**
+ * Reset loop detection for a single tool+ref pair only.
+ * Does not affect other refs or the trail history.
+ */
+export function resetLoopCounterForRef(tool, ref) {
+    loopResets.set(`${tool}:${ref}`, new Date().toISOString());
+    logDebug(`[Weavetab] Loop counter reset for ${tool}:${ref}`);
+}
+// Rolling window of last 5 tool calls for loop detection
+const toolCallWindow = [];
+const MAX_WINDOW_SIZE = 5;
+/**
+ * Track a tool call for loop detection
+ * Maintains a rolling window of the last 5 tool calls
+ */
+export function trackToolCall(tool, target, result) {
+    toolCallWindow.push({
+        tool,
+        target,
+        timestamp: new Date().toISOString(),
+        result,
+    });
+    // Keep only the last MAX_WINDOW_SIZE calls
+    if (toolCallWindow.length > MAX_WINDOW_SIZE) {
+        toolCallWindow.shift();
+    }
+}
+/**
+ * Check if the agent is stuck in a loop using rolling window detection
+ * Returns STUCK signal with diagnosis if loop detected
+ */
+export function detectStuckLoop() {
+    if (toolCallWindow.length < 3) {
+        return { stuck: false };
+    }
+    // Check for 3 consecutive same-tool+target calls without state change
+    let consecutiveCount = 0;
+    let lastStateChange;
+    for (let i = toolCallWindow.length - 1; i >= 0; i--) {
+        const call = toolCallWindow[i];
+        const currentState = JSON.stringify(call.result);
+        // Compare with previous call
+        if (i > 0) {
+            const prevCall = toolCallWindow[i - 1];
+            if (call.tool === prevCall.tool && call.target === prevCall.target) {
+                // Check if state changed
+                if (currentState === lastStateChange) {
+                    consecutiveCount++;
+                }
+                else {
+                    consecutiveCount = 0;
+                    lastStateChange = currentState;
+                }
+            }
+            else {
+                consecutiveCount = 0;
+                lastStateChange = currentState;
+            }
+        }
+    }
+    if (consecutiveCount >= 2) { // 3 total (current + 2 previous)
+        const lastCall = toolCallWindow[toolCallWindow.length - 1];
+        return {
+            stuck: true,
+            diagnosis: `Agent is stuck in a loop: ${consecutiveCount + 1} consecutive calls to ${lastCall.tool} on target "${lastCall.target}" without state change. Consider trying a different approach or resetting the loop counter.`
+        };
+    }
+    return { stuck: false };
+}
+/**
+ * Clear the tool call window (useful when starting a new task).
+ * Also called by navigate.ts on every navigation to prevent cross-page STUCK_LOOP.
+ */
+export function clearToolCallWindow() {
+    toolCallWindow.length = 0;
+}
+/**
+ * Get the current tool call window (for debugging)
+ */
+export function getToolCallWindow() {
+    return [...toolCallWindow];
+}
+/**
+ * Detect cross-tool loops — e.g. click→fill→click→fill repeating with no success.
+ * Catches cases where the agent alternates between tools on the same target
+ * without making progress, which single-tool detection misses entirely.
+ */
+export function detectCrossToolLoop() {
+    if (toolCallWindow.length < 4)
+        return { stuck: false };
+    const recent = toolCallWindow.slice(-6); // look at last 6 calls
+    const tools = recent.map(c => c.tool);
+    const allFailed = recent.every(c => c.result?.success === false || c.result?.stuck === true);
+    if (!allFailed)
+        return { stuck: false };
+    // Check for repeating 2-cycle pattern: A B A B or A B A B A B
+    if (recent.length >= 4) {
+        const last4Tools = tools.slice(-4);
+        if (last4Tools[0] === last4Tools[2] &&
+            last4Tools[1] === last4Tools[3] &&
+            last4Tools[0] !== last4Tools[1]) {
+            const pattern = `${last4Tools[0]} → ${last4Tools[1]}`;
+            return {
+                stuck: true,
+                pattern,
+                diagnosis: `Cross-tool loop detected: cycling "${pattern}" (${recent.length} times) without success. Stop this approach entirely. Try: 1) browser_map() to re-read the page, 2) browser_screenshot() to see what's visible, 3) browser_captcha({action:"detect"}) if a CAPTCHA may be blocking.`,
+            };
+        }
+    }
+    // Check for repeating 3-cycle: A B C A B C
+    if (recent.length >= 6) {
+        const last6Tools = tools.slice(-6);
+        if (last6Tools[0] === last6Tools[3] &&
+            last6Tools[1] === last6Tools[4] &&
+            last6Tools[2] === last6Tools[5]) {
+            const pattern = `${last6Tools[0]} → ${last6Tools[1]} → ${last6Tools[2]}`;
+            return {
+                stuck: true,
+                pattern,
+                diagnosis: `Cross-tool loop detected: cycling "${pattern}" without success. Stop and reassess. Call browser_map() to re-read the page state.`,
+            };
+        }
+    }
+    return { stuck: false };
+}

package/dist/intelligence/trail.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trail.test.d.ts.map

package/dist/intelligence/trail.test.js

@@ -0,0 +1,110 @@
+/**
+ * trail.test.ts — Phase 1.1
+ * Unit tests for the Phase 0.1 fix: resetLoopCounter must NOT wipe the trail,
+ * loop detection must respect timestamp-based reset boundaries.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { recordAction, getTrail, clearTrail, getLoopDiagnostics, detectLoop, resetLoopCounter, resetLoopCounterForRef, } from "./trail.js";
+// Helper: record N consecutive failures for a given tool+ref
+function recordFailures(tool, ref, count) {
+    for (let i = 0; i < count; i++) {
+        recordAction({
+            timestamp: new Date().toISOString(),
+            tool,
+            input: { ref },
+            result: { success: false, stuck: true },
+        });
+    }
+}
+// Helper: record one success
+function recordSuccess(tool, ref) {
+    recordAction({
+        timestamp: new Date().toISOString(),
+        tool,
+        input: { ref },
+        result: { success: true, stuck: false },
+    });
+}
+test("trail: recordAction appends entries", () => {
+    clearTrail();
+    recordSuccess("browser_click", "w:1");
+    assert.equal(getTrail().length, 1);
+    clearTrail();
+});
+test("loop: no warning below threshold (< 5 strikes)", () => {
+    clearTrail();
+    recordFailures("browser_click", "w:99", 4);
+    const diag = getLoopDiagnostics("browser_click", "w:99");
+    assert.equal(diag.severity, "none", `Expected none at 4 strikes, got ${diag.severity}`);
+    clearTrail();
+});
+test("loop: warning fires at ≥ 5 strikes (half of LOOP_LIMIT=10)", () => {
+    clearTrail();
+    recordFailures("browser_click", "w:99", 5);
+    const diag = getLoopDiagnostics("browser_click", "w:99");
+    assert.equal(diag.severity, "warning", `Expected warning at 5 strikes, got ${diag.severity}`);
+    clearTrail();
+});
+test("loop: critical fires at ≥ 10 strikes", () => {
+    clearTrail();
+    recordFailures("browser_click", "w:99", 10);
+    const diag = getLoopDiagnostics("browser_click", "w:99");
+    assert.equal(diag.severity, "critical", `Expected critical at 10 strikes, got ${diag.severity}`);
+    clearTrail();
+});
+test("loop: success resets the consecutive strike count", () => {
+    clearTrail();
+    recordFailures("browser_click", "w:5", 6);
+    recordSuccess("browser_click", "w:5"); // interrupts the consecutive run
+    const diag = getLoopDiagnostics("browser_click", "w:5");
+    assert.equal(diag.strikes, 0, `Expected 0 strikes after success, got ${diag.strikes}`);
+    clearTrail();
+});
+test("Phase 0.1: resetLoopCounter preserves trail history", () => {
+    clearTrail();
+    recordSuccess("browser_click", "w:1");
+    recordSuccess("browser_type", "w:2");
+    const countBefore = getTrail().length;
+    assert.equal(countBefore, 2);
+    resetLoopCounter("test");
+    // Trail must still have the same entries — history is preserved
+    const countAfter = getTrail().length;
+    assert.equal(countAfter, 2, `Trail should still have 2 entries after resetLoopCounter, got ${countAfter}`);
+    clearTrail();
+});
+test("Phase 0.1: resetLoopCounter clears strikes without wiping trail", () => {
+    clearTrail();
+    recordFailures("browser_click", "w:7", 10);
+    const before = getLoopDiagnostics("browser_click", "w:7");
+    assert.equal(before.severity, "critical");
+    resetLoopCounter("test");
+    // New failures recorded AFTER reset should count fresh
+    recordFailures("browser_click", "w:7", 2);
+    const after = getLoopDiagnostics("browser_click", "w:7");
+    // Trail still has 12 entries but only 2 are after the reset boundary
+    assert.equal(after.strikes, 2, `Expected 2 strikes post-reset, got ${after.strikes}`);
+    assert.equal(after.severity, "none", `Expected none at 2 strikes post-reset, got ${after.severity}`);
+    clearTrail();
+});
+test("Phase 0.1: resetLoopCounterForRef only affects that ref", () => {
+    clearTrail();
+    recordFailures("browser_click", "w:A", 10); // critical
+    recordFailures("browser_click", "w:B", 10); // critical
+    resetLoopCounterForRef("browser_click", "w:A");
+    const diagA = getLoopDiagnostics("browser_click", "w:A");
+    const diagB = getLoopDiagnostics("browser_click", "w:B");
+    assert.equal(diagA.strikes, 0, `w:A should have 0 strikes after per-ref reset, got ${diagA.strikes}`);
+    assert.equal(diagB.severity, "critical", `w:B should still be critical, got ${diagB.severity}`);
+    clearTrail();
+});
+test("Phase 0.1: detectLoop returns false after resetLoopCounter", () => {
+    clearTrail();
+    recordFailures("browser_click", "w:X", 10);
+    assert.equal(detectLoop("browser_click", "w:X"), true, "Expected loop before reset");
+    resetLoopCounter("test");
+    recordFailures("browser_click", "w:X", 3); // not enough for loop after reset
+    assert.equal(detectLoop("browser_click", "w:X"), false, "Expected no loop after reset with only 3 new strikes");
+    clearTrail();
+});
+//# sourceMappingURL=trail.test.js.map

package/dist/intelligence/vision.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Weavetab — intelligence/vision.ts
+ * Local pixel-analysis visual fallback — runs when CDP AX tree returns 0 elements.
+ * No external APIs. No ML. Pure image analysis using sharp.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+export interface ClickableZone {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface VisualFallback {
+    page_state: "loading" | "blank" | "content" | "error_page";
+    text_density: number;
+    content_heatmap: string;
+    clickable_zones: ClickableZone[];
+}
+/**
+ * Capture a CDP screenshot, run local pixel analysis, and return
+ * structured signal the agent can use when the AX tree is empty.
+ */
+export declare function analyzeVisualFallback(session: CDP.Client): Promise<VisualFallback>;

package/dist/intelligence/vision.js

@@ -0,0 +1,151 @@
+/**
+ * Weavetab — intelligence/vision.ts
+ * Local pixel-analysis visual fallback — runs when CDP AX tree returns 0 elements.
+ * No external APIs. No ML. Pure image analysis using sharp.
+ * Weavetab by fy2ne
+ */
+/**
+ * Capture a CDP screenshot, run local pixel analysis, and return
+ * structured signal the agent can use when the AX tree is empty.
+ */
+export async function analyzeVisualFallback(session) {
+    // ── 1. Capture screenshot via CDP ─────────────────────────────────────────
+    const { data } = await session.Page.captureScreenshot({ format: "png" });
+    const buffer = Buffer.from(data, "base64");
+    let sharp;
+    try {
+        sharp = (await import("sharp")).default;
+    }
+    catch {
+        // sharp not available — return a default fallback
+        return {
+            page_state: "content",
+            text_density: 50,
+            content_heatmap: "................",
+            clickable_zones: [],
+        };
+    }
+    const img = sharp(buffer);
+    const { width = 1280, height = 720 } = await img.metadata();
+    // ── 2A. Raw pixels for analysis ────────────────────────────────────────────
+    const rawBuf = await img
+        .raw()
+        .toBuffer();
+    const pixels = rawBuf; // [R, G, B, R, G, B ...]  (no alpha after .raw())
+    const totalPixels = width * height;
+    function getPixel(x, y) {
+        const idx = (y * width + x) * 3;
+        return [pixels[idx], pixels[idx + 1], pixels[idx + 2]];
+    }
+    // ── 2B. Convert to grayscale array ─────────────────────────────────────────
+    const gray = new Uint8Array(totalPixels);
+    for (let i = 0; i < totalPixels; i++) {
+        const r = pixels[i * 3];
+        const g = pixels[i * 3 + 1];
+        const b = pixels[i * 3 + 2];
+        gray[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+    }
+    // ── 3A. Dominant color regions (4×4 grid) ──────────────────────────────────
+    const GRID_COLS = 4;
+    const GRID_ROWS = 4;
+    const cellW = Math.floor(width / GRID_COLS);
+    const cellH = Math.floor(height / GRID_ROWS);
+    const cellAvgs = [];
+    for (let row = 0; row < GRID_ROWS; row++) {
+        for (let col = 0; col < GRID_COLS; col++) {
+            let sumR = 0, sumG = 0, sumB = 0, count = 0;
+            for (let y = row * cellH; y < (row + 1) * cellH && y < height; y++) {
+                for (let x = col * cellW; x < (col + 1) * cellW && x < width; x++) {
+                    const [r, g, b] = getPixel(x, y);
+                    sumR += r;
+                    sumG += g;
+                    sumB += b;
+                    count++;
+                }
+            }
+            cellAvgs.push({ r: sumR / count, g: sumG / count, b: sumB / count });
+        }
+    }
+    // Mark cells with significant variation from neighbors
+    function colorDist(a, b) {
+        return Math.sqrt((a.r - b.r) ** 2 + (a.g - b.g) ** 2 + (a.b - b.b) ** 2);
+    }
+    const heatmap = cellAvgs.map((cell, idx) => {
+        const neighbors = [];
+        if (idx % GRID_COLS !== 0)
+            neighbors.push(cellAvgs[idx - 1]);
+        if (idx % GRID_COLS !== GRID_COLS - 1)
+            neighbors.push(cellAvgs[idx + 1]);
+        if (idx >= GRID_COLS)
+            neighbors.push(cellAvgs[idx - GRID_COLS]);
+        if (idx < cellAvgs.length - GRID_COLS)
+            neighbors.push(cellAvgs[idx + GRID_COLS]);
+        const avgDist = neighbors.reduce((s, n) => s + colorDist(cell, n), 0) / (neighbors.length || 1);
+        return avgDist > 30 ? "X" : ".";
+    });
+    const content_heatmap = heatmap.join("");
+    // ── 3B. Text density estimate ───────────────────────────────────────────────
+    let textLikePixels = 0;
+    for (let i = 0; i < gray.length; i++) {
+        const g = gray[i];
+        if (g >= 40 && g <= 180)
+            textLikePixels++;
+    }
+    const text_density = Math.round((textLikePixels / totalPixels) * 100);
+    // ── 3C. Loading / page state detection ─────────────────────────────────────
+    // Check if most pixels are the same brightness (solid color = loading screen)
+    let mean = 0;
+    for (let i = 0; i < gray.length; i++)
+        mean += gray[i];
+    mean /= gray.length;
+    let variance = 0;
+    for (let i = 0; i < gray.length; i++)
+        variance += (gray[i] - mean) ** 2;
+    variance /= gray.length;
+    const stdDev = Math.sqrt(variance);
+    let page_state;
+    if (stdDev < 10) {
+        // Almost solid color
+        page_state = mean > 240 ? "blank" : "loading";
+    }
+    else if (text_density < 5 && heatmap.filter((c) => c === "X").length < 3) {
+        page_state = "loading";
+    }
+    else if (text_density > 15) {
+        page_state = "content";
+    }
+    else {
+        page_state = "content";
+    }
+    // Check for error page heuristic: very bright + low text density
+    if (mean > 230 && text_density < 8 && stdDev < 20) {
+        page_state = "error_page";
+    }
+    // ── 3D. Clickable zone detection ───────────────────────────────────────────
+    // Scan for rectangular high-contrast bordered regions (buttons have edges).
+    // Strategy: find horizontal bands of high contrast as potential button tops/bottoms.
+    const clickable_zones = [];
+    const ZONE_SAMPLE_STEP = 24;
+    for (let y = ZONE_SAMPLE_STEP; y < height - ZONE_SAMPLE_STEP && clickable_zones.length < 5; y += ZONE_SAMPLE_STEP) {
+        for (let x = ZONE_SAMPLE_STEP; x < width - ZONE_SAMPLE_STEP; x += ZONE_SAMPLE_STEP) {
+            // Sample a 3x3 neighborhood and look for high local contrast
+            const center = gray[y * width + x] ?? 128;
+            const neighbors = [
+                gray[(y - 1) * width + x] ?? center,
+                gray[(y + 1) * width + x] ?? center,
+                gray[y * width + (x - 1)] ?? center,
+                gray[y * width + (x + 1)] ?? center,
+            ];
+            const maxDiff = Math.max(...neighbors.map((n) => Math.abs(n - center)));
+            // High contrast border detected — plausible button region
+            if (maxDiff > 60) {
+                // Check it's not too close to an existing zone
+                const tooClose = clickable_zones.some((z) => Math.abs(z.x - x) < 60 && Math.abs(z.y - y) < 40);
+                if (!tooClose) {
+                    clickable_zones.push({ x, y, width: 80, height: 32 });
+                }
+            }
+        }
+    }
+    return { page_state, text_density, content_heatmap, clickable_zones };
+}

package/dist/lifecycle/mission_manager.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Weavetab — lifecycle/mission_manager.ts
+ * Mission Lifecycle Manager (MLM)
+ * Handles suspension, hibernation, and resumption of Weavetab missions.
+ * Weavetab by fy2ne
+ */
+export interface MissionState {
+    missionId: string;
+    agentId: string;
+    status: "active" | "suspended" | "completed";
+    timestamp: number;
+    plan: any;
+    tabs: any[];
+}
+export declare function suspendMission(agentId: string, missionId: string): Promise<void>;
+export declare function resumeMission(missionId: string): MissionState | null;

package/dist/lifecycle/mission_manager.js

@@ -0,0 +1,44 @@
+/**
+ * Weavetab — lifecycle/mission_manager.ts
+ * Mission Lifecycle Manager (MLM)
+ * 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";
+import { getSystemDir } from "../config/loader.js";
+const stateDir = getSystemDir("missions");
+function getMissionPath(missionId) {
+    return path.join(stateDir, `mission_${missionId}.json`);
+}
+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));
+}
+export function resumeMission(missionId) {
+    const p = getMissionPath(missionId);
+    if (fs.existsSync(p)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/overlay/bubble.d.ts

@@ -0,0 +1,16 @@
+import CDP from "chrome-remote-interface";
+export type ThoughtCategory = "planning" | "acting" | "verifying" | "done" | "error";
+export interface BubbleOptions {
+    text: string;
+    category?: ThoughtCategory;
+    step?: number;
+    stepTotal?: number;
+    estimatedMs?: number;
+    icon?: string;
+}
+export declare function showBubble(session: CDP.Client, icon: string, text: string, durationMs?: number, opts?: Partial<BubbleOptions>): Promise<void>;
+export declare function showProgress(session: CDP.Client, text: string, step: number, stepTotal: number, category?: ThoughtCategory, estimatedMs?: number): Promise<void>;
+export declare function hideBubble(session: CDP.Client): Promise<void>;
+export declare function injectBubbleScripts(_session: CDP.Client): Promise<void>;
+export declare function openOverlayTab(_session: CDP.Client): Promise<void>;
+export declare function startBubbleProcess(_humanMode?: boolean): void;