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

package/docs/desktop-automation/electron-apps.md

@@ -0,0 +1,217 @@
+---
+title: "Desktop & Electron Apps"
+description: "Native Layer 0 automation for VS Code, Discord, Figma, Slack, and any Electron app."
+product: mcp
+section: desktop-automation
+badge: new
+icon: AppWindow
+slug: electron-apps
+---
+
+# Desktop & Electron Application Automation
+
+Weavetab is a **universal Layer 0 agent runtime**. In addition to standard Chromium web browsing, Weavetab gives AI agents direct, native CDP control over **any desktop Electron application** — including Discord, VS Code, Figma, Slack, Obsidian, Postman, Notion, Spotify, and custom internal tools.
+
+## How It Works
+
+Because modern desktop applications are built on the Chromium/Electron framework, Weavetab can communicate with them directly over CDP WebSocket without requiring separate drivers or UI automation bridges.
+
+```text
+AI Agent (MCP) ──► withSecurity()
+                     ├── (Default) ─────────► CDP:9222 ──► Google Chrome / Chromium
+                     ├── (app: "discord") ──► CDP:9223 ──► Discord Desktop
+                     ├── (app: "figma")   ──► CDP:9224 ──► Figma Desktop
+                     └── (app: "vscode")  ──► CDP:9225 ──► VS Code Desktop
+```
+
+### Dual-Port Concurrency & Multi-Target Sessions
+- **Concurrent Execution**: Web browser sessions and Electron desktop app sessions run side-by-side on independent CDP ports (e.g. port `9222` for Chrome, `9223` for Discord, `9224` for Figma).
+- **Zero Session Clobbering**: Switching between a browser tab and a desktop app does not close, disconnect, or reload either target.
+- **Unified Tool Interface**: Pass `"app": "<appName>"` to any Weavetab tool to target that desktop application. Omit `app` to target the active web browser.
+
+---
+
+## Interactive App Configurator & Agent Generator
+
+Use the interactive configurator below to customize your desktop applications. Select presets or add custom apps, toggle between executable path strings, remote debug ports, or advanced objects, and copy the ready-to-use JSON or an automated setup prompt for your AI coding agent:
+
+```electron-configurator
+```
+
+---
+
+## 1. Configuring Desktop Apps in `config.json`
+
+Add an `"electron"` object to your local `./.weavetab/config.json` or global `~/.weavetab/config.json`:
+
+```json
+{
+  "electron": {
+    "discord": "C:\\Users\\username\\AppData\\Local\\Discord\\app-<version>\\Discord.exe",
+    "vscode": 9222,
+    "figma": {
+      "path": "C:\\Users\\username\\AppData\\Local\\Figma\\Figma.exe",
+      "port": 9224,
+      "url": "https://www.figma.com",
+      "args": ["--enable-features=WebRTCPipeWireCapturer"]
+    },
+    "slack": "/Applications/Slack.app/Contents/MacOS/Slack",
+    "obsidian": "/usr/bin/obsidian"
+  }
+}
+```
+
+### Configuration Formats Supported
+
+| Format | Example | Description |
+|---|---|---|
+| **Executable Path String** | `"discord": "C:\\path\\to\\Discord.exe"` | Automatically launches the binary on an isolated port and dedicated profile. |
+| **Port Number** | `"vscode": 9222` | Attaches directly to an already-running instance started with `--remote-debugging-port=9222`. |
+| **Full Configuration Object** | `"figma": { "path": "...", "port": 9224, "url": "..." }` | Custom control over binary path, debug port, initial launch URL, custom profile directory, and startup CLI args. |
+
+---
+
+## 2. Security & Profile Isolation
+
+Weavetab enforces enterprise-grade sandbox separation for all desktop applications:
+
+1. **Dedicated User Profiles**: Automated sessions are assigned isolated data profiles under `~/.weavetab-system/apps/<appName>/`.
+2. **Real AppData Protection**: Weavetab strictly enforces `assertNotRealElectronProfile` — attempting to target your primary OS user data directories (`%APPDATA%`, `~/Library/Application Support`, or `~/.config`) is blocked to protect your personal logins and local databases from accidental automation corruption.
+3. **Lock & Mutex Isolation**: Dedicated lockfiles (`~/.weavetab-system/locks/<appName>.lock`) ensure concurrent agent operations never conflict.
+
+---
+
+## 3. Supported Desktop Schemes & Protocols
+
+Weavetab automatically allows and whitelist-bypasses desktop internal protocols:
+- `app://` (Electron internal resources)
+- `vscode-webview://` / `vscode-file://` (VS Code extensions and webviews)
+- `discord://` / `slack://` (Deep-links)
+- `devtools://` / `chrome://` / `about:`
+- `file:///` (Local files)
+
+---
+
+## 4. How Agents Interact with Desktop Apps
+
+To target an Electron application, simply pass the `app` argument to any Weavetab tool:
+
+### A. Inspect Desktop DOM Tree
+```json
+{
+  "name": "browser_map",
+  "arguments": {
+    "app": "discord",
+    "scope": "main_content"
+  }
+}
+```
+
+### B. Click & Type in Desktop Apps
+```json
+{
+  "name": "browser_click",
+  "arguments": {
+    "ref": "w:42",
+    "app": "discord"
+  }
+}
+```
+
+```json
+{
+  "name": "browser_type",
+  "arguments": {
+    "ref": "w:45",
+    "text": "Automated build passed successfully! 🚀",
+    "app": "discord"
+  }
+}
+```
+
+### C. Multi-Target Burst Orchestration
+```json
+{
+  "name": "browser_burst",
+  "arguments": {
+    "app": "vscode",
+    "steps": [
+      { "action": "click_and_wait", "selector": ".monaco-editor" },
+      { "action": "type_and_send", "text": "npm test" }
+    ]
+  }
+}
+```
+
+---
+
+## 5. Launching Existing Desktop Apps in Debug Mode
+
+If you prefer to attach Weavetab to your existing desktop app instance:
+
+```bash
+# Launch VS Code with CDP debugging enabled
+code --remote-debugging-port=9222
+
+# Launch Obsidian with CDP debugging enabled
+obsidian --remote-debugging-port=9225
+
+# Launch Discord with CDP debugging enabled
+discord --remote-debugging-port=9223
+```
+Then in your `config.json`, simply map `"vscode": 9222` or `"obsidian": 9225`.
+
+---
+
+## 6. Environment Discovery Handshake (`browser_detect`)
+
+`browser_detect` is the foundational tool agents invoke upon initial engagement. It inspects local browsers and configured desktop applications, returning their real-time state:
+
+```json
+{
+  "available": [
+    { "engine": "chromium", "name": "Google Chrome", "path": "C:\\Program Files\\...\\chrome.exe" }
+  ],
+  "current": "chromium",
+  "configuredApps": [
+    {
+      "name": "discord",
+      "status": "running_no_debug",
+      "configuredPath": "C:\\Users\\username\\AppData\\Local\\Discord\\app-1.0.9256\\Discord.exe"
+    },
+    {
+      "name": "slack",
+      "status": "connected",
+      "port": 9222,
+      "configuredPath": "C:\\Users\\username\\AppData\\Local\\slack\\app-4.38.125\\slack.exe",
+      "activeTabs": [
+        { "id": "PAGE_1", "title": "general - Slack", "url": "https://app.slack.com/client/..." }
+      ]
+    },
+    {
+      "name": "vscode",
+      "status": "offline",
+      "configuredPath": "C:\\Users\\username\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe"
+    }
+  ]
+}
+```
+
+### Application Lifecycle States:
+- **`connected`**: The app is running with CDP remote debugging active and Weavetab is attached. Agents can immediately operate tabs/windows using `"app": "<name>"`.
+- **`running_no_debug`**: The app process is currently running on the OS, but was opened by the user without `--remote-debugging-port`. Weavetab alerts the agent that DOM interactions are blocked until the app is launched or restarted with debugging flags.
+- **`offline`**: The process is not running. Calling `browser_navigate(app: "<name>")` launches and connects the app automatically.
+
+### Windows Squirrel Auto-Path Resolution:
+On Windows, applications like Discord and Slack install inside versioned folders (e.g. `Discord\app-1.0.9256\Discord.exe`) that change on every background update. Weavetab dynamically resolves the newest `app-1.0.xxxx` version at launch time, eliminating broken path errors after silent background updates.
+
+---
+
+## 7. Smart Domain Routing & Sticky Context
+
+To ensure external AI agents do not accidentally trigger a web browser launch when intending to control an Electron application:
+
+1. **Automatic Domain Routing**: When `browser_navigate` or `browser_tabs(action: "open")` receives an app domain (e.g. `discord.com`, `slack.com`, `linear.app`, `notion.so`), Weavetab automatically routes the target to the configured desktop application.
+2. **Sticky App Sessions**: When an agent operates inside an Electron app, the target session context remains sticky. Subsequent calls to `browser_tabs` or DOM tools stick to that active desktop app without spawning an unwanted Chrome window.
+3. **Explicit Browser Targeting**: When the agent specifically intends to use the web browser, passing `"app": "browser"` overrides desktop routing and directs operations to the web browser.
+

