@signaliz/sdk 1.0.18 → 1.0.20

package/dist/mcp-config.js

@@ -479,6 +479,38 @@ var Signals = class {
   constructor(client) {
     this.client = client;
   }
+  /** Turn the strongest supported company signal into three complete, evidence-backed emails. */
+  async signalToCopy(params) {
+    const data = await this.client.post("api/v1/signal-to-copy", {
+      company_domain: params.companyDomain,
+      person_name: params.personName,
+      title: params.title,
+      campaign_offer: params.campaignOffer,
+      research_prompt: params.researchPrompt
+    });
+    return {
+      success: data.success ?? true,
+      strongestSignal: data.strongest_signal ?? "",
+      whyNow: data.why_now ?? "",
+      subjectLine: data.subject_line ?? "",
+      openingLine: data.opening_line ?? "",
+      confidence: data.confidence ?? 0,
+      evidenceUrl: data.evidence_url ?? "",
+      researchPrompt: data.research_prompt,
+      variations: (data.variations ?? []).map((v) => ({
+        style: v.style,
+        subjectLine: v.subject_line ?? "",
+        openingLine: v.opening_line ?? "",
+        cta: v.cta ?? "",
+        prediction: v.prediction,
+        email: v.email
+      }))
+    };
+  }
+  /** @deprecated Use signalToCopy. Retained for compatibility. */
+  async personalize(params) {
+    return this.signalToCopy(params);
+  }
   /** Enrich a company with actionable signals (V1) */
   async enrich(params) {
     const args = {
@@ -487,6 +519,9 @@ var Signals = class {
     if (params.domain) args.domain = params.domain;
     if (params.researchPrompt) args.research_prompt = params.researchPrompt;
     if (params.signalTypes) args.signal_types = params.signalTypes;
+    if (params.targetSignalCount) args.target_signal_count = params.targetSignalCount;
+    if (params.lookbackDays) args.lookback_days = params.lookbackDays;
+    if (params.enableDeepSearch !== void 0) args.enable_deep_search = params.enableDeepSearch;
     const data = await this.client.mcp("tools/call", {
       name: "enrich_company_signals",
       arguments: args
@@ -496,6 +531,16 @@ var Signals = class {
       signals: (data.signals ?? []).map((s) => ({
         title: s.title,
         signalType: s.signal_type,
+        sourceType: s.source_type ?? s.signal_classification?.label ?? "unknown",
+        sourceProvenance: s.source_provenance ?? s.metadata?.source_provenance ?? null,
+        signalFamily: s.signal_family ?? s.signal_type ?? null,
+        signalEventType: s.signal_event_type ?? s.signal_classification?.slug ?? null,
+        signalEventLabel: s.signal_event_label ?? s.signal_classification?.label ?? null,
+        signalClassification: s.signal_classification ? {
+          label: s.signal_classification.label,
+          slug: s.signal_classification.slug,
+          rationale: s.signal_classification.rationale
+        } : null,
         confidenceScore: s.confidence_score ?? 0,
         detectedAt: s.detected_at ?? "",
         url: s.url,
@@ -536,8 +581,17 @@ var Signals = class {
         content: s.content ?? "",
         date: s.date ?? null,
         sourceUrl: s.source_url ?? null,
-        sourceType: s.source_type ?? "unknown",
-        confidence: s.confidence ?? null
+        sourceType: s.source_type ?? s.signal_classification?.label ?? "unknown",
+        sourceProvenance: s.source_provenance ?? s.metadata?.source_provenance ?? null,
+        signalFamily: s.signal_family ?? s.type ?? null,
+        signalEventType: s.signal_event_type ?? s.signal_classification?.slug ?? null,
+        signalEventLabel: s.signal_event_label ?? s.signal_classification?.label ?? null,
+        confidence: s.confidence ?? null,
+        signalClassification: s.signal_classification ? {
+          label: s.signal_classification.label,
+          slug: s.signal_classification.slug,
+          rationale: s.signal_classification.rationale
+        } : null
       })),
       signalCount: data.signal_count ?? 0,
       intelligence: data.intelligence ? {
@@ -580,6 +634,58 @@ var Signals = class {
       }
     };
   }
+  /** Plan or run experimental Signal Fusion with explicit spend controls. */
+  async fusion(params) {
+    const args = {};
+    if (params.companyName) args.company_name = params.companyName;
+    if (params.domain) args.domain = params.domain;
+    if (params.companyDomain) args.company_domain = params.companyDomain;
+    if (params.linkedinUrl) args.linkedin_url = params.linkedinUrl;
+    if (params.companies) args.companies = params.companies;
+    if (params.preset) args.preset = params.preset;
+    if (params.researchPrompt) args.research_prompt = params.researchPrompt;
+    if (params.signalTypes) args.signal_types = params.signalTypes;
+    if (params.lookbackDays) args.lookback_days = params.lookbackDays;
+    if (params.targetSignalCount) args.target_signal_count = params.targetSignalCount;
+    if (params.maxToolCalls) args.max_tool_calls = params.maxToolCalls;
+    if (params.maxTokens) args.max_tokens = params.maxTokens;
+    if (params.timeoutMs) args.timeout_ms = params.timeoutMs;
+    const dryRun = params.dryRun ?? params.dry_run;
+    const confirmSpend = params.confirmSpend ?? params.confirm_spend;
+    const maxCredits = params.maxCredits ?? params.max_credits;
+    const maxCostUsd = params.maxCostUsd ?? params.max_cost_usd;
+    if (dryRun !== void 0) args.dry_run = dryRun;
+    if (confirmSpend !== void 0) args.confirm_spend = confirmSpend;
+    if (maxCredits !== void 0) args.max_credits = maxCredits;
+    if (maxCostUsd !== void 0) args.max_cost_usd = maxCostUsd;
+    const data = await this.client.post("signal-fusion", args);
+    return {
+      success: data.success ?? false,
+      capability: data.capability ?? "signal_fusion",
+      displayName: data.display_name ?? "Signal Fusion",
+      company: data.company,
+      signals: (data.signals ?? []).map((s) => ({
+        id: s.id,
+        title: s.title,
+        type: s.type,
+        content: s.content ?? "",
+        date: s.date ?? null,
+        sourceUrl: s.source_url ?? null,
+        sourceType: s.source_type ?? "unknown",
+        confidence: s.confidence ?? null
+      })),
+      signalCount: data.signal_count ?? data.signals?.length ?? 0,
+      results: data.results ?? [],
+      model: data.model,
+      fusion: data.fusion,
+      costUsd: data.cost_usd ?? 0,
+      tokensUsed: data.tokens_used ?? 0,
+      costSummary: data.cost_summary,
+      creditsUsed: data.total_credits_used ?? data.credits_used ?? 0,
+      billingMetadata: data.billing_metadata,
+      raw: data
+    };
+  }
 };
 
 // src/resources/systems.ts
@@ -1018,6 +1124,7 @@ function mapCustomerRowCounts(value) {
     acceptedRows: numberOrNull(record.accepted_rows) ?? void 0,
     usableRows: numberOrNull(record.usable_rows) ?? void 0,
     copiedRows: numberOrNull(record.copied_rows) ?? void 0,
+    copySkippedRows: numberOrNull(record.copy_skipped_rows) ?? void 0,
     approvalReadyRows: numberOrNull(record.approval_ready_rows) ?? void 0,
     qaReadyRows: numberOrNull(record.qa_ready_rows) ?? void 0,
     deliveredRows: numberOrNull(record.delivered_rows) ?? void 0,
@@ -1254,7 +1361,8 @@ function buildArgs(request) {
       geographies: request.icp.geographies,
       keywords: request.icp.keywords,
       exclusions: request.icp.exclusions,
-      require_verified_email: request.icp.requireVerifiedEmail
+      require_verified_email: request.icp.requireVerifiedEmail,
+      persona_expansion_mode: request.icp.personaExpansionMode
     };
   }
   if (request.policy) {
@@ -1294,6 +1402,7 @@ function buildArgs(request) {
       } : void 0,
       sequence_steps: request.copy.sequenceSteps,
       copy_schema: request.copy.copySchema,
+      evidence_mode: request.copy.evidenceMode,
       banned_phrases: request.copy.bannedPhrases,
       approval_required: request.copy.approvalRequired,
       quality_tier: request.copy.qualityTier
@@ -1350,7 +1459,8 @@ var DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS = {
   copy: {
     enabled: true,
     tone: "direct",
-    maxBodyWords: 125
+    maxBodyWords: 125,
+    evidenceMode: "signal_led"
   },
   delivery: {
     enabled: true,
@@ -1407,7 +1517,8 @@ var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
       "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"]
+    memoryKeywords: ["cache inventory", "large list", "unique emails", "top-up sourcing", "source metadata"],
+    knowledgeSources: ["data-ops/contact-data-lifecycle", "data-ops/credit-optimization-guide", "gtm/data-quality-ops", "gtm/lead-generation-strategies"]
   },
   {
     slug: "net-new-suppressed-list",
@@ -1432,7 +1543,8 @@ var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
       "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"]
+    memoryKeywords: ["suppression", "net-new", "prior email overlap", "domain review", "provenance-rich QA"],
+    knowledgeSources: ["gtm/data-quality-ops", "data-ops/contact-data-lifecycle", "gtm/outbound-sequencing"]
   },
   {
     slug: "proof-first-vertical-gate",
@@ -1457,7 +1569,8 @@ var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
       "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"]
+    memoryKeywords: ["proof gate", "vertical exclusion", "company before contact", "pass review fail", "fit threshold"],
+    knowledgeSources: ["gtm/icp-design-framework", "gtm/strategy/scoring.yaml", "gtm/advanced/account-prioritization-frameworks", "gtm/advanced/predictive-lead-scoring", "gtm/verticals"]
   },
   {
     slug: "signal-led-copy-approval",
@@ -1482,7 +1595,8 @@ var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
       "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"]
+    memoryKeywords: ["company signals", "evidence-fed copy", "why now", "copy blocker", "approval gate"],
+    knowledgeSources: ["gtm/email-personalization", "gtm/signal-based-selling", "gtm/signal-combination-matrix", "gtm/advanced/buyer-journey-mapping"]
   },
   {
     slug: "domain-first-recovery",
@@ -1507,7 +1621,8 @@ var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
       "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"]
+    memoryKeywords: ["domain-first", "yield modeling", "attrition", "accepted domains", "gap fill"],
+    knowledgeSources: ["gtm/lead-generation-strategies", "data-ops/enrichment-waterfall-strategy", "data-ops/credit-optimization-guide", "gtm/territory-account-planning"]
   },
   {
     slug: "table-workflow-handoff",
@@ -1532,7 +1647,112 @@ var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
       "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"]
+    memoryKeywords: ["table workflow", "request ready", "provider status", "export blocker", "BYO integration"],
+    knowledgeSources: ["gtm/multi-channel-orchestration", "data-ops/enrichment-waterfall-strategy", "recipes/clay-gtm-webhook-recipe", "systems/blueprints/multi-channel-orchestration"]
+  },
+  {
+    slug: "icp-persona-segmentation",
+    label: "ICP And Persona Segmentation",
+    whenToUse: [
+      "The brief has a broad market, multiple personas, or unclear buying committee.",
+      "The campaign should rank account tiers, persona fit, vertical nuance, and exclusions before sourcing at scale."
+    ],
+    sequence: [
+      "Convert the brief into account tiers, persona roles, buying committee influence, and explicit exclusions.",
+      "Choose vertical guidance only from the customer-safe GTM library and keep internal platform docs out of prompts.",
+      "Score accounts before contacts, then score contacts against persona, seniority, function, geography, and intent fit.",
+      "Return segment counts and review buckets before spend, copy, export, or launch."
+    ],
+    requiredFields: {
+      segment: ["segment_name", "tier", "persona_priority", "buying_committee_role", "fit_reason", "exclusion_reason"],
+      scoring: ["account_fit_score", "persona_fit_score", "segment_confidence", "review_bucket"]
+    },
+    qualityGates: [
+      "Do not treat adjacent personas or verticals as matches unless the brief allows them.",
+      "Keep ICP, persona, and exclusion evidence visible in the proof packet.",
+      "Low-confidence segments route to review before contact discovery or copy."
+    ],
+    activationBoundary: "Segmentation is planning guidance. Paid sourcing, enrichment, export, and launch require the normal approval gates.",
+    memoryKeywords: ["ICP design", "persona segmentation", "buying committee", "account tiers", "fit scoring", "vertical nuance"],
+    knowledgeSources: ["gtm/icp-design-framework", "gtm/personas/sdr.yaml", "gtm/personas/ae.yaml", "gtm/personas/cro.yaml", "gtm/personas/revops.yaml", "gtm/advanced/account-prioritization-frameworks", "gtm/verticals"]
+  },
+  {
+    slug: "buying-signal-prioritization",
+    label: "Buying Signal Prioritization",
+    whenToUse: [
+      "The campaign depends on timing, intent, trigger events, or account prioritization.",
+      "The operator wants why-now proof instead of generic list generation."
+    ],
+    sequence: [
+      "Map the campaign goal to signal families, trigger freshness, and buyer-journey stage.",
+      "Rank signals by relevance, recency, source quality, and persona-specific actionability.",
+      "Attach evidence URLs or evidence summaries without exposing private memory rows.",
+      "Use signal strength to decide source order, copy angle, and review priority."
+    ],
+    requiredFields: {
+      signal: ["signal_type", "signal_date", "signal_source", "why_now", "signal_confidence", "buyer_stage"],
+      prioritization: ["priority_score", "priority_reason", "next_best_action", "review_reason"]
+    },
+    qualityGates: [
+      "Do not use stale, unsupported, or weak signals as personalization proof.",
+      "Signal fit cannot override hard ICP, geography, suppression, or verified-email gates.",
+      "Rows with uncertain why-now evidence must stay review-only."
+    ],
+    activationBoundary: "Signal ranking can prioritize review and copy. It does not approve outreach, sender loading, exports, or sends.",
+    memoryKeywords: ["buying signals", "intent data", "funding trigger", "new executive", "tech adoption", "buyer journey", "why now"],
+    knowledgeSources: ["gtm/signal-based-selling", "gtm/signal-combination-matrix", "gtm/advanced/intent-data-strategies", "gtm/advanced/buyer-journey-mapping", "gtm/signals/funding-round", "gtm/signals/new-executive", "gtm/signals/tech-adoption", "recipes/funding-trigger-outreach", "recipes/new-hire-outreach"]
+  },
+  {
+    slug: "multi-channel-sequence-fit",
+    label: "Multi-Channel Sequence Fit",
+    whenToUse: [
+      "The campaign needs email, LinkedIn, call, webhook, CRM, or sequencer coordination.",
+      "Copy and delivery should adapt by persona, channel, deliverability risk, and proof strength."
+    ],
+    sequence: [
+      "Choose channel mix from persona, deal motion, evidence strength, deliverability constraints, and connected destination readiness.",
+      "Draft sequence logic with email, LinkedIn, call, and task handoffs only where supported by the approved destination.",
+      "Keep copy concise, proof-backed, channel-specific, and reviewable before delivery.",
+      "Run deliverability and destination readiness checks before sender load or launch approval."
+    ],
+    requiredFields: {
+      channel: ["channel", "touch_number", "persona_context", "message_angle", "channel_blocker", "approval_status"],
+      deliverability: ["verified_email", "domain_risk", "send_window", "unsubscribe_risk", "sender_ready"]
+    },
+    qualityGates: [
+      "Email copy must be row-supported and under the configured campaign tone/length limits.",
+      "LinkedIn, phone, CRM, webhook, and sequencer actions remain destination-locked until approved.",
+      "Deliverability risk or missing sender readiness blocks launch even when rows are qualified."
+    ],
+    activationBoundary: "Sequence strategy is draft-only. External writes, sender loading, launch, and sending need separate explicit approval.",
+    memoryKeywords: ["outbound sequencing", "email personalization", "LinkedIn outreach", "cold calling", "multi-channel orchestration", "deliverability"],
+    knowledgeSources: ["gtm/outbound-sequencing", "gtm/email-personalization", "gtm/linkedin-outreach-strategies", "gtm/cold-calling-frameworks", "gtm/multi-channel-orchestration", "gtm/advanced/email-deliverability", "systems/blueprints/multi-channel-orchestration"]
+  },
+  {
+    slug: "revops-feedback-loop",
+    label: "RevOps Feedback Loop",
+    whenToUse: [
+      "The campaign should improve from replies, meetings, delivery results, CRM outcomes, or operator QA.",
+      "The operator needs post-build monitoring, governance, or continuous ops follow-up."
+    ],
+    sequence: [
+      "Define success metrics, guardrails, and feedback sources before launch.",
+      "Collect aggregate outcomes, QA blockers, delivery health, and operator edits after each campaign phase.",
+      "Separate workspace-private evidence from public-safe learnings and Brain defaults.",
+      "Feed approved aggregate learnings back into future sourcing, qualification, copy, and suppression rules."
+    ],
+    requiredFields: {
+      feedback: ["source", "event_type", "metric", "sample_size", "confidence", "learning_candidate"],
+      governance: ["approval_owner", "last_reviewed_at", "risk_flag", "next_review_action"]
+    },
+    qualityGates: [
+      "Do not write memory or Brain learnings from raw replies, private labels, or provider payloads without approved redaction.",
+      "Use holdouts or pre/post comparisons before claiming causal lift.",
+      "Delivery, suppression, and opt-out signals must update future gates before scale-up."
+    ],
+    activationBoundary: "Feedback review is read-only until memory writes, Brain writes, CRM updates, or campaign changes are explicitly approved.",
+    memoryKeywords: ["RevOps", "feedback loop", "campaign learning", "reply outcomes", "sales marketing alignment", "data hygiene", "holdout"],
+    knowledgeSources: ["gtm/revenue-operations", "gtm/advanced/sales-marketing-alignment", "gtm/advanced/predictive-lead-scoring", "gtm/data-quality-ops", "data-ops/contact-data-lifecycle", "recipes/crm-data-hygiene", "gtm/playbooks/revops-automation-playbook"]
   }
 ];
 var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
@@ -1619,7 +1839,15 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
     agencyContext: {
       partnerEcosystem: ["signaliz", "instantly", "nango"]
     },
-    operatingPlaybookSlugs: ["net-new-suppressed-list", "proof-first-vertical-gate", "signal-led-copy-approval"]
+    operatingPlaybookSlugs: [
+      "net-new-suppressed-list",
+      "proof-first-vertical-gate",
+      "signal-led-copy-approval",
+      "icp-persona-segmentation",
+      "buying-signal-prioritization",
+      "multi-channel-sequence-fit",
+      "revops-feedback-loop"
+    ]
   },
   {
     slug: "non-medical-home-care",
@@ -1692,7 +1920,15 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
     agencyContext: {
       partnerEcosystem: ["clay", "octave", "signaliz", "instantly", "nango"]
     },
-    operatingPlaybookSlugs: ["proof-first-vertical-gate", "domain-first-recovery", "table-workflow-handoff"]
+    operatingPlaybookSlugs: [
+      "proof-first-vertical-gate",
+      "domain-first-recovery",
+      "table-workflow-handoff",
+      "icp-persona-segmentation",
+      "buying-signal-prioritization",
+      "multi-channel-sequence-fit",
+      "revops-feedback-loop"
+    ]
   },
   {
     slug: "agency-founder-led",
@@ -1753,7 +1989,15 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
     agencyContext: {
       partnerEcosystem: ["signaliz", "octave", "instantly", "nango"]
     },
-    operatingPlaybookSlugs: ["net-new-suppressed-list", "signal-led-copy-approval", "table-workflow-handoff"]
+    operatingPlaybookSlugs: [
+      "net-new-suppressed-list",
+      "signal-led-copy-approval",
+      "table-workflow-handoff",
+      "icp-persona-segmentation",
+      "buying-signal-prioritization",
+      "multi-channel-sequence-fit",
+      "revops-feedback-loop"
+    ]
   },
   {
     slug: "cloud-infrastructure-displacement",
@@ -1840,7 +2084,15 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
     agencyContext: {
       partnerEcosystem: ["signaliz", "octave", "instantly", "nango"]
     },
-    operatingPlaybookSlugs: ["proof-first-vertical-gate", "domain-first-recovery", "signal-led-copy-approval"]
+    operatingPlaybookSlugs: [
+      "proof-first-vertical-gate",
+      "domain-first-recovery",
+      "signal-led-copy-approval",
+      "icp-persona-segmentation",
+      "buying-signal-prioritization",
+      "multi-channel-sequence-fit",
+      "revops-feedback-loop"
+    ]
   }
 ];
 var CampaignBuilderAgent = class {
@@ -1871,6 +2123,9 @@ var CampaignBuilderAgent = class {
     const plan = await this.createPlan(request, options);
     return createCampaignBuilderReadiness(plan);
   }
+  activeWorkContext(input) {
+    return createCampaignBuilderActiveWorkContext(input);
+  }
   async proof(request, options = {}) {
     const plan = await this.createPlan(request, options);
     const result = await this.dryRunPlan(plan, {
@@ -2255,9 +2510,10 @@ function createCampaignBuilderAgentPlan(request, context = {}) {
   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 evidence = buildRequest.evidence ?? null;
   const approvals = deriveApprovals(resolvedRequest, routes, memory, estimatedCredits, defaults.delivery?.approvalRequired !== false);
   return {
-    planId: `cbp_${hashString(JSON.stringify({ goal: resolvedRequest.goal, campaignName, targetCount, routes }))}`,
+    planId: `cbp_${hashString(JSON.stringify({ goal: resolvedRequest.goal, campaignName, targetCount, routes, evidence }))}`,
     campaignName,
     goal: resolvedRequest.goal,
     targetCount,
@@ -2272,6 +2528,7 @@ function createCampaignBuilderAgentPlan(request, context = {}) {
     approvals,
     buildRequest,
     brainPreflight,
+    evidence,
     operatingPlaybooks,
     mcpFlow: createMcpFlow(resolvedRequest, buildRequest, routes, memory, approvals),
     estimatedCredits,
@@ -2363,6 +2620,90 @@ function createCampaignBuilderReadiness(plan) {
     nextActions: campaignReadinessNextActions(plan, ready, customRoutes.length)
   };
 }
+function createCampaignBuilderActiveWorkContext(input) {
+  const plan = input.readiness?.plan ?? input.plan;
+  const remembered = input.remembered ?? {};
+  const lastResult = asRecord(input.lastResult);
+  const readinessBlockers = input.readiness?.summary.blockers ?? [];
+  const explicitBlockers = input.blockers ?? [];
+  const blockers = uniqueStrings([...explicitBlockers, ...readinessBlockers]);
+  const warnings = uniqueStrings([
+    ...input.warnings ?? [],
+    ...input.readiness?.summary.warnings ?? [],
+    ...plan?.warnings ?? []
+  ]);
+  const missingApprovals = plan ? (input.approval ? getMissingCampaignBuilderApprovals(plan, input.approval) : plan.approvals.filter((approval) => approval.blocking)).map((approval) => approval.type) : [];
+  const refs = normalizeCampaignBuilderActiveWorkRefs({
+    plan,
+    remembered,
+    refs: input.refs,
+    lastResult
+  });
+  const state = inferCampaignBuilderActiveWorkState({
+    plan,
+    readiness: input.readiness,
+    remembered,
+    lastResult,
+    blockers,
+    missingApprovals
+  });
+  const nextSafeAction = campaignBuilderActiveWorkNextAction(state, blockers, missingApprovals, refs);
+  const approvalPacket = createCampaignBuilderApprovalPacket(plan, input.approval, missingApprovals);
+  const nextSafeMcpAction = campaignBuilderActiveWorkNextMcpAction({
+    state,
+    plan,
+    refs,
+    approvalPacket
+  });
+  const summary = {
+    plan_id: plan?.planId ?? remembered.planId ?? null,
+    campaign_name: plan?.campaignName ?? null,
+    target_count: plan?.targetCount ?? null,
+    gtm_campaign_id: plan?.buildRequest.gtmCampaignId ?? remembered.gtmCampaignId ?? null,
+    campaign_build_id: stringValue(lastResult.campaign_build_id ?? lastResult.campaignBuildId) ?? remembered.campaignBuildId ?? null,
+    provider_campaign_id: remembered.providerCampaignId ?? null
+  };
+  const approvalBoundary = campaignBuilderActiveWorkApprovalBoundary(missingApprovals, state);
+  const conversationStarters = campaignBuilderActiveWorkConversationStarters({
+    state,
+    blockers,
+    missingApprovals,
+    refs,
+    nextSafeAction
+  });
+  return {
+    packet_version: "campaign-builder-active-work-context.v1",
+    read_only: true,
+    no_spend: true,
+    no_provider_writes: true,
+    private_safe: true,
+    state,
+    summary,
+    refs,
+    blockers,
+    warnings,
+    missing_approval_types: missingApprovals,
+    approval_packet: approvalPacket,
+    approval_boundary: approvalBoundary,
+    next_safe_action: nextSafeAction,
+    next_safe_mcp_action: nextSafeMcpAction,
+    conversation_starters: conversationStarters,
+    openai_agent_handoff: createCampaignBuilderOpenAiAgentHandoff({
+      plan,
+      state,
+      summary,
+      refs,
+      blockers,
+      warnings,
+      missingApprovals,
+      approvalPacket,
+      approvalBoundary,
+      nextSafeAction,
+      nextSafeMcpAction,
+      conversationStarters
+    })
+  };
+}
 function createCampaignBuilderProofReceipt(plan, result) {
   const strategyMemory = asRecord(plan.strategyMemoryStatus);
   const dryRunResult = asRecord(result);
@@ -2421,6 +2762,7 @@ function createCampaignBuilderProofReceipt(plan, result) {
       estimated_credits: plan.estimatedCredits,
       operating_playbooks: plan.operatingPlaybooks.map((playbook) => playbook.slug)
     },
+    evidence: plan.evidence,
     gates,
     strategy_memory_status: summarizeCampaignBuilderProofStrategyMemory(strategyMemory),
     dry_run_result: summarizeCampaignBuilderProofDryRun(dryRunResult),
@@ -2469,6 +2811,56 @@ function getCampaignBuilderOperatingPlaybooksForRequest(request) {
   ]);
   return slugs.map(getCampaignBuilderOperatingPlaybook).filter((playbook) => Boolean(playbook));
 }
+function normalizeCampaignBuilderEvidence(evidence) {
+  if (!evidence) return null;
+  const attachmentSummary = (evidence.attachments ?? []).filter((attachment) => stringValue(attachment.name)).slice(0, 5).map((attachment) => ({
+    name: stringValue(attachment.name) ?? "attachment",
+    kind: stringValue(attachment.kind) ?? null,
+    media_type: stringValue(attachment.mediaType) ?? null,
+    redacted: attachment.redacted !== false,
+    columns: uniqueStrings(attachment.columns ?? []).slice(0, 25),
+    row_count: numberOrUndefined2(attachment.rowCount) ?? null,
+    content_summary: stringValue(attachment.contentSummary)?.slice(0, 500) ?? null,
+    evidence_fields: uniqueStrings(attachment.evidenceFields ?? []).slice(0, 25)
+  }));
+  const urlSummary = (evidence.urls ?? []).filter((url) => stringValue(url.url)).slice(0, 8).map((url) => {
+    const rawUrl = stringValue(url.url) ?? "";
+    return {
+      url: rawUrl,
+      host: stringValue(url.host) ?? hostFromUrl(rawUrl) ?? null,
+      type: stringValue(url.type) ?? null,
+      label: stringValue(url.label) ?? null,
+      summary: stringValue(url.summary)?.slice(0, 500) ?? null,
+      redacted: url.redacted === true
+    };
+  });
+  const operatorNotes = uniqueStrings(evidence.notes ?? []).map((note) => note.slice(0, 240)).slice(0, 5);
+  if (!attachmentSummary.length && !urlSummary.length && !operatorNotes.length) return null;
+  return {
+    packet_version: "campaign-builder-evidence.v1",
+    private_safe: true,
+    attachment_summary: attachmentSummary,
+    url_summary: urlSummary,
+    operator_notes: operatorNotes,
+    privacy_boundary: "Use these attachment and URL summaries as planning evidence only. Do not expose raw private attachment text, raw rows, leads, emails, provider payloads, copy bodies, or secrets.",
+    raw_private_fields_withheld: [
+      "raw_private_attachment_text",
+      "raw_attachment_rows",
+      "raw_leads",
+      "email_addresses",
+      "provider_auth_payloads",
+      "copy_bodies",
+      "secrets"
+    ]
+  };
+}
+function hostFromUrl(value) {
+  try {
+    return new URL(value).hostname || void 0;
+  } catch {
+    return void 0;
+  }
+}
 function applyCampaignBuilderStrategyTemplate(request) {
   const template = getCampaignBuilderStrategyTemplate(request.strategyTemplate);
   if (!template) return request;
@@ -3160,7 +3552,7 @@ function normalizeMemory(request) {
   };
 }
 function defaultAgencyMemoryQueries(request, configured) {
-  const operatingPlaybookTerms = getCampaignBuilderOperatingPlaybooksForRequest(request).flatMap((playbook) => [playbook.label, ...playbook.memoryKeywords]).join(" ");
+  const operatingPlaybookTerms = getCampaignBuilderOperatingPlaybooksForRequest(request).flatMap((playbook) => [playbook.label, ...playbook.memoryKeywords, ...playbook.knowledgeSources]).join(" ");
   const queries = [{
     query: request.goal,
     scopes: ["workspace", configured.useNetworkPatterns ? "network_patterns" : "operator_notes"],
@@ -3371,6 +3763,8 @@ function createBuildRequest(request, defaults, targetCount, campaignName, scopeB
       fillPolicy: "aggressive"
     }
   };
+  const evidence = normalizeCampaignBuilderEvidence(request.evidence);
+  if (evidence) buildRequest.evidence = evidence;
   const scoped = asRecord(scopeBuildArgs);
   buildRequest.gtmCampaignId = request.gtmCampaignId ?? stringValue(scoped.gtm_campaign_id ?? scoped.gtmCampaignId);
   buildRequest.learningHoldout = normalizeCampaignBuilderLearningHoldout(
@@ -3402,6 +3796,7 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
     memory.enabled ? "feedback" : void 0
   ]);
   const providerChain = uniqueStrings(["signaliz", ...request.preferredProviders ?? [], ...routes.map((route) => route.provider)]);
+  const evidence = buildRequest.evidence ?? normalizeCampaignBuilderEvidence(request.evidence);
   const targetIcp = compact({
     personas: buildRequest.icp?.personas,
     industries: buildRequest.icp?.industries,
@@ -3414,6 +3809,7 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
   const learningArgs = compact({
     campaign_brief: request.goal,
     target_icp: targetIcp,
+    evidence_context: evidence,
     layers,
     provider_chain: providerChain,
     lead_source: providerChain[0] ?? "signaliz",
@@ -3425,6 +3821,7 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
   const defaultsArgs = compact({
     campaign_brief: request.goal,
     target_icp: targetIcp,
+    evidence_context: evidence,
     layers,
     include_global: memory.useNetworkPatterns,
     include_memory: memory.enabled,
@@ -3435,6 +3832,7 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
     provider_chain: providerChain,
     lead_source: providerChain[0] ?? "signaliz",
     target_icp: targetIcp,
+    evidence_context: evidence,
     include_global: memory.useNetworkPatterns,
     limit: 25
   });
@@ -3447,9 +3845,11 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
       label: playbook.label,
       quality_gates: playbook.qualityGates,
       required_fields: playbook.requiredFields,
-      activation_boundary: playbook.activationBoundary
+      activation_boundary: playbook.activationBoundary,
+      knowledge_sources: playbook.knowledgeSources
     })),
     target_icp: targetIcp,
+    evidence_context: evidence,
     provider_chain: providerChain,
     lead_source: providerChain[0] ?? "signaliz",
     learning_holdout: buildRequest.learningHoldout,
@@ -3722,7 +4122,7 @@ function createMcpFlow(request, buildRequest, routes, memory, approvals) {
       phase: "plan",
       tool: "nango_mcp_tools_list",
       arguments: {
-        format: "mcp"
+        format: "openai"
       },
       readOnly: true,
       approvalRequired: false
@@ -4031,6 +4431,7 @@ function buildGtmCampaignBuildPlanArgs(request, buildRequest, routes, memory) {
     layers: layers.length > 0 ? layers : void 0,
     preferred_providers: preferredProviders.length > 0 ? preferredProviders : void 0,
     strategy_model: strategyModel,
+    evidence_context: buildRequest.evidence ?? normalizeCampaignBuilderEvidence(request.evidence),
     include_strategy_patterns: campaignBuilderStrategyPatternsEnabled(agencyContext),
     include_workflow_patterns: campaignBuilderWorkflowPatternsEnabled(agencyContext),
     include_nango_catalog: agencyContext.includeNangoCatalog !== false,
@@ -4039,7 +4440,8 @@ function buildGtmCampaignBuildPlanArgs(request, buildRequest, routes, memory) {
       slug: playbook.slug,
       label: playbook.label,
       quality_gates: playbook.qualityGates,
-      activation_boundary: playbook.activationBoundary
+      activation_boundary: playbook.activationBoundary,
+      knowledge_sources: playbook.knowledgeSources
     })),
     include_memory: memory.enabled,
     include_brain: true,
@@ -4132,6 +4534,7 @@ function buildCampaignArgs(request) {
   }
   if (request.campaignStrategyContext) args.campaign_strategy_context = request.campaignStrategyContext;
   if (request.deliveryRisk) args.delivery_risk = request.deliveryRisk;
+  if (request.evidence) args.evidence_context = request.evidence;
   if (request.icp) {
     args.icp = compact({
       personas: request.icp.personas,
@@ -4181,7 +4584,8 @@ function buildCampaignArgs(request) {
       max_body_words: request.copy.maxBodyWords,
       sender_context: request.copy.senderContext,
       offer_context: request.copy.offerContext,
-      model: request.copy.model
+      model: request.copy.model,
+      evidence_mode: request.copy.evidenceMode
     });
   }
   if (request.delivery) {
@@ -4458,6 +4862,7 @@ function mapAgentCustomerRowCounts(value) {
     acceptedRows: numberOrUndefined2(record.accepted_rows),
     usableRows: numberOrUndefined2(record.usable_rows),
     copiedRows: numberOrUndefined2(record.copied_rows),
+    copySkippedRows: numberOrUndefined2(record.copy_skipped_rows),
     approvalReadyRows: numberOrUndefined2(record.approval_ready_rows),
     qaReadyRows: numberOrUndefined2(record.qa_ready_rows),
     deliveredRows: numberOrUndefined2(record.delivered_rows),
@@ -4568,7 +4973,7 @@ function createCampaignBuilderNorthStarScorecard(status, rows, artifacts, termin
   const sampledRows = rows.rows.length;
   const rowData = rows.rows.map((row) => asRecord(row.data));
   const requestedTarget = status.customerRowCounts?.requestedTarget ?? status.recordsTotal ?? rows.count;
-  const finalRows = status.customerRowCounts?.deliveredRows ?? status.customerRowCounts?.qaReadyRows ?? status.customerRowCounts?.copiedRows ?? status.customerRowCounts?.acceptedRows ?? rows.count;
+  const finalRows = status.customerRowCounts?.deliveredRows ?? status.customerRowCounts?.qaReadyRows ?? status.customerRowCounts?.copySkippedRows ?? status.customerRowCounts?.copiedRows ?? status.customerRowCounts?.acceptedRows ?? rows.count;
   const rowsWithEmail = rows.rows.filter(campaignReviewRowHasEmail).length;
   const verifiedEmailRows = rowData.filter(campaignReviewDataHasVerifiedEmail).length;
   const uniqueEmails = new Set(rowData.map(campaignReviewDataEmail).filter(Boolean)).size;
@@ -5059,6 +5464,342 @@ function createCampaignBuilderReadinessLane(route, plan) {
     nextAction: customRoute ? `Review ${route.provider} route setup before launch approval.` : void 0
   };
 }
+function createCampaignBuilderApprovalPacket(plan, approval, missingTypes) {
+  const requestedTypes = plan ? uniqueStrings(plan.approvals.filter((item) => item.blocking).map((item) => item.type)) : [];
+  const approvalMatchesPlan = Boolean(plan && approval?.planId === plan.planId);
+  const approvedTypes = approvalMatchesPlan ? approval?.approvedTypes ?? [] : [];
+  const approvedRoutes = approvalMatchesPlan ? approval?.approvedRouteIds ?? [] : [];
+  const missingIds = new Set(
+    plan && approvalMatchesPlan && approval ? getMissingCampaignBuilderApprovals(plan, approval).map((item) => item.id) : plan?.approvals.filter((item) => item.blocking).map((item) => item.id) ?? []
+  );
+  const routeIdsRequired = plan ? uniqueStrings(plan.approvals.map((item) => item.routeId).filter((id) => Boolean(id))) : [];
+  const spendLimitRequired = plan ? Math.max(0, ...plan.approvals.filter((item) => item.type === "spend" && item.blocking).map((item) => item.estimatedCredits ?? plan.estimatedCredits)) : 0;
+  const normalizedSpendLimit = spendLimitRequired > 0 ? spendLimitRequired : null;
+  const approvalState = !plan ? "unscoped" : missingTypes.length > 0 ? "requires_approval" : "approved";
+  const approvalInput = {
+    approved_by: approval?.approvedBy ?? null,
+    approved_at: approval?.approvedAt ?? null,
+    approved_types: approvedTypes,
+    approved_route_ids: approvedRoutes,
+    spend_limit_credits: approval?.spendLimitCredits ?? null,
+    notes: approval?.notes
+  };
+  return {
+    packet_version: "campaign-builder-approval-packet.v1",
+    read_only: true,
+    no_spend: true,
+    no_provider_writes: true,
+    private_safe: true,
+    approval_state: approvalState,
+    plan_id: plan?.planId ?? null,
+    campaign_name: plan?.campaignName ?? null,
+    requested_approval_types: requestedTypes,
+    missing_approval_types: uniqueStrings(missingTypes),
+    spend_limit_credits_required: normalizedSpendLimit,
+    route_ids_required: routeIdsRequired,
+    required_approvals: (plan?.approvals ?? []).map((item) => compact({
+      id: item.id,
+      type: item.type,
+      label: item.label,
+      reason: item.reason,
+      blocking: item.blocking,
+      route_id: item.routeId,
+      provider: item.provider,
+      estimated_credits: item.estimatedCredits,
+      status: missingIds.has(item.id) ? "missing" : "approved"
+    })),
+    approval_input: approvalInput,
+    cli_handoff: plan ? {
+      command: campaignBuilderApprovalCliHandoff(requestedTypes, routeIdsRequired, normalizedSpendLimit),
+      safety: "Template only: run after explicit human approval identity, approved types, route scope, and spend limit are filled in."
+    } : null,
+    sdk_handoff: plan ? {
+      method: "campaignBuilderAgent.buildApprovedPlan",
+      approval: compact({
+        approvedBy: approval?.approvedBy ?? "<operator-email>",
+        approvedTypes: requestedTypes,
+        approvedRouteIds: routeIdsRequired,
+        spendLimitCredits: normalizedSpendLimit ?? void 0,
+        notes: approval?.notes
+      }),
+      options: {
+        idempotencyKey: "<set-before-execution>"
+      },
+      safety: "Call only after the approval packet is accepted; this helper does not execute writes or spend."
+    } : null,
+    mcp_handoffs: plan ? campaignBuilderApprovalMcpHandoffs(plan, requestedTypes, routeIdsRequired, normalizedSpendLimit) : [],
+    safety_boundary: "This approval packet is a reusable request for human approval; it is not an approval grant and it does not authorize spend, provider writes, sender loading, delivery, or launch by itself."
+  };
+}
+function campaignBuilderApprovalCliHandoff(requestedTypes, routeIds, spendLimit) {
+  return [
+    "signaliz campaign-agent build-approved --request-file campaign-request.json --confirm-launch",
+    requestedTypes.length > 0 ? `--approved-types ${shellArg(requestedTypes.join(","))}` : "--approve-all",
+    "--approved-by <operator-email>",
+    spendLimit !== null ? `--spend-limit ${spendLimit}` : void 0,
+    routeIds.length > 0 ? `--approved-route-ids ${shellArg(routeIds.join(","))}` : void 0
+  ].filter(Boolean).join(" ");
+}
+function campaignBuilderApprovalMcpHandoffs(plan, requestedTypes, routeIds, spendLimit) {
+  const approvalContext = compact({
+    plan_id: plan.planId,
+    approval_types: requestedTypes,
+    approved_route_ids: routeIds,
+    spend_limit_credits: spendLimit,
+    approved_by: "<operator-email>"
+  });
+  return plan.mcpFlow.filter((step) => ["execution-prepare", "approved-build", "delivery-approval"].includes(step.id)).map((step) => ({
+    id: step.id,
+    tool: step.tool,
+    arguments: step.id === "approved-build" ? compact({ ...step.arguments, approval_context: approvalContext }) : step.arguments,
+    read_only: step.readOnly,
+    approval_required: step.approvalRequired,
+    safety: step.readOnly ? "Read-only readiness handoff; safe to inspect before approval." : "Write-capable handoff; run only after the approval packet is accepted."
+  }));
+}
+function campaignBuilderActiveWorkNextMcpAction(input) {
+  const campaignBuildRef = input.refs.find((ref) => ref.kind === "campaign_build" && ref.id);
+  if (campaignBuildRef) {
+    return {
+      id: "check-campaign-build-status",
+      tool: "get_campaign_build_status",
+      arguments: { campaign_build_id: campaignBuildRef.id },
+      read_only: true,
+      approval_required: false,
+      safety: "Read-only status check for the remembered campaign build; does not spend, write, export, send, or approve anything."
+    };
+  }
+  const campaignRef = input.refs.find((ref) => ref.kind === "gtm_campaign" && ref.id);
+  if (campaignRef) {
+    return {
+      id: "check-gtm-campaign-status",
+      tool: "gtm_campaign_execution_status",
+      arguments: { campaign_id: campaignRef.id },
+      read_only: true,
+      approval_required: false,
+      safety: "Read-only campaign execution status check; does not start or mutate the campaign."
+    };
+  }
+  const preferredStepId = input.state === "ready_for_dry_run" ? "dry-run-build" : input.state === "planning" || input.state === "blocked" ? "agency-campaign-build-plan" : null;
+  const preferredStep = preferredStepId ? input.plan?.mcpFlow.find((step) => step.id === preferredStepId && step.readOnly) : void 0;
+  if (preferredStep) return campaignBuilderMcpStepToActiveWorkAction(preferredStep, "Read-only continuation from the saved campaign-agent plan.");
+  const readOnlyApprovalHandoff = input.approvalPacket.mcp_handoffs.find((handoff) => handoff.read_only && !handoff.approval_required);
+  if (readOnlyApprovalHandoff) return readOnlyApprovalHandoff;
+  const firstReadOnlyPlanStep = input.plan?.mcpFlow.find((step) => step.readOnly && !step.approvalRequired);
+  return firstReadOnlyPlanStep ? campaignBuilderMcpStepToActiveWorkAction(firstReadOnlyPlanStep, "Read-only saved plan check; safe before approvals or writes.") : null;
+}
+function campaignBuilderMcpStepToActiveWorkAction(step, safety) {
+  return {
+    id: step.id,
+    tool: step.tool,
+    arguments: step.arguments,
+    read_only: step.readOnly,
+    approval_required: step.approvalRequired,
+    safety
+  };
+}
+function normalizeCampaignBuilderActiveWorkRefs(input) {
+  const refs = [];
+  const pushRef = (ref) => {
+    if (!ref?.id) return;
+    refs.push(ref);
+  };
+  pushRef(input.plan?.planId ? { kind: "plan", id: input.plan.planId, label: input.plan.campaignName, source: "plan" } : void 0);
+  pushRef(input.remembered.planId ? { kind: "plan", id: input.remembered.planId, source: "remembered" } : void 0);
+  pushRef(
+    input.plan?.buildRequest.gtmCampaignId ?? input.remembered.gtmCampaignId ? {
+      kind: "gtm_campaign",
+      id: input.plan?.buildRequest.gtmCampaignId ?? input.remembered.gtmCampaignId,
+      label: input.plan?.campaignName,
+      source: input.plan?.buildRequest.gtmCampaignId ? "plan" : "remembered"
+    } : void 0
+  );
+  const campaignBuildId = stringValue(input.lastResult.campaign_build_id ?? input.lastResult.campaignBuildId) ?? input.remembered.campaignBuildId;
+  pushRef(campaignBuildId ? { kind: "campaign_build", id: campaignBuildId, status: activeWorkStatus(input.lastResult) ?? input.remembered.status, source: "result" } : void 0);
+  pushRef(
+    input.remembered.providerCampaignId ? {
+      kind: "provider_campaign",
+      id: input.remembered.providerCampaignId,
+      label: input.remembered.provider,
+      status: input.remembered.status,
+      source: "remembered"
+    } : void 0
+  );
+  for (const ref of input.remembered.refs ?? []) pushRef(ref);
+  for (const ref of input.refs ?? []) pushRef(ref);
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((ref) => {
+    const key = `${ref.kind}:${ref.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function inferCampaignBuilderActiveWorkState(input) {
+  if (input.blockers.length > 0) return "blocked";
+  const status = activeWorkStatus(input.lastResult) ?? input.remembered.status;
+  const normalized = status?.toLowerCase();
+  if (normalized && ["completed", "complete", "succeeded", "success", "done"].includes(normalized)) return "completed";
+  if (normalized && ["queued", "running", "in_progress", "processing", "pending"].includes(normalized)) return "queued_or_running";
+  const dryRunComplete = input.lastResult.dry_run === true || input.lastResult.dryRun === true || normalized === "dry_run";
+  if (dryRunComplete) return input.missingApprovals.length > 0 ? "needs_approval" : "dry_run_complete";
+  if (input.missingApprovals.length > 0) return "needs_approval";
+  if (input.readiness?.summary.ready === true) return "ready_for_dry_run";
+  if (input.plan) return "planning";
+  return "unknown";
+}
+function campaignBuilderActiveWorkApprovalBoundary(missingApprovals, state) {
+  if (missingApprovals.length > 0) {
+    return `Blocked before spend, provider writes, delivery, or launch until approval covers: ${uniqueStrings(missingApprovals).join(", ")}.`;
+  }
+  if (state === "dry_run_complete" || state === "ready_for_dry_run") {
+    return "Read-only planning and dry-runs are allowed; spend, provider writes, sender loading, delivery, and launch still require explicit approval.";
+  }
+  return "This packet is read-only and does not authorize spend, provider writes, sender loading, delivery, or launch.";
+}
+function campaignBuilderActiveWorkNextAction(state, blockers, missingApprovals, refs) {
+  if (blockers.length > 0) return `Resolve blocker: ${blockers[0]}`;
+  if (missingApprovals.length > 0) return `Ask the operator to approve ${uniqueStrings(missingApprovals).join(", ")} before any write or spend action.`;
+  if (state === "ready_for_dry_run") return "Run or inspect the read-only campaign dry-run, then return the receipt for approval review.";
+  if (state === "dry_run_complete") return "Review the dry-run receipt and collect explicit launch or delivery approval before any write action.";
+  if (state === "queued_or_running") return "Poll the remembered campaign build or provider job status; do not start a duplicate job.";
+  if (state === "completed") return "Review final artifacts and delivery gates before export, sync, sender load, or launch.";
+  if (refs.length > 0) return "Use the remembered refs to fetch current read-only status before asking the operator for IDs.";
+  return "Create or refresh a campaign-builder plan before taking any spendful or write action.";
+}
+function campaignBuilderActiveWorkConversationStarters(input) {
+  const starters = [];
+  if (input.blockers.length > 0) {
+    starters.push(
+      `I found a blocker: ${input.blockers[0]}. Want me to stay in read-only diagnostics and prepare the fix path?`
+    );
+  }
+  if (input.missingApprovals.length > 0) {
+    starters.push(
+      `You still owe approval for ${uniqueStrings(input.missingApprovals).join(", ")}. Want the exact approval packet before anything writes or spends?`
+    );
+  }
+  if (input.state === "queued_or_running") {
+    const buildRef = input.refs.find((ref) => ref.kind === "campaign_build");
+    starters.push(buildRef ? `I can check campaign build ${buildRef.id} now and avoid starting a duplicate job.` : "I can check the running job status now and avoid starting duplicate work.");
+  }
+  if (input.state === "dry_run_complete") {
+    starters.push("The dry run is complete. Want me to summarize blockers, artifacts, and the approval handoff?");
+  }
+  if (input.state === "ready_for_dry_run") {
+    starters.push("Everything is ready for a safe dry run. Want me to run the no-spend preview first?");
+  }
+  if (input.state === "completed") {
+    starters.push("The build looks complete. Want me to review rows, artifacts, and delivery gates before export or send approval?");
+  }
+  starters.push(`Next safe action: ${input.nextSafeAction}`);
+  return uniqueStrings(starters).slice(0, 4);
+}
+function createCampaignBuilderOpenAiAgentHandoff(input) {
+  const readOnlyPlanActions = input.plan?.mcpFlow.filter((step) => step.readOnly && !step.approvalRequired).map((step) => campaignBuilderMcpStepToActiveWorkAction(step, "Read-only Signaliz MCP continuation for the saved campaign-agent plan.")) ?? [];
+  const routeSetupActions = readOnlyPlanActions.filter(
+    (action) => action.tool === "gtm_provider_recipe_prepare" || action.tool === "gtm_provider_route_activate"
+  );
+  const safeReadActions = uniqueCampaignBuilderActiveWorkActions([
+    input.nextSafeMcpAction,
+    ...routeSetupActions,
+    ...readOnlyPlanActions
+  ]);
+  const approvalGatedActions = uniqueCampaignBuilderActiveWorkActions([
+    ...input.approvalPacket.mcp_handoffs.filter((action) => action.approval_required || !action.read_only),
+    ...input.plan?.mcpFlow.filter((step) => step.approvalRequired || !step.readOnly).map((step) => campaignBuilderMcpStepToActiveWorkAction(step, "Approval-gated Signaliz MCP continuation for the saved campaign-agent plan.")) ?? []
+  ]);
+  const approvalTypes = uniqueStrings([
+    ...input.missingApprovals,
+    ...input.approvalPacket.requested_approval_types
+  ]);
+  return {
+    packet_version: "campaign-builder-openai-agent-handoff.v1",
+    surface: "openai_agents_sdk",
+    agent: {
+      name: "Signaliz GTM Campaign Agent",
+      handoff_description: "Owns safe, conversational GTM campaign planning and continuation across Signaliz MCP, SDK, attachments, URLs, customer tools, approvals, and sender/export gates.",
+      instructions: [
+        "Be warm, direct, and expert-level GTM. Translate the current state into plain operator language before proposing work.",
+        "Start from the packet state, refs, evidence_context, approval_boundary, and next_safe_action. Do not ask for IDs already present in refs or summary.",
+        "Use attachment_summary, url_summary, and operator_notes as first-class planning evidence, while honoring the evidence privacy_boundary and withheld raw fields.",
+        "Prefer Signaliz-native, cached, remembered, and read-only MCP actions before provider calls. Never start duplicate jobs when a campaign_build or provider job is queued or running.",
+        "Call only tools listed in safe_read_tools without approval. Treat approval_gated_tools as human-review surfaces, not permission to spend, write, export, load senders, deliver, or launch.",
+        "When approval is missing, show the approval_packet and the exact missing approval scope before any side-effecting step."
+      ],
+      output_contract: [
+        "current_state: one concise sentence describing where the campaign work stands.",
+        "evidence_used: attachment, URL, memory, route, or integration evidence used without exposing private raw rows or secrets.",
+        "next_safe_mcp_action: the read-only Signaliz MCP action to run next, or null when none is safe.",
+        "approval_boundary: the human approval scope required before spend, provider writes, delivery, export, sender load, or launch.",
+        "operator_reply: conversational GTM guidance with blockers, risks, and the safest next move."
+      ]
+    },
+    context: {
+      state: input.state,
+      summary: input.summary,
+      refs: input.refs,
+      blockers: input.blockers,
+      warnings: input.warnings,
+      evidence_context: input.plan?.evidence ?? null,
+      approval_packet: input.approvalPacket,
+      approval_boundary: input.approvalBoundary,
+      next_safe_action: input.nextSafeAction,
+      conversation_starters: input.conversationStarters
+    },
+    tools: {
+      mcp_server_label: "signaliz",
+      remote_mcp_compatible: true,
+      next_safe_mcp_action: input.nextSafeMcpAction,
+      safe_read_tools: safeReadActions.map(
+        (action) => campaignBuilderOpenAiAgentTool(action, "Safe read-only Signaliz MCP action available before approval.")
+      ),
+      approval_gated_tools: approvalGatedActions.map(
+        (action) => campaignBuilderOpenAiAgentTool(action, "Requires explicit human review before execution.")
+      )
+    },
+    guardrails: {
+      input: [
+        "Reject or pause requests to expose raw private attachment text, raw rows, leads, emails, provider payloads, copy bodies, API keys, or secrets.",
+        "Pause when the user asks to spend credits, write to a provider, export, load a sender, deliver, or launch without explicit approval scope."
+      ],
+      tool: [
+        "Read-only tools may run when they match safe_read_tools and their arguments match this packet.",
+        "Any tool with approval_required=true or read_only=false requires human review and the approval_packet scope first."
+      ],
+      human_review_required_for: approvalTypes,
+      privacy: input.plan?.evidence?.privacy_boundary ?? "Use summarized context only. Do not expose raw private attachment text, raw rows, leads, emails, provider payloads, copy bodies, secrets, or credentials."
+    }
+  };
+}
+function campaignBuilderOpenAiAgentTool(action, purpose) {
+  return {
+    id: action.id,
+    type: "mcp",
+    server_label: "signaliz",
+    name: action.tool,
+    arguments: action.arguments,
+    read_only: action.read_only,
+    approval_required: action.approval_required,
+    purpose,
+    safety: action.safety
+  };
+}
+function uniqueCampaignBuilderActiveWorkActions(actions) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const action of actions) {
+    if (!action) continue;
+    const key = `${action.id}:${action.tool}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(action);
+  }
+  return unique;
+}
+function activeWorkStatus(record) {
+  return stringValue(record.status ?? record.state ?? record.phase);
+}
 function campaignBuilderBuiltInForRoute(route) {
   return Object.entries(CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS).find(([, routeId]) => route.id === routeId)?.[0];
 }
@@ -7855,6 +8596,36 @@ function recordsFromParams(params) {
   if (params.input) return { input: params.input };
   return { input: {} };
 }
+function toFusionConfig(params) {
+  return {
+    system_prompt: params.systemPrompt || params.system_prompt,
+    user_template: params.userTemplate || params.user_template || params.prompt,
+    preset: params.preset,
+    temperature: params.temperature,
+    max_tool_calls: params.maxToolCalls || params.max_tool_calls,
+    max_tokens: params.maxTokens || params.max_tokens,
+    timeout_ms: params.timeoutMs || params.timeout_ms,
+    output_fields: params.outputFields || params.output_fields || [{ name: "response", type: "text", description: "Structured Fusion enrichment result" }]
+  };
+}
+function toFusionSpendControls(params) {
+  const controls = {};
+  const dryRun = params.dryRun ?? params.dry_run;
+  const confirmSpend = params.confirmSpend ?? params.confirm_spend;
+  const maxCredits = params.maxCredits ?? params.max_credits;
+  const maxCostUsd = params.maxCostUsd ?? params.max_cost_usd;
+  if (dryRun !== void 0) controls.dry_run = dryRun;
+  if (confirmSpend !== void 0) controls.confirm_spend = confirmSpend;
+  if (maxCredits !== void 0) controls.max_credits = maxCredits;
+  if (maxCostUsd !== void 0) controls.max_cost_usd = maxCostUsd;
+  return controls;
+}
+function fusionRecordsFromParams(params) {
+  const records = params.records || params.inputs;
+  if (records?.length) return { records };
+  if (params.input) return { input: params.input };
+  return { input: {} };
+}
 var Ai = class {
   constructor(client) {
     this.client = client;
@@ -7888,6 +8659,33 @@ var Ai = class {
       raw: data
     };
   }
+  /**
+   * Plan or run experimental AI Enrichment Fusion with explicit spend controls.
+   */
+  async fusion(params) {
+    if (!params.prompt && !params.userTemplate && !params.user_template) {
+      throw new Error("prompt or userTemplate is required.");
+    }
+    const data = await this.client.post("ai-enrichment-fusion", {
+      ...fusionRecordsFromParams(params),
+      config: toFusionConfig(params),
+      ...toFusionSpendControls(params)
+    });
+    return {
+      success: data.success ?? false,
+      capability: data.capability ?? "ai_enrichment_fusion",
+      displayName: data.display_name ?? "AI Enrichment Fusion",
+      results: data.results ?? [],
+      creditsUsed: data.total_credits_used ?? data.credits_used ?? 0,
+      model: data.model,
+      fusion: data.fusion,
+      tokensUsed: data.tokens_used ?? 0,
+      costUsd: data.cost_usd ?? 0,
+      costSummary: data.cost_summary,
+      billingMetadata: data.billing_metadata,
+      raw: data
+    };
+  }
 };
 
 // src/resources/gtm-kernel.ts
@@ -8427,6 +9225,24 @@ var GtmKernel = class {
       limit: input.limit
     });
   }
+  /** Predict booked-meeting likelihood for uploaded, inline, or MCP-sourced lead rows without persisting raw rows. */
+  async predictMeetingLikelihood(input) {
+    return this.callMcp("gtm_predict_meeting_likelihood", {
+      lead_rows: input.leadRows,
+      input_source: input.inputSource,
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      days: input.days,
+      feedback_limit: input.feedbackLimit,
+      include_features: input.includeFeatures,
+      include_global: input.includeGlobal,
+      min_feedback_events: input.minFeedbackEvents,
+      min_historical_feature_sample_size: input.minHistoricalFeatureSampleSize,
+      min_workspace_count: input.minWorkspaceCount,
+      min_privacy_k: input.minPrivacyK,
+      limit: input.limit
+    });
+  }
   /** Rank provider-chain, ICP, source, copy, and sequence failure patterns without writing raw lead data. */
   async failurePatterns(options = {}) {
     return this.callMcp("gtm_brain_failure_patterns", {
@@ -9042,6 +9858,70 @@ function compact2(value) {
   return out;
 }
 
+// src/resources/public-ground-truth.ts
+var PublicGroundTruth = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Search the public-ground-truth cache by company/name/domain/native ID,
+   * or by plain-language industry + location.
+   * Results use the same snake_case wire shape returned by the hosted MCP API.
+   */
+  async search(params) {
+    return this.client.mcp("tools/call", {
+      name: "search_public_ground_truth",
+      arguments: {
+        query: params.query ?? params.search,
+        industry: params.industry,
+        location: params.location,
+        source_id: params.sourceId ?? params.source_id,
+        entity_type: params.entityType ?? params.entity_type,
+        native_id: params.nativeId ?? params.native_id,
+        entity_name: params.entityName ?? params.entity_name,
+        domain: params.domain,
+        website_url: params.websiteUrl ?? params.website_url,
+        phone: params.phone,
+        email: params.email,
+        city: params.city,
+        state: params.state,
+        postal_code: params.postalCode ?? params.postal_code,
+        country: params.country,
+        source_url: params.sourceUrl ?? params.source_url,
+        join_keys: params.joinKeys ?? params.join_keys,
+        row_data: params.rowData ?? params.row_data,
+        naics: params.naics,
+        industry_code: params.industryCode ?? params.industry_code,
+        industry_type: params.industryType ?? params.industry_type,
+        year: params.year,
+        quarter: params.quarter,
+        area_fips: params.areaFips ?? params.area_fips,
+        geo_id: params.geoId ?? params.geo_id,
+        own_code: params.ownCode ?? params.own_code,
+        source_updated_after: params.sourceUpdatedAfter ?? params.source_updated_after,
+        source_updated_before: params.sourceUpdatedBefore ?? params.source_updated_before,
+        observed_after: params.observedAfter ?? params.observed_after,
+        observed_before: params.observedBefore ?? params.observed_before,
+        limit: params.limit,
+        offset: params.offset
+      }
+    });
+  }
+  /**
+   * List available public-ground-truth cache sources and their join-key metadata.
+   */
+  async listSources(params = {}) {
+    return this.client.mcp("tools/call", {
+      name: "list_public_ground_truth_sources",
+      arguments: {
+        query: params.query ?? params.search,
+        status: params.status,
+        limit: params.limit
+      }
+    });
+  }
+};
+
 // src/index.ts
 var MCP_TOOL_CACHE_TTL_MS = 3e4;
 function inferMcpToolCategory(toolName) {
@@ -9084,6 +9964,7 @@ function inferMcpToolCategory(toolName) {
   }
   if (toolName.includes("icp")) return "icp";
   if (toolName.startsWith("ai_clean_")) return "data_cleaning";
+  if (toolName.includes("public_ground_truth")) return "public_data";
   if (toolName.includes("system") || toolName.includes("workflow")) return "automation";
   if (toolName.includes("agent") || toolName.includes("platform_health") || toolName === "discover_capabilities") return "observability";
   return void 0;
@@ -9135,6 +10016,7 @@ var Signaliz = class {
     this.ops = new Ops(this.client);
     this.ai = new Ai(this.client);
     this.gtm = new GtmKernel(this.client);
+    this.publicGroundTruth = new PublicGroundTruth(this.client);
   }
   /** Get current workspace info including credits */
   async getWorkspace() {