@signaliz/sdk 1.0.17 → 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,
@@ -881,6 +988,9 @@ function recordOrNull(value) {
 function stringArray(value) {
   return Array.isArray(value) ? value.map((item) => String(item || "").trim()).filter(Boolean) : [];
 }
+function recordArray(value) {
+  return Array.isArray(value) ? value.map(recordOrNull).filter((item) => Boolean(item)) : [];
+}
 function diagnosticMessages(value) {
   if (!Array.isArray(value)) return [];
   return value.map((item) => {
@@ -1042,7 +1152,8 @@ function buildArgs(request) {
       suppress_prior_campaign_ids: request.cacheReusePolicy.suppressPriorCampaignIds,
       suppress_prior_list_ids: request.cacheReusePolicy.suppressPriorListIds,
       uniqueness: request.cacheReusePolicy.uniqueness,
-      require_usage_metadata: request.cacheReusePolicy.requireUsageMetadata
+      require_usage_metadata: request.cacheReusePolicy.requireUsageMetadata,
+      verified_cache_ttl_days: request.cacheReusePolicy.verifiedCacheTtlDays
     };
   }
   if (request.brainPreflight) args.brain_preflight = request.brainPreflight;
@@ -1067,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) {
@@ -1107,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
@@ -1247,7 +1360,11 @@ var init_campaigns = __esm({
           maxSupportedTargetCount: data.max_supported_target_count,
           brainContext: data.brain_context ?? {},
           learningHoldout: data.learning_holdout ?? {},
-          providerRoute: mapProviderRoute(data)
+          providerRoute: mapProviderRoute(data),
+          effectiveSourceRouting: recordOrNull(data.effective_source_routing ?? data.source_routing),
+          sourcePlan: recordOrNull(data.source_plan ?? data.plan?.source_plan),
+          sourceRoutes: recordArray(data.source_routes ?? data.source_plan?.routes ?? data.plan?.source_plan?.routes),
+          sourceShards: recordArray(data.source_shards ?? data.source_plan?.shards ?? data.plan?.source_plan?.shards)
         };
       }
       async getCampaignBuildStatus(campaignBuildId) {
@@ -1368,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,
@@ -1385,6 +1503,7 @@ function createCampaignBuilderAgentPlan(request, context = {}) {
     approvals,
     buildRequest,
     brainPreflight,
+    evidence,
     operatingPlaybooks,
     mcpFlow: createMcpFlow(resolvedRequest, buildRequest, routes, memory, approvals),
     estimatedCredits,
@@ -1476,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);
@@ -1534,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),
@@ -1589,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;
@@ -2280,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"],
@@ -2446,6 +2700,21 @@ function routesFromCustomerTools(tools) {
     }))
   );
 }
+function normalizeCampaignBuilderLearningHoldout(input, gtmCampaignId, campaignName) {
+  const source = asRecord(input);
+  if (source.enabled === false) return { enabled: false };
+  const controlPercentage = numberOrUndefined2(source.control_percentage ?? source.controlPercentage);
+  const minControlSize = numberOrUndefined2(source.min_control_size ?? source.minControlSize);
+  const experimentKey = stringValue(source.experiment_key ?? source.experimentKey) ?? (gtmCampaignId ? `gtm_campaign:${gtmCampaignId}:learning_holdout` : `campaign_builder_agent:${hashString(campaignName)}:learning_holdout`);
+  return {
+    enabled: true,
+    controlPercentage: controlPercentage ?? 0.2,
+    minControlSize: minControlSize ?? 50,
+    experimentKey,
+    sourceCampaignId: stringValue(source.source_campaign_id ?? source.sourceCampaignId) ?? gtmCampaignId,
+    primaryMetric: stringValue(source.primary_metric ?? source.primaryMetric) ?? "positive_reply_rate"
+  };
+}
 function createBuildRequest(request, defaults, targetCount, campaignName, scopeBuildArgs, routes = [], memory, scopeBrainPreflight) {
   const buildRequest = {
     name: campaignName,
@@ -2476,8 +2745,15 @@ 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(
+    request.learningHoldout ?? scoped.learning_holdout ?? scoped.learningHoldout,
+    buildRequest.gtmCampaignId,
+    campaignName
+  );
   if (typeof scoped.name === "string") buildRequest.name = scoped.name;
   if (typeof scoped.prompt === "string") buildRequest.prompt = scoped.prompt;
   if (typeof scoped.target_count === "number") buildRequest.targetCount = scoped.target_count;
@@ -2502,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,
@@ -2514,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",
@@ -2525,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,
@@ -2535,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
   });
