@weavetab/mcp 2.5.0-beta.2 → 2.5.0-beta.5

package/dist/index.js

@@ -11,6 +11,7 @@ import { createRequire } from "node:module";
 import chalk from "chalk";
 import boxen from "boxen";
 import pc from "picocolors";
+import { WEAVETAB_VERSION } from "./version.js";
 // ─── Server-Process Singleton Lock ────────────────────────────────────────────
 // When an IDE opens multiple windows or reconnects after a crash, it spawns a new
 // `node dist/index.js` MCP process each time. Without a guard, these stack up
@@ -32,13 +33,29 @@ function _acquireServerLock() {
         fs.mkdirSync(_SERVER_LOCK_DIR, { recursive: true });
         if (fs.existsSync(_SERVER_LOCK_FILE)) {
             const existingPid = parseInt(fs.readFileSync(_SERVER_LOCK_FILE, "utf-8").trim(), 10);
-            if (!isNaN(existingPid) && existingPid !== process.pid && _isProcessAlive(existingPid)) {
-                process.stderr.write(`[Weavetab] Another Weavetab MCP server is running (PID ${existingPid}). Multiple clients active.\n`);
-                // We no longer return false here. The analyticsInterval.unref() call
-                // prevents zombie leaks, so it's safe to allow multiple agents (e.g.
-                // Openchamber + Antigravity) to run their own MCP processes concurrently
-                // and share the browser.
+            if (!isNaN(existingPid) && existingPid !== process.pid) {
+                if (_isProcessAlive(existingPid)) {
+                    process.stderr.write(`[Weavetab] Another Weavetab MCP server is running (PID ${existingPid}). Client session active.\n`);
+                }
+                else {
+                    // Process is dead: reap stale PID lock
+                    try {
+                        fs.unlinkSync(_SERVER_LOCK_FILE);
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        // Also reap stale browser lock file if the recorded browser PID is dead
+        const browserLockFile = path.join(_SERVER_LOCK_DIR, ".weavetab.lock");
+        if (fs.existsSync(browserLockFile)) {
+            try {
+                const lockData = JSON.parse(fs.readFileSync(browserLockFile, "utf-8"));
+                if (lockData.pid && !_isProcessAlive(lockData.pid)) {
+                    fs.unlinkSync(browserLockFile);
+                }
             }
+            catch { /* malformed lock, ignore */ }
         }
         fs.writeFileSync(_SERVER_LOCK_FILE, String(process.pid), "utf-8");
         return true;
@@ -81,6 +98,32 @@ function printBootBanner(port) {
 async function main() {
     assertNotRoot();
     const args = process.argv.slice(2);
+    // Global flags: --version always works; --ws starts the WebSocket daemon.
+    if (args.includes("--version") || args.includes("-v")) {
+        const _v = createRequire(import.meta.url);
+        const ver = _v("../package.json").version || WEAVETAB_VERSION;
+        console.log(`@weavetab/mcp v${ver}`);
+        process.exit(0);
+    }
+    if (args.includes("--ws")) {
+        let wsPort = 3000;
+        const pi = args.findIndex((a) => a === "--port");
+        const eq = args.find((a) => a.startsWith("--port="));
+        const rawPort = pi >= 0 ? args[pi + 1] : eq ? eq.slice("--port=".length) : undefined;
+        if (rawPort !== undefined) {
+            const parsed = parseInt(rawPort, 10);
+            if (isNaN(parsed) || parsed < 1 || parsed > 65535) {
+                console.error(`[Weavetab] Invalid --port value: "${rawPort}" (1-65535).`);
+                process.exit(1);
+            }
+            wsPort = parsed;
+        }
+        const config = await loadConfig();
+        global.__wt_is_server = true;
+        await printBootBanner(wsPort);
+        await startServer(config, "ws", wsPort);
+        return;
+    }
     // If NOT in a TTY environment (e.g. spawned by Claude Code as MCP server)
     if (!isInteractive && args.length === 0) {
         // Singleton guard — exit immediately if another MCP server is alive.
@@ -134,6 +177,17 @@ async function main() {
             await runPluginCli(args.slice(1));
             process.exit(0);
         }
+        if (cmd === "skills") {
+            const { execSync: exec } = await import("node:child_process");
+            const subArgs = args.slice(1).join(" ");
+            try {
+                exec(`npx -y @weavetab/skills@latest ${subArgs}`.trim(), { stdio: "inherit" });
+            }
+            catch {
+                process.exit(1);
+            }
+            process.exit(0);
+        }
         if (cmd === "init" || cmd === "create" || cmd === "build" || cmd === "manifest") {
             console.log(pc.yellow(`\n[Weavetab] Plugin authoring commands are part of the developer SDK (@weavetab/sdk).`));
             console.log(pc.dim("To scaffold a new plugin:   ") + pc.cyan("npx -y @weavetab/sdk init <name>"));
@@ -335,6 +389,7 @@ async function main() {
             S.sl("Role *", {
                 initialValue: "admin", options: [
                     { value: "admin", label: "Admin", hint: "Full access to all tools" },
+                    { value: "operator", label: "Operator", hint: "Full access, standard agent role" },
                     { value: "viewer", label: "Viewer", hint: "Read-only access (map, find, scrape, console)" },
                     { value: "automation", label: "Automation", hint: "CI/CD mode (burst, plan, wait, map)" },
                 ]
@@ -406,6 +461,7 @@ async function main() {
                         }, "browserType"),
                         S.cf("Enable Weavetab browser extension?", "extension", true),
                         S.cf("Persist cookies across sessions?", "cookies", false),
+                        S.cf("Sync browser data across profiles?", "syncDataAcrossBrowsers", false),
                         S.tx("Extra browser flags (space-separated)", "browserFlagsRaw", ""),
                         S.tx("Custom browser profile directory", "profileDir", ""),
                     ])) === "back")
@@ -427,6 +483,8 @@ async function main() {
                             return "Positive integer."; }),
                         S.tx("Actionability timeout (ms)", "actionabilityTimeout", "500", (v) => { const n = parseInt(v ?? ""); if (isNaN(n) || n < 100)
                             return "Min 100 ms."; }),
+                        S.tx("Ref cache TTL (ms) — stale element handle expiry", "refCacheTtlMs", "30000", (v) => { const n = parseInt(v ?? ""); if (isNaN(n) || n < 1000)
+                            return "Min 1000 ms."; }),
                     ])) === "back")
                         process.exit(0);
                 }
@@ -445,6 +503,10 @@ async function main() {
                     console.log(boxen(pc.cyan("SECTION D: STORAGE & PROXY"), { padding: 1, borderStyle: 'round', borderColor: 'cyan' }));
                     if ((await run([
                         S.tx("Download directory", "downloadDir", ""),
+                        S.tx("PDF output directory", "pdfDir", ""),
+                        S.tx("Snapshot directory (screenshots)", "snapshotDir", ""),
+                        S.tx("Recording output directory", "recordingDir", ""),
+                        S.tx("Design extraction directory", "designDir", ""),
                         S.tx("Proxy URL (or $WT_PROXY_URL)", "proxy", ""),
                     ])) === "back")
                         process.exit(0);
@@ -492,6 +554,7 @@ async function main() {
                     browserType: a.browserType || "chromium",
                     extension: a.extension !== undefined ? a.extension : true,
                     cookies: a.cookies || false,
+                    syncDataAcrossBrowsers: a.syncDataAcrossBrowsers || false,
                     browserFlags: a.browserFlags || [],
                     profileDir: a.profileDir || "",
                     sessionTimeout: parseInt(a.sessionTimeout) || 3600,
@@ -499,9 +562,14 @@ async function main() {
                     idleTimeout: parseInt(a.idleTimeout) || 60000,
                     maxActionsPerMinute: parseInt(a.maxActionsPerMinute) || 60,
                     actionabilityTimeout: parseInt(a.actionabilityTimeout) || 500,
+                    refCacheTtlMs: parseInt(a.refCacheTtlMs) || 30000,
                     telemetry: a.telemetry || false,
                     githubCacheTtlMs: parseInt(a.githubCacheTtlMs) || 1800000,
                     downloadDir: a.downloadDir || "",
+                    pdfDir: a.pdfDir || "",
+                    snapshotDir: a.snapshotDir || "",
+                    recordingDir: a.recordingDir || "",
+                    designDir: a.designDir || "",
                     proxy: typeof a.proxy === "string" && a.proxy.trim() ? a.proxy.trim() : undefined,
                     policies: a.policies || [],
                 });
@@ -610,7 +678,40 @@ async function main() {
                     mcpConfigured = true;
                 }
             }
-            // ── PHASE 5: SUMMARY ───────────────────────────────────────────────────────
+            // ── PHASE 5: AGENT SKILLS ────────────────────────────────────────────────────
+            console.log(boxen(pc.blue("PHASE 5: AGENT SKILLS"), { padding: 1, borderStyle: 'round', borderColor: 'blue' }));
+            let skillsInstalled = false;
+            const installSkillsNow = await p.confirm({
+                message: "Install or update Weavetab agent skills? (domain guides for your AI agent)",
+                initialValue: true
+            });
+            if (!p.isCancel(installSkillsNow) && installSkillsNow) {
+                const agentFramework = await p.select({
+                    message: "Select your target AI agent framework:",
+                    options: [
+                        { value: ".agent", label: "Antigravity", hint: ".agent/skills/<domain>/SKILL.md" },
+                        { value: ".cursor", label: "Cursor IDE", hint: ".cursor/rules/weavetab-<domain>.mdc" },
+                        { value: ".clinerules", label: "Cline", hint: ".clinerules" },
+                        { value: ".windsurf", label: "Windsurf", hint: ".windsurf/rules/" },
+                        { value: ".openclaw", label: "OpenClaw", hint: ".openclaw/skills/" },
+                        { value: ".roocode", label: "RooCode", hint: ".roocode/rules/" },
+                        { value: "generic", label: "Raw Markdown", hint: "weavetab-skills/ directory" },
+                    ]
+                });
+                if (!p.isCancel(agentFramework)) {
+                    const { execSync: exec } = await import("node:child_process");
+                    p.note(`${pc.dim("Installing skills for")} ${pc.cyan(agentFramework)} ${pc.dim("via")} ${pc.cyan("npx @weavetab/skills@latest")}...`, "SKILLS INSTALLER");
+                    console.log();
+                    try {
+                        exec(`npx -y @weavetab/skills@latest --framework ${agentFramework}`, { stdio: "inherit" });
+                        skillsInstalled = true;
+                    }
+                    catch {
+                        console.log(pc.yellow(`[WARN] Skills install failed — run 'npx @weavetab/skills@latest -f ${agentFramework}' manually`));
+                    }
+                }
+            }
+            // ── PHASE 6: SUMMARY ───────────────────────────────────────────────────────
             console.log(boxen(pc.green("CONFIGURATION COMPLETE"), { padding: 1, borderStyle: 'round', borderColor: 'green' }));
             const summary = [
                 `${pc.dim("Browser:")}        ${a.browser}`,
@@ -620,6 +721,7 @@ async function main() {
                 `${pc.dim("Max tabs:")}       ${partialConfig.maxTabs}`,
                 `${pc.dim("Config location:")} ~/.weavetab/config.json`,
                 `${pc.dim("MCP Config:")}     ${mcpConfigured ? pc.green("[OK] Configured") : pc.yellow("Pending")}`,
+                `${pc.dim("Skills:")}         ${skillsInstalled ? pc.green("[OK] Installed") : pc.dim("Skipped")}`,
             ];
             if (a.block?.length)
                 summary.push(`${pc.dim("Blocked:")}   ${a.block.join(", ")}`);
@@ -627,7 +729,7 @@ async function main() {
                 summary.push(`${pc.dim("Allowed:")}   ${a.allow.join(", ")}`);
             p.note(summary.join("\n"), "SUMMARY");
             if (!mcpConfigured) {
-                console.log(pc.dim("\nTo configure MCP manually, run: weavetab config-mcp"));
+                console.log(pc.dim("\nTo configure MCP manually, run: weavetab config"));
             }
             p.outro(`${pc.green("Weavetab is ready!")}  ${pc.dim("Run")} ${pc.cyan("weavetab help")} ${pc.dim("to see available commands.")}`);
         }
@@ -970,7 +1072,7 @@ async function main() {
         const open = (await import("open")).default;
         const config = await loadConfig();
         const _require = createRequire(import.meta.url);
-        const version = _require("../package.json").version || "2.5.0";
+        const version = _require("../package.json").version || WEAVETAB_VERSION;
         console.clear();
         await checkForUpdates();
         // Config resolution info
@@ -1001,7 +1103,7 @@ async function main() {
         console.log(pc.bold("LINKS"));
         console.log(`  ${pc.cyan("[G]")}  GitHub    ${pc.dim("github.com/Weavetab")}`);
         console.log(`  ${pc.cyan("[N]")}  NPM       ${pc.dim("npmjs.com/package/Weavetab")}`);
-        console.log(`  ${pc.cyan("[W]")}  Website   ${pc.dim("weavetab.pages.dev")}`);
+        console.log(`  ${pc.cyan("[W]")}  Website   ${pc.dim("weavetab.dev")}`);
         console.log();
         console.log(pc.dim("Awaiting command..."));
         process.stdin.setRawMode(true);
@@ -1063,10 +1165,10 @@ async function main() {
                 runMainUI();
             }
             if (k === "g") {
-                await open("https://github.com/Weavetab");
+                await open("https://github.com/weavetab");
             }
             if (k === "n") {
-                await open("https://npmjs.com/package/Weavetab");
+                await open("https://www.npmjs.com/package/@weavetab/mcp");
             }
             if (k === "w") {
                 await open("https://github.com/weavetab/mcp");
@@ -1076,7 +1178,7 @@ async function main() {
     }
     function runHelp() {
         const _require = createRequire(import.meta.url);
-        const version = _require("../package.json").version || "2.5.0";
+        const version = _require("../package.json").version || WEAVETAB_VERSION;
         console.clear();
         console.log(boxen(pc.cyan(`Weavetab v${version}`), { padding: 1, borderStyle: 'round', borderColor: 'cyan' }));
         console.log(pc.dim("Production-grade MCP server for Chrome DevTools Protocol"));
@@ -1087,14 +1189,21 @@ async function main() {
         console.log(pc.bold("COMMANDS"));
         console.log(`  ${pc.cyan("plugin")}        Manage Weavetab plugins (add, list, remove, search, browse, verify)`);
         console.log(`  ${pc.cyan("config")}        Launch the interactive configuration wizard`);
+        console.log(`  ${pc.cyan("skills")}        Install or update AI agent skills (@weavetab/skills)`);
         console.log(`  ${pc.cyan("view")}          Display the current active configuration`);
         console.log(`  ${pc.cyan("reset")}         Purge browser profiles, lockfiles, and orphan processes`);
-        console.log(`  ${pc.cyan("secrets")}       Manage blind-injected credentials (set, list, rm)`);
+        console.log(`  ${pc.cyan("secrets")}       Manage blind-injected credentials (set, list, rm, init)`);
         console.log(`  ${pc.cyan("reload-ext")}    Send a reload signal to the browser extension`);
+        console.log(`  ${pc.cyan("--ws")}          Start the WebSocket daemon (default port 3000, override with --port)`);
+        console.log(`  ${pc.cyan("--version")}     Print version and exit`);
         console.log(`  ${pc.cyan("help")}          Show this help message`);
         console.log();
+        console.log(pc.bold("AGENT SKILLS (@weavetab/skills)"));
+        console.log(`  ${pc.dim("Install/update skills:")} ${pc.cyan("npx -y @weavetab/skills@latest")}`);
+        console.log(`  ${pc.dim("Via CLI:")}               ${pc.cyan("weavetab skills [options]")}`);
+        console.log();
         console.log(pc.bold("PLUGIN COMMANDS (User)"));
-        console.log(`  ${pc.cyan("weavetab plugin add <pkg>")}         Install a plugin (resolves official @weavetab/plugin- & community)`);
+        console.log(`  ${pc.cyan("weavetab plugin add <pkg>")}         Install a plugin from npm (or a local path: ./my-plugin)`);
         console.log(`  ${pc.cyan("weavetab plugin browse")}            Interactive terminal explorer to browse & 1-click install`);
         console.log(`  ${pc.cyan("weavetab plugin search <query>")}    Search plugins across registry & npm`);
         console.log(`  ${pc.cyan("weavetab plugin list")}              List all installed Weavetab plugins and tools`);
@@ -1116,9 +1225,9 @@ async function main() {
         console.log(`  ${pc.cyan("WT_AGENT_ID")}       Agent identifier (auto-generated if unset)`);
         console.log();
         console.log(pc.bold("LINKS"));
-        console.log(`  ${pc.cyan("GitHub:")}  ${pc.dim("https://github.com/Weavetab")}`);
-        console.log(`  ${pc.cyan("npm:")}     ${pc.dim("https://npmjs.com/package/Weavetab")}`);
-        console.log(`  ${pc.cyan("Website:")} ${pc.dim("https://github.com/weavetab/mcp")}`);
+        console.log(`  ${pc.cyan("GitHub:")}  ${pc.dim("https://github.com/weavetab")}`);
+        console.log(`  ${pc.cyan("npm:")}     ${pc.dim("https://www.npmjs.com/package/@weavetab/mcp")}`);
+        console.log(`  ${pc.cyan("Website:")} ${pc.dim("https://weavetab.dev")}`);
         console.log();
     }
 }
@@ -1157,10 +1266,17 @@ async function runSecretsCommand(args) {
     const { secretStore } = await import("./security/secrets.js");
     const p = await import("@clack/prompts");
     if (args.length === 0) {
-        console.log(pc.red("[ERROR] Usage: weavetab secrets <set|list|rm> [key]"));
+        console.log(pc.red("[ERROR] Usage: weavetab secrets <set|list|rm|init> [key]"));
         process.exit(1);
     }
     const subcmd = args[0].toLowerCase();
+    if (subcmd === "init") {
+        const { initProjectSecrets } = await import("./security/secrets.js");
+        const filePath = initProjectSecrets();
+        console.log(pc.green(`[OK] Project secrets initialized: ${filePath}`));
+        console.log(pc.dim("Keys in this file take precedence over ~/.weavetab/secrets.json when Weavetab runs from this directory."));
+        return;
+    }
     if (subcmd === "list") {
         const list = await secretStore.listSecrets();
         console.log(boxen(pc.cyan("STORED SECRETS"), { padding: 1, borderStyle: 'round', borderColor: 'cyan' }));
@@ -1235,10 +1351,10 @@ async function runSecretsCommand(args) {
             }
         }
         await secretStore.setSecret(key, value, domains);
-        console.log(pc.green(`[OK] Secret "${key}" saved successfully.`));
+        console.log(pc.green(`[OK] Secret "${key}" saved.`));
         return;
     }
     console.log(pc.red(`[ERROR] Unknown secrets command: ${subcmd}`));
-    console.log(pc.red("Usage: weavetab secrets <set|list|rm> [key]"));
+    console.log(pc.red("Usage: weavetab secrets <set|list|rm|init> [key]"));
     process.exit(1);
 }

package/dist/intelligence/marks.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Weavetab — intelligence/marks.ts
+ * Visual grounding mark cache.
+ *
+ * When browser_map runs with visual: true/auto, numbered SoM badges are
+ * injected over the page, a screenshot is taken, and each badge's position
+ * and optional DOM ref are stored here. Interaction tools (browser_click,
+ * browser_pointer, etc.) can then resolve a { mark: N } argument directly
+ * to pixel coordinates without any further DOM walk.
+ *
+ * Weavetab by fy2ne
+ */
+export interface MarkEntry {
+    /** Center X coordinate (viewport-relative pixels). */
+    x: number;
+    /** Center Y coordinate (viewport-relative pixels). */
+    y: number;
+    /** Width of the element bounding box. */
+    width: number;
+    /** Height of the element bounding box. */
+    height: number;
+    /** Volatile ref ID (w:NN) if the element is DOM-backed. Undefined for canvas/visual-only regions. */
+    ref?: string;
+    /** Visible text or aria-label, if available. */
+    label?: string;
+    /** Element type hint. */
+    type?: "button" | "input" | "link" | "select" | "canvas_region" | "unknown";
+}
+/** Write a full set of marks for a tab. Replaces any previous marks. */
+export declare function marksSet(targetId: string, marks: Map<number, MarkEntry>): void;
+/** Look up a single mark for a tab. Returns null if not found. */
+export declare function marksGet(targetId: string, mark: number): MarkEntry | null;
+/** Clear all marks for a tab (called on navigation). */
+export declare function marksInvalidate(targetId: string): void;
+/** Return all marks for a tab (used for debugging / list output). */
+export declare function marksGetAll(targetId: string): Map<number, MarkEntry>;

package/dist/intelligence/marks.js

@@ -0,0 +1,30 @@
+/**
+ * Weavetab — intelligence/marks.ts
+ * Visual grounding mark cache.
+ *
+ * When browser_map runs with visual: true/auto, numbered SoM badges are
+ * injected over the page, a screenshot is taken, and each badge's position
+ * and optional DOM ref are stored here. Interaction tools (browser_click,
+ * browser_pointer, etc.) can then resolve a { mark: N } argument directly
+ * to pixel coordinates without any further DOM walk.
+ *
+ * Weavetab by fy2ne
+ */
+/** Per-tab: Map<targetId, Map<markNumber, MarkEntry>> */
+const store = new Map();
+/** Write a full set of marks for a tab. Replaces any previous marks. */
+export function marksSet(targetId, marks) {
+    store.set(targetId, marks);
+}
+/** Look up a single mark for a tab. Returns null if not found. */
+export function marksGet(targetId, mark) {
+    return store.get(targetId)?.get(mark) ?? null;
+}
+/** Clear all marks for a tab (called on navigation). */
+export function marksInvalidate(targetId) {
+    store.delete(targetId);
+}
+/** Return all marks for a tab (used for debugging / list output). */
+export function marksGetAll(targetId) {
+    return store.get(targetId) ?? new Map();
+}

package/dist/intelligence/patternCompiler.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Weavetab — intelligence/patternCompiler.ts
+ *
+ * Compiles raw browser session trails (action sequences) into persistent,
+ * reusable site workflow patterns stored under ~/.weavetab-system/memory/sites/.
+ *
+ * Design invariants:
+ *  - One file per origin (sanitized hostname). Never creates per-path or per-run files.
+ *  - Pattern names are caller-supplied (snake_case). Duplicate calls for the same
+ *    name on the same origin UPDATE the existing pattern rather than creating a new file.
+ *  - Volatile / unstable selectors (auto-generated classes, nth-child paths) are
+ *    stripped and replaced with semantic anchors where possible.
+ *  - Never reads or writes to ~/.weavetab/ (user config space).
+ */
+export interface WorkflowStep {
+    /** MCP tool name, e.g. "browser_click", "browser_fill", "browser_navigate" */
+    tool: string;
+    /** Primary selector or URL target */
+    target?: string;
+    /** Optional value (text typed, option selected, etc.) */
+    value?: string;
+    /** Any extra args forwarded verbatim to browser_burst replay */
+    extra?: Record<string, unknown>;
+}
+export interface WorkflowPattern {
+    /** Caller-assigned name in snake_case, e.g. "login_flow", "pr_review" */
+    name: string;
+    /** Compiled, stable steps ready for browser_burst replay */
+    steps: WorkflowStep[];
+    /** Optional CSS selector / URL fragment that confirms success */
+    success_indicator?: string;
+    /** URL path or pattern where this workflow starts, e.g. "/pull/:id/files" */
+    entry?: string;
+    /** Exponentially-weighted moving average of duration in ms */
+    avg_duration_ms?: number;
+    /** 0.0 – 1.0 reliability. Degrades on failures, climbs on successes. */
+    reliability: number;
+    /** Consecutive failure counter — 3 strikes triggers re-learn flag */
+    strikes: number;
+    /** ISO timestamp of last successful verified run */
+    last_verified: string;
+    /** Total times this pattern was executed */
+    total_executions: number;
+    /** Times the pattern completed without errors */
+    successful_executions: number;
+}
+export interface SiteQuirks {
+    cookie_banner?: {
+        selector: string;
+        action: string;
+        appears: "first_visit" | "always" | "random";
+    };
+    rate_limit?: {
+        threshold?: string;
+        recovery?: string;
+    };
+    modal_popups?: Array<{
+        trigger?: string;
+        dismiss_selector: string;
+    }>;
+    [key: string]: unknown;
+}
+export interface SiteProfile {
+    /** Full origin, e.g. "https://github.com" */
+    origin: string;
+    /** Detected JS framework: react, vue, angular, next, nuxt, svelte, etc. */
+    framework?: string;
+    /** True if the site uses Shadow DOM components */
+    shadowDom?: boolean;
+    /** How often this site presents CAPTCHA challenges */
+    captcha_frequency?: "none" | "rare" | "moderate" | "frequent";
+    /** Known site-level quirks to handle automatically */
+    quirks: SiteQuirks;
+    /** Named, compiled workflow patterns indexed by name */
+    patterns: Record<string, WorkflowPattern>;
+    /** ISO timestamp of last profile write */
+    updatedAt: string;
+    /** How many times this origin has been visited in automated sessions */
+    visitCount: number;
+}
+export declare function clearSiteProfileCache(): void;
+/**
+ * Load a site profile from disk. Returns null if the site has never been profiled.
+ * Hits in-process cache first — no redundant disk reads within a session.
+ */
+export declare function getSiteProfile(origin: string): Promise<SiteProfile | null>;
+/**
+ * Persist a site profile. Always deep-merges into existing data on disk — never
+ * blindly overwrites — so concurrent tool calls don't clobber each other.
+ */
+export declare function saveSiteProfile(profile: SiteProfile): Promise<void>;
+/**
+ * Learn or update a named workflow pattern for a given origin.
+ * - Duplicate name = merge/update, never duplicate file.
+ * - Volatile selectors in steps are dropped to keep patterns stable.
+ * - Anti-spam: skips disk write when content is identical to existing.
+ */
+export declare function learnPattern(origin: string, name: string, incoming: Partial<WorkflowPattern>): Promise<WorkflowPattern>;
+/**
+ * Record the outcome of executing a named pattern.
+ * Updates reliability via EWMA (α=0.15) and tracks consecutive strikes.
+ * 3 strikes → reliability will naturally fall below 0.4, agent should re-explore.
+ */
+export declare function recordPatternExecution(origin: string, patternName: string, success: boolean, durationMs?: number): Promise<WorkflowPattern | null>;
+/**
+ * Record or update a site quirk (cookie banner, rate limit, modal popup, etc.)
+ * Only writes if the stored data differs from incoming — prevents spam writes.
+ */
+export declare function recordQuirk(origin: string, quirkKey: string, quirkData: unknown): Promise<void>;
+/**
+ * Returns the reliability score (0–1) of a named pattern, or -1 if unknown.
+ */
+export declare function getPatternReliability(origin: string, patternName: string): Promise<number>;
+/**
+ * Formats a compact site profile hint string for agent system prompt injection.
+ * Called at session start when navigating to a known origin.
+ */
+export declare function formatSiteProfileHint(profile: SiteProfile): string;