@signaliz/cli 1.0.5 → 1.0.8

package/dist/bin.js

@@ -150,15 +150,28 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "attachment-fields",
   "attachment-file",
   "attachment-url",
+  "account-context",
+  "account-context-file",
+  "account-label",
+  "approved-by",
+  "approved-route-ids",
+  "approved-types",
+  "approval-notes",
+  "allowed-integrations",
   "blueprint",
   "brain-config-file",
   "brain-config-json",
+  "brain-defaults",
   "build-id",
   "cadence",
   "campaign-build-id",
   "campaign-id",
   "campaign-brief",
+  "campaign-name",
   "brief",
+  "builtins",
+  "builtin-tools",
+  "byo-tool",
   "company-domains",
   "company-domain",
   "company-name",
@@ -166,12 +179,15 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "context-json",
   "copy-file",
   "copy-json",
+  "custom-tool",
+  "customer-tool",
   "destination",
   "destinations",
   "days",
   "dedup-keys",
   "delivery-file",
   "delivery-json",
+  "delivery-risk",
   "delivery-risk-file",
   "delivery-risk-json",
   "domains",
@@ -184,6 +200,9 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "input-json",
   "instantly-campaign-id",
   "idempotency-key",
+  "icp",
+  "integration-display-name",
+  "integration-route",
   "judge-model",
   "layer",
   "layers",
@@ -193,6 +212,8 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "max-concurrency",
   "max-retries",
   "max-tokens",
+  "max-credits",
+  "max-credits-without-approval",
   "memory-limit",
   "memory-type",
   "model",
@@ -202,17 +223,21 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "nango-connection-id",
   "network-days",
   "output-format",
+  "output-file",
   "output-fields",
   "output-fields-file",
   "outcome-type",
   "pdf-engine",
   "pdf-url",
   "phases",
+  "privacy-mode",
   "policy-file",
   "policy-json",
+  "partners",
   "provider",
   "providers",
   "preferred-providers",
+  "provider-display-name",
   "provider-account-id",
   "provider-campaign-id",
   "provider-config-key",
@@ -222,8 +247,10 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "provider-workspace-id",
   "qualification-file",
   "qualification-json",
+  "request-file",
   "records-file",
   "records-json",
+  "revenue-motion",
   "readiness-json",
   "rationale",
   "route-config-json",
@@ -232,22 +259,36 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "search",
   "send-config-file",
   "send-config-json",
+  "signaliz-tools",
   "signals-file",
   "signals-json",
+  "spend-limit",
+  "spend-limit-credits",
   "status",
   "status-url",
+  "source",
+  "strategy-model",
+  "strategy-template",
   "system-prompt",
   "target-count",
+  "target-icp",
   "target-icp-file",
   "target-icp-json",
   "temperature",
   "tool-name",
   "url",
+  "user-display-name",
+  "user-email",
   "video-url",
   "write-mode",
   "workspace-connection-id",
   "workspace-integration-id",
+  "workspace-label",
   "workspace-mcp-server-id",
+  "workspace-context",
+  "workspace-context-file",
+  "icp-file",
+  "brain-defaults-file",
   "memory-dimension-filters-file",
   "memory-dimension-filters-json",
   "metadata-file",
@@ -272,6 +313,84 @@ function promptArg(rest) {
   }
   return parts.join(" ").trim() || void 0;
 }
