@signaliz/cli 1.0.11 → 1.0.13

package/dist/bin.js

@@ -1071,12 +1071,15 @@ 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
   campaign-agent dry-run  Execute build_campaign with dry_run=true
   campaign-agent build-approved
                           Launch only after explicit approval metadata
+  campaign-agent review <id>
+                          Review rows, artifacts, and delivery gates
   campaign-agent status <id>
                           Inspect a campaign-agent build
   campaign-agent rows <id>
@@ -2789,10 +2792,12 @@ 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
   build-approved    Launch only after explicit approval metadata
+  review            Review status, rows, artifacts, and delivery gates
   status            Inspect a campaign-agent build
   rows              Retrieve reviewable campaign-agent rows
   artifacts         List generated artifacts
@@ -2800,12 +2805,14 @@ 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
   signaliz campaign-agent dry-run --goal "Build a local services campaign" --target-count 250 --use-local-leads --json
   signaliz campaign-agent build-approved --goal "Build a strategy-template campaign" --confirm-launch --approve-all --approved-by operator@example.com --spend-limit 500
   signaliz campaign-agent build-approved --request-file campaign-builder-agent-request.json --confirm-launch --approve-all --approved-by operator@example.com --spend-limit 500 --wait --approve-delivery --delivery-destination-type json
+  signaliz campaign-agent review <campaign_build_id> --limit 100 --json
   signaliz campaign-agent status <campaign_build_id> --json
   signaliz campaign-agent rows <campaign_build_id> --limit 100 --json
 
@@ -2860,11 +2867,11 @@ async function campaignAgent(sub, rest) {
     process.stdout.write(CAMPAIGN_AGENT_HELP);
     return;
   }
