@maestrogtm/maestro-gtm 0.10.16

package/dist/chunk-M25KLO7T.js

@@ -0,0 +1,3272 @@
+// src/tools/prospect.ts
+var prospectTools = [
+  {
+    name: "find_companies",
+    description: 'Discover companies matching ICP criteria via DiscoLike, Apollo, StoreLeads, or Exa (semantic/neural search). Use provider: "exa" for meaning-based search that understands intent, not just keywords.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        icp_text: {
+          type: "string",
+          description: 'Natural language ICP description (e.g., "B2B SaaS startups in US, 50-200 employees")'
+        },
+        domain: {
+          type: "string",
+          description: "Single domain for direct company lookup"
+        },
+        domains: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Lookalike domains to find similar companies (e.g., ["stripe.com", "plaid.com"])'
+        },
+        country: {
+          type: "string",
+          description: 'Country filter (e.g., "US", "UK", "DE")'
+        },
+        min_employees: {
+          type: "number",
+          description: "Minimum employee count"
+        },
+        max_employees: {
+          type: "number",
+          description: "Maximum employee count"
+        },
+        tech_stack: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Filter by technology stack (e.g., ["React", "AWS"])'
+        },
+        category: {
+          type: "string",
+          description: 'Industry category filter (e.g., "SaaS", "FinTech", "Healthcare")'
+        },
+        negate_domains: {
+          type: "array",
+          items: { type: "string" },
+          description: "Exclude these domains from results"
+        },
+        min_digital_footprint: {
+          type: "number",
+          description: "Minimum DiscoLike digital footprint score"
+        },
+        max_digital_footprint: {
+          type: "number",
+          description: "Maximum DiscoLike digital footprint score"
+        },
+        offset: {
+          type: "number",
+          description: "Pagination offset (0-based)"
+        },
+        limit: {
+          type: "number",
+          description: "Max results to return (default: 50, max: 1000)"
+        },
+        provider: {
+          type: "string",
+          description: "Provider override: disco, apollo, storeleads (uses first available if omitted)"
+        },
+        fields: {
+          description: 'Response fields. Defaults to slim (domain, name, industry, employees, country). Pass "all" for full payload including description, tech_stack, score, linkedin_url.',
+          oneOf: [
+            { type: "string", enum: ["all"] },
+            { type: "array", items: { type: "string" } }
+          ]
+        },
+        search: {
+          type: "string",
+          description: "Fuzzy text match on name/description (StoreLeads provider)"
+        },
+        state: {
+          type: "string",
+          description: "US state filter (StoreLeads provider)"
+        },
+        platform: {
+          type: "string",
+          description: 'E-commerce platform filter, e.g. "Shopify" (StoreLeads provider)'
+        },
+        min_revenue: {
+          type: "number",
+          description: "Minimum estimated yearly revenue in USD (StoreLeads provider)"
+        },
+        max_revenue: {
+          type: "number",
+          description: "Maximum estimated yearly revenue in USD (StoreLeads provider)"
+        },
+        output: {
+          type: "string",
+          enum: ["file", "inline", "csv"],
+          description: 'Output mode. "file" writes JSONL (auto when >20 results). "csv" writes a CSV file for spreadsheet review. "inline" returns in response.'
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: 'Response detail level. "summary" (default) returns slim results. "full" includes applied_filters and all metadata.'
+        },
+        review: {
+          type: "boolean",
+          description: "Create a viewer table with results. Returns table_id and URL for human review. Other tools can read from this table via table_id parameter."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "find_people",
+    description: 'Find contacts by job title, company, or domain. Returns name, title, email, LinkedIn URL. Slim by default; pass fields: "all" for full payload. Pass enrich: true to resolve full emails inline (avoids a separate enrich call).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        job_title: {
+          type: "string",
+          description: 'Job title to search for (e.g., "VP of Sales", "CEO", "Head of Marketing")'
+        },
+        company_name: {
+          type: "string",
+          description: "Company name to search within"
+        },
+        company_domain: {
+          type: "string",
+          description: 'Company domain to search within (e.g., "stripe.com")'
+        },
+        location: {
+          type: "string",
+          description: 'Location filter (e.g., "San Francisco", "United States")'
+        },
+        seniority: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by seniority: owner, c_suite, vp, director, manager, senior, entry"
+        },
+        department: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by department: engineering, sales, marketing, finance, hr, etc."
+        },
+        has_email: {
+          type: "boolean",
+          description: "Filter to contacts with known email (default: true)"
+        },
+        has_phone: {
+          type: "boolean",
+          description: "Filter to contacts with known phone number"
+        },
+        has_linkedin: {
+          type: "boolean",
+          description: "Filter to contacts with LinkedIn profile"
+        },
+        min_connections: {
+          type: "number",
+          description: "Minimum LinkedIn connections"
+        },
+        offset: {
+          type: "number",
+          description: "Pagination offset (0-based)"
+        },
+        limit: {
+          type: "number",
+          description: "Max results to return (default: 25, max: 1000)"
+        },
+        provider: {
+          type: "string",
+          description: "Provider override: disco, apollo (uses first available if omitted)"
+        },
+        company_domains: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Search across multiple company domains in one call (e.g., ["stripe.com", "plaid.com"]). DiscoLike native.'
+        },
+        skills: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Filter by skills (e.g., ["artificial intelligence", "machine learning"])'
+        },
+        filter_industry: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Filter by company industry (e.g., ["SOFTWARE", "SAAS", "IT_SERVICES"])'
+        },
+        email_validated: {
+          type: "boolean",
+          description: "Only return contacts with validated email addresses"
+        },
+        min_employees: {
+          type: "number",
+          description: "Minimum company employee count"
+        },
+        max_employees: {
+          type: "number",
+          description: "Maximum company employee count"
+        },
+        revenue_range: {
+          type: "string",
+          description: 'Company revenue range as "min,max" (e.g., "1000000,10000000")'
+        },
+        enrich: {
+          type: "boolean",
+          description: "Resolve full email addresses inline. Some providers return masked emails (e.g., j***@company.com) in search results. Pass enrich: true to run waterfall enrichment on those contacts automatically, so you get real emails without a separate enrich call."
+        },
+        fields: {
+          description: 'Response fields. Defaults to slim (name, title, email, company, company_domain, linkedin). Pass "all" for full payload including skills, phone, seniority, department, connections. Or pass an array of specific field names.',
+          oneOf: [
+            { type: "string", enum: ["all"] },
+            { type: "array", items: { type: "string" } }
+          ]
+        },
+        output: {
+          type: "string",
+          enum: ["file", "inline", "csv"],
+          description: 'Output mode. "file" writes JSONL (auto when >20 results). "csv" writes a CSV file for spreadsheet review. "inline" returns in response.'
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: 'Response detail level. "summary" (default) returns slim results. "full" includes applied_filters and all metadata.'
+        },
+        review: {
+          type: "boolean",
+          description: "Create a viewer table with results. Returns table_id and URL for human review. Other tools can read from this table via table_id parameter."
+        }
+      },
+      required: []
+    }
+  }
+];
+
+// src/tools/enrich.ts
+var enrichTools = [
+  {
+    name: "enrich",
+    description: "Email/phone waterfall enrichment + single-email verification. Actions: enrich (default \u2014 waterfall enrichment, 1-100 contacts), verify (single email deliverability check). Always dry_run first for batches > 5. Defaults to email only \u2014 phone costs extra.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["enrich", "verify"],
+          description: "enrich (default) \u2014 waterfall enrichment. verify \u2014 single email deliverability check."
+        },
+        email: {
+          type: "string",
+          description: "Email address to verify (required for verify action)"
+        },
+        contacts: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              first_name: { type: "string" },
+              last_name: { type: "string" },
+              company: { type: "string" },
+              company_domain: { type: "string" },
+              linkedin_url: { type: "string" }
+            },
+            required: ["first_name", "last_name"]
+          },
+          description: "Contacts to enrich (1-100)",
+          maxItems: 100
+        },
+        find: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: ["email", "phone", "title", "company", "funding", "tech_stack"]
+          },
+          default: ["email"],
+          description: 'Fields to find. Defaults to ["email"] only. Add "phone" ONLY when explicitly requested \u2014 phone lookups cost extra. Additional fields (title, company, funding, tech_stack) return an informative error until Phase 2.'
+        },
+        waterfall: {
+          type: "array",
+          items: { type: "string" },
+          description: "Provider order override (uses client default if omitted)"
+        },
+        verify: { type: "boolean", default: true },
+        dry_run: { type: "boolean", default: false },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: 'Response detail level. "summary" (default) returns email/phone/providers per contact. "full" includes waterfall attempt details (provider, duration, errors) per contact.'
+        },
+        table_id: {
+          type: "string",
+          description: "Read contacts from a viewer table instead of passing inline. Fetches selected rows, enriches them, and writes results back to the table."
+        },
+        review: {
+          type: "boolean",
+          description: "Create a viewer table with enrichment results."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "verify",
+    description: "Verify a single email address for deliverability. Returns verification status: deliverable, catch_all_safe, catch_all_not_safe, undeliverable, or unknown. Use this after enrichment or to validate an existing email.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        email: {
+          type: "string",
+          description: "Email address to verify"
+        }
+      },
+      required: ["email"]
+    }
+  }
+];
+
+// src/tools/extract.ts
+var extractTools = [
+  {
+    name: "extract",
+    description: "Extract data from LinkedIn (profiles, posts, engagement, search) or web pages. HarvestAPI charges per request.",
+    inputSchema: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            "linkedin_profile",
+            "linkedin_posts",
+            "linkedin_engagement",
+            "linkedin_search",
+            "linkedin_company_posts",
+            "web_page"
+          ],
+          description: "Content type to extract"
+        },
+        url: {
+          type: "string",
+          description: "URL to extract data from (required for web_page)"
+        },
+        linkedin_url: {
+          type: "string",
+          description: "LinkedIn profile URL (required for linkedin_profile)"
+        },
+        find_email: {
+          type: "boolean",
+          description: "Find email via SMTP verification \u2014 uses extra credits (linkedin_profile only)"
+        },
+        profile: {
+          type: "string",
+          description: "LinkedIn URL or publicIdentifier (required for linkedin_posts)"
+        },
+        company: {
+          type: "string",
+          description: "Company LinkedIn URL or universalName (required for linkedin_company_posts)"
+        },
+        posted_within: {
+          type: "string",
+          enum: ["24h", "week", "month"],
+          description: "Filter posts by recency (linkedin_posts, linkedin_search, linkedin_company_posts)"
+        },
+        post_url: {
+          type: "string",
+          description: "LinkedIn post URL (required for linkedin_engagement)"
+        },
+        engagement_type: {
+          type: "string",
+          enum: ["comments", "reactions", "both"],
+          description: "Type of engagement to retrieve (default: both)"
+        },
+        query: {
+          type: "string",
+          description: "Keyword search (required for linkedin_search)"
+        },
+        sort: {
+          type: "string",
+          enum: ["relevance", "date"],
+          description: "Sort order for linkedin_search"
+        },
+        limit: { type: "number", description: "Max results to return (max 100)" },
+        fields: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Specific fields to extract (e.g., ["name", "title", "company", "about"]). Extracts all available fields if omitted.'
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: 'Response detail level. "summary" (default) returns counts and key fields only \u2014 truncates post text, omits individual engagement items. "full" returns complete data including all post content and engager lists.'
+        }
+      }
+    }
+  }
+];
+
+// src/tools/fetch.ts
+var fetchTools = [
+  {
+    name: "fetch",
+    description: "Make an HTTP call to any API endpoint. Use this to pull data from services that don't have a dedicated provider.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Full URL to call" },
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+          default: "GET"
+        },
+        headers: {
+          type: "object",
+          description: "Request headers (e.g., Authorization)"
+        },
+        body: {
+          type: "object",
+          description: "Request body (for POST/PUT/PATCH)"
+        },
+        params: {
+          type: "object",
+          description: "URL query parameters"
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: 'Response detail level. "summary" (default) omits response headers and truncates large bodies. "full" returns complete response including all headers.'
+        }
+      },
+      required: ["url"]
+    }
+  }
+];
+
+// src/tools/ai.ts
+var aiTools = [
+  {
+    name: "ai",
+    description: "AI-powered data operations: personalize outreach, classify leads, clean data, score prospects, or write copy. Provide an action, input data, and optional prompt. Uses your configured AI provider (Anthropic or OpenAI).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["personalize", "classify", "clean", "score", "write_copy"],
+          description: "Action type: personalize (outreach messages), classify (categorize data), clean (normalize/deduplicate), score (rank/prioritize), write_copy (generate copy)"
+        },
+        data: {
+          description: "Input data to process (object, array, or string)"
+        },
+        prompt: {
+          type: "string",
+          description: 'Custom instructions for the AI operation (e.g., "Write a 2-sentence cold email opener")'
+        },
+        model: {
+          type: "string",
+          description: "Model override (uses config default if omitted)"
+        },
+        enrich_with_graph: {
+          type: "boolean",
+          description: "When true and action is personalize or write_copy, auto-inject business context from the knowledge graph into the AI prompt. Requires Supabase and MAESTRO_OWNER_ID env vars."
+        }
+      },
+      required: ["action", "data"]
+    }
+  }
+];
+
+// src/tools/campaign.ts
+var campaignTools = [
+  {
+    name: "campaign",
+    description: "Provider-managed campaigns + engagement monitoring. Campaigns: list, stats, add_leads, create. Engagement: monitor (LinkedIn post scraping + auto-push), engagement_status, engagers, push. Auto-detects channel if omitted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "list",
+            "stats",
+            "add_leads",
+            "create",
+            "monitor",
+            "engagement_status",
+            "engagers",
+            "push"
+          ],
+          description: "Campaigns: list, stats, add_leads, create. Engagement: monitor (enable/disable scraping + auto-push), engagement_status (all monitored posts), engagers (list for a post), push (manual enrichment + push)."
+        },
+        channel: {
+          type: "string",
+          enum: ["email", "linkedin"],
+          description: 'Channel: "email" for cold email (PlusVibe, Instantly, SmartLead), "linkedin" for outreach (HeyReach). Auto-detects from provider/leads if omitted.'
+        },
+        campaign_id: {
+          type: "string",
+          description: "Campaign ID (required for stats and add_leads)"
+        },
+        leads: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              email: {
+                type: "string",
+                description: "Email address (required for email campaigns)"
+              },
+              linkedin_url: {
+                type: "string",
+                description: "LinkedIn profile URL (required for LinkedIn outreach campaigns)"
+              },
+              first_name: { type: "string" },
+              last_name: { type: "string" },
+              company: { type: "string" },
+              custom_fields: {
+                type: "object",
+                description: "Custom merge fields for email personalization"
+              }
+            }
+          },
+          description: "Leads to add (required for add_leads action). Each lead needs at least email or linkedin_url."
+        },
+        name: {
+          type: "string",
+          description: "Campaign name (required for create action)"
+        },
+        provider: {
+          type: "string",
+          description: "Provider override (auto-selects based on available campaign_email or outreach_linkedin provider if omitted)"
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: 'Response detail level. "summary" (default) returns key stats only. "full" returns all campaign data.'
+        },
+        table_id: {
+          type: "string",
+          description: "Read leads from a viewer table instead of passing inline. Fetches selected rows and maps them to campaign leads."
+        },
+        // ─── Engagement params (absorbed from engagement tool) ──
+        post_url: {
+          type: "string",
+          description: "LinkedIn post URL \u2014 yours or external (for monitor/engagers/push)"
+        },
+        enabled: {
+          type: "boolean",
+          description: "Enable/disable engagement scraping (for monitor)"
+        },
+        plusvibe_campaign_id: {
+          type: "string",
+          description: "PlusVibe campaign ID for auto-push (for monitor)"
+        },
+        opt_in_url: {
+          type: "string",
+          description: "Lead magnet URL for {{opt_in_url}} variable (for monitor)"
+        },
+        post_topic: {
+          type: "string",
+          description: "Post topic for personalization (for monitor on external posts)"
+        },
+        creator_name: {
+          type: "string",
+          description: "Post creator name (for monitor on external posts)"
+        },
+        filter: {
+          type: "string",
+          enum: ["all", "enriched", "unenriched", "pushed", "unpushed"],
+          description: "Filter engagers by status (for engagers)"
+        },
+        limit: {
+          type: "number",
+          description: "Max engagers to return or push (for engagers/push)"
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/crm.ts
+var crmTools = [
+  {
+    name: "crm",
+    description: "Read and write CRM data. Find, create, or update people and companies. Create deals. Supports Attio and other CRM providers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["find", "create", "update", "find_company", "create_deal"],
+          description: "Action to perform: find (search people by email/LinkedIn/name), create (person), update (person by id), find_company (search by name), create_deal"
+        },
+        id: {
+          type: "string",
+          description: "Person ID (required for update)"
+        },
+        query: {
+          type: "object",
+          properties: {
+            email: { type: "string" },
+            linkedin_url: { type: "string" },
+            name: { type: "string" }
+          },
+          description: "Search query (for find, find_company)"
+        },
+        data: {
+          type: "object",
+          properties: {
+            first_name: { type: "string" },
+            last_name: { type: "string" },
+            email: { type: "string" },
+            company: { type: "string" },
+            job_title: { type: "string" },
+            name: { type: "string", description: "Deal name (for create_deal)" },
+            company_id: { type: "string", description: "Associated company ID (for create_deal)" },
+            person_id: { type: "string", description: "Associated person ID (for create_deal)" },
+            stage: { type: "string", description: "Deal stage (for create_deal)" },
+            value: { type: "number", description: "Deal value (for create_deal)" }
+          },
+          description: "Data payload (for create, update, create_deal)"
+        },
+        provider: {
+          type: "string",
+          description: "CRM provider override (uses first available if omitted)"
+        },
+        table_id: {
+          type: "string",
+          description: "Read contacts from a viewer table for bulk create/update. Fetches selected rows and maps them to CRM person records."
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/status.ts
+var statusTools = [
+  {
+    name: "status",
+    description: "Check provider health, credit balances, and active configuration.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        check: {
+          type: "string",
+          enum: ["all", "credits", "health", "config"],
+          default: "all",
+          description: "What to check: all (full status report), credits (remaining balances), health (provider connectivity), config (active client and waterfall)"
+        },
+        provider: {
+          type: "string",
+          description: "Check a specific provider only (checks all configured providers if omitted)"
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: 'Response detail level. "summary" (default) returns provider name, health, and credits only. "full" includes capabilities, notes, and unconfigured tool details.'
+        }
+      },
+      required: []
+    }
+  }
+];
+
+// src/tools/configure.ts
+var configureTools = [
+  {
+    name: "configure",
+    description: "System config + provider health. Config: switch_client, list_clients, show_config, set_waterfall, add_client. Status: status (provider health, credits, capabilities).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "switch_client",
+            "list_clients",
+            "show_config",
+            "set_waterfall",
+            "add_client",
+            "status"
+          ],
+          description: "Config: switch_client, list_clients, show_config, set_waterfall, add_client. Status: status (provider health/credits)."
+        },
+        client: {
+          type: "string",
+          description: "Client name (for switch_client, add_client)"
+        },
+        email: {
+          type: "array",
+          items: { type: "string" },
+          description: "Email waterfall order (for set_waterfall)"
+        },
+        phone: {
+          type: "array",
+          items: { type: "string" },
+          description: "Phone waterfall order (for set_waterfall)"
+        },
+        // ─── Status params (absorbed from status tool) ──────────
+        check: {
+          type: "string",
+          enum: ["all", "credits", "health", "config"],
+          description: "What to check (for status action): all, credits, health, config"
+        },
+        provider: {
+          type: "string",
+          description: "Check a specific provider only (for status action)"
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "full"],
+          description: "Response detail level (for status action)"
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/feedback.ts
+var feedbackTools = [
+  {
+    name: "feedback",
+    description: "Submit feedback, bug reports, feature requests, or provider requests. Use this to report issues with Maestro or request new data providers and capabilities. Feedback is stored for the Maestro maintainers to review.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["bug", "feature_request", "provider_request"],
+          description: 'Type of feedback: "bug" for something broken, "feature_request" for new capabilities, "provider_request" for requesting a new data provider integration'
+        },
+        message: {
+          type: "string",
+          description: "Describe the issue, request, or suggestion in detail"
+        },
+        context: {
+          type: "object",
+          description: "Optional context \u2014 tool name, error_code, args used, provider, etc. Include anything that helps reproduce or understand the feedback."
+        }
+      },
+      required: ["type", "message"]
+    }
+  }
+];
+
+// src/tools/review.ts
+var reviewTools = [
+  {
+    name: "review",
+    description: "Push data to a visual review table. Users see an interactive grid in their browser and can select/deselect rows. Use after finding companies or contacts to let the user review before enrichment.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["create", "update", "get_selected"],
+          description: "create: new table from data. update: modify existing table rows. get_selected: fetch user-approved rows."
+        },
+        title: { type: "string", description: "Table title (for create)" },
+        data: {
+          type: "array",
+          items: { type: "object" },
+          description: "Array of row objects (for create)"
+        },
+        table_id: {
+          type: "string",
+          description: "Table ID (for update, get_selected, or optional client-provided ID on create)"
+        },
+        rows: {
+          type: "array",
+          items: { type: "object" },
+          description: "Updated row objects with _row_id (for update)"
+        },
+        ttl_seconds: {
+          type: "number",
+          description: "Optional TTL override in seconds (default: 24h). For create only."
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/batch.ts
+var batchTools = [
+  {
+    name: "batch",
+    description: 'CSV pipeline + saved recipes. Actions: run (default \u2014 process CSV through tool steps), save_recipe, list_recipes, run_recipe, show_recipe, delete_recipe. Always dry_run first to preview. Use rows: "0:1" to pilot on a single row.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        input_csv: {
+          type: "string",
+          description: "Path to input CSV file (supports ~ for home directory)"
+        },
+        output_csv: {
+          type: "string",
+          description: "Path for output CSV. Defaults to {input}_enriched.csv"
+        },
+        steps: {
+          type: "array",
+          description: "Pipeline steps to run per row",
+          items: {
+            type: "object",
+            properties: {
+              alias: {
+                type: "string",
+                description: 'Column prefix for extracted results (e.g., "enrich" produces "enrich_email")'
+              },
+              tool: {
+                type: "string",
+                description: 'GTM tool to call (e.g., "enrich", "find_people")'
+              },
+              payload_template: {
+                type: "object",
+                description: "Tool arguments with {{column}} placeholders for row values. Non-string values (numbers, booleans, arrays) pass through as-is."
+              },
+              extract: {
+                type: "array",
+                items: { type: "string" },
+                description: 'Fields to extract from tool result as new columns. Supports dot-path (e.g., "results.0.email") or simple key lookup.'
+              },
+              waterfall: {
+                type: "boolean",
+                description: "Skip this step for a row if all extract fields are already filled by a previous step"
+              },
+              skip_if: {
+                type: "string",
+                description: 'JS expression evaluated against `row`. If truthy, skip THIS step. Use after an AI scoring/classification step to conditionally proceed. Example: "Number(row.score_icp_score) < 70" skips personalization for low-score leads.'
+              },
+              stop_if: {
+                type: "string",
+                description: "JS expression evaluated against `row`. If truthy, stop ALL remaining steps for this row. Use to filter out unqualified rows early. Example: \"row.classify_fit === 'disqualified'\" stops the entire pipeline for this row."
+              }
+            },
+            required: ["alias", "tool", "payload_template", "extract"]
+          }
+        },
+        rows: {
+          type: "string",
+          description: 'Row slice as "start:end" (0-indexed, end exclusive). E.g., "0:5" for first 5 rows.'
+        },
+        dry_run: {
+          type: "boolean",
+          description: "Preview what would happen without making API calls"
+        },
+        concurrency: {
+          type: "number",
+          description: "Worker pool size (1-5, default 1). Processes up to N rows in parallel."
+        },
+        maestro_strategy: {
+          type: "string",
+          enum: [
+            "call_prep",
+            "content_generation",
+            "lead_scoring",
+            "personalization",
+            "campaign_planning",
+            "general"
+          ],
+          description: 'Knowledge graph context strategy. Auto-detected when templates use {{maestro.*}} variables. Injects persona, product, proof point, and competitor data into templates. Default: "personalization".'
+        },
+        output: {
+          type: "object",
+          description: 'Route enriched results to a secondary destination (CSV is always written). Types: "review" (interactive review table), "campaign" (push leads), "crm" (create/update contacts).',
+          properties: {
+            type: {
+              type: "string",
+              enum: ["review", "campaign", "crm"],
+              description: "Output destination type"
+            },
+            title: {
+              type: "string",
+              description: 'Review table title (type: "review" only)'
+            },
+            campaign_id: {
+              type: "string",
+              description: 'Campaign to push leads to (type: "campaign" only)'
+            },
+            provider: {
+              type: "string",
+              description: 'Campaign provider override (type: "campaign" only)'
+            },
+            lead_mapping: {
+              type: "object",
+              description: 'Column name mapping for campaign leads: { "email": "enrich_email", "first_name": "name" }. Auto-detected if omitted.'
+            },
+            action: {
+              type: "string",
+              enum: ["create", "update"],
+              description: 'CRM action (type: "crm" only, default: "create")'
+            }
+          },
+          required: ["type"]
+        },
+        post_process: {
+          type: "string",
+          description: 'JS code to run after all rows are processed. Has access to `rows` array. Must return a summary value. Example: "return { qualified: rows.filter(r => Number(r.score_score) >= 70).length }"'
+        },
+        ai_answers: {
+          type: "array",
+          description: "Pre-filled AI results from a previous passthrough run. Provide these when re-running a batch after the agent has processed the ai_pending prompts from the first run.",
+          items: {
+            type: "object",
+            properties: {
+              row_index: {
+                type: "number",
+                description: "Row index (0-based) this answer applies to"
+              },
+              step_alias: { type: "string", description: "Step alias this answer applies to" },
+              result: {
+                type: "object",
+                description: "AI result object with keys matching the step extract fields"
+              }
+            },
+            required: ["row_index", "step_alias", "result"]
+          }
+        },
+        // ─── Recipe params (absorbed from recipe tool) ──────────
+        action: {
+          type: "string",
+          enum: [
+            "run",
+            "save_recipe",
+            "list_recipes",
+            "run_recipe",
+            "show_recipe",
+            "delete_recipe"
+          ],
+          description: "run (default \u2014 process CSV pipeline), save_recipe, list_recipes, run_recipe, show_recipe, delete_recipe."
+        },
+        recipe_name: {
+          type: "string",
+          description: "Recipe name (for save_recipe/run_recipe/show_recipe/delete_recipe)"
+        },
+        recipe_description: {
+          type: "string",
+          description: "Recipe description (for save_recipe)"
+        },
+        config: {
+          type: "object",
+          description: "Full batch config to save as a recipe (for save_recipe)"
+        },
+        schedule: {
+          type: "string",
+          description: "Cron expression for recurring runs (for save_recipe)"
+        }
+      },
+      required: []
+    }
+  }
+];
+
+// src/tools/recipe.ts
+var recipeTools = [
+  {
+    name: "recipe",
+    description: "Manage reusable batch processing recipes. Save, load, run, and schedule batch pipelines. Recipes are stored as YAML in ~/.gtm/recipes/ and can include schedule expressions for recurring runs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["save", "list", "run", "show", "delete"],
+          description: "Recipe action to perform"
+        },
+        name: {
+          type: "string",
+          description: "Recipe name (required for save, run, show, delete)"
+        },
+        description: {
+          type: "string",
+          description: "Recipe description (save only)"
+        },
+        config: {
+          type: "object",
+          description: "Full BatchConfig to save as a recipe (save only)"
+        },
+        schedule: {
+          type: "string",
+          description: 'Cron expression for recurring runs, e.g., "0 9 * * 1-5" (save only)'
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/provision.ts
+var provisionTools = [
+  {
+    name: "provision",
+    description: "Infrastructure provisioning \u2014 domain management, mailbox creation, DMARC setup, PlusVibe client creation, config persistence, and full provisioning pipeline.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "check_domains",
+            "check_balance",
+            "buy_domains",
+            "list_domains",
+            "list_mailboxes",
+            "setup_dmarc",
+            "create_mailboxes",
+            "export_mailboxes",
+            "create_plusvibe_client",
+            "save_config",
+            "deploy_crm",
+            "start_provision",
+            "status"
+          ],
+          description: "Action: check_domains (availability), check_balance (Zapmail wallet), buy_domains (purchase via wallet), list_domains (show all with status), list_mailboxes (show mailboxes), setup_dmarc (configure DMARC for domains), create_mailboxes (create on specific domains), export_mailboxes (export to PlusVibe), create_plusvibe_client (create client in existing workspace), save_config (persist provider config to ~/.gtm/config.yaml), deploy_crm (generate Twenty CRM deployment instructions for Railway), start_provision (trigger full pipeline), status (check progress)"
+        },
+        domains: {
+          type: "array",
+          items: { type: "string" },
+          description: "Domain names (for check_domains, buy_domains, create_mailboxes)"
+        },
+        domain_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: "Zapmail domain IDs (for setup_dmarc, create_mailboxes)"
+        },
+        mailboxes: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              username: { type: "string" },
+              firstName: { type: "string" },
+              lastName: { type: "string" }
+            },
+            required: ["username", "firstName", "lastName"]
+          },
+          description: "Mailbox definitions (for create_mailboxes)"
+        },
+        name: {
+          type: "string",
+          description: "Client name (for create_plusvibe_client)"
+        },
+        email: {
+          type: "string",
+          description: "Client email (for create_plusvibe_client, setup_dmarc)"
+        },
+        dmarc_email: {
+          type: "string",
+          description: "DMARC reporting email (for setup_dmarc, defaults to email)"
+        },
+        dmarc_status: {
+          type: "array",
+          items: { type: "string" },
+          description: 'DMARC policy status (for setup_dmarc, defaults to ["p=none"])'
+        },
+        workspace_id: {
+          type: "string",
+          description: "PlusVibe workspace ID (for create_plusvibe_client)"
+        },
+        provider: {
+          type: "string",
+          description: "Provider name (for save_config \u2014 e.g. zapmail, plusvibe, twenty)"
+        },
+        config_values: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: 'Config values to save (for save_config \u2014 e.g. {"api_key":"xxx","base_url":"https://..."})'
+        },
+        client_name: {
+          type: "string",
+          description: "Client name in config (for save_config \u2014 defaults to active client)"
+        },
+        client_context: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            email: { type: "string" },
+            name: { type: "string" },
+            source: { type: "string", enum: ["student", "dfy_client", "self_serve"] }
+          },
+          required: ["id", "email", "name", "source"],
+          description: "Client identity (required for start_provision)"
+        },
+        provision_id: {
+          type: "string",
+          description: "Provision UUID (for start_provision and status)"
+        },
+        provision_type: {
+          type: "string",
+          enum: ["full", "outreach"],
+          description: "Provision type: full or outreach. Default: full."
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/list.ts
+var listTools = [
+  {
+    name: "list",
+    description: "Manage persistent GTM lists \u2014 import CSVs, store contacts/companies, query with filters, view in browser. Lists persist in Supabase and can be enriched, scored, and pushed to campaigns incrementally.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          description: "Action: create (new list), import_csv (CSV into list), add (items to list), query (filter items), view (open in browser), stats (list summary), lists (show all), delete (remove list)",
+          enum: ["create", "import_csv", "add", "query", "view", "stats", "lists", "delete"]
+        },
+        list_id: {
+          type: "string",
+          description: "List UUID (required for import_csv, add, query, view, stats, delete)"
+        },
+        name: {
+          type: "string",
+          description: "List name (for create)"
+        },
+        description: {
+          type: "string",
+          description: "List description (for create)"
+        },
+        list_type: {
+          type: "string",
+          enum: ["contacts", "companies", "mixed"],
+          description: "List type (for create, default: contacts)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for filtering (for create, lists)"
+        },
+        client_id: {
+          type: "string",
+          description: "Client scope (for create, lists \u2014 defaults to active client)"
+        },
+        csv_path: {
+          type: "string",
+          description: "Path to CSV file on disk (for import_csv)"
+        },
+        csv_text: {
+          type: "string",
+          description: "Raw CSV text (for import_csv \u2014 alternative to csv_path)"
+        },
+        column_mapping: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: 'Override column mapping: {"CSV Column": "core_field"} (for import_csv)'
+        },
+        items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              email: { type: "string" },
+              linkedin_url: { type: "string" },
+              first_name: { type: "string" },
+              last_name: { type: "string" },
+              company: { type: "string" },
+              company_domain: { type: "string" },
+              title: { type: "string" },
+              phone: { type: "string" },
+              location: { type: "string" },
+              custom_fields: { type: "object" }
+            }
+          },
+          description: "Contact/company items to add (for add action)"
+        },
+        enrichment_status: {
+          type: "string",
+          enum: ["pending", "enriched", "failed", "skipped"],
+          description: "Filter by enrichment status (for query)"
+        },
+        has_email: {
+          type: "boolean",
+          description: "Filter: has email (for query)"
+        },
+        has_linkedin: {
+          type: "boolean",
+          description: "Filter: has LinkedIn URL (for query)"
+        },
+        search: {
+          type: "string",
+          description: "Text search across name, company, email (for query)"
+        },
+        limit: {
+          type: "number",
+          description: "Max results (for query, default 100)"
+        },
+        offset: {
+          type: "number",
+          description: "Pagination offset (for query)"
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/maestro.ts
+var maestroTools = [
+  {
+    name: "intel",
+    description: "Knowledge graph \u2014 personas, products, competitors, proof points, scoring, ingestion, and context assembly. Actions: context (strategy-based assembly), product/persona/get_persona/segment/competitor (upsert entities), proof (add evidence), outcome (record deal_won/lost, meeting_booked for learning loop), gaps (missing evidence per persona), score (match contact to personas), propose (AI entity extraction), ingest/ingest_linkedin/refresh_competitor (feed data into graph), changelog (audit trail). Call tool_help for full parameter docs per action.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "context",
+            "product",
+            "persona",
+            "get_persona",
+            "segment",
+            "proof",
+            "competitor",
+            "outcome",
+            "gaps",
+            "propose",
+            "ingest",
+            "ingest_linkedin",
+            "refresh_competitor",
+            "changelog",
+            "score"
+          ],
+          description: "Context: context (assemble business context by strategy). Entities: product, persona, get_persona, segment, competitor (upsert). Evidence: proof (case studies, testimonials, metrics). Learning: outcome (record GTM outcomes). Analysis: gaps (coverage gaps), score (contact-to-persona matching), propose (AI entity extraction). Ingest: ingest (documents), ingest_linkedin (profile scrape), refresh_competitor (Exa web search). Audit: changelog (mutation history)."
+        },
+        // ─── Context params ─────────────────────────────
+        strategy: {
+          type: "string",
+          enum: [
+            "call_prep",
+            "content_generation",
+            "lead_scoring",
+            "personalization",
+            "campaign_planning",
+            "general"
+          ],
+          description: "Context assembly strategy \u2014 determines entity weights and limits (for context)"
+        },
+        query: {
+          type: "string",
+          description: "Focus context on a topic (for context), or search query (for refresh_competitor)"
+        },
+        // ─── Entity params (shared across multiple actions) ─
+        name: {
+          type: "string",
+          description: "Entity name \u2014 unique per owner (for product/persona/segment/competitor)"
+        },
+        description: {
+          type: "string",
+          description: "Entity description (for product/segment)"
+        },
+        // ─── Product params ─────────────────────────────
+        category: {
+          type: "string",
+          description: "Product category (for product) or proof point category"
+        },
+        value_proposition: {
+          type: "string",
+          description: "Core value proposition (for product)"
+        },
+        key_features: {
+          type: "array",
+          items: { type: "string" },
+          description: "Key features or capabilities (for product)"
+        },
+        pricing_summary: {
+          type: "string",
+          description: "Pricing overview (for product)"
+        },
+        // ─── Persona params ─────────────────────────────
+        persona_id: {
+          type: "string",
+          description: "Persona UUID (for get_persona, context, gaps, proof)"
+        },
+        title_patterns: {
+          type: "array",
+          items: { type: "string" },
+          description: "Job title patterns (for persona)"
+        },
+        industries: {
+          type: "array",
+          items: { type: "string" },
+          description: "Industries (for persona)"
+        },
+        company_size_min: {
+          type: "number",
+          description: "Min company size (for persona)"
+        },
+        company_size_max: {
+          type: "number",
+          description: "Max company size (for persona)"
+        },
+        pain_points: {
+          type: "array",
+          items: { type: "string" },
+          description: "Pain points (for persona)"
+        },
+        goals: {
+          type: "array",
+          items: { type: "string" },
+          description: "Goals (for persona)"
+        },
+        objections: {
+          type: "array",
+          items: { type: "string" },
+          description: "Common objections (for persona)"
+        },
+        buying_signals: {
+          type: "array",
+          items: { type: "string" },
+          description: "Buying intent signals (for persona)"
+        },
+        geographic_focus: {
+          type: "array",
+          items: { type: "string" },
+          description: "Geographic regions (for persona)"
+        },
+        budget_range: {
+          type: "string",
+          description: "Budget range (for persona)"
+        },
+        is_primary: {
+          type: "boolean",
+          description: "Primary persona flag (for persona)"
+        },
+        // ─── Segment params ─────────────────────────────
+        qualification_criteria: {
+          type: "object",
+          description: "Qualification criteria as JSON (for segment)"
+        },
+        market_size_estimate: {
+          type: "string",
+          description: "Estimated market size (for segment)"
+        },
+        // ─── Proof params ───────────────────────────────
+        type: {
+          type: "string",
+          enum: ["case_study", "testimonial", "metric", "quote", "before_after"],
+          description: "Proof point type (for proof)"
+        },
+        title: {
+          type: "string",
+          description: "Short title (for proof)"
+        },
+        content: {
+          type: "string",
+          description: "Full content (for proof, ingest)"
+        },
+        metric_value: {
+          type: "string",
+          description: 'Key metric like "3x ROI" (for proof)'
+        },
+        source_type: {
+          type: "string",
+          description: "Where this came from (for proof, changelog)"
+        },
+        source_id: {
+          type: "string",
+          description: "Source record ID (for proof)"
+        },
+        product_id: {
+          type: "string",
+          description: "Link to product via graph edge (for proof)"
+        },
+        // ─── Competitor params ──────────────────────────
+        website: {
+          type: "string",
+          description: "Competitor website URL (for competitor)"
+        },
+        positioning: {
+          type: "string",
+          description: "Market positioning (for competitor)"
+        },
+        strengths: {
+          type: "array",
+          items: { type: "string" },
+          description: "Competitor strengths (for competitor)"
+        },
+        weaknesses: {
+          type: "array",
+          items: { type: "string" },
+          description: "Competitor weaknesses (for competitor)"
+        },
+        differentiation_notes: {
+          type: "string",
+          description: "How we differentiate (for competitor)"
+        },
+        // ─── Outcome params ─────────────────────────────
+        outcome_type: {
+          type: "string",
+          enum: [
+            "deal_won",
+            "deal_lost",
+            "meeting_booked",
+            "reply_positive",
+            "reply_negative",
+            "content_high_engagement",
+            "content_low_engagement",
+            "campaign_result"
+          ],
+          description: "Outcome type (for outcome)"
+        },
+        entity_type: {
+          type: "string",
+          description: "Graph entity type (for outcome, changelog) \u2014 e.g., persona, product"
+        },
+        entity_id: {
+          type: "string",
+          description: "Entity UUID (for outcome, changelog)"
+        },
+        detail: {
+          type: "string",
+          description: "Outcome description (for outcome)"
+        },
+        metrics: {
+          type: "object",
+          description: "Outcome metrics as JSON (for outcome)"
+        },
+        occurred_at: {
+          type: "string",
+          description: "When the outcome occurred, ISO 8601 (for outcome)"
+        },
+        // ─── Propose params ─────────────────────────────
+        min_entries_per_topic: {
+          type: "number",
+          description: "Min entries per topic to consider, default 3 (for propose)"
+        },
+        max_clusters: {
+          type: "number",
+          description: "Max topic clusters to analyze, default 20 (for propose)"
+        },
+        // ─── Ingest params ──────────────────────────────
+        filename: {
+          type: "string",
+          description: "Document filename (for ingest)"
+        },
+        document_type: {
+          type: "string",
+          enum: [
+            "pitch_deck",
+            "case_study",
+            "icp_doc",
+            "proposal",
+            "sop",
+            "playbook",
+            "competitive_analysis",
+            "other"
+          ],
+          description: "Document type \u2014 determines extraction strategy (for ingest)"
+        },
+        // ─── LinkedIn ingest params ─────────────────────
+        linkedin_url: {
+          type: "string",
+          description: "LinkedIn profile URL (for ingest_linkedin)"
+        },
+        include_posts: {
+          type: "boolean",
+          description: "Also scrape recent posts (for ingest_linkedin)"
+        },
+        // ─── Refresh competitor params ──────────────────
+        competitor_name: {
+          type: "string",
+          description: "Name of competitor to refresh (for refresh_competitor)"
+        },
+        search_query: {
+          type: "string",
+          description: "Custom search query (for refresh_competitor)"
+        },
+        // ─── Changelog params ───────────────────────────
+        source: {
+          type: "string",
+          description: "Filter by change source: manual, ontology_extractor, document_processor, outcome_loop (for changelog)"
+        },
+        limit: {
+          type: "number",
+          description: "Max entries to return (for changelog)"
+        },
+        // ─── Score params ───────────────────────────────
+        headline: {
+          type: "string",
+          description: "LinkedIn headline or job title (for score)"
+        },
+        location: {
+          type: "string",
+          description: "Location (for score)"
+        },
+        company_name: {
+          type: "string",
+          description: "Company name (for score)"
+        },
+        company_size: {
+          type: "string",
+          description: 'Company size range e.g. "11-50" (for score)'
+        },
+        industry: {
+          type: "string",
+          description: "Industry (for score)"
+        },
+        base_score: {
+          type: "number",
+          description: "Base priority score to boost, 0-100 (for score)"
+        },
+        // ─── Ownership (shared) ─────────────────────────
+        owner_id: {
+          type: "string",
+          description: "Owner ID (omit to use your default owner from env)"
+        },
+        owner_type: {
+          type: "string",
+          enum: ["user", "tenant"],
+          description: "Owner type: user or tenant"
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/engagement.ts
+var engagementTools = [
+  {
+    name: "engagement",
+    description: "Monitor LinkedIn post engagement and auto-send personalized cold emails to engagers. Works with both your own posts AND external posts (competitors, influencers). Enable scraping on any post URL, view engagers, trigger enrichment + PlusVibe push. Enrichment includes email waterfall + phone number lookup. The scrape cron runs every 10 minutes and automatically pushes new engagers through the enrichment waterfall (email + phone finding + validation) and into a PlusVibe campaign.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["monitor", "status", "engagers", "push"],
+          description: "Action to perform: monitor (enable/disable scraping + cold email on any post), status (show all monitored posts \u2014 own and external), engagers (list engagers for a post), push (configure auto-push on a post \u2014 the scrape cron enriches and pushes every 10 min, or use the returned contacts with gtm_enrich + gtm_campaign for immediate push)"
+        },
+        post_url: {
+          type: "string",
+          description: "LinkedIn post URL. Required for monitor, engagers, and push actions. Works with any LinkedIn post \u2014 your own or external (competitor/influencer)."
+        },
+        enabled: {
+          type: "boolean",
+          description: "Enable (true) or disable (false) engagement scraping. Used with monitor action."
+        },
+        plusvibe_campaign_id: {
+          type: "string",
+          description: "PlusVibe campaign ID to auto-push enriched engagers to. When set with monitor action, all new engagers are automatically enriched and pushed."
+        },
+        opt_in_url: {
+          type: "string",
+          description: "Lead magnet URL for email template {{opt_in_url}} variable. Used with monitor action."
+        },
+        post_topic: {
+          type: "string",
+          description: 'Topic of the post for personalization (e.g. "AI agents", "cold email tips"). Used with monitor action for external posts where we cannot infer the topic.'
+        },
+        creator_name: {
+          type: "string",
+          description: 'Name of the post creator for display purposes (e.g. "Alex Hormozi"). Used with monitor action for external posts.'
+        },
+        filter: {
+          type: "string",
+          enum: ["all", "enriched", "unenriched", "pushed", "unpushed"],
+          description: "Filter engagers by enrichment/push status. Used with engagers action. Default: all."
+        },
+        campaign_id: {
+          type: "string",
+          description: "PlusVibe campaign ID for manual push. Required for push action."
+        },
+        limit: {
+          type: "number",
+          description: "Max number of engagers to return or push. Default: 50."
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/dfy.ts
+var dfyTools = [
+  {
+    name: "dfy",
+    description: 'Manage DFY (Done-For-You) client engagements. Query engagement status, content output, pipeline progress, and diagnose blockers. Requires SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY. Use action: "list" to see all engagements, "status" for a single engagement, "content" for content items, "pipeline" for the kanban view, "diagnose" to identify blockers, "queue" for items needing attention.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "status", "content", "pipeline", "diagnose", "queue"],
+          description: "list: all engagements with summary stats (supports name filter). status: single engagement overview (stage, deliverables, intake, blockers). content: content items for an engagement (count, statuses, titles). pipeline: kanban view of all active engagements by stage. diagnose: why is a client stuck? (automation failures, intake quality, blockers). queue: items needing attention (failed, stuck, past-due)."
+        },
+        engagement_id: {
+          type: "string",
+          description: "Engagement ID. Required for status, content, and diagnose actions."
+        },
+        name: {
+          type: "string",
+          description: "Client name or company to search for. Used with list to filter, or with status/content/diagnose as alternative to engagement_id."
+        },
+        status_filter: {
+          type: "string",
+          enum: [
+            "pending_payment",
+            "onboarding",
+            "active",
+            "paused",
+            "completed",
+            "cancelled",
+            "churned"
+          ],
+          description: "Filter engagements by status. Used with list action."
+        },
+        engagement_type: {
+          type: "string",
+          enum: ["intro_offer", "full_dfy"],
+          description: "Filter by engagement type. Used with list action."
+        },
+        tenant_id: {
+          type: "string",
+          description: "Tenant ID override. Defaults to GTM_TENANT_ID env var."
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/tam.ts
+var tamTools = [
+  {
+    name: "build_tam",
+    description: "Build a Total Addressable Market list by intelligently querying multiple company-finding providers (DiscoLike, Apollo, Exa, StoreLeads, Apify) in budget-optimized sequence. Deduplicates across providers by domain, LinkedIn URL, and company name. Supports session persistence for incremental builds across conversations. Use dry_run to preview provider order and cost estimate without spending credits.",
+    inputSchema: {
+      type: "object",
+      required: ["icp_text"],
+      properties: {
+        icp_text: {
+          type: "string",
+          description: 'Natural language ICP description (e.g., "B2B SaaS startups in US, 50-200 employees, using React")'
+        },
+        domains: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Lookalike seed domains \u2014 find companies similar to these (e.g., ["stripe.com", "plaid.com"])'
+        },
+        budget_usd: {
+          type: "number",
+          description: "Total budget for this TAM build in USD. System allocates across providers and stops when budget is exhausted."
+        },
+        session: {
+          type: "string",
+          description: "Session name to resume or create (persists to ~/.gtm/tam-sessions/). Resuming a session deduplicates against all previously found companies."
+        },
+        providers: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Override automatic provider order (e.g., ["disco", "apollo"]). Default: auto-routed based on ICP analysis.'
+        },
+        max_per_provider: {
+          type: "number",
+          description: "Max companies to fetch per provider (default: 500)"
+        },
+        limit: {
+          type: "number",
+          description: "Total target companies across all providers (default: 1000)"
+        },
+        country: {
+          type: "string",
+          description: 'Country filter (e.g., "US", "UK", "DE")'
+        },
+        min_employees: {
+          type: "number",
+          description: "Minimum employee count"
+        },
+        max_employees: {
+          type: "number",
+          description: "Maximum employee count"
+        },
+        tech_stack: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Filter by technology stack (e.g., ["React", "AWS"])'
+        },
+        category: {
+          type: "string",
+          description: 'Industry category filter (e.g., "SaaS", "FinTech", "Healthcare")'
+        },
+        negate_domains: {
+          type: "array",
+          items: { type: "string" },
+          description: "Domains to always exclude from results (e.g., your own company)"
+        },
+        output: {
+          type: "string",
+          enum: ["summary", "file", "inline"],
+          description: "Output mode. summary (default): round stats + file path. file: full JSONL/CSV output. inline: all companies in response (auto-switches to file if >200)."
+        },
+        dry_run: {
+          type: "boolean",
+          description: "Preview provider routing order and cost estimate without executing any API calls"
+        }
+      }
+    }
+  }
+];
+
+// src/tools/knowledge.ts
+var knowledgeTools = [
+  {
+    name: "knowledge",
+    description: "AI Brain \u2014 search, browse, ask questions, submit transcripts. Actions: search (query), browse, clusters, ask (question), submit (transcript + title).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["search", "browse", "clusters", "ask", "submit"],
+          description: "search (semantic), browse (by category), clusters (topic themes), ask (AI Q&A), submit (ingest transcript)"
+        },
+        query: { type: "string", description: "Search query (for search action)" },
+        question: { type: "string", description: "Question to answer (for ask action)" },
+        transcript: {
+          type: "string",
+          description: "Transcript text to ingest (for submit action, min 100 chars)"
+        },
+        title: { type: "string", description: "Transcript title (for submit action)" },
+        category: {
+          type: "string",
+          enum: ["insight", "question", "product_intel"],
+          description: "Filter by category"
+        },
+        type: {
+          type: "string",
+          description: "Filter by type: how_to, insight, story, question, objection, mistake, decision, market_intel"
+        },
+        tag: { type: "string", description: "Filter by tag (for browse action)" },
+        min_quality: {
+          type: "number",
+          description: "Minimum quality score 1-5 (for search)"
+        },
+        limit: { type: "number", description: "Max results (default 20)" },
+        team_id: { type: "string", description: "Team ID (optional, for multi-team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/mixer.ts
+var mixerTools = [
+  {
+    name: "mixer",
+    description: "Generate content by combining ingredients: exploits (formats), knowledge entries, styles, templates, creatives, and trends. Returns draft posts or ideas. Actions: mix (generate), inventory (available ingredients), recipes (suggested combos), performance (historical metrics).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["mix", "inventory", "recipes", "performance"],
+          description: "mix (generate content), inventory (available ingredients), recipes (suggested combos), performance (historical metrics)"
+        },
+        team_profile_id: {
+          type: "string",
+          description: "Team profile ID (required for all actions)"
+        },
+        exploit_id: { type: "string", description: "Exploit/format to use (for mix)" },
+        knowledge_topic: {
+          type: "string",
+          description: "Knowledge topic to incorporate (for mix)"
+        },
+        knowledge_query: {
+          type: "string",
+          description: "Search knowledge by query (for mix)"
+        },
+        style_id: { type: "string", description: "Writing style to apply (for mix)" },
+        template_id: { type: "string", description: "Template to follow (for mix)" },
+        creative_id: {
+          type: "string",
+          description: "Creative/swipe file to reference (for mix)"
+        },
+        trend_topic: {
+          type: "string",
+          description: "Trending topic to incorporate (for mix)"
+        },
+        hook: { type: "string", description: "Custom hook/opening (for mix)" },
+        instructions: {
+          type: "string",
+          description: "Additional generation instructions (for mix)"
+        },
+        count: {
+          type: "number",
+          description: "Number of outputs (default 3, for mix)"
+        },
+        output: {
+          type: "string",
+          enum: ["drafts", "ideas"],
+          description: "Output type (default drafts, for mix)"
+        },
+        limit: {
+          type: "number",
+          description: "Max results (for recipes/performance)"
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/dm-coach.ts
+var dmCoachTools = [
+  {
+    name: "dm",
+    description: "AI coaching for LinkedIn DM conversations. Get suggested responses based on conversation history, qualification stage, and goal. Actions: suggest (AI coaching), list/get/create/update/delete (manage contacts), messages (add conversation messages).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["suggest", "list", "get", "create", "update", "delete", "messages"],
+          description: "suggest (AI coaching), list/get/create/update/delete (manage contacts), messages (add conversation messages)"
+        },
+        id: {
+          type: "string",
+          description: "Contact ID (required for suggest, get, update, delete, messages)"
+        },
+        name: { type: "string", description: "Contact name (for create)" },
+        linkedin_url: { type: "string", description: "LinkedIn URL (for create)" },
+        headline: { type: "string", description: "Contact headline (for create/update)" },
+        company: { type: "string", description: "Contact company (for create/update)" },
+        conversation_goal: {
+          type: "string",
+          enum: [
+            "book_meeting",
+            "build_relationship",
+            "promote_content",
+            "explore_partnership",
+            "nurture_lead",
+            "close_deal"
+          ],
+          description: "Conversation goal (for create/update)"
+        },
+        status: {
+          type: "string",
+          enum: ["active", "paused", "closed_won", "closed_lost"],
+          description: "Filter by status (for list) or set status (for update)"
+        },
+        messages: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              role: { type: "string", enum: ["them", "me"] },
+              content: { type: "string" },
+              timestamp: { type: "string", description: "ISO 8601 timestamp" }
+            },
+            required: ["role", "content"]
+          },
+          description: "Messages to add (for messages action)"
+        },
+        notes: { type: "string", description: "Contact notes (for create/update)" },
+        search: { type: "string", description: "Search by name (for list)" },
+        team_id: { type: "string", description: "Team ID (optional, for multi-team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/launch.ts
+var launchTools = [
+  {
+    name: "launch",
+    description: "Multi-step shortcuts. Actions: magnet (create magnet + funnel + email + publish in one call), schedule_week (batch-create + schedule posts).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["magnet", "schedule_week"],
+          description: "magnet (create + publish lead magnet end-to-end), schedule_week (batch create + schedule posts)"
+        },
+        title: {
+          type: "string",
+          description: "Lead magnet title (for magnet action)"
+        },
+        archetype: {
+          type: "string",
+          enum: [
+            "single-breakdown",
+            "single-system",
+            "focused-toolkit",
+            "single-calculator",
+            "focused-directory",
+            "mini-training",
+            "one-story",
+            "prompt",
+            "assessment",
+            "workflow"
+          ],
+          description: "Lead magnet archetype (for magnet action)"
+        },
+        content: {
+          type: "object",
+          description: "Lead magnet content matching archetype schema (for magnet action)"
+        },
+        slug: {
+          type: "string",
+          description: "Funnel page slug (for magnet action)"
+        },
+        funnel_theme: {
+          type: "string",
+          enum: ["dark", "light", "modern"],
+          description: "Funnel visual theme (for magnet action)"
+        },
+        email_sequence: {
+          type: "object",
+          description: "Email sequence config: { emails: [{ day, subject, body }] } (for magnet action)"
+        },
+        posts: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              body: { type: "string" },
+              title: { type: "string" },
+              pillar: { type: "string" },
+              content_type: { type: "string" }
+            },
+            required: ["body"]
+          },
+          description: "Posts to create and schedule (for schedule_week action)"
+        },
+        week_start: {
+          type: "string",
+          description: "ISO date for start of week (defaults next Monday, for schedule_week)"
+        },
+        team_id: { type: "string", description: "Team ID (optional)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/exploit.ts
+var exploitTools = [
+  {
+    name: "exploit",
+    description: "Use proven LinkedIn post formats (exploits) to generate content. List available formats, generate a post from a format + knowledge + style combination, or see trending topics.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "generate", "trends"],
+          description: "list (available formats), generate (create post from format), trends (trending topics)"
+        },
+        category: {
+          type: "string",
+          enum: ["regular_post", "lead_magnet"],
+          description: "Filter exploits by category (for list)"
+        },
+        with_stats: {
+          type: "boolean",
+          description: "Include engagement stats (for list)"
+        },
+        exploit_id: {
+          type: "string",
+          description: "Exploit/format ID to use (for generate)"
+        },
+        creative_id: {
+          type: "string",
+          description: "Creative swipe file to reference (for generate)"
+        },
+        knowledge_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: "Knowledge entry IDs to incorporate (for generate)"
+        },
+        template_id: { type: "string", description: "Template ID (for generate)" },
+        style_id: { type: "string", description: "Writing style ID (for generate)" },
+        hook: {
+          type: "string",
+          description: "Custom hook/opening line (for generate)"
+        },
+        instructions: {
+          type: "string",
+          description: "Additional instructions (for generate)"
+        },
+        limit: {
+          type: "number",
+          description: "Max results (for trends, default 10)"
+        }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/mode.ts
+var modeTools = [
+  {
+    name: "switch_mode",
+    description: "Switch the active tool profile to show only relevant tools. Profiles: core (~20 general-purpose tools), discover (company/people search + TAM), create (content + knowledge tools), campaign (outreach + email), intel (knowledge graph \u2014 15 tools), manage (CRM + admin), full (all tools). Switching replaces the current profile. All tools remain callable regardless of profile.",
+    inputSchema: {
+      type: "object",
+      required: ["profile"],
+      properties: {
+        profile: {
+          type: "string",
+          enum: ["core", "discover", "create", "campaign", "intel", "manage", "full"],
+          description: "Profile to switch to"
+        },
+        show: {
+          type: "boolean",
+          description: "If true, show current profile and available profiles without switching"
+        }
+      }
+    }
+  }
+];
+
+// src/tools/magnet.ts
+var magnetTools = [
+  {
+    name: "magnet",
+    description: "Lead magnet lifecycle: CRUD, email sequences, and launch shortcut. CRUD: list, get, create (title + archetype required), update, delete. Sequences: get_sequence, save_sequence, activate_sequence (day-relative drip emails). Shortcuts: launch (create magnet + funnel + sequence + publish in one call), schedule_week (batch create + schedule posts).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "list",
+            "get",
+            "create",
+            "update",
+            "delete",
+            "publish",
+            "get_sequence",
+            "save_sequence",
+            "activate_sequence",
+            "launch",
+            "schedule_week"
+          ],
+          description: "CRUD: list, get, create, update, delete. Publishing: publish (set status to published, requires id). Sequences: get_sequence, save_sequence, activate_sequence. Shortcuts: launch (all-in-one), schedule_week (batch posts)."
+        },
+        id: {
+          type: "string",
+          description: "Lead magnet ID (for get/update/delete/sequence actions)"
+        },
+        title: { type: "string", description: "Lead magnet title (for create/launch)" },
+        archetype: {
+          type: "string",
+          enum: [
+            "single-breakdown",
+            "single-system",
+            "focused-toolkit",
+            "single-calculator",
+            "focused-directory",
+            "mini-training",
+            "one-story",
+            "prompt",
+            "assessment",
+            "workflow"
+          ],
+          description: "Lead magnet archetype (for create/launch). Determines content schema."
+        },
+        content: {
+          type: "object",
+          description: "Lead magnet content matching archetype schema (for update/launch)"
+        },
+        status: {
+          type: "string",
+          enum: ["draft", "published", "archived"],
+          description: "Filter by status (for list)"
+        },
+        limit: { type: "number", description: "Max results (for list)" },
+        offset: { type: "number", description: "Pagination offset (for list)" },
+        // ─── Sequence params (absorbed from email_sequence) ─────
+        emails: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              day: { type: "number", description: "Day number in sequence" },
+              subject: { type: "string", description: "Email subject line" },
+              body: { type: "string", description: "Email body (HTML or plain text)" }
+            },
+            required: ["day", "subject", "body"]
+          },
+          description: "Email sequence entries (for save_sequence)"
+        },
+        // ─── Launch params (absorbed from launch) ───────────────
+        slug: { type: "string", description: "Funnel page slug (for launch)" },
+        funnel_theme: {
+          type: "string",
+          enum: ["dark", "light", "modern"],
+          description: "Funnel visual theme (for launch)"
+        },
+        email_sequence: {
+          type: "object",
+          description: "Email sequence config: { emails: [{ day, subject, body }] } (for launch)"
+        },
+        // ─── Schedule week params (absorbed from launch) ────────
+        posts: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              body: { type: "string" },
+              title: { type: "string" },
+              pillar: { type: "string" },
+              content_type: { type: "string" }
+            },
+            required: ["body"]
+          },
+          description: "Posts to create and schedule (for schedule_week)"
+        },
+        week_start: {
+          type: "string",
+          description: "ISO date for start of week (for schedule_week)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/funnel.ts
+var funnelTools = [
+  {
+    name: "funnel",
+    description: "Opt-in funnel pages for lead magnets. CRUD: list, get, create (lead_magnet_id required), update, delete. Publishing: publish, unpublish. Update supports: optinSubline, optinSocialProof, thankyouSubline, qualificationFormId, vslUrl, calendlyUrl, qualificationPassMessage, qualificationFailMessage. Qualification forms: list_forms, get_form (form_id), get_questions (form_id).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "list",
+            "get",
+            "create",
+            "update",
+            "delete",
+            "publish",
+            "unpublish",
+            "list_forms",
+            "get_form",
+            "get_questions"
+          ],
+          description: "CRUD: list, get, create, update, delete. Publishing: publish, unpublish. Qualification forms: list_forms, get_form (form_id required), get_questions (form_id required)."
+        },
+        id: { type: "string", description: "Funnel ID (for get/update/delete/publish/unpublish)" },
+        lead_magnet_id: {
+          type: "string",
+          description: "Lead magnet to create funnel for (for create)"
+        },
+        theme: {
+          type: "string",
+          enum: ["dark", "light", "modern"],
+          description: "Visual theme (for create/update)"
+        },
+        content: {
+          type: "object",
+          description: "Funnel page content (for update)"
+        },
+        // ─── Updatable funnel fields (for update) ─────────────
+        optinSubline: { type: "string", description: "Opt-in page subtitle text (for update)" },
+        optinSocialProof: {
+          type: "string",
+          description: "Social proof text on opt-in page (for update)"
+        },
+        thankyouSubline: {
+          type: "string",
+          description: "Thank you page subtitle text (for update)"
+        },
+        qualificationFormId: {
+          type: "string",
+          description: "Qualification form ID to attach (for update)"
+        },
+        vslUrl: { type: "string", description: "Video sales letter URL (for update)" },
+        calendlyUrl: { type: "string", description: "Booking calendar URL (for update)" },
+        qualificationPassMessage: {
+          type: "string",
+          description: "Message shown when lead qualifies (for update)"
+        },
+        qualificationFailMessage: {
+          type: "string",
+          description: "Message shown when lead fails qualification (for update)"
+        },
+        // ─── Qualification form params ────────────────────────
+        form_id: {
+          type: "string",
+          description: "Qualification form ID (for get_form, get_questions)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/post.ts
+var postTools = [
+  {
+    name: "post",
+    description: "LinkedIn posts \u2014 CRUD, AI generation, content queue, and discovery. Actions: list/get/create/update/delete, publish/publish_linkedin/list_accounts, generate, queue_list/queue_update/queue_submit, formats/ingredients/recipes/trends/performance. Call tool_help for generation params.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: [
+            "list",
+            "get",
+            "create",
+            "update",
+            "delete",
+            "publish",
+            "publish_linkedin",
+            "list_accounts",
+            "generate",
+            "queue_list",
+            "queue_update",
+            "queue_submit",
+            "formats",
+            "ingredients",
+            "recipes",
+            "trends",
+            "performance"
+          ],
+          description: "CRUD: list, get, create, update, delete. Publish: publish (schedule), publish_linkedin (post now), list_accounts. Generate: generate (AI content). Discovery: formats, ingredients, recipes, trends, performance."
+        },
+        // ─── CRUD params ─────────────────────────────
+        id: { type: "string", description: "Post ID (for get/update/delete/publish)" },
+        body: { type: "string", description: "Post body text (for create/update)" },
+        title: { type: "string", description: "Post title (for create/update)" },
+        pillar: { type: "string", description: "Content pillar (for create)" },
+        content_type: { type: "string", description: "Content type (for create)" },
+        status: { type: "string", description: "Filter by status (for list)" },
+        limit: { type: "number", description: "Max results (for list/recipes/trends/performance)" },
+        offset: { type: "number", description: "Pagination offset (for list)" },
+        // ─── Publish params ──────────────────────────
+        account_id: {
+          type: "string",
+          description: "LinkedIn account to publish to (for publish_linkedin)"
+        },
+        // ─── Generation params (from mixer) ──────────
+        exploit_id: { type: "string", description: "Post format/exploit to use (for generate)" },
+        knowledge_topic: {
+          type: "string",
+          description: "Knowledge topic to incorporate (for generate)"
+        },
+        knowledge_query: {
+          type: "string",
+          description: "Search knowledge by query (for generate)"
+        },
+        knowledge_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: "Knowledge entry IDs to incorporate (for generate)"
+        },
+        style_id: { type: "string", description: "Writing style to apply (for generate)" },
+        template_id: { type: "string", description: "Template to follow (for generate)" },
+        creative_id: {
+          type: "string",
+          description: "Creative/swipe file to reference (for generate)"
+        },
+        trend_topic: {
+          type: "string",
+          description: "Trending topic to incorporate (for generate)"
+        },
+        hook: { type: "string", description: "Custom hook/opening (for generate)" },
+        instructions: {
+          type: "string",
+          description: "Additional generation instructions (for generate)"
+        },
+        count: {
+          type: "number",
+          description: "Number of outputs to generate (default 3, for generate)"
+        },
+        output: {
+          type: "string",
+          enum: ["drafts", "ideas"],
+          description: "Output type (default drafts, for generate)"
+        },
+        // ─── Formats params (from exploit) ───────────
+        category: {
+          type: "string",
+          enum: ["regular_post", "lead_magnet"],
+          description: "Filter formats by category (for formats)"
+        },
+        with_stats: {
+          type: "boolean",
+          description: "Include engagement stats (for formats)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/email-sequence.ts
+var emailSequenceTools = [
+  {
+    name: "email_sequence",
+    description: "Email nurture drip for lead magnets. Actions: get \u2192 save \u2192 activate. Requires lead_magnet_id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["get", "save", "activate"],
+          description: "get (view), save (create/update), activate (start sending)"
+        },
+        lead_magnet_id: {
+          type: "string",
+          description: "Lead magnet ID (required for all actions)"
+        },
+        emails: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              day: { type: "number", description: "Day number in sequence" },
+              subject: { type: "string", description: "Email subject line" },
+              body: { type: "string", description: "Email body (HTML or plain text)" }
+            },
+            required: ["day", "subject", "body"]
+          },
+          description: "Email sequence entries (for save action)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action", "lead_magnet_id"]
+    }
+  }
+];
+
+// src/tools/leads.ts
+var leadsTools = [
+  {
+    name: "leads",
+    description: "View/export leads captured via funnel opt-ins. Actions: list, get, export (csv/json).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "get", "export"],
+          description: "list (browse leads), get (single lead), export (download)"
+        },
+        id: { type: "string", description: "Lead ID (for get)" },
+        lead_magnet_id: { type: "string", description: "Filter by lead magnet (for list)" },
+        status: { type: "string", description: "Filter by status (for list)" },
+        limit: { type: "number", description: "Max results (for list, default 50)" },
+        offset: { type: "number", description: "Pagination offset (for list)" },
+        format: {
+          type: "string",
+          enum: ["csv", "json"],
+          description: "Export format (for export, default csv)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/analytics.ts
+var analyticsTools = [
+  {
+    name: "analytics",
+    description: "Team-wide GTM performance insights and AI recommendations. Actions: insights, recommendations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["insights", "recommendations"],
+          description: "insights (performance metrics), recommendations (AI suggestions)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/outreach.ts
+var outreachTools = [
+  {
+    name: "outreach",
+    description: "App-managed LinkedIn outreach campaigns with safety gates and human-like timing. Actions: list, get, create, update, activate, pause, delete, add_leads. Different from campaign: these are Maestro-managed sequences, not provider-level ops.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "get", "create", "update", "activate", "pause", "delete", "add_leads"],
+          description: "list, get, create, update, activate, pause, delete, add_leads."
+        },
+        id: {
+          type: "string",
+          description: "Outreach campaign ID (for get/update/activate/pause/delete/add_leads)"
+        },
+        name: { type: "string", description: "Campaign name (for create/update)" },
+        message_template: {
+          type: "string",
+          description: "Message template with {{placeholders}} (for create/update)"
+        },
+        follow_up_template: {
+          type: "string",
+          description: "Follow-up message template (for create/update)"
+        },
+        follow_up_delay_days: {
+          type: "number",
+          description: "Days before follow-up (for create/update)"
+        },
+        leads: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              linkedin_url: { type: "string", description: "LinkedIn profile URL (required)" },
+              first_name: { type: "string" },
+              last_name: { type: "string" },
+              company: { type: "string" },
+              headline: { type: "string" }
+            },
+            required: ["linkedin_url"]
+          },
+          description: "Leads to add (for add_leads)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/creative.ts
+var creativeTools = [
+  {
+    name: "creative",
+    description: 'Swipe file management for content generation. Actions: list (browse saved creatives), create (add a new creative), scan (analyze creatives for performance patterns), configure_sources (set up auto-scan sources). Creatives feed into post({ action: "generate", creative_id: "..." }).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "create", "scan", "configure_sources"],
+          description: "list, create, scan, configure_sources."
+        },
+        url: { type: "string", description: "URL of creative to add (for create)" },
+        body: { type: "string", description: "Creative content body (for create, if not URL)" },
+        source: { type: "string", description: "Source attribution (for create)" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization (for create)"
+        },
+        sources: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              type: { type: "string", description: "Source type (linkedin_profile, rss, etc.)" },
+              url: { type: "string", description: "Source URL" }
+            },
+            required: ["type", "url"]
+          },
+          description: "Scanner sources to configure (for configure_sources)"
+        },
+        limit: { type: "number", description: "Max results (for list)" },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action"]
+    }
+  }
+];
+
+// src/tools/safety.ts
+var safetyTools = [
+  {
+    name: "safety",
+    description: "Account safety settings for LinkedIn. Actions: get (view current limits), update (change limits). Manage daily action limits, cool-down periods, and risk thresholds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["get", "update"],
+          description: "get (view settings), update (change settings)."
+        },
+        account_id: { type: "string", description: "LinkedIn account ID (required)" },
+        daily_connection_limit: {
+          type: "number",
+          description: "Max connection requests per day (for update)"
+        },
+        daily_message_limit: { type: "number", description: "Max messages per day (for update)" },
+        daily_view_limit: { type: "number", description: "Max profile views per day (for update)" },
+        cooldown_minutes: { type: "number", description: "Minutes between actions (for update)" },
+        risk_level: {
+          type: "string",
+          enum: ["conservative", "moderate", "aggressive"],
+          description: "Risk threshold preset (for update)"
+        },
+        team_id: { type: "string", description: "Team ID (omit to use your default team)" }
+      },
+      required: ["action", "account_id"]
+    }
+  }
+];
+
+// src/tools/descriptions.ts
+var TOOL_DESCRIPTIONS = {
+  find_companies: `Discover companies matching your ICP criteria. Powered by DiscoLike (60M+ companies from web/SSL crawl data) and optionally Apollo.
+
+DiscoLike strengths:
+- Lookalike discovery: give it 1-10 seed domains, get similar companies
+- ICP text matching: describe your ideal customer in plain English
+- Tech stack filtering: find companies using specific technologies
+- Website content analysis: matches against actual site content
+- Best for: B2B companies, local businesses, professional services, healthcare
+
+For DTC/e-commerce brands, use provider: "storeleads" \u2014 it has revenue estimates and category data that neither DiscoLike nor Apollo provides.
+
+Tip: DiscoLike lookalike mode is extremely powerful. If you have 2-3 example companies, use the domains parameter to find hundreds of similar ones.
+
+Single domain lookup: passing just domain (no icp_text, domains, category, tech_stack, or country) does a direct company profile fetch with rich data (growth signals, engagement metrics, tech stack from vendors). This is for researching ONE specific company, not discovery.
+
+Pass review: true to push discovery results to a visual review table at view.maestrogtm.com so the user can select companies before enrichment or outreach.
+
+Exa (provider: "exa") \u2014 semantic/neural search:
+- Meaning-based ICP matching: "B2B SaaS companies selling to healthcare, not healthtech vendors" actually works
+- Best for: nuanced ICP descriptions where keyword matching fails
+- Uses icp_text for semantic search, domains for lookalike discovery
+- Does NOT return employee count, industry, or tech stack \u2014 use for discovery, then enrich with DiscoLike or Apollo
+- Must be explicitly selected with provider: "exa" (not auto-selected)
+- Requires GTM_EXA_API_KEY env var`,
+  find_people: `Find contacts at companies by job title, company, or domain. Returns name, title, email (when available), phone, and LinkedIn URL.
+
+Powered by DiscoLike Contacts, Apollo, or BetterContact depending on configuration.
+
+DiscoLike strengths:
+- Domain-based search: pass company_domain or company_domains[] for multi-domain batch
+- Seniority filtering (owner, founder, c_suite, partner, vp, head, director, manager, senior, entry, intern)
+- Industry + skills filtering to narrow results without post-processing
+- email_validated flag for pre-verified emails only
+- Employee/revenue range filters for company-level targeting
+- Returns validated emails when available
+
+Response is slim by default (name, title, email, company, company_domain, linkedin). Pass fields: "all" for full payload.
+
+After finding people, use:
+- enrich to get verified email/phone if not returned (company_domain field is pipeline-compatible)
+- extract to check LinkedIn activity and engagement signals
+
+Known limitations:
+- department + seniority filters combined may return 0 results (Disco API uses strict AND). Use one or the other.
+
+Pass review: true to push results to a visual review table at view.maestrogtm.com so the user can select rows before proceeding.`,
+  enrich: `Email/phone waterfall enrichment + single-email verification.
+
+Actions: (default) waterfall enrichment, verify (single email deliverability check).
+
+ENRICHMENT: Tries multiple providers in order, stops on first match. Supports 1-100 contacts per call. IMPORTANT: Defaults to email only. Phone enrichment costs extra \u2014 only include when user explicitly asks. Always dry_run first for batches > 5.
+
+Providers (in configured waterfall order):
+- Prospeo: email finder, good hit rate on LinkedIn-active professionals
+- BetterContact: email + phone, charges only on successful find
+
+Input needs: first_name + last_name minimum. Adding company_domain dramatically improves hit rates. LinkedIn URL is the gold standard input.
+
+Pass table_id to read contacts from an existing review table (selected rows only). Pass review: true to push enrichment results to a new review table.
+
+VERIFY: Pass action: "verify" + email to check deliverability. Returns: deliverable, catch_all_safe, catch_all_not_safe, undeliverable, or unknown. Use after enrichment or to validate an existing email.`,
+  verify: 'Verify a single email address for deliverability. Absorbed into enrich({ action: "verify" }).',
+  extract: `Extract structured data from any URL or platform. LinkedIn profiles, posts, engagement, search results, company posts, and web pages.
+
+When to use:
+- Scrape a LinkedIn profile for headline, experience, skills, follower count
+- Check if someone is active on LinkedIn (recent posts, engagement levels)
+- Find people who comment on or react to specific posts (warm lead mining)
+- Search LinkedIn posts by keyword to find thought leaders
+- Monitor competitor or industry content for engagers
+- Scrape any web page for structured data
+
+When NOT to use:
+- Finding people by job title at a company \u2014 use find_people instead
+- Email enrichment \u2014 use enrich instead
+
+Pairs well with:
+- find_people \u2192 extract (find contacts, then check LinkedIn activity)
+- extract linkedin_engagement \u2192 enrich (find engagers, then get emails)
+- storeleads \u2192 find_people \u2192 extract (DTC brands \u2192 CEOs \u2192 activity check)
+
+Note: HarvestAPI charges per request. For engagement mining, each post lookup counts as a request. Use limit to control costs.`,
+  fetch: "Make an HTTP call to any API endpoint. Use this to pull data from services that don't have a dedicated provider.",
+  ai: "AI-powered data operations: personalize outreach, classify leads, clean data, score prospects, or write copy. Provide an action, input data, and optional prompt. Uses your configured AI provider (Anthropic or OpenAI).",
+  campaign: "Manage cold email + LinkedIn outreach campaigns AND engagement monitoring. Campaign actions: list, stats, add_leads, create. Supports PlusVibe, Instantly, Smartlead (email) and HeyReach (LinkedIn). Each lead must have at least one of email or linkedin_url. Pass table_id to read leads directly from a review table. Engagement actions: monitor (enable/disable LinkedIn post scraping + set PlusVibe campaign), engagement_status (show all monitored posts with counts), engagers (list engagers for a post with enrichment/push status), push (trigger enrichment + PlusVibe push for unpushed engagers). Works with YOUR posts and ANY external post (competitors, influencers). Engagers are enriched via email waterfall + phone lookup and pushed with engagement context variables (post_topic, engagement_type, comment_text).",
+  engagement: 'Monitor LinkedIn post engagement and auto-push to cold email campaigns. Absorbed into campaign({ action: "monitor|engagement_status|engagers|push" }).',
+  crm: "Read and write CRM data. Find, create, or update people and companies. Create deals. Supports Attio and other CRM providers. For the create action, pass table_id to bulk-create contacts from a review table (selected rows only).",
+  status: 'Check provider health, credit balances, and active configuration. Absorbed into configure({ action: "status" }).',
+  configure: 'System config + provider health. Config actions: switch_client, list_clients, show_config, set_waterfall, add_client. Status action: status (provider health, credits, capabilities \u2014 shows which providers are configured and their remaining credits). Use action: "status" to check all provider health, or pass provider param for a single provider check.',
+  guide: "CALL THIS FIRST before any multi-step GTM task. Returns step-by-step workflow recipes for common tasks like building a TAM list, running enrichment, launching cold outreach, or coaching LinkedIn DM replies with Kondo. Always check the guide before starting work to ensure you follow the correct sequence and avoid wasting credits.",
+  tool_help: "Get the full parameter schema for a specific GTM tool. Use this to see exactly what arguments a tool accepts before calling execute.",
+  execute: "Gateway to execute any GTM tool by name. Use guide for workflow recipes, tool_help for parameter schemas, then this to execute.",
+  feedback: "Submit feedback, bug reports, feature requests, or provider requests. Feedback is stored for the Maestro maintainers to review.",
+  review: "Push data to a visual review table hosted at view.maestrogtm.com. Users see an interactive AG Grid in their browser with checkboxes to select/deselect rows. Creates a temporary table (24h TTL) with a shareable URL. Use after finding companies or contacts to let the user review before spending enrichment credits. Three actions: create (new table from data array), update (modify existing table \u2014 add columns, update rows), get_selected (fetch only the rows the user has checked).",
+  batch: 'CSV pipeline + saved recipes. Pipeline actions: run (default \u2014 process CSV through tool steps). Each row runs through steps sequentially \u2014 results extracted as new columns. Use rows: "0:1" to pilot on a single row, dry_run: true to preview without API calls. Template placeholders ({{column}}) for row values. Waterfall mode: set waterfall: true on later steps to skip rows already filled by earlier steps. Recipe actions: save_recipe (persist a batch config under a name), list_recipes, run_recipe (re-run saved config), show_recipe, delete_recipe. Recipes capture full pipeline configs for repeatable execution without re-specifying steps.',
+  provision: "Infrastructure provisioning for client setup. Thirteen actions: check_domains (Zapmail domain availability), check_balance (Zapmail wallet), buy_domains (purchase via wallet), list_domains (all domains with status), list_mailboxes (mailboxes for a domain), setup_dmarc (DMARC for domain IDs), create_mailboxes (mailboxes on domains), export_mailboxes (export to PlusVibe/Instantly), create_plusvibe_client (client in existing workspace), save_config (persist provider config), deploy_crm (Twenty CRM deployment instructions for Railway), start_provision (trigger full provisioning pipeline via gtm-api), status (check provisioning progress).",
+  recipe: "Save, list, run, show, and delete reusable batch pipeline recipes. A recipe captures a full batch config (steps, waterfall, output routing) under a name so it can be re-run later without re-specifying the pipeline. Use save to persist a batch config, list to see saved recipes, show to inspect one, run to execute it, and delete to remove it.",
+  build_tam: "Build a Total Addressable Market list by intelligently querying multiple company-finding providers (DiscoLike, Apollo, Exa, StoreLeads, Apify) in budget-optimized sequence. Deduplicates across providers by domain, LinkedIn URL, and company name. Supports session persistence for incremental builds across conversations. Use dry_run to preview provider order and cost estimate without spending credits.",
+  list: "Persistent GTM list management. Create named lists, import CSVs with auto-detected columns, add contacts, query with filters, view in browser via interactive AG Grid table. Lists persist in Supabase and support incremental enrichment, persona scoring, and campaign push. Custom columns preserved in custom_fields. Use import_csv to bring in Clay exports or any CSV. Use view to open the list in the gtm-viewer browser app.",
+  manage_list: "Persistent GTM list management. Renamed to list \u2014 use list() instead.",
+  // ─── DFY (Done-For-You) ────────────────────────────────
+  dfy: "Manage DFY (Done-For-You) client engagements \u2014 query status, content output, pipeline progress, and diagnose blockers. Actions: list (all engagements with summary stats, supports name filter), status (single engagement overview with deliverables and stage info), content (content items count, statuses, titles for an engagement), pipeline (kanban view of all active engagements grouped by stage), diagnose (identify why a client is stuck \u2014 checks intake quality, automation failures, blocked dependencies), queue (items needing attention \u2014 failed automations, stuck deliverables, past-due items). Supports name-based lookup: pass name instead of engagement_id to search by client name or company.",
+  // ─── Intel (Knowledge Graph) ───────────────────────────
+  intel: "Knowledge graph \u2014 the business intelligence layer. 15 actions covering entity CRUD, context assembly, scoring, ingestion, and auditing.\n\nCONTEXT: context (strategy-based assembly \u2014 call_prep, content_generation, lead_scoring, personalization, campaign_planning, general). Each strategy tunes which entities are included and their priority.\n\nENTITIES: product (what the business sells \u2014 upserts by name), persona (buyer profiles with title patterns, pain points, buying signals \u2014 upserts by name), get_persona (get one or the primary persona), segment (market categories broader than personas), competitor (positioning, strengths, weaknesses).\n\nEVIDENCE: proof (case studies, testimonials, metrics, quotes, before/after \u2014 optionally linked to persona/product via graph edges).\n\nLEARNING: outcome (record deal_won/lost, meeting_booked, reply_positive/negative, content engagement, campaign_result \u2014 feeds the learning loop).\n\nANALYSIS: gaps (coverage gaps per persona \u2014 missing proof points, competitive blind spots), score (match any contact against graph personas \u2014 returns best match, confidence, priority boost), propose (AI extracts entity candidates from knowledge entries \u2014 human review required).\n\nINGEST: ingest (documents \u2014 pitch decks, case studies, ICP docs, proposals, SOPs, playbooks), ingest_linkedin (scrape LinkedIn profile via HarvestAPI + classify against graph), refresh_competitor (Exa web search \u2192 update competitor record).\n\nAUDIT: changelog (mutation history with source, reason, diff).",
+  // ─── Product Tools ──────────────────────────────────────
+  magnet: "Lead magnet lifecycle: CRUD, email sequences, and launch shortcut. CRUD: list, get, create (title + archetype required), update, delete. Archetypes: single-breakdown, single-system, focused-toolkit, single-calculator, focused-directory, mini-training, one-story, prompt, assessment, workflow. Sequences: get_sequence, save_sequence, activate_sequence (day-relative drip emails attached to a magnet). Email day numbers are relative to lead signup (day 0 = immediate). Shortcuts: launch (create magnet + funnel + sequence + publish in one call \u2014 requires title + archetype + content), schedule_week (batch create + schedule posts \u2014 requires posts array with body, optional week_start). After creating, use funnel for opt-in page \u2192 leads for captured contacts.",
+  funnel: "Manage opt-in funnel pages for lead magnets. Each funnel is a landing page connected to exactly one lead magnet \u2014 create the magnet first. Create with lead_magnet_id + theme (dark/light/modern). Publish to make it live at its URL, unpublish to take offline. Leads who opt in via the funnel are visible in the leads tool.",
+  post: "Unified content tool for LinkedIn posts. CRUD: list/get/create (body required)/update/delete. Publishing: publish (add to content queue for scheduled posting), publish_linkedin (post immediately \u2014 requires account_id from list_accounts). AI Generation: generate (requires at least one of exploit_id, knowledge_topic, knowledge_query, trend_topic, or instructions). Queue: queue_list (view queue), queue_update (modify scheduled post), queue_submit (submit queue for publishing). Discovery: formats (proven post structures), ingredients (available content pieces), recipes (AI-suggested combos), trends (hot topics), performance (historical engagement metrics for past posts).",
+  email_sequence: "Manage email nurture sequences attached to lead magnets. Create the magnet first. Workflow: get \u2192 save \u2192 activate. Email day numbers are relative to lead signup (day 0 = immediate, day 1 = next day). Once activated, new leads from the magnet's funnel automatically receive the drip sequence.",
+  leads: "View and export leads captured through lead magnet funnels \u2014 people who opted in via a funnel page. List with filters (lead_magnet_id, status). Export as CSV or JSON. Note: these are opt-in leads, not prospecting contacts (use find_people for outbound prospecting).",
+  analytics: "Team-wide performance insights and AI-powered recommendations across all GTM activities (magnets, funnels, posts, campaigns). Two actions: insights (aggregate metrics overview) and recommendations (AI-generated improvement suggestions). For individual post engagement metrics, use post with action: performance instead.",
+  // ─── App Content Tools ────────────────────────────────
+  knowledge: "Search, browse, or ask questions against the AI knowledge base (Brain). search (pass query param) finds entries by semantic meaning. ask (pass question param) uses RAG to synthesize an answer with citations. browse lists recent entries by category/type/tag. clusters shows topic groupings. submit ingests call transcripts or meeting notes (pass transcript + title).",
+  mixer: "Generate LinkedIn content by combining ingredients: exploits (proven post formats), knowledge entries, writing styles, templates, and creatives (swipe file). Returns draft posts or ideas. Use inventory to see available ingredients, recipes for AI-suggested combinations, and performance for historical engagement data.",
+  dm: "AI-coached LinkedIn DM conversations. Add conversation messages (theirs and yours), then get AI-suggested responses based on conversation history, qualification stage (SPIN framework), and conversation goal (book meeting, build relationship, close deal, etc.). Uses Acknowledge-Value-Question framework + SPIN ladder.",
+  dm_coach: "AI-coached LinkedIn DM conversations. Renamed to dm \u2014 use dm() instead.",
+  launch: 'All-in-one shortcuts for multi-step content creation. "magnet" creates lead magnet + opt-in funnel + email sequence + publishes in one atomic call (requires title + archetype + content). Use magnet/funnel/email_sequence tools individually for more control. "schedule_week" batch-creates posts and schedules across the week (requires posts array with body, optional week_start defaults to next Monday).',
+  exploit: "Use proven LinkedIn post formats (exploits) to generate high-engagement content. List shows available formats with optional engagement stats. Generate creates a post from a format combined with knowledge entries, styles, and templates. Trends shows what topics are currently performing well.",
+  outreach: "App-managed LinkedIn outreach campaigns with built-in safety gates and human-like timing. Actions: list, get, create, update, activate, pause, delete, add_leads. Different from campaign: these are Maestro-managed sequences. For provider-level campaign ops (PlusVibe stats, HeyReach push), use campaign instead.",
+  creative: 'Swipe file management for content generation. Actions: list (browse saved creatives), create (add a new creative by URL or body text), scan (analyze creatives for performance patterns), configure_sources (set up auto-scan sources like LinkedIn profiles, RSS feeds). Creatives feed into post({ action: "generate", creative_id: "..." }) for AI content generation.',
+  safety: "Account safety settings for LinkedIn. Actions: get (view current limits for an account), update (change limits). Manage daily action limits (connections, messages, profile views), cool-down periods between actions, and risk level presets (conservative, moderate, aggressive).",
+  switch_mode: "Switch the active tool profile to control which tools appear in MCP listTools. Profiles group tools by workflow: core (~20 general-purpose), discover (company/people search + TAM), create (content + knowledge), campaign (outreach + email), intel (knowledge graph + knowledge), manage (CRM + admin), full (all tools). Pass show: true to see current profile without switching. All tools remain callable via callTool regardless of active profile."
+};
+
+// src/tools/catalog.ts
+var CATEGORY_LABELS = {
+  prospect: "Discovery & Prospecting",
+  enrich: "Enrichment & Verification",
+  extract: "Data Extraction",
+  fetch: "HTTP Requests",
+  ai: "AI Operations",
+  campaign: "Email Campaigns",
+  crm: "CRM Operations",
+  status: "Provider Status",
+  configure: "Configuration",
+  batch: "Batch Processing",
+  recipe: "Recipes",
+  provision: "Domain Provisioning",
+  list: "List Management",
+  maestro: "Intelligence & Scoring",
+  engagement: "Engagement Monitoring",
+  dfy: "DFY Client Management",
+  tam: "TAM Discovery",
+  knowledge: "Knowledge Base",
+  mixer: "Content Mixing",
+  dm_coach: "DM Coaching",
+  launch: "Compound Actions",
+  exploit: "Content Formats",
+  mode: "Tool Profiles",
+  magnet: "Lead Magnets",
+  funnel: "Funnel Pages",
+  post: "LinkedIn Posts",
+  email_sequence: "Email Sequences",
+  leads: "Lead Management",
+  analytics: "Analytics",
+  meta: "Meta-Tools"
+};
+function buildCatalogText(exclude) {
+  const lines = [];
+  for (const [category, toolNames] of Object.entries(toolCategories)) {
+    const filtered = toolNames.filter((n) => !exclude?.has(n));
+    if (!filtered.length) continue;
+    const label = CATEGORY_LABELS[category] || category;
+    lines.push(`
+### ${label}`);
+    for (const name of filtered) {
+      const tool = toolsByName.get(name);
+      const desc = tool?.description?.split("\n")[0] || "";
+      lines.push(`  ${name} \u2014 ${desc.slice(0, 120)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/tools/index.ts
+var capabilityTools = [
+  ...prospectTools,
+  ...enrichTools,
+  ...extractTools,
+  ...fetchTools,
+  ...aiTools,
+  ...campaignTools,
+  ...crmTools,
+  ...statusTools,
+  ...configureTools,
+  ...feedbackTools,
+  ...reviewTools,
+  ...batchTools,
+  ...recipeTools,
+  ...provisionTools,
+  ...listTools,
+  ...maestroTools,
+  ...engagementTools,
+  ...dfyTools,
+  ...tamTools,
+  ...knowledgeTools,
+  ...mixerTools,
+  ...dmCoachTools,
+  ...launchTools,
+  ...exploitTools,
+  ...modeTools,
+  ...magnetTools,
+  ...funnelTools,
+  ...postTools,
+  ...emailSequenceTools,
+  ...leadsTools,
+  ...analyticsTools,
+  ...outreachTools,
+  ...creativeTools,
+  ...safetyTools
+];
+var guideTool = {
+  name: "guide",
+  description: 'Step-by-step workflow recipes for multi-step GTM tasks. Call with task: "list_tasks" to see all available workflows.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      task: {
+        type: "string",
+        enum: [
+          "build_tam",
+          "enrich_list",
+          "cold_outreach",
+          "linkedin_outreach",
+          "crm_sync",
+          "export_to_webhook",
+          "engagement_cold_email",
+          "create_magnet",
+          "content_pipeline",
+          "dm_coaching",
+          "qualify_inbox",
+          "list_tasks"
+        ],
+        description: "The workflow to get guidance for"
+      }
+    },
+    required: ["task"]
+  }
+};
+var toolHelpTool = {
+  name: "tool_help",
+  description: "Get parameter schema for a GTM tool, or operational playbook for a provider. Use before calling tools to see accepted arguments and provider-specific quirks.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      tool: {
+        type: "string",
+        description: 'The tool name to get help for (e.g., "enrich", "find_companies")'
+      },
+      provider: {
+        type: "string",
+        description: 'Provider name to get operational playbook (quirks, cost, best practices). E.g., "apollo", "prospeo", "attio"'
+      },
+      topic: {
+        type: "string",
+        enum: ["waterfall_ordering", "csv_best_practices"],
+        description: "Get workflow pattern guidance instead of tool/provider help"
+      }
+    }
+  }
+};
+var executeTool = {
+  name: "execute",
+  description: "Gateway to execute any GTM tool by name. Use guide for workflow recipes, tool_help for parameter schemas, then this to execute.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      tool: {
+        type: "string",
+        description: 'The tool name to execute (e.g., "enrich")'
+      },
+      arguments: {
+        type: "object",
+        description: "The arguments to pass to the tool, matching its schema"
+      }
+    },
+    required: ["tool"]
+  }
+};
+var metaTools = [guideTool, toolHelpTool, executeTool];
+var tools = [...capabilityTools, ...metaTools];
+var MCP_HIDDEN_TOOLS = /* @__PURE__ */ new Set([
+  "execute",
+  "mixer",
+  "exploit",
+  // Absorbed tools (Phase 2):
+  "verify",
+  // → enrich({ action: 'verify' })
+  "engagement",
+  // → campaign({ action: 'monitor|engagement_status|engagers|push' })
+  "status",
+  // → configure({ action: 'status' })
+  "recipe",
+  // → batch({ action: 'save_recipe|list_recipes|...' })
+  "email_sequence",
+  // → magnet({ action: 'get_sequence|save_sequence|activate_sequence' })
+  "launch",
+  // → magnet({ action: 'launch|schedule_week' })
+  "feedback",
+  // Dropped from MCP — not agent-critical
+  // Renamed tools (Phase 4):
+  "manage_list",
+  // → list
+  "dm_coach"
+  // → dm
+]);
+var mcpTools = tools.filter((t) => !MCP_HIDDEN_TOOLS.has(t.name));
+var toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+var toolCategories = {
+  prospect: prospectTools.map((t) => t.name),
+  enrich: enrichTools.map((t) => t.name),
+  extract: extractTools.map((t) => t.name),
+  fetch: fetchTools.map((t) => t.name),
+  ai: aiTools.map((t) => t.name),
+  campaign: campaignTools.map((t) => t.name),
+  crm: crmTools.map((t) => t.name),
+  status: statusTools.map((t) => t.name),
+  configure: configureTools.map((t) => t.name),
+  batch: batchTools.map((t) => t.name),
+  recipe: recipeTools.map((t) => t.name),
+  provision: provisionTools.map((t) => t.name),
+  list: listTools.map((t) => t.name),
+  maestro: maestroTools.map((t) => t.name),
+  engagement: engagementTools.map((t) => t.name),
+  dfy: dfyTools.map((t) => t.name),
+  tam: tamTools.map((t) => t.name),
+  knowledge: knowledgeTools.map((t) => t.name),
+  mixer: mixerTools.map((t) => t.name),
+  dm_coach: dmCoachTools.map((t) => t.name),
+  launch: launchTools.map((t) => t.name),
+  exploit: exploitTools.map((t) => t.name),
+  mode: modeTools.map((t) => t.name),
+  magnet: magnetTools.map((t) => t.name),
+  funnel: funnelTools.map((t) => t.name),
+  post: postTools.map((t) => t.name),
+  email_sequence: emailSequenceTools.map((t) => t.name),
+  leads: leadsTools.map((t) => t.name),
+  analytics: analyticsTools.map((t) => t.name),
+  meta: metaTools.map((t) => t.name)
+};
+var workflowRecipes = {
+  build_tam: `# Build a TAM List \u2014 Workflow
+
+Start by identifying what kind of companies you're targeting:
+
+## DTC / E-commerce / Consumer Brands
+1. find_companies (provider: storeleads) \u2014 filter by category, revenue, country
+   \u2192 find_companies({ provider: "storeleads", category: "Beauty", min_revenue: 1000000, country: "US" })
+2. find_people \u2014 find decision-makers at those domains
+   \u2192 find_people({ company_domain: "...", job_title: "CEO" })
+3. enrich (dry_run first) \u2014 get verified emails
+   \u2192 enrich({ contacts: [...], find: ["email"], dry_run: true })
+4. Optional: extract \u2014 check if they're active on LinkedIn
+   \u2192 extract({ type: "linkedin_profile", linkedin_url: "..." })
+
+## B2B / SaaS / Services with websites
+1. find_companies \u2014 use DiscoLike ICP text or lookalikes
+   \u2192 find_companies({ icp_text: "...", limit: 100 })
+2. find_people \u2014 find contacts by title
+3. enrich \u2014 get verified emails
+4. campaign \u2014 push to email or LinkedIn campaigns
+
+## LinkedIn-native prospects
+1. find_people \u2014 search by title + company
+2. extract \u2014 scrape profiles for activity signals
+   \u2192 extract({ type: "linkedin_profile", linkedin_url: "..." })
+3. enrich \u2014 get emails for active prospects
+4. campaign \u2014 push to LinkedIn or email campaign
+
+## Engagement-based (warm leads)
+1. extract (linkedin_search) \u2014 find relevant content
+   \u2192 extract({ type: "linkedin_search", query: "...", sort: "date" })
+2. extract (linkedin_engagement) \u2014 extract commenters/reactors
+   \u2192 extract({ type: "linkedin_engagement", post_url: "...", engagement_type: "both" })
+3. enrich \u2014 get emails
+4. campaign \u2014 personalized outreach referencing their engagement
+
+## Review before enriching
+After finding companies, review the list before spending enrichment credits:
+- Use output: 'csv' to write results to a spreadsheet for visual review
+- Or export to Clay/webhook via fetch POST for team review (see export_to_webhook guide)
+- Use ai with action: 'classify' to auto-filter competitors or bad fits
+
+## Key principle
+Always dry_run enrichment first. Credits are spent per successful find \u2014 previewing cost avoids surprises.`,
+  enrich_list: `# Enrich a Contact List \u2014 Workflow
+
+## Steps
+
+1. PREPARE \u2014 Ensure contacts have at minimum first_name + last_name. company or company_domain dramatically improves match rates.
+
+2. DRY RUN \u2014 Preview cost before spending credits
+   \u2192 enrich({ contacts: [...], find: ["email"], dry_run: true })
+
+3. EXECUTE \u2014 Run the waterfall enrichment
+   \u2192 enrich({ contacts: [...], find: ["email"], verify: true })
+
+4. REVIEW \u2014 Check results. The waterfall tries each provider in order and stops on first match.
+
+## Waterfall order
+Default order comes from your config. Override per-call with the waterfall parameter.
+Most providers charge only on successful find \u2014 no result, no charge.`,
+  cold_outreach: `# Cold Email Outreach \u2014 Workflow
+
+## Steps
+
+1. ENRICH \u2014 Get verified emails for your contacts
+   \u2192 enrich({ contacts: [...], find: ["email"], verify: true, dry_run: true })
+   \u2192 enrich({ contacts: [...], find: ["email"], verify: true })
+
+2. PERSONALIZE \u2014 Use AI to write custom openers
+   \u2192 ai({ action: "personalize", data: [...], prompt: "Write a 2-sentence cold email opener referencing their company" })
+
+3. LIST CAMPAIGNS \u2014 Find or identify the target campaign
+   \u2192 campaign({ action: "list" })
+
+4. PUSH \u2014 Add enriched + personalized leads to campaign
+   \u2192 campaign({ action: "add_leads", campaign_id: "...", leads: [...] })
+
+5. SYNC CRM \u2014 Create contacts in CRM for tracking
+   \u2192 crm({ action: "create", data: { first_name: "...", last_name: "...", email: "..." } })
+
+## Key principle
+Always verify emails before pushing to campaigns. Bounced emails hurt sender reputation.`,
+  linkedin_outreach: `# LinkedIn Outreach \u2014 Workflow
+
+## Steps
+
+1. EXTRACT \u2014 Get LinkedIn profile data
+   \u2192 extract({ url: "https://linkedin.com/in/...", type: "linkedin_profile" })
+
+2. PERSONALIZE \u2014 Use AI to write connection request messages
+   \u2192 ai({ action: "personalize", data: [...], prompt: "Write a LinkedIn connection request referencing their recent post" })
+
+3. LIST CAMPAIGNS \u2014 Find or identify the target outreach campaign
+   \u2192 campaign({ action: "list", provider: "heyreach" })
+
+4. PUSH \u2014 Add leads to LinkedIn outreach campaign
+   \u2192 campaign({ action: "add_leads", campaign_id: "...", provider: "heyreach", leads: [{ linkedin_url: "..." }] })
+
+## Key principle
+LinkedIn outreach requires LinkedIn profile URLs \u2014 not emails. Extract profile data first for personalization.`,
+  crm_sync: `# CRM Sync \u2014 Workflow
+
+## Steps
+
+1. CHECK \u2014 See if the person already exists in CRM
+   \u2192 crm({ action: "find", query: { email: "..." } })
+
+2. CREATE or UPDATE
+   \u2192 crm({ action: "create", data: { first_name: "...", last_name: "...", email: "..." } })
+   \u2192 crm({ action: "update", id: "...", data: { job_title: "..." } })
+
+3. DEAL \u2014 Create a deal if this is a qualified prospect
+   \u2192 crm({ action: "create_deal", data: { name: "...", person_id: "...", stage: "New" } })
+
+## Key principle
+Always search before creating to avoid duplicates. Most CRMs have built-in email dedup but better to check first.`,
+  export_to_webhook: `# Export Data to Webhook \u2014 Workflow
+
+Push GTM data to Clay, Make, Zapier, or any webhook endpoint for visual review or further processing.
+
+## Steps
+1. FIND \u2014 Get your companies or contacts
+   \u2192 find_companies({ icp_text: "...", limit: 50 })
+   \u2192 find_people({ company_domain: "...", job_title: "CEO" })
+
+2. EXPORT \u2014 Push to webhook via fetch
+   \u2192 fetch({ url: "https://your-webhook-url", method: "POST", body: { results: [...] } })
+
+## Clay Integration
+Clay table webhooks accept JSON directly:
+\u2192 fetch({ url: "https://api.clay.com/v3/sources/webhook/...", method: "POST", body: { first_name: "...", last_name: "...", company: "...", ... } })
+
+Send one record per request, or batch them depending on the webhook's format.
+
+## Key principle
+Review data visually before spending enrichment credits. Export \u2192 review \u2192 enrich only the good leads.`,
+  engagement_cold_email: `# Engagement Cold Email \u2014 Workflow
+
+Monitor LinkedIn post engagement and auto-send personalized cold emails to engagers.
+Works with YOUR posts and ANY external post (competitors, influencers).
+
+## Steps
+
+1. CREATE CAMPAIGN \u2014 Create a PlusVibe campaign with engagement-based templates
+   \u2192 campaign({ action: "create", name: "Engagement Cold Email", provider: "plusvibe" })
+
+2. ENABLE MONITORING \u2014 Turn on engagement scraping + set PlusVibe campaign for auto-push
+   Works with any LinkedIn post URL \u2014 your own or external:
+   \u2192 campaign({ action: "monitor", post_url: "https://linkedin.com/feed/update/...", enabled: true, plusvibe_campaign_id: "camp_xxx" })
+
+   For external posts, add context for personalization:
+   \u2192 campaign({ action: "monitor", post_url: "...", enabled: true, plusvibe_campaign_id: "camp_xxx", post_topic: "AI agents", creator_name: "Alex Hormozi" })
+
+3. CHECK STATUS \u2014 Verify scraping is active (shows both own and external posts)
+   \u2192 campaign({ action: "engagement_status" })
+
+4. (AUTOMATIC) The scrape cron runs every 10 minutes:
+   - Scrapes commenters + reactors via Harvest API
+   - Triggers enrichment for each engager:
+     \u2022 Harvest profile lookup (company, headline)
+     \u2022 Email waterfall (LeadMagic \u2192 Prospeo \u2192 Blitz \u2192 ZeroBounce)
+     \u2022 Phone number lookup (Blitz API)
+   - Pushes enriched leads to PlusVibe campaign with engagement context variables
+
+5. VIEW ENGAGERS \u2014 Check who has been captured and their push status
+   \u2192 campaign({ action: "engagers", post_url: "...", filter: "pushed" })
+
+6. MONITOR PERFORMANCE \u2014 Check email campaign stats
+   \u2192 campaign({ action: "stats", campaign_id: "camp_xxx", provider: "plusvibe" })
+
+## Manual push (alternative to auto-push)
+If you didn't set a PlusVibe campaign on the post, manually push unpushed engagers:
+   \u2192 campaign({ action: "push", post_url: "...", campaign_id: "camp_xxx", limit: 20 })
+
+## One-shot workflow (no auto-monitoring)
+Use existing tools for a single extraction + push:
+1. extract({ type: "linkedin_engagement", post_url: "...", engagement_type: "both" })
+2. enrich({ contacts: [...], find: ["email", "phone"], verify: true })
+3. campaign({ action: "add_leads", campaign_id: "...", leads: [...] })
+
+## Email template variables
+When using PlusVibe with engagement context, these variables are available:
+{{first_name}}, {{last_name}}, {{company_name}}, {{linkedin_url}}, {{phone}},
+{{post_topic}}, {{engagement_type}}, {{comment_text}}, {{total_engagement}}, {{opt_in_url}}
+
+## Key principle
+Always create the PlusVibe campaign and configure templates BEFORE enabling monitoring.
+The auto-push starts immediately once scraping is enabled.`,
+  create_magnet: `# Create a Lead Magnet Funnel \u2014 Workflow
+
+## Quick path (all-in-one)
+magnet({ action: "launch", title: "...", archetype: "single-breakdown", content: {...} })
+\u2192 Creates magnet + funnel + email sequence + publishes in one call
+
+## Step-by-step (more control)
+1. magnet({ action: "create", title: "...", archetype: "single-breakdown" })
+2. magnet({ action: "update", id: "...", content: { sections: [...] } })
+3. funnel({ action: "create", lead_magnet_id: "..." })
+4. funnel({ action: "publish", id: "..." })
+5. magnet({ action: "save_sequence", id: "...", emails: [
+     { day: 0, subject: "Welcome!", body: "..." },
+     { day: 2, subject: "Next step", body: "..." }
+   ]})
+6. magnet({ action: "activate_sequence", id: "..." })
+
+## Check results
+leads({ action: "list", lead_magnet_id: "..." })
+analytics({ action: "insights" })
+
+## Archetypes
+single-breakdown, single-system, focused-toolkit, single-calculator,
+focused-directory, mini-training, one-story, prompt, assessment, workflow
+\u2192 Call tool_help({ tool: "magnet" }) for details on each archetype`,
+  content_pipeline: `# Content Creation Pipeline \u2014 Workflow
+
+## 1. Find content ingredients
+knowledge({ action: "search", query: "..." })  \u2014 find relevant knowledge
+post({ action: "formats" })  \u2014 browse proven post structures
+post({ action: "trends" })  \u2014 see what's hot
+post({ action: "recipes" })  \u2014 get AI-suggested combos
+
+## 2. Generate posts
+post({ action: "generate", knowledge_topic: "...", exploit_id: "...", instructions: "..." })
+\u2192 Requires at least one of: exploit_id, knowledge_topic, knowledge_query, trend_topic, instructions
+
+## 3. Review + edit
+post({ action: "list", status: "draft" })
+post({ action: "update", id: "...", body: "edited text..." })
+
+## 4. Publish
+post({ action: "list_accounts" })  \u2014 get LinkedIn account ID
+post({ action: "publish_linkedin", id: "...", account_id: "..." })  \u2014 post now
+post({ action: "publish", id: "..." })  \u2014 or add to scheduled queue
+
+## Batch scheduling
+magnet({ action: "schedule_week", posts: [{ body: "..." }, { body: "..." }] })`,
+  dm_coaching: `# DM Coaching with Kondo \u2014 Workflow
+
+AI-coached LinkedIn DM replies. Uses Kondo MCP for conversation access + our coaching methodology for style-matched, goal-adaptive replies.
+
+## Kondo Workflow
+
+1. MAP LABELS \u2014 kondo: list_inboxes() \u2014 get label name \u2192 UUID mapping. Identify which labels represent pipeline stages (opening, qualifying, meeting, follow-up, disqualified). People organize labels differently.
+2. READ INBOX \u2014 kondo: list_inbox({ view: "NEEDS_MY_REPLY" })
+3. FILTER \u2014 Only coach chats whose labelKeys contain a pipeline/sales label. Skip unlabeled noise (~60% is vendor pitches).
+4. LOAD FULL HISTORY \u2014 kondo: load_chat({ profileUrn, threadKey }) THEN read_chat(). CRITICAL: read_chat alone only returns cached messages (1-2 msgs). You must load_chat first for the full thread.
+5. GET CONTEXT (optional) \u2014 kondo: list_connections({ query: "name" }) for headline. Unreliable (~40% hit rate) \u2014 coach works without it.
+6. COACH \u2014 Diagnose what went well/wrong earlier in the thread, then apply methodology below to generate a style-matched reply.
+7. PUSH DRAFT \u2014 kondo: set_chat_draft({ profileUrn, threadKey, text: "coached reply" })
+8. UPDATE LABEL \u2014 kondo: set_chat_label({ chats: [...], labelKeys: ["uuid"], action: "replace" }) if stage advanced.
+9. SNOOZE (optional) \u2014 kondo: set_chat_reminder({ chats: [...], dueAt: epoch_ms }) for nurture conversations (4-6 weeks out).
+
+## Cardinal Rule: Style Matching
+
+Before writing ANY response, analyze their exact style (capitalization, punctuation, length, formality, grammar). Your response should look like THEY could have written it. This overrides all other guidance.
+
+## Framework: Acknowledge \u2192 Value \u2192 Question
+
+1. Acknowledge & Listen \u2014 show you read their message
+2. Add Value \u2014 share a relevant insight
+3. Ask One Clear Question \u2014 guide conversation forward
+
+Key rules: never pitch directly, one question at a time, make it personal not automated, follow up with purpose not pressure.
+
+## Qualification Ladder (ask in sequence, don't skip)
+
+- **Situation**: "What's your current approach to [challenge]?" (role, tools, team)
+- **Pain**: "What's the biggest friction point?" (bottlenecks, manual work)
+- **Impact**: "How's that affecting [bigger goal]?" (revenue, growth)
+- **Vision**: "What would 'solved' look like?" (ideal state, timeline)
+- **Capability**: "Is this something you're actively working on?" (resources, priority)
+- **Commitment**: "Would it be worth 20 minutes to explore?" (timeline, next steps)
+
+## Goal-Specific Coaching
+
+- **Book Meeting** (default): Focus Pain \u2192 Impact \u2192 Capability. Never suggest call before confirming real problem. Frame as "15 min to map out how to fix [pain]."
+- **Build Relationship**: No sales framing. Share value freely. Stay in Situation/Pain/Vision. Win = strong connection.
+- **Promote Content**: One share max. Only after establishing what they care about. "Thought you might find this useful."
+- **Explore Partnership**: Mutual benefit framing. Be willing to say "not a fit." Ask: "explore this further together?"
+- **Nurture Lead**: Half speed. Patience is the strategy. Advance only when THEY signal readiness. Timeline: weeks to months.
+- **Close Deal**: Remove final objections. Direct asks. Proof points matching their situation. Specific commitment + deadline.
+
+## Objection Handling
+
+Acknowledge without "but" \u2192 ask for context \u2192 provide proof \u2192 suggest easy next step.
+- "Not the right time" \u2192 "What would need to change for timing to work?"
+- "Need to think about it" \u2192 "What's the main thing you're weighing?"
+- "Too expensive" \u2192 "What were you expecting it to cost?"
+- "Send me info" \u2192 "What specifically would be most useful?"
+
+## Negative Signals (flag for removal, don't coach)
+
+"not interested", "please remove", "stop messaging", "too small", "just starting out", "not the right fit"
+
+## Kondo Label \u2192 Qualification Stage
+
+Map the user's Kondo labels to stages by intent (not exact name): opening/new \u2192 situation, qualifying/discovery \u2192 pain, meeting/demo \u2192 capability, booked/confirmed \u2192 commitment, follow-up/nurture \u2192 commitment, disqualified/dead \u2192 skip
+
+## Coaching Output
+
+When coaching a reply, provide: (1) Thread diagnosis \u2014 what went well/wrong earlier (e.g. jumped stages, pitched before establishing Impact). This is where users LEARN. (2) Style analysis, (3) Stage current \u2192 target, (4) Signals detected, (5) Coached reply (style-matched, AVQ framework), (6) Reasoning (why this approach, what to watch for).
+
+Full detailed methodology with examples: see skills/dm-coaching.md`,
+  qualify_inbox: `# Qualify LinkedIn Inbox with Kondo + Maestro
+
+Score conversations, invites, and connections against your Maestro personas. Tag qualified contacts fast.
+
+## Inbox Qualification (start here)
+
+1. LOAD PERSONA \u2014 intel({ action: "get_persona" }) \u2192 get ICP criteria (title patterns, industries, pain points, buying signals)
+2. MAP LABELS \u2014 kondo: list_inboxes() \u2192 discover the user's labels and identify which represent pipeline stages
+3. READ INBOX \u2014 kondo: list_inbox({ view: "NEEDS_MY_REPLY", limit: 20 })
+4. LOAD + READ \u2014 For each: kondo: load_chat() then read_chat() (load_chat first or you get 1-2 cached messages)
+5. QUALIFY \u2014 For each conversation evaluate:
+   - Profile fit: parse headline for title/company/industry \u2192 match against persona
+   - Conversation signals: scan messages for buying signals, pain points, urgency
+   - Engagement quality: are they asking questions? sharing context? or one-word replies?
+6. SCORE \u2014 intel({ action: "score", headline: "...", company_name: "...", industry: "..." })
+7. TAG \u2014 kondo: set_chat_label \u2192 apply the user's own pipeline labels (discovered in step 2). If none exist, ask or create them.
+8. PRESENT \u2014 Ranked list: Name | Headline | Score | Signals | Action
+
+Conversation signals beat profile signals. A slightly off-title contact describing their pain > perfect title with one-word replies.
+
+## Invite Triage
+
+1. intel({ action: "get_persona" }) \u2192 ICP criteria
+2. kondo: list_invites({ limit: 20 }) \u2192 pending requests (name, headline, mutual count)
+3. Parse headline \u2192 match against persona title patterns + industries
+4. kondo: set_invite_response \u2192 accept qualified, ignore spam
+Auto-accept: title + industry match AND mutuals > 5. Auto-ignore: crypto, "guaranteed leads", emoji-heavy.
+
+## Connection Mining
+
+1. intel({ action: "get_persona" }) \u2192 get title patterns
+2. kondo: list_connections({ query: "founder" }) \u2192 search by persona keywords (single words work best, multi-word returns 0)
+3. Parse headline \u2192 score against persona
+4. Check threadKeys \u2014 has chat = re-engage candidate, no chat = cold DM candidate
+5. kondo: set_connection_label \u2192 tag qualified connections
+
+## After Qualifying
+
+Run guide({ task: "dm_coaching" }) for the coaching methodology. Start with highest-scored conversations. The qualification signals become coaching context.
+
+Full workflow details with gotchas: see skills/qualify-inbox.md`,
+  list_tasks: `# Available GTM Workflows
+
+Call guide with one of these tasks:
+
+## Prospecting & Outreach
+- build_tam \u2014 Build a TAM list (DTC/e-commerce, B2B, LinkedIn-native, or engagement-based paths)
+- enrich_list \u2014 Take a contact list and enrich with email/phone via waterfall
+- cold_outreach \u2014 Enrich + personalize + push to cold email campaign
+- linkedin_outreach \u2014 Extract profiles + personalize + push to LinkedIn campaign
+- engagement_cold_email \u2014 Monitor LinkedIn post engagement + auto-send cold emails
+
+## Content & Product
+- create_magnet \u2014 Build a lead magnet funnel (magnet \u2192 funnel \u2192 email sequence \u2192 publish)
+- content_pipeline \u2014 Create LinkedIn posts (knowledge \u2192 generate \u2192 publish)
+
+## DM Management
+- qualify_inbox \u2014 Qualify LinkedIn conversations, invites, and connections against Maestro personas
+- dm_coaching \u2014 Coach LinkedIn DM replies with Kondo (style matching, qualification ladder, goal-adaptive coaching)
+
+## Operations
+- crm_sync \u2014 Find/create/update people and deals in CRM
+- export_to_webhook \u2014 Push data to Clay, Make, Zapier, or any webhook for review
+
+For any task: always dry_run enrichment batches > 5 to preview cost before executing.`
+};
+
+export {
+  prospectTools,
+  enrichTools,
+  extractTools,
+  fetchTools,
+  aiTools,
+  campaignTools,
+  crmTools,
+  statusTools,
+  configureTools,
+  reviewTools,
+  batchTools,
+  recipeTools,
+  provisionTools,
+  listTools,
+  maestroTools,
+  engagementTools,
+  dfyTools,
+  tamTools,
+  knowledgeTools,
+  mixerTools,
+  dmCoachTools,
+  launchTools,
+  exploitTools,
+  modeTools,
+  magnetTools,
+  funnelTools,
+  postTools,
+  emailSequenceTools,
+  leadsTools,
+  analyticsTools,
+  TOOL_DESCRIPTIONS,
+  buildCatalogText,
+  tools,
+  mcpTools,
+  toolsByName,
+  toolCategories,
+  workflowRecipes
+};
+//# sourceMappingURL=chunk-M25KLO7T.js.map