@signaliz/sdk 1.0.5 → 1.0.7

package/dist/{chunk-GF2T2X3W.mjs → chunk-BHL5NHVO.mjs}

@@ -751,7 +751,7 @@ var Campaigns = class {
   async build(request, options) {
     return this.buildCampaign(request, options);
   }
-  /** Scope an agency/client campaign into a markdown brief plus build_campaign dry-run args. */
+  /** Scope an agency/customer campaign into a markdown brief plus build_campaign dry-run args. */
   async scope(request) {
     return this.scopeCampaign(request);
   }
@@ -933,7 +933,11 @@ function mapStatus(data) {
     errors: diagnosticMessages(data.errors),
     artifactCount: data.artifact_count ?? 0,
     providerRoute: mapProviderRoute(data),
-    nextAction: data.next_action ?? "",
+    triggerRunId: typeof data.trigger_run_id === "string" ? data.trigger_run_id : null,
+    staleRunningPhase: data.stale_running_phase === true,
+    phaseAgeSeconds: numberOrNull(data.phase_age_seconds),
+    diagnostics: recordOrNull(data.diagnostics) ?? {},
+    nextAction: formatNextAction(data.next_action),
     createdAt: data.created_at,
     updatedAt: data.updated_at,
     completedAt: data.completed_at
@@ -973,6 +977,19 @@ function diagnosticMessages(value) {
     return typeof record?.message === "string" ? record.message : null;
   }).filter((item) => typeof item === "string" && item.length > 0);
 }
+function formatNextAction(value) {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  const record = recordOrNull(value);
+  if (!record) return "";
+  const tool = typeof record.tool === "string" ? record.tool : void 0;
+  const type = typeof record.type === "string" ? record.type : void 0;
+  const reason = typeof record.reason === "string" ? record.reason : void 0;
+  const args = recordOrNull(record.arguments);
+  const argText = args && Object.keys(args).length > 0 ? ` ${JSON.stringify(args)}` : "";
+  const action = tool ? `${tool}${argText}` : type || "";
+  return [action, reason].filter(Boolean).join(" \u2014 ");
+}
 function booleanOrNull(value) {
   return typeof value === "boolean" ? value : null;
 }
