neuron-inspector 0.8.0 → 1.0.0

package/dist/business-tools.js

@@ -0,0 +1,3065 @@
+/**
+ * Business intelligence tools — high-level compound tools that turn social
+ * media activity into leads, opportunities, and structured data.
+ *
+ * These chain existing extension primitives (openTab, scrollPage, extractData,
+ * etc.) from the bridge server. No new extension primitives needed.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import YAML from "yaml";
+import { NEURON_DIR } from "./paths.js";
+// ── Low-level helpers ───────────────────────────────────────
+async function call(ctx, primitive, args, timeoutMs = 15000) {
+    return ctx.pending.call(ctx.ws, primitive, args, timeoutMs);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+// ── Shared helpers ──────────────────────────────────────────
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function loadYaml(file) {
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        return YAML.parse(fs.readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveYaml(file, data) {
+    ensureDir(path.dirname(file));
+    fs.writeFileSync(file, YAML.stringify(data), "utf-8");
+}
+function detectPlatform(url) {
+    const u = url.toLowerCase();
+    if (u.includes("instagram.com"))
+        return "ig";
+    if (u.includes("x.com") || u.includes("twitter.com"))
+        return "x";
+    if (u.includes("tiktok.com"))
+        return "tk";
+    if (u.includes("linkedin.com"))
+        return "li";
+    if (u.includes("facebook.com") || u.includes("fb.com"))
+        return "fb";
+    if (u.includes("youtube.com") || u.includes("youtu.be"))
+        return "yt";
+    if (u.includes("threads.net"))
+        return "threads";
+    return "web";
+}
+function filterByKeywords(items, keywords) {
+    if (!keywords.length)
+        return items;
+    const lower = keywords.map((k) => k.toLowerCase());
+    return items.filter((item) => {
+        const text = JSON.stringify(item).toLowerCase();
+        return lower.some((kw) => text.includes(kw));
+    });
+}
+async function researchSingleProfile(ctx, url, scrolls = 2) {
+    try {
+        const tab = (await call(ctx, "openTab", { url }));
+        const tabId = tab?.tabId;
+        if (!tabId)
+            return { url, platform: detectPlatform(url), data: null, error: "Failed to open tab" };
+        await sleep(2500);
+        for (let i = 0; i < scrolls; i++) {
+            await call(ctx, "scrollPage", { tabId, deltaY: 600, smooth: true });
+            await sleep(500);
+        }
+        const data = await call(ctx, "extractData", { tabId });
+        try {
+            await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+        }
+        catch { /* ok */ }
+        return { url, platform: detectPlatform(url), data, error: null };
+    }
+    catch (err) {
+        return { url, platform: detectPlatform(url), data: null, error: err.message };
+    }
+}
+/** Per-platform selector map for social actions */
+const PLATFORM_SELECTORS = {
+    ig: {
+        like: ["span[class*='like'] button", "button svg[aria-label*='Like']", "[aria-label='Like']"],
+        comment: ["textarea[aria-label*='comment']", "textarea[placeholder*='comment']"],
+        follow: ["button:has-text('Follow')", "[aria-label='Follow']"],
+        compose: ["[aria-label='New post']", "svg[aria-label='New post']"],
+        dm: ["textarea[placeholder*='Message']"],
+    },
+    x: {
+        like: ["button[data-testid='like']", "[aria-label*='Like']"],
+        reply: ["div[data-testid='tweetTextarea_0']", "[aria-label*='Post your reply']"],
+        follow: ["button[data-testid*='follow']", "[aria-label*='Follow']"],
+        compose: ["a[data-testid='SideNav_NewTweet_Button']", "[aria-label='Post']"],
+        dm: ["div[data-testid='dmComposerTextInput']"],
+    },
+    li: {
+        like: ["button[aria-label*='Like']", "button.react-button__trigger"],
+        comment: ["div.ql-editor[data-placeholder*='comment']", "[aria-label*='comment']"],
+        follow: ["button:has-text('Connect')", "button:has-text('Follow')"],
+        compose: ["button.share-box-feed-entry__trigger", "[aria-label='Start a post']"],
+        dm: ["div.msg-form__contenteditable", "[aria-label*='message']"],
+    },
+    fb: {
+        like: ["div[aria-label='Like']", "[data-testid='UFI2ReactionActionLink']"],
+        comment: ["div[contenteditable='true'][aria-label*='comment']"],
+        follow: ["[aria-label*='Follow']"],
+        compose: ["div[aria-label*='What\\'s on your mind']", "[data-testid='status-attachment-mentions-input']"],
+        dm: ["div[contenteditable='true'][aria-label*='message']"],
+    },
+    tk: {
+        like: ["span[data-e2e='like-icon']", "[aria-label*='Like']"],
+        comment: ["div[data-e2e='comment-input']", "[contenteditable='true']"],
+        follow: ["button[data-e2e='follow-button']"],
+        compose: [],
+        dm: [],
+    },
+};
+// ── Tool definitions ────────────────────────────────────────
+export const BUSINESS_TOOLS = [
+    // ── Phase 1: Foundation ─────────────────────────────────
+    {
+        name: "neuron_profile_scanner",
+        description: "Scan a list of social media profile URLs — visit each, scroll to load content, extract structured " +
+            "profile data (name, bio, followers, posts). Supports session resume for large batches. Use for " +
+            "lead enrichment, competitor research, or building prospect lists from profile URLs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                urls: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Profile URLs to scan (max 20 per call)",
+                },
+                scrolls: { type: "number", description: "Scroll-downs per profile to load content (default: 2)" },
+                session_id: { type: "string", description: "Session ID for resume support on large batches (optional)" },
+                delay_ms: { type: "number", description: "Delay between profiles in ms (default: 2000)" },
+            },
+            required: ["urls"],
+        },
+    },
+    {
+        name: "neuron_hashtag_scout",
+        description: "Scout a hashtag or topic feed — open the feed URL, scroll to collect posts, extract post data " +
+            "and authors. Optionally enrich by visiting each unique author's profile. Use for finding active " +
+            "creators in a niche, discovering trending content, or building outreach lists from hashtag feeds.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Hashtag or topic feed URL (e.g. https://instagram.com/explore/tags/startup/)" },
+                scrolls: { type: "number", description: "Number of scroll-downs to collect posts (default: 5)" },
+                enrich_profiles: { type: "boolean", description: "Visit each unique author's profile for full data (default: false)" },
+                max_profiles: { type: "number", description: "Max profiles to enrich (default: 10)" },
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter posts by keywords (optional)",
+                },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "neuron_site_xray",
+        description: "Full network analysis of any URL. Captures requests, performance metrics, security scan, API " +
+            "discovery, and waterfall timing in parallel. Post-processes into a categorized report: first-party " +
+            "vs third-party services, tracking pixels, CDN usage, API endpoints found, performance score, and " +
+            "security findings. Use for competitive analysis, tech stack discovery, or site auditing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to analyze" },
+                scrolls: { type: "number", description: "Scroll-downs to trigger lazy-loaded resources (default: 3)" },
+            },
+            required: ["url"],
+        },
+    },
+    // ── Phase 2: Collection tools ──────────────────────────
+    {
+        name: "neuron_collection_harvest",
+        description: "One-shot processing of a saved collection or feed URL. Deep-scrolls to load all items, extracts " +
+            "structured data, filters by keywords, and optionally enriches author profiles. Use for processing " +
+            "saved/bookmarked collections, liked-posts feeds, or any paginated content list.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Collection or feed URL to harvest" },
+                scrolls: { type: "number", description: "Number of deep scroll-downs (default: 10)" },
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter items by keywords (optional)",
+                },
+                enrich_profiles: { type: "boolean", description: "Visit each unique author's profile (default: false)" },
+                max_profiles: { type: "number", description: "Max profiles to enrich (default: 10)" },
+                selector: { type: "string", description: "CSS selector for items (optional — auto-detects)" },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "neuron_collection_watch",
+        description: "Watch a collection or feed URL for new items. Creates a persistent monitor that checks at " +
+            "intervals and alerts when new content matching your keywords appears. Use for watching competitor " +
+            "feeds, saved collections, or topic pages for new content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Collection or feed URL to watch" },
+                name: { type: "string", description: "Human-readable name for this watch" },
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Only alert on items matching these keywords (optional)",
+                },
+                check_interval_minutes: { type: "number", description: "How often to check (default: 60)" },
+                selector: { type: "string", description: "CSS selector for items (optional)" },
+            },
+            required: ["url", "name"],
+        },
+    },
+    // ── Phase 3: Prospecting ───────────────────────────────
+    {
+        name: "neuron_local_scout",
+        description: "Search location or explore feeds for businesses and creators. Navigates to a search/explore URL, " +
+            "optionally types a query, scrolls to collect results, and enriches unique author profiles. Filters " +
+            "by criteria like minimum followers, has-website, or keyword presence. Use for local business " +
+            "discovery or geographic lead generation.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Search or explore URL (e.g. https://instagram.com/explore/locations/...)" },
+                query: { type: "string", description: "Search query to type (optional — some URLs pre-filter)" },
+                scrolls: { type: "number", description: "Scroll-downs to collect results (default: 5)" },
+                enrich_profiles: { type: "boolean", description: "Visit each author's profile for full data (default: true)" },
+                max_profiles: { type: "number", description: "Max profiles to enrich (default: 15)" },
+                min_followers: { type: "number", description: "Filter: minimum follower count (optional)" },
+                require_website: { type: "boolean", description: "Filter: only profiles with a website link (default: false)" },
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter by keywords in bio/posts (optional)",
+                },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "neuron_demand_scanner",
+        description: "Scan feeds for posts matching trigger phrases — people asking for help, recommendations, or " +
+            "services. Uses search + keyword matching to find demand signals. Optionally creates a recurring " +
+            "monitor for scheduled checks. Use for finding inbound leads, customer pain points, or service requests.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Feed or search URL to scan" },
+                triggers: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Trigger phrases to match (e.g. 'looking for', 'anyone know', 'recommend')",
+                },
+                scrolls: { type: "number", description: "Scroll-downs to collect posts (default: 5)" },
+                schedule: { type: "boolean", description: "Create a recurring monitor for this scan (default: false)" },
+                check_interval_minutes: { type: "number", description: "Monitor check interval if scheduled (default: 120)" },
+                enrich_profiles: { type: "boolean", description: "Enrich matched post authors' profiles (default: false)" },
+            },
+            required: ["url", "triggers"],
+        },
+    },
+    {
+        name: "neuron_opportunity_radar",
+        description: "Aggregator — reads recent alerts from all business monitors (Collection Watches, Demand Scanners, " +
+            "Page Watches). Merges, deduplicates, and sorts by recency. Returns a unified opportunity feed. " +
+            "Use as a daily digest of leads and opportunities across all your active monitors.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "number", description: "Max opportunities to return (default: 50)" },
+                since_hours: { type: "number", description: "Only show alerts from the last N hours (default: 24)" },
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter opportunities by keywords (optional)",
+                },
+            },
+        },
+    },
+    // ── Phase 4: Platform & Extraction ─────────────────────
+    {
+        name: "neuron_quick_action",
+        description: "Perform a social media action (like, comment, follow, DM, post) on the current tab or a URL. " +
+            "Uses per-platform selector registry. Auto-detects platform from tab URL. Use for quick engagement " +
+            "actions without remembering platform-specific selectors.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tabId: { type: "number", description: "Chrome tab ID (optional if url provided)" },
+                url: { type: "string", description: "URL to navigate to first (optional if tabId provided)" },
+                action: {
+                    type: "string",
+                    enum: ["like", "comment", "reply", "follow", "dm", "compose"],
+                    description: "Social action to perform",
+                },
+                text: { type: "string", description: "Text content for comment, reply, dm, or compose actions" },
+                platform: { type: "string", description: "Override platform detection (ig, x, li, fb, tk)" },
+            },
+            required: ["action"],
+        },
+    },
+    {
+        name: "neuron_pattern_learner",
+        description: "Learn extraction patterns from examples. Give it 2-3 example text values from a page, and it " +
+            "identifies the common DOM structure, infers a CSS selector, and stores it for reuse. Then extracts " +
+            "all matching items. Use when auto-detection misses or you need a custom extraction pattern.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tabId: { type: "number", description: "Chrome tab ID" },
+                examples: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "2-3 example text values visible on the page",
+                },
+                name: { type: "string", description: "Name for this pattern (stored for reuse)" },
+                extract: { type: "boolean", description: "Extract all matches immediately (default: true)" },
+            },
+            required: ["tabId", "examples"],
+        },
+    },
+    // ── Phase 5: Network & Monitoring ──────────────────────
+    {
+        name: "neuron_traffic_replay",
+        description: "Capture, save, and replay network traffic. Three modes: 'capture' saves current traffic as a " +
+            "HAR file; 'replay' loads a saved HAR and sets mock rules to simulate it; 'list' shows saved " +
+            "replays. Use for offline testing, reproducing bugs, or comparing API responses over time.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                mode: {
+                    type: "string",
+                    enum: ["capture", "replay", "list"],
+                    description: "Operation mode",
+                },
+                name: { type: "string", description: "Name for the capture/replay (required for capture and replay)" },
+                tabId: { type: "number", description: "Tab ID to capture traffic from (for capture mode)" },
+                platform: { type: "string", description: "Filter by platform (for capture mode)" },
+                navigate_url: { type: "string", description: "URL to navigate to after setting up mock rules (for replay mode)" },
+            },
+            required: ["mode"],
+        },
+    },
+    {
+        name: "neuron_api_blueprint",
+        description: "Enhanced API discovery — analyzes captured traffic, infers request/response schemas, detects auth " +
+            "patterns, and creates a Neuron API collection with all discovered endpoints. Use to reverse-engineer " +
+            "an API from observed traffic and create a ready-to-use collection for testing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                collection_name: { type: "string", description: "Name for the API collection to create" },
+                url: { type: "string", description: "Optional: navigate to this URL first to capture fresh traffic" },
+                tabId: { type: "number", description: "Tab ID to analyze traffic from (optional)" },
+                include_auth: { type: "boolean", description: "Include auth headers in collection (default: true)" },
+            },
+            required: ["collection_name"],
+        },
+    },
+    {
+        name: "neuron_page_watch",
+        description: "Semantic page diffing monitor. Creates a persistent monitor that uses structured DOM snapshots " +
+            "instead of raw text comparison. Produces human-readable diff reports showing exactly what changed. " +
+            "Use to track changes on product pages, competitor sites, job boards, or any page with dynamic content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to watch for changes" },
+                name: { type: "string", description: "Human-readable name for this watch" },
+                selector: { type: "string", description: "CSS selector to scope the watch (optional — watches full page)" },
+                check_interval_minutes: { type: "number", description: "How often to check (default: 60)" },
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Only alert on changes containing these keywords (optional)",
+                },
+            },
+            required: ["url", "name"],
+        },
+    },
+    // ── Wave 2: Revenue & Lead Management ─────────────────────
+    {
+        name: "neuron_revenue_tracker",
+        description: "CRM-lite funnel tracker. Add leads with source attribution (which tool found them), move them " +
+            "through stages (discovered → contacted → replied → interested → negotiating → closed-won/lost), " +
+            "tag revenue, and see conversion rates per source. Persists to ~/.neuron/pipeline.yaml.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["add_lead", "update_stage", "tag_revenue", "list", "stats"],
+                    description: "Pipeline action",
+                },
+                lead: {
+                    type: "object",
+                    description: "Lead data (for add_lead): { url, name, handle, platform, source, source_tool }",
+                },
+                lead_id: { type: "string", description: "Lead ID (for update_stage, tag_revenue)" },
+                stage: {
+                    type: "string",
+                    enum: ["discovered", "contacted", "replied", "interested", "negotiating", "closed_won", "closed_lost"],
+                    description: "New stage (for update_stage)",
+                },
+                revenue: { type: "number", description: "Revenue amount (for tag_revenue)" },
+                filters: {
+                    type: "object",
+                    description: "Filters for list: { stage?, source?, platform?, since_days? }",
+                },
+            },
+            required: ["action"],
+        },
+    },
+    {
+        name: "neuron_lead_scorer",
+        description: "Score a list of leads based on configurable criteria: follower count, bio keywords (founder, CEO, " +
+            "business owner), engagement rate, posting recency, website presence, location match. Returns leads " +
+            "sorted by score with tier (hot/warm/cold) and recommended action per tier.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                leads: {
+                    type: "array",
+                    items: { type: "object" },
+                    description: "Lead objects with profile data (from profile_scanner, collection_harvest, etc.)",
+                },
+                rubric: {
+                    type: "object",
+                    description: "Scoring weights: { follower_min?, follower_max?, bio_keywords?: string[], " +
+                        "require_website?: boolean, location_keywords?: string[], max_days_since_post?: number }",
+                },
+                hot_threshold: { type: "number", description: "Score above this = hot lead (default: 80)" },
+                warm_threshold: { type: "number", description: "Score above this = warm lead (default: 50)" },
+            },
+            required: ["leads"],
+        },
+    },
+    {
+        name: "neuron_social_proof",
+        description: "Monitor and collect social proof — positive mentions, testimonials, and user-generated content " +
+            "about your brand. Scans posts, comments, and tags for positive sentiment. Captures the quote, " +
+            "poster profile, and post link into a testimonial bank at ~/.neuron/testimonials.yaml.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["scan", "list", "export"],
+                    description: "Action: scan a URL for testimonials, list saved ones, or export",
+                },
+                url: { type: "string", description: "URL to scan for social proof (for scan action)" },
+                brand_keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Brand/product names to look for",
+                },
+                positive_signals: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Positive phrases (default: 'changed my', 'love this', 'best', 'recommend', 'game changer')",
+                },
+                scrolls: { type: "number", description: "Scroll-downs to collect content (default: 5)" },
+            },
+            required: ["action"],
+        },
+    },
+    // ── Wave 2: Outreach & Engagement ────────────────────────
+    {
+        name: "neuron_dm_outreach",
+        description: "Paced DM outreach from a lead list. Composes personalized messages from a template with merge " +
+            "fields ({name}, {handle}, {context}), sends one at a time with configurable delays to avoid " +
+            "platform limits, and tracks sent/replied status. Requires explicit start confirmation.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["preview", "start", "status", "pause"],
+                    description: "Outreach action",
+                },
+                campaign_id: { type: "string", description: "Campaign ID (for status/pause)" },
+                leads: {
+                    type: "array",
+                    items: { type: "object" },
+                    description: "Lead list with profile URLs and merge data (for start)",
+                },
+                template: { type: "string", description: "Message template with {name}, {handle}, {context} merge fields" },
+                delay_minutes: { type: "number", description: "Minutes between messages (default: 5)" },
+                max_per_day: { type: "number", description: "Max messages per day (default: 20)" },
+                platform: { type: "string", description: "Target platform (ig, x, li)" },
+            },
+            required: ["action"],
+        },
+    },
+    {
+        name: "neuron_post_to_lead",
+        description: "Monitor a post's comments for a trigger keyword (e.g. 'GUIDE', 'INTERESTED'). Extract each " +
+            "matching commenter's profile, push as a lead. Optionally auto-queue a DM with a resource link. " +
+            "Use to turn engagement CTAs into a lead funnel automatically.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                post_url: { type: "string", description: "URL of the post to monitor" },
+                trigger: { type: "string", description: "Keyword to match in comments (e.g. 'GUIDE')" },
+                enrich_profiles: { type: "boolean", description: "Visit each commenter's profile (default: true)" },
+                dm_template: { type: "string", description: "Optional DM template to queue for matched commenters" },
+                scrolls: { type: "number", description: "Scroll-downs on comments section (default: 5)" },
+                schedule: { type: "boolean", description: "Create a recurring monitor (default: false)" },
+                check_interval_minutes: { type: "number", description: "Monitor interval if scheduled (default: 30)" },
+            },
+            required: ["post_url", "trigger"],
+        },
+    },
+    {
+        name: "neuron_comment_miner",
+        description: "Extract every commenter from a post (yours or anyone's) with their profile data. Filter by " +
+            "keyword in their comment text. Returns a structured lead list. Use to turn a viral post's " +
+            "comment section into qualified leads.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                post_url: { type: "string", description: "URL of the post to mine comments from" },
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter commenters by keywords in their comment (optional)",
+                },
+                enrich_profiles: { type: "boolean", description: "Visit each commenter's profile (default: true)" },
+                max_profiles: { type: "number", description: "Max profiles to enrich (default: 20)" },
+                scrolls: { type: "number", description: "Scroll-downs on comments (default: 5)" },
+            },
+            required: ["post_url"],
+        },
+    },
+    // ── Wave 2: Competitive Intelligence ─────────────────────
+    {
+        name: "neuron_competitor_mapper",
+        description: "Map a competitor's engaged audience. Visit their profile, scan recent posts' comments, rank " +
+            "commenters by frequency, and enrich top commenters' profiles. Categorizes each as potential " +
+            "customer, fellow business, influencer, or casual follower.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                profile_url: { type: "string", description: "Competitor's profile URL" },
+                posts_to_scan: { type: "number", description: "Number of recent posts to scan comments from (default: 5)" },
+                max_commenters: { type: "number", description: "Max commenters to enrich (default: 20)" },
+                scrolls_per_post: { type: "number", description: "Scroll-downs per post's comments (default: 3)" },
+                your_handle: { type: "string", description: "Your handle — to detect overlap (people who engage with both)" },
+            },
+            required: ["profile_url"],
+        },
+    },
+    {
+        name: "neuron_influencer_vetter",
+        description: "Vet an influencer profile for authenticity. Calculates engagement rate, analyzes comment quality " +
+            "(generic vs substantive), checks posting consistency, and flags red flags like purchased followers. " +
+            "Returns a trust score (0-100) with breakdown.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                profile_url: { type: "string", description: "Influencer's profile URL" },
+                posts_to_analyze: { type: "number", description: "Number of recent posts to analyze (default: 10)" },
+                scrolls: { type: "number", description: "Scroll-downs on profile (default: 3)" },
+            },
+            required: ["profile_url"],
+        },
+    },
+    {
+        name: "neuron_engagement_analyzer",
+        description: "Analyze your own posting performance. Scans your last N posts, calculates best posting times, " +
+            "top content types, effective hashtags, engagement trends, and returns specific recommendations. " +
+            "Like Sprout Social analytics but free.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                profile_url: { type: "string", description: "Your profile URL" },
+                posts_to_analyze: { type: "number", description: "Number of recent posts to analyze (default: 20)" },
+                scrolls: { type: "number", description: "Scroll-downs on profile (default: 5)" },
+            },
+            required: ["profile_url"],
+        },
+    },
+    // ── Wave 2: Brand & Content ──────────────────────────────
+    {
+        name: "neuron_mention_tracker",
+        description: "Track who mentions your brand, handle, or keywords across platforms. Scan a search/hashtag URL, " +
+            "extract posts mentioning your brand, capture poster profile and sentiment. Optionally schedule " +
+            "recurring checks. Persists mentions to ~/.neuron/mentions.yaml.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Search or feed URL to scan for mentions" },
+                brand_terms: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Brand names, handles, or keywords to track",
+                },
+                scrolls: { type: "number", description: "Scroll-downs to collect posts (default: 5)" },
+                enrich_profiles: { type: "boolean", description: "Enrich mention authors' profiles (default: false)" },
+                schedule: { type: "boolean", description: "Create recurring monitor (default: false)" },
+                check_interval_minutes: { type: "number", description: "Monitor interval if scheduled (default: 60)" },
+            },
+            required: ["url", "brand_terms"],
+        },
+    },
+    {
+        name: "neuron_post_analyzer",
+        description: "Analyze a social post or batch of posts. Extract text, media type, engagement metrics, hashtags, " +
+            "mentions, posting time, and content classification (educational, promotional, storytelling). " +
+            "Batch mode: analyze a profile's feed and return a spreadsheet-ready breakdown.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Post URL or profile URL (for batch mode)" },
+                batch: { type: "boolean", description: "Analyze multiple posts from a profile feed (default: false)" },
+                posts_count: { type: "number", description: "Number of posts for batch mode (default: 20)" },
+                scrolls: { type: "number", description: "Scroll-downs to load posts (default: 3)" },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "neuron_content_pipeline",
+        description: "Extract content from a source URL (article, thread, post) and restructure it for a target " +
+            "platform format. Returns platform-optimized content with hooks and formatting. Use for content " +
+            "repurposing across platforms.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                source_url: { type: "string", description: "Source content URL (article, post, thread)" },
+                target_platform: {
+                    type: "string",
+                    enum: ["linkedin", "x", "instagram", "tiktok", "newsletter", "blog"],
+                    description: "Target platform format",
+                },
+                scrolls: { type: "number", description: "Scroll-downs on source page (default: 5)" },
+                tone: { type: "string", description: "Tone override: professional, casual, educational (optional)" },
+            },
+            required: ["source_url", "target_platform"],
+        },
+    },
+    // ── Wave 2: Data Collection ──────────────────────────────
+    {
+        name: "neuron_group_link_scanner",
+        description: "Scan posts, comments, bios for WhatsApp and Telegram group invite links (wa.me, chat.whatsapp.com, " +
+            "t.me). Extract the link, context, and poster profile. Push to ~/.neuron/group-links.yaml. " +
+            "Optionally validate if links are still active.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to scan (feed, post, profile)" },
+                scrolls: { type: "number", description: "Scroll-downs to collect content (default: 5)" },
+                validate_links: { type: "boolean", description: "Check if group links are still active (default: false)" },
+                enrich_profiles: { type: "boolean", description: "Enrich link poster profiles (default: false)" },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "neuron_bio_harvester",
+        description: "Scan a list of profile URLs and extract every link from their bios — websites, Linktree, WhatsApp, " +
+            "Calendly, email, phone. Follows link-in-bio pages (Linktree, Beacons) to extract destination URLs. " +
+            "Categorizes each link type.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                urls: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Profile URLs to harvest bio links from (max 20)",
+                },
+                follow_linktree: { type: "boolean", description: "Follow and expand link-in-bio pages (default: true)" },
+                delay_ms: { type: "number", description: "Delay between profiles in ms (default: 2000)" },
+            },
+            required: ["urls"],
+        },
+    },
+    {
+        name: "neuron_cross_platform_finder",
+        description: "Find a person across platforms. Given a handle on one platform, search for matching accounts on " +
+            "others by handle, name, and bio similarity. Returns a unified profile card with confidence scores.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                handle: { type: "string", description: "Handle to search for (e.g. 'rasheedalabi')" },
+                source_platform: { type: "string", description: "Platform the handle is from (ig, x, li, tk, fb)" },
+                search_platforms: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Platforms to search on (default: all except source)",
+                },
+            },
+            required: ["handle", "source_platform"],
+        },
+    },
+    {
+        name: "neuron_page_weight",
+        description: "Break down total page weight by category (JS, CSS, images, fonts, video, third-party). Flag " +
+            "oversized assets with specific recommendations. Compare against performance budgets. Returns a " +
+            "prioritized action list for optimization.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to profile" },
+                budget: {
+                    type: "object",
+                    description: "Performance budget: { max_js_kb?, max_css_kb?, max_images_kb?, max_total_kb?, max_single_asset_kb? }",
+                },
+            },
+            required: ["url"],
+        },
+    },
+];
+// ── Handler dispatcher ──────────────────────────────────────
+export async function handleBusinessTool(name, args, ctx) {
+    switch (name) {
+        case "neuron_profile_scanner":
+            return profileScanner(args, ctx);
+        case "neuron_hashtag_scout":
+            return hashtagScout(args, ctx);
+        case "neuron_site_xray":
+            return siteXray(args, ctx);
+        case "neuron_collection_harvest":
+            return collectionHarvest(args, ctx);
+        case "neuron_collection_watch":
+            return collectionWatch(args);
+        case "neuron_local_scout":
+            return localScout(args, ctx);
+        case "neuron_demand_scanner":
+            return demandScanner(args, ctx);
+        case "neuron_opportunity_radar":
+            return opportunityRadar(args);
+        case "neuron_quick_action":
+            return quickAction(args, ctx);
+        case "neuron_pattern_learner":
+            return patternLearner(args, ctx);
+        case "neuron_traffic_replay":
+            return trafficReplay(args, ctx);
+        case "neuron_api_blueprint":
+            return apiBlueprint(args, ctx);
+        case "neuron_page_watch":
+            return pageWatch(args);
+        // Wave 2
+        case "neuron_revenue_tracker":
+            return revenueTracker(args);
+        case "neuron_lead_scorer":
+            return leadScorer(args);
+        case "neuron_social_proof":
+            return socialProof(args, ctx);
+        case "neuron_dm_outreach":
+            return dmOutreach(args, ctx);
+        case "neuron_post_to_lead":
+            return postToLead(args, ctx);
+        case "neuron_comment_miner":
+            return commentMiner(args, ctx);
+        case "neuron_competitor_mapper":
+            return competitorMapper(args, ctx);
+        case "neuron_influencer_vetter":
+            return influencerVetter(args, ctx);
+        case "neuron_engagement_analyzer":
+            return engagementAnalyzer(args, ctx);
+        case "neuron_mention_tracker":
+            return mentionTracker(args, ctx);
+        case "neuron_post_analyzer":
+            return postAnalyzer(args, ctx);
+        case "neuron_content_pipeline":
+            return contentPipeline(args, ctx);
+        case "neuron_group_link_scanner":
+            return groupLinkScanner(args, ctx);
+        case "neuron_bio_harvester":
+            return bioHarvester(args, ctx);
+        case "neuron_cross_platform_finder":
+            return crossPlatformFinder(args, ctx);
+        case "neuron_page_weight":
+            return pageWeight(args, ctx);
+        default:
+            throw new Error(`Unknown business tool: ${name}`);
+    }
+}
+// ── Implementations ─────────────────────────────────────────
+// ── Phase 1 ─────────────────────────────────────────────────
+async function profileScanner(args, ctx) {
+    const urls = args.urls.slice(0, 20);
+    const scrolls = args.scrolls ?? 2;
+    const sessionId = args.session_id;
+    const delayMs = args.delay_ms ?? 2000;
+    // Session resume support
+    let startIndex = 0;
+    const completed = [];
+    if (sessionId) {
+        const sessionFile = path.join(NEURON_DIR, "sessions", `${sessionId}.yaml`);
+        const existing = loadYaml(sessionFile);
+        if (existing?.cursor != null) {
+            startIndex = existing.cursor;
+            if (existing.completed)
+                completed.push(...existing.completed);
+        }
+    }
+    const results = [];
+    for (let i = startIndex; i < urls.length; i++) {
+        const result = await researchSingleProfile(ctx, urls[i], scrolls);
+        results.push(result);
+        completed.push(result);
+        // Save progress if session tracking
+        if (sessionId) {
+            const sessionFile = path.join(NEURON_DIR, "sessions", `${sessionId}.yaml`);
+            saveYaml(sessionFile, {
+                session_id: sessionId,
+                cursor: i + 1,
+                total: urls.length,
+                completed,
+                updated_at: new Date().toISOString(),
+            });
+        }
+        if (i < urls.length - 1 && delayMs > 0)
+            await sleep(delayMs);
+    }
+    return {
+        total: urls.length,
+        scanned: results.length,
+        successful: results.filter((r) => r.data && !r.error).length,
+        failed: results.filter((r) => r.error).length,
+        session_id: sessionId ?? null,
+        profiles: results,
+    };
+}
+async function hashtagScout(args, ctx) {
+    const url = args.url;
+    const scrollCount = args.scrolls ?? 5;
+    const enrichProfiles = args.enrich_profiles ?? false;
+    const maxProfiles = args.max_profiles ?? 10;
+    const keywords = args.keywords ?? [];
+    // Open the feed
+    const tab = (await call(ctx, "openTab", { url }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    // Scroll to collect posts
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 800, smooth: true });
+        await sleep(700);
+    }
+    // Extract posts
+    const rawData = (await call(ctx, "extractData", { tabId }));
+    let items = Array.isArray(rawData)
+        ? rawData
+        : rawData?.items ?? [rawData];
+    // Filter by keywords
+    if (keywords.length > 0) {
+        items = filterByKeywords(items, keywords);
+    }
+    // Extract unique author URLs from items
+    const authorUrls = new Set();
+    for (const item of items) {
+        const obj = item;
+        // Look for profile links in the extracted data
+        const links = (obj.links ?? obj.url ?? obj.href ?? obj.author_url ?? "");
+        const linkList = Array.isArray(links) ? links : [links];
+        for (const link of linkList) {
+            if (typeof link === "string" && link.includes("/") && !link.includes("/p/") && !link.includes("/reel/")) {
+                authorUrls.add(link);
+            }
+        }
+    }
+    // Enrich profiles if requested
+    let enriched = [];
+    if (enrichProfiles && authorUrls.size > 0) {
+        const toEnrich = [...authorUrls].slice(0, maxProfiles);
+        for (const profileUrl of toEnrich) {
+            enriched.push(await researchSingleProfile(ctx, profileUrl, 2));
+            await sleep(1500);
+        }
+    }
+    // Close the feed tab
+    try {
+        await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+    }
+    catch { /* ok */ }
+    return {
+        url,
+        platform: detectPlatform(url),
+        total_posts: items.length,
+        keywords_applied: keywords,
+        posts: items.slice(0, 50),
+        unique_authors: authorUrls.size,
+        enriched_profiles: enriched.length > 0 ? enriched : undefined,
+    };
+}
+async function siteXray(args, ctx) {
+    const url = args.url;
+    const scrollCount = args.scrolls ?? 3;
+    // Open the page
+    const tab = (await call(ctx, "openTab", { url }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    // Scroll to trigger lazy resources
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 600, smooth: true });
+        await sleep(500);
+    }
+    // Run all analyses in parallel
+    const [requests, waterfallData, perf, security, apis] = await Promise.allSettled([
+        call(ctx, "getRecentRequests", { tabId, limit: 200 }),
+        call(ctx, "waterfall", { tabId }),
+        call(ctx, "perfSnapshot", { tabId }),
+        call(ctx, "securityScan", { tabId }),
+        call(ctx, "discoverApis", {}),
+    ]);
+    // Categorize requests
+    const requestList = requests.status === "fulfilled"
+        ? (requests.value?.requests ?? [])
+        : [];
+    const hostname = new URL(url).hostname;
+    const categories = {
+        first_party: [],
+        third_party: [],
+        tracking: [],
+        cdn: [],
+        api: [],
+    };
+    const trackingDomains = [
+        "google-analytics", "googletagmanager", "facebook.com/tr", "pixel",
+        "analytics", "hotjar", "mixpanel", "segment", "amplitude",
+        "doubleclick", "adsense", "adservice", "tracking",
+    ];
+    const cdnDomains = [
+        "cloudfront", "cdn", "akamai", "fastly", "cloudflare", "jsdelivr",
+        "unpkg", "cdnjs",
+    ];
+    for (const req of requestList) {
+        const r = req;
+        const reqUrl = String(r.url ?? "");
+        try {
+            const reqHost = new URL(reqUrl).hostname;
+            const lower = reqUrl.toLowerCase();
+            if (trackingDomains.some((d) => lower.includes(d))) {
+                categories.tracking.push({ url: reqUrl, host: reqHost });
+            }
+            else if (cdnDomains.some((d) => lower.includes(d))) {
+                categories.cdn.push({ url: reqUrl, host: reqHost });
+            }
+            else if (lower.includes("/api/") || lower.includes("/graphql") || lower.includes("/v1/") || lower.includes("/v2/")) {
+                categories.api.push({ url: reqUrl, host: reqHost });
+            }
+            else if (reqHost === hostname || reqHost.endsWith(`.${hostname}`)) {
+                categories.first_party.push({ url: reqUrl, host: reqHost });
+            }
+            else {
+                categories.third_party.push({ url: reqUrl, host: reqHost });
+            }
+        }
+        catch {
+            // skip malformed URLs
+        }
+    }
+    // Close tab
+    try {
+        await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+    }
+    catch { /* ok */ }
+    return {
+        url,
+        total_requests: requestList.length,
+        categories: {
+            first_party: categories.first_party.length,
+            third_party: categories.third_party.length,
+            tracking: categories.tracking.length,
+            cdn: categories.cdn.length,
+            api: categories.api.length,
+        },
+        tracking_services: [...new Set(categories.tracking.map((t) => t.host))],
+        third_party_services: [...new Set(categories.third_party.map((t) => t.host))].slice(0, 20),
+        api_endpoints: categories.api.slice(0, 20),
+        waterfall: waterfallData.status === "fulfilled" ? waterfallData.value : { error: "unavailable" },
+        performance: perf.status === "fulfilled" ? perf.value : { error: "unavailable" },
+        security: security.status === "fulfilled" ? security.value : { error: "unavailable" },
+        discovered_apis: apis.status === "fulfilled" ? apis.value : { error: "unavailable" },
+    };
+}
+// ── Phase 2 ─────────────────────────────────────────────────
+async function collectionHarvest(args, ctx) {
+    const url = args.url;
+    const scrollCount = args.scrolls ?? 10;
+    const keywords = args.keywords ?? [];
+    const enrichProfiles = args.enrich_profiles ?? false;
+    const maxProfiles = args.max_profiles ?? 10;
+    const selector = args.selector;
+    // Open the collection
+    const tab = (await call(ctx, "openTab", { url }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    // Deep scroll to load all items
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 1000, smooth: true });
+        await sleep(800);
+    }
+    // Extract all items
+    const extractArgs = { tabId };
+    if (selector)
+        extractArgs.selector = selector;
+    const rawData = (await call(ctx, "extractData", extractArgs));
+    let items = Array.isArray(rawData)
+        ? rawData
+        : rawData?.items ?? [rawData];
+    // Filter by keywords
+    const preFilterCount = items.length;
+    if (keywords.length > 0) {
+        items = filterByKeywords(items, keywords);
+    }
+    // Extract unique author URLs
+    const authorUrls = new Set();
+    for (const item of items) {
+        const obj = item;
+        const links = (obj.links ?? obj.url ?? obj.href ?? obj.author_url ?? "");
+        const linkList = Array.isArray(links) ? links : [links];
+        for (const link of linkList) {
+            if (typeof link === "string" && link.startsWith("http")) {
+                authorUrls.add(link);
+            }
+        }
+    }
+    // Enrich profiles
+    let enriched = [];
+    if (enrichProfiles && authorUrls.size > 0) {
+        const toEnrich = [...authorUrls].slice(0, maxProfiles);
+        for (const profileUrl of toEnrich) {
+            enriched.push(await researchSingleProfile(ctx, profileUrl, 2));
+            await sleep(1500);
+        }
+    }
+    // Close tab
+    try {
+        await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+    }
+    catch { /* ok */ }
+    return {
+        url,
+        total_extracted: preFilterCount,
+        after_filter: items.length,
+        keywords_applied: keywords,
+        items: items.slice(0, 100),
+        unique_authors: authorUrls.size,
+        enriched_profiles: enriched.length > 0 ? enriched : undefined,
+    };
+}
+async function collectionWatch(args) {
+    const url = args.url;
+    const name = args.name;
+    const keywords = args.keywords ?? [];
+    const intervalMin = args.check_interval_minutes ?? 60;
+    const selector = args.selector;
+    // Load existing monitors
+    const monitorsFile = path.join(NEURON_DIR, "monitors.yaml");
+    const store = loadYaml(monitorsFile) ?? { monitors: [] };
+    const monitorId = `cw-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const monitor = {
+        id: monitorId,
+        url,
+        name,
+        check_interval_minutes: intervalMin,
+        condition: {
+            type: "new_items",
+            selector: selector ?? undefined,
+            metadata: { keywords, source: "collection_watch" },
+        },
+        enabled: true,
+        created_at: new Date().toISOString(),
+        alert_count: 0,
+    };
+    store.monitors.push(monitor);
+    saveYaml(monitorsFile, store);
+    return {
+        status: "created",
+        monitor_id: monitorId,
+        name,
+        url,
+        check_interval_minutes: intervalMin,
+        keywords,
+        message: `Collection watch "${name}" created. It will check every ${intervalMin} minutes for new items.`,
+    };
+}
+// ── Phase 3 ─────────────────────────────────────────────────
+async function localScout(args, ctx) {
+    const url = args.url;
+    const query = args.query;
+    const scrollCount = args.scrolls ?? 5;
+    const enrichProfiles = args.enrich_profiles ?? true;
+    const maxProfiles = args.max_profiles ?? 15;
+    const minFollowers = args.min_followers;
+    const requireWebsite = args.require_website ?? false;
+    const keywords = args.keywords ?? [];
+    // Open the page
+    const tab = (await call(ctx, "openTab", { url }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    // Type query if provided
+    if (query) {
+        const searchSelectors = [
+            "input[type='search']", "input[name='q']", "input[name='keywords']",
+            "input[placeholder*='earch']", "input[aria-label*='earch']",
+        ];
+        try {
+            await call(ctx, "typeText", { tabId, selectors: searchSelectors, value: query });
+            await sleep(500);
+            await call(ctx, "pressKey", { tabId, key: "Enter" });
+            await sleep(2500);
+        }
+        catch {
+            // search box might not exist on explore pages
+        }
+    }
+    // Scroll to collect results
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 800, smooth: true });
+        await sleep(700);
+    }
+    // Extract results
+    const rawData = (await call(ctx, "extractData", { tabId }));
+    let items = Array.isArray(rawData)
+        ? rawData
+        : rawData?.items ?? [rawData];
+    // Filter by keywords
+    if (keywords.length > 0) {
+        items = filterByKeywords(items, keywords);
+    }
+    // Extract unique profile URLs
+    const authorUrls = new Set();
+    for (const item of items) {
+        const obj = item;
+        const links = (obj.links ?? obj.url ?? obj.href ?? "");
+        const linkList = Array.isArray(links) ? links : [links];
+        for (const link of linkList) {
+            if (typeof link === "string" && link.startsWith("http")) {
+                authorUrls.add(link);
+            }
+        }
+    }
+    // Enrich profiles
+    let enriched = [];
+    if (enrichProfiles && authorUrls.size > 0) {
+        const toEnrich = [...authorUrls].slice(0, maxProfiles);
+        for (const profileUrl of toEnrich) {
+            const profile = await researchSingleProfile(ctx, profileUrl, 2);
+            enriched.push(profile);
+            await sleep(1500);
+        }
+    }
+    // Apply profile-level filters
+    if (enriched.length > 0 && (minFollowers != null || requireWebsite)) {
+        enriched = enriched.filter((p) => {
+            if (!p.data)
+                return false;
+            const text = JSON.stringify(p.data).toLowerCase();
+            if (minFollowers != null) {
+                // Try to find follower count in data
+                const followerMatch = text.match(/(\d[\d,]*)\s*followers/);
+                if (followerMatch) {
+                    const count = parseInt(followerMatch[1].replace(/,/g, ""), 10);
+                    if (count < minFollowers)
+                        return false;
+                }
+            }
+            if (requireWebsite) {
+                if (!text.includes("http") && !text.includes("www.") && !text.includes(".com"))
+                    return false;
+            }
+            return true;
+        });
+    }
+    // Close tab
+    try {
+        await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+    }
+    catch { /* ok */ }
+    return {
+        url,
+        query: query ?? null,
+        total_results: items.length,
+        profiles_enriched: enriched.length,
+        filters_applied: {
+            keywords: keywords.length > 0 ? keywords : null,
+            min_followers: minFollowers ?? null,
+            require_website: requireWebsite,
+        },
+        results: items.slice(0, 30),
+        profiles: enriched,
+    };
+}
+async function demandScanner(args, ctx) {
+    const url = args.url;
+    const triggers = args.triggers;
+    const scrollCount = args.scrolls ?? 5;
+    const schedule = args.schedule ?? false;
+    const intervalMin = args.check_interval_minutes ?? 120;
+    const enrichProfiles = args.enrich_profiles ?? false;
+    // Open the feed
+    const tab = (await call(ctx, "openTab", { url }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    // Scroll to collect posts
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 800, smooth: true });
+        await sleep(700);
+    }
+    // Extract posts
+    const rawData = (await call(ctx, "extractData", { tabId }));
+    const items = Array.isArray(rawData)
+        ? rawData
+        : rawData?.items ?? [rawData];
+    // Match against triggers
+    const matched = filterByKeywords(items, triggers);
+    // Enrich matched authors
+    let enriched = [];
+    if (enrichProfiles && matched.length > 0) {
+        const authorUrls = new Set();
+        for (const item of matched) {
+            const obj = item;
+            const links = (obj.links ?? obj.url ?? obj.href ?? "");
+            const linkList = Array.isArray(links) ? links : [links];
+            for (const link of linkList) {
+                if (typeof link === "string" && link.startsWith("http")) {
+                    authorUrls.add(link);
+                }
+            }
+        }
+        for (const profileUrl of [...authorUrls].slice(0, 10)) {
+            enriched.push(await researchSingleProfile(ctx, profileUrl, 2));
+            await sleep(1500);
+        }
+    }
+    // Close tab
+    try {
+        await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+    }
+    catch { /* ok */ }
+    // Create recurring monitor if scheduled
+    let monitorId = null;
+    if (schedule) {
+        const monitorsFile = path.join(NEURON_DIR, "monitors.yaml");
+        const store = loadYaml(monitorsFile) ?? { monitors: [] };
+        monitorId = `ds-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        store.monitors.push({
+            id: monitorId,
+            url,
+            name: `Demand Scanner: ${triggers.slice(0, 3).join(", ")}`,
+            check_interval_minutes: intervalMin,
+            condition: {
+                type: "new_items",
+                metadata: { triggers, source: "demand_scanner" },
+            },
+            enabled: true,
+            created_at: new Date().toISOString(),
+            alert_count: 0,
+        });
+        saveYaml(monitorsFile, store);
+    }
+    return {
+        url,
+        platform: detectPlatform(url),
+        total_posts: items.length,
+        trigger_matches: matched.length,
+        triggers,
+        matches: matched.slice(0, 30),
+        enriched_profiles: enriched.length > 0 ? enriched : undefined,
+        monitor: monitorId
+            ? { id: monitorId, check_interval_minutes: intervalMin, status: "active" }
+            : undefined,
+    };
+}
+async function opportunityRadar(args) {
+    const limit = args.limit ?? 50;
+    const sinceHours = args.since_hours ?? 24;
+    const keywords = args.keywords ?? [];
+    const alertsFile = path.join(NEURON_DIR, "monitor-alerts.yaml");
+    const store = loadYaml(alertsFile);
+    let alerts = store?.alerts ?? [];
+    // Filter by time
+    const cutoff = new Date(Date.now() - sinceHours * 60 * 60 * 1000).toISOString();
+    alerts = alerts.filter((a) => {
+        const alert = a;
+        return alert.triggered_at >= cutoff;
+    });
+    // Filter by keywords
+    if (keywords.length > 0) {
+        alerts = filterByKeywords(alerts, keywords);
+    }
+    // Sort by recency (newest first)
+    alerts.sort((a, b) => {
+        const aTime = a.triggered_at;
+        const bTime = b.triggered_at;
+        return bTime.localeCompare(aTime);
+    });
+    // Deduplicate by URL + condition type
+    const seen = new Set();
+    alerts = alerts.filter((a) => {
+        const alert = a;
+        const key = `${alert.url}:${alert.condition_type}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    // Load monitor names for context
+    const monitorsFile = path.join(NEURON_DIR, "monitors.yaml");
+    const monitorStore = loadYaml(monitorsFile);
+    const monitorNames = new Map();
+    for (const m of monitorStore?.monitors ?? []) {
+        monitorNames.set(m.id, m.name);
+    }
+    const enrichedAlerts = alerts.slice(0, limit).map((a) => {
+        const alert = a;
+        return {
+            ...alert,
+            monitor_name: alert.monitor_name ?? monitorNames.get(alert.monitor_id) ?? "unknown",
+        };
+    });
+    return {
+        total_alerts: alerts.length,
+        showing: enrichedAlerts.length,
+        since_hours: sinceHours,
+        keywords_applied: keywords,
+        opportunities: enrichedAlerts,
+    };
+}
+// ── Phase 4 ─────────────────────────────────────────────────
+async function quickAction(args, ctx) {
+    const action = args.action;
+    const text = args.text;
+    let tabId = args.tabId;
+    const url = args.url;
+    // Navigate if URL provided
+    if (url && !tabId) {
+        const tab = (await call(ctx, "openTab", { url }));
+        tabId = tab?.tabId;
+        if (!tabId)
+            throw new Error("Failed to open tab");
+        await sleep(3000);
+    }
+    if (!tabId)
+        throw new Error("Either tabId or url is required");
+    // Detect platform
+    let platform = args.platform;
+    if (!platform) {
+        try {
+            const tabUrl = (await call(ctx, "evaluateJS", {
+                tabId,
+                expression: "window.location.href",
+            }));
+            platform = detectPlatform(tabUrl);
+        }
+        catch {
+            platform = "web";
+        }
+    }
+    // Focus the tab
+    await call(ctx, "focusTab", { tabId });
+    await sleep(300);
+    // Get platform selectors
+    const selectors = PLATFORM_SELECTORS[platform] ?? {};
+    const actionMap = {
+        like: "like",
+        comment: "comment",
+        reply: "reply",
+        follow: "follow",
+        dm: "dm",
+        compose: "compose",
+    };
+    const selectorKey = actionMap[action] ?? action;
+    const targetSelectors = selectors[selectorKey] ?? [];
+    if (targetSelectors.length === 0) {
+        return {
+            status: "unsupported",
+            action,
+            platform,
+            message: `No selectors registered for "${action}" on platform "${platform}"`,
+        };
+    }
+    // For actions that just need a click (like, follow)
+    if (action === "like" || action === "follow") {
+        try {
+            await call(ctx, "clickElement", { tabId, selectors: targetSelectors });
+            await sleep(500);
+            return { status: "success", action, platform, tabId };
+        }
+        catch (err) {
+            return { status: "error", action, platform, error: err.message };
+        }
+    }
+    // For actions that need text input (comment, reply, dm, compose)
+    if (!text) {
+        return {
+            status: "text_required",
+            action,
+            platform,
+            message: `The "${action}" action requires a "text" parameter`,
+        };
+    }
+    try {
+        // Click the input area
+        await call(ctx, "clickElement", { tabId, selectors: targetSelectors });
+        await sleep(500);
+        // Type the text
+        await call(ctx, "typeText", { tabId, selectors: targetSelectors, value: text });
+        await sleep(500);
+        return {
+            status: "typed",
+            action,
+            platform,
+            tabId,
+            message: `Text typed into ${action} field. Use neuron_smart_click to find and click the submit/send button.`,
+        };
+    }
+    catch (err) {
+        return { status: "error", action, platform, error: err.message };
+    }
+}
+async function patternLearner(args, ctx) {
+    const tabId = args.tabId;
+    const examples = args.examples;
+    const patternName = args.name;
+    const shouldExtract = args.extract ?? true;
+    if (examples.length < 2) {
+        throw new Error("At least 2 example text values are required");
+    }
+    // Use evaluateJS to find DOM elements matching example text and infer a common selector
+    const result = await call(ctx, "evaluateJS", {
+        tabId,
+        expression: `
+      (function() {
+        const examples = ${JSON.stringify(examples)};
+        const matchingElements = [];
+
+        // Find elements containing each example text
+        for (const example of examples) {
+          const walker = document.createTreeWalker(
+            document.body,
+            NodeFilter.SHOW_ELEMENT,
+            null
+          );
+          let node;
+          while (node = walker.nextNode()) {
+            const el = node;
+            if (el.textContent && el.textContent.trim().includes(example.trim())) {
+              // Prefer the deepest element that contains the text
+              let deepest = el;
+              for (const child of el.querySelectorAll('*')) {
+                if (child.textContent && child.textContent.trim().includes(example.trim()) && child.children.length < el.children.length) {
+                  deepest = child;
+                }
+              }
+              matchingElements.push({
+                tag: deepest.tagName.toLowerCase(),
+                classes: [...deepest.classList],
+                id: deepest.id || null,
+                parentTag: deepest.parentElement?.tagName.toLowerCase() || null,
+                parentClasses: deepest.parentElement ? [...deepest.parentElement.classList] : [],
+              });
+              break;
+            }
+          }
+        }
+
+        if (matchingElements.length < 2) {
+          return JSON.stringify({ error: 'Could not find matching elements for all examples', found: matchingElements.length });
+        }
+
+        // Find common ancestor pattern
+        const tags = matchingElements.map(e => e.tag);
+        const commonTag = tags.every(t => t === tags[0]) ? tags[0] : '*';
+
+        // Find common classes
+        const classSets = matchingElements.map(e => new Set(e.classes));
+        const commonClasses = [...classSets[0]].filter(c =>
+          classSets.every(s => s.has(c))
+        );
+
+        // Find common parent pattern
+        const parentTags = matchingElements.map(e => e.parentTag);
+        const commonParentTag = parentTags.every(t => t === parentTags[0]) ? parentTags[0] : null;
+        const parentClassSets = matchingElements.map(e => new Set(e.parentClasses));
+        const commonParentClasses = parentClassSets[0] ? [...parentClassSets[0]].filter(c =>
+          parentClassSets.every(s => s.has(c))
+        ) : [];
+
+        // Build selector
+        let selector = commonTag;
+        if (commonClasses.length > 0) {
+          selector = commonTag + '.' + commonClasses.join('.');
+        }
+
+        let parentSelector = null;
+        if (commonParentTag) {
+          parentSelector = commonParentTag;
+          if (commonParentClasses.length > 0) {
+            parentSelector += '.' + commonParentClasses.join('.');
+          }
+        }
+
+        // Count how many elements match
+        const fullSelector = parentSelector ? parentSelector + ' > ' + selector : selector;
+        const matchCount = document.querySelectorAll(fullSelector).length;
+
+        return JSON.stringify({
+          selector: fullSelector,
+          item_selector: selector,
+          parent_selector: parentSelector,
+          match_count: matchCount,
+          elements: matchingElements,
+        });
+      })()
+    `,
+    });
+    const parsed = JSON.parse(String(result ?? "{}"));
+    if (parsed.error) {
+        return { status: "failed", error: parsed.error };
+    }
+    const inferredSelector = parsed.selector;
+    // Save pattern if named
+    if (patternName && inferredSelector) {
+        const extractorsFile = path.join(NEURON_DIR, "extractors.yaml");
+        const extractors = loadYaml(extractorsFile) ?? {};
+        extractors[patternName] = {
+            selector: inferredSelector,
+            item_selector: parsed.item_selector,
+            parent_selector: parsed.parent_selector,
+            examples,
+            learned_at: new Date().toISOString(),
+        };
+        saveYaml(extractorsFile, extractors);
+    }
+    // Extract if requested
+    let extracted = null;
+    if (shouldExtract && inferredSelector) {
+        extracted = await call(ctx, "extractData", { tabId, selector: inferredSelector });
+    }
+    return {
+        status: "success",
+        pattern_name: patternName ?? null,
+        selector: inferredSelector,
+        match_count: parsed.match_count,
+        saved: !!patternName,
+        extracted: extracted,
+    };
+}
+// ── Phase 5 ─────────────────────────────────────────────────
+async function trafficReplay(args, ctx) {
+    const mode = args.mode;
+    const name = args.name;
+    const replaysDir = path.join(NEURON_DIR, "replays");
+    ensureDir(replaysDir);
+    switch (mode) {
+        case "capture": {
+            if (!name)
+                throw new Error("Name is required for capture mode");
+            const tabId = args.tabId;
+            const platform = args.platform;
+            const harArgs = { includeBody: true };
+            if (tabId)
+                harArgs.tabId = tabId;
+            if (platform)
+                harArgs.platform = platform;
+            const har = await call(ctx, "exportHAR", harArgs);
+            const filePath = path.join(replaysDir, `${name}.har.json`);
+            fs.writeFileSync(filePath, JSON.stringify(har, null, 2), "utf-8");
+            const entries = har?.log?.entries;
+            const entryCount = Array.isArray(entries) ? entries.length : 0;
+            return {
+                status: "captured",
+                name,
+                file: filePath,
+                entries: entryCount,
+            };
+        }
+        case "replay": {
+            if (!name)
+                throw new Error("Name is required for replay mode");
+            const filePath = path.join(replaysDir, `${name}.har.json`);
+            if (!fs.existsSync(filePath)) {
+                throw new Error(`Replay "${name}" not found at ${filePath}`);
+            }
+            const harContent = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            const log = harContent.log;
+            const entries = (log?.entries ?? []);
+            // Set mock rules for each captured URL
+            let rulesSet = 0;
+            for (const entry of entries.slice(0, 50)) {
+                const request = entry.request;
+                const response = entry.response;
+                const content = response?.content;
+                const body = content?.text;
+                if (request?.url && body) {
+                    try {
+                        await call(ctx, "setMockRule", {
+                            urlPattern: request.url,
+                            matchType: "glob",
+                            responseStatus: response?.status ?? 200,
+                            responseBody: body,
+                        });
+                        rulesSet++;
+                    }
+                    catch {
+                        // skip if mock fails
+                    }
+                }
+            }
+            // Navigate if URL provided
+            const navigateUrl = args.navigate_url;
+            let tabId;
+            if (navigateUrl) {
+                const tab = (await call(ctx, "openTab", { url: navigateUrl }));
+                tabId = tab?.tabId;
+            }
+            return {
+                status: "replaying",
+                name,
+                mock_rules_set: rulesSet,
+                total_entries: entries.length,
+                tabId: tabId ?? null,
+                message: `${rulesSet} mock rules set from "${name}". Traffic will be intercepted.`,
+            };
+        }
+        case "list": {
+            const files = fs.existsSync(replaysDir)
+                ? fs.readdirSync(replaysDir).filter((f) => f.endsWith(".har.json"))
+                : [];
+            const replays = files.map((f) => {
+                const stat = fs.statSync(path.join(replaysDir, f));
+                return {
+                    name: f.replace(".har.json", ""),
+                    file: f,
+                    size_kb: Math.round(stat.size / 1024),
+                    captured_at: stat.mtime.toISOString(),
+                };
+            });
+            return { replays, count: replays.length };
+        }
+        default:
+            throw new Error(`Unknown traffic replay mode: ${mode}. Use 'capture', 'replay', or 'list'.`);
+    }
+}
+async function apiBlueprint(args, ctx) {
+    const collectionName = args.collection_name;
+    const url = args.url;
+    const includeAuth = args.include_auth ?? true;
+    // Navigate to URL if provided to capture fresh traffic
+    let tabId = args.tabId;
+    if (url) {
+        const tab = (await call(ctx, "openTab", { url }));
+        tabId = tab?.tabId;
+        if (!tabId)
+            throw new Error("Failed to open tab");
+        await sleep(3000);
+        // Scroll to trigger API calls
+        for (let i = 0; i < 3; i++) {
+            await call(ctx, "scrollPage", { tabId, deltaY: 600, smooth: true });
+            await sleep(500);
+        }
+    }
+    // Discover APIs
+    const apis = (await call(ctx, "discoverApis", {}));
+    // Get recent requests for auth headers and response details
+    const requestArgs = { limit: 200 };
+    if (tabId)
+        requestArgs.tabId = tabId;
+    const requests = (await call(ctx, "getRecentRequests", requestArgs));
+    const requestList = (requests?.requests ?? []);
+    // Build auth header map
+    const authHeaders = {};
+    if (includeAuth) {
+        for (const req of requestList) {
+            const headers = req.requestHeaders;
+            if (headers) {
+                for (const [key, value] of Object.entries(headers)) {
+                    const lk = key.toLowerCase();
+                    if (lk === "authorization" || lk === "x-api-key" || lk.includes("token") || lk.includes("csrf")) {
+                        authHeaders[key] = value;
+                    }
+                }
+            }
+        }
+    }
+    // Group endpoints by base URL
+    const endpoints = (apis?.endpoints ?? apis?.api_map ?? []);
+    const folders = new Map();
+    for (const ep of endpoints) {
+        const epUrl = String(ep.url ?? ep.pattern ?? "");
+        try {
+            const parsed = new URL(epUrl.startsWith("http") ? epUrl : `https://example.com${epUrl}`);
+            const folder = parsed.hostname.replace(/\./g, "-");
+            if (!folders.has(folder))
+                folders.set(folder, []);
+            folders.get(folder).push(ep);
+        }
+        catch {
+            if (!folders.has("misc"))
+                folders.set("misc", []);
+            folders.get("misc").push(ep);
+        }
+    }
+    // Create the collection file
+    const slug = collectionName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const collectionsDir = path.join(NEURON_DIR, "collections");
+    ensureDir(collectionsDir);
+    const collection = {
+        name: collectionName,
+        description: `API blueprint auto-generated from traffic${url ? ` on ${url}` : ""}`,
+        version: "1.0.0",
+        created_at: new Date().toISOString(),
+        defaults: {
+            headers: includeAuth ? authHeaders : {},
+        },
+        folders: {},
+    };
+    const foldersObj = collection.folders;
+    for (const [folderName, eps] of folders) {
+        foldersObj[folderName] = {
+            description: `Endpoints for ${folderName}`,
+            endpoints: eps.map((ep) => ({
+                method: String(ep.method ?? ep.methods ?? "GET").split(",")[0].trim().toUpperCase(),
+                path: String(ep.url ?? ep.pattern ?? "/"),
+                name: String(ep.name ?? ep.pattern ?? ep.url ?? "endpoint"),
+                description: `${ep.call_count ?? 0} calls observed`,
+            })),
+        };
+    }
+    saveYaml(path.join(collectionsDir, `${slug}.yaml`), collection);
+    // Close tab if we opened one
+    if (url && tabId) {
+        try {
+            await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+        }
+        catch { /* ok */ }
+    }
+    return {
+        status: "created",
+        collection_name: collectionName,
+        collection_file: `${slug}.yaml`,
+        total_endpoints: endpoints.length,
+        folders: [...folders.entries()].map(([name, eps]) => ({
+            name,
+            endpoint_count: eps.length,
+        })),
+        auth_headers_found: Object.keys(authHeaders).length,
+        source_url: url ?? "existing traffic",
+    };
+}
+// ── Wave 2 helper: extract posts from a page ────────────────
+async function extractPosts(ctx, url, scrollCount, selector) {
+    const tab = (await call(ctx, "openTab", { url }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 800, smooth: true });
+        await sleep(700);
+    }
+    const extractArgs = { tabId };
+    if (selector)
+        extractArgs.selector = selector;
+    const rawData = (await call(ctx, "extractData", extractArgs));
+    const items = Array.isArray(rawData)
+        ? rawData
+        : rawData?.items ?? [rawData];
+    return { tabId, items };
+}
+async function closeTab(ctx, tabId) {
+    try {
+        await call(ctx, "evaluateJS", { tabId, expression: "window.close()" });
+    }
+    catch { /* ok */ }
+}
+async function pageWatch(args) {
+    const url = args.url;
+    const name = args.name;
+    const selector = args.selector;
+    const intervalMin = args.check_interval_minutes ?? 60;
+    const keywords = args.keywords ?? [];
+    // Load existing monitors
+    const monitorsFile = path.join(NEURON_DIR, "monitors.yaml");
+    const store = loadYaml(monitorsFile) ?? { monitors: [] };
+    const monitorId = `pw-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const monitor = {
+        id: monitorId,
+        url,
+        name,
+        check_interval_minutes: intervalMin,
+        condition: {
+            type: "content_change",
+            selector: selector ?? undefined,
+            metadata: { keywords, source: "page_watch", use_structured_diff: true },
+        },
+        enabled: true,
+        created_at: new Date().toISOString(),
+        alert_count: 0,
+    };
+    store.monitors.push(monitor);
+    saveYaml(monitorsFile, store);
+    return {
+        status: "created",
+        monitor_id: monitorId,
+        name,
+        url,
+        selector: selector ?? "full page",
+        check_interval_minutes: intervalMin,
+        keywords,
+        message: `Page watch "${name}" created. It will check ${url} every ${intervalMin} minutes for content changes.`,
+    };
+}
+// ── Wave 2 implementations ──────────────────────────────────
+async function revenueTracker(args) {
+    const action = args.action;
+    const pipelineFile = path.join(NEURON_DIR, "pipeline.yaml");
+    const pipeline = loadYaml(pipelineFile) ?? { leads: [] };
+    switch (action) {
+        case "add_lead": {
+            const lead = args.lead;
+            if (!lead)
+                throw new Error("Lead data required for add_lead");
+            const id = `lead-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            pipeline.leads.push({
+                id,
+                ...lead,
+                stage: "discovered",
+                revenue: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                history: [{ stage: "discovered", at: new Date().toISOString() }],
+            });
+            saveYaml(pipelineFile, pipeline);
+            return { status: "added", lead_id: id, stage: "discovered" };
+        }
+        case "update_stage": {
+            const leadId = args.lead_id;
+            const stage = args.stage;
+            if (!leadId || !stage)
+                throw new Error("lead_id and stage required");
+            const lead = pipeline.leads.find((l) => l.id === leadId);
+            if (!lead)
+                throw new Error(`Lead ${leadId} not found`);
+            lead.stage = stage;
+            lead.updated_at = new Date().toISOString();
+            const history = lead.history ?? [];
+            history.push({ stage, at: new Date().toISOString() });
+            lead.history = history;
+            saveYaml(pipelineFile, pipeline);
+            return { status: "updated", lead_id: leadId, stage };
+        }
+        case "tag_revenue": {
+            const leadId = args.lead_id;
+            const revenue = args.revenue;
+            if (!leadId || revenue == null)
+                throw new Error("lead_id and revenue required");
+            const lead = pipeline.leads.find((l) => l.id === leadId);
+            if (!lead)
+                throw new Error(`Lead ${leadId} not found`);
+            lead.revenue = revenue;
+            lead.stage = "closed_won";
+            lead.updated_at = new Date().toISOString();
+            const history = lead.history ?? [];
+            history.push({ stage: "closed_won", revenue, at: new Date().toISOString() });
+            lead.history = history;
+            saveYaml(pipelineFile, pipeline);
+            return { status: "revenue_tagged", lead_id: leadId, revenue };
+        }
+        case "list": {
+            const filters = (args.filters ?? {});
+            let leads = pipeline.leads;
+            if (filters.stage)
+                leads = leads.filter((l) => l.stage === filters.stage);
+            if (filters.source)
+                leads = leads.filter((l) => String(l.source_tool ?? l.source ?? "").includes(filters.source));
+            if (filters.platform)
+                leads = leads.filter((l) => l.platform === filters.platform);
+            if (filters.since_days) {
+                const cutoff = new Date(Date.now() - filters.since_days * 86400000).toISOString();
+                leads = leads.filter((l) => l.created_at >= cutoff);
+            }
+            return { total: leads.length, leads };
+        }
+        case "stats": {
+            const stages = {};
+            const sources = {};
+            let totalRevenue = 0;
+            for (const lead of pipeline.leads) {
+                const s = lead.stage;
+                stages[s] = (stages[s] ?? 0) + 1;
+                const src = String(lead.source_tool ?? lead.source ?? "unknown");
+                sources[src] = (sources[src] ?? 0) + 1;
+                totalRevenue += lead.revenue ?? 0;
+            }
+            return {
+                total_leads: pipeline.leads.length,
+                by_stage: stages,
+                by_source: sources,
+                total_revenue: totalRevenue,
+                conversion_rate: pipeline.leads.length > 0
+                    ? `${Math.round((stages.closed_won ?? 0) / pipeline.leads.length * 100)}%`
+                    : "0%",
+            };
+        }
+        default:
+            throw new Error(`Unknown revenue tracker action: ${action}`);
+    }
+}
+async function leadScorer(args) {
+    const leads = args.leads;
+    const rubric = (args.rubric ?? {});
+    const hotThreshold = args.hot_threshold ?? 80;
+    const warmThreshold = args.warm_threshold ?? 50;
+    const bioKeywords = rubric.bio_keywords ?? ["founder", "ceo", "business", "owner", "entrepreneur"];
+    const locationKeywords = rubric.location_keywords ?? [];
+    const followerMin = rubric.follower_min ?? 0;
+    const followerMax = rubric.follower_max ?? Infinity;
+    const requireWebsite = rubric.require_website ?? false;
+    const maxDaysSincePost = rubric.max_days_since_post;
+    const scored = leads.map((lead) => {
+        let score = 50; // base score
+        const text = JSON.stringify(lead).toLowerCase();
+        const breakdown = {};
+        // Bio keyword matching (+5 per match, max 25)
+        let bioMatch = 0;
+        for (const kw of bioKeywords) {
+            if (text.includes(kw.toLowerCase()))
+                bioMatch++;
+        }
+        const bioScore = Math.min(bioMatch * 5, 25);
+        score += bioScore;
+        breakdown.bio_keywords = bioScore;
+        // Follower count
+        const followerMatch = text.match(/(\d[\d,]*)\s*followers/);
+        if (followerMatch) {
+            const count = parseInt(followerMatch[1].replace(/,/g, ""), 10);
+            if (count >= followerMin && count <= followerMax) {
+                const followerScore = Math.min(Math.floor(count / 1000), 15);
+                score += followerScore;
+                breakdown.followers = followerScore;
+            }
+            else {
+                score -= 20;
+                breakdown.followers = -20;
+            }
+        }
+        // Website presence
+        if (text.includes("http") || text.includes("www.") || text.includes(".com")) {
+            score += 10;
+            breakdown.website = 10;
+        }
+        else if (requireWebsite) {
+            score -= 30;
+            breakdown.website = -30;
+        }
+        // Location match
+        if (locationKeywords.length > 0) {
+            const locMatch = locationKeywords.some((l) => text.includes(l.toLowerCase()));
+            if (locMatch) {
+                score += 10;
+                breakdown.location = 10;
+            }
+        }
+        // Engagement signals
+        if (text.includes("engaged") || text.includes("active")) {
+            score += 5;
+            breakdown.engagement = 5;
+        }
+        // Clamp score
+        score = Math.max(0, Math.min(100, score));
+        const tier = score >= hotThreshold ? "hot" : score >= warmThreshold ? "warm" : "cold";
+        const recommended = tier === "hot" ? "DM immediately"
+            : tier === "warm" ? "Comment/engage first"
+                : "Follow and nurture";
+        return { ...lead, score, tier, recommended_action: recommended, score_breakdown: breakdown };
+    });
+    // Sort by score descending
+    scored.sort((a, b) => b.score - a.score);
+    return {
+        total: scored.length,
+        hot: scored.filter((s) => s.tier === "hot").length,
+        warm: scored.filter((s) => s.tier === "warm").length,
+        cold: scored.filter((s) => s.tier === "cold").length,
+        thresholds: { hot: hotThreshold, warm: warmThreshold },
+        leads: scored,
+    };
+}
+async function socialProof(args, ctx) {
+    const action = args.action;
+    const testimonialsFile = path.join(NEURON_DIR, "testimonials.yaml");
+    switch (action) {
+        case "scan": {
+            const url = args.url;
+            if (!url)
+                throw new Error("URL required for scan action");
+            const brandKeywords = args.brand_keywords ?? [];
+            const positiveSignals = args.positive_signals ?? [
+                "changed my", "love this", "best", "recommend", "game changer",
+                "amazing", "thank you", "incredible", "life saver", "must have",
+            ];
+            const scrollCount = args.scrolls ?? 5;
+            const { tabId, items } = await extractPosts(ctx, url, scrollCount);
+            // Filter for positive mentions
+            const allSignals = [...positiveSignals, ...brandKeywords];
+            const matches = filterByKeywords(items, allSignals);
+            // Save testimonials
+            const store = loadYaml(testimonialsFile) ?? { testimonials: [] };
+            for (const match of matches) {
+                store.testimonials.push({
+                    ...match,
+                    source_url: url,
+                    captured_at: new Date().toISOString(),
+                    matched_signals: allSignals.filter((s) => JSON.stringify(match).toLowerCase().includes(s.toLowerCase())),
+                });
+            }
+            saveYaml(testimonialsFile, store);
+            await closeTab(ctx, tabId);
+            return {
+                url,
+                total_scanned: items.length,
+                testimonials_found: matches.length,
+                saved: matches.length,
+                testimonials: matches.slice(0, 20),
+            };
+        }
+        case "list": {
+            const store = loadYaml(testimonialsFile);
+            const testimonials = store?.testimonials ?? [];
+            return { total: testimonials.length, testimonials: testimonials.slice(-50) };
+        }
+        case "export": {
+            const store = loadYaml(testimonialsFile);
+            return { testimonials: store?.testimonials ?? [], format: "json" };
+        }
+        default:
+            throw new Error(`Unknown social proof action: ${action}`);
+    }
+}
+async function dmOutreach(args, ctx) {
+    const action = args.action;
+    const campaignsFile = path.join(NEURON_DIR, "outreach-campaigns.yaml");
+    switch (action) {
+        case "preview": {
+            const template = args.template;
+            const leads = args.leads?.slice(0, 3) ?? [];
+            if (!template)
+                throw new Error("Template required for preview");
+            const previews = leads.map((lead) => {
+                let msg = template;
+                for (const [key, value] of Object.entries(lead)) {
+                    msg = msg.replace(new RegExp(`\\{${key}\\}`, "g"), String(value ?? ""));
+                }
+                return { lead, message: msg };
+            });
+            return { action: "preview", previews };
+        }
+        case "start": {
+            const template = args.template;
+            const leads = args.leads;
+            const platform = args.platform;
+            const delayMin = args.delay_minutes ?? 5;
+            const maxPerDay = args.max_per_day ?? 20;
+            if (!template || !leads?.length || !platform) {
+                throw new Error("template, leads, and platform required");
+            }
+            const campaignId = `dm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const campaigns = loadYaml(campaignsFile) ?? { campaigns: [] };
+            campaigns.campaigns.push({
+                id: campaignId,
+                platform,
+                template,
+                total_leads: leads.length,
+                delay_minutes: delayMin,
+                max_per_day: maxPerDay,
+                status: "active",
+                sent: 0,
+                replied: 0,
+                created_at: new Date().toISOString(),
+                leads: leads.map((l) => ({ ...l, status: "queued" })),
+            });
+            saveYaml(campaignsFile, campaigns);
+            // Send first message
+            const firstLead = leads[0];
+            let msg = template;
+            for (const [key, value] of Object.entries(firstLead)) {
+                msg = msg.replace(new RegExp(`\\{${key}\\}`, "g"), String(value ?? ""));
+            }
+            const selectors = PLATFORM_SELECTORS[platform]?.dm ?? [];
+            if (selectors.length > 0 && firstLead.url) {
+                try {
+                    const tab = (await call(ctx, "openTab", { url: firstLead.url }));
+                    if (tab?.tabId) {
+                        await sleep(3000);
+                        await call(ctx, "focusTab", { tabId: tab.tabId });
+                        await sleep(300);
+                        // Navigate to DM
+                        await call(ctx, "clickElement", { tabId: tab.tabId, selectors });
+                        await sleep(1000);
+                        await call(ctx, "typeText", { tabId: tab.tabId, selectors, value: msg });
+                    }
+                }
+                catch {
+                    // first message send failed, campaign still created
+                }
+            }
+            return {
+                status: "started",
+                campaign_id: campaignId,
+                total_leads: leads.length,
+                delay_minutes: delayMin,
+                first_message: msg,
+                message: `Campaign started. ${leads.length} leads queued. Sending 1 every ${delayMin} minutes (max ${maxPerDay}/day).`,
+            };
+        }
+        case "status": {
+            const campaignId = args.campaign_id;
+            const campaigns = loadYaml(campaignsFile);
+            if (!campaignId) {
+                return { campaigns: campaigns?.campaigns?.map((c) => ({ id: c.id, status: c.status, sent: c.sent, total: c.total_leads })) ?? [] };
+            }
+            const campaign = campaigns?.campaigns?.find((c) => c.id === campaignId);
+            if (!campaign)
+                throw new Error(`Campaign ${campaignId} not found`);
+            return campaign;
+        }
+        case "pause": {
+            const campaignId = args.campaign_id;
+            if (!campaignId)
+                throw new Error("campaign_id required");
+            const campaigns = loadYaml(campaignsFile);
+            const campaign = campaigns?.campaigns?.find((c) => c.id === campaignId);
+            if (!campaign)
+                throw new Error(`Campaign ${campaignId} not found`);
+            campaign.status = "paused";
+            saveYaml(campaignsFile, campaigns);
+            return { status: "paused", campaign_id: campaignId };
+        }
+        default:
+            throw new Error(`Unknown dm outreach action: ${action}`);
+    }
+}
+async function postToLead(args, ctx) {
+    const postUrl = args.post_url;
+    const trigger = args.trigger;
+    const enrichProfiles = args.enrich_profiles ?? true;
+    const scrollCount = args.scrolls ?? 5;
+    const schedule = args.schedule ?? false;
+    const intervalMin = args.check_interval_minutes ?? 30;
+    // Open the post
+    const { tabId, items } = await extractPosts(ctx, postUrl, scrollCount);
+    // Find comments matching the trigger keyword
+    const matched = filterByKeywords(items, [trigger]);
+    // Enrich matched commenters
+    let enriched = [];
+    if (enrichProfiles && matched.length > 0) {
+        const authorUrls = new Set();
+        for (const item of matched) {
+            const obj = item;
+            const links = (obj.links ?? obj.url ?? obj.href ?? "");
+            const linkList = Array.isArray(links) ? links : [links];
+            for (const link of linkList) {
+                if (typeof link === "string" && link.startsWith("http"))
+                    authorUrls.add(link);
+            }
+        }
+        for (const profileUrl of [...authorUrls].slice(0, 20)) {
+            enriched.push(await researchSingleProfile(ctx, profileUrl, 2));
+            await sleep(1500);
+        }
+    }
+    await closeTab(ctx, tabId);
+    // Create monitor if scheduled
+    let monitorId = null;
+    if (schedule) {
+        const monitorsFile = path.join(NEURON_DIR, "monitors.yaml");
+        const store = loadYaml(monitorsFile) ?? { monitors: [] };
+        monitorId = `ptl-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        store.monitors.push({
+            id: monitorId,
+            url: postUrl,
+            name: `Post-to-Lead: "${trigger}" on ${postUrl.slice(0, 50)}`,
+            check_interval_minutes: intervalMin,
+            condition: { type: "new_items", metadata: { trigger, source: "post_to_lead" } },
+            enabled: true,
+            created_at: new Date().toISOString(),
+            alert_count: 0,
+        });
+        saveYaml(monitorsFile, store);
+    }
+    return {
+        post_url: postUrl,
+        trigger,
+        total_comments: items.length,
+        trigger_matches: matched.length,
+        leads: enriched.length > 0 ? enriched : matched.slice(0, 30),
+        monitor: monitorId ? { id: monitorId, interval: intervalMin } : undefined,
+    };
+}
+async function commentMiner(args, ctx) {
+    const postUrl = args.post_url;
+    const keywords = args.keywords ?? [];
+    const enrichProfiles = args.enrich_profiles ?? true;
+    const maxProfiles = args.max_profiles ?? 20;
+    const scrollCount = args.scrolls ?? 5;
+    const { tabId, items } = await extractPosts(ctx, postUrl, scrollCount);
+    let filtered = items;
+    if (keywords.length > 0) {
+        filtered = filterByKeywords(items, keywords);
+    }
+    // Extract unique commenter URLs
+    const authorUrls = new Set();
+    for (const item of filtered) {
+        const obj = item;
+        const links = (obj.links ?? obj.url ?? obj.href ?? "");
+        const linkList = Array.isArray(links) ? links : [links];
+        for (const link of linkList) {
+            if (typeof link === "string" && link.startsWith("http"))
+                authorUrls.add(link);
+        }
+    }
+    let enriched = [];
+    if (enrichProfiles && authorUrls.size > 0) {
+        for (const profileUrl of [...authorUrls].slice(0, maxProfiles)) {
+            enriched.push(await researchSingleProfile(ctx, profileUrl, 2));
+            await sleep(1500);
+        }
+    }
+    await closeTab(ctx, tabId);
+    return {
+        post_url: postUrl,
+        total_comments: items.length,
+        filtered: filtered.length,
+        keywords_applied: keywords,
+        unique_commenters: authorUrls.size,
+        comments: filtered.slice(0, 50),
+        profiles: enriched,
+    };
+}
+async function competitorMapper(args, ctx) {
+    const profileUrl = args.profile_url;
+    const postsToScan = args.posts_to_scan ?? 5;
+    const maxCommenters = args.max_commenters ?? 20;
+    const scrollsPerPost = args.scrolls_per_post ?? 3;
+    const yourHandle = args.your_handle;
+    // Visit competitor profile
+    const tab = (await call(ctx, "openTab", { url: profileUrl }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    // Scroll to load posts
+    for (let i = 0; i < 3; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 600, smooth: true });
+        await sleep(500);
+    }
+    // Extract post links
+    const profileData = (await call(ctx, "extractData", { tabId }));
+    const profileItems = Array.isArray(profileData)
+        ? profileData
+        : profileData?.items ?? [profileData];
+    // Find post URLs
+    const postUrls = [];
+    for (const item of profileItems) {
+        const text = JSON.stringify(item);
+        const urlMatches = text.match(/https?:\/\/[^\s"',]+\/p\/[^\s"',]+/g) ??
+            text.match(/https?:\/\/[^\s"',]+\/status\/[^\s"',]+/g) ?? [];
+        for (const u of urlMatches) {
+            if (!postUrls.includes(u))
+                postUrls.push(u);
+        }
+    }
+    await closeTab(ctx, tabId);
+    // Visit each post and extract commenters
+    const commenterFrequency = new Map();
+    const commenterData = new Map();
+    for (const postUrl of postUrls.slice(0, postsToScan)) {
+        try {
+            const { tabId: postTabId, items } = await extractPosts(ctx, postUrl, scrollsPerPost);
+            for (const item of items) {
+                const obj = item;
+                const links = (obj.links ?? obj.url ?? obj.href ?? "");
+                const linkList = Array.isArray(links) ? links : [links];
+                for (const link of linkList) {
+                    if (typeof link === "string" && link.startsWith("http")) {
+                        commenterFrequency.set(link, (commenterFrequency.get(link) ?? 0) + 1);
+                        if (!commenterData.has(link))
+                            commenterData.set(link, item);
+                    }
+                }
+            }
+            await closeTab(ctx, postTabId);
+            await sleep(1500);
+        }
+        catch {
+            // skip failed posts
+        }
+    }
+    // Sort by frequency and enrich top commenters
+    const sorted = [...commenterFrequency.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, maxCommenters);
+    const enriched = [];
+    for (const [url, frequency] of sorted) {
+        const profile = await researchSingleProfile(ctx, url, 2);
+        const text = JSON.stringify(profile.data).toLowerCase();
+        // Categorize
+        let category = "casual_follower";
+        if (text.includes("founder") || text.includes("ceo") || text.includes("business") || text.includes("owner")) {
+            category = "potential_customer";
+        }
+        else if (text.includes("agency") || text.includes("marketing") || text.includes("consulting")) {
+            category = "fellow_business";
+        }
+        else if (text.match(/(\d[\d,]*)\s*followers/) && parseInt((text.match(/(\d[\d,]*)\s*followers/) ?? ["0", "0"])[1].replace(/,/g, ""), 10) > 10000) {
+            category = "influencer";
+        }
+        const isOverlap = yourHandle ? text.includes(yourHandle.toLowerCase()) : false;
+        enriched.push({
+            url,
+            frequency,
+            category,
+            overlap_with_you: isOverlap,
+            profile: profile.data,
+            error: profile.error,
+        });
+        await sleep(1500);
+    }
+    return {
+        competitor: profileUrl,
+        posts_scanned: Math.min(postsToScan, postUrls.length),
+        unique_commenters: commenterFrequency.size,
+        enriched: enriched.length,
+        commenters: enriched,
+    };
+}
+async function influencerVetter(args, ctx) {
+    const profileUrl = args.profile_url;
+    const postsToAnalyze = args.posts_to_analyze ?? 10;
+    const scrollCount = args.scrolls ?? 3;
+    // Visit profile
+    const tab = (await call(ctx, "openTab", { url: profileUrl }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 600, smooth: true });
+        await sleep(500);
+    }
+    const profileData = (await call(ctx, "extractData", { tabId }));
+    const text = JSON.stringify(profileData).toLowerCase();
+    // Extract metrics
+    const followerMatch = text.match(/(\d[\d,]*)\s*followers/);
+    const followingMatch = text.match(/(\d[\d,]*)\s*following/);
+    const postsMatch = text.match(/(\d[\d,]*)\s*posts/);
+    const followers = followerMatch ? parseInt(followerMatch[1].replace(/,/g, ""), 10) : 0;
+    const following = followingMatch ? parseInt(followingMatch[1].replace(/,/g, ""), 10) : 0;
+    const postCount = postsMatch ? parseInt(postsMatch[1].replace(/,/g, ""), 10) : 0;
+    // Analyze engagement from visible posts
+    const items = Array.isArray(profileData)
+        ? profileData
+        : profileData?.items ?? [profileData];
+    let totalEngagement = 0;
+    let genericComments = 0;
+    let substantiveComments = 0;
+    for (const item of items.slice(0, postsToAnalyze)) {
+        const itemText = JSON.stringify(item).toLowerCase();
+        const likeMatch = itemText.match(/(\d[\d,]*)\s*likes?/);
+        const commentMatch = itemText.match(/(\d[\d,]*)\s*comments?/);
+        totalEngagement += likeMatch ? parseInt(likeMatch[1].replace(/,/g, ""), 10) : 0;
+        totalEngagement += commentMatch ? parseInt(commentMatch[1].replace(/,/g, ""), 10) : 0;
+        // Simple comment quality heuristic
+        const genericPatterns = /^(nice|great|love|wow|fire|amazing|beautiful|❤|🔥|👏|💯|😍)\s*[!.]?$/;
+        if (genericPatterns.test(itemText.trim()))
+            genericComments++;
+        else if (itemText.length > 20)
+            substantiveComments++;
+    }
+    await closeTab(ctx, tabId);
+    // Calculate scores
+    const engagementRate = followers > 0 ? (totalEngagement / Math.max(items.length, 1)) / followers * 100 : 0;
+    const followRatio = following > 0 ? followers / following : 0;
+    const commentQuality = (genericComments + substantiveComments) > 0
+        ? substantiveComments / (genericComments + substantiveComments) * 100
+        : 50;
+    // Build trust score
+    let trustScore = 50;
+    const redFlags = [];
+    const positives = [];
+    // Engagement rate scoring
+    if (engagementRate > 3) {
+        trustScore += 15;
+        positives.push(`Good engagement rate: ${engagementRate.toFixed(2)}%`);
+    }
+    else if (engagementRate > 1) {
+        trustScore += 5;
+    }
+    else if (engagementRate < 0.5 && followers > 10000) {
+        trustScore -= 20;
+        redFlags.push(`Very low engagement (${engagementRate.toFixed(2)}%) for ${followers.toLocaleString()} followers — possible purchased audience`);
+    }
+    // Follow ratio
+    if (followRatio > 5) {
+        trustScore += 10;
+        positives.push("Healthy follower-to-following ratio");
+    }
+    else if (followRatio < 1) {
+        trustScore -= 10;
+        redFlags.push("Following more people than followers — may use follow/unfollow tactics");
+    }
+    // Comment quality
+    if (commentQuality > 60) {
+        trustScore += 10;
+        positives.push("Substantive comment quality");
+    }
+    else if (commentQuality < 30) {
+        trustScore -= 10;
+        redFlags.push("Most engagement appears generic/bot-like");
+    }
+    // Posting consistency
+    if (postCount > 100) {
+        trustScore += 5;
+        positives.push("Consistent posting history");
+    }
+    trustScore = Math.max(0, Math.min(100, trustScore));
+    return {
+        profile_url: profileUrl,
+        platform: detectPlatform(profileUrl),
+        trust_score: trustScore,
+        verdict: trustScore >= 70 ? "likely_authentic" : trustScore >= 40 ? "moderate_risk" : "high_risk",
+        metrics: {
+            followers,
+            following,
+            posts: postCount,
+            engagement_rate: `${engagementRate.toFixed(2)}%`,
+            follow_ratio: followRatio.toFixed(1),
+            comment_quality: `${commentQuality.toFixed(0)}%`,
+        },
+        red_flags: redFlags,
+        positives,
+        posts_analyzed: Math.min(postsToAnalyze, items.length),
+    };
+}
+async function engagementAnalyzer(args, ctx) {
+    const profileUrl = args.profile_url;
+    const postsToAnalyze = args.posts_to_analyze ?? 20;
+    const scrollCount = args.scrolls ?? 5;
+    const tab = (await call(ctx, "openTab", { url: profileUrl }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(3000);
+    for (let i = 0; i < scrollCount; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 600, smooth: true });
+        await sleep(500);
+    }
+    const profileData = (await call(ctx, "extractData", { tabId }));
+    const items = Array.isArray(profileData)
+        ? profileData
+        : profileData?.items ?? [profileData];
+    await closeTab(ctx, tabId);
+    // Analyze posts
+    const postAnalysis = [];
+    let totalLikes = 0;
+    let totalComments = 0;
+    const hashtags = {};
+    for (const item of items.slice(0, postsToAnalyze)) {
+        const text = JSON.stringify(item).toLowerCase();
+        const likeMatch = text.match(/(\d[\d,]*)\s*likes?/);
+        const commentMatch = text.match(/(\d[\d,]*)\s*comments?/);
+        const likes = likeMatch ? parseInt(likeMatch[1].replace(/,/g, ""), 10) : 0;
+        const comments = commentMatch ? parseInt(commentMatch[1].replace(/,/g, ""), 10) : 0;
+        totalLikes += likes;
+        totalComments += comments;
+        // Extract hashtags
+        const hashMatches = text.match(/#\w+/g) ?? [];
+        for (const h of hashMatches) {
+            hashtags[h] = (hashtags[h] ?? 0) + 1;
+        }
+        // Detect content type
+        let contentType = "text";
+        if (text.includes("video") || text.includes("reel"))
+            contentType = "video";
+        else if (text.includes("carousel") || text.includes("slides"))
+            contentType = "carousel";
+        else if (text.includes("image") || text.includes("photo"))
+            contentType = "image";
+        postAnalysis.push({ likes, comments, engagement: likes + comments, content_type: contentType });
+    }
+    const avgEngagement = postAnalysis.length > 0
+        ? (totalLikes + totalComments) / postAnalysis.length
+        : 0;
+    // Top performing content types
+    const byType = {};
+    for (const p of postAnalysis) {
+        const ct = p.content_type;
+        if (!byType[ct])
+            byType[ct] = { count: 0, avg_engagement: 0 };
+        byType[ct].count++;
+        byType[ct].avg_engagement += p.engagement;
+    }
+    for (const ct of Object.keys(byType)) {
+        byType[ct].avg_engagement = Math.round(byType[ct].avg_engagement / byType[ct].count);
+    }
+    // Top hashtags
+    const topHashtags = Object.entries(hashtags)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([tag, count]) => ({ tag, uses: count }));
+    // Recommendations
+    const recommendations = [];
+    const bestType = Object.entries(byType).sort((a, b) => b[1].avg_engagement - a[1].avg_engagement)[0];
+    if (bestType) {
+        recommendations.push(`${bestType[0]} posts average ${bestType[1].avg_engagement} engagement — lean into this format`);
+    }
+    if (topHashtags.length > 0) {
+        recommendations.push(`Top hashtags: ${topHashtags.slice(0, 3).map((h) => h.tag).join(", ")}`);
+    }
+    if (avgEngagement > 0) {
+        recommendations.push(`Average engagement per post: ${Math.round(avgEngagement)}`);
+    }
+    return {
+        profile_url: profileUrl,
+        posts_analyzed: postAnalysis.length,
+        total_likes: totalLikes,
+        total_comments: totalComments,
+        avg_engagement: Math.round(avgEngagement),
+        content_type_breakdown: byType,
+        top_hashtags: topHashtags,
+        recommendations,
+        post_details: postAnalysis,
+    };
+}
+async function mentionTracker(args, ctx) {
+    const url = args.url;
+    const brandTerms = args.brand_terms;
+    const scrollCount = args.scrolls ?? 5;
+    const enrichProfiles = args.enrich_profiles ?? false;
+    const schedule = args.schedule ?? false;
+    const intervalMin = args.check_interval_minutes ?? 60;
+    const { tabId, items } = await extractPosts(ctx, url, scrollCount);
+    const matches = filterByKeywords(items, brandTerms);
+    // Save mentions
+    const mentionsFile = path.join(NEURON_DIR, "mentions.yaml");
+    const store = loadYaml(mentionsFile) ?? { mentions: [] };
+    for (const match of matches) {
+        store.mentions.push({
+            ...match,
+            brand_terms_matched: brandTerms.filter((t) => JSON.stringify(match).toLowerCase().includes(t.toLowerCase())),
+            source_url: url,
+            detected_at: new Date().toISOString(),
+        });
+    }
+    saveYaml(mentionsFile, store);
+    // Enrich if requested
+    let enriched = [];
+    if (enrichProfiles && matches.length > 0) {
+        const authorUrls = new Set();
+        for (const item of matches) {
+            const obj = item;
+            const links = (obj.links ?? obj.url ?? obj.href ?? "");
+            for (const link of (Array.isArray(links) ? links : [links])) {
+                if (typeof link === "string" && link.startsWith("http"))
+                    authorUrls.add(link);
+            }
+        }
+        for (const profileUrl of [...authorUrls].slice(0, 10)) {
+            enriched.push(await researchSingleProfile(ctx, profileUrl, 2));
+            await sleep(1500);
+        }
+    }
+    await closeTab(ctx, tabId);
+    // Schedule if requested
+    let monitorId = null;
+    if (schedule) {
+        const monitorsFile = path.join(NEURON_DIR, "monitors.yaml");
+        const monitorStore = loadYaml(monitorsFile) ?? { monitors: [] };
+        monitorId = `mt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        monitorStore.monitors.push({
+            id: monitorId,
+            url,
+            name: `Mention Tracker: ${brandTerms.slice(0, 3).join(", ")}`,
+            check_interval_minutes: intervalMin,
+            condition: { type: "new_items", metadata: { brand_terms: brandTerms, source: "mention_tracker" } },
+            enabled: true,
+            created_at: new Date().toISOString(),
+            alert_count: 0,
+        });
+        saveYaml(monitorsFile, monitorStore);
+    }
+    return {
+        url,
+        brand_terms: brandTerms,
+        total_scanned: items.length,
+        mentions_found: matches.length,
+        mentions: matches.slice(0, 30),
+        enriched_profiles: enriched.length > 0 ? enriched : undefined,
+        monitor: monitorId ? { id: monitorId, interval: intervalMin } : undefined,
+    };
+}
+async function postAnalyzer(args, ctx) {
+    const url = args.url;
+    const batch = args.batch ?? false;
+    const postsCount = args.posts_count ?? 20;
+    const scrollCount = args.scrolls ?? 3;
+    const { tabId, items } = await extractPosts(ctx, url, batch ? scrollCount + 2 : scrollCount);
+    const analyzed = items.slice(0, batch ? postsCount : 1).map((item) => {
+        const text = JSON.stringify(item).toLowerCase();
+        const obj = item;
+        const likeMatch = text.match(/(\d[\d,]*)\s*likes?/);
+        const commentMatch = text.match(/(\d[\d,]*)\s*comments?/);
+        const shareMatch = text.match(/(\d[\d,]*)\s*(shares?|reposts?)/);
+        const viewMatch = text.match(/(\d[\d,]*)\s*views?/);
+        const hashMatches = text.match(/#\w+/g) ?? [];
+        const mentionMatches = text.match(/@\w+/g) ?? [];
+        let contentType = "text";
+        if (text.includes("video") || text.includes("reel"))
+            contentType = "video";
+        else if (text.includes("carousel") || text.includes("slides"))
+            contentType = "carousel";
+        else if (text.includes("image") || text.includes("photo"))
+            contentType = "image";
+        return {
+            ...obj,
+            metrics: {
+                likes: likeMatch ? parseInt(likeMatch[1].replace(/,/g, ""), 10) : null,
+                comments: commentMatch ? parseInt(commentMatch[1].replace(/,/g, ""), 10) : null,
+                shares: shareMatch ? parseInt(shareMatch[1].replace(/,/g, ""), 10) : null,
+                views: viewMatch ? parseInt(viewMatch[1].replace(/,/g, ""), 10) : null,
+            },
+            content_type: contentType,
+            hashtags: hashMatches,
+            mentions: mentionMatches,
+        };
+    });
+    await closeTab(ctx, tabId);
+    return {
+        url,
+        platform: detectPlatform(url),
+        batch,
+        posts_analyzed: analyzed.length,
+        posts: analyzed,
+    };
+}
+async function contentPipeline(args, ctx) {
+    const sourceUrl = args.source_url;
+    const targetPlatform = args.target_platform;
+    const scrollCount = args.scrolls ?? 5;
+    // Extract source content
+    const { tabId, items } = await extractPosts(ctx, sourceUrl, scrollCount);
+    // Also get the page's text content
+    let pageText = "";
+    try {
+        pageText = String(await call(ctx, "evaluateJS", {
+            tabId,
+            expression: `
+        const article = document.querySelector('article') || document.querySelector('[role="main"]') || document.body;
+        article.innerText.substring(0, 5000);
+      `,
+        }));
+    }
+    catch {
+        pageText = JSON.stringify(items).substring(0, 5000);
+    }
+    await closeTab(ctx, tabId);
+    // Platform-specific formatting hints
+    const formatGuide = {
+        linkedin: {
+            max_chars: 3000,
+            format: "line breaks between sentences, emoji sparingly, 3-5 hashtags at end",
+            hook_style: "Bold first line, line break, story or stat",
+            cta: "Comment below, follow for more, share if you agree",
+        },
+        x: {
+            max_chars: 280,
+            format: "Thread if long, numbered tweets, no hashtag spam",
+            hook_style: "Hot take, contrarian, or surprising stat",
+            cta: "RT if you agree, follow for more",
+        },
+        instagram: {
+            max_chars: 2200,
+            format: "Caption with line breaks, 20-30 hashtags in first comment",
+            hook_style: "Stop-scroll first sentence, emoji hooks",
+            cta: "Save this, share to stories, link in bio",
+        },
+        tiktok: {
+            max_chars: 300,
+            format: "Script format: hook (3s), body (20-40s), CTA (3s)",
+            hook_style: "POV:, What if, Story time, Controversial opener",
+            cta: "Follow for part 2, comment your experience",
+        },
+        newsletter: {
+            max_chars: 10000,
+            format: "Subject line, preview text, sections with headers, CTA button",
+            hook_style: "Subject: curiosity gap or direct benefit",
+            cta: "Reply to this email, share with a friend",
+        },
+        blog: {
+            max_chars: 20000,
+            format: "H1, intro, H2 sections, bullet points, conclusion, meta description",
+            hook_style: "SEO-aware title, engaging first paragraph",
+            cta: "Subscribe, read related posts",
+        },
+    };
+    return {
+        source_url: sourceUrl,
+        source_platform: detectPlatform(sourceUrl),
+        target_platform: targetPlatform,
+        source_content: pageText.substring(0, 3000),
+        source_data: items.slice(0, 5),
+        format_guide: formatGuide[targetPlatform] ?? formatGuide.blog,
+        hint: "Use the source_content and format_guide to restructure the content for the target platform. " +
+            "Write the hook, body, and CTA following the platform's conventions.",
+    };
+}
+async function groupLinkScanner(args, ctx) {
+    const url = args.url;
+    const scrollCount = args.scrolls ?? 5;
+    const validateLinks = args.validate_links ?? false;
+    const enrichProfiles = args.enrich_profiles ?? false;
+    const { tabId, items } = await extractPosts(ctx, url, scrollCount);
+    // Also scan full page text for group links
+    let fullText = "";
+    try {
+        fullText = String(await call(ctx, "evaluateJS", {
+            tabId,
+            expression: "document.body.innerText.substring(0, 50000)",
+        }));
+    }
+    catch { /* ok */ }
+    await closeTab(ctx, tabId);
+    // Regex patterns for group links
+    const patterns = [
+        /https?:\/\/wa\.me\/[^\s"',<>]+/gi,
+        /https?:\/\/chat\.whatsapp\.com\/[^\s"',<>]+/gi,
+        /https?:\/\/t\.me\/[^\s"',<>]+/gi,
+        /https?:\/\/telegram\.me\/[^\s"',<>]+/gi,
+    ];
+    const allText = fullText + " " + JSON.stringify(items);
+    const groupLinks = [];
+    const seen = new Set();
+    for (const pattern of patterns) {
+        const matches = allText.match(pattern) ?? [];
+        for (const match of matches) {
+            const cleaned = match.replace(/[),.'";]+$/, "");
+            if (seen.has(cleaned))
+                continue;
+            seen.add(cleaned);
+            const type = cleaned.includes("whatsapp") || cleaned.includes("wa.me")
+                ? "whatsapp" : "telegram";
+            // Extract surrounding context
+            const idx = allText.indexOf(cleaned);
+            const context = allText.substring(Math.max(0, idx - 100), idx + cleaned.length + 100).trim();
+            groupLinks.push({ url: cleaned, type, context: context.substring(0, 200) });
+        }
+    }
+    // Save to file
+    const groupLinksFile = path.join(NEURON_DIR, "group-links.yaml");
+    const store = loadYaml(groupLinksFile) ?? { links: [] };
+    for (const link of groupLinks) {
+        store.links.push({
+            ...link,
+            source_url: url,
+            found_at: new Date().toISOString(),
+        });
+    }
+    saveYaml(groupLinksFile, store);
+    return {
+        source_url: url,
+        total_links_found: groupLinks.length,
+        whatsapp: groupLinks.filter((l) => l.type === "whatsapp").length,
+        telegram: groupLinks.filter((l) => l.type === "telegram").length,
+        links: groupLinks,
+    };
+}
+async function bioHarvester(args, ctx) {
+    const urls = args.urls.slice(0, 20);
+    const followLinktree = args.follow_linktree ?? true;
+    const delayMs = args.delay_ms ?? 2000;
+    const results = [];
+    for (const profileUrl of urls) {
+        try {
+            const tab = (await call(ctx, "openTab", { url: profileUrl }));
+            const tabId = tab?.tabId;
+            if (!tabId) {
+                results.push({ profile_url: profileUrl, platform: detectPlatform(profileUrl), links: [], error: "Failed to open tab" });
+                continue;
+            }
+            await sleep(2500);
+            // Extract all links from the page
+            const linkData = await call(ctx, "evaluateJS", {
+                tabId,
+                expression: `
+          (function() {
+            const links = [];
+            // Bio section links
+            document.querySelectorAll('a[href]').forEach(a => {
+              const href = a.href;
+              if (href && !href.startsWith('javascript') && !href.includes(window.location.hostname + '/')) {
+                links.push(href);
+              }
+            });
+            // Check for email patterns in bio text
+            const bioText = document.body.innerText;
+            const emails = bioText.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}/g) || [];
+            const phones = bioText.match(/(\\+?\\d{1,3}[-.\\s]?)?\\(?\\d{1,4}\\)?[-.\\s]?\\d{1,4}[-.\\s]?\\d{1,9}/g) || [];
+            return JSON.stringify({ links: [...new Set(links)], emails, phones });
+          })()
+        `,
+            });
+            const parsed = JSON.parse(String(linkData ?? '{"links":[],"emails":[],"phones":[]}'));
+            // Categorize links
+            const categorized = [];
+            for (const link of parsed.links) {
+                const lower = link.toLowerCase();
+                let category = "website";
+                if (lower.includes("wa.me") || lower.includes("whatsapp"))
+                    category = "whatsapp";
+                else if (lower.includes("t.me") || lower.includes("telegram"))
+                    category = "telegram";
+                else if (lower.includes("linktr.ee") || lower.includes("beacons.ai") || lower.includes("stan.store") || lower.includes("linkin.bio"))
+                    category = "link_in_bio";
+                else if (lower.includes("calendly") || lower.includes("cal.com"))
+                    category = "booking";
+                else if (lower.includes("youtube") || lower.includes("youtu.be"))
+                    category = "youtube";
+                else if (lower.includes("tiktok"))
+                    category = "tiktok";
+                else if (lower.includes("twitter") || lower.includes("x.com"))
+                    category = "x";
+                else if (lower.includes("linkedin"))
+                    category = "linkedin";
+                else if (lower.includes("facebook") || lower.includes("fb.com"))
+                    category = "facebook";
+                else if (lower.includes("github"))
+                    category = "github";
+                categorized.push({ url: link, category });
+            }
+            for (const email of parsed.emails) {
+                categorized.push({ url: `mailto:${email}`, category: "email" });
+            }
+            for (const phone of parsed.phones) {
+                categorized.push({ url: `tel:${phone}`, category: "phone" });
+            }
+            // Follow link-in-bio pages
+            if (followLinktree) {
+                const linktreeLinks = categorized.filter((l) => l.category === "link_in_bio");
+                for (const ltLink of linktreeLinks.slice(0, 1)) {
+                    try {
+                        const ltTab = (await call(ctx, "openTab", { url: ltLink.url }));
+                        if (ltTab?.tabId) {
+                            await sleep(2000);
+                            const ltData = await call(ctx, "evaluateJS", {
+                                tabId: ltTab.tabId,
+                                expression: `
+                  JSON.stringify([...document.querySelectorAll('a[href]')].map(a => a.href).filter(h =>
+                    h && !h.includes(window.location.hostname) && !h.startsWith('javascript')
+                  ))
+                `,
+                            });
+                            const ltLinks = JSON.parse(String(ltData ?? "[]"));
+                            for (const ll of ltLinks) {
+                                categorized.push({ url: ll, category: "from_linktree" });
+                            }
+                            await closeTab(ctx, ltTab.tabId);
+                        }
+                    }
+                    catch { /* ok */ }
+                }
+            }
+            await closeTab(ctx, tabId);
+            results.push({ profile_url: profileUrl, platform: detectPlatform(profileUrl), links: categorized, error: null });
+        }
+        catch (err) {
+            results.push({ profile_url: profileUrl, platform: detectPlatform(profileUrl), links: [], error: err.message });
+        }
+        if (delayMs > 0)
+            await sleep(delayMs);
+    }
+    return {
+        total_profiles: results.length,
+        total_links: results.reduce((sum, r) => sum + r.links.length, 0),
+        profiles: results,
+    };
+}
+async function crossPlatformFinder(args, ctx) {
+    const handle = args.handle;
+    const sourcePlatform = args.source_platform;
+    const searchPlatforms = args.search_platforms ??
+        ["ig", "x", "li", "tk", "fb"].filter((p) => p !== sourcePlatform);
+    const platformSearchUrls = {
+        ig: `https://www.instagram.com/${handle}/`,
+        x: `https://x.com/${handle}`,
+        li: `https://www.linkedin.com/in/${handle}/`,
+        tk: `https://www.tiktok.com/@${handle}`,
+        fb: `https://www.facebook.com/${handle}`,
+    };
+    const results = [];
+    for (const platform of searchPlatforms) {
+        const searchUrl = platformSearchUrls[platform];
+        if (!searchUrl)
+            continue;
+        try {
+            const profile = await researchSingleProfile(ctx, searchUrl, 1);
+            const hasContent = profile.data != null && !profile.error;
+            const text = JSON.stringify(profile.data ?? "").toLowerCase();
+            // Check if the page is a valid profile (not a 404/error page)
+            const is404 = text.includes("sorry, this page isn") ||
+                text.includes("this account doesn") ||
+                text.includes("this page isn't available") ||
+                text.includes("user not found") ||
+                text.length < 100;
+            results.push({
+                platform,
+                url: searchUrl,
+                found: hasContent && !is404,
+                confidence: hasContent && !is404 ? "handle_match" : "not_found",
+                data: hasContent && !is404 ? profile.data : null,
+                error: profile.error,
+            });
+        }
+        catch (err) {
+            results.push({
+                platform,
+                url: searchUrl,
+                found: false,
+                confidence: "error",
+                data: null,
+                error: err.message,
+            });
+        }
+        await sleep(2000);
+    }
+    return {
+        handle,
+        source_platform: sourcePlatform,
+        platforms_searched: searchPlatforms.length,
+        found_on: results.filter((r) => r.found).length,
+        results,
+    };
+}
+async function pageWeight(args, ctx) {
+    const url = args.url;
+    const budget = (args.budget ?? {});
+    const maxJsKb = budget.max_js_kb ?? 300;
+    const maxCssKb = budget.max_css_kb ?? 100;
+    const maxImagesKb = budget.max_images_kb ?? 500;
+    const maxTotalKb = budget.max_total_kb ?? 1500;
+    const maxSingleKb = budget.max_single_asset_kb ?? 200;
+    // Open page and let it fully load
+    const tab = (await call(ctx, "openTab", { url }));
+    const tabId = tab?.tabId;
+    if (!tabId)
+        throw new Error("Failed to open tab");
+    await sleep(4000);
+    // Scroll to trigger lazy loads
+    for (let i = 0; i < 3; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY: 600, smooth: true });
+        await sleep(500);
+    }
+    // Get waterfall data for resource sizes and timing
+    const [waterfallData, requests] = await Promise.allSettled([
+        call(ctx, "waterfall", { tabId }),
+        call(ctx, "getRecentRequests", { tabId, limit: 300 }),
+    ]);
+    await closeTab(ctx, tabId);
+    // Categorize resources
+    const categories = {
+        javascript: { count: 0, total_kb: 0, assets: [] },
+        css: { count: 0, total_kb: 0, assets: [] },
+        images: { count: 0, total_kb: 0, assets: [] },
+        fonts: { count: 0, total_kb: 0, assets: [] },
+        video: { count: 0, total_kb: 0, assets: [] },
+        other: { count: 0, total_kb: 0, assets: [] },
+    };
+    const requestList = requests.status === "fulfilled"
+        ? (requests.value?.requests ?? [])
+        : [];
+    let totalKb = 0;
+    for (const req of requestList) {
+        const r = req;
+        const reqUrl = String(r.url ?? "");
+        const size = (r.responseSize ?? r.size ?? r.contentLength ?? 0) / 1024;
+        const lower = reqUrl.toLowerCase();
+        let cat = "other";
+        if (lower.endsWith(".js") || lower.includes("javascript") || (r.contentType ?? "").includes("javascript"))
+            cat = "javascript";
+        else if (lower.endsWith(".css") || (r.contentType ?? "").includes("css"))
+            cat = "css";
+        else if (/\.(png|jpg|jpeg|gif|webp|avif|svg|ico)/.test(lower) || (r.contentType ?? "").includes("image"))
+            cat = "images";
+        else if (/\.(woff2?|ttf|otf|eot)/.test(lower) || (r.contentType ?? "").includes("font"))
+            cat = "fonts";
+        else if (/\.(mp4|webm|m3u8)/.test(lower) || (r.contentType ?? "").includes("video"))
+            cat = "video";
+        const sizeKb = Math.round(size * 10) / 10;
+        categories[cat].count++;
+        categories[cat].total_kb += sizeKb;
+        categories[cat].assets.push({ url: reqUrl.substring(0, 120), size_kb: sizeKb });
+        totalKb += sizeKb;
+    }
+    // Build recommendations
+    const recommendations = [];
+    const violations = [];
+    if (categories.javascript.total_kb > maxJsKb) {
+        violations.push({ rule: "max_js_kb", actual: Math.round(categories.javascript.total_kb), limit: maxJsKb });
+        recommendations.push({ priority: "high", category: "javascript", message: `JS total ${Math.round(categories.javascript.total_kb)}KB exceeds budget of ${maxJsKb}KB — tree-shake, code-split, or defer non-critical scripts` });
+    }
+    if (categories.css.total_kb > maxCssKb) {
+        violations.push({ rule: "max_css_kb", actual: Math.round(categories.css.total_kb), limit: maxCssKb });
+        recommendations.push({ priority: "medium", category: "css", message: `CSS total ${Math.round(categories.css.total_kb)}KB exceeds budget — purge unused rules, inline critical CSS` });
+    }
+    if (categories.images.total_kb > maxImagesKb) {
+        violations.push({ rule: "max_images_kb", actual: Math.round(categories.images.total_kb), limit: maxImagesKb });
+        recommendations.push({ priority: "high", category: "images", message: `Images total ${Math.round(categories.images.total_kb)}KB exceeds budget — compress, convert to WebP/AVIF, lazy-load below fold` });
+    }
+    if (totalKb > maxTotalKb) {
+        violations.push({ rule: "max_total_kb", actual: Math.round(totalKb), limit: maxTotalKb });
+    }
+    // Flag oversized individual assets
+    for (const [cat, data] of Object.entries(categories)) {
+        for (const asset of data.assets) {
+            if (asset.size_kb > maxSingleKb) {
+                recommendations.push({ priority: "high", category: cat, message: `${asset.url} is ${asset.size_kb}KB — exceeds ${maxSingleKb}KB single asset limit` });
+            }
+        }
+    }
+    // Sort each category's assets by size descending
+    for (const cat of Object.values(categories)) {
+        cat.assets.sort((a, b) => b.size_kb - a.size_kb);
+        cat.assets = cat.assets.slice(0, 5); // keep top 5 per category
+        cat.total_kb = Math.round(cat.total_kb);
+    }
+    return {
+        url,
+        total_kb: Math.round(totalKb),
+        total_requests: requestList.length,
+        categories,
+        budget_violations: violations,
+        recommendations: recommendations.sort((a, b) => a.priority === "high" ? -1 : 1),
+        waterfall: waterfallData.status === "fulfilled" ? waterfallData.value : undefined,
+    };
+}
+//# sourceMappingURL=business-tools.js.map