package/docs/get-started/installation.md

@@ -0,0 +1,47 @@
+---
+title: "Installation"
+description: "Install Weavetab globally or run it ad-hoc with npx."
+product: mcp
+section: get-started
+icon: Download
+slug: installation
+---
+
+# Installation
+
+```bash
+# Global installation (recommended)
+npm install -g @weavetab/mcp@latest
+
+# Or run directly without installation
+npx -y @weavetab/mcp@latest
+
+# Install Developer SDK as dev dependency in a project
+npm install -D @weavetab/sdk@latest
+
+# Verify installation
+weavetab --version
+# → @weavetab/mcp 2.5.0
+```
+
+## System Requirements
+
+- **Node.js** >= 18.0.0 (Node 20 or 22 LTS recommended)
+- **Chromium-based browser** (Google Chrome, Microsoft Edge, Brave, or Chromium)
+- *Optional:* Firefox or Safari Technology Preview via `browserType` config
+- *Optional for Desktop Automation:* Any Electron application (Discord, VS Code, Figma, Obsidian, Postman, etc.)
+
+## CLI Binary Aliases
+
+```bash
+weavetab          # standard binary
+Weavetab          # case-insensitive alias
+```
+
+## What Gets Configured
+
+Weavetab ships as a single, self-contained Node package. On first run it:
+
+1. Auto-detects an installed Chromium binary on `$PATH`
+2. Creates `~/.weavetab/` for global configuration, secrets, and policy rules
+3. Registers a local MCP entry point that clients launch over stdio or WebSocket