@@ -1013,7 +1030,7 @@ function mapArtifact(a) {
 function mapScope(data) {
   return {
     campaignScopeId: data.campaign_scope_id,
-    clientName: data.client_name,
+    accountLabel: data.account_label,
     campaignName: data.campaign_name,
     approach: data.approach,
     approachLabel: data.approach_label,
@@ -1039,8 +1056,8 @@ function scopeArgs(request) {
   const args = {
     prompt: request.prompt
   };
-  if (request.clientName) args.client_name = request.clientName;
-  if (request.clientContext) args.client_context = request.clientContext;
+  if (request.accountLabel) args.account_label = request.accountLabel;
+  if (request.accountContext) args.account_context = request.accountContext;
   if (request.campaignGoal) args.campaign_goal = request.campaignGoal;
   if (request.targetCount) args.target_count = request.targetCount;
   if (request.destinations) args.destinations = request.destinations;
@@ -1168,22 +1185,565 @@ var DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS = {
     approvalRequired: true
   }
 };
+var DEFAULT_CAMPAIGN_BUILDER_BUILT_INS = [
+  "lead_generation",
+  "email_finding",
+  "email_verification",
+  "signals"
+];
+var DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES = [
+  "memory_retrieval",
+  "spend",
+  "customer_tool",
+  "external_write",
+  "delivery",
+  "launch"
+];
+var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
+  {
+    slug: "cache-first-large-list",
+    label: "Cache-First Large List",
+    whenToUse: [
+      "The target count is high and reusable workspace lead or cache coverage may exist.",
+      "The deliverable is a verified list or top-up rather than a deeply custom one-off workflow."
+    ],
+    sequence: [
+      "Inventory reusable cache before paid sourcing.",
+      "Report unique emails, role buckets, exclusions, and missing-field counts.",
+      "Use fresh sourcing only for the approved gap.",
+      "Write newly approved source metadata back to memory or cache after review."
+    ],
+    requiredFields: {
+      inventory: ["matching_cached_rows", "unique_cached_emails", "persona_bucket_counts", "exclusions_applied", "missing_field_counts"],
+      finalRows: ["first_name", "last_name", "company_name", "company_domain", "work_email", "email_status", "source_type"]
+    },
+    qualityGates: [
+      "Deduplicate by normalized email before counting final rows.",
+      "Separate cache reuse from fresh sourcing in the build receipt.",
+      "Block export when required identity, company, or email fields are missing."
+    ],
+    activationBoundary: "Cache inventory is read-only. Fresh sourcing, cache writes, export, and sender loading require explicit approval.",
+    memoryKeywords: ["cache inventory", "large list", "unique emails", "top-up sourcing", "source metadata"]
+  },
+  {
+    slug: "net-new-suppressed-list",
+    label: "Net-New Suppressed List",
+    whenToUse: [
+      "A prior campaign, seed list, or exclusion list must be suppressed.",
+      "The operator needs both outreach-facing rows and provenance-rich QA evidence."
+    ],
+    sequence: [
+      "Load suppression baselines before source selection.",
+      "Apply email suppression as a hard gate and domain suppression as required by the brief.",
+      "Keep provenance, source, and validation fields outside the outreach-facing export when needed.",
+      "Run final overlap checks before any delivery action."
+    ],
+    requiredFields: {
+      suppression: ["suppression_source", "prior_email_overlap", "prior_domain_match", "suppression_decision"],
+      finalRows: ["first_name", "last_name", "company_name", "company_domain", "work_email", "email_status", "provenance_id"]
+    },
+    qualityGates: [
+      "Prior email overlap must be zero for rows marked export ready.",
+      "Prior-domain matches must be flagged or blocked according to the approved campaign promise.",
+      "Do not describe rows as fully qualified when the approved path only proves net-new email status."
+    ],
+    activationBoundary: "Suppression review must pass before export, upload, CRM sync, sender load, or sequence launch.",
+    memoryKeywords: ["suppression", "net-new", "prior email overlap", "domain review", "provenance-rich QA"]
+  },
+  {
+    slug: "proof-first-vertical-gate",
+    label: "Proof-First Vertical Gate",
+    whenToUse: [
+      "Wrong-account risk is high or the target category has close lookalike exclusions.",
+      "Account proof is more important than raw lead volume."
+    ],
+    sequence: [
+      "Define positive and negative proof fields before sourcing at scale.",
+      "Qualify companies before contact discovery.",
+      "Qualify contacts before email finding.",
+      "Keep pass, review, and fail rows distinct through delivery review."
+    ],
+    requiredFields: {
+      account: ["company_name", "company_domain", "source_url", "positive_proof", "negative_proof", "fit_score", "account_qualified"],
+      contact: ["person_name", "person_title", "persona_match", "contact_fit_score", "contact_qualified"]
+    },
+    qualityGates: [
+      "Do not spend on contact or email enrichment until the account passes the proof gate.",
+      "Adjacent excluded categories must stay exclusions, not synonyms.",
+      "Contact fit should meet the configured threshold before email finding or copy generation."
+    ],
+    activationBoundary: "Proof gates are required before contact spend, copy, export, or external writes.",
+    memoryKeywords: ["proof gate", "vertical exclusion", "company before contact", "pass review fail", "fit threshold"]
+  },
+  {
+    slug: "signal-led-copy-approval",
+    label: "Signal-Led Copy With Approval",
+    whenToUse: [
+      "Outbound copy should be grounded in company signals, proof fields, or row context.",
+      "Delivery destinations must remain locked after copy generation until review."
+    ],
+    sequence: [
+      "Validate list quality before copy.",
+      "Attach the strongest supported signal and source evidence.",
+      "Generate copy only for fit-qualified and contactable rows.",
+      "Hold every destination behind explicit approval."
+    ],
+    requiredFields: {
+      evidence: ["strongest_signal", "signal_source_url", "why_now", "personalization_basis"],
+      copy: ["subject_line", "opening_line", "email_copy", "copy_ready", "copy_blocker"]
+    },
+    qualityGates: [
+      "Copy cannot invent unsupported pain, claims, numbers, or recent events.",
+      "Weak evidence should route the row to review instead of send-ready copy.",
+      "Destination fields must remain blocked until approval metadata is present."
+    ],
+    activationBoundary: "Copy readiness is not delivery approval. Export, sync, sender load, and launch require a separate human-approved gate.",
+    memoryKeywords: ["company signals", "evidence-fed copy", "why now", "copy blocker", "approval gate"]
+  },
+  {
+    slug: "domain-first-recovery",
+    label: "Domain-First Recovery",
+    whenToUse: [
+      "Strict yield is low and broad people sourcing creates noisy, duplicated, or off-fit rows.",
+      "The account universe should be recovered or expanded before more contact spend."
+    ],
+    sequence: [
+      "Model attrition after an initial sample.",
+      "Source or recover account domains in tight slices.",
+      "Filter domains locally before contact discovery.",
+      "Use accepted domains as the seed for person and email work."
+    ],
+    requiredFields: {
+      domainReview: ["company_domain", "source_slice", "domain_fit_score", "domain_rejection_reason", "accepted_domain"],
+      recovery: ["target_gap", "expected_yield", "accepted_domain_count", "contact_pull_limit"]
+    },
+    qualityGates: [
+      "Do not repeat broad people-with-email sourcing after strict yield proves low.",
+      "Rejected domains should stay suppressed unless the operator changes the ICP.",
+      "Target count means final held rows, not raw sourced rows."
+    ],
+    activationBoundary: "Domain recovery informs sourcing. Contact enrichment, paid qualification, and export still require approved gates.",
+    memoryKeywords: ["domain-first", "yield modeling", "attrition", "accepted domains", "gap fill"]
+  },
+  {
+    slug: "table-workflow-handoff",
+    label: "Table Workflow Handoff",
+    whenToUse: [
+      "The campaign needs connected source, account, people, enrichment, copy, and destination tables.",
+      "A workspace or partner tool owns part of the workflow through MCP, webhook, API, or managed integration."
+    ],
+    sequence: [
+      "Create source/account context before child people rows.",
+      "Carry source context into enrichment, copy, and destination mapping.",
+      "Expose request-ready, result, error, blocker, and export-ready fields for every action.",
+      "Dry-run provider routes and destination writes before activation."
+    ],
+    requiredFields: {
+      workflow: ["source_record_id", "company_context", "request_ready", "provider_status", "error", "export_ready", "export_blocker"],
+      destination: ["destination_type", "destination_status", "approval_status", "approved_by", "approved_at"]
+    },
+    qualityGates: [
+      "Every paid/API action needs visible request readiness and parsed output fields.",
+      "Child people rows must preserve the account context that justified the search.",
+      "Provider route activation must dry-run before any external write."
+    ],
+    activationBoundary: "MCP, webhook, managed integration, and destination routes remain dry-run until the reviewed route and campaign are approved.",
+    memoryKeywords: ["table workflow", "request ready", "provider status", "export blocker", "BYO integration"]
+  }
+];
+var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
+  {
+    slug: "industrial-ot-resilience",
+    label: "Industrial OT Resilience",
+    aliases: ["industrial ot", "ot resilience", "industrial continuity", "industrial-ot-resilience"],
+    defaultTargetCount: 3e3,
+    campaignName: "Industrial OT Resilience Net-New",
+    accountContext: [
+      "Strategy template: Signaliz-only OT, industrial, manufacturing, embedded systems, field service, cyber resilience, and business continuity sourcing.",
+      "Use prior approved campaign output as the email suppression baseline; final files must have zero prior-used email overlap.",
+      "Keep external qualification providers disabled unless the operator explicitly changes the requirement."
+    ].join(" "),
+    icp: {
+      personas: [
+        "OT leader",
+        "Industrial automation leader",
+        "Engineering leader",
+        "IT infrastructure leader",
+        "Reliability or maintenance leader",
+        "Operations leader"
+      ],
+      industries: [
+        "Machinery",
+        "Electrical and electronic manufacturing",
+        "Mechanical or industrial engineering",
+        "Industrial automation",
+        "Semiconductors",
+        "Medical devices",
+        "Oil and energy",
+        "Automotive"
+      ],
+      geographies: ["United States", "United Kingdom", "Canada", "Nordics", "Netherlands"],
+      keywords: [
+        "OT",
+        "ICS",
+        "SCADA",
+        "control systems",
+        "industrial automation",
+        "manufacturing",
+        "plant operations",
+        "reliability",
+        "maintenance",
+        "PLC",
+        "business continuity"
+      ],
+      exclusions: [
+        "sales",
+        "marketing",
+        "recruiting",
+        "HR",
+        "finance",
+        "legal",
+        "customer success",
+        "retail",
+        "restaurants",
+        "staffing",
+        "real estate"
+      ],
+      requireVerifiedEmail: true
+    },
+    builtIns: ["lead_generation", "email_finding", "email_verification", "signals"],
+    preferredProviders: ["signaliz_native"],
+    memoryQueries: [{
+      query: "industrial OT net-new prior email suppression verified manufacturing embedded systems field service cyber resilience business continuity",
+      scopes: ["workspace", "operator_notes"],
+      topK: 10,
+      required: true,
+      rationale: "Load OT sourcing, dedupe, cache metadata, and approval gates before planning net-new work."
+    }],
+    constraints: {
+      deliverabilityNotes: [
+        "Require verified email, valid syntax, first name, last name, company name, and normalized company domain.",
+        "Keep export, upload, sync, send, and replacement actions blocked until explicit approval.",
+        "Treat prior-domain matches as flagged review evidence unless strict domain suppression is explicitly requested."
+      ]
+    },
+    signalizDefaults: {
+      copy: {
+        offerContext: "Do not invent product claims. Anchor messaging only in row-supported OT, industrial, cyber resilience, backup/recovery, or business-continuity context."
+      }
+    },
+    agencyContext: {
+      partnerEcosystem: ["signaliz", "instantly", "nango"]
+    },
+    operatingPlaybookSlugs: ["net-new-suppressed-list", "proof-first-vertical-gate", "signal-led-copy-approval"]
+  },
+  {
+    slug: "non-medical-home-care",
+    label: "Non-Medical Home Care Operations",
+    aliases: ["home care", "non-medical home care", "home-care-operations", "non-medical-home-care"],
+    defaultTargetCount: 3e3,
+    campaignName: "Mature Home Care Agency Operators",
+    accountContext: [
+      "Strategy template: mature US non-medical home care agencies with scale signals, proof fields, strict home-care vs home-health separation, and approval-gated export.",
+      "Use proof before paid enrichment or copy. Preserve pass vs review ICP status because healthcare language often blurs home care and home health."
+    ].join(" "),
+    icp: {
+      personas: [
+        "Owner",
+        "CEO",
+        "COO",
+        "Administrator",
+        "Operations Director",
+        "Scheduler",
+        "Care coordinator leader"
+      ],
+      industries: ["Non-medical home care", "Senior care", "Private duty care", "Home services"],
+      companySizes: ["20+ employees", "600+ billable care hours/week", "1000+ billable care hours/week ideal"],
+      geographies: ["United States"],
+      keywords: [
+        "non-medical home care",
+        "private duty",
+        "caregiver recruiting",
+        "multi-location",
+        "franchise",
+        "scheduler",
+        "billing",
+        "payroll",
+        "EVV",
+        "WellSky",
+        "AxisCare",
+        "CareSmartz360"
+      ],
+      exclusions: [
+        "home health",
+        "skilled nursing",
+        "hospice",
+        "hospital",
+        "clinic",
+        "therapy practice",
+        "very small owner-only shop"
+      ],
+      requireVerifiedEmail: true
+    },
+    builtIns: ["lead_generation", "local_leads", "email_finding", "email_verification", "signals"],
+    preferredProviders: ["signaliz_native", "octave", "clay_webhook", "apify"],
+    memoryQueries: [{
+      query: "mature non-medical home care agencies billable hours franchise caregiver recruiting proof gate qualification export approval",
+      scopes: ["workspace", "operator_notes"],
+      topK: 10,
+      required: true,
+      rationale: "Load home-care ICP gates, source lanes, qualification thresholds, and home-care exclusion logic."
+    }],
+    constraints: {
+      deliverabilityNotes: [
+        "Company proof and strict ICP gate must pass before contact search, email finding, Signaliz signals, or export.",
+        "Home health is an exclusion signal, not a synonym for home care."
+      ]
+    },
+    signalizDefaults: {
+      copy: {
+        offerContext: "Use angles around after-hours shift recovery, billing/payroll exceptions, multi-location consistency, and caregiver retention only when supported by evidence."
+      }
+    },
+    agencyContext: {
+      partnerEcosystem: ["clay", "octave", "signaliz", "instantly", "nango"]
+    },
+    operatingPlaybookSlugs: ["proof-first-vertical-gate", "domain-first-recovery", "table-workflow-handoff"]
+  },
+  {
+    slug: "agency-founder-led",
+    label: "Founder-Led Agency Services",
+    aliases: ["agency founder", "founder-led agency", "agency-founder-led"],
+    defaultTargetCount: 3e3,
+    campaignName: "Founder-Led Agency Executive Campaign",
+    accountContext: [
+      "Strategy template: agency founder, owner, CEO, and executive sourcing across marketing services, creative, web, PR, ecommerce, paid media, SEO, content, and specialist digital agencies.",
+      "Use suppression files, company-domain pool review, people/email verification queues, and final approval gates before any delivery action."
+    ].join(" "),
+    icp: {
+      personas: ["Founder", "Owner", "CEO", "Managing Partner", "President", "Agency Executive"],
+      industries: [
+        "Marketing services",
+        "Advertising services",
+        "Digital marketing agency",
+        "Creative agency",
+        "PR and communications",
+        "Ecommerce agency",
+        "Paid media agency",
+        "SEO agency",
+        "Content agency"
+      ],
+      companySizes: ["11-50", "25-150", "51-200"],
+      geographies: ["United States"],
+      keywords: [
+        "agency founder",
+        "performance marketing",
+        "paid media",
+        "SEO",
+        "content",
+        "creative",
+        "web design",
+        "brand agency",
+        "PR communications",
+        "Shopify",
+        "Klaviyo"
+      ],
+      exclusions: ["enterprise holding company", "staffing", "recruiting", "software-only vendor", "freelancer-only profile"],
+      requireVerifiedEmail: true
+    },
+    builtIns: ["lead_generation", "email_finding", "email_verification", "signals"],
+    preferredProviders: ["signaliz_native", "octave"],
+    memoryQueries: [{
+      query: "agency founder owner CEO marketing services suppression domain pool email verification final approval gate",
+      scopes: ["workspace", "operator_notes"],
+      topK: 10,
+      required: true,
+      rationale: "Load agency-segment sourcing lanes, suppression rules, and verification workflow lessons."
+    }],
+    constraints: {
+      deliverabilityNotes: [
+        "Keep email and domain suppression visible in the plan.",
+        "Do not export or send until the final verified file and suppression checks are approved."
+      ]
+    },
+    agencyContext: {
+      partnerEcosystem: ["signaliz", "octave", "instantly", "nango"]
+    },
+    operatingPlaybookSlugs: ["net-new-suppressed-list", "signal-led-copy-approval", "table-workflow-handoff"]
+  },
+  {
+    slug: "cloud-infrastructure-displacement",
+    label: "Cloud Infrastructure Displacement",
+    aliases: ["cloud displacement", "private cloud displacement", "cloud infrastructure", "cloud-infrastructure-displacement"],
+    defaultTargetCount: 3e3,
+    campaignName: "Cloud Infrastructure Displacement Campaign",
+    accountContext: [
+      "Strategy template: managed infrastructure, private cloud, disaster recovery, colocation, and VMware/Broadcom displacement motions.",
+      "The spend-efficient ladder is Signaliz company search, Octave company qualification, Signaliz people search, Octave person qualification, then Signaliz email finding and verification."
+    ].join(" "),
+    icp: {
+      personas: [
+        "CTO",
+        "CIO",
+        "CISO",
+        "CFO tied to cloud spend",
+        "VP Engineering",
+        "VP Infrastructure",
+        "VP Cloud",
+        "Head of Platform",
+        "Director IT",
+        "Cloud Architect",
+        "Infrastructure Architect"
+      ],
+      industries: [
+        "SaaS",
+        "Software",
+        "Cybersecurity",
+        "Fintech",
+        "Healthcare technology",
+        "Compliance and GRC",
+        "DevOps",
+        "Infrastructure",
+        "Observability"
+      ],
+      companySizes: ["$10M-$500M revenue", "50-1500 employees"],
+      geographies: ["United States"],
+      keywords: [
+        "VMware Broadcom",
+        "VxRail",
+        "cloud cost pressure",
+        "private cloud",
+        "Proxmox",
+        "Hyper-V",
+        "managed infrastructure",
+        "DRaaS",
+        "colocation",
+        "uptime",
+        "reliability"
+      ],
+      exclusions: [
+        "MSP competitor",
+        "hosting provider",
+        "data center competitor",
+        "staffing",
+        "recruiting",
+        "international-only",
+        "procurement-only",
+        "AI GPU-heavy infrastructure"
+      ],
+      requireVerifiedEmail: true
+    },
+    builtIns: ["lead_generation", "email_finding", "email_verification", "signals"],
+    preferredProviders: ["signaliz_native", "octave"],
+    memoryQueries: [{
+      query: "cloud hosting infrastructure VMware Broadcom qualification verified email persona trigger SKU mapping",
+      scopes: ["workspace", "operator_notes"],
+      topK: 10,
+      required: true,
+      rationale: "Load cloud-infrastructure qualification order, persona clusters, trigger/SKU mapping, and verified-list QA rules."
+    }],
+    constraints: {
+      deliverabilityNotes: [
+        "Qualify accounts and people before email verification.",
+        "If signal enrichment is deferred or unavailable, state it plainly instead of inventing evidence."
+      ]
+    },
+    signalizDefaults: {
+      copy: {
+        offerContext: "Map pain to routes such as VMware/Broadcom exit, cloud cost reduction, infrastructure modernization, compliance gap, managed infrastructure, private cloud, Proxmox/Hyper-V, colocation, or DRaaS."
+      }
+    },
+    agencyContext: {
+      partnerEcosystem: ["signaliz", "octave", "instantly", "nango"]
+    },
+    operatingPlaybookSlugs: ["proof-first-vertical-gate", "domain-first-recovery", "signal-led-copy-approval"]
+  }
+];
 var CampaignBuilderAgent = class {
   constructor(client) {
     this.client = client;
   }
   async createPlan(request, options = {}) {
+    const resolvedRequest = applyCampaignBuilderStrategyTemplate(request);
     const warnings = [];
-    const workspaceContext = request.workspaceContext ?? await this.getWorkspaceContext(warnings);
-    const scopeResult = options.scopeCampaign === false ? void 0 : await this.scopeCampaign(request, warnings);
+    const workspaceContext = resolvedRequest.workspaceContext ?? await this.getWorkspaceContext(warnings);
+    const scopeResult = options.scopeCampaign === false ? void 0 : await this.scopeCampaign(resolvedRequest, warnings);
     if (options.discoverCapabilities !== false) {
-      await this.discoverPlannedRoutes(request, warnings);
+      await this.discoverPlannedRoutes(resolvedRequest, warnings);
     }
-    return createCampaignBuilderAgentPlan(request, {
+    const plan = createCampaignBuilderAgentPlan(resolvedRequest, {
       workspaceContext,
       scopeBuildArgs: asRecord(scopeResult?.build_campaign_args ?? scopeResult?.buildCampaignArgs),
       warnings
     });
+    if (options.includeStrategyMemoryStatus !== false) {
+      await this.attachStrategyMemoryStatus(plan, warnings);
+    }
+    if (options.includeKernelPlan !== false) {
+      await this.attachKernelCampaignBuildPlan(plan, warnings);
+    }
+    if (options.includeDeliveryRisk !== false) {
+      await this.attachDeliveryRiskPreflight(plan, warnings);
+    }
+    return plan;
+  }
+  async commitPlan(plan, options = {}) {
+    const writeMode = options.confirm === true && options.dryRun === false;
+    if (writeMode && !options.approvedBy) {
+      throw new Error("Campaign builder plan commit requires approvedBy before writing state");
+    }
+    const plannerStep = plan.mcpFlow.find((step) => step.id === "agency-campaign-build-plan");
+    const plannerArgs = asRecord(plannerStep?.arguments);
+    const commitArgs = compact({
+      campaign_id: plan.buildRequest.gtmCampaignId,
+      name: plan.campaignName,
+      campaign_brief: plan.buildRequest.prompt || plan.goal,
+      target_icp: plan.buildRequest.icp ? buildGtmTargetIcpContext(plan.buildRequest.icp) : void 0,
+      lead_count: plan.targetCount,
+      layers: plannerArgs.layers,
+      preferred_providers: plannerArgs.preferred_providers,
+      plan_snapshot: Object.keys(asRecord(plan.kernelPlan)).length > 0 ? plan.kernelPlan : buildFallbackPlanSnapshot(plan),
+      send_config: plan.buildRequest.delivery ? {
+        delivery: plan.buildRequest.delivery,
+        approval_required: true
+      } : void 0,
+      brain_config: compact({
+        campaign_builder_agent_v1: {
+          plan_id: plan.planId,
+          kernel_plan_attached: Object.keys(asRecord(plan.kernelPlan)).length > 0,
+          approval_ids: plan.approvals.map((approval) => approval.id)
+        },
+        brain_defaults: plan.buildRequest.brainDefaults,
+        brain_preflight: plan.buildRequest.brainPreflight,
+        delivery_risk_preflight: plan.buildRequest.deliveryRisk,
+        delivery_risk: plan.buildRequest.deliveryRisk
+      }),
+      metadata: {
+        campaign_builder_agent_v1: {
+          plan_id: plan.planId,
+          source: "campaign-builder-agent",
+          approval_required: plan.approvals.some((approval) => approval.blocking),
+          approval_ids: plan.approvals.map((approval) => approval.id),
+          estimated_credits: plan.estimatedCredits
+        },
+        brain_delivery_risk_preflight: plan.buildRequest.deliveryRisk,
+        delivery_risk: plan.buildRequest.deliveryRisk
+      },
+      approval_required: plan.approvals.some((approval) => approval.blocking),
+      actor_type: "agent",
+      actor_id: options.approvedBy,
+      rationale: options.rationale || "Committed a reviewed strategy-template campaign-builder plan before execution.",
+      idempotency_key: options.idempotencyKey,
+      dry_run: !writeMode,
+      confirm: writeMode
+    });
+    const data = asRecord(await this.callMcp("gtm_campaign_build_plan_commit", commitArgs));
+    const result = mapPlanCommitResult(data);
+    if (result.wroteState && result.campaignId) {
+      plan.buildRequest.gtmCampaignId = result.campaignId;
+      refreshBuildStepArguments(plan);
+    }
+    return result;
   }
   async dryRunPlan(plan, options) {
     let args = buildCampaignArgs({
@@ -1218,6 +1778,15 @@ var CampaignBuilderAgent = class {
     if (missing.length > 0) {
       throw new Error(`Campaign builder approval is incomplete: ${missing.map((a) => a.label).join(", ")}`);
     }
+    if (options?.commitBeforeLaunch && !plan.buildRequest.gtmCampaignId) {
+      await this.commitPlan(plan, {
+        confirm: true,
+        dryRun: false,
+        approvedBy: approval.approvedBy,
+        idempotencyKey: options.idempotencyKey ? `${options.idempotencyKey}:plan-commit` : void 0,
+        rationale: "Committed reviewed campaign-builder plan immediately before approved launch."
+      });
+    }
     let args = buildCampaignArgs({
       ...plan.buildRequest,
       dryRun: false,
@@ -1264,8 +1833,8 @@ var CampaignBuilderAgent = class {
     try {
       return await this.callMcp("scope_campaign", {
         prompt: request.goal,
-        client_name: request.clientName,
-        client_context: request.clientContext,
+        account_label: campaignBuilderAccountLabel(request),
+        account_context: campaignBuilderAccountContext(request),
         campaign_goal: request.goal,
         target_count: request.targetCount,
         approval_policy: request.approvalPolicy?.requireHumanApproval ? "human_required" : "standard"
@@ -1290,25 +1859,70 @@ var CampaignBuilderAgent = class {
       }
     }
   }
+  async attachStrategyMemoryStatus(plan, warnings) {
+    const statusStep = plan.mcpFlow.find((step) => step.id === "strategy-memory-status");
+    if (!statusStep) return;
+    try {
+      const status = asRecord(await this.callMcp("gtm_campaign_strategy_memory_status", asRecord(statusStep.arguments)));
+      plan.strategyMemoryStatus = status;
+      const blockers = arrayOfStrings(status.blockers) ?? [];
+      if (status.ready === false || blockers.length > 0) {
+        warnings.push(`Strategy memory readiness is incomplete: ${blockers.join("; ") || "missing required strategy or workflow memory"}`);
+      }
+    } catch (error) {
+      warnings.push(`Strategy memory readiness check failed: ${errorMessage(error)}`);
+    }
+  }
+  async attachKernelCampaignBuildPlan(plan, warnings) {
+    const plannerStep = plan.mcpFlow.find((step) => step.id === "agency-campaign-build-plan");
+    if (!plannerStep) return;
+    try {
+      const kernelPlan = await this.callMcp("gtm_campaign_build_plan", asRecord(plannerStep.arguments));
+      plan.kernelPlan = asRecord(kernelPlan);
+      const brainDefaults = asRecord(plan.kernelPlan.brain_defaults ?? plan.kernelPlan.brainDefaults);
+      if (Object.keys(brainDefaults).length > 0 && Object.keys(asRecord(plan.buildRequest.brainDefaults)).length === 0) {
+        plan.buildRequest.brainDefaults = brainDefaults;
+        refreshBuildStepArguments(plan);
+      }
+    } catch (error) {
+      warnings.push(`GTM Kernel campaign build plan failed: ${errorMessage(error)}`);
+    }
+  }
+  async attachDeliveryRiskPreflight(plan, warnings) {
+    if (Object.keys(asRecord(plan.buildRequest.deliveryRisk)).length > 0) return;
+    const riskStep = plan.mcpFlow.find((step) => step.tool === "gtm_brain_delivery_risk");
+    if (!riskStep) return;
+    try {
+      const deliveryRisk = asRecord(await this.callMcp("gtm_brain_delivery_risk", asRecord(riskStep.arguments)));
+      if (Object.keys(deliveryRisk).length > 0) {
+        plan.buildRequest.deliveryRisk = deliveryRisk;
+        refreshBuildStepArguments(plan);
+      }
+    } catch (error) {
+      warnings.push(`GTM Brain delivery risk preflight failed: ${errorMessage(error)}`);
+    }
+  }
   async callMcp(tool, args) {
     return this.client.mcp("tools/call", { name: tool, arguments: compact(args) });
   }
 };
 function createCampaignBuilderAgentPlan(request, context = {}) {
-  const defaults = mergeDefaults(request.signalizDefaults);
-  const targetCount = request.targetCount ?? numberOrUndefined2(context.scopeBuildArgs?.target_count) ?? 100;
-  const campaignName = request.campaignName ?? stringValue(context.scopeBuildArgs?.name) ?? titleFromGoal(request.goal);
-  const workspaceContext = context.workspaceContext ?? request.workspaceContext ?? {};
-  const memory = normalizeMemory(request);
-  const routes = normalizeRoutes(request);
-  const estimatedCredits = estimateCredits(request, defaults, targetCount);
-  const buildRequest = createBuildRequest(request, defaults, targetCount, campaignName, context.scopeBuildArgs, routes, memory, context.scopeBrainPreflight);
+  const resolvedRequest = applyCampaignBuilderStrategyTemplate(request);
+  const defaults = mergeDefaults(resolvedRequest.signalizDefaults);
+  const targetCount = resolvedRequest.targetCount ?? numberOrUndefined2(context.scopeBuildArgs?.target_count) ?? 100;
+  const campaignName = resolvedRequest.campaignName ?? stringValue(context.scopeBuildArgs?.name) ?? titleFromGoal(resolvedRequest.goal);
+  const workspaceContext = context.workspaceContext ?? resolvedRequest.workspaceContext ?? {};
+  const memory = normalizeMemory(resolvedRequest);
+  const routes = normalizeRoutes(resolvedRequest);
+  const operatingPlaybooks = getCampaignBuilderOperatingPlaybooksForRequest(resolvedRequest);
+  const estimatedCredits = estimateCredits(resolvedRequest, defaults, targetCount);
+  const buildRequest = createBuildRequest(resolvedRequest, defaults, targetCount, campaignName, context.scopeBuildArgs, routes, memory, context.scopeBrainPreflight);
   const brainPreflight = asRecord(buildRequest.brainPreflight);
-  const approvals = deriveApprovals(request, routes, memory, estimatedCredits, defaults.delivery?.approvalRequired !== false);
+  const approvals = deriveApprovals(resolvedRequest, routes, memory, estimatedCredits, defaults.delivery?.approvalRequired !== false);
   return {
-    planId: `cbp_${hashString(JSON.stringify({ goal: request.goal, campaignName, targetCount, routes }))}`,
+    planId: `cbp_${hashString(JSON.stringify({ goal: resolvedRequest.goal, campaignName, targetCount, routes }))}`,
     campaignName,
-    goal: request.goal,
+    goal: resolvedRequest.goal,
     targetCount,
     workspaceContext,
     memory,
@@ -1321,7 +1935,8 @@ function createCampaignBuilderAgentPlan(request, context = {}) {
     approvals,
     buildRequest,
     brainPreflight,
-    mcpFlow: createMcpFlow(request, buildRequest, routes, memory, approvals),
+    operatingPlaybooks,
+    mcpFlow: createMcpFlow(resolvedRequest, buildRequest, routes, memory, approvals),
     estimatedCredits,
     warnings: context.warnings ?? []
   };
@@ -1349,6 +1964,249 @@ function createCampaignBuilderApproval(plan, input) {
     approvedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function getCampaignBuilderStrategyTemplate(value) {
+  const normalized = normalizeTemplateKey(value);
+  if (!normalized) return void 0;
+  return CAMPAIGN_BUILDER_STRATEGY_TEMPLATES.find(
+    (template) => template.slug === normalized || template.aliases.some((alias) => normalizeTemplateKey(alias) === normalized)
+  );
+}
+function getCampaignBuilderOperatingPlaybook(value) {
+  const normalized = normalizeTemplateKey(value);
+  if (!normalized) return void 0;
+  return CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS.find((playbook) => playbook.slug === normalized);
+}
+function getCampaignBuilderOperatingPlaybooksForRequest(request) {
+  const template = getCampaignBuilderStrategyTemplate(request.strategyTemplate);
+  const slugs = uniqueStrings([
+    ...template?.operatingPlaybookSlugs ?? [],
+    ...request.operatingPlaybooks ?? []
+  ]);
+  return slugs.map(getCampaignBuilderOperatingPlaybook).filter((playbook) => Boolean(playbook));
+}
+function applyCampaignBuilderStrategyTemplate(request) {
+  const template = getCampaignBuilderStrategyTemplate(request.strategyTemplate);
+  if (!template) return request;
+  return {
+    ...request,
+    strategyTemplate: template.slug,
+    campaignName: request.campaignName ?? template.campaignName,
+    accountContext: mergeText(template.accountContext, campaignBuilderAccountContext(request)),
+    targetCount: request.targetCount ?? template.defaultTargetCount,
+    icp: mergeIcp(template.icp, request.icp),
+    builtIns: request.builtIns ?? template.builtIns,
+    operatingPlaybooks: uniqueStrings([
+      ...template.operatingPlaybookSlugs,
+      ...request.operatingPlaybooks ?? []
+    ]),
+    preferredProviders: uniqueStrings([
+      ...template.preferredProviders,
+      ...request.preferredProviders ?? []
+    ]),
+    memory: mergeMemoryPlan({
+      enabled: true,
+      useWorkspaceHistory: true,
+      useNetworkPatterns: request.memory?.useNetworkPatterns,
+      privacyMode: request.memory?.privacyMode,
+      queries: template.memoryQueries
+    }, request.memory),
+    constraints: mergeConstraints(template.constraints, request.constraints),
+    signalizDefaults: mergeSignalizDefaultOverrides(template.signalizDefaults, request.signalizDefaults),
+    agencyContext: mergeAgencyContext(template.agencyContext, request.agencyContext)
+  };
+}
+function createCampaignBuilderAgentRequestTemplate(input = {}) {
+  const builtIns = new Set(input.builtIns ?? DEFAULT_CAMPAIGN_BUILDER_BUILT_INS);
+  if (input.includeLocalLeads) builtIns.add("local_leads");
+  const integrations = input.integrations ?? (input.includeCustomToolPlaceholder ? [createCampaignBuilderToolRoute({
+    provider: "custom_mcp",
+    layer: "enrichment",
+    gtmLayers: ["company_enrichment"],
+    toolName: "workspace_enrich",
+    mcpServerName: "workspace-mcp",
+    label: "Workspace enrichment MCP",
+    mode: "if_available",
+    approvalRequired: true
+  })] : void 0);
+  const preferredProviders = uniqueStrings([
+    ...input.preferredProviders ?? [],
+    ...input.includeNango === false ? [] : ["nango"]
+  ]);
+  const templated = applyCampaignBuilderStrategyTemplate({
+    goal: input.goal || "Build a strategy-template campaign for mature operators in the target ICP.",
+    strategyTemplate: input.strategyTemplate || "non-medical-home-care",
+    campaignName: input.campaignName,
+    accountLabel: input.accountLabel || "Workspace Campaign",
+    accountContext: input.accountContext || "Use private workspace memory, current suppression rules, verified-email quality gates, and approval-gated provider routes.",
+    targetCount: input.targetCount,
+    icp: input.icp ?? {
+      personas: ["Operations leader", "Founder", "Revenue leader"],
+      industries: ["B2B services", "Vertical software", "Local operators"],
+      geographies: ["United States"],
+      keywords: ["growth", "operations", "customer acquisition"],
+      requireVerifiedEmail: true
+    },
+    builtIns: [...builtIns],
+    integrations,
+    customerTools: input.customerTools,
+    preferredProviders,
+    constraints: input.constraints,
+    workspaceContext: input.workspaceContext,
+    brainDefaults: input.brainDefaults,
+    deliveryRisk: input.deliveryRisk,
+    gtmCampaignId: input.gtmCampaignId
+  });
+  return compact({
+    ...templated,
+    memory: mergeMemoryPlan({
+      enabled: true,
+      useWorkspaceHistory: true,
+      useNetworkPatterns: false,
+      privacyMode: "anonymized_patterns",
+      queries: [{
+        query: `${templated.strategyTemplate || "strategy-template"} campaign reply patterns, objections, qualification gates, and verified-email QA`,
+        scopes: ["workspace", "operator_notes"],
+        topK: 10,
+        required: true,
+        rationale: "Load approved private strategy and workflow patterns before campaign planning."
+      }]
+    }, input.memory),
+    agencyContext: mergeAgencyContext({
+      strategyModel: "strategy_template",
+      includeStrategyPatterns: true,
+      includeWorkflowPatterns: true,
+      includeNangoCatalog: true,
+      partnerEcosystem: input.includeNango === false ? ["signaliz"] : ["signaliz", "nango"]
+    }, input.agencyContext),
+    signalizDefaults: mergeSignalizDefaultOverrides({
+      maxCredits: input.signalizDefaults?.maxCredits,
+      delivery: {
+        enabled: true,
+        destinationType: input.signalizDefaults?.delivery?.destinationType ?? "json",
+        approvalRequired: true
+      }
+    }, input.signalizDefaults),
+    approvalPolicy: {
+      requireHumanApproval: true,
+      maxCreditsWithoutApproval: 0,
+      requireApprovalFor: DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES,
+      ...input.approvalPolicy
+    }
+  });
+}
+function createCampaignBuilderToolRoute(input) {
+  return {
+    provider: input.provider ?? "custom_mcp",
+    layer: input.layer,
+    toolName: input.toolName,
+    mcpServerName: input.mcpServerName,
+    label: input.label,
+    mode: input.mode ?? "if_available",
+    gtmLayer: input.gtmLayer,
+    gtmLayers: input.gtmLayers,
+    approvalRequired: input.approvalRequired ?? input.mode === "required",
+    config: input.config,
+    rationale: `${input.label ?? input.provider ?? "Custom tool"} is a user-provided campaign-builder route for ${input.layer}.`
+  };
+}
+function normalizeTemplateKey(value) {
+  return String(value || "").trim().toLowerCase().replace(/[_\s]+/g, "-");
+}
+function mergeText(base, override) {
+  if (base && override && !base.includes(override)) return `${base}
+${override}`;
+  return override ?? base;
+}
+function mergeIcp(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    personas: uniqueStrings([...base.personas ?? [], ...override.personas ?? []]),
+    industries: uniqueStrings([...base.industries ?? [], ...override.industries ?? []]),
+    companySizes: uniqueStrings([...base.companySizes ?? [], ...override.companySizes ?? []]),
+    geographies: uniqueStrings([...base.geographies ?? [], ...override.geographies ?? []]),
+    keywords: uniqueStrings([...base.keywords ?? [], ...override.keywords ?? []]),
+    exclusions: uniqueStrings([...base.exclusions ?? [], ...override.exclusions ?? []]),
+    requireVerifiedEmail: override.requireVerifiedEmail ?? base.requireVerifiedEmail
+  };
+}
+function mergeMemoryPlan(base, override) {
+  const queries = dedupeMemoryQueries([...base.queries ?? [], ...override?.queries ?? []]);
+  return {
+    ...base,
+    ...override,
+    queries: queries.length > 0 ? queries : void 0,
+    enabled: override?.enabled ?? base.enabled,
+    useWorkspaceHistory: override?.useWorkspaceHistory ?? base.useWorkspaceHistory,
+    useNetworkPatterns: override?.useNetworkPatterns ?? base.useNetworkPatterns,
+    privacyMode: override?.privacyMode ?? base.privacyMode
+  };
+}
+function dedupeMemoryQueries(queries) {
+  const seen = /* @__PURE__ */ new Set();
+  return queries.filter((query) => {
+    const key = query.query.trim().toLowerCase();
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function mergeConstraints(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    geographies: uniqueStrings([...base.geographies ?? [], ...override.geographies ?? []]),
+    exclusions: uniqueStrings([...base.exclusions ?? [], ...override.exclusions ?? []]),
+    deliverabilityNotes: uniqueStrings([...base.deliverabilityNotes ?? [], ...override.deliverabilityNotes ?? []]),
+    maxDailySends: override.maxDailySends ?? base.maxDailySends
+  };
+}
+function mergeSignalizDefaultOverrides(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    signals: { ...base.signals, ...override.signals },
+    qualification: { ...base.qualification, ...override.qualification },
+    copy: { ...base.copy, ...override.copy },
+    delivery: { ...base.delivery, ...override.delivery }
+  };
+}
+function mergeAgencyContext(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    partnerEcosystem: uniqueStrings([...base.partnerEcosystem ?? [], ...override.partnerEcosystem ?? []]),
+    strategyModel: override.strategyModel ?? base.strategyModel,
+    includeStrategyPatterns: override.includeStrategyPatterns ?? base.includeStrategyPatterns,
+    includeWorkflowPatterns: override.includeWorkflowPatterns ?? base.includeWorkflowPatterns,
+    includeClayPatterns: override.includeClayPatterns ?? base.includeClayPatterns,
+    includeNangoCatalog: override.includeNangoCatalog ?? base.includeNangoCatalog,
+    revenueMotion: override.revenueMotion ?? base.revenueMotion
+  };
+}
+function campaignBuilderStrategyModel(agencyContext) {
+  return agencyContext?.strategyModel ?? "strategy_template";
+}
+function campaignBuilderStrategyPatternsEnabled(agencyContext) {
+  return agencyContext?.includeStrategyPatterns ?? true;
+}
+function campaignBuilderWorkflowPatternsEnabled(agencyContext) {
+  return agencyContext?.includeWorkflowPatterns ?? agencyContext?.includeClayPatterns ?? true;
+}
+function campaignBuilderAccountLabel(request) {
+  return request.accountLabel;
+}
+function campaignBuilderAccountContext(request) {
+  return request.accountContext;
+}
 function mergeDefaults(overrides) {
   return {
     ...DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS,
@@ -1361,12 +2219,9 @@ function mergeDefaults(overrides) {
 }
 function normalizeMemory(request) {
   const configured = request.memory ?? {};
-  const queries = configured.queries && configured.queries.length > 0 ? configured.queries : [{
-    query: request.goal,
-    scopes: ["workspace", configured.useNetworkPatterns ? "network_patterns" : "operator_notes"],
-    topK: 8,
-    rationale: "Seed the campaign plan with prior ICP, angle, source, and reply-performance patterns."
-  }];
+  const defaultQueries = defaultAgencyMemoryQueries(request, configured);
+  const configuredQueries = configured.queries ?? [];
+  const queries = configuredQueries.length > 0 ? request.strategyTemplate ? dedupeMemoryQueries([...configuredQueries, ...defaultQueries]) : configuredQueries : defaultQueries;
   return {
     enabled: configured.enabled !== false,
     queries,
@@ -1375,40 +2230,130 @@ function normalizeMemory(request) {
     privacyMode: configured.privacyMode ?? (configured.useNetworkPatterns ? "anonymized_patterns" : "workspace_only")
   };
 }
+function defaultAgencyMemoryQueries(request, configured) {
+  const operatingPlaybookTerms = getCampaignBuilderOperatingPlaybooksForRequest(request).flatMap((playbook) => [playbook.label, ...playbook.memoryKeywords]).join(" ");
+  const queries = [{
+    query: request.goal,
+    scopes: ["workspace", configured.useNetworkPatterns ? "network_patterns" : "operator_notes"],
+    topK: 8,
+    rationale: "Seed the campaign plan with prior ICP, angle, source, and reply-performance patterns."
+  }];
+  if (campaignBuilderStrategyModel(request.agencyContext) !== "custom" && campaignBuilderStrategyPatternsEnabled(request.agencyContext)) {
+    queries.push({
+      query: [
+        "Private campaign strategy pattern library prior campaign casebook",
+        campaignBuilderAccountLabel(request),
+        operatingPlaybookTerms,
+        request.goal
+      ].filter(Boolean).join(" "),
+      scopes: ["workspace", "operator_notes"],
+      topK: 8,
+      required: true,
+      rationale: "Anchor the plan in private strategy learnings from prior industrial, healthcare, agency-services, infrastructure, recruiting, media, and integration builds."
+    });
+  }
+  if (campaignBuilderWorkflowPatternsEnabled(request.agencyContext)) {
+    queries.push({
+      query: [
+        "Workflow table architecture enrichment qualification copy export gates",
+        request.goal
+      ].filter(Boolean).join(" "),
+      scopes: ["workspace", "operator_notes"],
+      topK: 6,
+      rationale: "Pull workflow patterns for source tables, enrichment order, qualification gates, and handoff controls."
+    });
+  }
+  return queries;
+}
 function normalizeRoutes(request) {
-  const routes = [
-    {
-      id: "signaliz-source",
+  const routes = builtInRoutesFor(request);
+  routes.push(...routesFromCustomerTools(request.customerTools ?? []));
+  routes.push(...request.integrations ?? []);
+  return routes.map((route, index) => ({
+    ...route,
+    id: route.id ?? `${route.provider}-${route.layer}-${index + 1}`,
+    mode: route.mode ?? "if_available"
+  }));
+}
+function builtInRoutesFor(request) {
+  const builtIns = new Set(normalizeBuiltIns(request));
+  const routes = [];
+  if (builtIns.has("lead_generation")) {
+    routes.push({
+      id: "signaliz-lead-generation",
       layer: "source",
+      gtmLayers: ["find_company", "find_people", "lead_generation"],
       provider: "signaliz",
       mode: "required",
       toolName: "generate_leads",
       rationale: "Use Signaliz fresh workspace acquisition as the default source of truth."
-    },
-    {
-      id: "signaliz-verify",
-      layer: "qualification",
+    });
+  }
+  if (builtIns.has("local_leads")) {
+    routes.push({
+      id: "signaliz-local-leads",
+      layer: "source",
+      gtmLayer: "local_leads",
+      provider: "signaliz",
+      mode: "if_available",
+      toolName: "generate_local_leads",
+      rationale: "Use Signaliz local-leads sourcing for geography-bound local business campaigns."
+    });
+  }
+  if (builtIns.has("email_finding")) {
+    routes.push({
+      id: "signaliz-email-finding",
+      layer: "enrichment",
+      gtmLayer: "email_finding",
       provider: "signaliz",
       mode: "required",
       toolName: "find_and_verify_emails",
+      rationale: "Find contact emails before verification and campaign handoff."
+    });
+  }
+  if (builtIns.has("email_verification")) {
+    routes.push({
+      id: "signaliz-email-verification",
+      layer: "qualification",
+      gtmLayer: "email_verification",
+      provider: "signaliz",
+      mode: "required",
+      toolName: "verify_emails",
       rationale: "Require verified contactability before sequence delivery."
-    },
-    {
+    });
+  }
+  if (builtIns.has("signals")) {
+    routes.push({
       id: "signaliz-signals",
       layer: "enrichment",
+      gtmLayer: "company_enrichment",
       provider: "signaliz",
       mode: "if_available",
       toolName: "enrich_company_signals",
       rationale: "Attach current buying signals and evidence for qualification and copy."
-    }
-  ];
-  routes.push(...routesFromCustomerTools(request.customerTools ?? []));
-  routes.push(...request.integrations ?? []);
-  return routes.map((route, index) => ({
-    ...route,
-    id: route.id ?? `${route.provider}-${route.layer}-${index + 1}`,
-    mode: route.mode ?? "if_available"
-  }));
+    });
+  }
+  return routes;
+}
+function normalizeBuiltIns(request) {
+  const configured = request.builtIns !== void 0 ? request.builtIns : DEFAULT_CAMPAIGN_BUILDER_BUILT_INS;
+  const builtIns = new Set(configured);
+  if (request.builtIns === void 0 && looksLikeLocalLeadCampaign(request)) {
+    builtIns.add("local_leads");
+  }
+  return [...builtIns].filter(isCampaignBuilderBuiltInTool);
+}
+function isCampaignBuilderBuiltInTool(value) {
+  return ["lead_generation", "local_leads", "email_finding", "email_verification", "signals"].includes(String(value));
+}
+function looksLikeLocalLeadCampaign(request) {
+  const text = [
+    request.goal,
+    campaignBuilderAccountContext(request),
+    ...request.icp?.industries ?? [],
+    ...request.icp?.keywords ?? []
+  ].filter(Boolean).join(" ").toLowerCase();
+  return /\b(local|google maps|near me|nearby|city|cities|location|locations|home services?|clinics?|restaurants?|contractors?)\b/.test(text);
 }
 function routesFromCustomerTools(tools) {
   return tools.flatMap(
@@ -1426,7 +2371,7 @@ function routesFromCustomerTools(tools) {
         ...tool.config,
         available_tools: tool.availableTools
       },
-      rationale: `${tool.label ?? tool.provider} is customer-provided for ${layer}.`
+      rationale: `${tool.label ?? tool.provider} is operator-provided for ${layer}.`
     }))
   );
 }
@@ -1471,6 +2416,7 @@ function createBuildRequest(request, defaults, targetCount, campaignName, scopeB
   return buildRequest;
 }
 function createBrainPreflight(request, buildRequest, routes, memory) {
+  const operatingPlaybooks = getCampaignBuilderOperatingPlaybooksForRequest(request);
   const layers = uniqueStrings([
     "icp",
     "email_finding",
@@ -1480,7 +2426,7 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
     ["instantly", "smartlead", "heyreach"].some((provider) => routes.some((route) => route.provider === provider)) ? "sender" : void 0,
     memory.enabled ? "feedback" : void 0
   ]);
-  const providerChain = uniqueStrings(["signaliz", ...routes.map((route) => route.provider)]);
+  const providerChain = uniqueStrings(["signaliz", ...request.preferredProviders ?? [], ...routes.map((route) => route.provider)]);
   const targetIcp = compact({
     personas: buildRequest.icp?.personas,
     industries: buildRequest.icp?.industries,
@@ -1521,6 +2467,13 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
     required: true,
     policy: "Run read-only GTM Brain preflight before build_campaign so learned defaults, memory, and deliverability risk stay attached to the build.",
     layers,
+    operating_playbooks: operatingPlaybooks.map((playbook) => ({
+      slug: playbook.slug,
+      label: playbook.label,
+      quality_gates: playbook.qualityGates,
+      required_fields: playbook.requiredFields,
+      activation_boundary: playbook.activationBoundary
+    })),
     target_icp: targetIcp,
     provider_chain: providerChain,
     lead_source: providerChain[0] ?? "signaliz",
@@ -1653,6 +2606,47 @@ function createMcpFlow(request, buildRequest, routes, memory, approvals) {
       approvalRequired: false
     }
   ];
+  steps.push({
+    id: "gtm-provider-catalog",
+    phase: "plan",
+    tool: "gtm_provider_catalog",
+    arguments: {
+      include_layer_catalog: true,
+      include_planned: true
+    },
+    readOnly: true,
+    approvalRequired: false
+  });
+  if (request.agencyContext?.includeNangoCatalog !== false) {
+    steps.push({
+      id: "nango-tool-catalog",
+      phase: "plan",
+      tool: "nango_mcp_tools_list",
+      arguments: {
+        format: "mcp"
+      },
+      readOnly: true,
+      approvalRequired: false
+    });
+  }
+  if (memory.enabled) {
+    steps.push({
+      id: "strategy-memory-status",
+      phase: "memory",
+      tool: "gtm_campaign_strategy_memory_status",
+      arguments: buildGtmCampaignStrategyMemoryStatusArgs(request, buildRequest),
+      readOnly: true,
+      approvalRequired: false
+    });
+  }
+  steps.push({
+    id: "agency-campaign-build-plan",
+    phase: "plan",
+    tool: "gtm_campaign_build_plan",
+    arguments: buildGtmCampaignBuildPlanArgs(request, buildRequest, routes, memory),
+    readOnly: true,
+    approvalRequired: memory.useNetworkPatterns === true
+  });
   if (memory.enabled) {
     for (const [index, query] of memory.queries.entries()) {
       steps.push({
@@ -1666,6 +2660,25 @@ function createMcpFlow(request, buildRequest, routes, memory, approvals) {
     }
   }
   for (const route of routes) {
+    if (shouldPrepareProviderRoute(route)) {
+      steps.push({
+        id: `prepare-${route.id}`,
+        phase: "plan",
+        tool: "gtm_provider_recipe_prepare",
+        arguments: buildProviderRecipePrepareArgs(route, buildRequest),
+        readOnly: true,
+        approvalRequired: false
+      });
+      steps.push({
+        id: `activate-${route.id}-dry-run`,
+        phase: "plan",
+        tool: "gtm_provider_route_activate",
+        arguments: buildProviderRouteActivateArgs(route, buildRequest),
+        readOnly: true,
+        approvalRequired: false
+      });
+    }
+    const routeApprovalRequired = route.approvalRequired === true || route.provider !== "signaliz" && route.approvalRequired !== false && route.mode === "required" || route.layer === "delivery" || route.layer === "feedback";
     steps.push({
       id: `route-${route.id}`,
       phase: route.layer,
@@ -1677,7 +2690,7 @@ function createMcpFlow(request, buildRequest, routes, memory, approvals) {
         config: route.config
       },
       readOnly: !["delivery", "feedback"].includes(route.layer),
-      approvalRequired: route.approvalRequired === true || route.layer === "delivery" || route.layer === "feedback"
+      approvalRequired: routeApprovalRequired
     });
   }
   steps.push({
@@ -1686,8 +2699,8 @@ function createMcpFlow(request, buildRequest, routes, memory, approvals) {
     tool: "scope_campaign",
     arguments: {
       prompt: request.goal,
-      client_name: request.clientName,
-      client_context: request.clientContext,
+      account_label: campaignBuilderAccountLabel(request),
+      account_context: campaignBuilderAccountContext(request),
       target_count: request.targetCount
     },
     readOnly: true,
@@ -1749,9 +2762,199 @@ function createMcpFlow(request, buildRequest, routes, memory, approvals) {
   });
   return steps.map((step) => ({ ...step, arguments: compact(step.arguments) }));
 }
+function shouldPrepareProviderRoute(route) {
+  return !["signaliz", "csv"].includes(route.provider);
+}
+function buildProviderRecipePrepareArgs(route, buildRequest) {
+  const layerCapabilities = uniqueStrings(gtmLayersForRoute(route));
+  const layer = layerCapabilities[0] ?? mapCampaignBuilderLayerToGtmLayer(route.layer) ?? "custom";
+  const config = asRecord(route.config);
+  return compact({
+    provider_id: route.provider,
+    provider_name: route.label,
+    layer,
+    layer_capabilities: layerCapabilities.length > 0 ? layerCapabilities : void 0,
+    invocation_type: route.providerCapability?.invocationType ?? inferProviderInvocationType(route),
+    auth_strategy: inferProviderAuthStrategy(route),
+    workspace_mcp_server_id: stringValue(config.workspace_mcp_server_id ?? config.workspaceMcpServerId ?? route.mcpServerName),
+    workspace_integration_id: stringValue(config.workspace_integration_id ?? config.workspaceIntegrationId),
+    workspace_connection_id: stringValue(config.workspace_connection_id ?? config.workspaceConnectionId),
+    endpoint_url: stringValue(config.endpoint_url ?? config.endpointUrl ?? config.webhook_url ?? config.webhookUrl),
+    request_template: asOptionalRecord(config.request_template ?? config.requestTemplate),
+    response_mapping: asOptionalRecord(config.response_mapping ?? config.responseMapping),
+    input_schema: asOptionalRecord(config.input_schema ?? config.inputSchema ?? route.providerCapability?.exampleInputSchema),
+    output_schema: asOptionalRecord(config.output_schema ?? config.outputSchema ?? route.providerCapability?.exampleOutputSchema),
+    readiness: asOptionalRecord(config.readiness),
+    metadata: compact({
+      source: "campaign-builder-agent",
+      route_id: route.id,
+      campaign_name: buildRequest.name,
+      tool_name: route.toolName,
+      mcp_server_name: route.mcpServerName,
+      dry_run_only: true
+    }),
+    context: compact({
+      source: "campaign-builder-agent",
+      route_id: route.id,
+      gtm_campaign_id: buildRequest.gtmCampaignId
+    }),
+    use_signaliz_fallback: route.routingPolicy?.useSignalizFallback ?? true,
+    priority: numberOrUndefined2(config.priority),
+    status: stringValue(config.status) ?? "needs_setup"
+  });
+}
+function buildProviderRouteActivateArgs(route, buildRequest) {
+  const layerCapabilities = uniqueStrings(gtmLayersForRoute(route));
+  const config = asRecord(route.config);
+  return compact({
+    provider_id: route.provider,
+    provider_name: route.label,
+    campaign_id: buildRequest.gtmCampaignId,
+    layer: layerCapabilities[0] ?? mapCampaignBuilderLayerToGtmLayer(route.layer) ?? "custom",
+    layers: layerCapabilities.length > 0 ? layerCapabilities : void 0,
+    invocation_type: route.providerCapability?.invocationType ?? inferProviderInvocationType(route),
+    auth_strategy: inferProviderAuthStrategy(route),
+    workspace_mcp_server_id: stringValue(config.workspace_mcp_server_id ?? config.workspaceMcpServerId ?? route.mcpServerName),
+    workspace_integration_id: stringValue(config.workspace_integration_id ?? config.workspaceIntegrationId),
+    workspace_connection_id: stringValue(config.workspace_connection_id ?? config.workspaceConnectionId),
+    endpoint_url: stringValue(config.endpoint_url ?? config.endpointUrl ?? config.webhook_url ?? config.webhookUrl),
+    route_config: compact({
+      ...asRecord(config.route_config ?? config.routeConfig),
+      source: "campaign-builder-agent",
+      route_id: route.id,
+      tool_name: route.toolName,
+      mcp_server_name: route.mcpServerName
+    }),
+    use_signaliz_fallback: route.routingPolicy?.useSignalizFallback ?? true,
+    priority: numberOrUndefined2(config.priority),
+    dry_run: true,
+    confirm: false
+  });
+}
+function inferProviderInvocationType(route) {
+  if (route.provider === "airbyte") return "airbyte";
+  if (route.provider === "nango") return "managed_integration";
+  if (["custom_webhook", "webhook", "clay_webhook"].includes(route.provider)) return "webhook";
+  if (["custom_api", "apollo", "ai_ark", "apify"].includes(route.provider)) return "api";
+  if (route.mcpServerName || route.toolName || ["custom_mcp", "octave"].includes(route.provider)) return "mcp_tool";
+  return "manual";
+}
+function inferProviderAuthStrategy(route) {
+  const config = asRecord(route.config);
+  const configured = stringValue(config.auth_strategy ?? config.authStrategy);
+  if (configured) return configured;
+  const invocationType = route.providerCapability?.invocationType ?? inferProviderInvocationType(route);
+  if (invocationType === "webhook") return "webhook_secret";
+  if (invocationType === "mcp_tool") return "mcp_auth";
+  if (invocationType === "managed_integration") return "byo_runtime";
+  if (invocationType === "api" || invocationType === "airbyte") return "integration_key";
+  return void 0;
+}
+function refreshBuildStepArguments(plan) {
+  for (const step of plan.mcpFlow) {
+    if (step.id === "dry-run-build") {
+      step.arguments = compact({
+        ...buildCampaignArgs({ ...plan.buildRequest, dryRun: true, confirmSpend: false }),
+        dry_run: true
+      });
+    }
+    if (step.id === "approved-build") {
+      step.arguments = compact({
+        ...buildCampaignArgs({ ...plan.buildRequest, dryRun: false, confirmSpend: true }),
+        required_approvals: plan.approvals.map((approval) => approval.id)
+      });
+    }
+  }
+}
+function buildFallbackPlanSnapshot(plan) {
+  const plannerStep = plan.mcpFlow.find((step) => step.id === "agency-campaign-build-plan");
+  return compact({
+    source_tool: "campaign-builder-agent",
+    plan_id: plan.planId,
+    query: asRecord(plannerStep?.arguments),
+    campaign_name: plan.campaignName,
+    goal: plan.goal,
+    target_count: plan.targetCount,
+    approvals: plan.approvals,
+    brain_preflight: plan.brainPreflight,
+    operating_playbooks: plan.operatingPlaybooks
+  });
+}
+function mapPlanCommitResult(data) {
+  const campaign = asRecord(data.campaign);
+  const campaignBuild = asRecord(data.campaign_build ?? data.campaignBuild);
+  const committedPlan = asRecord(data.committed_plan ?? data.committedPlan);
+  const commitPlan = asRecord(data.commit_plan ?? data.commitPlan);
+  const campaignArgs = asRecord(commitPlan.campaign_arguments ?? commitPlan.campaignArguments);
+  return {
+    dryRun: data.dry_run === true || data.dryRun === true,
+    wroteState: data.wrote_state === true || data.wroteState === true,
+    campaignId: stringValue(campaign.id ?? committedPlan.campaign_id ?? committedPlan.campaignId ?? commitPlan.campaign_id ?? commitPlan.campaignId ?? campaignArgs.id),
+    campaignBuildId: stringValue(campaignBuild.id ?? committedPlan.campaign_build_id ?? committedPlan.campaignBuildId ?? campaignArgs.campaign_build_id ?? campaignArgs.campaignBuildId),
+    raw: data
+  };
+}
+function buildGtmCampaignBuildPlanArgs(request, buildRequest, routes, memory) {
+  const agencyContext = request.agencyContext ?? {};
+  const strategyModel = campaignBuilderStrategyModel(agencyContext);
+  const partnerEcosystem = agencyContext.partnerEcosystem ?? (strategyModel === "custom" ? void 0 : ["clay", "instantly", "nango"]);
+  const layers = uniqueStrings([
+    "icp",
+    buildRequest.icp?.requireVerifiedEmail !== false ? "email_finding" : void 0,
+    buildRequest.icp?.requireVerifiedEmail !== false ? "email_verification" : void 0,
+    ...routes.flatMap(gtmLayersForRoute),
+    buildRequest.delivery?.destinationType === "webhook" ? "destination_export" : void 0,
+    memory.enabled ? "feedback" : void 0
+  ]);
+  const preferredProviders = uniqueStrings([
+    ...request.preferredProviders ?? [],
+    ...routes.map((route) => route.provider).filter((provider) => provider !== "signaliz")
+  ]);
+  const operatingPlaybooks = getCampaignBuilderOperatingPlaybooksForRequest(request);
+  return compact({
+    campaign_id: buildRequest.gtmCampaignId,
+    campaign_brief: buildRequest.prompt || request.goal,
+    strategy_template: request.strategyTemplate,
+    target_icp: buildRequest.icp ? buildGtmTargetIcpContext(buildRequest.icp) : void 0,
+    lead_count: buildRequest.targetCount,
+    layers: layers.length > 0 ? layers : void 0,
+    preferred_providers: preferredProviders.length > 0 ? preferredProviders : void 0,
+    strategy_model: strategyModel,
+    include_strategy_patterns: campaignBuilderStrategyPatternsEnabled(agencyContext),
+    include_workflow_patterns: campaignBuilderWorkflowPatternsEnabled(agencyContext),
+    include_nango_catalog: agencyContext.includeNangoCatalog !== false,
+    partner_ecosystem: partnerEcosystem,
+    operating_playbooks: operatingPlaybooks.map((playbook) => ({
+      slug: playbook.slug,
+      label: playbook.label,
+      quality_gates: playbook.qualityGates,
+      activation_boundary: playbook.activationBoundary
+    })),
+    include_memory: memory.enabled,
+    include_brain: true,
+    include_provider_routes: true,
+    include_failure_patterns: true,
+    include_planned_providers: true,
+    limit: 25
+  });
+}
+function buildGtmCampaignStrategyMemoryStatusArgs(request, buildRequest) {
+  return compact({
+    query: request.goal,
+    campaign_brief: buildRequest.prompt || request.goal,
+    strategy_template: request.strategyTemplate,
+    target_icp: buildRequest.icp ? buildGtmTargetIcpContext(buildRequest.icp) : void 0,
+    memory_dimension_filters: request.strategyTemplate ? { strategy_template: request.strategyTemplate } : void 0,
+    require_memory_dimension_match: false,
+    include_samples: false,
+    include_sources: true,
+    days: 3650,
+    limit: 25
+  });
+}
 function buildGtmMemorySearchArgs(request, routes, query) {
   const layers = uniqueStrings(routes.flatMap(gtmLayersForRoute));
-  const providerChain = uniqueStrings(routes.map((route) => route.provider));
+  const providerChain = uniqueStrings([...request.preferredProviders ?? [], ...routes.map((route) => route.provider)]);
   return compact({
     query: query.query,
     limit: query.topK,
@@ -1773,6 +2976,26 @@ function buildGtmTargetIcpContext(icp) {
     require_verified_email: icp.requireVerifiedEmail
   });
 }
+function mapCampaignBuilderLayerToGtmLayer(layer) {
+  switch (layer) {
+    case "source":
+      return "lead_generation";
+    case "enrichment":
+      return "company_enrichment";
+    case "qualification":
+      return "qualification";
+    case "copy":
+      return "copy_enrichment";
+    case "delivery":
+      return "destination_export";
+    case "feedback":
+      return "feedback";
+    case "approval":
+      return "approval";
+    default:
+      return void 0;
+  }
+}
 function buildCampaignArgs(request) {
   const args = {
     name: request.name,
@@ -1953,8 +3176,8 @@ function estimateCredits(request, defaults, targetCount) {
 }
 function buildDescription(request) {
   const parts = [
-    request.clientName ? `Client: ${request.clientName}` : void 0,
-    request.clientContext ? `Context: ${request.clientContext}` : void 0,
+    campaignBuilderAccountLabel(request) ? `Account label: ${campaignBuilderAccountLabel(request)}` : void 0,
+    campaignBuilderAccountContext(request) ? `Context: ${campaignBuilderAccountContext(request)}` : void 0,
     request.constraints?.deliverabilityNotes?.length ? `Deliverability: ${request.constraints.deliverabilityNotes.join("; ")}` : void 0,
     "Agent-built campaign plan layered on Signaliz kernel and existing MCP tools."
   ];
@@ -1977,6 +3200,10 @@ function compact(record) {
 function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function asOptionalRecord(value) {
+  const record = asRecord(value);
+  return Object.keys(record).length > 0 ? record : void 0;
+}
 function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -3721,7 +4948,7 @@ var GtmKernel = class {
       campaigns: input.campaigns.map(campaignHistoryImportCampaignArgs)
     });
   }
-  /** Queue a Trigger-backed campaign history import for larger CMM/client backfills. */
+  /** Queue a Trigger-backed campaign history import for larger private campaign backfills. */
   async importCampaignHistoryRun(input) {
     return this.callMcp("gtm_campaign_history_import_run", {
       source: input.source,
@@ -3852,6 +5079,25 @@ var GtmKernel = class {
       write_routine_outcomes: input.writeRoutineOutcomes
     });
   }
+  /** Run a read-only Campaign Audit and persist workspace-scoped failure findings. */
+  async runCampaignAudit(input) {
+    return this.callMcp("gtm_campaign_audit_run", {
+      provider: input.provider,
+      provider_campaign_id: input.providerCampaignId,
+      campaign_id: input.campaignId,
+      campaign_name: input.campaignName,
+      lookback_days: input.lookbackDays,
+      limit_findings: input.limitFindings
+    });
+  }
+  /** Read a persisted Campaign Audit by audit id or campaign id. */
+  async getCampaignAudit(options) {
+    return this.callMcp("gtm_campaign_audit_get", {
+      audit_id: options.auditId,
+      campaign_id: options.campaignId,
+      limit_findings: options.limitFindings
+    });
+  }
   /** Normalize Instantly webhook/pull payloads and ingest row-level feedback through the GTM Kernel. */
   async syncInstantlyFeedback(input) {
     return this.callMcp("gtm_instantly_feedback_sync", {
@@ -4149,6 +5395,40 @@ var GtmKernel = class {
       include_layer_catalog: options.includeLayerCatalog
     });
   }
+  /** List private-safe campaign strategy templates agents can merge into campaign build plans. */
+  async campaignStrategyTemplates(options = {}) {
+    return this.callMcp("gtm_campaign_strategy_templates", {
+      strategy_template: options.strategyTemplate,
+      query: options.query,
+      include_details: options.includeDetails
+    });
+  }
+  /** Build the read-only Memory, Brain, risk, and provider-route runbook needed before planning a campaign. */
+  async campaignStartContext(input = {}) {
+    return this.callMcp("gtm_campaign_start_context", {
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      campaign_brief: input.campaignBrief,
+      strategy_template: input.strategyTemplate,
+      target_icp: input.targetIcp,
+      lead_count: input.leadCount,
+      layers: input.layers,
+      preferred_providers: input.preferredProviders,
+      memory_dimension_filters: input.memoryDimensionFilters,
+      require_memory_dimension_match: input.requireMemoryDimensionMatch,
+      include_memory: input.includeMemory,
+      include_brain: input.includeBrain,
+      include_provider_routes: input.includeProviderRoutes,
+      include_failure_patterns: input.includeFailurePatterns,
+      include_delivery_risk: input.includeDeliveryRisk,
+      include_global_brain: input.includeGlobalBrain,
+      include_planned_providers: input.includePlannedProviders,
+      days: input.days,
+      min_confidence: input.minConfidence,
+      min_sample_size: input.minSampleSize,
+      limit: input.limit
+    });
+  }
   /** Inspect GTM integration activation cards for UI and agent routing without writing state. */
   async integrationsActivationStatus(options = {}) {
     return this.callMcp("gtm_integrations_activation_status", {
@@ -4164,10 +5444,16 @@ var GtmKernel = class {
       campaign_id: input.campaignId,
       campaign_build_id: input.campaignBuildId,
       campaign_brief: input.campaignBrief,
+      strategy_template: input.strategyTemplate,
       target_icp: input.targetIcp,
       lead_count: input.leadCount,
       layers: input.layers,
       preferred_providers: input.preferredProviders,
+      strategy_model: input.strategyModel,
+      include_strategy_patterns: input.includeStrategyPatterns,
+      include_workflow_patterns: input.includeWorkflowPatterns ?? input.includeClayPatterns,
+      include_nango_catalog: input.includeNangoCatalog,
+      partner_ecosystem: input.partnerEcosystem,
       memory_dimension_filters: input.memoryDimensionFilters,
       require_memory_dimension_match: input.requireMemoryDimensionMatch,
       include_memory: input.includeMemory,
@@ -4179,6 +5465,79 @@ var GtmKernel = class {
       limit: input.limit
     });
   }
+  /** Emit reusable CampaignBuilderAgentRequest JSON from hosted MCP strategy-template defaults without spending credits. */
+  async campaignAgentRequestTemplate(input = {}) {
+    return this.callMcp("gtm_campaign_agent_request_template", {
+      goal: input.goal,
+      campaign_brief: input.campaignBrief,
+      campaign_name: input.campaignName,
+      account_label: input.accountLabel,
+      account_context: input.accountContext,
+      strategy_template: input.strategyTemplate,
+      operating_playbooks: input.operatingPlaybooks,
+      target_icp: input.targetIcp,
+      target_count: input.targetCount,
+      builtins: input.builtIns,
+      include_local_leads: input.includeLocalLeads,
+      include_byo_placeholder: input.includeByoPlaceholder,
+      include_nango_catalog: input.includeNangoCatalog,
+      preferred_providers: input.preferredProviders,
+      privacy_mode: input.privacyMode,
+      destination_type: input.destinationType
+    });
+  }
+  /** Compose a one-call read-only strategy-template campaign-agent runbook across built-ins, Memory, Brain, Nango, and BYO routes. */
+  async campaignAgentPlan(input = {}) {
+    return this.callMcp("gtm_campaign_agent_plan", {
+      goal: input.goal,
+      campaign_brief: input.campaignBrief,
+      campaign_name: input.campaignName,
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      strategy_template: input.strategyTemplate,
+      operating_playbooks: input.operatingPlaybooks,
+      account_context: input.accountContext,
+      target_icp: input.targetIcp,
+      target_count: input.targetCount,
+      lead_count: input.leadCount,
+      builtins: input.builtIns,
+      use_local_leads: input.useLocalLeads,
+      layers: input.layers,
+      preferred_providers: input.preferredProviders,
+      custom_tools: input.customTools,
+      integrations: input.integrations,
+      strategy_model: input.strategyModel,
+      include_strategy_patterns: input.includeStrategyPatterns,
+      include_workflow_patterns: input.includeWorkflowPatterns,
+      include_nango_catalog: input.includeNangoCatalog,
+      partner_ecosystem: input.partnerEcosystem,
+      memory_dimension_filters: input.memoryDimensionFilters,
+      require_memory_dimension_match: input.requireMemoryDimensionMatch,
+      include_memory: input.includeMemory,
+      include_brain: input.includeBrain,
+      include_provider_routes: input.includeProviderRoutes,
+      include_failure_patterns: input.includeFailurePatterns,
+      include_delivery_risk: input.includeDeliveryRisk,
+      include_planned_providers: input.includePlannedProviders,
+      days: input.days,
+      limit: input.limit
+    });
+  }
+  /** Inspect private-safe strategy-template/workflow memory readiness before campaign planning. */
+  async campaignStrategyMemoryStatus(input = {}) {
+    return this.callMcp("gtm_campaign_strategy_memory_status", {
+      strategy_template: input.strategyTemplate,
+      query: input.query,
+      campaign_brief: input.campaignBrief,
+      target_icp: input.targetIcp,
+      memory_dimension_filters: input.memoryDimensionFilters,
+      require_memory_dimension_match: input.requireMemoryDimensionMatch,
+      include_samples: input.includeSamples,
+      include_sources: input.includeSources,
+      days: input.days,
+      limit: input.limit
+    });
+  }
   /** Persist a reviewed campaign build plan into a campaign object and audit log. Dry-run first by default. */
   async commitCampaignBuildPlan(input = {}) {
     return this.callMcp("gtm_campaign_build_plan_commit", {
@@ -4325,6 +5684,13 @@ var GtmKernel = class {
       vendor_id: input.vendorId,
       service_category: input.serviceCategory,
       connection_type: input.connectionType,
+      integration_id: input.integrationId,
+      provider_config_key: input.providerConfigKey,
+      allowed_integrations: input.allowedIntegrations,
+      surface: input.surface,
+      source: input.source,
+      user_email: input.userEmail,
+      user_display_name: input.userDisplayName,
       status: input.status,
       metadata: input.metadata
     });
@@ -4381,6 +5747,20 @@ var GtmKernel = class {
       context: input.context
     });
   }
+  /** Create a short-lived Nango Connect session so a user can authorize a vendor API. */
+  async createNangoConnectSession(input) {
+    return this.callMcp("nango_connect_session_create", {
+      provider_id: input.providerId,
+      integration_id: input.integrationId,
+      provider_display_name: input.providerDisplayName,
+      integration_display_name: input.integrationDisplayName,
+      allowed_integrations: input.allowedIntegrations,
+      surface: input.surface,
+      source: input.source,
+      user_email: input.userEmail,
+      user_display_name: input.userDisplayName
+    });
+  }
   /** List Nango-backed action tools for a workspace connection without executing them. */
   async listNangoTools(options = {}) {
     return this.callMcp("nango_mcp_tools_list", {
@@ -4726,10 +6106,20 @@ export {
   SignalizError,
   Campaigns,
   DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS,
+  DEFAULT_CAMPAIGN_BUILDER_BUILT_INS,
+  DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES,
+  CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS,
+  CAMPAIGN_BUILDER_STRATEGY_TEMPLATES,
   CampaignBuilderAgent,
   createCampaignBuilderAgentPlan,
   getMissingCampaignBuilderApprovals,
   createCampaignBuilderApproval,
+  getCampaignBuilderStrategyTemplate,
+  getCampaignBuilderOperatingPlaybook,
+  getCampaignBuilderOperatingPlaybooksForRequest,
+  applyCampaignBuilderStrategyTemplate,
+  createCampaignBuilderAgentRequestTemplate,
+  createCampaignBuilderToolRoute,
   Icps,
   normalizeExecutionReference,
   collectExecutionReferences,