@signaliz/sdk 1.0.18 → 1.0.19

package/dist/cli.js

@@ -483,6 +483,38 @@ var init_signals = __esm({
       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 = {
@@ -491,6 +523,9 @@ var init_signals = __esm({
         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
@@ -500,6 +535,16 @@ var init_signals = __esm({
           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,
@@ -540,8 +585,17 @@ var init_signals = __esm({
             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 ? {
@@ -584,6 +638,58 @@ var init_signals = __esm({
           }
         };
       }
+      /** 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
+        };
+      }
     };
   }
 });
@@ -835,6 +941,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,
@@ -1071,7 +1178,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) {
@@ -1111,6 +1219,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
@@ -1376,9 +1485,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,
@@ -1393,6 +1503,7 @@ function createCampaignBuilderAgentPlan(request, context = {}) {
     approvals,
     buildRequest,
     brainPreflight,
+    evidence,
     operatingPlaybooks,
     mcpFlow: createMcpFlow(resolvedRequest, buildRequest, routes, memory, approvals),
     estimatedCredits,
@@ -1484,6 +1595,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);
@@ -1542,6 +1737,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),
@@ -1597,6 +1793,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;
@@ -2288,7 +2534,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"],
@@ -2499,6 +2745,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(
@@ -2530,6 +2778,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,
@@ -2542,6 +2791,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",
@@ -2553,6 +2803,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,
@@ -2563,6 +2814,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
   });
@@ -2575,9 +2827,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,
@@ -2850,7 +3104,7 @@ function createMcpFlow(request, buildRequest, routes, memory, approvals) {
       phase: "plan",
       tool: "nango_mcp_tools_list",
       arguments: {
-        format: "mcp"
+        format: "openai"
       },
       readOnly: true,
       approvalRequired: false
@@ -3159,6 +3413,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,
@@ -3167,7 +3422,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,
@@ -3260,6 +3516,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,
@@ -3309,7 +3566,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) {
@@ -3584,6 +3842,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),
@@ -3685,7 +3944,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;
@@ -4176,6 +4435,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];
 }
@@ -4463,7 +5058,8 @@ var init_campaign_builder_agent = __esm({
       copy: {
         enabled: true,
         tone: "direct",
-        maxBodyWords: 125
+        maxBodyWords: 125,
+        evidenceMode: "signal_led"
       },
       delivery: {
         enabled: true,
@@ -4520,7 +5116,8 @@ var init_campaign_builder_agent = __esm({
           "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",
@@ -4545,7 +5142,8 @@ var init_campaign_builder_agent = __esm({
           "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",
@@ -4570,7 +5168,8 @@ var init_campaign_builder_agent = __esm({
           "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",
@@ -4595,7 +5194,8 @@ var init_campaign_builder_agent = __esm({
           "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",
@@ -4620,7 +5220,8 @@ var init_campaign_builder_agent = __esm({
           "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",
@@ -4645,7 +5246,112 @@ var init_campaign_builder_agent = __esm({
           "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"]
       }
     ];
     CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
@@ -4732,7 +5438,15 @@ var init_campaign_builder_agent = __esm({
         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",
@@ -4805,7 +5519,15 @@ var init_campaign_builder_agent = __esm({
         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",
@@ -4866,7 +5588,15 @@ var init_campaign_builder_agent = __esm({
         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",
@@ -4953,7 +5683,15 @@ var init_campaign_builder_agent = __esm({
         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"
+        ]
       }
     ];
     CampaignBuilderAgent = class {
@@ -4984,6 +5722,9 @@ var init_campaign_builder_agent = __esm({
         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, {
@@ -7924,6 +8665,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;
 var init_ai = __esm({
   "src/resources/ai.ts"() {
@@ -7961,6 +8732,33 @@ var init_ai = __esm({
           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
+        };
+      }
     };
   }
 });
@@ -8623,6 +9421,24 @@ var init_gtm_kernel = __esm({
           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", {
@@ -9123,6 +9939,76 @@ var init_gtm_kernel = __esm({
   }
 });
 
+// src/resources/public-ground-truth.ts
+var PublicGroundTruth;
+var init_public_ground_truth = __esm({
+  "src/resources/public-ground-truth.ts"() {
+    "use strict";
+    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 index_exports = {};
 __export(index_exports, {
@@ -9137,10 +10023,12 @@ __export(index_exports, {
   GtmKernel: () => GtmKernel,
   Icps: () => Icps,
   Ops: () => Ops,
+  PublicGroundTruth: () => PublicGroundTruth,
   Signaliz: () => Signaliz,
   SignalizError: () => SignalizError,
   applyCampaignBuilderStrategyTemplate: () => applyCampaignBuilderStrategyTemplate,
   collectExecutionReferences: () => collectExecutionReferences,
+  createCampaignBuilderActiveWorkContext: () => createCampaignBuilderActiveWorkContext,
   createCampaignBuilderAgentPlan: () => createCampaignBuilderAgentPlan,
   createCampaignBuilderAgentRequestTemplate: () => createCampaignBuilderAgentRequestTemplate,
   createCampaignBuilderApproval: () => createCampaignBuilderApproval,
@@ -9195,6 +10083,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;
@@ -9248,9 +10137,11 @@ var init_index = __esm({
     init_ops();
     init_ai();
     init_gtm_kernel();
+    init_public_ground_truth();
     init_errors();
     init_ai();
     init_gtm_kernel();
+    init_public_ground_truth();
     init_campaigns();
     init_campaign_builder_agent();
     init_icps();
@@ -9272,6 +10163,7 @@ var init_index = __esm({
         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() {
@@ -9430,6 +10322,13 @@ async function main() {
       await handleGtmCommand(signaliz, process.argv.slice(3));
       break;
     }
+    case "public-data":
+    case "ground-truth":
+    case "public-ground-truth": {
+      const signaliz = await createSignalizClient();
+      await handlePublicGroundTruthCommand(signaliz, process.argv.slice(3));
+      break;
+    }
     case "campaign-agent":
     case "campaign-builder": {
       await handleCampaignAgentCommand(createSignalizClient, process.argv.slice(3));
@@ -9439,6 +10338,51 @@ async function main() {
       printHelp();
   }
 }
+async function handlePublicGroundTruthCommand(signaliz, argv) {
+  const subcommand = argv[0] && !argv[0].startsWith("--") ? argv[0] : "search";
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printPublicGroundTruthHelp();
+    return;
+  }
+  if (subcommand === "sources" || subcommand === "list-sources") {
+    const flags2 = parseFlags(argv.slice(subcommand === argv[0] ? 1 : 0));
+    const result2 = await signaliz.publicGroundTruth.listSources({
+      query: stringFlag(flags2, "query", "q", "search"),
+      status: stringFlag(flags2, "status"),
+      limit: numberFlag(flags2, "limit")
+    });
+    if (booleanFlag(flags2, "json")) {
+      printJson(result2);
+    } else {
+      printPublicGroundTruthSources(result2);
+    }
+    return;
+  }
+  if (subcommand !== "search") {
+    throw new Error(`Unknown public-data command: ${subcommand}`);
+  }
+  const flags = parseFlags(argv.slice(subcommand === argv[0] ? 1 : 0));
+  const query = stringFlag(flags, "query", "q", "search");
+  const sourceId = stringFlag(flags, "source-id", "sourceId");
+  const entityType = stringFlag(flags, "entity-type", "entityType");
+  const filters = publicGroundTruthFiltersFromFlags(flags);
+  if (!query && !sourceId && !entityType && Object.keys(filters).length === 0) {
+    throw new Error("public-data search requires --query or at least one filter");
+  }
+  const result = await signaliz.publicGroundTruth.search({
+    query,
+    sourceId,
+    entityType,
+    ...filters,
+    limit: numberFlag(flags, "limit"),
+    offset: numberFlag(flags, "offset")
+  });
+  if (booleanFlag(flags, "json")) {
+    printJson(result);
+  } else {
+    printPublicGroundTruthSearch(result);
+  }
+}
 async function handleGtmCommand(signaliz, argv) {
   const subcommand = argv[0];
   if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
@@ -10425,6 +11369,69 @@ function jsonObjectFromString(value, label) {
   }
   return parsed;
 }
+var PUBLIC_GROUND_TRUTH_CLI_FILTERS = [
+  ["industry", "industry"],
+  ["location", "location"],
+  ["nativeId", "native-id", "nativeId"],
+  ["entityName", "entity-name", "entityName"],
+  ["domain", "domain"],
+  ["websiteUrl", "website-url", "websiteUrl"],
+  ["phone", "phone"],
+  ["email", "email"],
+  ["city", "city"],
+  ["state", "state"],
+  ["postalCode", "postal-code", "postalCode"],
+  ["country", "country"],
+  ["sourceUrl", "source-url", "sourceUrl"],
+  ["naics", "naics"],
+  ["industryCode", "industry-code", "industryCode"],
+  ["industryType", "industry-type", "industryType"],
+  ["year", "year"],
+  ["quarter", "quarter"],
+  ["areaFips", "area-fips", "areaFips"],
+  ["geoId", "geo-id", "geoId"],
+  ["ownCode", "own-code", "ownCode"],
+  ["sourceUpdatedAfter", "source-updated-after", "sourceUpdatedAfter"],
+  ["sourceUpdatedBefore", "source-updated-before", "sourceUpdatedBefore"],
+  ["observedAfter", "observed-after", "observedAfter"],
+  ["observedBefore", "observed-before", "observedBefore"]
+];
+function objectFromKeyValueFlags(flags, keyValueNames, jsonNames) {
+  const object = {};
+  for (const jsonName of jsonNames) {
+    const parsed = jsonObjectFlag(flags, jsonName);
+    if (parsed) Object.assign(object, parsed);
+  }
+  for (const pair of repeatedStringFlag(flags, ...keyValueNames)) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) throw new Error(`Expected key=value for --${keyValueNames[0]}`);
+    const key = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1).trim();
+    if (!key) throw new Error(`Expected non-empty key for --${keyValueNames[0]}`);
+    object[key] = value;
+  }
+  return Object.keys(object).length > 0 ? object : void 0;
+}
+function publicGroundTruthFiltersFromFlags(flags) {
+  const filters = {};
+  for (const [paramName, ...flagNames] of PUBLIC_GROUND_TRUTH_CLI_FILTERS) {
+    const value = stringFlag(flags, ...flagNames);
+    if (value) filters[paramName] = value;
+  }
+  const joinKeys = objectFromKeyValueFlags(
+    flags,
+    ["join-key", "joinKey"],
+    ["join-keys-json", "joinKeysJson"]
+  );
+  const rowData = objectFromKeyValueFlags(
+    flags,
+    ["row-data", "rowData"],
+    ["row-data-json", "rowDataJson"]
+  );
+  if (joinKeys) filters.joinKeys = joinKeys;
+  if (rowData) filters.rowData = rowData;
+  return filters;
+}
 function printResult(result, flags) {
   if (booleanFlag(flags, "json")) {
     printJson(result);
@@ -10501,10 +11508,59 @@ function printCampaignAgentExecution(payload, flags) {
     printJson(payload);
     return;
   }
+  printCampaignAgentOperatorVerdict(payload);
   printCampaignAgentPlan(payload.plan);
   console.log("\nResult:");
   printJson(payload.result);
 }
+function printCampaignAgentOperatorVerdict(payload) {
+  const result = asRecord4(payload.result);
+  const build = hasRecordKeys(asRecord4(result.build)) ? asRecord4(result.build) : result;
+  const finalStatus = asRecord4(result.finalStatus);
+  const deliveryApproval = asRecord4(result.deliveryApproval);
+  const status = textFromRecord(finalStatus, "status") ?? textFromRecord(build, "status") ?? "unknown";
+  const dryRun = build.dryRun === true || build.dry_run === true || status === "dry_run";
+  const campaignBuildId = textFromRecord(build, "campaignBuildId", "campaign_build_id") ?? textFromRecord(finalStatus, "campaignBuildId", "campaign_build_id");
+  const campaignId = textFromRecord(build, "campaignId", "campaign_id") ?? textFromRecord(finalStatus, "campaignId", "campaign_id");
+  if (dryRun) {
+    console.log("Operator verdict: dry run complete; nothing launched.");
+    console.log("Safety: Dry-run only. No spend, provider write, sender load, delivery, or launch ran.");
+  } else if (textFromRecord(finalStatus, "status") === "completed") {
+    console.log("Operator verdict: approved campaign build completed.");
+    console.log("Safety: Approved build path. Review rows and artifacts before any delivery expansion.");
+  } else {
+    console.log(`Operator verdict: approved campaign build ${status}.`);
+    console.log("Safety: Approved build path. Spend and provider writes require the supplied approval packet; delivery remains separately gated.");
+  }
+  console.log(`Approval state: ${campaignAgentApprovalState(payload)}`);
+  if (campaignId) console.log(`Campaign ID: ${campaignId}`);
+  if (campaignBuildId) console.log(`Campaign build ID: ${campaignBuildId}`);
+  if (hasRecordKeys(finalStatus)) console.log(`Final status: ${textFromRecord(finalStatus, "status") ?? "unknown"}`);
+  if (hasRecordKeys(deliveryApproval)) console.log(`Delivery approval: ${textFromRecord(deliveryApproval, "status") ?? "unknown"}`);
+  console.log(`Next safe command: ${campaignAgentNextSafeCommand(payload.plan, dryRun, campaignBuildId)}`);
+  console.log("");
+}
+function campaignAgentApprovalState(payload) {
+  if (payload.approval) return "approval packet supplied";
+  const required = payload.plan.approvals.map((item) => item.type);
+  return required.length ? `missing ${required.join(", ")}` : "no explicit approvals required";
+}
+function campaignAgentNextSafeCommand(plan, dryRun, campaignBuildId) {
+  if (campaignBuildId) return `signaliz campaign-agent review ${campaignBuildId} --limit 100`;
+  if (!dryRun) return "signaliz campaign-agent status <campaign-build-id>";
+  return [
+    "signaliz campaign-agent build-approved",
+    "--goal",
+    shellQuote(plan.campaignName),
+    "--target-count",
+    String(plan.targetCount),
+    "--confirm-launch",
+    "--approve-all",
+    "--approved-by <operator-email>",
+    "--spend-limit",
+    String(plan.estimatedCredits)
+  ].join(" ");
+}
 function printCampaignAgentReadiness(readiness) {
   const summary = asRecord4(readiness.summary);
   const plan = readiness.plan;
@@ -10580,7 +11636,10 @@ function printCampaignCustomerRowCounts(status) {
   if (!counts || typeof counts !== "object") return;
   const value = (camel, snake) => counts[camel] ?? counts[snake] ?? "n/a";
   const requested = value("requestedTarget", "requested_target");
-  console.log(`Customer rows: accepted ${value("acceptedRows", "accepted_rows")}/${requested}, copied ${value("copiedRows", "copied_rows")}, approval-ready ${value("approvalReadyRows", "approval_ready_rows")}, QA-ready ${value("qaReadyRows", "qa_ready_rows")}, delivered ${value("deliveredRows", "delivered_rows")}`);
+  const copied = value("copiedRows", "copied_rows");
+  const copySkipped = value("copySkippedRows", "copy_skipped_rows");
+  const copyLabel = typeof copySkipped === "number" && copySkipped > 0 && (!copied || copied === "n/a") ? `copy-skipped ${copySkipped}` : `copied ${copied}`;
+  console.log(`Customer rows: accepted ${value("acceptedRows", "accepted_rows")}/${requested}, ${copyLabel}, approval-ready ${value("approvalReadyRows", "approval_ready_rows")}, QA-ready ${value("qaReadyRows", "qa_ready_rows")}, delivered ${value("deliveredRows", "delivered_rows")}`);
   const shortfalls = [
     ["accepted", value("acceptedShortfall", "accepted_shortfall")],
     ["usable", value("usableShortfall", "usable_shortfall")],
@@ -10715,6 +11774,20 @@ function printCampaignAgentCopySnippets(rows, limit = 5) {
 function asRecord4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function hasRecordKeys(value) {
+  return Object.keys(value).length > 0;
+}
+function textFromRecord(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  }
+  return void 0;
+}
+function shellQuote(value) {
+  return `'${String(value || "").replace(/'/g, `'\\''`)}'`;
+}
 function printCampaignAgentProof(proof) {
   console.log(`Campaign-agent proof: ${proof.success ? "passed" : "failed"}`);
   const campaign = asRecord4(proof.campaign);
@@ -10732,6 +11805,51 @@ function printCampaignAgentProof(proof) {
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
+function truncateCell(value, width) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  return text.length > width ? `${text.slice(0, Math.max(width - 3, 0))}...` : text;
+}
+function printPublicGroundTruthSearch(result) {
+  const records = Array.isArray(result.records) ? result.records : [];
+  console.log(`Public data search: ${result.total_count ?? 0} matches (${records.length} returned)`);
+  if (result.query) console.log(`Query: ${result.query}`);
+  if (result.source_id) console.log(`Source: ${result.source_id}`);
+  if (result.entity_type) console.log(`Entity type: ${result.entity_type}`);
+  if (!records.length) {
+    console.log("No records matched.");
+    return;
+  }
+  console.log("");
+  console.log("Source".padEnd(22) + "Native ID".padEnd(22) + "Name".padEnd(42) + "Industry".padEnd(28) + "Domain".padEnd(24) + "Loc".padEnd(12) + "Match");
+  console.log("-".repeat(160));
+  for (const record of records) {
+    const loc = [record.city, record.state].filter(Boolean).join(", ");
+    const industry = [record.industry_code, record.industry_name].filter(Boolean).join(" ");
+    console.log(
+      truncateCell(record.source_id, 21).padEnd(22) + truncateCell(record.native_id, 21).padEnd(22) + truncateCell(record.entity_name, 41).padEnd(42) + truncateCell(industry, 27).padEnd(28) + truncateCell(record.domain, 23).padEnd(24) + truncateCell(loc, 11).padEnd(12) + truncateCell(record.match_type, 16)
+    );
+  }
+  if (result.next_offset !== null && result.next_offset !== void 0) {
+    console.log(`
+Next page: --offset ${result.next_offset}`);
+  }
+}
+function printPublicGroundTruthSources(result) {
+  const sources = Array.isArray(result.sources) ? result.sources : [];
+  console.log(`Public data sources: ${sources.length}/${result.total ?? sources.length}`);
+  if (!sources.length) {
+    console.log("No sources matched.");
+    return;
+  }
+  console.log("");
+  console.log("Source ID".padEnd(30) + "Status".padEnd(12) + "Rung".padEnd(7) + "Join key".padEnd(20) + "Cadence".padEnd(16) + "Name");
+  console.log("-".repeat(120));
+  for (const source of sources) {
+    console.log(
+      truncateCell(source.id, 29).padEnd(30) + truncateCell(source.ingestion_status, 11).padEnd(12) + String(source.ground_truth_rung ?? "").padEnd(7) + truncateCell(source.primary_join_key || source.join_key_quality, 19).padEnd(20) + truncateCell(source.update_cadence, 15).padEnd(16) + truncateCell(source.name, 40)
+    );
+  }
+}
 function printHelp() {
   console.log(`
 Signaliz CLI v1.0.0
@@ -10739,6 +11857,8 @@ Signaliz CLI v1.0.0
 Usage:
   signaliz test                       Verify API connectivity
   signaliz tools                      List all available MCP tools
+  signaliz public-data search --query "swift transportation" --limit 10
+  signaliz public-data sources --status ready
   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
@@ -10769,6 +11889,25 @@ Environment:
   SIGNALIZ_BASE_URL  Optional API base URL override
 `);
 }
+function printPublicGroundTruthHelp() {
+  console.log(`
+Signaliz public-data commands:
+
+  signaliz public-data search [--query TEXT] [--industry TEXT] [--location TEXT] [--source-id ID] [--domain DOMAIN] [--naics CODE] [--state ST] [--year YYYY] [--join-key k=v] [--row-data k=v] [--limit N] [--offset N] [--json]
+  signaliz public-data sources [--query TEXT] [--status ready|partial|blocked|planned] [--limit N] [--json]
+
+Aliases:
+  signaliz ground-truth search ...
+
+Examples:
+  signaliz public-data search --query "swift transportation" --source-id fmcsa_company_census --limit 10
+  signaliz public-data search --industry "software publishers" --location CA --limit 25 --json
+  signaliz public-data search --source-id bls_qcew --naics 541511 --state CA --year 2025 --json
+  signaliz public-data search --domain swifttrans.com --json
+  signaliz public-data search --join-key ein=123456789 --json
+  signaliz public-data sources --status ready --json
+`);
+}
 function printGtmHelp() {
   console.log(`
 Signaliz GTM commands: