@signaliz/sdk 1.0.6 → 1.0.7

package/dist/cli.mjs

@@ -1,18 +1,27 @@
 #!/usr/bin/env node
 import {
-  Signaliz
-} from "./chunk-GRVV37LD.mjs";
+  Signaliz,
+  createCampaignBuilderAgentRequestTemplate,
+  createCampaignBuilderApproval
+} from "./chunk-BHL5NHVO.mjs";
 
 // src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
 var apiKey = process.env.SIGNALIZ_API_KEY;
+var baseUrl = process.env.SIGNALIZ_BASE_URL || process.env.SIGNALIZ_API_URL;
 async function main() {
   const command = process.argv[2];
-  if (!apiKey) {
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  const offlineCampaignAgentTemplate = (command === "campaign-agent" || command === "campaign-builder") && ["init", "template", "request-template", "new"].includes(String(process.argv[3] || ""));
+  if (!apiKey && !offlineCampaignAgentTemplate) {
     console.error("\u274C SIGNALIZ_API_KEY environment variable is required.");
     console.error("   Set it with: export SIGNALIZ_API_KEY=sk_...");
     process.exit(1);
   }
-  const signaliz = new Signaliz({ apiKey });
+  const signaliz = new Signaliz({ apiKey: apiKey || "offline", baseUrl });
   switch (command) {
     case "test": {
       try {
@@ -43,18 +52,962 @@ async function main() {
       }
       break;
     }
+    case "gtm": {
+      await handleGtmCommand(signaliz, process.argv.slice(3));
+      break;
+    }
+    case "campaign-agent":
+    case "campaign-builder": {
+      await handleCampaignAgentCommand(signaliz, process.argv.slice(3));
+      break;
+    }
     default:
-      console.log(`
+      printHelp();
+  }
+}
+async function handleGtmCommand(signaliz, argv) {
+  const subcommand = argv[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printGtmHelp();
+    return;
+  }
+  if (subcommand === "context") {
+    const flags = parseFlags(argv.slice(1));
+    const result = await signaliz.gtm.context({
+      includeCampaigns: booleanFlag(flags, "include-campaigns"),
+      includeMemory: booleanFlag(flags, "include-memory"),
+      includeBrain: booleanFlag(flags, "include-brain"),
+      includeConnections: booleanFlag(flags, "include-connections"),
+      limit: numberFlag(flags, "limit")
+    });
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "bootstrap") {
+    const flags = parseFlags(argv.slice(1));
+    const result = await signaliz.gtm.bootstrapStatus({
+      campaignId: stringFlag(flags, "campaign-id"),
+      days: numberFlag(flags, "days"),
+      minSampleSize: numberFlag(flags, "min-sample-size"),
+      includeConnections: booleanFlag(flags, "include-connections"),
+      includeSamples: booleanFlag(flags, "include-samples"),
+      limit: numberFlag(flags, "limit")
+    });
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "memory" && argv[1] === "search") {
+    const flags = parseFlags(argv.slice(2));
+    const query = stringFlag(flags, "query", "q");
+    if (!query) throw new Error("gtm memory search requires --query");
+    const options = {
+      query,
+      campaignId: stringFlag(flags, "campaign-id"),
+      memoryType: stringFlag(flags, "memory-type"),
+      keywords: csvFlag(flags, "keywords"),
+      outcomeType: stringFlag(flags, "outcome-type"),
+      layers: csvFlag(flags, "layers"),
+      providerChain: csvFlag(flags, "provider-chain", "providers"),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.searchMemory(options);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "templates" || subcommand === "strategy-templates") {
+    const flags = parseFlags(argv.slice(1));
+    const result = await signaliz.gtm.campaignStrategyTemplates({
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      query: stringFlag(flags, "query", "q"),
+      includeDetails: !booleanFlag(flags, "summary")
+    });
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "start-context" || subcommand === "start") {
+    const flags = parseFlags(argv.slice(1));
+    const campaignBrief = stringFlag(flags, "brief", "campaign-brief", "goal");
+    const strategyTemplate = stringFlag(flags, "strategy-template", "template");
+    const targetIcp = jsonObjectFlag(flags, "target-icp", "icp");
+    if (!campaignBrief && !stringFlag(flags, "campaign-id") && !stringFlag(flags, "campaign-build-id") && !strategyTemplate && !targetIcp) {
+      throw new Error("gtm start-context requires --brief, --campaign-id, --campaign-build-id, --strategy-template, or --target-icp");
+    }
+    const input = {
+      campaignId: stringFlag(flags, "campaign-id"),
+      campaignBuildId: stringFlag(flags, "campaign-build-id"),
+      campaignBrief,
+      strategyTemplate,
+      targetIcp,
+      leadCount: numberFlag(flags, "lead-count", "target-count"),
+      layers: csvFlag(flags, "layers"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      memoryDimensionFilters: jsonObjectFlag(flags, "memory-dimension-filters"),
+      requireMemoryDimensionMatch: booleanFlag(flags, "require-memory-dimension-match"),
+      includeMemory: booleanFlag(flags, "include-memory", true),
+      includeBrain: booleanFlag(flags, "include-brain", true),
+      includeProviderRoutes: booleanFlag(flags, "include-provider-routes", true),
+      includeFailurePatterns: booleanFlag(flags, "include-failure-patterns", true),
+      includeDeliveryRisk: booleanFlag(flags, "include-delivery-risk", true),
+      includeGlobalBrain: booleanFlag(flags, "include-global-brain", true),
+      includePlannedProviders: booleanFlag(flags, "include-planned-providers", true),
+      days: numberFlag(flags, "days"),
+      minConfidence: numberFlag(flags, "min-confidence"),
+      minSampleSize: numberFlag(flags, "min-sample-size"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignStartContext(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "strategy-memory" || subcommand === "memory-status" || subcommand === "strategy-memory-status") {
+    const flags = parseFlags(argv.slice(1));
+    const input = {
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      query: stringFlag(flags, "query", "goal", "q"),
+      campaignBrief: stringFlag(flags, "brief", "campaign-brief"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      memoryDimensionFilters: jsonObjectFlag(flags, "memory-dimension-filters"),
+      requireMemoryDimensionMatch: booleanFlag(flags, "require-memory-dimension-match"),
+      includeSamples: booleanFlag(flags, "include-samples"),
+      includeSources: !booleanFlag(flags, "no-sources"),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignStrategyMemoryStatus(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "plan") {
+    const flags = parseFlags(argv.slice(1));
+    const campaignBrief = stringFlag(flags, "brief", "campaign-brief", "goal");
+    if (!campaignBrief && !stringFlag(flags, "campaign-id") && !stringFlag(flags, "campaign-build-id")) {
+      throw new Error("gtm plan requires --brief, --campaign-id, or --campaign-build-id");
+    }
+    const input = {
+      campaignId: stringFlag(flags, "campaign-id"),
+      campaignBuildId: stringFlag(flags, "campaign-build-id"),
+      campaignBrief,
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      leadCount: numberFlag(flags, "lead-count", "target-count"),
+      layers: csvFlag(flags, "layers"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      strategyModel: stringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !booleanFlag(flags, "no-strategy-patterns") && !booleanFlag(flags, "no-agency-patterns"),
+      includeWorkflowPatterns: !booleanFlag(flags, "no-workflow-patterns") && !booleanFlag(flags, "no-clay-patterns"),
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: csvFlag(flags, "partner-ecosystem", "partners"),
+      includeMemory: booleanFlag(flags, "include-memory", true),
+      includeBrain: booleanFlag(flags, "include-brain", true),
+      includeProviderRoutes: booleanFlag(flags, "include-provider-routes", true),
+      includeFailurePatterns: booleanFlag(flags, "include-failure-patterns", true),
+      includePlannedProviders: booleanFlag(flags, "include-planned-providers", true),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignBuildPlan(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "agent-plan" || subcommand === "campaign-agent-plan") {
+    const flags = parseFlags(argv.slice(1));
+    const goal = stringFlag(flags, "goal", "brief", "campaign-brief");
+    if (!goal && !stringFlag(flags, "campaign-id") && !stringFlag(flags, "campaign-build-id") && !stringFlag(flags, "strategy-template", "template")) {
+      throw new Error("gtm agent-plan requires --goal, --campaign-id, --campaign-build-id, or --strategy-template");
+    }
+    const input = {
+      goal,
+      campaignName: stringFlag(flags, "campaign-name", "name"),
+      campaignId: stringFlag(flags, "campaign-id"),
+      campaignBuildId: stringFlag(flags, "campaign-build-id", "build-id"),
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      operatingPlaybooks: csvFlag(flags, "operating-playbooks", "playbooks"),
+      accountContext: stringFlag(flags, "account-context", "workspace-context"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      targetCount: numberFlag(flags, "target-count", "lead-count"),
+      builtIns: campaignAgentBuiltInsFromFlags(flags),
+      useLocalLeads: booleanFlag(flags, "use-local-leads") || void 0,
+      layers: csvFlag(flags, "layers"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      customTools: campaignAgentCustomToolRoutesFromFlags(flags),
+      strategyModel: stringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !booleanFlag(flags, "no-strategy-patterns"),
+      includeWorkflowPatterns: !booleanFlag(flags, "no-workflow-patterns"),
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: csvFlag(flags, "partner-ecosystem", "partners"),
+      includeMemory: !booleanFlag(flags, "no-memory"),
+      includeBrain: !booleanFlag(flags, "no-brain"),
+      includeProviderRoutes: !booleanFlag(flags, "no-provider-routes"),
+      includeFailurePatterns: !booleanFlag(flags, "no-failure-patterns"),
+      includeDeliveryRisk: !booleanFlag(flags, "no-delivery-risk"),
+      includePlannedProviders: !booleanFlag(flags, "no-planned-providers"),
+      days: numberFlag(flags, "days"),
+      limit: numberFlag(flags, "limit")
+    };
+    const result = await signaliz.gtm.campaignAgentPlan(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "agent-template" || subcommand === "campaign-agent-template" || subcommand === "request-template") {
+    const flags = parseFlags(argv.slice(1));
+    const input = {
+      goal: stringFlag(flags, "goal", "brief", "campaign-brief"),
+      campaignName: stringFlag(flags, "campaign-name", "name"),
+      accountLabel: stringFlag(flags, "workspace-label", "account-label"),
+      accountContext: stringFlag(flags, "account-context", "workspace-context"),
+      strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+      operatingPlaybooks: csvFlag(flags, "operating-playbooks", "playbooks"),
+      targetIcp: jsonObjectFlag(flags, "target-icp", "icp"),
+      targetCount: numberFlag(flags, "target-count", "lead-count"),
+      builtIns: campaignAgentBuiltInsFromFlags(flags),
+      includeLocalLeads: booleanFlag(flags, "use-local-leads") || booleanFlag(flags, "include-local-leads") || void 0,
+      includeByoPlaceholder: booleanFlag(flags, "with-byo-placeholder") || booleanFlag(flags, "include-byo-placeholder") || void 0,
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      preferredProviders: csvFlag(flags, "preferred-providers", "providers"),
+      privacyMode: stringFlag(flags, "privacy-mode"),
+      destinationType: stringFlag(flags, "destination", "destination-type")
+    };
+    const result = await signaliz.gtm.campaignAgentRequestTemplate(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "provider-prepare" || subcommand === "prepare-provider" || subcommand === "recipe-prepare" || subcommand === "prepare-recipe") {
+    const flags = parseFlags(argv.slice(1));
+    const providerId = stringFlag(flags, "provider-id", "provider") || argv[1];
+    if (!providerId) {
+      throw new Error("gtm provider-prepare requires --provider-id or provider id");
+    }
+    const input = {
+      providerId,
+      providerName: stringFlag(flags, "provider-name", "name"),
+      description: stringFlag(flags, "description"),
+      layerCapabilities: csvFlag(flags, "layer-capabilities", "layers"),
+      invocationType: stringFlag(flags, "invocation-type"),
+      authStrategy: stringFlag(flags, "auth-strategy"),
+      endpointUrl: stringFlag(flags, "endpoint-url"),
+      httpMethod: stringFlag(flags, "http-method") || void 0,
+      secretRef: stringFlag(flags, "secret-ref"),
+      workspaceIntegrationId: stringFlag(flags, "workspace-integration-id"),
+      workspaceMcpServerId: stringFlag(flags, "workspace-mcp-server-id"),
+      workspaceConnectionId: stringFlag(flags, "workspace-connection-id"),
+      requestTemplate: jsonObjectFlag(flags, "request-template"),
+      responseMapping: jsonObjectFlag(flags, "response-mapping"),
+      inputSchema: jsonObjectFlag(flags, "input-schema"),
+      outputSchema: jsonObjectFlag(flags, "output-schema"),
+      readiness: jsonObjectFlag(flags, "readiness"),
+      metadata: jsonObjectFlag(flags, "metadata"),
+      layer: stringFlag(flags, "layer"),
+      campaignId: stringFlag(flags, "campaign-id"),
+      useSignalizFallback: !booleanFlag(flags, "no-signaliz-fallback"),
+      priority: numberFlag(flags, "priority"),
+      status: stringFlag(flags, "status"),
+      context: jsonObjectFlag(flags, "context")
+    };
+    const result = await signaliz.gtm.prepareProviderRecipe(input);
+    printResult(result, flags);
+    return;
+  }
+  if (subcommand === "activate-route" || subcommand === "route-activate") {
+    const flags = parseFlags(argv.slice(1));
+    const providerId = stringFlag(flags, "provider-id", "provider") || argv[1];
+    if (!providerId) {
+      throw new Error("gtm activate-route requires --provider-id or provider id");
+    }
+    const layers = csvFlag(flags, "layers");
+    const layer = stringFlag(flags, "layer");
+    if (!layer && !layers?.length) {
+      throw new Error("gtm activate-route requires --layer or --layers");
+    }
+    const confirm = booleanFlag(flags, "confirm");
+    const input = {
+      providerId,
+      providerName: stringFlag(flags, "provider-name", "name"),
+      description: stringFlag(flags, "description"),
+      campaignId: stringFlag(flags, "campaign-id"),
+      layer,
+      layers,
+      invocationType: stringFlag(flags, "invocation-type"),
+      authStrategy: stringFlag(flags, "auth-strategy"),
+      endpointUrl: stringFlag(flags, "endpoint-url"),
+      httpMethod: stringFlag(flags, "http-method") || void 0,
+      secretRef: stringFlag(flags, "secret-ref"),
+      workspaceIntegrationId: stringFlag(flags, "workspace-integration-id"),
+      workspaceMcpServerId: stringFlag(flags, "workspace-mcp-server-id"),
+      workspaceConnectionId: stringFlag(flags, "workspace-connection-id"),
+      useSignalizFallback: !booleanFlag(flags, "no-signaliz-fallback"),
+      priority: numberFlag(flags, "priority"),
+      routeConfig: jsonObjectFlag(flags, "route-config"),
+      requestTemplate: jsonObjectFlag(flags, "request-template"),
+      responseMapping: jsonObjectFlag(flags, "response-mapping"),
+      inputSchema: jsonObjectFlag(flags, "input-schema"),
+      outputSchema: jsonObjectFlag(flags, "output-schema"),
+      readiness: jsonObjectFlag(flags, "readiness"),
+      metadata: jsonObjectFlag(flags, "metadata"),
+      status: stringFlag(flags, "status"),
+      routeStatus: stringFlag(flags, "route-status"),
+      replaceExistingRoutes: !booleanFlag(flags, "keep-existing-routes"),
+      dryRun: !confirm,
+      confirm,
+      context: jsonObjectFlag(flags, "context")
+    };
+    const result = await signaliz.gtm.activateProviderRoute(input);
+    printResult(result, flags);
+    return;
+  }
+  printGtmHelp();
+}
+async function handleCampaignAgentCommand(signaliz, argv) {
+  const subcommand = argv[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printCampaignAgentHelp();
+    return;
+  }
+  if (["init", "template", "request-template", "new"].includes(subcommand)) {
+    const flags2 = parseFlags(argv.slice(1));
+    const request2 = campaignAgentRequestTemplateFromFlags(flags2);
+    const outputFile = stringFlag(flags2, "output-file", "out");
+    if (outputFile) {
+      writeFileSync(outputFile, `${JSON.stringify(request2, null, 2)}
+`, "utf8");
+    }
+    if (booleanFlag(flags2, "json") || !outputFile) {
+      printJson(request2);
+    } else {
+      console.log(`Campaign request template written: ${outputFile}`);
+      console.log(`Next: signaliz campaign-agent plan --request-file ${outputFile} --json`);
+    }
+    return;
+  }
+  if (!["plan", "proof", "smoke", "commit-plan", "dry-run", "build-approved", "launch-approved"].includes(subcommand)) {
+    printCampaignAgentHelp();
+    return;
+  }
+  const flags = parseFlags(argv.slice(1));
+  const requestFromFile = campaignAgentRequestFileFromFlags(flags);
+  const goal = stringFlag(flags, "goal", "brief") ?? stringOrUndefined(requestFromFile?.goal);
+  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";
+  const isConfirmedCommit = isCommitPlan && booleanFlag(flags, "confirm-write");
+  const approvedBy = stringFlag(flags, "approved-by");
+  if (isApprovedBuild) {
+    if (!booleanFlag(flags, "confirm-launch")) {
+      throw new Error(`campaign-agent ${subcommand} requires --confirm-launch`);
+    }
+    if (!approvedBy) throw new Error(`campaign-agent ${subcommand} requires --approved-by`);
+  }
+  if (isConfirmedCommit && !approvedBy) {
+    throw new Error("campaign-agent commit-plan --confirm-write requires --approved-by");
+  }
+  const request = mergeCampaignAgentRequests(
+    requestFromFile,
+    campaignAgentRequestFromFlags(goal, flags, { includeDefaults: !requestFromFile })
+  );
+  const plan = await signaliz.campaignBuilderAgent.createPlan(request, {
+    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 (subcommand === "proof" || subcommand === "smoke") {
+    const result = await signaliz.campaignBuilderAgent.dryRunPlan(plan, {
+      idempotencyKey: stringFlag(flags, "idempotency-key")
+    });
+    const proof = createCampaignAgentProofReceipt(plan, result);
+    if (booleanFlag(flags, "json")) {
+      printJson(proof);
+    } else {
+      printCampaignAgentProof(proof);
+    }
+    if (!proof.success) process.exitCode = 1;
+    return;
+  }
+  if (isCommitPlan) {
+    const result = await signaliz.campaignBuilderAgent.commitPlan(plan, {
+      confirm: isConfirmedCommit,
+      dryRun: !isConfirmedCommit,
+      approvedBy,
+      idempotencyKey: stringFlag(flags, "idempotency-key"),
+      rationale: stringFlag(flags, "rationale")
+    });
+    printCampaignAgentExecution({ plan, result }, flags);
+    return;
+  }
+  if (subcommand === "dry-run") {
+    const result = await signaliz.campaignBuilderAgent.dryRunPlan(plan, {
+      idempotencyKey: stringFlag(flags, "idempotency-key")
+    });
+    printCampaignAgentExecution({ plan, result }, flags);
+    return;
+  }
+  if (isApprovedBuild) {
+    const approvedTypes = approvedTypesFromFlags(plan, flags);
+    const approval = createCampaignBuilderApproval(plan, {
+      approvedBy,
+      approvedTypes,
+      spendLimitCredits: numberFlag(flags, "spend-limit", "spend-limit-credits", "max-credits"),
+      approvedRouteIds: approvedRouteIdsFromFlags(plan, flags),
+      notes: stringFlag(flags, "approval-notes", "notes")
+    });
+    const result = await signaliz.campaignBuilderAgent.buildApprovedPlan(plan, approval, {
+      idempotencyKey: stringFlag(flags, "idempotency-key"),
+      commitBeforeLaunch: booleanFlag(flags, "commit-before-launch")
+    });
+    printCampaignAgentExecution({ plan, approval, result }, flags);
+    return;
+  }
+  if (booleanFlag(flags, "json")) {
+    printJson(plan);
+  } else {
+    printCampaignAgentPlan(plan);
+  }
+}
+function campaignAgentRequestTemplateFromFlags(flags) {
+  const goal = stringFlag(flags, "goal", "brief") || "Build a strategy-template campaign for mature operators in the target ICP.";
+  const request = campaignAgentRequestFromFlags(goal, flags, { includeDefaults: true });
+  const options = {
+    ...request,
+    includeLocalLeads: booleanFlag(flags, "use-local-leads"),
+    includeCustomToolPlaceholder: booleanFlag(flags, "with-byo-placeholder") || booleanFlag(flags, "include-custom-tool-placeholder") || booleanFlag(flags, "include-byo-placeholder"),
+    includeNango: !booleanFlag(flags, "no-nango-catalog")
+  };
+  return createCampaignBuilderAgentRequestTemplate(options);
+}
+function campaignAgentRequestFileFromFlags(flags) {
+  const file = stringFlag(flags, "request-file", "input-file", "campaign-file");
+  if (!file) return void 0;
+  const parsed = JSON.parse(readFileSync(file, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected JSON object for --request-file`);
+  }
+  return parsed;
+}
+function campaignAgentRequestFromFlags(goal, flags, options = {}) {
+  const builtIns = campaignAgentBuiltInsFromFlags(flags);
+  const integrations = campaignAgentCustomToolRoutesFromFlags(flags);
+  const includeDefaults = options.includeDefaults !== false;
+  const request = {
+    goal,
+    campaignName: stringFlag(flags, "campaign-name", "name"),
+    accountLabel: stringFlag(flags, "workspace-label", "account-label"),
+    strategyTemplate: stringFlag(flags, "strategy-template", "template"),
+    accountContext: stringFlag(flags, "account-context", "workspace-context"),
+    targetCount: numberFlag(flags, "target-count", "lead-count"),
+    gtmCampaignId: stringFlag(flags, "gtm-campaign-id", "campaign-id"),
+    icp: jsonObjectFlag(flags, "icp", "target-icp"),
+    brainDefaults: jsonObjectFlag(flags, "brain-defaults"),
+    deliveryRisk: jsonObjectFlag(flags, "delivery-risk"),
+    builtIns,
+    operatingPlaybooks: csvFlag(flags, "operating-playbooks", "playbooks"),
+    integrations,
+    preferredProviders: csvFlag(flags, "preferred-providers", "providers")
+  };
+  if (includeDefaults || flagValue(flags, "strategy-model", "no-strategy-patterns", "no-agency-patterns", "no-workflow-patterns", "no-clay-patterns", "no-nango-catalog", "partners", "revenue-motion") !== void 0) {
+    request.agencyContext = {
+      strategyModel: stringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !booleanFlag(flags, "no-strategy-patterns") && !booleanFlag(flags, "no-agency-patterns"),
+      includeWorkflowPatterns: !booleanFlag(flags, "no-workflow-patterns") && !booleanFlag(flags, "no-clay-patterns"),
+      includeNangoCatalog: !booleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: csvFlag(flags, "partners"),
+      revenueMotion: stringFlag(flags, "revenue-motion")
+    };
+  }
+  if (includeDefaults || flagValue(flags, "no-memory", "no-workspace-history", "use-network-patterns", "privacy-mode") !== void 0) {
+    request.memory = {
+      enabled: !booleanFlag(flags, "no-memory"),
+      useWorkspaceHistory: !booleanFlag(flags, "no-workspace-history"),
+      useNetworkPatterns: booleanFlag(flags, "use-network-patterns"),
+      privacyMode: stringFlag(flags, "privacy-mode")
+    };
+  }
+  if (includeDefaults || flagValue(flags, "max-credits", "no-delivery", "destination") !== void 0) {
+    request.signalizDefaults = {
+      maxCredits: numberFlag(flags, "max-credits"),
+      delivery: {
+        enabled: !booleanFlag(flags, "no-delivery"),
+        destinationType: stringFlag(flags, "destination"),
+        approvalRequired: true
+      }
+    };
+  }
+  if (includeDefaults || flagValue(flags, "no-human-approval", "max-credits-without-approval") !== void 0) {
+    request.approvalPolicy = {
+      requireHumanApproval: !booleanFlag(flags, "no-human-approval"),
+      maxCreditsWithoutApproval: numberFlag(flags, "max-credits-without-approval"),
+      requireApprovalFor: ["memory_retrieval", "spend", "customer_tool", "external_write", "delivery", "launch"]
+    };
+  }
+  return compactRequest(request);
+}
+function mergeCampaignAgentRequests(base, override) {
+  if (!base) return override;
+  return compactRequest({
+    ...base,
+    ...override,
+    icp: mergeRecords(base.icp, override.icp),
+    memory: mergeRecords(base.memory, override.memory),
+    agencyContext: mergeRecords(base.agencyContext, override.agencyContext),
+    signalizDefaults: mergeRecords(base.signalizDefaults, override.signalizDefaults),
+    approvalPolicy: mergeRecords(base.approvalPolicy, override.approvalPolicy),
+    constraints: mergeRecords(base.constraints, override.constraints),
+    workspaceContext: mergeRecords(base.workspaceContext, override.workspaceContext),
+    builtIns: override.builtIns ?? base.builtIns,
+    operatingPlaybooks: override.operatingPlaybooks ?? base.operatingPlaybooks,
+    integrations: override.integrations ?? base.integrations,
+    customerTools: override.customerTools ?? base.customerTools,
+    preferredProviders: override.preferredProviders ?? base.preferredProviders
+  });
+}
+function mergeRecords(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  if (typeof base === "object" && typeof override === "object" && !Array.isArray(base) && !Array.isArray(override)) {
+    return { ...base, ...override };
+  }
+  return override;
+}
+function compactRequest(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([, value]) => value !== void 0)
+  );
+}
+function campaignAgentBuiltInsFromFlags(flags) {
+  const explicit = csvFlag(flags, "builtins", "builtin-tools", "signaliz-tools");
+  const hasBuiltinFlag = Boolean(
+    explicit?.length || flagValue(flags, "use-local-leads") !== void 0 || flagValue(flags, "no-lead-generation") !== void 0 || flagValue(flags, "no-email-finding") !== void 0 || flagValue(flags, "no-verification") !== void 0 || flagValue(flags, "no-signals") !== void 0
+  );
+  if (!hasBuiltinFlag) return void 0;
+  const builtIns = new Set(
+    explicit?.length ? explicit : ["lead_generation", "email_finding", "email_verification", "signals"]
+  );
+  if (booleanFlag(flags, "use-local-leads")) builtIns.add("local_leads");
+  if (booleanFlag(flags, "no-lead-generation")) builtIns.delete("lead_generation");
+  if (booleanFlag(flags, "no-email-finding")) builtIns.delete("email_finding");
+  if (booleanFlag(flags, "no-verification")) builtIns.delete("email_verification");
+  if (booleanFlag(flags, "no-signals")) builtIns.delete("signals");
+  return [...builtIns];
+}
+function campaignAgentCustomToolRoutesFromFlags(flags) {
+  const values = repeatedStringFlag(flags, "custom-tool", "customer-tool", "byo-tool", "integration-route");
+  const routes = values.map(parseCampaignAgentCustomToolRoute);
+  return routes.length > 0 ? routes : void 0;
+}
+function parseCampaignAgentCustomToolRoute(raw) {
+  const record = raw.trim().startsWith("{") ? jsonObjectFromString(raw, "--custom-tool") : raw.includes("=") ? keyValueObject(raw) : colonRouteObject(raw);
+  const layer = normalizeCampaignBuilderLayer(String(record.layer ?? record.use_for_layer ?? record.useForLayer ?? "enrichment"));
+  const gtmLayers = stringArrayValue(record.gtm_layers ?? record.gtmLayers ?? record.capabilities);
+  const provider = String(record.provider ?? record.provider_id ?? record.providerId ?? "custom_mcp");
+  const toolName = stringOrUndefined(record.tool ?? record.tool_name ?? record.toolName);
+  const label = stringOrUndefined(record.label ?? record.name) ?? provider;
+  const mcpServerName = stringOrUndefined(record.mcp ?? record.server ?? record.mcp_server_name ?? record.mcpServerName);
+  const mode = normalizeRouteMode(String(record.mode ?? "required"));
+  return {
+    provider,
+    layer,
+    gtmLayers,
+    mode,
+    toolName,
+    mcpServerName,
+    label,
+    approvalRequired: optionalBoolean(record.approval_required ?? record.approvalRequired, true),
+    config: {
+      provider_id: record.provider_id ?? record.providerId,
+      available_tools: stringArrayValue(record.available_tools ?? record.availableTools ?? record.tools),
+      raw: raw.trim()
+    },
+    rationale: `${label} is a user-provided campaign-builder route declared from the CLI.`
+  };
+}
+function colonRouteObject(raw) {
+  const [provider, layer, tool, mcp] = raw.split(":").map((part) => part.trim()).filter(Boolean);
+  if (!provider || !layer) {
+    throw new Error("Expected --custom-tool provider:layer:tool[:mcp] or key=value pairs");
+  }
+  return { provider, layer, tool, mcp };
+}
+function keyValueObject(raw) {
+  const record = {};
+  for (const segment of raw.split(",")) {
+    const eq = segment.indexOf("=");
+    if (eq < 0) continue;
+    const key = segment.slice(0, eq).trim().replace(/-/g, "_");
+    const value = segment.slice(eq + 1).trim();
+    record[key] = value;
+  }
+  return record;
+}
+function normalizeCampaignBuilderLayer(value) {
+  const normalized = normalizeEnumValue(value);
+  const allowed = ["workspace_context", "memory", "source", "enrichment", "qualification", "copy", "delivery", "feedback", "approval"];
+  if (!allowed.includes(normalized)) {
+    throw new Error(`Unknown campaign-builder layer "${value}". Use source, enrichment, qualification, copy, delivery, feedback, or approval.`);
+  }
+  return normalized;
+}
+function normalizeRouteMode(value) {
+  const normalized = normalizeEnumValue(value);
+  return ["required", "if_available", "fallback", "disabled"].includes(normalized) ? normalized : "required";
+}
+function normalizeEnumValue(value) {
+  return value.trim().toLowerCase().replace(/-/g, "_");
+}
+function stringArrayValue(value) {
+  const values = Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  const parsed = values.flatMap((item) => String(item).split(/[|,]/).map((part) => part.trim()).filter(Boolean));
+  return parsed.length > 0 ? parsed : void 0;
+}
+function stringOrUndefined(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function optionalBoolean(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  return parseBoolean(String(value), defaultValue);
+}
+function approvedTypesFromFlags(plan, flags) {
+  const requested = csvFlag(flags, "approved-types", "approve-types");
+  if (requested?.length) return requested;
+  if (!booleanFlag(flags, "approve-all")) {
+    throw new Error("campaign-agent build-approved requires --approve-all or --approved-types");
+  }
+  return [...new Set(plan.approvals.map((item) => item.type))];
+}
+function approvedRouteIdsFromFlags(plan, flags) {
+  const requested = csvFlag(flags, "approved-route-ids", "route-ids");
+  if (requested?.length) return requested;
+  if (!booleanFlag(flags, "approve-all")) return void 0;
+  const routeIds = plan.approvals.map((item) => item.routeId).filter((id) => Boolean(id));
+  return routeIds.length > 0 ? routeIds : void 0;
+}
+function parseFlags(argv) {
+  const flags = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token.startsWith("--")) continue;
+    const eq = token.indexOf("=");
+    const key = normalizeFlagName(eq >= 0 ? token.slice(2, eq) : token.slice(2));
+    const value = eq >= 0 ? token.slice(eq + 1) : argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[++i] : true;
+    const existing = flags[key];
+    if (existing === void 0) {
+      flags[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(String(value));
+    } else {
+      flags[key] = [String(existing), String(value)];
+    }
+  }
+  return flags;
+}
+function normalizeFlagName(name) {
+  return name.replace(/_/g, "-");
+}
+function flagValue(flags, ...names) {
+  for (const name of names.map(normalizeFlagName)) {
+    if (flags[name] !== void 0) return flags[name];
+  }
+  return void 0;
+}
+function stringFlag(flags, ...names) {
+  const value = flagValue(flags, ...names);
+  if (Array.isArray(value)) return value.at(-1);
+  if (value === void 0 || value === true || value === false) return void 0;
+  const trimmed = String(value).trim();
+  return trimmed || void 0;
+}
+function numberFlag(flags, ...names) {
+  const value = stringFlag(flags, ...names);
+  if (!value) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new Error(`Expected numeric value for --${names[0]}`);
+  return parsed;
+}
+function booleanFlag(flags, name, defaultValue = false) {
+  const value = flagValue(flags, name);
+  if (value === void 0) return defaultValue;
+  if (Array.isArray(value)) return value.length > 0 ? parseBoolean(value.at(-1), defaultValue) : defaultValue;
+  return parseBoolean(value, defaultValue);
+}
+function parseBoolean(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  return !["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function csvFlag(flags, ...names) {
+  const value = flagValue(flags, ...names);
+  const values = Array.isArray(value) ? value : value === void 0 || typeof value === "boolean" ? [] : [value];
+  const parsed = values.flatMap((item) => String(item).split(",").map((part) => part.trim()).filter(Boolean));
+  return parsed.length > 0 ? parsed : void 0;
+}
+function repeatedStringFlag(flags, ...names) {
+  const value = flagValue(flags, ...names);
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  if (value === void 0 || typeof value === "boolean") return [];
+  const trimmed = String(value).trim();
+  return trimmed ? [trimmed] : [];
+}
+function jsonObjectFlag(flags, ...names) {
+  const value = stringFlag(flags, ...names);
+  if (!value) return void 0;
+  return jsonObjectFromString(value, `--${names[0]}`);
+}
+function jsonObjectFromString(value, label) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected JSON object for ${label}`);
+  }
+  return parsed;
+}
+function printResult(result, flags) {
+  if (booleanFlag(flags, "json")) {
+    printJson(result);
+    return;
+  }
+  if (result && typeof result === "object") {
+    const record = result;
+    const title = record.summary || record.message || record.next_action || record.status;
+    if (title) console.log(String(title));
+    printJson(result);
+    return;
+  }
+  console.log(String(result ?? ""));
+}
+function printCampaignAgentPlan(plan) {
+  console.log(`Plan: ${plan.campaignName}`);
+  console.log(`Plan ID: ${plan.planId}`);
+  console.log(`Target: ${plan.targetCount}`);
+  console.log(`Estimated credits: ${plan.estimatedCredits}`);
+  console.log(`Memory: ${plan.memory.enabled ? plan.memory.privacyMode : "disabled"}`);
+  console.log(`Playbooks: ${plan.operatingPlaybooks.map((item) => item.slug).join(", ") || "none"}`);
+  console.log(`Strategy memory: ${plan.strategyMemoryStatus ? plan.strategyMemoryStatus.ready === false ? "needs seeding" : "ready" : "not loaded"}`);
+  console.log(`Kernel plan: ${plan.kernelPlan ? "loaded" : "not loaded"}`);
+  console.log(`Approvals: ${plan.approvals.map((item) => item.type).join(", ") || "none"}`);
+  if (plan.warnings.length > 0) {
+    console.log(`Warnings: ${plan.warnings.join("; ")}`);
+  }
+  console.log("\nMCP flow:");
+  for (const step of plan.mcpFlow) {
+    console.log(`- ${step.id}: ${step.tool}${step.approvalRequired ? " (approval required)" : ""}`);
+  }
+}
+function printCampaignAgentExecution(payload, flags) {
+  if (booleanFlag(flags, "json")) {
+    printJson(payload);
+    return;
+  }
+  printCampaignAgentPlan(payload.plan);
+  console.log("\nResult:");
+  printJson(payload.result);
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function createCampaignAgentProofReceipt(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 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."
+    ]
+  };
+}
+function campaignAgentString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return null;
+}
+function campaignAgentStrategyTemplate(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 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 = 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: 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 = asRecord(proof.campaign);
+  if (campaign.plan_id) console.log(`Plan ID: ${campaign.plan_id}`);
+  if (campaign.strategy_template) console.log(`Strategy template: ${campaign.strategy_template}`);
+  if (campaign.target_count !== void 0) console.log(`Target: ${campaign.target_count}`);
+  console.log("\nGates:");
+  const gates = Array.isArray(proof.gates) ? proof.gates : [];
+  for (const gate of gates) {
+    const gateRecord = asRecord(gate);
+    console.log(`- ${gateRecord.id}: ${gateRecord.passed ? "passed" : "failed"}`);
+  }
+  console.log("\nSafety: dry-run only; no spendful launch, external write, sender load, or email send.");
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function printHelp() {
+  console.log(`
 Signaliz CLI v1.0.0
 
 Usage:
-  signaliz test    Verify API connectivity
-  signaliz tools   List all available MCP tools
+  signaliz test                       Verify API connectivity
+  signaliz tools                      List all available MCP tools
+  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
+  signaliz gtm start-context --strategy-template non-medical-home-care --json
+  signaliz gtm strategy-memory --strategy-template non-medical-home-care --include-samples --json
+  signaliz gtm agent-plan --goal "Build a strategy-template campaign" --strategy-template non-medical-home-care --target-count 500 --json
+  signaliz gtm provider-prepare --provider-id customer_mcp --layer company_enrichment --invocation-type mcp_tool --json
+  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 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
+  signaliz campaign-agent commit-plan --goal "Build a strategy-template campaign..." --json
+  signaliz campaign-agent dry-run --goal "Build a strategy-template campaign..." --target-count 500 --use-local-leads --json
+  signaliz campaign-agent build-approved --goal "Build a strategy-template campaign..." --confirm-launch --approve-all --approved-by you@example.com --spend-limit 500
 
 Environment:
-  SIGNALIZ_API_KEY  Your API key (required)
+  SIGNALIZ_API_KEY   Your API key (not required for campaign-agent init)
+  SIGNALIZ_BASE_URL  Optional API base URL override
+`);
+}
+function printGtmHelp() {
+  console.log(`
+Signaliz GTM commands:
+
+  signaliz gtm context [--include-campaigns] [--include-memory] [--include-brain] [--include-connections] [--limit N] [--json]
+  signaliz gtm bootstrap [--campaign-id ID] [--days N] [--include-connections] [--include-samples] [--json]
+  signaliz gtm templates [--query TEXT] [--strategy-template ID] [--summary] [--json]
+  signaliz gtm start-context [--brief TEXT] [--strategy-template ID] [--target-count N] [--layers a,b] [--providers a,b] [--json]
+  signaliz gtm strategy-memory [--query TEXT] [--strategy-template ID] [--include-samples] [--json]
+  signaliz gtm provider-prepare --provider-id ID [--layer NAME] [--invocation-type webhook|mcp_tool|api] [--json]
+  signaliz gtm activate-route --provider-id ID --layer NAME [--confirm] [--json]
+  signaliz gtm memory search --query TEXT [--layers a,b] [--provider-chain a,b] [--limit N] [--json]
+  signaliz gtm plan --brief TEXT [--strategy-template industrial-ot-resilience|non-medical-home-care|agency-founder-led|cloud-infrastructure-displacement] [--lead-count N] [--layers a,b] [--providers a,b] [--partners clay,instantly,nango] [--target-icp JSON] [--json]
+`);
+}
+function printCampaignAgentHelp() {
+  console.log(`
+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 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]
+  signaliz campaign-agent dry-run (--goal TEXT | --request-file FILE) [--gtm-campaign-id ID] [--delivery-risk JSON] [--idempotency-key KEY] [--json]
+  signaliz campaign-agent build-approved (--goal TEXT | --request-file FILE) --confirm-launch --approved-by EMAIL (--approve-all | --approved-types a,b) [--commit-before-launch] [--spend-limit N] [--approved-route-ids a,b] [--idempotency-key KEY] [--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.
 `);
-  }
 }
 main().catch((e) => {
   console.error(e);