@@ -2547,11 +2827,14 @@ 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,
     tool_sequence: [
       { tool: "gtm_brain_learning_cycle_plan", purpose: "Plan the Brain learning loop for this campaign.", arguments: learningArgs },
       { tool: "gtm_brain_seed_defaults", purpose: "Seed campaign defaults from workspace memory and safe aggregate patterns.", arguments: defaultsArgs },
@@ -2821,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
@@ -3130,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,
@@ -3138,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,
@@ -3219,8 +3504,19 @@ function buildCampaignArgs(request) {
   if (request.dedupKeys) args.dedup_keys = request.dedupKeys;
   if (request.brainPreflight) args.brain_preflight = request.brainPreflight;
   if (request.brainDefaults) args.brain_defaults = request.brainDefaults;
+  if (request.learningHoldout) {
+    args.learning_holdout = compact({
+      enabled: request.learningHoldout.enabled,
+      control_percentage: request.learningHoldout.controlPercentage,
+      min_control_size: request.learningHoldout.minControlSize,
+      experiment_key: request.learningHoldout.experimentKey,
+      source_campaign_id: request.learningHoldout.sourceCampaignId,
+      primary_metric: request.learningHoldout.primaryMetric
+    });
+  }
   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,
@@ -3270,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) {
@@ -3315,6 +3612,7 @@ function buildExecutionPrepareArgs(request, dryRun, confirmSpend) {
     delivery_risk: buildArgs2.delivery_risk,
     dedup_keys: buildArgs2.dedup_keys,
     policy: buildArgs2.policy,
+    learning_holdout: buildArgs2.learning_holdout,
     signals: buildArgs2.signals,
     qualification: buildArgs2.qualification,
     copy: buildArgs2.copy,
@@ -3349,10 +3647,143 @@ function mapBuildResult(data, dryRun) {
     targetLimitReason: data.target_limit_reason,
     maxSupportedTargetCount: data.max_supported_target_count,
     brainContext: data.brain_context ?? {},
+    learningHoldout: data.learning_holdout ?? {},
     providerRoute: mapProviderRoute2(data)
   };
 }
+function mapAgentCampaignPhaseHealth(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((phase) => {
+    const record = asRecord(phase);
+    return {
+      phase: stringValue(record.phase) ?? "unknown",
+      status: stringValue(record.status) ?? "unknown",
+      recordsProcessed: numberOrNull2(record.records_processed ?? record.recordsProcessed),
+      recordsSucceeded: numberOrNull2(record.records_succeeded ?? record.recordsSucceeded),
+      recordsFailed: numberOrNull2(record.records_failed ?? record.recordsFailed),
+      heartbeatAgeSeconds: numberOrNull2(record.heartbeat_age_seconds ?? record.heartbeatAgeSeconds ?? record.phase_age_seconds)
+    };
+  });
+}
+function deriveCampaignBuildTerminalState(input) {
+  const status = input.status.toLowerCase();
+  const heartbeatAgeSeconds = input.phaseAgeSeconds;
+  const stale = input.staleRunningPhase === true;
+  const safeWatchAction = input.triggerRunId ? `signaliz ops run-status ${input.triggerRunId} --watch` : "signaliz campaign-agent status <campaign_build_id>";
+  if (CAMPAIGN_BUILDER_BLOCKED_TERMINAL_STATUSES.has(status)) {
+    return {
+      kind: "blocked",
+      label: "Blocked terminal state",
+      reviewable: true,
+      terminal: true,
+      stale: false,
+      phase: input.phase,
+      phaseStatus: input.phaseStatus,
+      heartbeatAgeSeconds,
+      nextPollAfterSeconds: input.nextPollAfterSeconds,
+      terminalReason: input.terminalReason,
+      staleReason: null,
+      safeNextAction: input.nextAction || "Review errors and rerun only after the blocker is resolved."
+    };
+  }
+  if (status === "pending_approval") {
+    return {
+      kind: "pending_approval",
+      label: "Pending delivery approval",
+      reviewable: true,
+      terminal: false,
+      stale: false,
+      phase: input.phase,
+      phaseStatus: input.phaseStatus,
+      heartbeatAgeSeconds,
+      nextPollAfterSeconds: input.nextPollAfterSeconds,
+      terminalReason: input.terminalReason,
+      staleReason: null,
+      safeNextAction: input.approvalAction || input.nextAction || "Review rows and approve delivery only after the approval packet passes."
+    };
+  }
+  if (CAMPAIGN_BUILDER_TERMINAL_STATUSES.has(status)) {
+    return {
+      kind: "terminal",
+      label: "Terminal and reviewable",
+      reviewable: true,
+      terminal: true,
+      stale: false,
+      phase: input.phase,
+      phaseStatus: input.phaseStatus,
+      heartbeatAgeSeconds,
+      nextPollAfterSeconds: input.nextPollAfterSeconds,
+      terminalReason: input.terminalReason,
+      staleReason: null,
+      safeNextAction: input.nextAction || "Review rows, artifacts, scorecard, and approval locks before delivery."
+    };
+  }
+  if (status === "running" || status === "queued" || status === "processing") {
+    if (stale) {
+      return {
+        kind: "running_stale",
+        label: "Running but stale",
+        reviewable: false,
+        terminal: false,
+        stale: true,
+        phase: input.phase,
+        phaseStatus: input.phaseStatus,
+        heartbeatAgeSeconds,
+        nextPollAfterSeconds: input.nextPollAfterSeconds,
+        terminalReason: null,
+        staleReason: input.staleReason || "The active phase heartbeat is stale.",
+        safeNextAction: input.nextAction || safeWatchAction
+      };
+    }
+    return {
+      kind: "running_healthy",
+      label: "Running and healthy",
+      reviewable: false,
+      terminal: false,
+      stale: false,
+      phase: input.phase,
+      phaseStatus: input.phaseStatus,
+      heartbeatAgeSeconds,
+      nextPollAfterSeconds: input.nextPollAfterSeconds,
+      terminalReason: null,
+      staleReason: null,
+      safeNextAction: input.nextAction || safeWatchAction
+    };
+  }
+  return {
+    kind: "unknown",
+    label: "Unknown build state",
+    reviewable: false,
+    terminal: false,
+    stale,
+    phase: input.phase,
+    phaseStatus: input.phaseStatus,
+    heartbeatAgeSeconds,
+    nextPollAfterSeconds: input.nextPollAfterSeconds,
+    terminalReason: input.terminalReason,
+    staleReason: input.staleReason,
+    safeNextAction: input.nextAction || "Read campaign build status again before making a launch or delivery decision."
+  };
+}
 function mapAgentCampaignBuildStatus(data) {
+  const customerRowCounts = mapAgentCustomerRowCounts(data.customer_row_counts);
+  const phaseHealth = mapAgentCampaignPhaseHealth(data.phases);
+  const terminalReason = stringValue(data.terminal_reason) ?? customerRowCounts?.terminalReason ?? null;
+  const staleReason = stringValue(data.stale_reason) ?? stringValue(asRecord(data.diagnostics).stale_reason) ?? null;
+  const nextPollAfterSeconds = numberOrNull2(data.next_poll_after_seconds ?? data.nextPollAfterSeconds);
+  const terminalState = deriveCampaignBuildTerminalState({
+    status: stringValue(data.status) ?? "unknown",
+    phase: stringValue(data.current_phase) ?? null,
+    phaseStatus: stringValue(data.current_phase_status) ?? null,
+    staleRunningPhase: data.stale_running_phase === true,
+    phaseAgeSeconds: numberOrNull2(data.phase_age_seconds),
+    nextPollAfterSeconds,
+    terminalReason,
+    staleReason,
+    nextAction: formatAgentNextAction(data.next_action),
+    approvalAction: formatAgentNextAction(data.approval_action),
+    triggerRunId: stringValue(data.trigger_run_id) ?? null
+  });
   return {
     campaignBuildId: stringValue(data.campaign_build_id) ?? "",
     campaignId: stringValue(data.campaign_id) ?? null,
@@ -3370,12 +3801,18 @@ function mapAgentCampaignBuildStatus(data) {
     errors: diagnosticMessages2(data.errors),
     artifactCount: numberOrUndefined2(data.artifact_count) ?? 0,
     artifactDownloads: Array.isArray(data.artifact_downloads) ? data.artifact_downloads.map(mapAgentCampaignArtifactDownload) : [],
-    customerRowCounts: mapAgentCustomerRowCounts(data.customer_row_counts),
+    customerRowCounts,
     phaseAttemptTotals: nullableRecord(data.phase_attempt_totals) ?? void 0,
     providerRoute: mapProviderRoute2(data),
     triggerRunId: stringValue(data.trigger_run_id) ?? null,
     staleRunningPhase: data.stale_running_phase === true,
     phaseAgeSeconds: numberOrNull2(data.phase_age_seconds),
+    nextPollAfterSeconds,
+    terminalReason,
+    staleReason,
+    safeNextAction: terminalState.safeNextAction,
+    terminalState,
+    phaseHealth,
     diagnostics: nullableRecord(data.diagnostics) ?? {},
     nextAction: formatAgentNextAction(data.next_action),
     approvalAction: formatAgentNextAction(data.approval_action),
@@ -3405,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),
@@ -3463,67 +3901,276 @@ function mapAgentCampaignArtifact(data) {
     createdAt: stringValue(data.created_at) ?? ""
   };
 }
+function campaignReviewGate(id, label, status, detail) {
+  return {
+    id,
+    label,
+    status,
+    passed: status !== "blocked",
+    detail
+  };
+}
+function northStarMetric(id, label, status, detail, value, target) {
+  return {
+    id,
+    label,
+    status,
+    detail,
+    ...value !== void 0 ? { value } : {},
+    ...target !== void 0 ? { target } : {}
+  };
+}
+function createCampaignBuilderNorthStarScorecard(status, rows, artifacts, terminalState) {
+  if (!terminalState.reviewable) {
+    const pendingMetric = northStarMetric(
+      "terminal_state",
+      "Terminal-state contract",
+      terminalState.kind === "running_stale" ? "blocked" : "pending",
+      terminalState.kind === "running_stale" ? `Build is stale in ${terminalState.phase || "unknown phase"}; do not grade output yet.` : `Build is ${terminalState.label.toLowerCase()}; wait for terminal or approval state before grading.`,
+      terminalState.kind,
+      "terminal or pending_approval"
+    );
+    return {
+      version: "campaign-builder-north-star.v1",
+      status: pendingMetric.status,
+      score: null,
+      moatState: "scaffolding_ready",
+      metrics: [pendingMetric],
+      blockers: pendingMetric.status === "blocked" ? [pendingMetric.detail] : [],
+      warnings: pendingMetric.status === "pending" ? [pendingMetric.detail] : [],
+      nextAction: terminalState.safeNextAction
+    };
+  }
+  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?.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;
+  const uniqueDomains = new Set(rowData.map(campaignReviewDataDomain).filter(Boolean)).size;
+  const copyReadyRows = rows.rows.filter(campaignReviewRowHasCopy).length;
+  const copyQaIssuesByRow = rowData.map(campaignReviewDataCopyQaIssues).filter((issues) => issues.length > 0);
+  const copyQaIssueCounts = countCampaignReviewIssues(copyQaIssuesByRow);
+  const signalBackedRows = rowData.filter(campaignReviewDataHasSignalBasis).length;
+  const noSupportedSignalRows = rowData.filter(campaignReviewDataHasNoSupportedSignal).length;
+  const unsupportedSignalClaims = rowData.filter(campaignReviewDataHasUnsupportedSignalClaim).length;
+  const approvalLockedRows = rowData.filter(campaignReviewDataHasApprovalLock).length;
+  const holdoutRows = rowData.filter(campaignReviewDataHasHoldoutAttribution).length;
+  const artifactCount = artifacts.length || status.artifactCount || 0;
+  const deliveredRows = status.customerRowCounts?.deliveredRows ?? 0;
+  const feedbackReady = campaignReviewStatusHasFeedbackReadiness(status);
+  const feedbackRequiredForApproval = terminalState.kind === "pending_approval";
+  const moat = campaignReviewMoatState(status, holdoutRows);
+  const metrics = [
+    northStarMetric(
+      "terminal_state",
+      "Terminal-state contract",
+      terminalState.kind === "blocked" ? "blocked" : "pass",
+      terminalState.label,
+      terminalState.kind,
+      "terminal or pending_approval"
+    ),
+    northStarMetric(
+      "target_fill",
+      "Target fill",
+      requestedTarget && finalRows < requestedTarget ? "review" : "pass",
+      requestedTarget ? `${finalRows || 0}/${requestedTarget} final or reviewable row(s) are accounted for.` : "No requested target was reported; using sampled rows for review.",
+      finalRows || sampledRows,
+      requestedTarget || sampledRows
+    ),
+    northStarMetric(
+      "unique_emails",
+      "Unique emails",
+      sampledRows === 0 ? "blocked" : uniqueEmails === rowsWithEmail ? "pass" : "blocked",
+      sampledRows === 0 ? "No sampled rows were available for email uniqueness review." : `${uniqueEmails}/${rowsWithEmail} sampled email(s) are unique.`,
+      uniqueEmails,
+      rowsWithEmail
+    ),
+    northStarMetric(
+      "unique_domains",
+      "Unique domains",
+      sampledRows === 0 ? "blocked" : uniqueDomains === sampledRows ? "pass" : "review",
+      sampledRows === 0 ? "No sampled rows were available for domain uniqueness review." : `${uniqueDomains}/${sampledRows} sampled company domain(s) are unique.`,
+      uniqueDomains,
+      sampledRows
+    ),
+    northStarMetric(
+      "verified_email_rows",
+      "Verified email rows",
+      sampledRows === 0 ? "blocked" : verifiedEmailRows === sampledRows ? "pass" : rowsWithEmail === sampledRows ? "review" : "blocked",
+      sampledRows === 0 ? "No sampled rows were available for email verification review." : `${verifiedEmailRows}/${sampledRows} sampled row(s) carry verified-email evidence.`,
+      verifiedEmailRows,
+      sampledRows
+    ),
+    northStarMetric(
+      "copy_completeness",
+      "Copy completeness",
+      sampledRows === 0 ? "blocked" : copyReadyRows === sampledRows ? "pass" : "blocked",
+      sampledRows === 0 ? "No sampled rows were available for copy review." : `${copyReadyRows}/${sampledRows} sampled row(s) include generated copy.`,
+      copyReadyRows,
+      sampledRows
+    ),
+    northStarMetric(
+      "copy_quality",
+      "Copy QA",
+      copyQaIssuesByRow.length === 0 ? "pass" : "blocked",
+      copyQaIssuesByRow.length === 0 ? "No sampled copy QA blockers were detected." : `${copyQaIssuesByRow.length}/${sampledRows} sampled row(s) have copy QA issue(s): ${formatCampaignReviewIssueCounts(copyQaIssueCounts)}.`,
+      copyQaIssuesByRow.length,
+      0
+    ),
+    northStarMetric(
+      "signal_grounding",
+      "Signal grounding",
+      unsupportedSignalClaims > 0 ? "blocked" : signalBackedRows > 0 ? "pass" : "review",
+      unsupportedSignalClaims > 0 ? `${unsupportedSignalClaims} sampled row(s) make unsupported signal claims.` : signalBackedRows > 0 ? `${signalBackedRows}/${sampledRows} sampled row(s) include supported signal or personalization basis.` : noSupportedSignalRows > 0 ? `${noSupportedSignalRows}/${sampledRows} sampled row(s) are explicitly marked no_supported_signal; copy should stay conservative.` : "No sampled rows include supported signal evidence; copy should stay conservative.",
+      signalBackedRows,
+      sampledRows
+    ),
+    northStarMetric(
+      "approval_locks",
+      "Approval locks",
+      approvalLockedRows > 0 || deliveredRows === 0 ? "pass" : "review",
+      approvalLockedRows > 0 ? `${approvalLockedRows}/${sampledRows} sampled row(s) show approval/export lock metadata.` : "Approval-lock metadata was not visible in sampled rows; preserve delivery approval gates.",
+      approvalLockedRows,
+      sampledRows
+    ),
+    northStarMetric(
+      "export_send_safety",
+      "Export/send safety",
+      deliveredRows > 0 && status.status !== "completed" ? "blocked" : "pass",
+      deliveredRows > 0 ? `${deliveredRows} row(s) are delivered; status is ${status.status}.` : "No delivered rows are reported before approval.",
+      deliveredRows,
+      0
+    ),
+    northStarMetric(
+      "holdout_attribution",
+      "Holdout attribution",
+      holdoutRows > 0 ? "pass" : "review",
+      holdoutRows > 0 ? `${holdoutRows}/${sampledRows} sampled row(s) preserve holdout attribution.` : "No holdout attribution was visible in the sampled rows.",
+      holdoutRows,
+      sampledRows
+    ),
+    northStarMetric(
+      "feedback_readiness",
+      "Feedback readiness",
+      feedbackReady ? "pass" : feedbackRequiredForApproval ? "blocked" : "review",
+      feedbackReady ? "Feedback readiness is visible in status diagnostics." : feedbackRequiredForApproval ? "Feedback webhook or approved pull readiness is required before delivery approval." : "Feedback webhook or approved pull readiness was not visible; require it before real send approval.",
+      feedbackReady,
+      true
+    ),
+    northStarMetric(
+      "causal_moat",
+      "Causal moat",
+      moat.state === "proved" ? "pass" : "review",
+      moat.detail,
+      moat.state,
+      "proved"
+    ),
+    northStarMetric(
+      "artifact_readback",
+      "Artifact readback",
+      artifactCount > 0 ? "pass" : "review",
+      artifactCount > 0 ? `${artifactCount} artifact(s) are available for review.` : "No review artifact is available yet.",
+      artifactCount,
+      1
+    )
+  ];
+  const gradedMetrics = metrics.filter((metric) => metric.status !== "pending");
+  const score = gradedMetrics.length === 0 ? null : Math.round(gradedMetrics.filter((metric) => metric.status === "pass").length / gradedMetrics.length * 100);
+  const blockers = metrics.filter((metric) => metric.status === "blocked").map((metric) => metric.detail);
+  const warnings = metrics.filter((metric) => metric.status === "review").map((metric) => metric.detail);
+  const scorecardStatus = blockers.length > 0 ? "blocked" : warnings.length > 0 ? "review" : "pass";
+  return {
+    version: "campaign-builder-north-star.v1",
+    status: scorecardStatus,
+    score,
+    moatState: moat.state,
+    metrics,
+    blockers,
+    warnings,
+    nextAction: scorecardStatus === "blocked" ? "Fix blocked North Star gates before approval or delivery." : terminalState.safeNextAction
+  };
+}
 function createCampaignBuilderBuildReview(status, rows, artifacts) {
+  const terminalState = status.terminalState ?? deriveCampaignBuildTerminalState({
+    status: status.status,
+    phase: status.currentPhase,
+    phaseStatus: status.currentPhaseStatus,
+    staleRunningPhase: status.staleRunningPhase === true,
+    phaseAgeSeconds: status.phaseAgeSeconds ?? null,
+    nextPollAfterSeconds: status.nextPollAfterSeconds ?? null,
+    terminalReason: status.terminalReason ?? status.customerRowCounts?.terminalReason ?? null,
+    staleReason: status.staleReason ?? null,
+    nextAction: status.nextAction,
+    approvalAction: status.approvalAction,
+    triggerRunId: status.triggerRunId ?? null
+  });
   const sampledRows = rows.rows.length;
   const availableRows = rows.count || sampledRows;
   const qualifiedRows = rows.rows.filter((row) => row.qualified !== false).length;
   const rowsWithEmail = rows.rows.filter(campaignReviewRowHasEmail).length;
   const copyReadyRows = rows.rows.filter(campaignReviewRowHasCopy).length;
   const artifactCount = artifacts.length || status.artifactCount || 0;
+  const northStarScorecard = createCampaignBuilderNorthStarScorecard(status, rows, artifacts, terminalState);
   const gates = [
-    {
-      id: "build_completed",
-      label: "Build completed",
-      passed: status.status === "completed",
-      detail: status.status === "completed" ? "The campaign build is completed." : `The campaign build is ${status.status}; review again after completion.`
-    },
-    {
-      id: "rows_available",
-      label: "Rows available",
-      passed: sampledRows > 0,
-      detail: sampledRows > 0 ? `${sampledRows} sampled row(s) are available for review.` : "No rows were returned for review."
-    },
-    {
-      id: "qualified_sample",
-      label: "Sample rows qualified",
-      passed: sampledRows > 0 && qualifiedRows === sampledRows,
-      detail: sampledRows > 0 ? `${qualifiedRows}/${sampledRows} sampled row(s) are marked qualified.` : "Qualification could not be checked without sampled rows."
-    },
-    {
-      id: "email_coverage",
-      label: "Email coverage",
-      passed: sampledRows > 0 && rowsWithEmail === sampledRows,
-      detail: sampledRows > 0 ? `${rowsWithEmail}/${sampledRows} sampled row(s) include an email.` : "Email coverage could not be checked without sampled rows."
-    },
-    {
-      id: "artifact_available",
-      label: "Artifact available",
-      passed: artifactCount > 0,
-      detail: artifactCount > 0 ? `${artifactCount} artifact(s) are available.` : "No delivery artifact is available yet."
-    },
-    {
-      id: "no_failed_rows",
-      label: "No failed rows",
-      passed: status.recordsFailed === 0,
-      detail: status.recordsFailed === 0 ? "The build reports zero failed rows." : `${status.recordsFailed} row(s) failed during the build.`
-    }
+    campaignReviewGate(
+      "build_reviewable",
+      "Build reviewable",
+      terminalState.kind === "running_healthy" ? "pending" : terminalState.kind === "running_stale" || terminalState.kind === "blocked" ? "blocked" : "pass",
+      terminalState.label
+    ),
+    campaignReviewGate(
+      "rows_available",
+      "Rows available",
+      sampledRows > 0 ? "pass" : terminalState.reviewable ? "blocked" : "pending",
+      sampledRows > 0 ? `${sampledRows} sampled row(s) are available for review.` : terminalState.reviewable ? "No rows were returned for review." : "Rows are not graded until the build is reviewable."
+    ),
+    campaignReviewGate(
+      "qualified_sample",
+      "Sample rows qualified",
+      sampledRows === 0 ? terminalState.reviewable ? "blocked" : "pending" : qualifiedRows === sampledRows ? "pass" : "blocked",
+      sampledRows > 0 ? `${qualifiedRows}/${sampledRows} sampled row(s) are marked qualified.` : "Qualification could not be checked without sampled rows."
+    ),
+    campaignReviewGate(
+      "email_coverage",
+      "Email coverage",
+      sampledRows === 0 ? terminalState.reviewable ? "blocked" : "pending" : rowsWithEmail === sampledRows ? "pass" : "blocked",
+      sampledRows > 0 ? `${rowsWithEmail}/${sampledRows} sampled row(s) include an email.` : "Email coverage could not be checked without sampled rows."
+    ),
+    campaignReviewGate(
+      "artifact_available",
+      "Artifact available",
+      artifactCount > 0 ? "pass" : terminalState.reviewable ? "review" : "pending",
+      artifactCount > 0 ? `${artifactCount} artifact(s) are available.` : "No delivery artifact is available yet."
+    ),
+    campaignReviewGate(
+      "no_failed_rows",
+      "No failed rows",
+      status.recordsFailed === 0 ? "pass" : "blocked",
+      status.recordsFailed === 0 ? "The build reports zero failed rows." : `${status.recordsFailed} row(s) failed during the build.`
+    )
   ];
-  const blockedReasons = gates.filter((gate) => !gate.passed).map((gate) => gate.detail);
+  const blockedReasons = gates.filter((gate) => gate.status === "blocked" || !gate.passed).map((gate) => gate.detail);
   const warnings = [
     rows.hasMore ? "This review is based on a row sample; page through remaining rows before final approval." : void 0,
     sampledRows > 0 && copyReadyRows < sampledRows ? `${copyReadyRows}/${sampledRows} sampled row(s) include generated copy.` : void 0,
     ...status.warnings
   ].filter((item) => Boolean(item));
-  const readyForDeliveryApproval = blockedReasons.length === 0;
+  const readyForDeliveryApproval = terminalState.reviewable && blockedReasons.length === 0 && northStarScorecard.status !== "blocked";
   return {
     campaignBuildId: status.campaignBuildId || rows.campaignBuildId,
     status,
     rows,
     artifacts,
     gates,
+    northStarScorecard,
     summary: {
       status: status.status,
       phase: status.currentPhase,
+      terminalState: terminalState.kind,
+      scorecardStatus: northStarScorecard.status,
+      scorecardScore: northStarScorecard.score,
       sampledRows,
       availableRows,
       qualifiedRows,
@@ -3577,6 +4224,184 @@ function campaignReviewRowHasCopy(row) {
     stringValue(data.subject) || stringValue(data.subject_line) || stringValue(data.subjectLine) || stringValue(data.opener) || stringValue(data.body) || stringValue(data.cta) || stringValue(copy.subject) || stringValue(copy.body) || stringValue(rawCopy.subject) || stringValue(rawCopy.body)
   );
 }
+function campaignReviewDataEmail(data) {
+  return stringValue(data.email) || stringValue(data.work_email) || stringValue(data.workEmail) || stringValue(asRecord(data.contact).email);
+}
+function campaignReviewDataDomain(data) {
+  const domain = stringValue(data.company_domain) || stringValue(data.companyDomain) || stringValue(asRecord(data.company).domain);
+  return domain?.toLowerCase();
+}
+function campaignReviewDataHasVerifiedEmail(data) {
+  const status = String(data.email_status ?? data.emailStatus ?? asRecord(data.contact).email_status ?? "").toLowerCase();
+  return data.email_verified === true || data.emailVerified === true || asRecord(data.contact).email_verified === true || ["valid", "validated", "verified"].includes(status);
+}
+function campaignReviewDataCopyParts(data) {
+  const copy = asRecord(data.copy);
+  const rawCopy = asRecord(data.raw_copy ?? data.rawCopy);
+  return [
+    stringValue(data.subject),
+    stringValue(data.subject_line),
+    stringValue(data.opener),
+    stringValue(data.body),
+    stringValue(data.cta),
+    stringValue(copy.subject),
+    stringValue(copy.opener),
+    stringValue(copy.body),
+    stringValue(copy.cta),
+    stringValue(rawCopy.subject),
+    stringValue(rawCopy.opener),
+    stringValue(rawCopy.body),
+    stringValue(rawCopy.cta)
+  ].filter((part) => Boolean(part));
+}
+function campaignReviewDataHasBadGreeting(data) {
+  return campaignReviewDataCopyParts(data).some(
+    (part) => /\bhi\s*(?:,|\{\{|\[)|\bhello\s*(?:,|\{\{|\[)/i.test(part) || /\b(first_name|firstname|name)\b/i.test(part)
+  );
+}
+function campaignReviewDataHasBannedPhrase(data) {
+  const text = campaignReviewDataCopyParts(data).join(" ").toLowerCase();
+  return NORTH_STAR_BANNED_COPY_PHRASES.some((phrase) => text.includes(phrase));
+}
+function campaignReviewDataSubject(data) {
+  const copy = asRecord(data.copy);
+  const rawCopy = asRecord(data.raw_copy ?? data.rawCopy);
+  return stringValue(data.subject) || stringValue(data.subject_line) || stringValue(data.subjectLine) || stringValue(copy.subject) || stringValue(rawCopy.subject);
+}
+function campaignReviewDataCta(data) {
+  const copy = asRecord(data.copy);
+  const rawCopy = asRecord(data.raw_copy ?? data.rawCopy);
+  return stringValue(data.cta) || stringValue(copy.cta) || stringValue(rawCopy.cta);
+}
+function countCampaignReviewIssues(issueRows) {
+  return issueRows.flat().reduce((acc, issue) => {
+    acc[issue] = (acc[issue] || 0) + 1;
+    return acc;
+  }, {});
+}
+function formatCampaignReviewIssueCounts(counts) {
+  const entries = Object.entries(counts);
+  return entries.length > 0 ? entries.map(([issue, count]) => `${issue}=${count}`).join(", ") : "none";
+}
+function campaignReviewDataCopyQaIssues(data) {
+  const issues = /* @__PURE__ */ new Set();
+  const copyParts = campaignReviewDataCopyParts(data);
+  if (copyParts.length === 0) return [];
+  if (campaignReviewDataHasBadGreeting(data)) issues.add("bad_greeting");
+  if (campaignReviewDataHasBannedPhrase(data)) issues.add("banned_or_vague_phrase");
+  if (campaignReviewDataHasUnsupportedSignalClaim(data)) issues.add("unsupported_signal_claim");
+  if (campaignReviewDataPersonalizationBasis(data).length === 0) issues.add("missing_personalization_basis");
+  if (!campaignReviewDataCta(data)) issues.add("missing_cta");
+  const subject = campaignReviewDataSubject(data);
+  if (subject && subject.length > 70) issues.add("overlong_subject");
+  return [...issues];
+}
+function campaignReviewDataPersonalizationBasis(data) {
+  const rawCopy = asRecord(data.raw_copy ?? data.rawCopy);
+  const copy = asRecord(data.copy);
+  const metadata = asRecord(data.metadata);
+  const signalEvidence = asRecord(data.signal_evidence ?? metadata.signal_evidence ?? metadata.signalEvidence);
+  return [
+    ...arrayOfStrings(data.personalization_basis) ?? [],
+    ...arrayOfStrings(data.personalizationBasis) ?? [],
+    ...arrayOfStrings(copy.personalization_basis) ?? [],
+    ...arrayOfStrings(rawCopy.personalization_basis) ?? [],
+    ...arrayOfStrings(metadata.personalization_basis) ?? [],
+    ...arrayOfStrings(metadata.personalizationBasis) ?? [],
+    ...arrayOfStrings(signalEvidence.personalization_basis) ?? []
+  ];
+}
+function campaignReviewDataHasNoSupportedSignal(data) {
+  const metadata = asRecord(data.metadata);
+  const copy = asRecord(data.copy);
+  const state = [
+    data.copy_signal_state,
+    data.signal_basis,
+    data.signal_type,
+    metadata.copy_signal_state,
+    metadata.signal_basis,
+    metadata.signal_type,
+    copy.copy_signal_state
+  ].map((value) => stringValue(value)?.toLowerCase()).filter(Boolean);
+  return data.no_supported_signal === true || metadata.no_supported_signal === true || state.includes("no_supported_signal");
+}
+function campaignReviewDataHasSignalBasis(data) {
+  if (campaignReviewDataHasNoSupportedSignal(data)) return false;
+  const metadata = asRecord(data.metadata);
+  const signal = asRecord(data.signal);
+  const signalEvidence = asRecord(data.signal_evidence ?? metadata.signal_evidence ?? metadata.signalEvidence);
+  const basis = campaignReviewDataPersonalizationBasis(data);
+  return Boolean(
+    stringValue(data.signal_type) || stringValue(data.signalType) || stringValue(data.signal_summary) || stringValue(data.signalSummary) || stringValue(data.signal_source_url) || stringValue(data.signalSourceUrl) || stringValue(metadata.signal_type) || stringValue(metadata.signal_summary) || stringValue(metadata.signal_source_url) || stringValue(signal.type) || stringValue(signal.summary) || stringValue(signal.source_url) || stringValue(signalEvidence.signal_type) || stringValue(signalEvidence.summary) || stringValue(signalEvidence.source_url) || basis.some((item) => /\bsignal|hiring|funding|leadership|growth|launch|news|technology\b/i.test(item))
+  );
+}
+function campaignReviewDataHasUnsupportedSignalClaim(data) {
+  const copyText = campaignReviewDataCopyParts(data).join(" ").toLowerCase();
+  const claimsSignal = /\b(hiring|funding|raised|launched|expanding|appointed|announced|recent news|new role|job posting)\b/.test(copyText);
+  return claimsSignal && !campaignReviewDataHasSignalBasis(data);
+}
+function campaignReviewDataHasApprovalLock(data) {
+  const metadata = asRecord(data.fit_metadata ?? data.metadata);
+  const approval = String(data.approval_status ?? data.delivery_approval_status ?? metadata.approval_status ?? "").toLowerCase();
+  const exportStatus = String(data.export_status ?? data.exportStatus ?? "").toLowerCase();
+  return data.export_ready === false || data.exportReady === false || data.delivery_approved === false || data.deliveryApproved === false || ["pending", "pending_approval", "blocked", "approval_required", "held"].includes(approval) || ["pending", "blocked", "approval_required", "held"].includes(exportStatus);
+}
+function campaignReviewDataHasHoldoutAttribution(data) {
+  const fitMetadata = asRecord(data.fit_metadata ?? data.fitMetadata);
+  const metadata = asRecord(data.metadata);
+  const holdout = asRecord(
+    fitMetadata.learning_holdout ?? fitMetadata.learningHoldout ?? metadata.learning_holdout ?? metadata.learningHoldout ?? data.learning_holdout ?? data.learningHoldout
+  );
+  const experimentKey = stringValue(holdout.experiment_key ?? holdout.experimentKey ?? data.experiment_key ?? data.experimentKey);
+  const cohort = stringValue(holdout.cohort_role ?? holdout.cohortRole ?? data.cohort_role ?? data.learning_cohort ?? data.learningCohort);
+  const brainApplied = holdout.brain_applied ?? holdout.brainApplied ?? data.brain_applied ?? data.signaliz_brain_applied;
+  return Boolean(experimentKey && cohort && brainApplied !== void 0);
+}
+function campaignReviewStatusHasFeedbackReadiness(status) {
+  const diagnostics = asRecord(status.diagnostics);
+  const feedbackReadiness = asRecord(diagnostics.feedback_readiness ?? diagnostics.feedbackReadiness);
+  const feedbackSubstrate = asRecord(diagnostics.feedback_substrate ?? diagnostics.feedbackSubstrate);
+  const evidenceCounts = asRecord(diagnostics.evidence_counts ?? diagnostics.evidenceCounts);
+  return feedbackReadiness.ready === true || feedbackReadiness.webhook_configured === true || feedbackSubstrate.stage === "ready" || Number(evidenceCounts.feedback_events ?? 0) > 0;
+}
+function campaignReviewMoatState(status, holdoutRows) {
+  const diagnostics = asRecord(status.diagnostics);
+  const evidenceCounts = asRecord(diagnostics.evidence_counts ?? diagnostics.evidenceCounts);
+  const embeddedHoldout = asRecord(diagnostics.embedded_holdout ?? diagnostics.embeddedHoldout);
+  const holdoutLift = asRecord(diagnostics.holdout_lift ?? diagnostics.holdoutLift ?? diagnostics.holdout_measurement ?? diagnostics.holdoutMeasurement);
+  const controlSample = Math.max(
+    Number(evidenceCounts.holdout_control_sample_size ?? 0),
+    Number(evidenceCounts.embedded_holdout_control_sample ?? 0),
+    Number(embeddedHoldout.control_sample_size ?? 0)
+  );
+  const learnedSample = Math.max(
+    Number(evidenceCounts.holdout_learned_sample_size ?? 0),
+    Number(evidenceCounts.embedded_holdout_learned_sample ?? 0),
+    Number(embeddedHoldout.learned_sample_size ?? 0)
+  );
+  const feedbackEvents = Math.max(
+    Number(evidenceCounts.feedback_events ?? 0),
+    Number(evidenceCounts.campaign_build_feedback_events ?? 0),
+    Number(evidenceCounts.delivery_holdout_sent_outcomes ?? 0)
+  );
+  const proved = diagnostics.closed_loop_proof_ready === true || holdoutLift.honest_measurement === true && holdoutLift.positive_lift === true;
+  if (proved) {
+    return {
+      state: "proved",
+      detail: "Real attributed feedback shows positive lift for explicit control and learned cohorts."
+    };
+  }
+  if (controlSample > 0 && learnedSample > 0 && feedbackEvents > 0) {
+    return {
+      state: "moved_needs_lift_volume",
+      detail: `Control and learned cohorts have attributed feedback (${controlSample} control, ${learnedSample} learned, ${feedbackEvents} feedback event(s)); keep collecting lift volume before claiming proof.`
+    };
+  }
+  return {
+    state: "scaffolding_ready",
+    detail: holdoutRows > 0 ? `${holdoutRows} sampled row(s) carry holdout attribution, but real control/learned feedback lift is not proved yet.` : "Holdout and feedback scaffolding may be ready, but no real control/learned feedback lift is proved yet."
+  };
+}
 function createCampaignBuilderReadinessLane(route, plan) {
   const builtIn = campaignBuilderBuiltInForRoute(route);
   const customRoute = route.provider !== "signaliz" && route.provider !== "csv" && builtIn === void 0;
@@ -3610,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];
 }
@@ -3877,7 +5038,7 @@ function hashString(input) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-var DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS, DEFAULT_CAMPAIGN_BUILDER_BUILT_INS, CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS, DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES, CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS, CAMPAIGN_BUILDER_STRATEGY_TEMPLATES, CampaignBuilderAgent;
+var DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS, DEFAULT_CAMPAIGN_BUILDER_BUILT_INS, CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS, DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES, CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS, CAMPAIGN_BUILDER_STRATEGY_TEMPLATES, CampaignBuilderAgent, CAMPAIGN_BUILDER_TERMINAL_STATUSES, CAMPAIGN_BUILDER_BLOCKED_TERMINAL_STATUSES, NORTH_STAR_BANNED_COPY_PHRASES;
 var init_campaign_builder_agent = __esm({
   "src/resources/campaign-builder-agent.ts"() {
     "use strict";
@@ -3897,7 +5058,8 @@ var init_campaign_builder_agent = __esm({
       copy: {
         enabled: true,
         tone: "direct",
-        maxBodyWords: 125
+        maxBodyWords: 125,
+        evidenceMode: "signal_led"
       },
       delivery: {
         enabled: true,
@@ -3954,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",
@@ -3979,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",
@@ -4004,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",
@@ -4029,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",
@@ -4054,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",
@@ -4079,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 = [
@@ -4166,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",
@@ -4239,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",
@@ -4300,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",
@@ -4387,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 {
@@ -4418,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, {
@@ -4459,6 +5766,7 @@ var init_campaign_builder_agent = __esm({
             },
             brain_defaults: plan.buildRequest.brainDefaults,
             brain_preflight: plan.buildRequest.brainPreflight,
+            learning_holdout: plan.buildRequest.learningHoldout,
             campaign_strategy_context: plan.buildRequest.campaignStrategyContext,
             delivery_risk_preflight: plan.buildRequest.deliveryRisk,
             delivery_risk: plan.buildRequest.deliveryRisk
@@ -4472,7 +5780,8 @@ var init_campaign_builder_agent = __esm({
               estimated_credits: plan.estimatedCredits
             },
             brain_delivery_risk_preflight: plan.buildRequest.deliveryRisk,
-            delivery_risk: plan.buildRequest.deliveryRisk
+            delivery_risk: plan.buildRequest.deliveryRisk,
+            learning_holdout: plan.buildRequest.learningHoldout
           },
           approval_required: plan.approvals.some((approval) => approval.blocking),
           actor_type: "agent",
@@ -4788,6 +6097,17 @@ var init_campaign_builder_agent = __esm({
         return this.client.mcp("tools/call", { name: tool, arguments: compact(args) });
       }
     };
+    CAMPAIGN_BUILDER_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "canceled", "cancelled"]);
+    CAMPAIGN_BUILDER_BLOCKED_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["failed", "canceled", "cancelled"]);
+    NORTH_STAR_BANNED_COPY_PHRASES = [
+      "i have been following",
+      "i saw that",
+      "would you be opposed",
+      "unlock new opportunities",
+      "significant success",
+      "we understand",
+      "hope this finds you well"
+    ];
   }
 });
 
@@ -7345,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"() {
@@ -7382,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
+        };
+      }
     };
   }
 });
@@ -7858,6 +9235,16 @@ var init_gtm_kernel = __esm({
           min_privacy_k: input.minPrivacyK
         });
       }
+      /** Queue a dry-run-first bridge from imported historical feedback to attribution-only Campaign Build surrogates. */
+      async runHistoricalCampaignBuildBridge(input = {}) {
+        return this.callMcp("gtm_historical_campaign_build_bridge_run", {
+          dry_run: input.dryRun,
+          write_approved: input.writeApproved,
+          max_events: input.maxEvents,
+          max_campaigns: input.maxCampaigns,
+          min_feedback_events: input.minFeedbackEvents
+        });
+      }
       /** Prepare a provider-agnostic feedback webhook URL for Smartlead, HeyReach, Airbyte, or custom sender events. */
       async prepareFeedbackWebhook(input) {
         return this.callMcp("gtm_feedback_webhook_prepare", {
@@ -8034,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", {
@@ -8534,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, {
@@ -8548,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,
@@ -8606,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;
@@ -8659,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();
@@ -8683,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() {
@@ -8841,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));
@@ -8850,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") {
@@ -9836,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);
@@ -9912,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;
@@ -9954,6 +11599,13 @@ function printCampaignAgentBuildStatus(status) {
   if (status.campaignId) console.log(`Campaign ID: ${status.campaignId}`);
   console.log(`Status: ${status.status}`);
   console.log(`Phase: ${status.currentPhase || "N/A"}`);
+  const terminalState = asRecord4(status.terminalState);
+  if (terminalState.kind) {
+    console.log(`Terminal state: ${terminalState.kind} (${terminalState.label || "no label"})`);
+    if (terminalState.heartbeatAgeSeconds !== void 0 && terminalState.heartbeatAgeSeconds !== null) {
+      console.log(`Heartbeat age: ${terminalState.heartbeatAgeSeconds}s`);
+    }
+  }
   console.log(`Rows: ${status.recordsSucceeded}/${status.recordsTotal} succeeded, ${status.recordsFailed} failed`);
   printCampaignCustomerRowCounts(status);
   console.log(`Artifacts: ${status.artifactCount}`);
@@ -9975,6 +11627,8 @@ function printCampaignAgentBuildStatus(status) {
     console.log(`Next: ${status.nextAction}`);
   } else if (status.status === "pending_approval") {
     console.log(`Next: signaliz campaign-agent approve ${status.campaignBuildId} --destination-type webhook`);
+  } else if (terminalState.safeNextAction) {
+    console.log(`Next: ${terminalState.safeNextAction}`);
   }
 }
 function printCampaignCustomerRowCounts(status) {
@@ -9982,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")],
@@ -9998,17 +11655,20 @@ function printCampaignAgentBuildReview(review) {
   console.log(`Campaign: ${review.status?.name || review.campaignBuildId}`);
   console.log(`Status: ${summary.status || review.status?.status}`);
   console.log(`Phase: ${summary.phase || review.status?.currentPhase || "N/A"}`);
+  console.log(`Terminal state: ${summary.terminalState || review.status?.terminalState?.kind || "unknown"}`);
   console.log(`Rows: ${summary.sampledRows || 0} sampled, ${summary.availableRows || 0} available`);
   console.log(`Qualified: ${summary.qualifiedRows || 0}`);
   console.log(`Emails: ${summary.rowsWithEmail || 0}`);
   console.log(`Copy ready: ${summary.copyReadyRows || 0}`);
   console.log(`Artifacts: ${summary.artifactCount || 0}`);
+  printCampaignAgentNorthStarScorecard(review.northStarScorecard);
   if (review.campaignBuildId) printCampaignArtifactDownload(review.status, review.campaignBuildId);
   console.log(`Delivery approval ready: ${summary.readyForDeliveryApproval === true ? "yes" : "no"}`);
   if (Array.isArray(review.gates) && review.gates.length > 0) {
     console.log("\nGates:");
     for (const gate of review.gates) {
-      console.log(`- ${gate.passed ? "PASS" : "BLOCKED"} ${gate.label}: ${gate.detail}`);
+      const status = String(gate.status || (gate.passed ? "pass" : "blocked")).toUpperCase();
+      console.log(`- ${status} ${gate.label}: ${gate.detail}`);
     }
   }
   const warnings = Array.isArray(summary.warnings) ? summary.warnings : [];
@@ -10022,6 +11682,21 @@ function printCampaignAgentBuildReview(review) {
     for (const action of nextActions) console.log(`- ${action}`);
   }
 }
+function printCampaignAgentNorthStarScorecard(scorecard) {
+  const card = asRecord4(scorecard);
+  if (!card.version) return;
+  const score = card.score === null || card.score === void 0 ? "pending" : `${card.score}%`;
+  console.log(`North Star: ${String(card.status || "unknown")} (${score})`);
+  if (card.moatState) console.log(`Moat state: ${card.moatState}`);
+  const metrics = Array.isArray(card.metrics) ? card.metrics : [];
+  if (metrics.length > 0) {
+    console.log("\nNorth Star gates:");
+    for (const metric of metrics.slice(0, 12)) {
+      const item = asRecord4(metric);
+      console.log(`- ${String(item.status || "review").toUpperCase()} ${item.label || item.id}: ${item.detail || ""}`);
+    }
+  }
+}
 function formatCampaignAgentRows(rows) {
   return rows.map((row) => {
     const data = asRecord4(row.data);
@@ -10099,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);
@@ -10116,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
@@ -10123,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
@@ -10153,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: