@signaliz/sdk 1.0.6 → 1.0.7

package/dist/cli.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 "use strict";
 
+// src/cli.ts
+var import_node_fs = require("fs");
+
 // src/errors.ts
 var SignalizError = class extends Error {
   constructor(data) {
@@ -754,7 +757,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);
   }
@@ -936,6 +939,10 @@ function mapStatus(data) {
     errors: diagnosticMessages(data.errors),
     artifactCount: data.artifact_count ?? 0,
     providerRoute: mapProviderRoute(data),
+    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,
@@ -1029,7 +1036,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,
@@ -1055,8 +1062,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;
@@ -1184,22 +1191,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({
@@ -1234,6 +1784,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,
@@ -1280,8 +1839,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"
@@ -1306,25 +1865,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,
@@ -1337,7 +1941,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 ?? []
   };
@@ -1358,6 +1963,256 @@ function getMissingCampaignBuilderApprovals(plan, approval) {
     return false;
   });
 }
+function createCampaignBuilderApproval(plan, input) {
+  return {
+    ...input,
+    planId: plan.planId,
+    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,
@@ -1370,12 +2225,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,
@@ -1384,40 +2236,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(
@@ -1435,7 +2377,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}.`
     }))
   );
 }
@@ -1480,6 +2422,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",
@@ -1489,7 +2432,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,
@@ -1530,6 +2473,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",
@@ -1662,6 +2612,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({
@@ -1675,6 +2666,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,
@@ -1686,7 +2696,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({
@@ -1695,8 +2705,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,
@@ -1758,9 +2768,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,
@@ -1782,6 +2982,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,
@@ -1962,8 +3182,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."
   ];
@@ -1986,6 +3206,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;
 }
@@ -3730,7 +4954,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,
@@ -4177,6 +5401,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", {
@@ -4192,21 +5450,100 @@ 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,
+      include_brain: input.includeBrain,
+      include_provider_routes: input.includeProviderRoutes,
+      include_failure_patterns: input.includeFailurePatterns,
+      include_planned_providers: input.includePlannedProviders,
+      days: input.days,
+      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", {
@@ -4353,6 +5690,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
     });
@@ -4409,6 +5753,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", {
@@ -4752,14 +6110,20 @@ var Signaliz = class {
 
 // src/cli.ts
 var apiKey = process.env.SIGNALIZ_API_KEY;
+var baseUrl = process.env.SIGNALIZ_BASE_URL || process.env.SIGNALIZ_API_URL;
 async function main() {
   const command = process.argv[2];
-  if (!apiKey) {
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  const offlineCampaignAgentTemplate = (command === "campaign-agent" || command === "campaign-builder") && ["init", "template", "request-template", "new"].includes(String(process.argv[3] || ""));
+  if (!apiKey && !offlineCampaignAgentTemplate) {
     console.error("\u274C SIGNALIZ_API_KEY environment variable is required.");
     console.error("   Set it with: export SIGNALIZ_API_KEY=sk_...");
     process.exit(1);
   }
-  const signaliz = new Signaliz({ apiKey });
+  const signaliz = new Signaliz({ apiKey: apiKey || "offline", baseUrl });
   switch (command) {
     case "test": {
       try {
@@ -4790,18 +6154,962 @@ async function main() {
       }
       break;
     }
+    case "gtm": {
+      await handleGtmCommand(signaliz, process.argv.slice(3));
+      break;
+    }
+    case "campaign-agent":
+    case "campaign-builder": {
+      await handleCampaignAgentCommand(signaliz, process.argv.slice(3));
+      break;
+    }
     default:
-      console.log(`
+      printHelp();
+  }
+}
+async function handleGtmCommand(signaliz, argv) {
+  const subcommand = argv[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printGtmHelp();
+    return;
+  }
+  if (subcommand === "context") {
+    const flags = parseFlags(argv.slice(1));
+    const result = await signaliz.gtm.context({
+      includeCampaigns: booleanFlag(flags, "include-campaigns"),
+      includeMemory: booleanFlag(flags, "include-memory"),
+      includeBrain: booleanFlag(flags, "include-brain"),
+      includeConnections: booleanFlag(flags, "include-connections"),
+      limit: numberFlag(flags, "limit")
+    });
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "bootstrap") {
+    const flags = parseFlags(argv.slice(1));
+    const result = await signaliz.gtm.bootstrapStatus({
+      campaignId: stringFlag(flags, "campaign-id"),
+      days: numberFlag(flags, "days"),
+      minSampleSize: numberFlag(flags, "min-sample-size"),
+      includeConnections: booleanFlag(flags, "include-connections"),
+      includeSamples: booleanFlag(flags, "include-samples"),
+      limit: numberFlag(flags, "limit")
+    });
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "memory" && argv[1] === "search") {
+    const flags = parseFlags(argv.slice(2));
+    const query = stringFlag(flags, "query", "q");
+    if (!query) throw new Error("gtm memory search requires --query");
+    const options = {
+      query,
+      campaignId: stringFlag(flags, "campaign-id"),
+      memoryType: stringFlag(flags, "memory-type"),
+      keywords: csvFlag(flags, "keywords"),
+      outcomeType: stringFlag(flags, "outcome-type"),
+      layers: csvFlag(flags, "layers"),
+      providerChain: csvFlag(flags, "provider-chain", "providers"),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.searchMemory(options);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "templates" || subcommand === "strategy-templates") {
+    const flags = parseFlags(argv.slice(1));
+    const result = await signaliz.gtm.campaignStrategyTemplates({
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      query: stringFlag(flags, "query", "q"),
+      includeDetails: !booleanFlag(flags, "summary")
+    });
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "start-context" || subcommand === "start") {
+    const flags = parseFlags(argv.slice(1));
+    const campaignBrief = stringFlag(flags, "brief", "campaign-brief", "goal");
+    const strategyTemplate = stringFlag(flags, "strategy-template", "template");
+    const targetIcp = jsonObjectFlag(flags, "target-icp", "icp");
+    if (!campaignBrief && !stringFlag(flags, "campaign-id") && !stringFlag(flags, "campaign-build-id") && !strategyTemplate && !targetIcp) {
+      throw new Error("gtm start-context requires --brief, --campaign-id, --campaign-build-id, --strategy-template, or --target-icp");
+    }
+    const input = {
+      campaignId: stringFlag(flags, "campaign-id"),
+      campaignBuildId: stringFlag(flags, "campaign-build-id"),
+      campaignBrief,
+      strategyTemplate,
+      targetIcp,
+      leadCount: numberFlag(flags, "lead-count", "target-count"),
+      layers: csvFlag(flags, "layers"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      memoryDimensionFilters: jsonObjectFlag(flags, "memory-dimension-filters"),
+      requireMemoryDimensionMatch: booleanFlag(flags, "require-memory-dimension-match"),
+      includeMemory: booleanFlag(flags, "include-memory", true),
+      includeBrain: booleanFlag(flags, "include-brain", true),
+      includeProviderRoutes: booleanFlag(flags, "include-provider-routes", true),
+      includeFailurePatterns: booleanFlag(flags, "include-failure-patterns", true),
+      includeDeliveryRisk: booleanFlag(flags, "include-delivery-risk", true),
+      includeGlobalBrain: booleanFlag(flags, "include-global-brain", true),
+      includePlannedProviders: booleanFlag(flags, "include-planned-providers", true),
+      days: numberFlag(flags, "days"),
+      minConfidence: numberFlag(flags, "min-confidence"),
+      minSampleSize: numberFlag(flags, "min-sample-size"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignStartContext(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "strategy-memory" || subcommand === "memory-status" || subcommand === "strategy-memory-status") {
+    const flags = parseFlags(argv.slice(1));
+    const input = {
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      query: stringFlag(flags, "query", "goal", "q"),
+      campaignBrief: stringFlag(flags, "brief", "campaign-brief"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      memoryDimensionFilters: jsonObjectFlag(flags, "memory-dimension-filters"),
+      requireMemoryDimensionMatch: booleanFlag(flags, "require-memory-dimension-match"),
+      includeSamples: booleanFlag(flags, "include-samples"),
+      includeSources: !booleanFlag(flags, "no-sources"),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignStrategyMemoryStatus(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "plan") {
+    const flags = parseFlags(argv.slice(1));
+    const campaignBrief = stringFlag(flags, "brief", "campaign-brief", "goal");
+    if (!campaignBrief && !stringFlag(flags, "campaign-id") && !stringFlag(flags, "campaign-build-id")) {
+      throw new Error("gtm plan requires --brief, --campaign-id, or --campaign-build-id");
+    }
+    const input = {
+      campaignId: stringFlag(flags, "campaign-id"),
+      campaignBuildId: stringFlag(flags, "campaign-build-id"),
+      campaignBrief,
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      leadCount: numberFlag(flags, "lead-count", "target-count"),
+      layers: csvFlag(flags, "layers"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      strategyModel: stringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !booleanFlag(flags, "no-strategy-patterns") && !booleanFlag(flags, "no-agency-patterns"),
+      includeWorkflowPatterns: !booleanFlag(flags, "no-workflow-patterns") && !booleanFlag(flags, "no-clay-patterns"),
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: csvFlag(flags, "partner-ecosystem", "partners"),
+      includeMemory: booleanFlag(flags, "include-memory", true),
+      includeBrain: booleanFlag(flags, "include-brain", true),
+      includeProviderRoutes: booleanFlag(flags, "include-provider-routes", true),
+      includeFailurePatterns: booleanFlag(flags, "include-failure-patterns", true),
+      includePlannedProviders: booleanFlag(flags, "include-planned-providers", true),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignBuildPlan(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "agent-plan" || subcommand === "campaign-agent-plan") {
+    const flags = parseFlags(argv.slice(1));
+    const goal = stringFlag(flags, "goal", "brief", "campaign-brief");
+    if (!goal && !stringFlag(flags, "campaign-id") && !stringFlag(flags, "campaign-build-id") && !stringFlag(flags, "strategy-template", "template")) {
+      throw new Error("gtm agent-plan requires --goal, --campaign-id, --campaign-build-id, or --strategy-template");
+    }
+    const input = {
+      goal,
+      campaignName: stringFlag(flags, "campaign-name", "name"),
+      campaignId: stringFlag(flags, "campaign-id"),
+      campaignBuildId: stringFlag(flags, "campaign-build-id", "build-id"),
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      operatingPlaybooks: csvFlag(flags, "operating-playbooks", "playbooks"),
+      accountContext: stringFlag(flags, "account-context", "workspace-context"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      targetCount: numberFlag(flags, "target-count", "lead-count"),
+      builtIns: campaignAgentBuiltInsFromFlags(flags),
+      useLocalLeads: booleanFlag(flags, "use-local-leads") || void 0,
+      layers: csvFlag(flags, "layers"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      customTools: campaignAgentCustomToolRoutesFromFlags(flags),
+      strategyModel: stringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !booleanFlag(flags, "no-strategy-patterns"),
+      includeWorkflowPatterns: !booleanFlag(flags, "no-workflow-patterns"),
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: csvFlag(flags, "partner-ecosystem", "partners"),
+      includeMemory: !booleanFlag(flags, "no-memory"),
+      includeBrain: !booleanFlag(flags, "no-brain"),
+      includeProviderRoutes: !booleanFlag(flags, "no-provider-routes"),
+      includeFailurePatterns: !booleanFlag(flags, "no-failure-patterns"),
+      includeDeliveryRisk: !booleanFlag(flags, "no-delivery-risk"),
+      includePlannedProviders: !booleanFlag(flags, "no-planned-providers"),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignAgentPlan(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "agent-template" || subcommand === "campaign-agent-template" || subcommand === "request-template") {
+    const flags = parseFlags(argv.slice(1));
+    const input = {
+      goal: stringFlag(flags, "goal", "brief", "campaign-brief"),
+      campaignName: stringFlag(flags, "campaign-name", "name"),
+      accountLabel: stringFlag(flags, "workspace-label", "account-label"),
+      accountContext: stringFlag(flags, "account-context", "workspace-context"),
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      operatingPlaybooks: csvFlag(flags, "operating-playbooks", "playbooks"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      targetCount: numberFlag(flags, "target-count", "lead-count"),
+      builtIns: campaignAgentBuiltInsFromFlags(flags),
+      includeLocalLeads: booleanFlag(flags, "use-local-leads") || booleanFlag(flags, "include-local-leads") || void 0,
+      includeByoPlaceholder: booleanFlag(flags, "with-byo-placeholder") || booleanFlag(flags, "include-byo-placeholder") || void 0,
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      privacyMode: stringFlag(flags, "privacy-mode"),
+      destinationType: stringFlag(flags, "destination", "destination-type")
+    };
+    const result = await signaliz.gtm.campaignAgentRequestTemplate(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "provider-prepare" || subcommand === "prepare-provider" || subcommand === "recipe-prepare" || subcommand === "prepare-recipe") {
+    const flags = parseFlags(argv.slice(1));
+    const providerId = stringFlag(flags, "provider-id", "provider") || argv[1];
+    if (!providerId) {
+      throw new Error("gtm provider-prepare requires --provider-id or provider id");
+    }
+    const input = {
+      providerId,
+      providerName: stringFlag(flags, "provider-name", "name"),
+      description: stringFlag(flags, "description"),
+      layerCapabilities: csvFlag(flags, "layer-capabilities", "layers"),
+      invocationType: stringFlag(flags, "invocation-type"),
+      authStrategy: stringFlag(flags, "auth-strategy"),
+      endpointUrl: stringFlag(flags, "endpoint-url"),
+      httpMethod: stringFlag(flags, "http-method") || void 0,
+      secretRef: stringFlag(flags, "secret-ref"),
+      workspaceIntegrationId: stringFlag(flags, "workspace-integration-id"),
+      workspaceMcpServerId: stringFlag(flags, "workspace-mcp-server-id"),
+      workspaceConnectionId: stringFlag(flags, "workspace-connection-id"),
+      requestTemplate: jsonObjectFlag(flags, "request-template"),
+      responseMapping: jsonObjectFlag(flags, "response-mapping"),
+      inputSchema: jsonObjectFlag(flags, "input-schema"),
+      outputSchema: jsonObjectFlag(flags, "output-schema"),
+      readiness: jsonObjectFlag(flags, "readiness"),
+      metadata: jsonObjectFlag(flags, "metadata"),
+      layer: stringFlag(flags, "layer"),
+      campaignId: stringFlag(flags, "campaign-id"),
+      useSignalizFallback: !booleanFlag(flags, "no-signaliz-fallback"),
+      priority: numberFlag(flags, "priority"),
+      status: stringFlag(flags, "status"),
+      context: jsonObjectFlag(flags, "context")
+    };
+    const result = await signaliz.gtm.prepareProviderRecipe(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "activate-route" || subcommand === "route-activate") {
+    const flags = parseFlags(argv.slice(1));
+    const providerId = stringFlag(flags, "provider-id", "provider") || argv[1];
+    if (!providerId) {
+      throw new Error("gtm activate-route requires --provider-id or provider id");
+    }
+    const layers = csvFlag(flags, "layers");
+    const layer = stringFlag(flags, "layer");
+    if (!layer && !layers?.length) {
+      throw new Error("gtm activate-route requires --layer or --layers");
+    }
+    const confirm = booleanFlag(flags, "confirm");
+    const input = {
+      providerId,
+      providerName: stringFlag(flags, "provider-name", "name"),
+      description: stringFlag(flags, "description"),
+      campaignId: stringFlag(flags, "campaign-id"),
+      layer,
+      layers,
+      invocationType: stringFlag(flags, "invocation-type"),
+      authStrategy: stringFlag(flags, "auth-strategy"),
+      endpointUrl: stringFlag(flags, "endpoint-url"),
+      httpMethod: stringFlag(flags, "http-method") || void 0,
+      secretRef: stringFlag(flags, "secret-ref"),
+      workspaceIntegrationId: stringFlag(flags, "workspace-integration-id"),
+      workspaceMcpServerId: stringFlag(flags, "workspace-mcp-server-id"),
+      workspaceConnectionId: stringFlag(flags, "workspace-connection-id"),
+      useSignalizFallback: !booleanFlag(flags, "no-signaliz-fallback"),
+      priority: numberFlag(flags, "priority"),
+      routeConfig: jsonObjectFlag(flags, "route-config"),
+      requestTemplate: jsonObjectFlag(flags, "request-template"),
+      responseMapping: jsonObjectFlag(flags, "response-mapping"),
+      inputSchema: jsonObjectFlag(flags, "input-schema"),
+      outputSchema: jsonObjectFlag(flags, "output-schema"),
+      readiness: jsonObjectFlag(flags, "readiness"),
+      metadata: jsonObjectFlag(flags, "metadata"),
+      status: stringFlag(flags, "status"),
+      routeStatus: stringFlag(flags, "route-status"),
+      replaceExistingRoutes: !booleanFlag(flags, "keep-existing-routes"),
+      dryRun: !confirm,
+      confirm,
+      context: jsonObjectFlag(flags, "context")
+    };
+    const result = await signaliz.gtm.activateProviderRoute(input);
+    printResult(result, flags);
+    return;
+  }
+  printGtmHelp();
+}
+async function handleCampaignAgentCommand(signaliz, argv) {
+  const subcommand = argv[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printCampaignAgentHelp();
+    return;
+  }
+  if (["init", "template", "request-template", "new"].includes(subcommand)) {
+    const flags2 = parseFlags(argv.slice(1));
+    const request2 = campaignAgentRequestTemplateFromFlags(flags2);
+    const outputFile = stringFlag(flags2, "output-file", "out");
+    if (outputFile) {
+      (0, import_node_fs.writeFileSync)(outputFile, `${JSON.stringify(request2, null, 2)}
+`, "utf8");
+    }
+    if (booleanFlag(flags2, "json") || !outputFile) {
+      printJson(request2);
+    } else {
+      console.log(`Campaign request template written: ${outputFile}`);
+      console.log(`Next: signaliz campaign-agent plan --request-file ${outputFile} --json`);
+    }
+    return;
+  }
+  if (!["plan", "proof", "smoke", "commit-plan", "dry-run", "build-approved", "launch-approved"].includes(subcommand)) {
+    printCampaignAgentHelp();
+    return;
+  }
+  const flags = parseFlags(argv.slice(1));
+  const requestFromFile = campaignAgentRequestFileFromFlags(flags);
+  const goal = stringFlag(flags, "goal", "brief") ?? stringOrUndefined(requestFromFile?.goal);
+  if (!goal) throw new Error(`campaign-agent ${subcommand} requires --goal or a request file with goal`);
+  const isApprovedBuild = subcommand === "build-approved" || subcommand === "launch-approved";
+  const isCommitPlan = subcommand === "commit-plan";
+  const isConfirmedCommit = isCommitPlan && booleanFlag(flags, "confirm-write");
+  const approvedBy = stringFlag(flags, "approved-by");
+  if (isApprovedBuild) {
+    if (!booleanFlag(flags, "confirm-launch")) {
+      throw new Error(`campaign-agent ${subcommand} requires --confirm-launch`);
+    }
+    if (!approvedBy) throw new Error(`campaign-agent ${subcommand} requires --approved-by`);
+  }
+  if (isConfirmedCommit && !approvedBy) {
+    throw new Error("campaign-agent commit-plan --confirm-write requires --approved-by");
+  }
+  const request = mergeCampaignAgentRequests(
+    requestFromFile,
+    campaignAgentRequestFromFlags(goal, flags, { includeDefaults: !requestFromFile })
+  );
+  const plan = await signaliz.campaignBuilderAgent.createPlan(request, {
+    discoverCapabilities: !booleanFlag(flags, "skip-discovery"),
+    scopeCampaign: !booleanFlag(flags, "skip-scope"),
+    includeStrategyMemoryStatus: !booleanFlag(flags, "no-strategy-memory"),
+    includeKernelPlan: !booleanFlag(flags, "no-kernel-plan"),
+    includeDeliveryRisk: !booleanFlag(flags, "no-delivery-risk")
+  });
+  if (subcommand === "proof" || subcommand === "smoke") {
+    const result = await signaliz.campaignBuilderAgent.dryRunPlan(plan, {
+      idempotencyKey: stringFlag(flags, "idempotency-key")
+    });
+    const proof = createCampaignAgentProofReceipt(plan, result);
+    if (booleanFlag(flags, "json")) {
+      printJson(proof);
+    } else {
+      printCampaignAgentProof(proof);
+    }
+    if (!proof.success) process.exitCode = 1;
+    return;
+  }
+  if (isCommitPlan) {
+    const result = await signaliz.campaignBuilderAgent.commitPlan(plan, {
+      confirm: isConfirmedCommit,
+      dryRun: !isConfirmedCommit,
+      approvedBy,
+      idempotencyKey: stringFlag(flags, "idempotency-key"),
+      rationale: stringFlag(flags, "rationale")
+    });
+    printCampaignAgentExecution({ plan, result }, flags);
+    return;
+  }
+  if (subcommand === "dry-run") {
+    const result = await signaliz.campaignBuilderAgent.dryRunPlan(plan, {
+      idempotencyKey: stringFlag(flags, "idempotency-key")
+    });
+    printCampaignAgentExecution({ plan, result }, flags);
+    return;
+  }
+  if (isApprovedBuild) {
+    const approvedTypes = approvedTypesFromFlags(plan, flags);
+    const approval = createCampaignBuilderApproval(plan, {
+      approvedBy,
+      approvedTypes,
+      spendLimitCredits: numberFlag(flags, "spend-limit", "spend-limit-credits", "max-credits"),
+      approvedRouteIds: approvedRouteIdsFromFlags(plan, flags),
+      notes: stringFlag(flags, "approval-notes", "notes")
+    });
+    const result = await signaliz.campaignBuilderAgent.buildApprovedPlan(plan, approval, {
+      idempotencyKey: stringFlag(flags, "idempotency-key"),
+      commitBeforeLaunch: booleanFlag(flags, "commit-before-launch")
+    });
+    printCampaignAgentExecution({ plan, approval, result }, flags);
+    return;
+  }
+  if (booleanFlag(flags, "json")) {
+    printJson(plan);
+  } else {
+    printCampaignAgentPlan(plan);
+  }
+}
+function campaignAgentRequestTemplateFromFlags(flags) {
+  const goal = stringFlag(flags, "goal", "brief") || "Build a strategy-template campaign for mature operators in the target ICP.";
+  const request = campaignAgentRequestFromFlags(goal, flags, { includeDefaults: true });
+  const options = {
+    ...request,
+    includeLocalLeads: booleanFlag(flags, "use-local-leads"),
+    includeCustomToolPlaceholder: booleanFlag(flags, "with-byo-placeholder") || booleanFlag(flags, "include-custom-tool-placeholder") || booleanFlag(flags, "include-byo-placeholder"),
+    includeNango: !booleanFlag(flags, "no-nango-catalog")
+  };
+  return createCampaignBuilderAgentRequestTemplate(options);
+}
+function campaignAgentRequestFileFromFlags(flags) {
+  const file = stringFlag(flags, "request-file", "input-file", "campaign-file");
+  if (!file) return void 0;
+  const parsed = JSON.parse((0, import_node_fs.readFileSync)(file, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected JSON object for --request-file`);
+  }
+  return parsed;
+}
+function campaignAgentRequestFromFlags(goal, flags, options = {}) {
+  const builtIns = campaignAgentBuiltInsFromFlags(flags);
+  const integrations = campaignAgentCustomToolRoutesFromFlags(flags);
+  const includeDefaults = options.includeDefaults !== false;
+  const request = {
+    goal,
+    campaignName: stringFlag(flags, "campaign-name", "name"),
+    accountLabel: stringFlag(flags, "workspace-label", "account-label"),
+    strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+    accountContext: stringFlag(flags, "account-context", "workspace-context"),
+    targetCount: numberFlag(flags, "target-count", "lead-count"),
+    gtmCampaignId: stringFlag(flags, "gtm-campaign-id", "campaign-id"),
+    icp: jsonObjectFlag(flags, "icp", "target-icp"),
+    brainDefaults: jsonObjectFlag(flags, "brain-defaults"),
+    deliveryRisk: jsonObjectFlag(flags, "delivery-risk"),
+    builtIns,
+    operatingPlaybooks: csvFlag(flags, "operating-playbooks", "playbooks"),
+    integrations,
+    preferredProviders: csvFlag(flags, "preferred-providers", "providers")
+  };
+  if (includeDefaults || flagValue(flags, "strategy-model", "no-strategy-patterns", "no-agency-patterns", "no-workflow-patterns", "no-clay-patterns", "no-nango-catalog", "partners", "revenue-motion") !== void 0) {
+    request.agencyContext = {
+      strategyModel: stringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !booleanFlag(flags, "no-strategy-patterns") && !booleanFlag(flags, "no-agency-patterns"),
+      includeWorkflowPatterns: !booleanFlag(flags, "no-workflow-patterns") && !booleanFlag(flags, "no-clay-patterns"),
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: csvFlag(flags, "partners"),
+      revenueMotion: stringFlag(flags, "revenue-motion")
+    };
+  }
+  if (includeDefaults || flagValue(flags, "no-memory", "no-workspace-history", "use-network-patterns", "privacy-mode") !== void 0) {
+    request.memory = {
+      enabled: !booleanFlag(flags, "no-memory"),
+      useWorkspaceHistory: !booleanFlag(flags, "no-workspace-history"),
+      useNetworkPatterns: booleanFlag(flags, "use-network-patterns"),
+      privacyMode: stringFlag(flags, "privacy-mode")
+    };
+  }
+  if (includeDefaults || flagValue(flags, "max-credits", "no-delivery", "destination") !== void 0) {
+    request.signalizDefaults = {
+      maxCredits: numberFlag(flags, "max-credits"),
+      delivery: {
+        enabled: !booleanFlag(flags, "no-delivery"),
+        destinationType: stringFlag(flags, "destination"),
+        approvalRequired: true
+      }
+    };
+  }
+  if (includeDefaults || flagValue(flags, "no-human-approval", "max-credits-without-approval") !== void 0) {
+    request.approvalPolicy = {
+      requireHumanApproval: !booleanFlag(flags, "no-human-approval"),
+      maxCreditsWithoutApproval: numberFlag(flags, "max-credits-without-approval"),
+      requireApprovalFor: ["memory_retrieval", "spend", "customer_tool", "external_write", "delivery", "launch"]
+    };
+  }
+  return compactRequest(request);
+}
+function mergeCampaignAgentRequests(base, override) {
+  if (!base) return override;
+  return compactRequest({
+    ...base,
+    ...override,
+    icp: mergeRecords(base.icp, override.icp),
+    memory: mergeRecords(base.memory, override.memory),
+    agencyContext: mergeRecords(base.agencyContext, override.agencyContext),
+    signalizDefaults: mergeRecords(base.signalizDefaults, override.signalizDefaults),
+    approvalPolicy: mergeRecords(base.approvalPolicy, override.approvalPolicy),
+    constraints: mergeRecords(base.constraints, override.constraints),
+    workspaceContext: mergeRecords(base.workspaceContext, override.workspaceContext),
+    builtIns: override.builtIns ?? base.builtIns,
+    operatingPlaybooks: override.operatingPlaybooks ?? base.operatingPlaybooks,
+    integrations: override.integrations ?? base.integrations,
+    customerTools: override.customerTools ?? base.customerTools,
+    preferredProviders: override.preferredProviders ?? base.preferredProviders
+  });
+}
+function mergeRecords(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  if (typeof base === "object" && typeof override === "object" && !Array.isArray(base) && !Array.isArray(override)) {
+    return { ...base, ...override };
+  }
+  return override;
+}
+function compactRequest(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([, value]) => value !== void 0)
+  );
+}
+function campaignAgentBuiltInsFromFlags(flags) {
+  const explicit = csvFlag(flags, "builtins", "builtin-tools", "signaliz-tools");
+  const hasBuiltinFlag = Boolean(
+    explicit?.length || flagValue(flags, "use-local-leads") !== void 0 || flagValue(flags, "no-lead-generation") !== void 0 || flagValue(flags, "no-email-finding") !== void 0 || flagValue(flags, "no-verification") !== void 0 || flagValue(flags, "no-signals") !== void 0
+  );
+  if (!hasBuiltinFlag) return void 0;
+  const builtIns = new Set(
+    explicit?.length ? explicit : ["lead_generation", "email_finding", "email_verification", "signals"]
+  );
+  if (booleanFlag(flags, "use-local-leads")) builtIns.add("local_leads");
+  if (booleanFlag(flags, "no-lead-generation")) builtIns.delete("lead_generation");
+  if (booleanFlag(flags, "no-email-finding")) builtIns.delete("email_finding");
+  if (booleanFlag(flags, "no-verification")) builtIns.delete("email_verification");
+  if (booleanFlag(flags, "no-signals")) builtIns.delete("signals");
+  return [...builtIns];
+}
+function campaignAgentCustomToolRoutesFromFlags(flags) {
+  const values = repeatedStringFlag(flags, "custom-tool", "customer-tool", "byo-tool", "integration-route");
+  const routes = values.map(parseCampaignAgentCustomToolRoute);
+  return routes.length > 0 ? routes : void 0;
+}
+function parseCampaignAgentCustomToolRoute(raw) {
+  const record = raw.trim().startsWith("{") ? jsonObjectFromString(raw, "--custom-tool") : raw.includes("=") ? keyValueObject(raw) : colonRouteObject(raw);
+  const layer = normalizeCampaignBuilderLayer(String(record.layer ?? record.use_for_layer ?? record.useForLayer ?? "enrichment"));
+  const gtmLayers = stringArrayValue(record.gtm_layers ?? record.gtmLayers ?? record.capabilities);
+  const provider = String(record.provider ?? record.provider_id ?? record.providerId ?? "custom_mcp");
+  const toolName = stringOrUndefined(record.tool ?? record.tool_name ?? record.toolName);
+  const label = stringOrUndefined(record.label ?? record.name) ?? provider;
+  const mcpServerName = stringOrUndefined(record.mcp ?? record.server ?? record.mcp_server_name ?? record.mcpServerName);
+  const mode = normalizeRouteMode(String(record.mode ?? "required"));
+  return {
+    provider,
+    layer,
+    gtmLayers,
+    mode,
+    toolName,
+    mcpServerName,
+    label,
+    approvalRequired: optionalBoolean(record.approval_required ?? record.approvalRequired, true),
+    config: {
+      provider_id: record.provider_id ?? record.providerId,
+      available_tools: stringArrayValue(record.available_tools ?? record.availableTools ?? record.tools),
+      raw: raw.trim()
+    },
+    rationale: `${label} is a user-provided campaign-builder route declared from the CLI.`
+  };
+}
+function colonRouteObject(raw) {
+  const [provider, layer, tool, mcp] = raw.split(":").map((part) => part.trim()).filter(Boolean);
+  if (!provider || !layer) {
+    throw new Error("Expected --custom-tool provider:layer:tool[:mcp] or key=value pairs");
+  }
+  return { provider, layer, tool, mcp };
+}
+function keyValueObject(raw) {
+  const record = {};
+  for (const segment of raw.split(",")) {
+    const eq = segment.indexOf("=");
+    if (eq < 0) continue;
+    const key = segment.slice(0, eq).trim().replace(/-/g, "_");
+    const value = segment.slice(eq + 1).trim();
+    record[key] = value;
+  }
+  return record;
+}
+function normalizeCampaignBuilderLayer(value) {
+  const normalized = normalizeEnumValue(value);
+  const allowed = ["workspace_context", "memory", "source", "enrichment", "qualification", "copy", "delivery", "feedback", "approval"];
+  if (!allowed.includes(normalized)) {
+    throw new Error(`Unknown campaign-builder layer "${value}". Use source, enrichment, qualification, copy, delivery, feedback, or approval.`);
+  }
+  return normalized;
+}
+function normalizeRouteMode(value) {
+  const normalized = normalizeEnumValue(value);
+  return ["required", "if_available", "fallback", "disabled"].includes(normalized) ? normalized : "required";
+}
+function normalizeEnumValue(value) {
+  return value.trim().toLowerCase().replace(/-/g, "_");
+}
+function stringArrayValue(value) {
+  const values = Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  const parsed = values.flatMap((item) => String(item).split(/[|,]/).map((part) => part.trim()).filter(Boolean));
+  return parsed.length > 0 ? parsed : void 0;
+}
+function stringOrUndefined(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function optionalBoolean(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  return parseBoolean(String(value), defaultValue);
+}
+function approvedTypesFromFlags(plan, flags) {
+  const requested = csvFlag(flags, "approved-types", "approve-types");
+  if (requested?.length) return requested;
+  if (!booleanFlag(flags, "approve-all")) {
+    throw new Error("campaign-agent build-approved requires --approve-all or --approved-types");
+  }
+  return [...new Set(plan.approvals.map((item) => item.type))];
+}
+function approvedRouteIdsFromFlags(plan, flags) {
+  const requested = csvFlag(flags, "approved-route-ids", "route-ids");
+  if (requested?.length) return requested;
+  if (!booleanFlag(flags, "approve-all")) return void 0;
+  const routeIds = plan.approvals.map((item) => item.routeId).filter((id) => Boolean(id));
+  return routeIds.length > 0 ? routeIds : void 0;
+}
+function parseFlags(argv) {
+  const flags = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token.startsWith("--")) continue;
+    const eq = token.indexOf("=");
+    const key = normalizeFlagName(eq >= 0 ? token.slice(2, eq) : token.slice(2));
+    const value = eq >= 0 ? token.slice(eq + 1) : argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[++i] : true;
+    const existing = flags[key];
+    if (existing === void 0) {
+      flags[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(String(value));
+    } else {
+      flags[key] = [String(existing), String(value)];
+    }
+  }
+  return flags;
+}
+function normalizeFlagName(name) {
+  return name.replace(/_/g, "-");
+}
+function flagValue(flags, ...names) {
+  for (const name of names.map(normalizeFlagName)) {
+    if (flags[name] !== void 0) return flags[name];
+  }
+  return void 0;
+}
+function stringFlag(flags, ...names) {
+  const value = flagValue(flags, ...names);
+  if (Array.isArray(value)) return value.at(-1);
+  if (value === void 0 || value === true || value === false) return void 0;
+  const trimmed = String(value).trim();
+  return trimmed || void 0;
+}
+function numberFlag(flags, ...names) {
+  const value = stringFlag(flags, ...names);
+  if (!value) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new Error(`Expected numeric value for --${names[0]}`);
+  return parsed;
+}
+function booleanFlag(flags, name, defaultValue = false) {
+  const value = flagValue(flags, name);
+  if (value === void 0) return defaultValue;
+  if (Array.isArray(value)) return value.length > 0 ? parseBoolean(value.at(-1), defaultValue) : defaultValue;
+  return parseBoolean(value, defaultValue);
+}
+function parseBoolean(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  return !["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function csvFlag(flags, ...names) {
+  const value = flagValue(flags, ...names);
+  const values = Array.isArray(value) ? value : value === void 0 || typeof value === "boolean" ? [] : [value];
+  const parsed = values.flatMap((item) => String(item).split(",").map((part) => part.trim()).filter(Boolean));
+  return parsed.length > 0 ? parsed : void 0;
+}
+function repeatedStringFlag(flags, ...names) {
+  const value = flagValue(flags, ...names);
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  if (value === void 0 || typeof value === "boolean") return [];
+  const trimmed = String(value).trim();
+  return trimmed ? [trimmed] : [];
+}
+function jsonObjectFlag(flags, ...names) {
+  const value = stringFlag(flags, ...names);
+  if (!value) return void 0;
+  return jsonObjectFromString(value, `--${names[0]}`);
+}
+function jsonObjectFromString(value, label) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected JSON object for ${label}`);
+  }
+  return parsed;
+}
+function printResult(result, flags) {
+  if (booleanFlag(flags, "json")) {
+    printJson(result);
+    return;
+  }
+  if (result && typeof result === "object") {
+    const record = result;
+    const title = record.summary || record.message || record.next_action || record.status;
+    if (title) console.log(String(title));
+    printJson(result);
+    return;
+  }
+  console.log(String(result ?? ""));
+}
+function printCampaignAgentPlan(plan) {
+  console.log(`Plan: ${plan.campaignName}`);
+  console.log(`Plan ID: ${plan.planId}`);
+  console.log(`Target: ${plan.targetCount}`);
+  console.log(`Estimated credits: ${plan.estimatedCredits}`);
+  console.log(`Memory: ${plan.memory.enabled ? plan.memory.privacyMode : "disabled"}`);
+  console.log(`Playbooks: ${plan.operatingPlaybooks.map((item) => item.slug).join(", ") || "none"}`);
+  console.log(`Strategy memory: ${plan.strategyMemoryStatus ? plan.strategyMemoryStatus.ready === false ? "needs seeding" : "ready" : "not loaded"}`);
+  console.log(`Kernel plan: ${plan.kernelPlan ? "loaded" : "not loaded"}`);
+  console.log(`Approvals: ${plan.approvals.map((item) => item.type).join(", ") || "none"}`);
+  if (plan.warnings.length > 0) {
+    console.log(`Warnings: ${plan.warnings.join("; ")}`);
+  }
+  console.log("\nMCP flow:");
+  for (const step of plan.mcpFlow) {
+    console.log(`- ${step.id}: ${step.tool}${step.approvalRequired ? " (approval required)" : ""}`);
+  }
+}
+function printCampaignAgentExecution(payload, flags) {
+  if (booleanFlag(flags, "json")) {
+    printJson(payload);
+    return;
+  }
+  printCampaignAgentPlan(payload.plan);
+  console.log("\nResult:");
+  printJson(payload.result);
+}
+function asRecord4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function createCampaignAgentProofReceipt(plan, result) {
+  const strategyMemory = asRecord4(plan.strategyMemoryStatus);
+  const dryRunResult = asRecord4(result);
+  const memoryReady = plan.strategyMemoryStatus ? strategyMemory.ready !== false : false;
+  const dryRunCompleted = dryRunResult.dryRun === true || dryRunResult.dry_run === true || dryRunResult.status === "dry_run";
+  const noLaunch = dryRunCompleted && !dryRunResult.campaignBuildId && !dryRunResult.campaign_build_id;
+  const gates = [
+    {
+      id: "strategy_memory_ready",
+      passed: memoryReady,
+      ready: strategyMemory.ready ?? null,
+      blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0
+    },
+    {
+      id: "campaign_plan_ready",
+      passed: Boolean(plan.planId && plan.mcpFlow.length > 0),
+      plan_id: plan.planId,
+      flow_steps: plan.mcpFlow.length
+    },
+    {
+      id: "approval_gates_present",
+      passed: plan.approvals.length > 0,
+      approval_types: plan.approvals.map((approval) => approval.type)
+    },
+    {
+      id: "dry_run_completed",
+      passed: dryRunCompleted,
+      status: dryRunResult.status ?? null,
+      current_phase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null
+    },
+    {
+      id: "no_spendful_launch",
+      passed: noLaunch,
+      campaign_build_id: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null
+    }
+  ];
+  return {
+    receipt_version: "campaign-agent-proof.v1",
+    source: "signaliz campaign-agent proof",
+    success: gates.every((gate) => gate.passed),
+    safety: {
+      spendful_tools_called: false,
+      external_writes_called: false,
+      sender_loads_called: false,
+      email_sends_called: false,
+      dry_run_only: true
+    },
+    campaign: {
+      plan_id: plan.planId,
+      campaign_name: plan.campaignName,
+      strategy_template: campaignAgentStrategyTemplate(plan),
+      target_count: plan.targetCount,
+      estimated_credits: plan.estimatedCredits,
+      operating_playbooks: plan.operatingPlaybooks.map((playbook) => playbook.slug)
+    },
+    gates,
+    strategy_memory_status: summarizeCampaignAgentStrategyMemory(strategyMemory),
+    dry_run_result: summarizeCampaignAgentDryRun(dryRunResult),
+    recommended_next_actions: [
+      "Review the plan, approvals, and dry-run result.",
+      "Use campaign-agent commit-plan --confirm-write only after review.",
+      "Use campaign-agent build-approved only with --confirm-launch, approval identity, approval types, and spend limit."
+    ]
+  };
+}
+function campaignAgentString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return null;
+}
+function campaignAgentStrategyTemplate(plan) {
+  const buildRequest = asRecord4(plan.buildRequest);
+  const strategyMemory = asRecord4(plan.strategyMemoryStatus);
+  const statusTemplate = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
+  const statusTemplateRecord = asRecord4(statusTemplate);
+  const flowTemplate = plan.mcpFlow.map((step) => asRecord4(step.arguments).strategy_template ?? asRecord4(step.arguments).strategyTemplate).find((value) => typeof value === "string" && value.trim());
+  return campaignAgentString(
+    buildRequest.strategyTemplate,
+    buildRequest.strategy_template,
+    statusTemplate,
+    statusTemplateRecord.slug,
+    statusTemplateRecord.id,
+    flowTemplate
+  );
+}
+function summarizeCampaignAgentStrategyMemory(strategyMemory) {
+  if (Object.keys(strategyMemory).length === 0) return { ready: false };
+  const template = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
+  const templateRecord = asRecord4(template);
+  const coverage = asRecord4(strategyMemory.coverage);
+  const rawSourceGroups = Array.isArray(strategyMemory.source_groups) ? strategyMemory.source_groups : Array.isArray(strategyMemory.sourceGroups) ? strategyMemory.sourceGroups : [];
+  const sourceGroups = rawSourceGroups.map((group) => {
+    const sourceGroup = asRecord4(group);
+    return {
+      id: sourceGroup.id ?? null,
+      required: sourceGroup.required ?? null,
+      ready: sourceGroup.ready ?? null,
+      counts: asRecord4(sourceGroup.counts)
+    };
+  });
+  return {
+    ready: strategyMemory.ready ?? null,
+    read_only: strategyMemory.read_only ?? strategyMemory.readOnly ?? null,
+    source_tool: campaignAgentString(strategyMemory.source_tool, strategyMemory.sourceTool),
+    strategy_template: {
+      slug: campaignAgentString(template, templateRecord.slug, templateRecord.id),
+      label: campaignAgentString(templateRecord.label)
+    },
+    coverage: {
+      required_groups_ready: coverage.required_groups_ready ?? coverage.requiredGroupsReady ?? null,
+      required_groups_total: coverage.required_groups_total ?? coverage.requiredGroupsTotal ?? null,
+      source_groups_ready: coverage.source_groups_ready ?? coverage.sourceGroupsReady ?? null,
+      source_groups_total: coverage.source_groups_total ?? coverage.sourceGroupsTotal ?? null,
+      knowledge_docs: coverage.knowledge_docs ?? coverage.knowledgeDocs ?? null,
+      memories: coverage.memories ?? null
+    },
+    source_groups: sourceGroups,
+    blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0,
+    warning_count: Array.isArray(strategyMemory.warnings) ? strategyMemory.warnings.length : 0
+  };
+}
+function summarizeCampaignAgentDryRun(dryRunResult) {
+  return {
+    dryRun: dryRunResult.dryRun ?? dryRunResult.dry_run ?? null,
+    status: dryRunResult.status ?? null,
+    currentPhase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null,
+    campaignBuildId: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null,
+    plannedTargetCount: dryRunResult.plannedTargetCount ?? dryRunResult.planned_target_count ?? null
+  };
+}
+function printCampaignAgentProof(proof) {
+  console.log(`Campaign-agent proof: ${proof.success ? "passed" : "failed"}`);
+  const campaign = asRecord4(proof.campaign);
+  if (campaign.plan_id) console.log(`Plan ID: ${campaign.plan_id}`);
+  if (campaign.strategy_template) console.log(`Strategy template: ${campaign.strategy_template}`);
+  if (campaign.target_count !== void 0) console.log(`Target: ${campaign.target_count}`);
+  console.log("\nGates:");
+  const gates = Array.isArray(proof.gates) ? proof.gates : [];
+  for (const gate of gates) {
+    const gateRecord = asRecord4(gate);
+    console.log(`- ${gateRecord.id}: ${gateRecord.passed ? "passed" : "failed"}`);
+  }
+  console.log("\nSafety: dry-run only; no spendful launch, external write, sender load, or email send.");
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function printHelp() {
+  console.log(`
 Signaliz CLI v1.0.0
 
 Usage:
-  signaliz test    Verify API connectivity
-  signaliz tools   List all available MCP tools
+  signaliz test                       Verify API connectivity
+  signaliz tools                      List all available MCP tools
+  signaliz gtm context --json         Load GTM Kernel workspace context
+  signaliz gtm bootstrap --json       Inspect GTM Kernel readiness
+  signaliz gtm templates --json       List private-safe campaign strategy templates
+  signaliz gtm start-context --strategy-template non-medical-home-care --json
+  signaliz gtm strategy-memory --strategy-template non-medical-home-care --include-samples --json
+  signaliz gtm agent-plan --goal "Build a strategy-template campaign" --strategy-template non-medical-home-care --target-count 500 --json
+  signaliz gtm provider-prepare --provider-id customer_mcp --layer company_enrichment --invocation-type mcp_tool --json
+  signaliz gtm memory search --query "proof-first vertical gate" --json
+  signaliz gtm plan --brief "Build 500 verified leads for..." --strategy-template non-medical-home-care --lead-count 500 --json
+  signaliz campaign-agent init --strategy-template non-medical-home-care --target-count 250 --use-local-leads --json > campaign-request.json
+  signaliz campaign-agent plan --goal "Build a strategy-template campaign..." --strategy-template industrial-ot-resilience --target-count 500 --builtins lead_generation,email_finding,email_verification,signals
+  signaliz campaign-agent proof --goal "Build a strategy-template campaign..." --strategy-template non-medical-home-care --target-count 100 --json
+  signaliz campaign-agent plan --request-file examples/campaign-builder-agent-request.json --target-count 250 --json
+  signaliz campaign-agent commit-plan --goal "Build a strategy-template campaign..." --json
+  signaliz campaign-agent dry-run --goal "Build a strategy-template campaign..." --target-count 500 --use-local-leads --json
+  signaliz campaign-agent build-approved --goal "Build a strategy-template campaign..." --confirm-launch --approve-all --approved-by you@example.com --spend-limit 500
 
 Environment:
-  SIGNALIZ_API_KEY  Your API key (required)
+  SIGNALIZ_API_KEY   Your API key (not required for campaign-agent init)
+  SIGNALIZ_BASE_URL  Optional API base URL override
+`);
+}
+function printGtmHelp() {
+  console.log(`
+Signaliz GTM commands:
+
+  signaliz gtm context [--include-campaigns] [--include-memory] [--include-brain] [--include-connections] [--limit N] [--json]
+  signaliz gtm bootstrap [--campaign-id ID] [--days N] [--include-connections] [--include-samples] [--json]
+  signaliz gtm templates [--query TEXT] [--strategy-template ID] [--summary] [--json]
+  signaliz gtm start-context [--brief TEXT] [--strategy-template ID] [--target-count N] [--layers a,b] [--providers a,b] [--json]
+  signaliz gtm strategy-memory [--query TEXT] [--strategy-template ID] [--include-samples] [--json]
+  signaliz gtm provider-prepare --provider-id ID [--layer NAME] [--invocation-type webhook|mcp_tool|api] [--json]
+  signaliz gtm activate-route --provider-id ID --layer NAME [--confirm] [--json]
+  signaliz gtm memory search --query TEXT [--layers a,b] [--provider-chain a,b] [--limit N] [--json]
+  signaliz gtm plan --brief TEXT [--strategy-template industrial-ot-resilience|non-medical-home-care|agency-founder-led|cloud-infrastructure-displacement] [--lead-count N] [--layers a,b] [--providers a,b] [--partners clay,instantly,nango] [--target-icp JSON] [--json]
+`);
+}
+function printCampaignAgentHelp() {
+  console.log(`
+Signaliz campaign-agent commands:
+
+  signaliz campaign-agent init [--goal TEXT] [--strategy-template ID] [--target-count N] [--use-local-leads] [--with-byo-placeholder] [--output-file FILE] [--json]
+  signaliz campaign-agent plan (--goal TEXT | --request-file FILE) [--campaign-name NAME] [--workspace-label NAME] [--strategy-template industrial-ot-resilience|non-medical-home-care|agency-founder-led|cloud-infrastructure-displacement] [--operating-playbooks proof-first-vertical-gate,signal-led-copy-approval] [--target-count N] [--icp JSON] [--builtins lead_generation,email_finding,email_verification,signals,local_leads] [--use-local-leads] [--custom-tool provider:layer:tool[:mcp]] [--preferred-providers signaliz_native,octave] [--partners clay,instantly,nango] [--no-strategy-memory] [--no-kernel-plan] [--no-delivery-risk] [--json]
+  signaliz campaign-agent proof (--goal TEXT | --request-file FILE) [--strategy-template ID] [--target-count N] [--use-local-leads] [--custom-tool provider:layer:tool[:mcp]] [--idempotency-key KEY] [--json]
+  signaliz campaign-agent commit-plan (--goal TEXT | --request-file FILE) [--confirm-write --approved-by EMAIL] [--idempotency-key KEY] [--json]
+  signaliz campaign-agent dry-run (--goal TEXT | --request-file FILE) [--gtm-campaign-id ID] [--delivery-risk JSON] [--idempotency-key KEY] [--json]
+  signaliz campaign-agent build-approved (--goal TEXT | --request-file FILE) --confirm-launch --approved-by EMAIL (--approve-all | --approved-types a,b) [--commit-before-launch] [--spend-limit N] [--approved-route-ids a,b] [--idempotency-key KEY] [--json]
+
+The init command emits a reusable JSON CampaignBuilderAgentRequest. The plan command composes an approval-gated strategy-template MCP flow. Proof runs the same plan path plus build_campaign dry_run=true and returns a no-spend receipt. Use --request-file to load a reusable request, then override fields such as --target-count or --strategy-template from the command line. Use --strategy-template to merge a private-safe strategy pattern into the plan without exposing private account labels, and --operating-playbooks to add reusable build-loop gates such as proof-first vertical qualification, net-new suppression, cache-first inventory, and signal-led copy approval. Built-ins map to Signaliz-native tools: lead_generation -> generate_leads, local_leads -> generate_local_leads, email_finding -> find_and_verify_emails, email_verification -> verify_emails, signals -> enrich_company_signals. Add BYO tools with --custom-tool provider:layer:tool[:mcp] or key=value pairs such as provider=apollo,layer=source,tool=apollo_search,mcp=apollo. Use --no-strategy-patterns or --no-workflow-patterns to disable default private strategy memory hints. Commit-plan dry-runs by default and writes only with --confirm-write plus approval identity. Dry-run executes build_campaign with dry_run=true. Approved build requires explicit launch confirmation and approval metadata; add --commit-before-launch to persist the reviewed plan as a GTM campaign before launch.
 `);
-  }
 }
 main().catch((e) => {
   console.error(e);