package/docs/get-started/introduction.md

@@ -0,0 +1,60 @@
+---
+title: "Introduction"
+description: "What Weavetab is, Layer 0 CDP architecture, and design tenets."
+product: mcp
+section: get-started
+icon: BookOpen
+slug: introduction
+---
+
+# Introduction
+
+Weavetab is a production-grade, local **Model Context Protocol (MCP) server** that grants AI agents human-like control over Chromium browsers and native **Electron desktop applications** (VS Code, Discord, Slack, Figma, Obsidian, Postman, Antigravity IDE, etc.) — communicating directly over the **Chrome DevTools Protocol (CDP)** at Layer 0.
+
+No WebDriver. No browser binary downloads. No Playwright or Puppeteer abstraction layer. No cloud dependency. Tool invocations resolve in **3–8 ms** of mean latency.
+
+## Synchronized Ecosystem Releases
+
+Both **`@weavetab/mcp`** and the **`@weavetab/sdk`** share synchronized release lines. Every capability introduced in the core runtime is immediately available in the developer SDK with 100% type safety and zero version mismatch.
+
+```bash
+# Install core Weavetab MCP server globally
+npm install -g @weavetab/mcp@latest
+
+# Or run directly via npx
+npx -y @weavetab/mcp@latest
+
+# Install Weavetab Developer SDK as a dev dependency
+npm install -D @weavetab/sdk@latest
+```
+
+## Design Tenets
+
+| Tenet | Implementation |
+|---|---|
+| **Ultra-Low Latency** | Sub-10 ms tool execution via direct CDP WebSocket connections |
+| **Universal Control** | Native orchestration across Chromium web tabs and any Electron desktop app |
+| **Autonomous CAPTCHA** | Zero-API solving (Cloudflare Turnstile, GeeTest, reCAPTCHA) via human Bézier mouse physics |
+| **Security & RBAC** | 4-tier RBAC + domain policies + Blind Credential Injection + profile isolation |
+| **Token Efficiency** | Semantic Delta diffing (up to 97% reduction) + intelligent DOM pruning |
+| **Stealth & Physics** | Ghost Cursor (Bézier curves), human typing jitter, and CDP early-script fingerprint spoofing |
+| **Self-Learning** | Per-domain session memory, framework detection, and automated loop recovery |
+| **Zero Cloud** | Pure local computation. No external telemetry or cloud tracking unless explicitly opted in |
+
+## What You Get
+
+- **49 built-in MCP tools** covering DOM vision, input synthesis, desktop apps, tabs, network interception, office files, design extraction, and plugin lifecycle
+- **Universal Desktop App Runtime** — control Chrome and native Electron apps (Discord, Figma, VS Code) side-by-side without port conflicts
+- **Autonomous Zero-API CAPTCHA Solver** — solve Cloudflare Turnstile, GeeTest, and reCAPTCHA locally via CDP mouse physics with $0 API costs
+- **Two transport modes** — stdio (Claude Desktop, Cursor, VS Code, Windsurf, Antigravity) and WebSocket (`--ws --port 3000`)
+- **Four RBAC roles** — `admin`, `operator`, `viewer`, and `automation`
+- **Per-domain policies** — ring-fences sensitive banking, internal, and production surfaces
+- **Blind Injection** — credentials resolved server-side from `secrets.json` and never exposed to the LLM
+- **Extensible Plugin System** — auto-discovers and mounts custom MCP tools from `node_modules`
+
+## Next Steps
+
+- **[Quickstart](quickstart.md)** — install and run a first mission in 60 seconds
+- **[Desktop & Electron Apps](../desktop-automation/electron-apps.md)** — configure and control desktop apps
+- **[Autonomous CAPTCHA Solver](../captcha-stealth/captcha-solver.md)** — zero-API anti-bot solving
+- **[MCP Tools Reference](../tools/tools.md)** — full reference for all 49 built-in automation tools

package/docs/get-started/quickstart.md

@@ -0,0 +1,54 @@
+---
+title: "Quickstart"
+description: "Install, configure, and run a first mission in under a minute."
+product: mcp
+section: get-started
+icon: Zap
+slug: quickstart
+---
+
+# Quickstart
+
+Get Weavetab attached to your agent and running a real browser mission in three simple steps.
+
+## 1. Install Weavetab
+
+```bash
+# Global installation (recommended)
+npm install -g @weavetab/mcp@latest
+
+# Or run directly with npx
+npx -y @weavetab/mcp@latest
+```
+
+## 2. Wire to your MCP Client
+
+Point any MCP-compatible client (Claude Desktop, Cursor, Windsurf, VS Code, Antigravity) at the binary:
+
+```json
+{
+  "mcpServers": {
+    "weavetab": {
+      "command": "weavetab"
+    }
+  }
+}
+```
+
+## 3. Run a First Mission
+
+Use `browser_burst` to chain multiple actions in a single round-trip:
+
+```json
+{
+  "name": "browser_burst",
+  "arguments": {
+    "steps": [
+      { "action": "navigate_and_read", "url": "https://example.com" },
+      { "action": "click_and_wait", "selector": "#login-btn" }
+    ]
+  }
+}
+```
+
+You will see the browser launch, the Ghost Cursor glide across the page along human Bézier curves, and the agent complete the task with sub-10ms CDP execution.

package/docs/get-started/setup-wizard.md

@@ -0,0 +1,26 @@
+---
+title: "Setup Wizard"
+description: "Interactive wizard that writes a clean config.json."
+product: mcp
+section: get-started
+icon: Wand2
+slug: setup-wizard
+---
+
+# Setup Wizard
+
+Run the interactive CLI configuration wizard:
+
+```bash
+weavetab config
+```
+
+The wizard walks through every option across 5 interactive phases. Re-run it at any time to update your saved config.
+
+## Wizard Phases
+
+1. **Phase 1 — Essentials:** Browser path, RBAC role (`admin`, `operator`, `viewer`, `automation`), headless mode, dev mode, max tabs, actionability timeout, domain block/allow lists.
+2. **Phase 2 — Advanced:** Browser engine selection, navigation timeouts, dark mode preferences, telemetry opt-in, outbound HTTP/SOCKS proxy, domain policy modes.
+3. **Phase 3 — Save Location:** Global (`~/.weavetab/config.json`) or Project-scoped (`./.weavetab/config.json`).
+4. **Phase 4 — MCP Auto-Config:** Auto-detects installed IDEs (Claude Desktop, Cursor, Windsurf, VS Code, OpenCode, Claude Code, Antigravity) and merges Weavetab into their MCP configuration.
+5. **Phase 5 — Summary:** Displays full configuration validation report.

package/docs/intelligence/site-profiles.md