+function parseCommandFlags(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 name = normalizeCommandFlagName(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 current = flags[name];
+    if (current === void 0) {
+      flags[name] = value;
+    } else if (Array.isArray(current)) {
+      current.push(String(value));
+    } else {
+      flags[name] = [String(current), String(value)];
+    }
+  }
+  return flags;
+}
+function normalizeCommandFlagName(name) {
+  return name.replace(/_/g, "-");
+}
+function commandFlagValue(flags, ...names) {
+  for (const name of names.map(normalizeCommandFlagName)) {
+    if (flags[name] !== void 0) return flags[name];
+  }
+  return void 0;
+}
+function commandStringFlag(flags, ...names) {
+  const value = commandFlagValue(flags, ...names);
+  if (Array.isArray(value)) return value.at(-1);
+  if (value === void 0 || typeof value === "boolean") return void 0;
+  const trimmed = String(value).trim();
+  return trimmed || void 0;
+}
+function commandNumberFlag(flags, ...names) {
+  const value = commandStringFlag(flags, ...names);
+  if (!value) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) die(`Expected numeric value for --${names[0]}`);
+  return parsed;
+}
+function commandBooleanFlag(flags, name, defaultValue = false) {
+  const value = commandFlagValue(flags, name);
+  if (value === void 0) return defaultValue;
+  if (Array.isArray(value)) return value.length > 0 ? parseCommandBoolean(value.at(-1), defaultValue) : defaultValue;
+  return parseCommandBoolean(value, defaultValue);
+}
+function parseCommandBoolean(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  return !["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function commandCsvFlag(flags, ...names) {
+  const value = commandFlagValue(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 repeatedCommandStringFlag(flags, ...names) {
+  const value = commandFlagValue(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 commandJsonObjectFlag(flags, ...names) {
+  const value = commandStringFlag(flags, ...names);
+  if (!value) return void 0;
+  return parseJsonObjectFromString(value, `--${names[0]}`);
+}
+function parseJsonObjectFromString(value, label) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    die(`${label} must be a JSON object`);
+  }
+  return parsed;
+}
 function output(data, humanFn) {
   if (jsonMode()) {
     console.log(JSON.stringify(data, null, 2));
@@ -706,7 +825,7 @@ function getSdk() {
   try {
     const { Signaliz } = require("@signaliz/sdk");
     const sdk = createSdk(Signaliz);
-    if (sdk.campaigns?.buildCampaign && sdk.ops?.listOutputSinks && sdk.leads?.generate && sdk.emails?.verify && sdk.ai?.multiModel && sdk.gtm?.campaignBuildPlan && sdk.gtm?.commitCampaignBuildPlan && sdk.gtm?.prepareCampaignBuildExecution && sdk.gtm?.listNangoTools && sdk.gtm?.callNangoTool && sdk.gtm?.getNangoActionResult && sdk.getPlatformHealth) return sdk;
+    if (sdk.campaigns?.buildCampaign && sdk.ops?.listOutputSinks && sdk.leads?.generate && sdk.emails?.verify && sdk.ai?.multiModel && sdk.gtm?.campaignBuildPlan && sdk.gtm?.campaignStrategyTemplates && sdk.gtm?.campaignStartContext && sdk.gtm?.campaignAgentPlan && sdk.gtm?.commitCampaignBuildPlan && sdk.gtm?.prepareCampaignBuildExecution && sdk.gtm?.prepareProviderRecipe && sdk.gtm?.activateProviderRoute && sdk.gtm?.createNangoConnectSession && sdk.gtm?.listNangoTools && sdk.gtm?.callNangoTool && sdk.gtm?.getNangoActionResult && sdk.campaignBuilderAgent?.createPlan && sdk.campaignBuilderAgent?.commitPlan && sdk.campaignBuilderAgent?.dryRunPlan && sdk.campaignBuilderAgent?.buildApprovedPlan && sdk.getPlatformHealth) return sdk;
     primaryError = new Error("SDK missing required GTM workflow APIs");
   } catch (err) {
     primaryError = err;
@@ -732,19 +851,23 @@ var HELP = `signaliz <command> [options]
 
 Quick Start:
   signaliz auth login
+
+No-spend agent path:
   signaliz start
   signaliz build "Build a campaign for industrial maintenance buyers"
   signaliz connect
   signaliz audit
   signaliz improve <campaign_id>
-  signaliz prove
+  signaliz prove   # alias: signaliz proof
   signaliz health
   signaliz tools
+
+Spendful path after review:
   signaliz ops plan "Monitor key accounts daily and alert Slack"
   signaliz ops create "Build 100 verified VP Sales leads" --confirm-spend
   signaliz autopilot
-  signaliz execute "Launch a CMM-style campaign for my ICP" --dry-run
-  signaliz campaign build --prompt "VP Sales at B2B SaaS" --target-count 100
+  signaliz execute "Launch a strategy-template campaign for my ICP" --dry-run
+  signaliz campaign build --prompt "VP Sales at B2B SaaS" --target-count 100 --dry-run
   signaliz campaign build --prompt "VP Sales at B2B SaaS" --confirm-spend
   signaliz campaign status <campaign_build_id>
   signaliz campaign rows <campaign_build_id> --limit 100
@@ -760,13 +883,14 @@ Auth:
   start                   Recommend where to begin across Build, Connect, Audit, Improve, and Ops proof
     --campaign-brief "..." Optional brief for the suggested campaign-plan command
     --json                Machine-readable onboarding state
+    --include-raw         Include full raw MCP diagnostics in JSON output
 
 Simple Jobs:
   build "brief"           Plan a campaign without spending credits
   connect                 Inspect blocked provider/tool routes
   audit                   Find previous campaigns to audit
   improve <campaign_id>   Plan Brain learning for a campaign
-  prove                   Prove Ops delivery readiness
+  prove/proof             Prove Ops delivery readiness
 
 Discovery:
   tools                   List available MCP tools
@@ -825,6 +949,26 @@ GTM Kernel:
     --campaign-id ID      Optional campaign scope
     --days N              Lookback window, default server-side
     --include-samples     Include diagnostic samples when supported
+  gtm templates           List private-safe campaign strategy templates
+    --query TEXT          Optional text filter
+    --strategy-template ID
+                          Inspect one template
+  gtm start-context       Build read-only campaign-start MCP runbook
+    --strategy-template ID
+                          Merge a private-safe strategy template
+    --target-count N      Desired lead count
+  gtm strategy-memory     Inspect strategy/workflow memory readiness
+    --strategy-template ID
+                          Verify a private-safe strategy template
+    --include-samples     Include sanitized memory sample metadata
+  gtm agent-template      Build hosted reusable campaign request JSON
+    --strategy-template ID
+                          Merge a private-safe strategy template
+    --with-byo-placeholder
+                          Add an editable custom MCP route placeholder
+  gtm agent-plan          Build one-call campaign-agent MCP runbook
+    --builtins a,b        Native lanes: lead_generation, local_leads, email_finding, email_verification, signals
+    --custom-tool ROUTE   BYO route: provider:layer:tool[:mcp]
   gtm plan "brief"        Compose a read-only GTM Kernel campaign build plan
     --layers a,b          Optional GTM layers to plan
     --target-count N      Desired lead count
@@ -872,6 +1016,10 @@ GTM Kernel:
   gtm route-preview       Preview the effective provider route for a layer
     --campaign-id ID      Optional campaign scope
     --layer LAYER         Required campaign layer
+  gtm provider-prepare    Build read-only BYO provider setup plan
+    --provider-id ID      Required provider ID
+    --layer LAYER         Optional route preview layer
+    --invocation-type T   webhook|mcp_tool|api|airbyte|managed_integration|manual
   gtm activate-route      Dry-run or confirm provider route setup
     --provider-id ID      Required provider ID
     --layer LAYER         Single layer, or use --layers a,b
@@ -887,6 +1035,9 @@ Native GTM Data Sources:
   gtm find "<intent>"     Auto-route a free-text intent to the right capability
   gtm run --capability ID Run a GTM capability (use --query, --urls, --confirm-spend)
   gtm status <job_id>     Check GTM job status
+  gtm nango connect       Start Nango Connect auth for a provider
+    --provider-id ID      Provider to authorize, e.g. apollo, hubspot
+    --integration-id ID   Optional Nango integration/provider-config key
   gtm nango tools         List Nango action tools for a workspace connection
     --workspace-connection-id ID
                           Signaliz workspace connection id
@@ -911,10 +1062,26 @@ Email:
   email status <job_id>   Check async email job status
 
 Campaign Builder:
-  campaign scope          Scope a client campaign into a markdown brief + dry-run args
+  campaign-agent init     Emit reusable CampaignBuilderAgentRequest JSON
+    --output-file FILE    Optional request file to write
+  campaign-agent plan     Compose an approval-gated strategy-template MCP flow
+    --goal "..."          Campaign goal or brief
+    --request-file FILE   Reusable JSON CampaignBuilderAgentRequest
+    --strategy-template ID
+                          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 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 scope          Scope a workspace/account campaign into a markdown brief + dry-run args
     --prompt "..."        Campaign request or outcome (required)
-    --client-name NAME    Client/customer name
-    --client-context-file FILE
+    --account-label NAME  Workspace/account label
+    --account-context-file FILE
                           Markdown/notes with ICP, exclusions, offer, proof, approvals
     --target-count N      Desired target count
     --destinations csv,instantly,slack
@@ -928,6 +1095,7 @@ Campaign Builder:
     --dry-run             Validate and plan without launching spendful work
     --allow-downscale     Allow oversized target counts to be clamped
     --confirm-spend       Acknowledge spendful generation after approval prompts
+    --no-progress         Hide wait-mode progress on stderr
     --webhook-url URL     Webhook delivery endpoint
     --input-file FILE     JSON config file (overrides flags)
     --wait                Poll until completion
@@ -1068,17 +1236,41 @@ New-user path:
   signaliz auth login
   signaliz gtm context
   signaliz gtm bootstrap --include-samples
+  signaliz gtm 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-template --strategy-template non-medical-home-care --target-count 250 --with-byo-placeholder --json
+  signaliz gtm agent-plan --strategy-template non-medical-home-care --target-count 100 --json
   signaliz gtm plan "Find CTOs at Series B fintech companies" --target-count 100 --json > plan.json
   signaliz gtm commit-plan --plan-file plan.json
   signaliz gtm commit-plan --plan-file plan.json --confirm
   signaliz gtm integrations --include-planned
+  signaliz gtm provider-prepare --provider-id customer_mcp --layer company_enrichment --invocation-type mcp_tool
   signaliz gtm activate-route --provider-id instantly --layer sender
   signaliz gtm prepare-build <campaign_id> --build-input --json > build-args.json
   signaliz campaign build --input-file build-args.json --confirm-spend
+  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 for my ICP" --strategy-template non-medical-home-care --json
+  signaliz campaign-agent dry-run --goal "Build a strategy-template campaign for my ICP" --target-count 100 --json
 
 Read-only planning:
   context                 Inspect GTM Kernel workspace context
   bootstrap               Inspect Kernel + Brain readiness gates
+  templates               List private-safe campaign strategy templates
+  start-context           Build read-only Memory, Brain, risk, and route runbook
+  strategy-memory         Inspect strategy/workflow memory readiness
+  agent-template          Build hosted reusable campaign request JSON
+    --goal TEXT           Campaign goal or brief
+    --strategy-template ID
+                          Strategy template to merge
+    --with-byo-placeholder
+                          Add an editable custom MCP route placeholder
+  agent-plan              Build one-call campaign-agent MCP runbook
+    --goal TEXT           Campaign goal or brief
+    --strategy-template ID
+                          Strategy template to merge
+    --builtins a,b        Native lanes to include
+    --custom-tool ROUTE   BYO route: provider:layer:tool[:mcp]
   plan "brief"            Compose Memory, Brain, failure, and provider-route plan
     --campaign-id ID      Optional existing campaign scope
     --campaign-build-id ID
@@ -1113,6 +1305,7 @@ Status and repair:
   execution <id>          Inspect execution/provider readiness
   integrations            Inspect provider activation cards
   route-preview           Preview effective route for a layer
+  provider-prepare        Build read-only recipe, route, and preview arguments
   activate-route          Dry-run or confirm provider route setup
   feedback-webhook        Prepare feedback ingress
   learning <id>           Plan Brain learning
@@ -1153,6 +1346,132 @@ Options:
   --include-samples       Include safe sample rows/evidence where available
   --min-sample-size N     Minimum sample size for Brain/readiness checks
   --json                  Machine-readable output
+`,
+  templates: `signaliz gtm templates [options]
+
+List private-safe campaign strategy templates that can be merged into
+gtm_campaign_build_plan with --strategy-template.
+
+Options:
+  --query TEXT            Filter by ICP, motion, provider, or keyword
+  --strategy-template ID  Inspect one template
+  --summary               Return compact summaries instead of full ICP details
+  --json                  Machine-readable output
+`,
+  "strategy-templates": `signaliz gtm strategy-templates [options]
+
+Alias for signaliz gtm templates.
+`,
+  "start-context": `signaliz gtm start-context [options]
+
+Build a read-only MCP runbook for the campaign start: ranked memory, Brain
+defaults, delivery risk, failure patterns, provider-route previews, and final
+gtm_campaign_build_plan arguments.
+
+Options:
+  --brief TEXT            Campaign request or goal
+  --campaign-id ID        Optional existing campaign scope
+  --campaign-build-id ID  Optional Campaign Builder build scope
+  --strategy-template ID  Strategy template to merge
+  --target-count N        Desired lead count
+  --layers a,b            GTM layers to include
+  --preferred-providers a,b
+                          Provider preferences for route planning
+  --target-icp-json JSON  Structured ICP object
+  --target-icp-file FILE  Structured ICP JSON file
+  --no-memory             Skip workspace memory call
+  --no-brain              Skip Brain defaults call
+  --no-provider-routes    Skip provider-route calls
+  --no-failure-patterns   Skip Brain failure-pattern call
+  --no-delivery-risk      Skip delivery-risk call
+  --json                  Machine-readable output
+`,
+  start: `signaliz gtm start [options]
+
+Alias for signaliz gtm start-context.
+`,
+  "strategy-memory": `signaliz gtm strategy-memory [options]
+
+Inspect private-safe strategy/workflow memory readiness before campaign planning.
+
+Options:
+  --query TEXT            Campaign goal or memory query
+  --strategy-template ID  Strategy template to verify
+  --target-icp-json JSON  Structured ICP object
+  --target-icp-file FILE  Structured ICP JSON file
+  --memory-dimension-filters-json JSON
+                          Structured memory filters
+  --include-samples       Include sanitized memory sample metadata
+  --no-sources            Omit source-group details
+  --json                  Machine-readable output
+`,
+  "memory-status": `signaliz gtm memory-status [options]
+
+Alias for signaliz gtm strategy-memory.
+`,
+  "strategy-memory-status": `signaliz gtm strategy-memory-status [options]
+
+Alias for signaliz gtm strategy-memory.
+`,
+  "agent-template": `signaliz gtm agent-template [options]
+
+Build hosted reusable CampaignBuilderAgentRequest JSON from a strategy template,
+Signaliz-native lanes, private memory settings, Nango catalog preference, and an
+optional editable BYO integration placeholder.
+
+Options:
+  --goal TEXT             Campaign goal or brief
+  --campaign-name NAME    Optional private-safe campaign label
+  --workspace-label NAME  Optional private-safe workspace/account label
+  --account-context TEXT  Optional private-safe ICP, offer, or approval context
+  --strategy-template ID  Strategy template to merge
+  --operating-playbooks a,b
+                          Optional playbook slugs to apply with the template
+  --target-count N        Desired lead/account count
+  --target-icp-json JSON  Structured ICP object
+  --target-icp-file FILE  Structured ICP JSON file
+  --builtins a,b          lead_generation,local_leads,email_finding,email_verification,signals
+  --use-local-leads       Add the local_leads native lane
+  --with-byo-placeholder  Add an editable custom MCP route placeholder
+  --preferred-providers a,b
+                          Provider preferences or BYO provider ids
+  --privacy-mode MODE     workspace_only, anonymized_patterns, opt_in_network
+  --destination TYPE      json, csv, webhook
+  --json                  Machine-readable output
+`,
+  "campaign-agent-template": `signaliz gtm campaign-agent-template [options]
+
+Alias for signaliz gtm agent-template.
+`,
+  "request-template": `signaliz gtm request-template [options]
+
+Alias for signaliz gtm agent-template.
+`,
+  "agent-plan": `signaliz gtm agent-plan [options]
+
+Build a one-call, read-only campaign-agent MCP runbook from a strategy template,
+Signaliz-native lanes, Memory, Brain, Nango discovery, and BYO integration routes.
+
+Options:
+  --goal TEXT             Campaign goal or brief
+  --campaign-name NAME    Optional private-safe campaign label
+  --campaign-id ID        Optional existing campaign scope
+  --campaign-build-id ID  Optional Campaign Builder build scope
+  --strategy-template ID  Strategy template to merge
+  --target-count N        Desired lead/account count
+  --target-icp-json JSON  Structured ICP object
+  --target-icp-file FILE  Structured ICP JSON file
+  --builtins a,b          lead_generation,local_leads,email_finding,email_verification,signals
+  --use-local-leads       Add the local_leads native lane
+  --custom-tool ROUTE     BYO route: provider:layer:tool[:mcp] or key=value pairs
+  --preferred-providers a,b
+                          Provider preferences or BYO provider ids
+  --no-delivery-risk      Skip delivery-risk preflight
+  --json                  Machine-readable output
+`,
+  "campaign-agent-plan": `signaliz gtm campaign-agent-plan [options]
+
+Alias for signaliz gtm agent-plan.
 `,
   plan: `signaliz gtm plan "campaign brief" [options]
 
@@ -1162,10 +1481,16 @@ defaults, failure intelligence, provider routes, and approval boundaries.
 Options:
   --campaign-id ID        Optional existing campaign scope
   --campaign-build-id ID  Optional Campaign Builder build scope
+  --strategy-template ID  Strategy template: industrial-ot-resilience, non-medical-home-care, agency-founder-led, cloud-infrastructure-displacement
   --target-count N        Desired lead count
   --layers a,b            GTM layers to include
   --preferred-providers a,b
                           Provider preferences for route planning
+  --strategy-model custom Optional custom strategy model override
+  --partners a,b          Partner/tool ecosystem hints
+  --no-agency-patterns    Disable default private strategy pattern hints
+  --no-workflow-patterns  Disable default workflow table pattern hints
+  --no-nango-catalog      Skip Nango tool catalog discovery
   --target-icp-json JSON  Structured ICP object
   --target-icp-file FILE  Structured ICP JSON file
   --include-planned       Include planned/needs-setup providers
@@ -1176,7 +1501,7 @@ Options:
   --json                  Machine-readable output
 
 Safe next step:
-  signaliz gtm plan "Find CTOs at fintech startups" --target-count 100 --json > plan.json
+  signaliz gtm plan "Find CTOs at fintech startups" --strategy-template cloud-infrastructure-displacement --target-count 100 --json > plan.json
   signaliz gtm commit-plan --plan-file plan.json
 `,
   "build-plan": `signaliz gtm build-plan "campaign brief" [options]
@@ -1322,6 +1647,34 @@ Options:
   "preview-route": `signaliz gtm preview-route --layer <layer> [options]
 
 Alias for signaliz gtm route-preview.
+`,
+  "provider-prepare": `signaliz gtm provider-prepare --provider-id <provider_id> [options]
+
+Build a read-only BYO provider setup plan. Returns exact recipe, route,
+preview, and activation arguments without writing state or calling providers.
+
+Options:
+  --provider-id ID        Provider id, for example customer_mcp
+  --provider-name NAME    Display name for the provider
+  --layer NAME            Layer to preview route setup for
+  --layers a,b            Recipe layer capabilities
+  --invocation-type TYPE  webhook|mcp_tool|api|airbyte|managed_integration|manual
+  --auth-strategy TYPE    none|integration_key|mcp_auth|webhook_secret|session_vault|byo_runtime
+  --endpoint-url URL      Webhook or API endpoint
+  --workspace-mcp-server-id ID
+                          Existing workspace MCP server reference
+  --workspace-connection-id ID
+                          Existing workspace connection reference
+  --no-signaliz-fallback  Disable Signaliz fallback for route preview
+  --json                  Machine-readable output
+`,
+  "prepare-provider": `signaliz gtm prepare-provider --provider-id <provider_id> [options]
+
+Alias for signaliz gtm provider-prepare.
+`,
+  "recipe-prepare": `signaliz gtm recipe-prepare --provider-id <provider_id> [options]
+
+Alias for signaliz gtm provider-prepare.
 `,
   "activate-route": `signaliz gtm activate-route --provider-id <provider_id> --layer <layer> [options]
 
@@ -1497,14 +1850,14 @@ Run: signaliz ops help <command>
   return OPS_COMMAND_HELP[sub] || opsHelpFor(void 0);
 }
 var CAMPAIGN_COMMAND_HELP = {
-  scope: `signaliz campaign scope --prompt "client campaign request" [options]
+  scope: `signaliz campaign scope --prompt "campaign request" [options]
 
-Turn a client/campaign brief into a markdown scope, Brain preflight, and
+Turn a campaign brief into a markdown scope, Brain preflight, and
 ready-to-run build_campaign dry-run arguments.
 
 Options:
-  --client-name NAME      Client/customer name
-  --client-context-file FILE
+  --account-label NAME    Workspace/account label
+  --account-context-file FILE
                           Markdown notes with ICP, exclusions, offer, proof, approvals
   --target-count N        Desired target count
   --destinations a,b      json,csv,webhook,instantly,slack,airbyte,nango
@@ -1747,6 +2100,16 @@ async function start() {
   const bootstrap = bootstrapState.ok ? record(bootstrapState.data) : {};
   const integrations = integrationsState.ok ? record(integrationsState.data) : {};
   const integrationSummary = record(integrations.summary);
+  const integrationLayers = firstArray(
+    integrations.layers || integrations.route_cards || integrations.items || integrations.routes
+  );
+  const providerBlockers = integrationLayers.filter((layer) => layer.ready === false || layer.status === "needs_route" || layer.status === "blocked").map((layer) => ({
+    layer: layer.layer,
+    label: layer.label || layer.layer,
+    status: layer.status || (layer.ready === false ? "blocked" : "unknown"),
+    blockers: firstArray(record(layer.readiness).blockers || layer.blockers),
+    next_tools: firstArray(layer.next_tools || layer.nextTools)
+  }));
   const gates = firstArray(bootstrap.gates);
   const readyGates = gates.filter((gate) => gate.ready === true || gate.status === "ready").length;
   const blockedLayers = Number(integrationSummary.blocked_layers || 0);
@@ -1792,7 +2155,8 @@ async function start() {
       kernel_gates_total: gates.length,
       provider_layers_ready: readyLayers,
       provider_layers_total: totalLayers,
-      provider_layers_blocked: blockedLayers
+      provider_layers_blocked: blockedLayers,
+      provider_blockers: providerBlockers
     },
     next_move: {
       title: nextMove,
@@ -1800,13 +2164,15 @@ async function start() {
       command: nextCommand
     },
     safe_commands: commands,
-    raw_status: {
-      workspace: workspaceState,
-      platform: platformState,
-      ops_proof: proofState,
-      gtm_bootstrap: bootstrapState,
-      gtm_integrations: integrationsState
-    }
+    ...hasFlag("include-raw") || hasFlag("verbose") ? {
+      raw_status: {
+        workspace: workspaceState,
+        platform: platformState,
+        ops_proof: proofState,
+        gtm_bootstrap: bootstrapState,
+        gtm_integrations: integrationsState
+      }
+    } : {}
   };
   return output(result, () => {
     console.log("Signaliz start");
@@ -2098,17 +2464,24 @@ async function campaignBuild() {
   if (hasFlag("wait")) {
     if (!result.campaignBuildId) die("Campaign build did not return a campaign_build_id to poll");
     info("\nPolling for completion...");
+    let lastProgressLine = "";
     const finalStatus = await sdk.campaigns.waitForCompletion(result.campaignBuildId, {
       intervalMs: 5e3,
       onStatus: (s) => {
-        if (!jsonMode()) {
-          process.stderr.write(
-            `\r  [${s.status}] phase=${s.currentPhase ?? "N/A"} rows=${s.recordsSucceeded}/${s.recordsTotal} artifacts=${s.artifactCount}   `
-          );
+        if (hasFlag("no-progress")) return;
+        const line = `[${s.status}] phase=${s.currentPhase ?? "N/A"} rows=${s.recordsSucceeded}/${s.recordsTotal} artifacts=${s.artifactCount}`;
+        if (jsonMode()) {
+          if (line !== lastProgressLine) {
+            process.stderr.write(`signaliz campaign build: ${line}
+`);
+            lastProgressLine = line;
+          }
+          return;
         }
+        process.stderr.write(`\r  ${line}   `);
       }
     });
-    if (!jsonMode()) process.stderr.write("\n");
+    if (!jsonMode() && !hasFlag("no-progress")) process.stderr.write("\n");
     output(jsonMode() ? { initial: result, final: finalStatus } : finalStatus, () => {
       console.log(`
 \u2713 Build ${finalStatus.status}`);
@@ -2124,15 +2497,15 @@ async function campaignScope() {
   const sdk = getSdk();
   const promptText = flagArg("prompt") || positionalAfter("scope");
   if (!promptText) {
-    die('--prompt is required. Example: signaliz campaign scope --prompt "Build a Vali-style home care campaign"');
+    die('--prompt is required. Example: signaliz campaign scope --prompt "Build a home-care strategy home care campaign"');
   }
-  const contextFile = flagArg("client-context-file");
+  const contextFile = flagArg("account-context-file") || flagArg("workspace-context-file");
   const targetCount = numberFlag("target-count");
   const destinations = csvFlag("destinations")?.map((type) => ({ type }));
   const result = await sdk.campaigns.scopeCampaign({
     prompt: promptText,
-    clientName: flagArg("client-name"),
-    clientContext: contextFile ? (0, import_node_fs.readFileSync)(contextFile, "utf8") : flagArg("client-context"),
+    accountLabel: flagArg("account-label") || flagArg("workspace-label"),
+    accountContext: contextFile ? (0, import_node_fs.readFileSync)(contextFile, "utf8") : flagArg("account-context") || flagArg("workspace-context"),
     campaignGoal: flagArg("campaign-goal"),
     targetCount,
     destinations,
@@ -2169,6 +2542,11 @@ async function campaignStatus() {
     console.log(`Phase:    ${status.currentPhase || "N/A"}`);
     console.log(`Rows:     ${status.recordsSucceeded}/${status.recordsTotal} succeeded, ${status.recordsFailed} failed`);
     console.log(`Artifacts: ${status.artifactCount}`);
+    if (status.triggerRunId) console.log(`Trigger:  ${status.triggerRunId}`);
+    if (status.staleRunningPhase) {
+      const age = typeof status.phaseAgeSeconds === "number" ? `${status.phaseAgeSeconds}s` : "unknown age";
+      console.log(`Stale:    acquisition has reported no row progress for ${age}`);
+    }
     if (status.warnings.length) {
       console.log(`Warnings: ${status.warnings.length}`);
       for (const warning of status.warnings.slice(0, 3)) console.log(`  - ${warning}`);
@@ -2179,6 +2557,8 @@ async function campaignStatus() {
     }
     if (status.status === "completed") {
       hint(`signaliz campaign rows ${buildId} --limit 100`);
+    } else if (status.staleRunningPhase && status.triggerRunId) {
+      hint(`signaliz ops run-status ${status.triggerRunId} --watch`);
     } else if (status.status === "running" || status.status === "queued") {
       hint(`signaliz campaign status ${buildId} (poll again in ~10s)`);
     } else if (status.status === "pending_approval") {
@@ -2209,7 +2589,7 @@ async function campaignRows() {
       if (hasFlag("qualified")) opts.qualified = true;
       if (hasFlag("disqualified")) opts.qualified = false;
       const result = await sdk.campaigns.getCampaignBuildRows(buildId, opts);
-      allRows.push(...result.rows);
+      allRows.push(...formatCampaignRowsForOperator(result.rows));
       nextCursor = result.nextCursor;
       page++;
       info(`  Fetched page ${page}: ${result.rows.length} rows (total: ${allRows.length})`);
@@ -2233,26 +2613,73 @@ async function campaignRows() {
     if (hasFlag("qualified")) opts.qualified = true;
     if (hasFlag("disqualified")) opts.qualified = false;
     const result = await sdk.campaigns.getCampaignBuildRows(buildId, opts);
-    output(result, () => {
-      if (result.rows.length === 0) {
+    const operatorResult = {
+      ...result,
+      rows: formatCampaignRowsForOperator(result.rows)
+    };
+    output(operatorResult, () => {
+      if (operatorResult.rows.length === 0) {
         console.log("No rows found.");
         return;
       }
-      console.table(result.rows.map((r) => ({
-        email: r.data?.email || "",
-        name: r.data?.full_name || `${r.data?.first_name || ""} ${r.data?.last_name || ""}`.trim(),
-        company: r.data?.company_name || r.data?.company_domain || "",
+      console.table(operatorResult.rows.map((r) => ({
+        email: r.email || "",
+        name: r.name || "",
+        title: r.title || "",
+        company: r.company || r.domain || "",
         segment: r.segment || "",
-        status: r.status || ""
+        status: r.status || "",
+        score: r.score ?? ""
       })));
       console.log(`
-Showing ${result.rows.length} row(s)${result.hasMore ? " (more available)" : ""}`);
-      if (result.nextCursor) {
-        hint(`signaliz campaign rows ${buildId} --limit ${limit} --cursor ${result.nextCursor}`);
+Showing ${operatorResult.rows.length} row(s)${operatorResult.hasMore ? " (more available)" : ""}`);
+      if (operatorResult.nextCursor) {
+        hint(`signaliz campaign rows ${buildId} --limit ${limit} --cursor ${operatorResult.nextCursor}`);
       }
     });
   }
 }
+function formatCampaignRowsForOperator(rows) {
+  return rows.map((row) => {
+    const rowRecord = record(row);
+    const data = record(rowRecord.data);
+    const rawCopy = record(data.raw_copy);
+    const copy = {
+      subject: data.subject || rawCopy.subject || null,
+      opener: data.opener || rawCopy.opener || null,
+      body: data.body || rawCopy.body || null,
+      cta: data.cta || rawCopy.cta || null,
+      engine: data.copy_engine || rawCopy.engine || null,
+      model: data.copy_model || null
+    };
+    return {
+      ...rowRecord,
+      email: data.email || null,
+      name: data.full_name || `${data.first_name || ""} ${data.last_name || ""}`.trim() || null,
+      title: data.title || null,
+      company: data.company_name || null,
+      domain: data.company_domain || null,
+      industry: data.industry || null,
+      linkedin_url: data.linkedin_url || null,
+      score: data.overall_score ?? null,
+      company_fit_score: data.company_fit_score ?? null,
+      contact_fit_score: data.contact_fit_score ?? null,
+      signal_relevance_score: data.signal_relevance_score ?? null,
+      reason_codes: firstArray(data.reason_codes),
+      disqualifiers: firstArray(data.disqualifiers),
+      signal: data.signal_title ? {
+        type: data.signal_type || null,
+        title: data.signal_title,
+        summary: data.signal_summary || null,
+        date: data.signal_date || null,
+        confidence: data.signal_confidence ?? null,
+        source_url: data.signal_source_url || null
+      } : null,
+      copy,
+      has_copy: Boolean(copy.subject || copy.opener || copy.body || copy.cta)
+    };
+  });
+}
 async function campaignArtifacts() {
   const buildId = positionalAfter("artifacts") || flagArg("campaign-build-id");
   if (!buildId) die("Usage: signaliz campaign artifacts <campaign_build_id>");
@@ -2335,6 +2762,617 @@ async function campaign(sub) {
 Available: scope, build, status, rows, artifacts, approve, cancel`);
   }
 }
+var CAMPAIGN_AGENT_APPROVAL_TYPES = [
+  "memory_retrieval",
+  "spend",
+  "customer_tool",
+  "external_write",
+  "delivery",
+  "launch"
+];
+var CAMPAIGN_AGENT_TEMPLATE_PLAYBOOKS = {
+  "industrial-ot-resilience": ["net-new-suppressed-list", "proof-first-vertical-gate", "signal-led-copy-approval"],
+  "non-medical-home-care": ["proof-first-vertical-gate", "domain-first-recovery", "table-workflow-handoff"],
+  "agency-founder-led": ["net-new-suppressed-list", "signal-led-copy-approval", "table-workflow-handoff"],
+  "cloud-infrastructure-displacement": ["proof-first-vertical-gate", "domain-first-recovery", "signal-led-copy-approval"]
+};
+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
+  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
+
+Examples:
+  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 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
+
+Plan options:
+  --goal TEXT             Campaign goal or brief
+  --output-file FILE      Write init output to a reusable request JSON file
+  --request-file FILE     Reusable JSON CampaignBuilderAgentRequest; flags override file fields
+  --campaign-name NAME    Optional campaign label
+  --workspace-label NAME  Optional workspace/account label
+  --account-context TEXT  Optional ICP, offer, exclusion, or approval context
+  --strategy-template ID  Strategy template to merge
+  --target-count N        Desired lead/account count
+  --icp JSON             Structured ICP object
+  --builtins a,b          lead_generation,local_leads,email_finding,email_verification,signals
+  --use-local-leads       Add the local_leads built-in lane
+  --custom-tool ROUTE     BYO route: provider:layer:tool[:mcp] or key=value pairs
+  --with-byo-placeholder  Add an editable custom MCP route placeholder during init
+  --preferred-providers a,b
+                          Provider preferences or BYO provider ids
+  --no-strategy-patterns  Disable default private strategy memory hints
+  --no-workflow-patterns  Disable default workflow memory hints
+  --no-strategy-memory    Skip live strategy-memory readiness proof
+  --no-kernel-plan        Skip live gtm_campaign_build_plan evidence
+  --no-delivery-risk      Skip live delivery-risk evidence
+
+Approval options:
+  --confirm-write         Required to write commit-plan
+  --confirm-launch        Required for build-approved
+  --approved-by EMAIL     Required approval identity for writes/launches
+  --approve-all           Approve every required approval type in the plan
+  --approved-types a,b    Approve selected types
+  --spend-limit N         Maximum approved credits
+  --commit-before-launch  Commit the reviewed plan before launch
+  --idempotency-key KEY   Idempotency key for write/launch calls
+  --json                  Machine-readable output
+`;
+async function campaignAgent(sub, rest) {
+  if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+    process.stdout.write(CAMPAIGN_AGENT_HELP);
+    return;
+  }
+  if (isHelpRequest(rest)) {
+    process.stdout.write(CAMPAIGN_AGENT_HELP);
+    return;
+  }
+  if (!["init", "template", "request-template", "new", "plan", "proof", "smoke", "commit-plan", "dry-run", "build-approved", "launch-approved"].includes(sub)) {
+    process.stdout.write(CAMPAIGN_AGENT_HELP);
+    return;
+  }
+  const flags = parseCommandFlags(rest);
+  if (["init", "template", "request-template", "new"].includes(sub)) {
+    const request2 = campaignAgentRequestTemplateFromFlags(flags, rest);
+    const outputFile = commandStringFlag(flags, "output-file", "out");
+    if (outputFile) {
+      (0, import_node_fs.writeFileSync)(outputFile, `${JSON.stringify(request2, null, 2)}
+`, "utf8");
+    }
+    if (jsonMode() || !outputFile) return output(request2);
+    console.log(`Campaign request template written: ${outputFile}`);
+    console.log(`Next: signaliz campaign-agent plan --request-file ${outputFile} --json`);
+    return;
+  }
+  const requestFromFile = campaignAgentRequestFileFromFlags(flags);
+  const goal = commandStringFlag(flags, "goal", "brief") || promptArg(rest) || campaignAgentStringValue(requestFromFile?.goal);
+  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";
+  const isConfirmedCommit = isCommitPlan && commandBooleanFlag(flags, "confirm-write");
+  const approvedBy = commandStringFlag(flags, "approved-by");
+  if (isApprovedBuild) {
+    if (!commandBooleanFlag(flags, "confirm-launch")) die(`campaign-agent ${sub} requires --confirm-launch`);
+    if (!approvedBy) die(`campaign-agent ${sub} requires --approved-by`);
+  }
+  if (isConfirmedCommit && !approvedBy) {
+    die("campaign-agent commit-plan --confirm-write requires --approved-by");
+  }
+  const sdk = getSdk();
+  const agent = sdk.campaignBuilderAgent;
+  const request = mergeCampaignAgentRequests(
+    requestFromFile,
+    campaignAgentRequestFromFlags(goal, flags, { includeDefaults: !requestFromFile })
+  );
+  const plan = await agent.createPlan(request, {
+    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 (sub === "proof" || sub === "smoke") {
+    const result = await agent.dryRunPlan(plan, {
+      idempotencyKey: commandStringFlag(flags, "idempotency-key")
+    });
+    const proof = createCampaignAgentProofReceipt(plan, result);
+    if (!proof.success) process.exitCode = 1;
+    return output(proof, () => printCampaignAgentProof(proof));
+  }
+  if (isCommitPlan) {
+    const result = await agent.commitPlan(plan, {
+      confirm: isConfirmedCommit,
+      dryRun: !isConfirmedCommit,
+      approvedBy,
+      idempotencyKey: commandStringFlag(flags, "idempotency-key"),
+      rationale: commandStringFlag(flags, "rationale")
+    });
+    return output({ plan, result }, () => printCampaignAgentExecution(plan, result));
+  }
+  if (sub === "dry-run") {
+    const result = await agent.dryRunPlan(plan, {
+      idempotencyKey: commandStringFlag(flags, "idempotency-key")
+    });
+    return output({ plan, result }, () => printCampaignAgentExecution(plan, result));
+  }
+  if (isApprovedBuild) {
+    const approval = createCampaignAgentApproval(plan, {
+      approvedBy,
+      approvedTypes: campaignAgentApprovedTypesFromFlags(plan, flags),
+      spendLimitCredits: commandNumberFlag(flags, "spend-limit", "spend-limit-credits", "max-credits"),
+      approvedRouteIds: campaignAgentApprovedRouteIdsFromFlags(plan, flags),
+      notes: commandStringFlag(flags, "approval-notes", "notes")
+    });
+    const result = await agent.buildApprovedPlan(plan, approval, {
+      idempotencyKey: commandStringFlag(flags, "idempotency-key"),
+      commitBeforeLaunch: commandBooleanFlag(flags, "commit-before-launch")
+    });
+    return output({ plan, approval, result }, () => printCampaignAgentExecution(plan, result));
+  }
+  return output(plan, () => printCampaignAgentPlan(plan));
+}
+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 });
+  request.strategyTemplate = request.strategyTemplate || "non-medical-home-care";
+  if (!Array.isArray(request.operatingPlaybooks)) {
+    request.operatingPlaybooks = CAMPAIGN_AGENT_TEMPLATE_PLAYBOOKS[String(request.strategyTemplate)] || [];
+  }
+  request.campaignName = request.campaignName || "Strategy Template Campaign";
+  request.accountLabel = request.accountLabel || "Workspace Campaign";
+  request.accountContext = request.accountContext || "Use private workspace memory, current suppression rules, verified-email quality gates, and approval-gated provider routes.";
+  request.targetCount = request.targetCount || 250;
+  request.icp = request.icp || {
+    personas: ["Operations leader", "Founder", "Revenue leader"],
+    industries: ["B2B services", "Vertical software", "Local operators"],
+    geographies: ["United States"],
+    keywords: ["growth", "operations", "customer acquisition"],
+    requireVerifiedEmail: true
+  };
+  const builtIns = new Set(campaignAgentStringArray(request.builtIns) || [
+    "lead_generation",
+    "email_finding",
+    "email_verification",
+    "signals"
+  ]);
+  if (commandBooleanFlag(flags, "use-local-leads")) builtIns.add("local_leads");
+  request.builtIns = [...builtIns];
+  if (!Array.isArray(request.integrations) && (commandBooleanFlag(flags, "with-byo-placeholder") || commandBooleanFlag(flags, "include-byo-placeholder") || commandBooleanFlag(flags, "include-custom-tool-placeholder"))) {
+    request.integrations = [{
+      provider: "custom_mcp",
+      layer: "enrichment",
+      gtmLayers: ["company_enrichment"],
+      mode: "if_available",
+      toolName: "workspace_enrich",
+      mcpServerName: "workspace-mcp",
+      label: "Workspace enrichment MCP",
+      approvalRequired: true,
+      rationale: "Editable custom MCP route placeholder for workspace-owned enrichment."
+    }];
+  }
+  const preferredProviders = new Set(campaignAgentStringArray(request.preferredProviders) || []);
+  if (!commandBooleanFlag(flags, "no-nango-catalog")) preferredProviders.add("nango");
+  request.preferredProviders = [...preferredProviders];
+  request.memory = mergeCampaignAgentRecords({
+    enabled: true,
+    useWorkspaceHistory: true,
+    useNetworkPatterns: false,
+    privacyMode: "anonymized_patterns",
+    queries: [{
+      query: `${request.strategyTemplate} campaign reply patterns, objections, qualification gates, and verified-email QA`,
+      scopes: ["workspace", "operator_notes"],
+      topK: 10,
+      required: true,
+      rationale: "Load approved private strategy and workflow patterns before campaign planning."
+    }]
+  }, record(request.memory));
+  request.agencyContext = mergeCampaignAgentRecords({
+    strategyModel: "strategy_template",
+    includeStrategyPatterns: true,
+    includeWorkflowPatterns: true,
+    includeNangoCatalog: !commandBooleanFlag(flags, "no-nango-catalog"),
+    partnerEcosystem: commandBooleanFlag(flags, "no-nango-catalog") ? ["signaliz"] : ["signaliz", "nango"]
+  }, record(request.agencyContext));
+  request.signalizDefaults = mergeCampaignAgentRecords({
+    delivery: {
+      enabled: true,
+      destinationType: "json",
+      approvalRequired: true
+    }
+  }, record(request.signalizDefaults));
+  request.approvalPolicy = mergeCampaignAgentRecords({
+    requireHumanApproval: true,
+    maxCreditsWithoutApproval: 0,
+    requireApprovalFor: CAMPAIGN_AGENT_APPROVAL_TYPES
+  }, record(request.approvalPolicy));
+  return compactCampaignAgentRequest(request);
+}
+function campaignAgentRequestFileFromFlags(flags) {
+  const file = commandStringFlag(flags, "request-file", "input-file", "campaign-file");
+  if (!file) return void 0;
+  const parsed = readJsonValue(file);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    die("--request-file must point to a JSON object");
+  }
+  return parsed;
+}
+function campaignAgentRequestFromFlags(goal, flags, options = {}) {
+  const includeDefaults = options.includeDefaults !== false;
+  const request = {
+    goal,
+    campaignName: commandStringFlag(flags, "campaign-name", "name"),
+    accountLabel: commandStringFlag(flags, "workspace-label", "account-label"),
+    strategyTemplate: commandStringFlag(flags, "strategy-template", "template"),
+    accountContext: commandStringFlag(flags, "account-context", "workspace-context"),
+    targetCount: commandNumberFlag(flags, "target-count", "lead-count"),
+    gtmCampaignId: commandStringFlag(flags, "gtm-campaign-id", "campaign-id"),
+    icp: campaignAgentJsonObjectInput(flags, ["icp", "target-icp"], ["icp-file", "target-icp-file"]),
+    brainDefaults: campaignAgentJsonObjectInput(flags, ["brain-defaults"], ["brain-defaults-file"]),
+    deliveryRisk: campaignAgentJsonObjectInput(flags, ["delivery-risk"], ["delivery-risk-file"]),
+    builtIns: campaignAgentBuiltInsFromFlags(flags),
+    operatingPlaybooks: commandCsvFlag(flags, "operating-playbooks", "playbooks"),
+    integrations: campaignAgentCustomToolRoutesFromFlags(flags),
+    preferredProviders: commandCsvFlag(flags, "preferred-providers", "providers")
+  };
+  if (includeDefaults || commandFlagValue(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: commandStringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !commandBooleanFlag(flags, "no-strategy-patterns") && !commandBooleanFlag(flags, "no-agency-patterns"),
+      includeWorkflowPatterns: !commandBooleanFlag(flags, "no-workflow-patterns") && !commandBooleanFlag(flags, "no-clay-patterns"),
+      includeNangoCatalog: !commandBooleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: commandCsvFlag(flags, "partners"),
+      revenueMotion: commandStringFlag(flags, "revenue-motion")
+    };
+  }
+  if (includeDefaults || commandFlagValue(flags, "no-memory", "no-workspace-history", "use-network-patterns", "privacy-mode") !== void 0) {
+    request.memory = {
+      enabled: !commandBooleanFlag(flags, "no-memory"),
+      useWorkspaceHistory: !commandBooleanFlag(flags, "no-workspace-history"),
+      useNetworkPatterns: commandBooleanFlag(flags, "use-network-patterns"),
+      privacyMode: commandStringFlag(flags, "privacy-mode")
+    };
+  }
+  if (includeDefaults || commandFlagValue(flags, "max-credits", "no-delivery", "destination") !== void 0) {
+    request.signalizDefaults = {
+      maxCredits: commandNumberFlag(flags, "max-credits"),
+      delivery: {
+        enabled: !commandBooleanFlag(flags, "no-delivery"),
+        destinationType: commandStringFlag(flags, "destination"),
+        approvalRequired: true
+      }
+    };
+  }
+  if (includeDefaults || commandFlagValue(flags, "no-human-approval", "max-credits-without-approval") !== void 0) {
+    request.approvalPolicy = {
+      requireHumanApproval: !commandBooleanFlag(flags, "no-human-approval"),
+      maxCreditsWithoutApproval: commandNumberFlag(flags, "max-credits-without-approval"),
+      requireApprovalFor: CAMPAIGN_AGENT_APPROVAL_TYPES
+    };
+  }
+  return compactCampaignAgentRequest(request);
+}
+function mergeCampaignAgentRequests(base, override) {
+  if (!base) return override;
+  return compactCampaignAgentRequest({
+    ...base,
+    ...override,
+    icp: mergeCampaignAgentRecords(record(base.icp), record(override.icp)),
+    memory: mergeCampaignAgentRecords(record(base.memory), record(override.memory)),
+    agencyContext: mergeCampaignAgentRecords(record(base.agencyContext), record(override.agencyContext)),
+    signalizDefaults: mergeCampaignAgentRecords(record(base.signalizDefaults), record(override.signalizDefaults)),
+    approvalPolicy: mergeCampaignAgentRecords(record(base.approvalPolicy), record(override.approvalPolicy)),
+    constraints: mergeCampaignAgentRecords(record(base.constraints), record(override.constraints)),
+    workspaceContext: mergeCampaignAgentRecords(record(base.workspaceContext), record(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 mergeCampaignAgentRecords(base, override) {
+  const merged = { ...base, ...override };
+  return Object.keys(merged).length ? merged : void 0;
+}
+function compactCampaignAgentRequest(record2) {
+  return Object.fromEntries(Object.entries(record2).filter(([, value]) => value !== void 0));
+}
+function campaignAgentJsonObjectInput(flags, inlineNames, fileNames) {
+  const inline = commandJsonObjectFlag(flags, ...inlineNames);
+  if (inline) return inline;
+  const file = commandStringFlag(flags, ...fileNames);
+  if (!file) return void 0;
+  const parsed = readJsonValue(file);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    die(`--${fileNames[0]} must point to a JSON object`);
+  }
+  return parsed;
+}
+function campaignAgentBuiltInsFromFlags(flags) {
+  const explicit = commandCsvFlag(flags, "builtins", "builtin-tools", "signaliz-tools");
+  const hasBuiltinFlag = Boolean(
+    explicit?.length || commandFlagValue(flags, "use-local-leads") !== void 0 || commandFlagValue(flags, "no-lead-generation") !== void 0 || commandFlagValue(flags, "no-email-finding") !== void 0 || commandFlagValue(flags, "no-verification") !== void 0 || commandFlagValue(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 (commandBooleanFlag(flags, "use-local-leads")) builtIns.add("local_leads");
+  if (commandBooleanFlag(flags, "no-lead-generation")) builtIns.delete("lead_generation");
+  if (commandBooleanFlag(flags, "no-email-finding")) builtIns.delete("email_finding");
+  if (commandBooleanFlag(flags, "no-verification")) builtIns.delete("email_verification");
+  if (commandBooleanFlag(flags, "no-signals")) builtIns.delete("signals");
+  return [...builtIns];
+}
+function campaignAgentCustomToolRoutesFromFlags(flags) {
+  const values = repeatedCommandStringFlag(flags, "custom-tool", "customer-tool", "byo-tool", "integration-route");
+  const routes = values.map(parseCampaignAgentCustomToolRoute);
+  return routes.length ? routes : void 0;
+}
+function parseCampaignAgentCustomToolRoute(raw) {
+  const route = raw.trim().startsWith("{") ? parseJsonObjectFromString(raw, "--custom-tool") : raw.includes("=") ? campaignAgentKeyValueObject(raw) : campaignAgentColonRouteObject(raw);
+  const provider = String(route.provider ?? route.provider_id ?? route.providerId ?? "custom_mcp");
+  const layer = normalizeCampaignAgentLayer(String(route.layer ?? route.use_for_layer ?? route.useForLayer ?? "enrichment"));
+  const label = campaignAgentStringValue(route.label ?? route.name) ?? provider;
+  return {
+    provider,
+    layer,
+    gtmLayers: campaignAgentStringArray(route.gtm_layers ?? route.gtmLayers ?? route.capabilities),
+    mode: normalizeCampaignAgentRouteMode(String(route.mode ?? "required")),
+    toolName: campaignAgentStringValue(route.tool ?? route.tool_name ?? route.toolName),
+    mcpServerName: campaignAgentStringValue(route.mcp ?? route.server ?? route.mcp_server_name ?? route.mcpServerName),
+    label,
+    approvalRequired: campaignAgentOptionalBoolean(route.approval_required ?? route.approvalRequired, true),
+    config: {
+      provider_id: route.provider_id ?? route.providerId,
+      available_tools: campaignAgentStringArray(route.available_tools ?? route.availableTools ?? route.tools),
+      raw: raw.trim()
+    },
+    rationale: `${label} is a user-provided campaign-builder route declared from the CLI.`
+  };
+}
+function campaignAgentColonRouteObject(raw) {
+  const [provider, layer, tool, mcp] = raw.split(":").map((part) => part.trim()).filter(Boolean);
+  if (!provider || !layer) die("Expected --custom-tool provider:layer:tool[:mcp] or key=value pairs");
+  return { provider, layer, tool, mcp };
+}
+function campaignAgentKeyValueObject(raw) {
+  const parsed = {};
+  for (const segment of raw.split(",")) {
+    const eq = segment.indexOf("=");
+    if (eq < 0) continue;
+    parsed[segment.slice(0, eq).trim().replace(/-/g, "_")] = segment.slice(eq + 1).trim();
+  }
+  return parsed;
+}
+function normalizeCampaignAgentLayer(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  const allowed = ["workspace_context", "memory", "source", "enrichment", "qualification", "copy", "delivery", "feedback", "approval"];
+  if (!allowed.includes(normalized)) {
+    die(`Unknown campaign-builder layer "${value}". Use source, enrichment, qualification, copy, delivery, feedback, or approval.`);
+  }
+  return normalized;
+}
+function normalizeCampaignAgentRouteMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  return ["required", "if_available", "fallback", "disabled"].includes(normalized) ? normalized : "required";
+}
+function campaignAgentStringArray(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 ? parsed : void 0;
+}
+function campaignAgentStringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function campaignAgentOptionalBoolean(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  return parseCommandBoolean(String(value), defaultValue);
+}
+function campaignAgentApprovedTypesFromFlags(plan, flags) {
+  const requested = commandCsvFlag(flags, "approved-types", "approve-types");
+  if (requested?.length) return requested;
+  if (!commandBooleanFlag(flags, "approve-all")) {
+    die("campaign-agent build-approved requires --approve-all or --approved-types");
+  }
+  const types = Array.isArray(plan?.approvals) ? plan.approvals.map((item) => item?.type).filter(Boolean) : [];
+  return [...new Set(types.length ? types : CAMPAIGN_AGENT_APPROVAL_TYPES)];
+}
+function campaignAgentApprovedRouteIdsFromFlags(plan, flags) {
+  const requested = commandCsvFlag(flags, "approved-route-ids", "route-ids");
+  if (requested?.length) return requested;
+  if (!commandBooleanFlag(flags, "approve-all")) return void 0;
+  const routeIds = Array.isArray(plan?.approvals) ? plan.approvals.map((item) => item?.routeId).filter(Boolean) : [];
+  return routeIds.length ? routeIds : void 0;
+}
+function createCampaignAgentApproval(plan, input) {
+  return {
+    ...input,
+    planId: plan?.planId,
+    approvedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function printCampaignAgentPlan(plan) {
+  console.log(`Plan: ${plan.campaignName || plan.goal || plan.planId}`);
+  if (plan.planId) console.log(`Plan ID: ${plan.planId}`);
+  if (plan.targetCount !== void 0) console.log(`Target: ${plan.targetCount}`);
+  if (plan.estimatedCredits !== void 0) console.log(`Estimated credits: ${plan.estimatedCredits}`);
+  const memory = record(plan.memory);
+  console.log(`Memory: ${memory.enabled === false ? "disabled" : memory.privacyMode || "workspace_only"}`);
+  const playbooks = Array.isArray(plan.operatingPlaybooks) ? plan.operatingPlaybooks : [];
+  console.log(`Playbooks: ${playbooks.map((item) => item.slug).filter(Boolean).join(", ") || "none"}`);
+  console.log(`Strategy memory: ${plan.strategyMemoryStatus ? record(plan.strategyMemoryStatus).ready === false ? "needs seeding" : "ready" : "not loaded"}`);
+  console.log(`Kernel plan: ${plan.kernelPlan ? "loaded" : "not loaded"}`);
+  const approvals = Array.isArray(plan.approvals) ? plan.approvals : [];
+  console.log(`Approvals: ${approvals.map((item) => item.type).filter(Boolean).join(", ") || "none"}`);
+  const warnings = Array.isArray(plan.warnings) ? plan.warnings : [];
+  if (warnings.length) console.log(`Warnings: ${warnings.join("; ")}`);
+  const flow = Array.isArray(plan.mcpFlow) ? plan.mcpFlow : [];
+  if (flow.length) {
+    console.log("\nMCP flow:");
+    for (const step of flow) {
+      console.log(`- ${step.id || step.tool}: ${step.tool}${step.approvalRequired ? " (approval required)" : ""}`);
+    }
+  }
+}
+function printCampaignAgentExecution(plan, result) {
+  printCampaignAgentPlan(plan);
+  console.log("\nResult:");
+  console.log(JSON.stringify(result, null, 2));
+}
+function createCampaignAgentProofReceipt(plan, result) {
+  const strategyMemory = record(plan.strategyMemoryStatus);
+  const dryRunResult = record(result);
+  const approvals = firstArray(plan.approvals);
+  const flow = firstArray(plan.mcpFlow);
+  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: firstArray(strategyMemory.blockers).length
+    },
+    {
+      id: "campaign_plan_ready",
+      passed: Boolean(plan.planId && flow.length > 0),
+      plan_id: plan.planId ?? null,
+      flow_steps: flow.length
+    },
+    {
+      id: "approval_gates_present",
+      passed: approvals.length > 0,
+      approval_types: approvals.map((approval) => approval?.type).filter(Boolean)
+    },
+    {
+      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: firstArray(plan.operatingPlaybooks).map((playbook) => playbook?.slug).filter(Boolean)
+    },
+    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 run campaign approve <campaign_build_id> --destination-type json."
+    ]
+  };
+}
+function campaignAgentString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return null;
+}
+function campaignAgentStrategyTemplate(plan) {
+  const buildRequest = record(plan.buildRequest);
+  const strategyMemory = record(plan.strategyMemoryStatus);
+  const statusTemplate = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
+  const statusTemplateRecord = record(statusTemplate);
+  const flowTemplate = firstArray(plan.mcpFlow).map((step) => record(record(step).arguments).strategy_template ?? record(record(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 = record(template);
+  const coverage = record(strategyMemory.coverage);
+  const sourceGroups = firstArray(strategyMemory.source_groups, strategyMemory.sourceGroups).map((group) => {
+    const sourceGroup = record(group);
+    return {
+      id: sourceGroup.id ?? null,
+      required: sourceGroup.required ?? null,
+      ready: sourceGroup.ready ?? null,
+      counts: record(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: firstArray(strategyMemory.blockers).length,
+    warning_count: firstArray(strategyMemory.warnings).length
+  };
+}
+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 campaign2 = record(proof.campaign);
+  if (campaign2.plan_id) console.log(`Plan ID: ${campaign2.plan_id}`);
+  if (campaign2.strategy_template) console.log(`Strategy template: ${campaign2.strategy_template}`);
+  if (campaign2.target_count !== void 0) console.log(`Target: ${campaign2.target_count}`);
+  console.log("\nGates:");
+  for (const gate of firstArray(proof.gates)) {
+    console.log(`- ${gate.id}: ${gate.passed ? "passed" : "failed"}`);
+  }
+  console.log("\nSafety: dry-run only; no spendful launch, external write, sender load, or email send.");
+}
 async function lead(sub, rest) {
   const sdk = getSdk();
   if (sub === "generate") {
@@ -2427,19 +3465,219 @@ async function gtm(sub, rest) {
     return;
   }
   const sdk = getSdk();
+  if (sub === "start-context" || sub === "start") {
+    const campaignBrief = promptArg(rest) || flagArg("campaign-brief") || flagArg("brief") || flagArg("goal");
+    const strategyTemplate = flagArg("strategy-template") || flagArg("template");
+    const targetIcp = readJsonObjectInput("target-icp-json", "target-icp-file");
+    if (!campaignBrief && !flagArg("campaign-id") && !flagArg("campaign-build-id") && !flagArg("build-id") && !strategyTemplate && !targetIcp) {
+      die('Usage: signaliz gtm start-context "campaign brief" [--strategy-template ID] [--target-count N] [--json]');
+    }
+    const result = await sdk.gtm.campaignStartContext({
+      campaignId: flagArg("campaign-id"),
+      campaignBuildId: flagArg("campaign-build-id") || flagArg("build-id"),
+      campaignBrief,
+      strategyTemplate,
+      targetIcp,
+      leadCount: numberFlag("lead-count") || numberFlag("target-count"),
+      layers: csvFlag("layers"),
+      preferredProviders: csvFlag("preferred-providers") || csvFlag("providers"),
+      memoryDimensionFilters: readJsonObjectInput("memory-dimension-filters-json", "memory-dimension-filters-file"),
+      requireMemoryDimensionMatch: hasFlag("require-memory-dimension-match") || void 0,
+      includeMemory: !hasFlag("no-memory"),
+      includeBrain: !hasFlag("no-brain"),
+      includeProviderRoutes: !hasFlag("no-provider-routes"),
+      includeFailurePatterns: !hasFlag("no-failure-patterns"),
+      includeDeliveryRisk: !hasFlag("no-delivery-risk"),
+      includeGlobalBrain: !hasFlag("no-global-brain"),
+      includePlannedProviders: !hasFlag("no-planned-providers"),
+      days: numberFlag("days"),
+      minConfidence: numberFlag("min-confidence"),
+      minSampleSize: numberFlag("min-sample-size"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      const runbook = Array.isArray(result.runbook) ? result.runbook : [];
+      const blockers = Array.isArray(result.blockers) ? result.blockers : [];
+      const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+      const readyCount = runbook.filter((step) => step.ready).length;
+      console.log(blockers.length ? "GTM campaign start context: blocked" : "GTM campaign start context: ready");
+      console.log(`  Ready:    ${readyCount}/${runbook.length} read-only calls`);
+      console.log(`  Safety:   read-only; no credits spent, no provider writes, no send/export approval`);
+      console.log(`  Blockers: ${blockers.length}`);
+      console.log(`  Warnings: ${warnings.length}`);
+      if (runbook.length) {
+        console.log("  Runbook:");
+        for (const step of runbook.slice(0, 6)) {
+          console.log(`  - ${step.tool || step.name || "unknown_tool"}${step.ready === false ? " [blocked]" : ""}`);
+        }
+      }
+      if (blockers.length) {
+        for (const blocker of blockers.slice(0, 5)) console.log(`- ${blocker}`);
+      } else {
+        hint("Review the read-only runbook, then run signaliz gtm plan with the same brief/template.");
+      }
+    });
+  }
+  if (sub === "templates" || sub === "strategy-templates") {
+    const result = await sdk.gtm.campaignStrategyTemplates({
+      strategyTemplate: flagArg("strategy-template") || flagArg("template"),
+      query: flagArg("query") || flagArg("q"),
+      includeDetails: !hasFlag("summary")
+    });
+    return output(result, () => {
+      const templates = Array.isArray(result.templates) ? result.templates : [];
+      console.log("GTM campaign strategy templates");
+      for (const template of templates) {
+        console.log(`- ${template.label || template.slug} (${template.slug})`);
+        if (template.default_lead_count !== void 0) console.log(`  Default lead count: ${template.default_lead_count}`);
+        if (Array.isArray(template.preferred_providers)) console.log(`  Providers: ${template.preferred_providers.join(", ")}`);
+        if (template.usage?.cli) console.log(`  CLI: ${template.usage.cli}`);
+      }
+      if (!templates.length) console.log("No strategy templates matched.");
+      hint('Use one with: signaliz gtm plan "campaign brief" --strategy-template <slug> --json');
+    });
+  }
+  if (sub === "strategy-memory" || sub === "memory-status" || sub === "strategy-memory-status") {
+    const flags = parseCommandFlags(rest);
+    const result = await sdk.gtm.campaignStrategyMemoryStatus({
+      strategyTemplate: commandStringFlag(flags, "strategy-template", "template"),
+      query: commandStringFlag(flags, "query", "goal", "q") || promptArg(rest),
+      campaignBrief: commandStringFlag(flags, "brief", "campaign-brief"),
+      targetIcp: readJsonObjectInput("target-icp-json", "target-icp-file") || campaignAgentJsonObjectInput(flags, ["icp", "target-icp"], ["icp-file", "target-icp-file"]),
+      memoryDimensionFilters: readJsonObjectInput("memory-dimension-filters-json", "memory-dimension-filters-file"),
+      requireMemoryDimensionMatch: commandBooleanFlag(flags, "require-memory-dimension-match") || void 0,
+      includeSamples: commandBooleanFlag(flags, "include-samples") || void 0,
+      includeSources: commandBooleanFlag(flags, "no-sources") ? false : void 0,
+      days: commandNumberFlag(flags, "days"),
+      limit: commandNumberFlag(flags, "limit")
+    });
+    return output(result, () => {
+      const coverage = result.coverage || {};
+      const blockers = Array.isArray(result.blockers) ? result.blockers : [];
+      const groups = Array.isArray(result.source_groups) ? result.source_groups : [];
+      console.log(result.ready ? "GTM strategy memory: ready" : "GTM strategy memory: needs seeding");
+      console.log(`  Knowledge docs: ${coverage.knowledge_docs ?? 0}`);
+      console.log(`  Memories:       ${coverage.memories ?? 0}`);
+      console.log(`  Required:       ${coverage.required_groups_ready ?? 0}/${coverage.required_groups_total ?? 0}`);
+      console.log(`  Blockers:       ${blockers.length}`);
+      if (groups.length) {
+        console.log("  Source groups:");
+        for (const group of groups.slice(0, 6)) {
+          console.log(`  - ${group.label || group.id}: ${group.ready ? "ready" : "missing"}`);
+        }
+      }
+      hint("Use the returned memory_search_request before gtm agent-plan or gtm plan.");
+    });
+  }
+  if (sub === "agent-template" || sub === "campaign-agent-template" || sub === "request-template") {
+    const flags = parseCommandFlags(rest);
+    const goal = commandStringFlag(flags, "goal", "brief", "campaign-brief") || promptArg(rest);
+    const targetIcp = readJsonObjectInput("target-icp-json", "target-icp-file") || campaignAgentJsonObjectInput(flags, ["icp", "target-icp"], ["icp-file", "target-icp-file"]);
+    const result = await sdk.gtm.campaignAgentRequestTemplate({
+      goal,
+      campaignName: commandStringFlag(flags, "campaign-name", "name"),
+      accountLabel: commandStringFlag(flags, "workspace-label", "account-label"),
+      accountContext: commandStringFlag(flags, "account-context", "workspace-context"),
+      strategyTemplate: commandStringFlag(flags, "strategy-template", "template"),
+      operatingPlaybooks: commandCsvFlag(flags, "operating-playbooks", "playbooks"),
+      targetIcp,
+      targetCount: commandNumberFlag(flags, "target-count", "lead-count"),
+      builtIns: campaignAgentBuiltInsFromFlags(flags),
+      includeLocalLeads: commandBooleanFlag(flags, "use-local-leads") || commandBooleanFlag(flags, "include-local-leads") || void 0,
+      includeByoPlaceholder: commandBooleanFlag(flags, "with-byo-placeholder") || commandBooleanFlag(flags, "include-byo-placeholder") || void 0,
+      includeNangoCatalog: !commandBooleanFlag(flags, "no-nango-catalog"),
+      preferredProviders: commandCsvFlag(flags, "preferred-providers", "providers"),
+      privacyMode: commandStringFlag(flags, "privacy-mode"),
+      destinationType: commandStringFlag(flags, "destination", "destination-type")
+    });
+    return output(result, () => {
+      const request = result.request || {};
+      console.log("GTM campaign request template: ready");
+      console.log(`  Campaign: ${request.campaignName || commandStringFlag(flags, "campaign-name", "name") || "Strategy Template Campaign"}`);
+      console.log(`  Target:   ${request.targetCount || commandNumberFlag(flags, "target-count", "lead-count") || "n/a"}`);
+      console.log(`  Safety:   read-only; no credits spent, no provider calls, no writes`);
+      if (result.next_mcp_call?.tool) console.log(`  Next MCP: ${result.next_mcp_call.tool}`);
+      hint("Save request_json, then run signaliz campaign-agent plan --request-file campaign-builder-agent-request.json --json.");
+    });
+  }
+  if (sub === "agent-plan" || sub === "campaign-agent-plan") {
+    const flags = parseCommandFlags(rest);
+    const goal = commandStringFlag(flags, "goal", "brief", "campaign-brief") || promptArg(rest);
+    const strategyTemplate = commandStringFlag(flags, "strategy-template", "template");
+    const targetIcp = readJsonObjectInput("target-icp-json", "target-icp-file") || campaignAgentJsonObjectInput(flags, ["icp", "target-icp"], ["icp-file", "target-icp-file"]);
+    if (!goal && !commandStringFlag(flags, "campaign-id") && !commandStringFlag(flags, "campaign-build-id", "build-id") && !strategyTemplate && !targetIcp) {
+      die('Usage: signaliz gtm agent-plan --goal "campaign brief" [--strategy-template ID] [--target-count N] [--json]');
+    }
+    const result = await sdk.gtm.campaignAgentPlan({
+      goal,
+      campaignName: commandStringFlag(flags, "campaign-name", "name"),
+      campaignId: commandStringFlag(flags, "campaign-id"),
+      campaignBuildId: commandStringFlag(flags, "campaign-build-id", "build-id"),
+      strategyTemplate,
+      operatingPlaybooks: commandCsvFlag(flags, "operating-playbooks", "playbooks"),
+      accountContext: commandStringFlag(flags, "account-context", "workspace-context"),
+      targetIcp,
+      targetCount: commandNumberFlag(flags, "target-count", "lead-count"),
+      builtIns: campaignAgentBuiltInsFromFlags(flags),
+      useLocalLeads: commandBooleanFlag(flags, "use-local-leads") || void 0,
+      layers: commandCsvFlag(flags, "layers"),
+      preferredProviders: commandCsvFlag(flags, "preferred-providers", "providers"),
+      customTools: campaignAgentCustomToolRoutesFromFlags(flags),
+      strategyModel: commandStringFlag(flags, "strategy-model"),
+      includeStrategyPatterns: !commandBooleanFlag(flags, "no-strategy-patterns"),
+      includeWorkflowPatterns: !commandBooleanFlag(flags, "no-workflow-patterns"),
+      includeNangoCatalog: !commandBooleanFlag(flags, "no-nango-catalog"),
+      partnerEcosystem: commandCsvFlag(flags, "partner-ecosystem", "partners"),
+      memoryDimensionFilters: readJsonObjectInput("memory-dimension-filters-json", "memory-dimension-filters-file"),
+      requireMemoryDimensionMatch: commandBooleanFlag(flags, "require-memory-dimension-match") || void 0,
+      includeMemory: !commandBooleanFlag(flags, "no-memory"),
+      includeBrain: !commandBooleanFlag(flags, "no-brain"),
+      includeProviderRoutes: !commandBooleanFlag(flags, "no-provider-routes"),
+      includeFailurePatterns: !commandBooleanFlag(flags, "no-failure-patterns"),
+      includeDeliveryRisk: !commandBooleanFlag(flags, "no-delivery-risk"),
+      includePlannedProviders: !commandBooleanFlag(flags, "no-planned-providers"),
+      days: commandNumberFlag(flags, "days"),
+      limit: commandNumberFlag(flags, "limit")
+    });
+    return output(result, () => {
+      const flow = Array.isArray(result.mcp_flow) ? result.mcp_flow : [];
+      const approvals = Array.isArray(result.required_approvals) ? result.required_approvals : [];
+      const blockers = Array.isArray(result.blockers) ? result.blockers : [];
+      const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+      console.log(blockers.length ? "GTM campaign agent plan: blocked" : "GTM campaign agent plan: ready for review");
+      console.log(`  Plan ID:   ${result.plan_id || "n/a"}`);
+      console.log(`  Campaign:  ${result.campaign?.name || goal || "strategy-template campaign"}`);
+      console.log(`  Safety:    read-only; no credits spent, no provider writes, no send/export approval`);
+      console.log(`  Flow:      ${flow.length} MCP steps`);
+      console.log(`  Approvals: ${approvals.length}`);
+      console.log(`  Blockers:  ${blockers.length}`);
+      console.log(`  Warnings:  ${warnings.length}`);
+      if (flow.length) {
+        console.log("  Next MCP flow:");
+        for (const step of flow.slice(0, 6)) console.log(`  - ${step.tool || step.name || "unknown_tool"}`);
+      }
+      hint("Review the runbook, then call gtm_campaign_build_plan and dry-run gtm_campaign_build_plan_commit.");
+    });
+  }
   if (sub === "plan" || sub === "build-plan" || sub === "campaign-plan") {
     const campaignBrief = promptArg(rest) || flagArg("campaign-brief") || flagArg("brief");
     if (!campaignBrief && !flagArg("campaign-id") && !flagArg("campaign-build-id") && !flagArg("build-id")) {
-      die('Usage: signaliz gtm plan "campaign brief" [--target-count N] [--layers a,b] [--preferred-providers a,b]');
+      die('Usage: signaliz gtm plan "campaign brief" [--strategy-template ID] [--target-count N] [--layers a,b] [--preferred-providers a,b]');
     }
     const result = await sdk.gtm.campaignBuildPlan({
       campaignId: flagArg("campaign-id"),
       campaignBuildId: flagArg("campaign-build-id") || flagArg("build-id"),
       campaignBrief,
+      strategyTemplate: flagArg("strategy-template") || flagArg("template"),
       targetIcp: readJsonObjectInput("target-icp-json", "target-icp-file"),
       leadCount: numberFlag("lead-count") || numberFlag("target-count"),
       layers: csvFlag("layers"),
       preferredProviders: csvFlag("preferred-providers") || csvFlag("providers"),
+      strategyModel: flagArg("strategy-model"),
+      includeStrategyPatterns: !hasFlag("no-strategy-patterns") && !hasFlag("no-agency-patterns"),
+      includeWorkflowPatterns: !hasFlag("no-workflow-patterns") && !hasFlag("no-clay-patterns"),
+      includeNangoCatalog: !hasFlag("no-nango-catalog"),
+      partnerEcosystem: csvFlag("partner-ecosystem") || csvFlag("partners"),
       memoryDimensionFilters: readJsonObjectInput("memory-dimension-filters-json", "memory-dimension-filters-file"),
       requireMemoryDimensionMatch: hasFlag("require-memory-dimension-match") || void 0,
       includeMemory: !hasFlag("no-memory"),
@@ -2930,6 +4168,52 @@ async function gtm(sub, rest) {
       hint("signaliz gtm activate-route --provider-id <provider> --layer <layer> --campaign-id <campaign_id>");
     });
   }
+  if (sub === "provider-prepare" || sub === "prepare-provider" || sub === "recipe-prepare" || sub === "prepare-recipe") {
+    const providerId = flagArg("provider-id") || flagArg("provider") || rest[0];
+    if (!providerId) die("Usage: signaliz gtm provider-prepare --provider-id <provider_id> [--layer <layer>] [--json]");
+    const result = await sdk.gtm.prepareProviderRecipe({
+      providerId,
+      providerName: flagArg("provider-name") || flagArg("name"),
+      description: flagArg("description"),
+      layerCapabilities: csvFlag("layer-capabilities") || csvFlag("layers"),
+      invocationType: flagArg("invocation-type"),
+      authStrategy: flagArg("auth-strategy"),
+      endpointUrl: flagArg("endpoint-url"),
+      httpMethod: flagArg("http-method"),
+      secretRef: flagArg("secret-ref"),
+      workspaceIntegrationId: flagArg("workspace-integration-id"),
+      workspaceMcpServerId: flagArg("workspace-mcp-server-id"),
+      workspaceConnectionId: flagArg("workspace-connection-id"),
+      requestTemplate: readJsonObjectInput("request-template-json", "request-template-file"),
+      responseMapping: readJsonObjectInput("response-mapping-json", "response-mapping-file"),
+      inputSchema: readJsonObjectInput("input-schema-json", "input-schema-file"),
+      outputSchema: readJsonObjectInput("output-schema-json", "output-schema-file"),
+      readiness: readJsonObjectInput("readiness-json", "readiness-file"),
+      metadata: readJsonObjectInput("metadata-json", "metadata-file"),
+      layer: flagArg("layer"),
+      campaignId: flagArg("campaign-id"),
+      useSignalizFallback: !hasFlag("no-signaliz-fallback"),
+      priority: numberFlag("priority"),
+      status: flagArg("status"),
+      sampleRecords: flagArg("records-file") ? readJsonValue(flagArg("records-file")) : void 0,
+      context: readJsonObjectInput("context-json", "context-file")
+    });
+    return output(result, () => {
+      const recipeArgs = result.recipe_arguments || result.recipeArgs || {};
+      const routeArgs = result.route_arguments || result.routeArgs || {};
+      const blockers = Array.isArray(result.blockers) ? result.blockers : [];
+      const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+      console.log("GTM provider setup plan");
+      console.log(`  Provider: ${providerId}`);
+      console.log(`  Layer:    ${flagArg("layer") || (Array.isArray(recipeArgs.layer_capabilities) ? recipeArgs.layer_capabilities[0] : "not specified")}`);
+      console.log("  Safety:   read-only; no recipe, route, provider call, or external write");
+      if (recipeArgs.provider_id) console.log(`  Recipe:   ${recipeArgs.provider_id}`);
+      if (routeArgs.layer) console.log(`  Route:    ${routeArgs.layer}`);
+      if (blockers.length) console.log(`  Blockers: ${blockers.join("; ")}`);
+      if (warnings.length) console.log(`  Warnings: ${warnings.join("; ")}`);
+      hint("Review the recipe and route arguments, then run signaliz gtm activate-route as a dry-run.");
+    });
+  }
   if (sub === "activate-route" || sub === "route-activate") {
     const providerId = flagArg("provider-id") || rest[0];
     if (!providerId) die("Usage: signaliz gtm activate-route --provider-id <provider_id> --layer <layer> [--confirm]");
@@ -3026,7 +4310,7 @@ async function gtm(sub, rest) {
     });
   }
   if (sub === "find") {
-    const intent = rest.join(" ").trim() || flagArg("intent") || "";
+    const intent = promptArg(rest) || flagArg("intent") || "";
     if (!intent) die('Usage: signaliz gtm find "<free-text intent>"');
     const result = await sdk.leads.findGtmCapability(intent);
     return output(result, () => {
@@ -3074,7 +4358,7 @@ ${i + 1}. ${m.capability_id} (score ${m.score}) \u2014 ${m.label}`);
     const result = await sdk.leads.checkStatus(jobId);
     return output(result);
   }
-  die("Usage: signaliz gtm <context|bootstrap|plan|commit-plan|prepare-build|campaigns|campaign|existing-campaigns|audit-existing|memory|learning|execution|integrations|activate-route|list|find|run|status|nango>");
+  die("Usage: signaliz gtm <context|bootstrap|strategy-memory|agent-template|agent-plan|plan|commit-plan|prepare-build|campaigns|campaign|existing-campaigns|audit-existing|memory|learning|execution|integrations|provider-prepare|activate-route|list|find|run|status|nango>");
 }
 function nangoActionInput() {
   const fromFile = readJsonFlag("input-file");
@@ -3091,11 +4375,40 @@ function nangoBaseOptions() {
     nangoConnectionId: flagArg("nango-connection-id")
   };
 }
+function nangoConnectOptions() {
+  return {
+    providerId: flagArg("provider-id") || flagArg("provider"),
+    integrationId: flagArg("integration-id") || flagArg("provider-config-key"),
+    providerDisplayName: flagArg("provider-display-name") || flagArg("provider-name"),
+    integrationDisplayName: flagArg("integration-display-name"),
+    allowedIntegrations: csvFlag("allowed-integrations"),
+    surface: flagArg("surface") || "gtm_kernel",
+    source: flagArg("source") || "signaliz_cli",
+    userEmail: flagArg("user-email"),
+    userDisplayName: flagArg("user-display-name")
+  };
+}
 function nangoStatusUrl(result) {
   return result?.status_url || result?.statusUrl || result?.nango_result?.status_url || result?.nango_result?.statusUrl;
 }
 async function gtmNango(sub, rest) {
   const sdk = getSdk();
+  if (sub === "connect" || sub === "auth" || sub === "authorize") {
+    const options = nangoConnectOptions();
+    if (!options.providerId && !options.integrationId && (!options.allowedIntegrations || options.allowedIntegrations.length === 0)) {
+      die("Usage: signaliz gtm nango connect --provider-id <provider> [--integration-id <key>] [--allowed-integrations a,b]");
+    }
+    const result = await sdk.gtm.createNangoConnectSession(options);
+    return output(result, () => {
+      console.log(`Nango connect session: ${result?.status || "created"}`);
+      if (result?.provider_id || options.providerId) console.log(`  Provider: ${result?.provider_id || options.providerId}`);
+      if (result?.integration_id || options.integrationId) console.log(`  Integration: ${result?.integration_id || options.integrationId}`);
+      if (result?.connect_link || result?.auth_window_url) console.log(`  Auth link: ${result.connect_link || result.auth_window_url}`);
+      if (result?.expires_at) console.log(`  Expires: ${result.expires_at}`);
+      if (result?.next_action) console.log(`  Next: ${result.next_action}`);
+      hint("After authorization finishes, run signaliz gtm nango tools --workspace-connection-id <id> --provider-config-key <key>");
+    });
+  }
   if (!sub || sub === "tools" || sub === "list") {
     const result = await sdk.gtm.listNangoTools({
       ...nangoBaseOptions(),
@@ -3148,7 +4461,7 @@ async function gtmNango(sub, rest) {
       if (nextStatusUrl) console.log(`  Status URL: ${nextStatusUrl}`);
     });
   }
-  die("Usage: signaliz gtm nango <tools|call|result>");
+  die("Usage: signaliz gtm nango <connect|tools|call|result>");
 }
 async function email(sub, rest) {
   const sdk = getSdk();
@@ -4088,6 +5401,8 @@ async function main() {
     case "email":
     case "emails":
       return email(rest[0], rest.slice(1));
+    case "campaign-agent":
+      return campaignAgent(rest[0], rest.slice(1));
     case "campaign": {
       const sub = rest[0];
       if (!sub || sub === "--help" || sub === "-h") {