@signaliz/sdk 1.0.12 → 1.0.14

package/dist/cli.js

@@ -1197,6 +1197,13 @@ var DEFAULT_CAMPAIGN_BUILDER_BUILT_INS = [
   "email_verification",
   "signals"
 ];
+var CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS = {
+  lead_generation: "signaliz-lead-generation",
+  local_leads: "signaliz-local-leads",
+  email_finding: "signaliz-email-finding",
+  email_verification: "signaliz-email-verification",
+  signals: "signaliz-signals"
+};
 var DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES = [
   "memory_retrieval",
   "spend",
@@ -1693,6 +1700,17 @@ var CampaignBuilderAgent = class {
     }
     return plan;
   }
+  async readiness(request, options = {}) {
+    const plan = await this.createPlan(request, options);
+    return createCampaignBuilderReadiness(plan);
+  }
+  async proof(request, options = {}) {
+    const plan = await this.createPlan(request, options);
+    const result = await this.dryRunPlan(plan, {
+      idempotencyKey: options.idempotencyKey
+    });
+    return createCampaignBuilderProofReceipt(plan, result);
+  }
   async commitPlan(plan, options = {}) {
     const writeMode = options.confirm === true && options.dryRun === false;
     if (writeMode && !options.approvedBy) {
@@ -2053,6 +2071,157 @@ function createCampaignBuilderAgentPlan(request, context = {}) {
     warnings: context.warnings ?? []
   };
 }
+function createCampaignBuilderReadiness(plan) {
+  const lanes = plan.routes.map((route) => createCampaignBuilderReadinessLane(route, plan));
+  const builtInLanes = lanes.filter((lane) => lane.builtIn);
+  const customRoutes = lanes.filter((lane) => lane.customRoute);
+  const strategyMemory = asRecord(plan.strategyMemoryStatus);
+  const deliveryRisk = asRecord(plan.buildRequest.deliveryRisk);
+  const deliveryRiskBlockers = arrayOfStrings(deliveryRisk.blockers) ?? [];
+  const deliveryRiskValue = asRecord(deliveryRisk.risk);
+  const deliveryRiskLevel = stringValue(deliveryRiskValue.risk_level ?? deliveryRiskValue.riskLevel);
+  const memoryReady = !plan.strategyMemoryStatus || strategyMemory.ready !== false;
+  const kernelPlanReady = Object.keys(asRecord(plan.kernelPlan)).length > 0;
+  const deliveryRiskReady = !plan.buildRequest.deliveryRisk || deliveryRiskBlockers.length === 0 && !["high", "critical", "blocked"].includes(String(deliveryRiskLevel ?? "").toLowerCase());
+  const builtInsReady = builtInLanes.length > 0 && builtInLanes.every((lane) => lane.ready);
+  const customRoutesReady = customRoutes.every((lane) => lane.ready);
+  const approvalGatesReady = plan.approvals.length > 0;
+  const gates = [
+    {
+      id: "campaign_plan_created",
+      label: "Campaign plan created",
+      passed: Boolean(plan.planId && plan.mcpFlow.length > 0),
+      detail: plan.planId ? `Plan ${plan.planId} has ${plan.mcpFlow.length} MCP step(s).` : "No campaign-builder plan was created."
+    },
+    {
+      id: "built_in_lanes_ready",
+      label: "Built-in lanes ready",
+      passed: builtInsReady,
+      detail: `${builtInLanes.filter((lane) => lane.ready).length}/${builtInLanes.length} Signaliz built-in lane(s) are present.`
+    },
+    {
+      id: "strategy_memory_ready",
+      label: "Strategy memory ready",
+      passed: memoryReady,
+      detail: plan.strategyMemoryStatus ? "Strategy memory readiness was checked." : "Strategy memory readiness was not requested."
+    },
+    {
+      id: "kernel_plan_attached",
+      label: "Kernel plan attached",
+      passed: kernelPlanReady,
+      detail: kernelPlanReady ? "Kernel planner evidence is attached." : "Kernel planner evidence is not attached."
+    },
+    {
+      id: "delivery_risk_clear",
+      label: "Delivery risk clear",
+      passed: deliveryRiskReady,
+      detail: plan.buildRequest.deliveryRisk ? `Delivery risk is ${deliveryRiskLevel || "available"} with ${deliveryRiskBlockers.length} blocker(s).` : "Delivery risk preflight was not requested."
+    },
+    {
+      id: "custom_routes_prepared",
+      label: "Custom routes prepared",
+      passed: customRoutesReady,
+      detail: customRoutes.length === 0 ? "No BYO routes were requested." : `${customRoutes.filter((lane) => lane.ready).length}/${customRoutes.length} BYO route(s) have read-only setup steps.`
+    },
+    {
+      id: "approval_gates_present",
+      label: "Approval gates present",
+      passed: approvalGatesReady,
+      detail: approvalGatesReady ? `${plan.approvals.length} approval gate(s) are attached.` : "No approval gates are attached."
+    }
+  ];
+  const blockers = [
+    ...gates.filter((gate) => !gate.passed).map((gate) => gate.detail),
+    ...lanes.flatMap((lane) => lane.blockers)
+  ];
+  const score = gates.length === 0 ? 0 : Math.round(gates.filter((gate) => gate.passed).length / gates.length * 100);
+  const ready = blockers.length === 0;
+  return {
+    plan,
+    lanes,
+    gates,
+    summary: {
+      ready,
+      score,
+      targetCount: plan.targetCount,
+      estimatedCredits: plan.estimatedCredits,
+      builtInLanesReady: builtInLanes.filter((lane) => lane.ready).length,
+      builtInLanesTotal: builtInLanes.length,
+      customRoutesReady: customRoutes.filter((lane) => lane.ready).length,
+      customRoutesTotal: customRoutes.length,
+      approvalGateCount: plan.approvals.length,
+      blockers,
+      warnings: plan.warnings
+    },
+    nextActions: campaignReadinessNextActions(plan, ready, customRoutes.length)
+  };
+}
+function createCampaignBuilderProofReceipt(plan, result) {
+  const strategyMemory = asRecord(plan.strategyMemoryStatus);
+  const dryRunResult = asRecord(result);
+  const memoryReady = plan.strategyMemoryStatus ? strategyMemory.ready !== false : false;
+  const dryRunCompleted = dryRunResult.dryRun === true || dryRunResult.dry_run === true || dryRunResult.status === "dry_run";
+  const noLaunch = dryRunCompleted && !dryRunResult.campaignBuildId && !dryRunResult.campaign_build_id;
+  const gates = [
+    {
+      id: "strategy_memory_ready",
+      passed: memoryReady,
+      ready: strategyMemory.ready ?? null,
+      blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0
+    },
+    {
+      id: "campaign_plan_ready",
+      passed: Boolean(plan.planId && plan.mcpFlow.length > 0),
+      plan_id: plan.planId,
+      flow_steps: plan.mcpFlow.length
+    },
+    {
+      id: "approval_gates_present",
+      passed: plan.approvals.length > 0,
+      approval_types: plan.approvals.map((approval) => approval.type)
+    },
+    {
+      id: "dry_run_completed",
+      passed: dryRunCompleted,
+      status: dryRunResult.status ?? null,
+      current_phase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null
+    },
+    {
+      id: "no_spendful_launch",
+      passed: noLaunch,
+      campaign_build_id: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null
+    }
+  ];
+  return {
+    receipt_version: "campaign-agent-proof.v1",
+    source: "signaliz.campaignBuilderAgent.proof",
+    success: gates.every((gate) => gate.passed),
+    safety: {
+      spendful_tools_called: false,
+      external_writes_called: false,
+      sender_loads_called: false,
+      email_sends_called: false,
+      dry_run_only: true
+    },
+    campaign: {
+      plan_id: plan.planId,
+      campaign_name: plan.campaignName,
+      strategy_template: campaignBuilderProofStrategyTemplate(plan),
+      target_count: plan.targetCount,
+      estimated_credits: plan.estimatedCredits,
+      operating_playbooks: plan.operatingPlaybooks.map((playbook) => playbook.slug)
+    },
+    gates,
+    strategy_memory_status: summarizeCampaignBuilderProofStrategyMemory(strategyMemory),
+    dry_run_result: summarizeCampaignBuilderProofDryRun(dryRunResult),
+    recommended_next_actions: [
+      "Review the plan, approvals, and dry-run result.",
+      "Use campaign-agent commit-plan --confirm-write only after review.",
+      "Use campaign-agent build-approved only with --confirm-launch, approval identity, approval types, and spend limit.",
+      "When an approved build reaches pending_approval, review rows and approve delivery through the Campaigns SDK."
+    ]
+  };
+}
 function getMissingCampaignBuilderApprovals(plan, approval) {
   if (approval.planId !== plan.planId) {
     return plan.approvals;
@@ -3430,6 +3599,137 @@ 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 createCampaignBuilderReadinessLane(route, plan) {
+  const builtIn = campaignBuilderBuiltInForRoute(route);
+  const customRoute = route.provider !== "signaliz" && route.provider !== "csv" && builtIn === void 0;
+  const prepareStep = plan.mcpFlow.find(
+    (step) => step.tool === "gtm_provider_recipe_prepare" && step.arguments.provider_id === route.provider
+  );
+  const activateStep = plan.mcpFlow.find(
+    (step) => step.tool === "gtm_provider_route_activate" && step.arguments.provider_id === route.provider
+  );
+  const readOnlySetup = !customRoute || prepareStep?.readOnly === true && activateStep?.readOnly === true && activateStep.arguments.dry_run === true && activateStep.arguments.confirm === false;
+  const blockers = [
+    customRoute && !prepareStep ? `${route.label ?? route.provider} is missing provider recipe setup.` : void 0,
+    customRoute && !activateStep ? `${route.label ?? route.provider} is missing provider route dry-run setup.` : void 0,
+    customRoute && !readOnlySetup ? `${route.label ?? route.provider} route setup must stay read-only before approval.` : void 0,
+    route.mode === "required" && !route.toolName && customRoute ? `${route.label ?? route.provider} is required but has no tool name.` : void 0
+  ].filter((item) => Boolean(item));
+  return {
+    id: route.id ?? `${route.provider}-${route.layer}`,
+    label: route.label ?? readinessLaneLabel(route, builtIn),
+    layer: route.layer,
+    gtmLayers: gtmLayersForRoute(route),
+    provider: route.provider,
+    toolName: route.toolName,
+    mode: route.mode ?? "if_available",
+    builtIn,
+    approvalRequired: route.approvalRequired === true || plan.approvals.some((approval) => approval.routeId === route.id),
+    customRoute,
+    readOnlySetup,
+    ready: blockers.length === 0,
+    blockers,
+    nextAction: customRoute ? `Review ${route.provider} route setup before launch approval.` : void 0
+  };
+}
+function campaignBuilderBuiltInForRoute(route) {
+  return Object.entries(CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS).find(([, routeId]) => route.id === routeId)?.[0];
+}
+function readinessLaneLabel(route, builtIn) {
+  if (builtIn) {
+    const labels = {
+      lead_generation: "Signaliz lead generation",
+      local_leads: "Signaliz local leads",
+      email_finding: "Signaliz email finding",
+      email_verification: "Signaliz email verification",
+      signals: "Signaliz signals"
+    };
+    return labels[builtIn];
+  }
+  return `${route.provider} ${route.layer}`;
+}
+function campaignReadinessNextActions(plan, ready, customRouteCount) {
+  const requestHint = "--request-file campaign-request.json";
+  if (ready) {
+    return [
+      `signaliz campaign-agent proof ${requestHint} --json`,
+      `signaliz campaign-agent commit-plan ${requestHint} --json`,
+      `signaliz campaign-agent build-approved ${requestHint} --confirm-launch --approve-all --approved-by operator@example.com --spend-limit ${plan.estimatedCredits}`
+    ];
+  }
+  const actions = [
+    plan.strategyMemoryStatus && asRecord(plan.strategyMemoryStatus).ready === false ? "signaliz gtm strategy-memory --strategy-template <strategy_template> --include-samples --json" : void 0,
+    customRouteCount > 0 ? "Review BYO provider recipe and route dry-run steps in the readiness packet." : void 0,
+    `signaliz campaign-agent plan ${requestHint} --json`
+  ];
+  return actions.filter((item) => Boolean(item));
+}
+function campaignBuilderProofStrategyTemplate(plan) {
+  const buildRequest = asRecord(plan.buildRequest);
+  const strategyMemory = asRecord(plan.strategyMemoryStatus);
+  const statusTemplate = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
+  const statusTemplateRecord = asRecord(statusTemplate);
+  const flowTemplate = plan.mcpFlow.map((step) => asRecord(step.arguments).strategy_template ?? asRecord(step.arguments).strategyTemplate).find((value) => typeof value === "string" && value.trim());
+  return firstNonEmptyString(
+    buildRequest.strategyTemplate,
+    buildRequest.strategy_template,
+    statusTemplate,
+    statusTemplateRecord.slug,
+    statusTemplateRecord.id,
+    flowTemplate
+  );
+}
+function summarizeCampaignBuilderProofStrategyMemory(strategyMemory) {
+  if (Object.keys(strategyMemory).length === 0) return { ready: false };
+  const template = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
+  const templateRecord = asRecord(template);
+  const coverage = asRecord(strategyMemory.coverage);
+  const rawSourceGroups = Array.isArray(strategyMemory.source_groups) ? strategyMemory.source_groups : Array.isArray(strategyMemory.sourceGroups) ? strategyMemory.sourceGroups : [];
+  const sourceGroups = rawSourceGroups.map((group) => {
+    const sourceGroup = asRecord(group);
+    return {
+      id: sourceGroup.id ?? null,
+      required: sourceGroup.required ?? null,
+      ready: sourceGroup.ready ?? null,
+      counts: asRecord(sourceGroup.counts)
+    };
+  });
+  return {
+    ready: strategyMemory.ready ?? null,
+    read_only: strategyMemory.read_only ?? strategyMemory.readOnly ?? null,
+    source_tool: firstNonEmptyString(strategyMemory.source_tool, strategyMemory.sourceTool),
+    strategy_template: {
+      slug: firstNonEmptyString(template, templateRecord.slug, templateRecord.id),
+      label: firstNonEmptyString(templateRecord.label)
+    },
+    coverage: {
+      required_groups_ready: coverage.required_groups_ready ?? coverage.requiredGroupsReady ?? null,
+      required_groups_total: coverage.required_groups_total ?? coverage.requiredGroupsTotal ?? null,
+      source_groups_ready: coverage.source_groups_ready ?? coverage.sourceGroupsReady ?? null,
+      source_groups_total: coverage.source_groups_total ?? coverage.sourceGroupsTotal ?? null,
+      knowledge_docs: coverage.knowledge_docs ?? coverage.knowledgeDocs ?? null,
+      memories: coverage.memories ?? null
+    },
+    source_groups: sourceGroups,
+    blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0,
+    warning_count: Array.isArray(strategyMemory.warnings) ? strategyMemory.warnings.length : 0
+  };
+}
+function summarizeCampaignBuilderProofDryRun(dryRunResult) {
+  return {
+    dryRun: dryRunResult.dryRun ?? dryRunResult.dry_run ?? null,
+    status: dryRunResult.status ?? null,
+    currentPhase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null,
+    campaignBuildId: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null,
+    plannedTargetCount: dryRunResult.plannedTargetCount ?? dryRunResult.planned_target_count ?? null
+  };
+}
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return null;
+}
 function diagnosticMessages2(value) {
   if (!Array.isArray(value)) return [];
   return value.map((item) => {
@@ -6807,13 +7107,14 @@ async function handleCampaignAgentCommand(signaliz, argv) {
     await handleCampaignAgentReviewCommand(signaliz, subcommand, argv.slice(1));
     return;
   }
-  if (!["plan", "proof", "smoke", "commit-plan", "dry-run", "build-approved", "launch-approved"].includes(subcommand)) {
+  if (!["plan", "doctor", "readiness", "preflight", "proof", "smoke", "commit-plan", "dry-run", "build-approved", "launch-approved"].includes(subcommand)) {
     printCampaignAgentHelp();
     return;
   }
   const flags = parseFlags(argv.slice(1));
+  const isDoctor = subcommand === "doctor" || subcommand === "readiness" || subcommand === "preflight";
   const requestFromFile = campaignAgentRequestFileFromFlags(flags);
-  const goal = stringFlag(flags, "goal", "brief") ?? stringOrUndefined(requestFromFile?.goal);
+  const goal = stringFlag(flags, "goal", "brief") ?? stringOrUndefined(requestFromFile?.goal) ?? (isDoctor ? "Build a strategy-template campaign for the target ICP." : void 0);
   if (!goal) throw new Error(`campaign-agent ${subcommand} requires --goal or a request file with goal`);
   const isApprovedBuild = subcommand === "build-approved" || subcommand === "launch-approved";
   const isCommitPlan = subcommand === "commit-plan";
@@ -6832,18 +7133,28 @@ async function handleCampaignAgentCommand(signaliz, argv) {
     requestFromFile,
     campaignAgentRequestFromFlags(goal, flags, { includeDefaults: !requestFromFile })
   );
-  const plan = await signaliz.campaignBuilderAgent.createPlan(request, {
+  const planOptions = {
     discoverCapabilities: !booleanFlag(flags, "skip-discovery"),
     scopeCampaign: !booleanFlag(flags, "skip-scope"),
     includeStrategyMemoryStatus: !booleanFlag(flags, "no-strategy-memory"),
     includeKernelPlan: !booleanFlag(flags, "no-kernel-plan"),
     includeDeliveryRisk: !booleanFlag(flags, "no-delivery-risk")
-  });
+  };
+  if (isDoctor) {
+    const readiness = await signaliz.campaignBuilderAgent.readiness(request, planOptions);
+    if (booleanFlag(flags, "json")) {
+      printJson(readiness);
+    } else {
+      printCampaignAgentReadiness(readiness);
+    }
+    if (!readiness.summary.ready) process.exitCode = 1;
+    return;
+  }
   if (subcommand === "proof" || subcommand === "smoke") {
-    const result = await signaliz.campaignBuilderAgent.dryRunPlan(plan, {
+    const proof = await signaliz.campaignBuilderAgent.proof(request, {
+      ...planOptions,
       idempotencyKey: stringFlag(flags, "idempotency-key")
     });
-    const proof = createCampaignAgentProofReceipt(plan, result);
     if (booleanFlag(flags, "json")) {
       printJson(proof);
     } else {
@@ -6852,6 +7163,7 @@ async function handleCampaignAgentCommand(signaliz, argv) {
     if (!proof.success) process.exitCode = 1;
     return;
   }
+  const plan = await signaliz.campaignBuilderAgent.createPlan(request, planOptions);
   if (isCommitPlan) {
     const result = await signaliz.campaignBuilderAgent.commitPlan(plan, {
       confirm: isConfirmedCommit,
@@ -7326,6 +7638,39 @@ function printCampaignAgentExecution(payload, flags) {
   console.log("\nResult:");
   printJson(payload.result);
 }
+function printCampaignAgentReadiness(readiness) {
+  const summary = asRecord4(readiness.summary);
+  const plan = readiness.plan;
+  console.log(`Readiness: ${summary.ready === true ? "ready" : "blocked"} (${summary.score ?? 0}%)`);
+  if (plan?.campaignName) console.log(`Campaign: ${plan.campaignName}`);
+  if (summary.targetCount !== void 0) console.log(`Target: ${summary.targetCount}`);
+  if (summary.estimatedCredits !== void 0) console.log(`Estimated credits: ${summary.estimatedCredits}`);
+  console.log(`Built-ins: ${summary.builtInLanesReady ?? 0}/${summary.builtInLanesTotal ?? 0}`);
+  console.log(`BYO routes: ${summary.customRoutesReady ?? 0}/${summary.customRoutesTotal ?? 0}`);
+  console.log(`Approval gates: ${summary.approvalGateCount ?? 0}`);
+  if (Array.isArray(readiness.gates) && readiness.gates.length > 0) {
+    console.log("\nGates:");
+    for (const gate of readiness.gates) {
+      console.log(`- ${gate.passed ? "PASS" : "BLOCKED"} ${gate.label}: ${gate.detail}`);
+    }
+  }
+  if (Array.isArray(readiness.lanes) && readiness.lanes.length > 0) {
+    console.log("\nLanes:");
+    for (const lane of readiness.lanes) {
+      console.log(`- ${lane.ready ? "READY" : "BLOCKED"} ${lane.label}: ${lane.toolName || lane.provider}`);
+    }
+  }
+  const blockers = Array.isArray(summary.blockers) ? summary.blockers : [];
+  if (blockers.length > 0) {
+    console.log("\nBlockers:");
+    for (const blocker of blockers.slice(0, 8)) console.log(`- ${blocker}`);
+  }
+  const nextActions = Array.isArray(readiness.nextActions) ? readiness.nextActions : [];
+  if (nextActions.length > 0) {
+    console.log("\nNext:");
+    for (const action of nextActions) console.log(`- ${action}`);
+  }
+}
 function printCampaignAgentBuildStatus(status) {
   console.log(`Campaign: ${status.name || status.campaignBuildId}`);
   if (status.campaignId) console.log(`Campaign ID: ${status.campaignId}`);
@@ -7410,138 +7755,6 @@ function printCampaignAgentRows(result) {
 function asRecord4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function createCampaignAgentProofReceipt(plan, result) {
-  const strategyMemory = asRecord4(plan.strategyMemoryStatus);
-  const dryRunResult = asRecord4(result);
-  const memoryReady = plan.strategyMemoryStatus ? strategyMemory.ready !== false : false;
-  const dryRunCompleted = dryRunResult.dryRun === true || dryRunResult.dry_run === true || dryRunResult.status === "dry_run";
-  const noLaunch = dryRunCompleted && !dryRunResult.campaignBuildId && !dryRunResult.campaign_build_id;
-  const gates = [
-    {
-      id: "strategy_memory_ready",
-      passed: memoryReady,
-      ready: strategyMemory.ready ?? null,
-      blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0
-    },
-    {
-      id: "campaign_plan_ready",
-      passed: Boolean(plan.planId && plan.mcpFlow.length > 0),
-      plan_id: plan.planId,
-      flow_steps: plan.mcpFlow.length
-    },
-    {
-      id: "approval_gates_present",
-      passed: plan.approvals.length > 0,
-      approval_types: plan.approvals.map((approval) => approval.type)
-    },
-    {
-      id: "dry_run_completed",
-      passed: dryRunCompleted,
-      status: dryRunResult.status ?? null,
-      current_phase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null
-    },
-    {
-      id: "no_spendful_launch",
-      passed: noLaunch,
-      campaign_build_id: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null
-    }
-  ];
-  return {
-    receipt_version: "campaign-agent-proof.v1",
-    source: "signaliz campaign-agent proof",
-    success: gates.every((gate) => gate.passed),
-    safety: {
-      spendful_tools_called: false,
-      external_writes_called: false,
-      sender_loads_called: false,
-      email_sends_called: false,
-      dry_run_only: true
-    },
-    campaign: {
-      plan_id: plan.planId,
-      campaign_name: plan.campaignName,
-      strategy_template: campaignAgentStrategyTemplate(plan),
-      target_count: plan.targetCount,
-      estimated_credits: plan.estimatedCredits,
-      operating_playbooks: plan.operatingPlaybooks.map((playbook) => playbook.slug)
-    },
-    gates,
-    strategy_memory_status: summarizeCampaignAgentStrategyMemory(strategyMemory),
-    dry_run_result: summarizeCampaignAgentDryRun(dryRunResult),
-    recommended_next_actions: [
-      "Review the plan, approvals, and dry-run result.",
-      "Use campaign-agent commit-plan --confirm-write only after review.",
-      "Use campaign-agent build-approved only with --confirm-launch, approval identity, approval types, and spend limit.",
-      "When an approved build reaches pending_approval, review rows and approve delivery through the Campaigns SDK."
-    ]
-  };
-}
-function campaignAgentString(...values) {
-  for (const value of values) {
-    if (typeof value === "string" && value.trim()) return value;
-  }
-  return null;
-}
-function campaignAgentStrategyTemplate(plan) {
-  const buildRequest = asRecord4(plan.buildRequest);
-  const strategyMemory = asRecord4(plan.strategyMemoryStatus);
-  const statusTemplate = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
-  const statusTemplateRecord = asRecord4(statusTemplate);
-  const flowTemplate = plan.mcpFlow.map((step) => asRecord4(step.arguments).strategy_template ?? asRecord4(step.arguments).strategyTemplate).find((value) => typeof value === "string" && value.trim());
-  return campaignAgentString(
-    buildRequest.strategyTemplate,
-    buildRequest.strategy_template,
-    statusTemplate,
-    statusTemplateRecord.slug,
-    statusTemplateRecord.id,
-    flowTemplate
-  );
-}
-function summarizeCampaignAgentStrategyMemory(strategyMemory) {
-  if (Object.keys(strategyMemory).length === 0) return { ready: false };
-  const template = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
-  const templateRecord = asRecord4(template);
-  const coverage = asRecord4(strategyMemory.coverage);
-  const rawSourceGroups = Array.isArray(strategyMemory.source_groups) ? strategyMemory.source_groups : Array.isArray(strategyMemory.sourceGroups) ? strategyMemory.sourceGroups : [];
-  const sourceGroups = rawSourceGroups.map((group) => {
-    const sourceGroup = asRecord4(group);
-    return {
-      id: sourceGroup.id ?? null,
-      required: sourceGroup.required ?? null,
-      ready: sourceGroup.ready ?? null,
-      counts: asRecord4(sourceGroup.counts)
-    };
-  });
-  return {
-    ready: strategyMemory.ready ?? null,
-    read_only: strategyMemory.read_only ?? strategyMemory.readOnly ?? null,
-    source_tool: campaignAgentString(strategyMemory.source_tool, strategyMemory.sourceTool),
-    strategy_template: {
-      slug: campaignAgentString(template, templateRecord.slug, templateRecord.id),
-      label: campaignAgentString(templateRecord.label)
-    },
-    coverage: {
-      required_groups_ready: coverage.required_groups_ready ?? coverage.requiredGroupsReady ?? null,
-      required_groups_total: coverage.required_groups_total ?? coverage.requiredGroupsTotal ?? null,
-      source_groups_ready: coverage.source_groups_ready ?? coverage.sourceGroupsReady ?? null,
-      source_groups_total: coverage.source_groups_total ?? coverage.sourceGroupsTotal ?? null,
-      knowledge_docs: coverage.knowledge_docs ?? coverage.knowledgeDocs ?? null,
-      memories: coverage.memories ?? null
-    },
-    source_groups: sourceGroups,
-    blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0,
-    warning_count: Array.isArray(strategyMemory.warnings) ? strategyMemory.warnings.length : 0
-  };
-}
-function summarizeCampaignAgentDryRun(dryRunResult) {
-  return {
-    dryRun: dryRunResult.dryRun ?? dryRunResult.dry_run ?? null,
-    status: dryRunResult.status ?? null,
-    currentPhase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null,
-    campaignBuildId: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null,
-    plannedTargetCount: dryRunResult.plannedTargetCount ?? dryRunResult.planned_target_count ?? null
-  };
-}
 function printCampaignAgentProof(proof) {
   console.log(`Campaign-agent proof: ${proof.success ? "passed" : "failed"}`);
   const campaign = asRecord4(proof.campaign);
@@ -7576,6 +7789,7 @@ Usage:
   signaliz gtm memory search --query "proof-first vertical gate" --json
   signaliz gtm plan --brief "Build 500 verified leads for..." --strategy-template non-medical-home-care --lead-count 500 --json
   signaliz campaign-agent init --strategy-template non-medical-home-care --target-count 250 --use-local-leads --json > campaign-request.json
+  signaliz campaign-agent doctor --request-file campaign-request.json --json
   signaliz campaign-agent plan --goal "Build a strategy-template campaign..." --strategy-template industrial-ot-resilience --target-count 500 --builtins lead_generation,email_finding,email_verification,signals
   signaliz campaign-agent proof --goal "Build a strategy-template campaign..." --strategy-template non-medical-home-care --target-count 100 --json
   signaliz campaign-agent plan --request-file examples/campaign-builder-agent-request.json --target-count 250 --json
@@ -7612,6 +7826,7 @@ function printCampaignAgentHelp() {
 Signaliz campaign-agent commands:
 
   signaliz campaign-agent init [--goal TEXT] [--strategy-template ID] [--target-count N] [--use-local-leads] [--with-byo-placeholder] [--output-file FILE] [--json]
+  signaliz campaign-agent doctor [--goal TEXT | --request-file FILE] [--strategy-template ID] [--target-count N] [--builtins lead_generation,email_finding,email_verification,signals,local_leads] [--custom-tool provider:layer:tool[:mcp]] [--json]
   signaliz campaign-agent plan (--goal TEXT | --request-file FILE) [--campaign-name NAME] [--workspace-label NAME] [--strategy-template industrial-ot-resilience|non-medical-home-care|agency-founder-led|cloud-infrastructure-displacement] [--operating-playbooks proof-first-vertical-gate,signal-led-copy-approval] [--target-count N] [--icp JSON] [--builtins lead_generation,email_finding,email_verification,signals,local_leads] [--use-local-leads] [--custom-tool provider:layer:tool[:mcp]] [--preferred-providers signaliz_native,octave] [--partners clay,instantly,nango] [--no-strategy-memory] [--no-kernel-plan] [--no-delivery-risk] [--json]
   signaliz campaign-agent proof (--goal TEXT | --request-file FILE) [--strategy-template ID] [--target-count N] [--use-local-leads] [--custom-tool provider:layer:tool[:mcp]] [--idempotency-key KEY] [--json]
   signaliz campaign-agent commit-plan (--goal TEXT | --request-file FILE) [--confirm-write --approved-by EMAIL] [--idempotency-key KEY] [--json]
@@ -7623,7 +7838,7 @@ Signaliz campaign-agent commands:
   signaliz campaign-agent artifacts <campaign_build_id> [--json]
   signaliz campaign-agent approve <campaign_build_id> --destination-type json|csv|webhook [--destination-config JSON] [--json]
 
-The init command emits a reusable JSON CampaignBuilderAgentRequest. The plan command composes an approval-gated strategy-template MCP flow. Proof runs the same plan path plus build_campaign dry_run=true and returns a no-spend receipt. Use --request-file to load a reusable request, then override fields such as --target-count or --strategy-template from the command line. Use --strategy-template to merge a private-safe strategy pattern into the plan without exposing private account labels, and --operating-playbooks to add reusable build-loop gates such as proof-first vertical qualification, net-new suppression, cache-first inventory, and signal-led copy approval. Built-ins map to Signaliz-native tools: lead_generation -> generate_leads, local_leads -> generate_local_leads, email_finding -> find_and_verify_emails, email_verification -> verify_emails, signals -> enrich_company_signals. Add BYO tools with --custom-tool provider:layer:tool[:mcp] or key=value pairs such as provider=apollo,layer=source,tool=apollo_search,mcp=apollo. Use --no-strategy-patterns or --no-workflow-patterns to disable default private strategy memory hints. Commit-plan dry-runs by default and writes only with --confirm-write plus approval identity. Dry-run executes build_campaign with dry_run=true. Approved build requires explicit launch confirmation and approval metadata; add --commit-before-launch to persist the reviewed plan as a GTM campaign before launch, --wait to poll until completion or pending approval, and --approve-delivery to approve reviewed webhook delivery after pending_approval. Use review to inspect status, sampled rows, artifacts, and delivery-readiness gates before approving delivery or routing rows to external tools.
+The init command emits a reusable JSON CampaignBuilderAgentRequest. Doctor returns a readiness packet for built-in lanes, BYO routes, Memory, Brain, Kernel planning, and approval gates. The plan command composes an approval-gated strategy-template MCP flow. Proof runs the same plan path plus build_campaign dry_run=true and returns a no-spend receipt. Use --request-file to load a reusable request, then override fields such as --target-count or --strategy-template from the command line. Use --strategy-template to merge a private-safe strategy pattern into the plan without exposing private account labels, and --operating-playbooks to add reusable build-loop gates such as proof-first vertical qualification, net-new suppression, cache-first inventory, and signal-led copy approval. Built-ins map to Signaliz-native tools: lead_generation -> generate_leads, local_leads -> generate_local_leads, email_finding -> find_and_verify_emails, email_verification -> verify_emails, signals -> enrich_company_signals. Add BYO tools with --custom-tool provider:layer:tool[:mcp] or key=value pairs such as provider=apollo,layer=source,tool=apollo_search,mcp=apollo. Use --no-strategy-patterns or --no-workflow-patterns to disable default private strategy memory hints. Commit-plan dry-runs by default and writes only with --confirm-write plus approval identity. Dry-run executes build_campaign with dry_run=true. Approved build requires explicit launch confirmation and approval metadata; add --commit-before-launch to persist the reviewed plan as a GTM campaign before launch, --wait to poll until completion or pending approval, and --approve-delivery to approve reviewed webhook delivery after pending_approval. Use review to inspect status, sampled rows, artifacts, and delivery-readiness gates before approving delivery or routing rows to external tools.
 `);
 }
 main().catch((e) => {