-  if (["status", "rows", "artifacts", "approve", "approve-delivery"].includes(sub)) {
+  if (["review", "status", "rows", "artifacts", "approve", "approve-delivery"].includes(sub)) {
     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;
   }
@@ -2882,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";
@@ -2901,13 +2909,19 @@ 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));
+  }
+  const plan = await agent.createPlan(request, planOptions);
   if (sub === "proof" || sub === "smoke") {
     const result = await agent.dryRunPlan(plan, {
       idempotencyKey: commandStringFlag(flags, "idempotency-key")
@@ -2974,6 +2988,24 @@ async function campaignAgentReview(sub, rest) {
   const sdk = getSdk();
   const agent = sdk.campaignBuilderAgent;
   const campaigns = sdk.campaigns || {};
+  if (sub === "review") {
+    const rowOptions = {
+      limit: commandNumberFlag(flags, "limit") ?? 100,
+      cursor: commandStringFlag(flags, "cursor"),
+      segment: commandStringFlag(flags, "segment"),
+      rowStatus: commandStringFlag(flags, "row-status"),
+      qualified: commandBooleanFlag(flags, "qualified") ? true : commandBooleanFlag(flags, "disqualified") ? false : void 0
+    };
+    const review = await agent.reviewBuild?.(buildId, rowOptions) || await campaignAgentBuildReviewFromCampaignApis(agent, campaigns, buildId, rowOptions);
+    const operatorReview = {
+      ...review,
+      rows: {
+        ...review.rows,
+        rows: formatCampaignRowsForOperator(review.rows?.rows || [])
+      }
+    };
+    return output(operatorReview, () => printCampaignAgentBuildReview(operatorReview));
+  }
   if (sub === "status") {
     const status = await (agent.getBuildStatus?.bind(agent) || campaigns.status?.bind(campaigns) || campaigns.getCampaignBuildStatus?.bind(campaigns))?.(buildId);
     if (!status) die("campaign-agent status requires a compatible @signaliz/sdk campaign status API");
@@ -3025,6 +3057,13 @@ async function campaignAgentReview(sub, rest) {
     if (result.message) console.log(result.message);
   });
 }
+async function campaignAgentBuildReviewFromCampaignApis(agent, campaigns, buildId, rowOptions) {
+  const status = await (agent.getBuildStatus?.bind(agent) || campaigns.status?.bind(campaigns) || campaigns.getCampaignBuildStatus?.bind(campaigns))?.(buildId);
+  const rows = await (agent.getBuildRows?.bind(agent) || campaigns.rows?.bind(campaigns) || campaigns.getCampaignBuildRows?.bind(campaigns))?.(buildId, rowOptions);
+  const artifacts = await (agent.listBuildArtifacts?.bind(agent) || campaigns.artifacts?.bind(campaigns) || campaigns.listCampaignBuildArtifacts?.bind(campaigns))?.(buildId);
+  if (!status || !rows || !artifacts) die("campaign-agent review requires compatible @signaliz/sdk build status, rows, and artifacts APIs");
+  return createCampaignAgentBuildReview(status, rows, artifacts);
+}
 function campaignAgentRequestTemplateFromFlags(flags, rest) {
   const goal = commandStringFlag(flags, "goal", "brief") || promptArg(rest) || "Build a strategy-template campaign for mature operators in the target ICP.";
   const request = campaignAgentRequestFromFlags(goal, flags, { includeDefaults: true });
@@ -3305,6 +3344,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}`);
@@ -3357,6 +3562,140 @@ function printCampaignAgentBuildStatus(status) {
     hint(`signaliz ops run-status ${status.triggerRunId} --watch`);
   }
 }
+function printCampaignAgentBuildReview(review) {
+  const summary = record(review.summary);
+  const status = record(review.status);
+  console.log(`Campaign: ${status.name || review.campaignBuildId}`);
+  console.log(`Status:   ${summary.status || status.status}`);
+  console.log(`Phase:    ${summary.phase || status.currentPhase || "N/A"}`);
+  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}`);
+  console.log(`Delivery approval ready: ${summary.readyForDeliveryApproval === true ? "yes" : "no"}`);
+  const gates = Array.isArray(review.gates) ? review.gates : [];
+  if (gates.length) {
+    console.log("\nGates:");
+    for (const gate of gates) {
+      console.log(`- ${gate.passed ? "PASS" : "BLOCKED"} ${gate.label}: ${gate.detail}`);
+    }
+  }
+  const warnings = Array.isArray(summary.warnings) ? summary.warnings : [];
+  if (warnings.length) {
+    console.log("\nWarnings:");
+    for (const warning of warnings.slice(0, 5)) console.log(`- ${warning}`);
+  }
+  const nextActions = Array.isArray(review.nextActions) ? review.nextActions : [];
+  if (nextActions.length) {
+    console.log("\nNext:");
+    for (const action of nextActions) console.log(`- ${action}`);
+  }
+}
+function createCampaignAgentBuildReview(status, rows, artifacts) {
+  const rowList = Array.isArray(rows?.rows) ? rows.rows : [];
+  const sampledRows = rowList.length;
+  const availableRows = Number(rows?.count || sampledRows);
+  const qualifiedRows = rowList.filter((row) => row?.qualified !== false).length;
+  const operatorRows = formatCampaignRowsForOperator(rowList);
+  const rowsWithEmail = operatorRows.filter((row) => Boolean(row.email)).length;
+  const copyReadyRows = operatorRows.filter((row) => Boolean(row.has_copy || row.status === "copy_ready")).length;
+  const artifactCount = artifacts.length || Number(status?.artifactCount || status?.artifact_count || 0);
+  const buildStatus = String(status?.status || "unknown");
+  const gates = [
+    {
+      id: "build_completed",
+      label: "Build completed",
+      passed: buildStatus === "completed",
+      detail: buildStatus === "completed" ? "The campaign build is completed." : `The campaign build is ${buildStatus}; 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: Number(status?.recordsFailed || status?.records_failed || 0) === 0,
+      detail: Number(status?.recordsFailed || status?.records_failed || 0) === 0 ? "The build reports zero failed rows." : `${status.recordsFailed || status.records_failed} row(s) failed during the build.`
+    }
+  ];
+  const blockedReasons = gates.filter((gate) => !gate.passed).map((gate) => gate.detail);
+  const warnings = [
+    rows?.hasMore || rows?.has_more ? "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,
+    ...Array.isArray(status?.warnings) ? status.warnings : []
+  ].filter(Boolean);
+  const readyForDeliveryApproval = blockedReasons.length === 0;
+  return {
+    campaignBuildId: status.campaignBuildId || status.campaign_build_id || rows.campaignBuildId || rows.campaign_build_id || "",
+    status,
+    rows,
+    artifacts,
+    gates,
+    summary: {
+      status: buildStatus,
+      phase: status.currentPhase || status.current_phase || null,
+      sampledRows,
+      availableRows,
+      qualifiedRows,
+      rowsWithEmail,
+      copyReadyRows,
+      artifactCount,
+      readyForDeliveryApproval,
+      blockedReasons,
+      warnings
+    },
+    nextActions: campaignAgentReviewNextActions(status, readyForDeliveryApproval)
+  };
+}
+function campaignAgentReviewNextActions(status, readyForDeliveryApproval) {
+  const buildId = status.campaignBuildId || status.campaign_build_id;
+  const buildStatus = String(status.status || "unknown");
+  if (!buildId) return [];
+  if (buildStatus === "completed" && readyForDeliveryApproval) {
+    return [
+      `signaliz campaign-agent approve ${buildId} --destination-type json`,
+      `signaliz campaign-agent artifacts ${buildId}`
+    ];
+  }
+  if (buildStatus === "completed") {
+    return [
+      `signaliz campaign-agent rows ${buildId} --limit 100`,
+      `signaliz campaign-agent artifacts ${buildId}`
+    ];
+  }
+  if (buildStatus === "pending_approval") {
+    return [
+      `signaliz campaign-agent rows ${buildId} --limit 100`,
+      `signaliz campaign-agent approve ${buildId} --destination-type json`
+    ];
+  }
+  if ((buildStatus === "queued" || buildStatus === "running") && status.triggerRunId) {
+    return [`signaliz ops run-status ${status.triggerRunId} --watch`];
+  }
+  return [`signaliz campaign-agent status ${buildId}`];
+}
 function printCampaignAgentRows(result) {
   if (!Array.isArray(result.rows) || result.rows.length === 0) {
     console.log("No rows found.");

package/package.json

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