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

package/dist/index.js

@@ -98,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.
@@ -363,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)" },
                 ]
@@ -702,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.")}`);
         }
@@ -1165,8 +1192,10 @@ async function main() {
         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)"));
@@ -1174,7 +1203,7 @@ async function main() {
         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`);
@@ -1198,7 +1227,7 @@ async function main() {
         console.log(pc.bold("LINKS"));
         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://github.com/weavetab/mcp")}`);
+        console.log(`  ${pc.cyan("Website:")} ${pc.dim("https://weavetab.dev")}`);
         console.log();
     }
 }
@@ -1237,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' }));
@@ -1319,6 +1355,6 @@ async function runSecretsCommand(args) {
         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/plugin/interface.d.ts

@@ -57,6 +57,7 @@ export interface WeavetabPermissions {
         reason?: string;
         [key: string]: any;
     };
+    /** @deprecated use `filesystem` */
     fs?: {
         read?: string[];
         write?: string[];
@@ -68,11 +69,19 @@ export interface WeavetabPermissions {
         reason?: string;
     };
     tools?: {
-        /** List of built-in tool names this plugin is permitted to override */
+        /** Must be true for the plugin to register any new MCP tools */
+        add?: boolean;
+        /** Explicit list of built-in tool names this plugin may override */
         override?: string[];
-        /** List of built-in tool names this plugin is permitted to remove */
+        /** Explicit list of built-in tool names this plugin may remove */
         remove?: string[];
-        hooks?: boolean;
+        reason?: string;
+    };
+    hooks?: {
+        onBeforeAction?: boolean;
+        onAfterAction?: boolean;
+        onDOMMutation?: boolean;
+        onPageNavigate?: boolean;
         reason?: string;
     };
     [key: string]: any;
@@ -121,8 +130,6 @@ export interface WeavetabManifest {
     engines?: Record<string, string>;
     /** Supported environments */
     environments?: string[];
-    /** Whether the plugin should be lazy-loaded on demand */
-    lazy?: boolean;
     /** Tools exposed by this plugin to the MCP server */
     tools?: WeavetabManifestTool[];
     /** Default configuration template */
@@ -236,6 +243,7 @@ export interface WeavetabPluginDefinition {
     overrides?: WeavetabToolOverride[];
     removeTools?: string[];
     defaultConfig?: Record<string, any>;
+    permissions?: WeavetabPermissions;
     onBeforeAction?: BeforeActionHook;
     onAfterAction?: AfterActionHook;
     onDOMMutation?: DOMMutationHook;
@@ -246,6 +254,7 @@ export interface WeavetabPlugin {
     name: string;
     version: string;
     description?: string;
+    permissions?: WeavetabPermissions;
     /** Add new tools */
     tools?: WeavetabToolDefinition[] | WeavetabPluginTool[];
     /** Override or wrap existing tools */

package/dist/plugin/loader.d.ts

@@ -21,9 +21,6 @@ export declare function inspectInstalledPackage(pkgDir: string): InstalledPlugin
  * Scan node_modules and return metadata for all installed Weavetab plugins.
  */
 export declare function listInstalledPlugins(pluginDir?: string): InstalledPluginInfo[];
-/**
- * Builds the canonical rich PluginContext for a loaded plugin.
- */
 export declare function buildPluginContext(plugin: WeavetabPlugin, storageManager: PluginStorageManager, extensionBridge: PluginExtensionBridge, pluginConfig: Record<string, any>, hooks: {
     beforeToolCall: Array<(toolName: string, args: Record<string, any>, session?: any) => Promise<any> | void>;
     afterToolCall: Array<(toolName: string, args: Record<string, any>, result: any, session?: any) => Promise<any> | void>;

package/dist/plugin/loader.js

@@ -27,9 +27,9 @@ function getNodeModulesDirs(customDir) {
 export function normalizePermissions(perms) {
     if (!perms)
         return {};
-    // Handle flat string array: ["browser.evaluate", "browser.navigate", "fs.read", ...]
+    // Handle flat string array: ["browser.evaluate", "tools.add", "tools", "fs.read", ...]
     if (Array.isArray(perms)) {
-        const normalized = { cdp: {}, fs: {}, extension: {} };
+        const normalized = { cdp: {}, fs: {}, filesystem: {}, extension: {}, tools: {}, hooks: {} };
         for (const item of perms) {
             if (typeof item !== "string")
                 continue;
@@ -39,10 +39,27 @@ export function normalizePermissions(perms) {
             }
             else if (cat === "fs" || cat === "filesystem") {
                 normalized.fs[sub || "read"] = ["*"];
+                normalized.filesystem[sub || "read"] = ["*"];
             }
             else if (cat === "extension" || cat === "hud") {
                 normalized.extension[sub || "hud"] = true;
             }
+            else if (cat === "tools") {
+                normalized.tools = normalized.tools || {};
+                if (!sub || sub === "add") {
+                    normalized.tools.add = true;
+                }
+            }
+            else if (cat === "hooks") {
+                normalized.hooks = normalized.hooks || {};
+                if (sub) {
+                    normalized.hooks[sub] = true;
+                }
+                else {
+                    normalized.hooks.onBeforeAction = true;
+                    normalized.hooks.onAfterAction = true;
+                }
+            }
         }
         return normalized;
     }
@@ -165,12 +182,11 @@ export function listInstalledPlugins(pluginDir) {
     }
     return results;
 }
-/**
- * Builds the canonical rich PluginContext for a loaded plugin.
- */
 export function buildPluginContext(plugin, storageManager, extensionBridge, pluginConfig, hooks) {
+    const perms = plugin.manifest?.permissions ?? {};
+    const pname = plugin.name;
     return {
-        name: plugin.name,
+        name: pname,
         version: plugin.version,
         pluginDir: storageManager.getDirectory(),
         config: pluginConfig,
@@ -178,34 +194,61 @@ export function buildPluginContext(plugin, storageManager, extensionBridge, plug
         extension: extensionBridge,
         mcp: {
             registerTool: (tool) => {
+                if (!perms.tools?.add) {
+                    console.error(`[Plugin: ${pname}] blocked registerTool("${tool?.name}"): permissions.tools.add not declared`);
+                    return;
+                }
                 plugin.tools = plugin.tools || [];
-                const existingIndex = plugin.tools.findIndex((t) => t.name === tool.name);
-                if (existingIndex >= 0) {
-                    plugin.tools[existingIndex] = tool;
+                const idx = plugin.tools.findIndex((t) => t.name === tool.name);
+                if (idx >= 0) {
+                    plugin.tools[idx] = tool;
                 }
                 else {
                     plugin.tools.push(tool);
                 }
             },
             overrideTool: (toolName, overrideHandler) => {
+                const allowed = perms.tools?.override ?? [];
+                if (!allowed.includes(toolName)) {
+                    console.error(`[Plugin: ${pname}] blocked overrideTool("${toolName}"): not listed in permissions.tools.override`);
+                    return;
+                }
                 plugin.overrides = plugin.overrides || [];
                 plugin.overrides.push({ name: toolName, handler: overrideHandler });
             },
             removeTool: (toolName) => {
+                const allowed = perms.tools?.remove ?? [];
+                if (!allowed.includes(toolName)) {
+                    console.error(`[Plugin: ${pname}] blocked removeTool("${toolName}"): not listed in permissions.tools.remove`);
+                    return;
+                }
                 plugin.removeTools = plugin.removeTools || [];
                 plugin.removeTools.push(toolName);
             },
             unregisterTool: (toolName) => {
+                const allowed = perms.tools?.remove ?? [];
+                if (!allowed.includes(toolName)) {
+                    console.error(`[Plugin: ${pname}] blocked unregisterTool("${toolName}"): not listed in permissions.tools.remove`);
+                    return;
+                }
                 plugin.removeTools = plugin.removeTools || [];
                 plugin.removeTools.push(toolName);
             },
         },
         hooks: {
             onBeforeAction: (fn) => {
+                if (!perms.hooks?.onBeforeAction) {
+                    console.error(`[Plugin: ${pname}] blocked onBeforeAction hook: permissions.hooks.onBeforeAction not declared`);
+                    return;
+                }
                 if (typeof fn === "function")
                     hooks.beforeToolCall.push(fn);
             },
             onAfterAction: (fn) => {
+                if (!perms.hooks?.onAfterAction) {
+                    console.error(`[Plugin: ${pname}] blocked onAfterAction hook: permissions.hooks.onAfterAction not declared`);
+                    return;
+                }
                 if (typeof fn === "function") {
                     hooks.afterToolCall.push(async (toolName, args, result, session) => {
                         return await fn(toolName, result, session, args);
@@ -213,18 +256,34 @@ export function buildPluginContext(plugin, storageManager, extensionBridge, plug
                 }
             },
             onDOMMutation: (fn) => {
+                if (!perms.hooks?.onDOMMutation) {
+                    console.error(`[Plugin: ${pname}] blocked onDOMMutation hook: permissions.hooks.onDOMMutation not declared`);
+                    return;
+                }
                 if (typeof fn === "function")
                     hooks.onDOMMutation?.push(fn);
             },
             beforeToolCall: (fn) => {
+                if (!perms.hooks?.onBeforeAction) {
+                    console.error(`[Plugin: ${pname}] blocked beforeToolCall hook: permissions.hooks.onBeforeAction not declared`);
+                    return;
+                }
                 if (typeof fn === "function")
                     hooks.beforeToolCall.push(fn);
             },
             afterToolCall: (fn) => {
+                if (!perms.hooks?.onAfterAction) {
+                    console.error(`[Plugin: ${pname}] blocked afterToolCall hook: permissions.hooks.onAfterAction not declared`);
+                    return;
+                }
                 if (typeof fn === "function")
                     hooks.afterToolCall.push(fn);
             },
             onPageNavigate: (fn) => {
+                if (!perms.hooks?.onPageNavigate) {
+                    console.error(`[Plugin: ${pname}] blocked onPageNavigate hook: permissions.hooks.onPageNavigate not declared`);
+                    return;
+                }
                 if (typeof fn === "function")
                     hooks.onPageNavigate.push(fn);
             },
@@ -237,10 +296,10 @@ export function buildPluginContext(plugin, storageManager, extensionBridge, plug
             recordQuirk: (origin, quirkKey, quirkData) => recordQuirk(origin, quirkKey, quirkData),
         },
         logger: {
-            info: (...args) => console.error(`[Plugin: ${plugin.name}] [INFO]`, ...args),
-            warn: (...args) => console.error(`[Plugin: ${plugin.name}] [WARN]`, ...args),
-            error: (...args) => console.error(`[Plugin: ${plugin.name}] [ERROR]`, ...args),
-            debug: (...args) => console.error(`[Plugin: ${plugin.name}] [DEBUG]`, ...args),
+            info: (...args) => console.error(`[Plugin: ${pname}] [INFO]`, ...args),
+            warn: (...args) => console.error(`[Plugin: ${pname}] [WARN]`, ...args),
+            error: (...args) => console.error(`[Plugin: ${pname}] [ERROR]`, ...args),
+            debug: (...args) => console.error(`[Plugin: ${pname}] [DEBUG]`, ...args),
         },
     };
 }
@@ -288,7 +347,10 @@ function tryLoadPlugin(pkgDir) {
         }
         const pluginModule = require(resolvedEntry);
         const plugin = pluginModule.default || pluginModule.plugin || pluginModule;
-        const normalizedPerms = normalizePermissions(manifest.permissions);
+        const rawPerms = Array.isArray(manifest.permissions)
+            ? manifest.permissions
+            : { ...(plugin?.permissions || {}), ...(manifest?.permissions || {}) };
+        const normalizedPerms = normalizePermissions(rawPerms);
         if (plugin &&
             (Array.isArray(plugin.tools) ||
                 Array.isArray(plugin.overrides) ||
@@ -302,9 +364,10 @@ function tryLoadPlugin(pkgDir) {
             plugin.version = plugin.version || manifest.version || pkg.version || "1.0.0";
             plugin.description = plugin.description || manifest.description || pkg.description || "";
             plugin.manifest = manifest;
+            plugin.permissions = normalizedPerms;
+            plugin.manifest.permissions = normalizedPerms;
             plugin.tools = Array.isArray(plugin.tools) ? plugin.tools : [];
             plugin.overrides = Array.isArray(plugin.overrides) ? plugin.overrides : [];
-            plugin.manifest.permissions = normalizedPerms;
             plugin.removeTools = Array.isArray(plugin.removeTools)
                 ? plugin.removeTools
                 : normalizedPerms.tools?.remove || [];

package/dist/plugin/registry.d.ts

@@ -19,7 +19,8 @@ export interface PluginCandidate {
     description?: string;
 }
 export declare const OFFICIAL_PLUGIN_PREFIX = "@weavetab/plugin-";
-export declare const REGISTRY_URL = "https://raw.githubusercontent.com/weavetab/registry/main/verified.json";
+export declare const REGISTRY_URL = "https://weavetab.dev/api/registry/verified.json";
+export declare const REGISTRY_FALLBACK_URL = "https://raw.githubusercontent.com/weavetab/registry/main/verified.json";
 /**
  * Returns the set of verified package names.
  * - Tries local registry/verified.json first (dev/test mode).

package/dist/plugin/registry.js

@@ -18,8 +18,9 @@ const __dirname = dirname(__filename);
 // Verification Registry
 // ---------------------------------------------------------------------------
 export const OFFICIAL_PLUGIN_PREFIX = "@weavetab/plugin-";
-// The production remote URL — points to weavetab/registry on GitHub.
-export const REGISTRY_URL = "https://raw.githubusercontent.com/weavetab/registry/main/verified.json";
+// The production remote URLs — weavetab.dev (D1-backed) primary, GitHub raw fallback.
+export const REGISTRY_URL = "https://weavetab.dev/api/registry/verified.json";
+export const REGISTRY_FALLBACK_URL = "https://raw.githubusercontent.com/weavetab/registry/main/verified.json";
 // Local override: when this file exists at the root of the repo, we use it instead
 // of the remote URL. This allows full offline/local testing.
 const LOCAL_REGISTRY_PATH = join(__dirname, "..", "..", "..", "registry", "verified.json");
@@ -59,16 +60,24 @@ function loadLocalRegistry() {
     return null;
 }
 async function fetchRemoteRegistry() {
-    const res = await fetch(REGISTRY_URL, {
-        signal: AbortSignal.timeout(5000),
-        headers: { "User-Agent": "Weavetab-Registry-Check/1.0" },
-    });
-    if (!res.ok)
-        throw new Error(`registry fetch failed: ${res.status}`);
-    const data = await res.json();
-    if (!Array.isArray(data.verified))
-        throw new Error("invalid registry format");
-    return extractPackageNames(data.verified);
+    for (const url of [REGISTRY_URL, REGISTRY_FALLBACK_URL]) {
+        try {
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(5000),
+                headers: { "User-Agent": "Weavetab-Registry-Check/1.0" },
+            });
+            if (!res.ok)
+                continue;
+            const data = await res.json();
+            if (!Array.isArray(data.verified))
+                continue;
+            return extractPackageNames(data.verified);
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("registry fetch failed: all sources unreachable");
 }
 /**
  * Returns the set of verified package names.

package/dist/security/secrets.d.ts

@@ -18,6 +18,12 @@ export interface SecretListEntry {
     updatedAt: string;
 }
 export declare const GLOBAL_SECRETS_PATH: string;
+export declare const PROJECT_SECRETS_DIRNAME = ".weavetab";
+export declare const PROJECT_SECRETS_FILENAME = "secrets.json";
+/** Absolute path of the project-scoped secrets file for a directory (default: cwd). */
+export declare function getProjectSecretsPath(cwd?: string): string;
+/** Creates an empty project-scoped secrets file (chmod 600). Returns its path. */
+export declare function initProjectSecrets(cwd?: string): string;
 declare class JsonSecretStoreImpl implements SecretProvider {
     /**
      * Resolve a secret value by key.

package/dist/security/secrets.js

@@ -86,7 +86,31 @@ function decrypt(ciphertext) {
 import { GLOBAL_CONFIG_DIR } from "../config/loader.js";
 // ─── Path resolution ──────────────────────────────────────────────────────────
 export const GLOBAL_SECRETS_PATH = path.join(GLOBAL_CONFIG_DIR, "secrets.json");
+export const PROJECT_SECRETS_DIRNAME = ".weavetab";
+export const PROJECT_SECRETS_FILENAME = "secrets.json";
+/** Absolute path of the project-scoped secrets file for a directory (default: cwd). */
+export function getProjectSecretsPath(cwd = process.cwd()) {
+    return path.join(cwd, PROJECT_SECRETS_DIRNAME, PROJECT_SECRETS_FILENAME);
+}
+/** Creates an empty project-scoped secrets file (chmod 600). Returns its path. */
+export function initProjectSecrets(cwd = process.cwd()) {
+    const filePath = getProjectSecretsPath(cwd);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, JSON.stringify({ version: 1, secrets: {} }, null, 2), { mode: 0o600 });
+    }
+    return filePath;
+}
 function resolveSecretsPath() {
+    // Project-scoped file wins when present — lets a checkout carry its own keys.
+    try {
+        const projectPath = getProjectSecretsPath();
+        if (fs.existsSync(projectPath))
+            return projectPath;
+    }
+    catch {
+        // fall through to global
+    }
     return GLOBAL_SECRETS_PATH;
 }
 // ─── Permission guard ─────────────────────────────────────────────────────────

package/dist/server.js

@@ -53,7 +53,7 @@ import { browserCheckpoint } from "./tools/checkpoint.js";
 import { getActiveEngine } from "./cdp/connector.js";
 import { resetLoopCounter } from "./intelligence/trail.js";
 import { getSiteProfile, learnPattern, recordPatternExecution, recordQuirk, getPatternReliability, formatSiteProfileHint } from "./intelligence/patternCompiler.js";
-import { discoverPlugins, listInstalledPlugins, loadPluginByName } from "./plugin/loader.js";
+import { discoverPlugins } from "./plugin/loader.js";
 import { hookPipeline } from "./plugin/pipeline.js";
 import { agentAction } from "./sensors/pacing.js";
 import { getCachedConfig, getElectronApps } from "./config/loader.js";
@@ -1701,22 +1701,32 @@ DO NOT use browser_scrape or browser_map for binary documents — they cannot re
         }
         // 1. Tool Removals (disable built-in tools)
         const manifestPerms = plugin.manifest?.permissions;
-        const manifestToolsRemove = Array.isArray(manifestPerms)
+        const declaredRemove = Array.isArray(manifestPerms)
             ? []
             : manifestPerms?.tools?.remove || [];
         const toRemove = [
             ...(plugin.removeTools || []),
-            ...manifestToolsRemove,
         ];
         for (const toolName of toRemove) {
+            if (!declaredRemove.includes(toolName)) {
+                process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} tried to remove "${toolName}" but it's not listed in permissions.tools.remove — skipped.\x1b[0m\n`);
+                continue;
+            }
             if (server._registeredTools?.[toolName]) {
                 delete server._registeredTools[toolName];
                 removedNames.push(toolName);
             }
         }
         // 2. Tool Overrides (replace or wrap built-in tools)
+        const declaredOverride = Array.isArray(manifestPerms)
+            ? []
+            : manifestPerms?.tools?.override || [];
         const overrides = plugin.overrides || [];
         for (const ov of overrides) {
+            if (!declaredOverride.includes(ov.name)) {
+                process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} tried to override "${ov.name}" but it's not listed in permissions.tools.override — skipped.\x1b[0m\n`);
+                continue;
+            }
             const existingTool = server._registeredTools?.[ov.name];
             const existingDesc = existingTool?.description || "";
             const existingSchema = existingTool?.parameters?.shape || {};
@@ -1745,8 +1755,13 @@ DO NOT use browser_scrape or browser_map for binary documents — they cannot re
             overriddenNames.push(ov.name);
         }
         // 3. Tool Additions (new tools)
+        const canAdd = !Array.isArray(manifestPerms) && manifestPerms?.tools?.add === true;
         const newTools = plugin.tools || [];
         for (const td of newTools) {
+            if (!canAdd) {
+                process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} tried to add tool "${td.name}" but permissions.tools.add is not declared — skipped.\x1b[0m\n`);
+                continue;
+            }
             if (server._registeredTools?.[td.name]) {
                 process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} registered tool "${td.name}" which replaced an existing tool.\x1b[0m\n`);
                 delete server._registeredTools[td.name];
@@ -1768,6 +1783,10 @@ DO NOT use browser_scrape or browser_map for binary documents — they cannot re
         const fullPluginCtx = plugin._context;
         if (fullPluginCtx && fullPluginCtx.mcp) {
             fullPluginCtx.mcp.registerTool = (tool) => {
+                if (!canAdd) {
+                    process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} dynamic registerTool("${tool?.name}"): permissions.tools.add not declared — skipped.\x1b[0m\n`);
+                    return;
+                }
                 if (server._registeredTools?.[tool.name]) {
                     process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} dynamic tool "${tool.name}" replaced an existing tool.\x1b[0m\n`);
                     delete server._registeredTools[tool.name];
@@ -1780,6 +1799,10 @@ DO NOT use browser_scrape or browser_map for binary documents — they cannot re
                 });
             };
             fullPluginCtx.mcp.overrideTool = (toolName, overrideHandler) => {
+                if (!declaredOverride.includes(toolName)) {
+                    process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} dynamic overrideTool("${toolName}"): not in permissions.tools.override — skipped.\x1b[0m\n`);
+                    return;
+                }
                 const existingTool = server._registeredTools?.[toolName];
                 if (existingTool) {
                     delete server._registeredTools[toolName];
@@ -1799,11 +1822,19 @@ DO NOT use browser_scrape or browser_map for binary documents — they cannot re
                 });
             };
             fullPluginCtx.mcp.removeTool = (toolName) => {
+                if (!declaredRemove.includes(toolName)) {
+                    process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} dynamic removeTool("${toolName}"): not in permissions.tools.remove — skipped.\x1b[0m\n`);
+                    return;
+                }
                 if (server._registeredTools?.[toolName]) {
                     delete server._registeredTools[toolName];
                 }
             };
             fullPluginCtx.mcp.unregisterTool = (toolName) => {
+                if (!declaredRemove.includes(toolName)) {
+                    process.stderr.write(`  \x1b[33m[!] Plugin ${plugin.name} dynamic unregisterTool("${toolName}"): not in permissions.tools.remove — skipped.\x1b[0m\n`);
+                    return;
+                }
                 if (server._registeredTools?.[toolName]) {
                     delete server._registeredTools[toolName];
                 }
@@ -1830,38 +1861,10 @@ DO NOT use browser_scrape or browser_map for binary documents — they cannot re
             // Ignore if client doesn't support it or not connected yet
         }
     };
-    // Add the built-in ecosystem tools
-    server.tool("list_plugins", "List all available Weavetab plugins that can be loaded.", {}, async () => {
-        const installed = listInstalledPlugins();
-        const available = installed
-            .filter(info => !loadedPluginNames.has(info.packageName))
-            .map(info => `- ${info.packageName}: ${info.manifest?.description || "No description"}`);
-        if (available.length === 0) {
-            return { content: [{ type: "text", text: "No un-loaded plugins available." }] };
-        }
-        return { content: [{ type: "text", text: `Available plugins:\n${available.join("\n")}\n\nUse load_plugin with the plugin package name to load one.` }] };
-    });
-    server.tool("load_plugin", "Load any Weavetab plugin dynamically by npm package name (e.g. '@fy2ne/wt-youtube', 'my-plugin').", {
-        name: z.string().describe("The exact npm package name of the plugin to load (e.g. '@fy2ne/wt-youtube', 'my-plugin')")
-    }, async ({ name }) => {
-        if (loadedPluginNames.has(name)) {
-            return { content: [{ type: "text", text: `Plugin ${name} is already loaded.` }] };
-        }
-        const plugin = loadPluginByName(name);
-        if (!plugin) {
-            return { content: [{ type: "text", text: `Plugin "${name}" not found. Make sure it is installed via "weavetab plugin add ${name}".` }] };
-        }
-        await registerPluginTools(plugin);
-        const toolsList = (plugin.tools || []).map((t) => t.name).join(", ");
-        return { content: [{ type: "text", text: `loaded plugin ${name}. Tools registered: ${toolsList || "(dynamic tools registered)"}` }] };
-    });
-    // Auto-load plugins by default unless explicitly marked with lazy: true
+    // Auto-load all installed plugins at startup
     const allPlugins = discoverPlugins();
     for (const plugin of allPlugins) {
-        const isExplicitlyLazy = plugin.manifest?.lazy === true;
-        if (!isExplicitlyLazy) {
-            await registerPluginTools(plugin);
-        }
+        await registerPluginTools(plugin);
     }
     let transport;
     if (transportMode === "ws") {

package/dist/tools/browser_detect.js

@@ -10,7 +10,7 @@ const ENGINE_COVERAGE = {
             "browser_network_intercept",
             "browser_viewport",
             "browser_recording",
-            "browser_thought",
+            "browser_thoughts",
             "browser_highlight",
             "browser_inspect",
             "browser_snapshot",
@@ -24,7 +24,7 @@ const ENGINE_COVERAGE = {
             "browser_network_intercept",
             "browser_viewport",
             "browser_recording",
-            "browser_thought",
+            "browser_thoughts",
             "browser_highlight",
             "browser_inspect",
             "browser_snapshot",

package/dist/tools/captcha.js

@@ -111,7 +111,7 @@ export async function browserCaptcha(session, args, _config) {
                         user_instructions: solution.userInstructions,
                         next_action: isVisionAssisted
                             ? "Take a screenshot to view the CAPTCHA, then use browser_click or browser_type to solve it yourself. Do not ask the user for help."
-                            : `Call browser_thought({ action: "question", message: "${solution.userInstructions}" }) to ask the user to complete it, then call browser_captcha({ action: "wait_for_user" }).`,
+                            : `Call browser_thoughts({ action: "question", message: "${solution.userInstructions}" }) to ask the user to complete it, then call browser_captcha({ action: "wait_for_user" }).`,
                         execution_ms: Date.now() - t0,
                     };
                 }

package/dist/tools/navigate.d.ts

@@ -1,5 +1,5 @@
 /**
- * Weavetab — tools/navigate.ts
+ * Weavetab — tools/navigate.ts
  * URL navigation with domain blocklist enforcement and post-navigation DOM stability wait.
  * Weavetab by fy2ne
  */