@signaliz/cli 1.0.12 → 1.0.14

package/dist/bin.js

@@ -1071,6 +1071,7 @@ Campaign Builder:
                           Merge a private-safe strategy template
     --builtins a,b        lead_generation,local_leads,email_finding,email_verification,signals
     --custom-tool ROUTE   BYO route: provider:layer:tool[:mcp]
+  campaign-agent doctor   Inspect built-in lanes, BYO routes, Memory, Brain, and approvals
   campaign-agent proof    Prove memory, plan, approvals, and build dry-run without spend
   campaign-agent commit-plan
                           Dry-run or write a reviewed GTM campaign object
@@ -2791,6 +2792,7 @@ var CAMPAIGN_AGENT_HELP = `signaliz campaign-agent <command> [options]
 Strategy-template campaign builder:
   init              Emit reusable CampaignBuilderAgentRequest JSON
   plan              Compose an approval-gated strategy-template MCP flow
+  doctor           Inspect built-in lanes, BYO routes, Memory, Brain, and approvals
   proof             Prove memory, plan, approvals, and build dry-run without spend
   commit-plan       Dry-run or write a reviewed GTM campaign object
   dry-run           Execute build_campaign with dry_run=true
@@ -2803,6 +2805,7 @@ Strategy-template campaign builder:
 
 Examples:
   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 for my ICP" --strategy-template non-medical-home-care --target-count 500 --builtins lead_generation,email_finding,email_verification,signals
   signaliz campaign-agent proof --goal "Build a strategy-template campaign for my ICP" --strategy-template non-medical-home-care --target-count 100 --json
   signaliz campaign-agent plan --request-file campaign-builder-agent-request.json --target-count 250 --json
@@ -2868,7 +2871,7 @@ async function campaignAgent(sub, rest) {
     await campaignAgentReview(sub, rest);
     return;
   }
-  if (!["init", "template", "request-template", "new", "plan", "proof", "smoke", "commit-plan", "dry-run", "build-approved", "launch-approved"].includes(sub)) {
+  if (!["init", "template", "request-template", "new", "plan", "doctor", "readiness", "preflight", "proof", "smoke", "commit-plan", "dry-run", "build-approved", "launch-approved"].includes(sub)) {
     process.stdout.write(CAMPAIGN_AGENT_HELP);
     return;
   }
@@ -2886,7 +2889,8 @@ async function campaignAgent(sub, rest) {
     return;
   }
   const requestFromFile = campaignAgentRequestFileFromFlags(flags);
-  const goal = commandStringFlag(flags, "goal", "brief") || promptArg(rest) || campaignAgentStringValue(requestFromFile?.goal);
+  const isDoctor = sub === "doctor" || sub === "readiness" || sub === "preflight";
+  const goal = commandStringFlag(flags, "goal", "brief") || promptArg(rest) || campaignAgentStringValue(requestFromFile?.goal) || (isDoctor ? "Build a strategy-template campaign for the target ICP." : void 0);
   if (!goal) die(`campaign-agent ${sub} requires --goal or a request file with goal`);
   const isApprovedBuild = sub === "build-approved" || sub === "launch-approved";
   const isCommitPlan = sub === "commit-plan";
@@ -2905,21 +2909,32 @@ async function campaignAgent(sub, rest) {
     requestFromFile,
     campaignAgentRequestFromFlags(goal, flags, { includeDefaults: !requestFromFile })
   );
-  const plan = await agent.createPlan(request, {
+  const planOptions = {
     discoverCapabilities: !commandBooleanFlag(flags, "skip-discovery"),
     scopeCampaign: !commandBooleanFlag(flags, "skip-scope"),
     includeStrategyMemoryStatus: !commandBooleanFlag(flags, "no-strategy-memory"),
     includeKernelPlan: !commandBooleanFlag(flags, "no-kernel-plan"),
     includeDeliveryRisk: !commandBooleanFlag(flags, "no-delivery-risk")
-  });
+  };
+  if (isDoctor) {
+    const readiness = await agent.readiness?.(request, planOptions) || createCampaignAgentReadiness(await agent.createPlan(request, planOptions));
+    if (!readiness.summary?.ready) process.exitCode = 1;
+    return output(readiness, () => printCampaignAgentReadiness(readiness));
+  }
   if (sub === "proof" || sub === "smoke") {
-    const result = await agent.dryRunPlan(plan, {
+    const proof = typeof agent.proof === "function" ? await agent.proof(request, {
+      ...planOptions,
       idempotencyKey: commandStringFlag(flags, "idempotency-key")
-    });
-    const proof = createCampaignAgentProofReceipt(plan, result);
+    }) : await (async () => {
+      const plan2 = await agent.createPlan(request, planOptions);
+      return createCampaignAgentProofReceipt(plan2, await agent.dryRunPlan(plan2, {
+        idempotencyKey: commandStringFlag(flags, "idempotency-key")
+      }));
+    })();
     if (!proof.success) process.exitCode = 1;
     return output(proof, () => printCampaignAgentProof(proof));
   }
+  const plan = await agent.createPlan(request, planOptions);
   if (isCommitPlan) {
     const result = await agent.commitPlan(plan, {
       confirm: isConfirmedCommit,
@@ -3334,6 +3349,172 @@ function createCampaignAgentApproval(plan, input) {
     approvedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function createCampaignAgentReadiness(plan) {
+  const lanes = firstArray(plan?.routes).map((route) => {
+    const builtIn = campaignAgentBuiltInForRoute(route);
+    const customRoute = route?.provider !== "signaliz" && route?.provider !== "csv" && !builtIn;
+    const prepareStep = firstArray(plan?.mcpFlow).find(
+      (step) => step?.tool === "gtm_provider_recipe_prepare" && record(step?.arguments).provider_id === route?.provider
+    );
+    const activateStep = firstArray(plan?.mcpFlow).find(
+      (step) => step?.tool === "gtm_provider_route_activate" && record(step?.arguments).provider_id === route?.provider
+    );
+    const activationArgs = record(activateStep?.arguments);
+    const readOnlySetup = !customRoute || prepareStep?.readOnly === true && activateStep?.readOnly === true && activationArgs.dry_run === true && activationArgs.confirm === false;
+    const blockers2 = [
+      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(Boolean);
+    return {
+      id: route?.id || `${route?.provider}-${route?.layer}`,
+      label: route?.label || campaignAgentReadinessLaneLabel(route, builtIn),
+      layer: route?.layer,
+      gtmLayers: firstArray(route?.gtmLayers).length ? route.gtmLayers : [route?.gtmLayer].filter(Boolean),
+      provider: route?.provider,
+      toolName: route?.toolName,
+      mode: route?.mode || "if_available",
+      builtIn,
+      approvalRequired: route?.approvalRequired === true || firstArray(plan?.approvals).some((approval) => approval?.routeId === route?.id),
+      customRoute,
+      readOnlySetup,
+      ready: blockers2.length === 0,
+      blockers: blockers2,
+      nextAction: customRoute ? `Review ${route?.provider} route setup before launch approval.` : void 0
+    };
+  });
+  const builtInLanes = lanes.filter((lane) => lane.builtIn);
+  const customRoutes = lanes.filter((lane) => lane.customRoute);
+  const strategyMemory = record(plan?.strategyMemoryStatus);
+  const deliveryRisk = record(record(plan?.buildRequest).deliveryRisk);
+  const risk = record(deliveryRisk.risk);
+  const riskLevel = String(risk.risk_level || risk.riskLevel || "").toLowerCase();
+  const riskBlockers = firstArray(deliveryRisk.blockers);
+  const gates = [
+    {
+      id: "campaign_plan_created",
+      label: "Campaign plan created",
+      passed: Boolean(plan?.planId && firstArray(plan?.mcpFlow).length),
+      detail: plan?.planId ? `Plan ${plan.planId} has ${firstArray(plan?.mcpFlow).length} MCP step(s).` : "No campaign-builder plan was created."
+    },
+    {
+      id: "built_in_lanes_ready",
+      label: "Built-in lanes ready",
+      passed: builtInLanes.length > 0 && builtInLanes.every((lane) => lane.ready),
+      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: !plan?.strategyMemoryStatus || strategyMemory.ready !== false,
+      detail: plan?.strategyMemoryStatus ? "Strategy memory readiness was checked." : "Strategy memory readiness was not requested."
+    },
+    {
+      id: "kernel_plan_attached",
+      label: "Kernel plan attached",
+      passed: Object.keys(record(plan?.kernelPlan)).length > 0,
+      detail: Object.keys(record(plan?.kernelPlan)).length > 0 ? "Kernel planner evidence is attached." : "Kernel planner evidence is not attached."
+    },
+    {
+      id: "delivery_risk_clear",
+      label: "Delivery risk clear",
+      passed: Object.keys(deliveryRisk).length === 0 || riskBlockers.length === 0 && !["high", "critical", "blocked"].includes(riskLevel),
+      detail: Object.keys(deliveryRisk).length === 0 ? "Delivery risk preflight was not requested." : `Delivery risk is ${riskLevel || "available"} with ${riskBlockers.length} blocker(s).`
+    },
+    {
+      id: "custom_routes_prepared",
+      label: "Custom routes prepared",
+      passed: customRoutes.every((lane) => lane.ready),
+      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: firstArray(plan?.approvals).length > 0,
+      detail: firstArray(plan?.approvals).length > 0 ? `${firstArray(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 ready = blockers.length === 0;
+  return {
+    plan,
+    lanes,
+    gates,
+    summary: {
+      ready,
+      score: Math.round(gates.filter((gate) => gate.passed).length / gates.length * 100),
+      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: firstArray(plan?.approvals).length,
+      blockers,
+      warnings: firstArray(plan?.warnings)
+    },
+    nextActions: ready ? [
+      "signaliz campaign-agent proof --request-file campaign-request.json --json",
+      "signaliz campaign-agent commit-plan --request-file campaign-request.json --json",
+      `signaliz campaign-agent build-approved --request-file campaign-request.json --confirm-launch --approve-all --approved-by operator@example.com --spend-limit ${plan?.estimatedCredits || 0}`
+    ] : ["signaliz campaign-agent plan --request-file campaign-request.json --json"]
+  };
+}
+function campaignAgentBuiltInForRoute(route) {
+  const map = {
+    "signaliz-lead-generation": "lead_generation",
+    "signaliz-local-leads": "local_leads",
+    "signaliz-email-finding": "email_finding",
+    "signaliz-email-verification": "email_verification",
+    "signaliz-signals": "signals"
+  };
+  return map[String(route?.id || "")];
+}
+function campaignAgentReadinessLaneLabel(route, 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 builtIn ? labels[builtIn] : `${route?.provider || "custom"} ${route?.layer || "route"}`;
+}
+function printCampaignAgentReadiness(readiness) {
+  const summary = record(readiness.summary);
+  const plan = record(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}`);
+  const gates = firstArray(readiness.gates);
+  if (gates.length) {
+    console.log("\nGates:");
+    for (const gate of gates) console.log(`- ${gate.passed ? "PASS" : "BLOCKED"} ${gate.label}: ${gate.detail}`);
+  }
+  const lanes = firstArray(readiness.lanes);
+  if (lanes.length) {
+    console.log("\nLanes:");
+    for (const lane of lanes) console.log(`- ${lane.ready ? "READY" : "BLOCKED"} ${lane.label}: ${lane.toolName || lane.provider}`);
+  }
+  const blockers = firstArray(summary.blockers);
+  if (blockers.length) {
+    console.log("\nBlockers:");
+    for (const blocker of blockers.slice(0, 8)) console.log(`- ${blocker}`);
+  }
+  const nextActions = firstArray(readiness.nextActions);
+  if (nextActions.length) {
+    console.log("\nNext:");
+    for (const action of nextActions) console.log(`- ${action}`);
+  }
+}
 function printCampaignAgentPlan(plan) {
   console.log(`Plan: ${plan.campaignName || plan.goal || plan.planId}`);
   if (plan.planId) console.log(`Plan ID: ${plan.planId}`);
@@ -5570,18 +5751,19 @@ async function simpleJob(cmd, rest) {
     if (isHelpRequest(rest) || !promptArg(rest) && !flagArg("prompt") && !flagArg("brief") && !flagArg("campaign-brief")) {
       process.stdout.write(`signaliz build "campaign brief" [options]
 
-Plan a campaign without spending credits or writing to providers.
+Run the campaign-agent proof path: strategy memory, Kernel plan, approvals, and
+a forced build_campaign dry-run without spend or provider writes.
 
 Examples:
   signaliz build "Build a campaign for industrial maintenance buyers" --target-count 50
-  signaliz build "Audit prior Instantly performance and build the next campaign" --preferred-providers instantly
+  signaliz build "Build a strategy-template campaign for local operators" --strategy-template non-medical-home-care --use-local-leads --json
 
 Equivalent:
-  signaliz gtm plan "campaign brief"
+  signaliz campaign-agent proof "campaign brief"
 `);
       return;
     }
-    return gtm("plan", rest);
+    return campaignAgent("proof", rest);
   }
   if (cmd === "connect") {
     if (isHelpRequest(rest)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaliz/cli",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Signaliz CLI — GTM Kernel, Nango routes, MCP, and enrichment operations.",
   "bin": {
     "signaliz": "dist/bin.js"