@@ -0,0 +1,151 @@
+---
+title: "Site Profiles and Intelligent Memory"
+description: "Persistent cross-session workflow memory, pattern compilation, and quirk bypass in ~/.weavetab-system/memory/sites/."
+product: mcp
+section: intelligence
+icon: Brain
+slug: site-profiles
+---
+
+# Site Profiles and Intelligent Memory Engine
+
+Every browser automation session normally starts from zero context. The agent re-inspects DOM trees, re-triggers cookie banners, and re-discovers login fields.
+
+Weavetab solves this with a **Two-Tier Persistent Memory System** that accumulates knowledge about domains and workflows across sessions.
+
+---
+
+## Directory Hierarchy: System vs. User Space
+
+| Directory | Purpose | Managed By |
+| :--- | :--- | :--- |
+| `~/.weavetab-system/memory/sites/` | **Persistent Site Profiles**: named workflow patterns, quirks, reliability scores | Weavetab Engine (autonomous) |
+| `~/.weavetab-system/memory/` | **Selector Confidence Cache**: per-domain element selectors and strike counters | Weavetab Engine (autonomous) |
+| `~/.weavetab-system/sessions/` | **Rolling Action Trails**: 50-step window for loop detection | Weavetab Engine (autonomous) |
+| `~/.weavetab/` | **User Configuration**: `config.json`, `secrets.json`, `policy.json`, plugins | User / Developer (manual) |
+
+> **Directory Law**: Machine-compiled memory profiles are strictly located in `~/.weavetab-system/memory/sites/`. User configuration in `~/.weavetab/` is never polluted by machine learning trails or dynamic decay counters.
+
+---
+
+## Site Profile Schema
+
+Profiles are stored as `<sanitized-hostname>.json` under `~/.weavetab-system/memory/sites/`:
+
+```json
+{
+  "origin": "https://github.com",
+  "framework": "react",
+  "shadowDom": false,
+  "captcha_frequency": "rare",
+  "quirks": {
+    "cookie_banner": {
+      "selector": "#cookie-consent",
+      "action": "click .accept-all",
+      "appears": "first_visit"
+    },
+    "rate_limit": {
+      "threshold": "60req/min",
+      "recovery": "wait 30s"
+    }
+  },
+  "patterns": {
+    "login_flow": {
+      "name": "login_flow",
+      "steps": [
+        { "tool": "browser_navigate", "target": "https://github.com/login" },
+        { "tool": "browser_fill", "target": "#login_field", "value": "{{username}}" },
+        { "tool": "browser_fill", "target": "#password", "value": "{{password}}" },
+        { "tool": "browser_click", "target": "[type=submit]" }
+      ],
+      "success_indicator": "a[aria-label='Homepage']",
+      "entry": "/login",
+      "avg_duration_ms": 3200,
+      "reliability": 0.96,
+      "strikes": 0,
+      "last_verified": "2026-09-16T08:00:00.000Z",
+      "total_executions": 12,
+      "successful_executions": 12
+    }
+  },
+  "visitCount": 15,
+  "updatedAt": "2026-09-16T08:00:00.000Z"
+}
+```
+
+---
+
+## The Pattern Compiler
+
+When an agent executes an automation flow:
+1. **Trail Capture**: Steps are tracked via the lightweight action trail.
+2. **Selector Stabilization**: Volatile CSS hash classes (`[class*="hash-"]`), positional pseudos (`:nth-child`), and deep anonymous structural chains are filtered out. Only semantic selectors (`id`, `data-testid`, semantic attributes, roles) are persisted.
+3. **Merge-on-Write**: Calling `browser_pattern_learn` updates existing patterns in place. Duplicate calls never create duplicate files or duplicate entries.
+4. **Anti-Spam Guard**: If an incoming pattern is identical to stored disk state, the disk write is skipped entirely.
+
+---
+
+## Reliability Scoring and 3-Strike Degradation
+
+Each pattern tracks a reliability score (`0.0` to `1.0`) computed via Exponentially Weighted Moving Average (EWMA with $\alpha = 0.15$):
+
+$$\text{Reliability}_{t} = 0.85 \times \text{Reliability}_{t-1} + 0.15 \times (\text{Success} ? 1 : 0)$$
+
+### Decision Thresholds
+
+- **Fast-Path ($\ge 0.80$)**: Replay stored steps directly via `browser_burst` — skips exploratory DOM navigation entirely.
+- **Cautious Replay ($0.50 - 0.79$)**: Replay steps, but verify `success_indicator` after critical steps.
+- **Re-Learn ($< 0.50$ or $\ge 3$ consecutive strikes)**: Pattern is flagged `[RE-LEARN NEEDED]`. The agent falls back to fresh DOM exploration, then calls `browser_pattern_learn` to teach the updated steps.
+
+---
+
+## MCP Tools
+
+### `browser_pattern_learn`
+All site memory operations use a single tool. Use `action: "get"` to read a site profile, `action: "learn"` to register a workflow, `action: "record_execution"` to update reliability scores, and `action: "record_quirk"` to store site quirks:
+
+```json
+{ "action": "get", "origin": "https://github.com" }
+```
+
+```json
+{
+  "origin": "https://github.com",
+  "action": "learn",
+  "name": "login_flow",
+  "steps": [
+    { "tool": "browser_click", "target": ".btn-login" },
+    { "tool": "browser_fill", "target": "#login_field", "value": "{{username}}" }
+  ],
+  "success_indicator": "a[aria-label='Homepage']"
+}
+```
+
+---
+
+## SDK Plugin Integration (`ctx.memory`)
+
+Plugin authors can interact with persistent site memory directly via the SDK:
+
+```typescript
+import { definePlugin } from "@weavetab/sdk";
+
+export default definePlugin({
+  name: "custom-site-automator",
+  async onLoad(ctx) {
+    // Read current profile
+    const profile = await ctx.memory?.getSiteProfile("https://github.com");
+
+    // Check reliability
+    const reliability = await ctx.memory?.getReliability("https://github.com", "login_flow");
+    if (reliability && reliability >= 0.8) {
+      ctx.logger.info("Fast-path ready for login_flow");
+    }
+
+    // Teach a new pattern
+    await ctx.memory?.learnPattern("https://github.com", "quick_search", {
+      steps: [{ tool: "browser_fill", target: "input.header-search-input", value: "test" }]
+    });
+  }
+});
+```

package/docs/skills-ecosystem/skills-overview.md

@@ -0,0 +1,35 @@
+---
+title: "Skills Ecosystem"
+description: "Drop-in agent skills and recipes from @weavetab/skills."
+product: mcp
+section: skills-ecosystem
+icon: BrainCircuit
+slug: skills-overview
+---
+
+# Weavetab Skills Ecosystem
+
+The **`@weavetab/skills`** package provides drop-in operational directives and behavior skills for AI agents (Claude, Cursor, Windsurf, Copilot, Antigravity).
+
+## Interactive Skills Installer
+
+```bash
+npx -y @weavetab/skills@latest
+```
+
+The interactive installer detects your IDE (`.agents`, `.cursorrules`, `.clinerules`, `.roocode`, etc.) and injects selected skills directly without workspace clutter.
+
+---
+
+## Available Skills Directory
+
+- **CAPTCHA Evasion** (`general/captcha-evasion.md`) — Heuristics for resolving bot challenges and checkbox modals.
+- **Context Awareness** (`general/context-awareness.md`) — Deep page analysis and landmark scoping.
+- **Cookie Consent Banners** (`general/cookie-consent.md`) — Auto-dismissing GDPR and overlay modals.
+- **Data Extraction** (`general/data-extraction.md`) — CSS & XPath tabular scraping.
+- **Dynamic Interaction** (`general/dynamic-interaction.md`) — Precision hover, drag-and-drop, and flyout menus.
+- **Error Recovery** (`general/error-recovery.md`) — Resolving 404s, stale elements, and network timeouts.
+- **File Upload** (`general/file-upload.md`) — Direct CDP file attachments.
+- **Form Filling** (`general/form-filling.md`) — Multi-field smart form batch completion.
+- **Infinite Scroll** (`general/infinite-scroll.md`) — Pagination and dynamic lazy loading.
+- **SPA Navigation** (`general/spa-navigation.md`) — Client-side route changes in React/Vue/Angular.

package/docs/skills-ecosystem/skills-recipes.md

@@ -0,0 +1,36 @@
+---
+title: "Automation Recipes"
+description: "Step-by-step recipes for common browser automation challenges."
+product: mcp
+section: skills-ecosystem
+icon: BookOpenCheck
+slug: skills-recipes
+---
+
+# Automation Skills Recipes
+
+## Recipe 1: Handling Dynamic Cookie Consent Overlays
+
+```markdown
+1. Run browser_find({ query: "Accept all cookies" })
+2. If found, call browser_click({ label: "Accept all" })
+3. Wait for stability: browser_wait({ for: "stable", timeout: 2000 })
+4. Read page with delta: browser_map({ delta: true, prune: true })
+```
+
+---
+
+## Recipe 2: Autonomous Form Completion
+
+```markdown
+1. Map the form: browser_map({ scope: "form", query: "input" })
+2. Batch fill fields in one round-trip:
+   browser_fill({
+     fields: [
+       { ref: "w:12", value: "alex@company.com" },
+       { ref: "w:14", value: "United States" }
+     ],
+     submit: "w:16"
+   })
+3. Wait for submission: browser_wait({ for: "network" })
+```