@signaliz/cli 1.0.16 → 1.0.17

package/dist/bin.js

@@ -9,18 +9,23 @@ var import_node_readline = require("readline");
 var import_node_child_process = require("child_process");
 var CONFIG_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".signaliz");
 var CONFIG_FILE = (0, import_node_path.join)(CONFIG_DIR, "config.json");
-function loadConfig() {
+var cachedConfig;
+function loadConfig(options = {}) {
+  if (cachedConfig && !options.refresh) return cachedConfig;
   try {
     if ((0, import_node_fs.existsSync)(CONFIG_FILE)) {
-      return JSON.parse((0, import_node_fs.readFileSync)(CONFIG_FILE, "utf8"));
+      cachedConfig = JSON.parse((0, import_node_fs.readFileSync)(CONFIG_FILE, "utf8"));
+      return cachedConfig;
     }
   } catch {
   }
-  return {};
+  cachedConfig = {};
+  return cachedConfig;
 }
 function saveConfig(config) {
   (0, import_node_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
   (0, import_node_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+  cachedConfig = config;
 }
 function arg(name) {
   const found = process.argv.find((a) => a.startsWith(`--${name}=`));
@@ -98,6 +103,7 @@ function normalizeCampaignBuildInput(raw) {
   const signals = nested("signals", "signals");
   const copy = nested("copy", "copy");
   const delivery = nested("delivery", "delivery");
+  const learningHoldout = nested("learning_holdout", "learningHoldout");
   return {
     name: get("name", "name"),
     prompt: get("prompt", "prompt"),
@@ -110,6 +116,14 @@ function normalizeCampaignBuildInput(raw) {
     dedupKeys: get("dedup_keys", "dedupKeys"),
     brainPreflight: get("brain_preflight", "brainPreflight"),
     brainDefaults: get("brain_defaults", "brainDefaults"),
+    learningHoldout: learningHoldout ? {
+      ...learningHoldout,
+      controlPercentage: learningHoldout.control_percentage ?? learningHoldout.controlPercentage,
+      minControlSize: learningHoldout.min_control_size ?? learningHoldout.minControlSize,
+      experimentKey: learningHoldout.experiment_key ?? learningHoldout.experimentKey,
+      sourceCampaignId: learningHoldout.source_campaign_id ?? learningHoldout.sourceCampaignId,
+      primaryMetric: learningHoldout.primary_metric ?? learningHoldout.primaryMetric
+    } : void 0,
     deliveryRisk: get("delivery_risk", "deliveryRisk"),
     icp: nested("icp", "icp"),
     policy: policy ? {
@@ -145,7 +159,6 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "action-name",
   "actor-id",
   "actor-type",
-  "analysis-models",
   "attachment-field",
   "attachment-fields",
   "attachment-file",
@@ -193,6 +206,8 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "domains",
   "enhancers-file",
   "enhancers-json",
+  "field-map-file",
+  "field-map-json",
   "file-url",
   "integration-id",
   "image-url",
@@ -203,13 +218,14 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "icp",
   "integration-display-name",
   "integration-route",
-  "judge-model",
+  "interval-ms",
   "layer",
   "layers",
   "limit",
   "lead-count",
   "log-limit",
   "max-concurrency",
+  "max-polls",
   "max-retries",
   "max-tokens",
   "max-credits",
@@ -218,9 +234,18 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "memory-type",
   "model",
   "name",
+  "holdout-min-sample-size",
+  "holdout-control-percentage",
+  "holdout-experiment-key",
+  "holdout-min-control-size",
+  "holdout-primary-metric",
+  "holdout-source-campaign-id",
+  "http-method",
   "min-sample-size",
   "min-workspace-count",
   "nango-connection-id",
+  "nango-action",
+  "nango-proxy-path",
   "network-days",
   "output-format",
   "output-file",
@@ -245,11 +270,14 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "provider-link-id",
   "provider-name",
   "provider-workspace-id",
+  "proxy-path",
   "qualification-file",
   "qualification-json",
   "request-file",
   "records-file",
   "records-json",
+  "required-field",
+  "required-fields",
   "revenue-motion",
   "readiness-json",
   "rationale",
@@ -275,12 +303,20 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "target-icp-file",
   "target-icp-json",
   "temperature",
+  "timeout-ms",
   "tool-name",
   "url",
   "user-display-name",
   "user-email",
   "video-url",
+  "wait-interval-ms",
+  "wait-max-polls",
+  "wait-timeout-ms",
   "write-mode",
+  "timezone",
+  "wake-event",
+  "wake-events",
+  "wake-on-events",
   "workspace-connection-id",
   "workspace-integration-id",
   "workspace-label",
@@ -291,6 +327,7 @@ var promptValueFlags = /* @__PURE__ */ new Set([
   "brain-defaults-file",
   "memory-dimension-filters-file",
   "memory-dimension-filters-json",
+  "method",
   "metadata-file",
   "metadata-json",
   "plan-file",
@@ -361,6 +398,9 @@ function commandBooleanFlag(flags, name, defaultValue = false) {
   if (Array.isArray(value)) return value.length > 0 ? parseCommandBoolean(value.at(-1), defaultValue) : defaultValue;
   return parseCommandBoolean(value, defaultValue);
 }
+function commandOptionalBooleanFlag(flags, name) {
+  return commandFlagValue(flags, name) === void 0 ? void 0 : commandBooleanFlag(flags, name);
+}
 function parseCommandBoolean(value, defaultValue) {
   if (value === void 0) return defaultValue;
   if (typeof value === "boolean") return value;
@@ -609,6 +649,50 @@ function printExecutionRefs(refs) {
     if (ref.replay_command) console.log(`  replay: ${ref.replay_command}`);
   }
 }
+function combineExecutionRefs(...groups) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    if (!Array.isArray(group)) continue;
+    for (const ref of group) {
+      if (!ref?.kind || !ref?.id) continue;
+      refs.set(`${ref.kind}:${ref.id}`, ref);
+    }
+  }
+  return Array.from(refs.values());
+}
+function opsWaitOptions() {
+  return {
+    interval_ms: numberFlag("interval-ms") ?? numberFlag("wait-interval-ms"),
+    max_polls: numberFlag("max-polls") ?? numberFlag("wait-max-polls"),
+    timeout_ms: numberFlag("timeout-ms") ?? numberFlag("wait-timeout-ms"),
+    limit: numberFlag("limit"),
+    cursor: flagArg("cursor"),
+    include_failed_runs: hasFlag("include-failed-runs"),
+    include_results: !hasFlag("no-results")
+  };
+}
+function printOpsWaitForResults(result) {
+  const status = result.status || {};
+  console.log(`Op:      ${result.op_id || result.opId || status.op_id || status.opId || "unknown"}`);
+  console.log(`Status:  ${status.status || "unknown"}`);
+  console.log(`Phase:   ${status.phase || "unknown"}`);
+  console.log(`Polls:   ${result.polls ?? 0}${result.timed_out || result.timedOut ? " (timed out)" : ""}`);
+  if (result.results) {
+    const summary = result.results.summary || {};
+    const count = summary.results_count ?? summary.resultsCount ?? result.results.results_count ?? result.results.resultsCount ?? 0;
+    const total = summary.results_total ?? summary.resultsTotal ?? result.results.results_total ?? result.results.resultsTotal;
+    const delivery = summary.delivery_status ?? summary.deliveryStatus ?? result.results.delivery_status ?? result.results.deliveryStatus;
+    console.log(`Results: ${count}`);
+    if (total !== void 0 && total !== null) console.log(`Total:   ${total}`);
+    if (delivery) console.log(`Deliver: ${delivery}`);
+    if (Array.isArray(result.results.results) && result.results.results.length) {
+      console.log("\nRows");
+      for (const row of result.results.results.slice(0, 10)) console.log(JSON.stringify(row));
+    }
+  }
+  if (result.next_action || result.nextAction) console.log(`Next:    ${result.next_action || result.nextAction}`);
+  printExecutionRefs(result.execution_refs || result.executionRefs);
+}
 function printQueueProducerEnvelope(envelope) {
   if (!envelope || typeof envelope !== "object") return;
   const queueName = envelope.queue_name ?? envelope.queueName;
@@ -635,6 +719,52 @@ function printPrimitiveGraph(primitives) {
     console.log(`- ${primitive.id || "unknown"}@${primitive.version || "unknown"} (${primitive.permission_level || "unknown"}, ${retry}, ${concurrency}, ${rate})`);
   }
 }
+function printOpsExecutionContract(plan) {
+  const contract = record(plan?.execution_contract || plan?.executionContract);
+  if (!Object.keys(contract).length) return;
+  const runNow = record(contract.run_now || contract.runNow);
+  const schedule = record(contract.schedule);
+  const approval = record(contract.approval);
+  const monitor = record(contract.monitor);
+  const resultContract = record(contract.result_contract || contract.resultContract);
+  const sequence = firstArray(contract.sequence);
+  const nangoRoute = record(contract.nango_route || contract.nangoRoute);
+  const createTool = schedule.create_tool || schedule.createTool || "ops_create";
+  const activateTool = schedule.activate_tool || schedule.activateTool || "ops_execute";
+  const schedulePath = createTool === activateTool ? String(createTool) : `${createTool} -> ${activateTool}`;
+  const statusTool = monitor.status_tool || monitor.statusTool || "ops_status";
+  const waitTool = monitor.wait_tool || monitor.waitTool || resultContract.wait_tool || resultContract.waitTool || "ops_wait";
+  const resultsTool = monitor.results_tool || monitor.resultsTool || "ops_results";
+  const resultShape = firstArray(resultContract.shape).map(String);
+  console.log("\nExecution contract");
+  console.log(`- Mode: ${contract.mode || "run_once"}`);
+  console.log(`- Run now: ${runNow.tool || "ops_execute"}`);
+  console.log(`- Schedule: ${schedule.cadence || "manual"} via ${schedulePath}`);
+  if (schedule.recurrence) console.log(`- Recurrence: ${schedule.recurrence}`);
+  console.log(`- Monitor/results: ${waitTool} (or ${statusTool} -> ${resultsTool})`);
+  if (resultShape.length) console.log(`- Result shape: ${resultShape.join(", ")}`);
+  if (approval.tool) {
+    console.log(`- Approval: ${approval.required ? `${approval.tool} required` : "not required"}${approval.reason ? ` - ${approval.reason}` : ""}`);
+  }
+  if (sequence.length) {
+    console.log(`- Sequence: ${sequence.map((step) => step.tool || "unknown_tool").join(" -> ")}`);
+  }
+  if (Object.keys(nangoRoute).length) {
+    console.log("\nNango API route");
+    console.log(`- Connect: ${nangoRoute.connect_tool || nangoRoute.connectTool || "nango_connect_session_create"}`);
+    console.log(`- Discover: ${nangoRoute.discover_tool || nangoRoute.discoverTool || "nango_mcp_tools_list"}`);
+    console.log(`- Dry run: ${nangoRoute.dry_run_tool || nangoRoute.dryRunTool || "nango_mcp_tool_call"}`);
+    console.log(`- Execute: ${nangoRoute.execute_tool || nangoRoute.executeTool || "nango_mcp_tool_call"} after approval`);
+    if (nangoRoute.execute_and_wait_tool || nangoRoute.executeAndWaitTool) {
+      console.log(`- Execute and wait: ${nangoRoute.execute_and_wait_tool || nangoRoute.executeAndWaitTool}`);
+    }
+    const nangoScheduleTool = nangoRoute.schedule_and_wait_tool || nangoRoute.scheduleAndWaitTool || nangoRoute.schedule_tool || nangoRoute.scheduleTool;
+    if (nangoScheduleTool) {
+      console.log(`- Schedule: ${nangoScheduleTool} after approval`);
+    }
+    if (nangoRoute.write_gate || nangoRoute.writeGate) console.log(`- Gate: ${nangoRoute.write_gate || nangoRoute.writeGate}`);
+  }
+}
 function normalizeSavedCommandArgs(args) {
   const separator = args.indexOf("--");
   const raw = separator === -1 ? args : args.slice(separator + 1);
@@ -758,7 +888,7 @@ function opsSaved(sub, rest) {
       stdio: "inherit",
       env: process.env
     });
-    const latest = loadConfig();
+    const latest = loadConfig({ refresh: true });
     const latestSaved = latest.saved_commands || {};
     const latestCommand = latestSaved[name];
     if (latestCommand) {
@@ -943,11 +1073,9 @@ Discovery:
     --category NAME       Optional category filter, e.g. ops or enrichment
 
 AI:
-  ai multi-model          Run Custom AI Enrichment - Multi Model
-    --prompt "..."        Prompt/template for each record (required)
-    --model provider/model
-                          OpenRouter model id, e.g. google/gemini-2.5-flash
-    --records-file FILE   JSON array, or object with records/inputs/data
+	  ai multi-model          Run Custom AI Enrichment - Multi Model
+	    --prompt "..."        Prompt/template for each record (required)
+	    --records-file FILE   JSON array, or object with records/inputs/data
     --input-file FILE     Single JSON record
     --output-fields a:text,b:number
                           Structured fields to return
@@ -955,12 +1083,10 @@ AI:
     --pdf-url URL         Attach a PDF URL to all records
     --attachment-file FILE
                           Attach a local image/PDF/audio/video as base64
-    --attachment-fields a,b
-                          Record fields containing attachment URLs/arrays
-    --max-concurrency N   Record concurrency, default 3, maximum 5
-    --analysis-models a,b Optional Fusion analysis model panel
-    --judge-model MODEL   Optional Fusion judge model
-    --confirm-spend       Required to run spendful Fusion enrichment
+	    --attachment-fields a,b
+	                          Record fields containing attachment URLs/arrays
+	    --max-concurrency N   Record concurrency, default 3, maximum 5
+	    --confirm-spend       Required to run spendful AI enrichment
 
 Lead Generation:
   lead generate           Start a B2B lead-generation job
@@ -1046,9 +1172,13 @@ GTM Kernel:
   gtm learning <id>       Plan Brain learning for a campaign
     --include-network     Include privacy-safe network lanes
     --write-mode MODE     dry_run or write
+    --holdout-min-sample-size N
+                          Minimum control/treatment subjects for measured lift
   gtm learning-run <id>   Queue ready Brain learning phases
     --phases a,b          Optional phase allow-list
     --write-mode MODE     dry_run or write, default dry_run
+    --holdout-min-sample-size N
+                          Minimum control/treatment subjects for measured lift
   gtm calibrate <id>      Calibrate deliverability predictions
     --min-sample-size N   Default server-side
     --write               Write calibrations/patterns; otherwise dry-run
@@ -1072,6 +1202,12 @@ GTM Kernel:
     --provider NAME       instantly, smartlead, heyreach, airbyte, custom_webhook
     --campaign-id ID      Optional campaign scope
     --write-mode MODE     Brain-cycle mode, default dry_run
+  gtm feedback-pull       Pull Instantly feedback into the learning loop
+    --source SOURCE       webhook_events or emails, default webhook_events
+    --campaign-id ID      Optional campaign scope
+    --provider-campaign-id ID
+                          Instantly campaign id
+    --confirm             Write feedback/memory rows; otherwise dry-run
 
 Native GTM Data Sources:
   Use these when you already know the exact source you want to run.
@@ -1164,8 +1300,12 @@ Campaign Builder:
   campaign rows <id>      Retrieve build rows
     --limit N             Page size (default: 50, max: 500)
     --cursor <id>         Pagination cursor
+    --include-data        Include generated copy and rich row data
+    --include-raw         Include raw provider payloads
     --all                 Dump all rows (caution: unbounded)
   campaign artifacts <id> List artifacts with download URLs
+  campaign download <id>  Generate fresh signed artifact URLs
+    --format csv|ndjson   Artifact format (default: csv)
   campaign approve <id>   Approve pending delivery
     --destination-type    json|csv|webhook
     --destination-id ID   Optional destination/sink ID
@@ -1173,12 +1313,18 @@ Campaign Builder:
   campaign cancel <id>    Cancel a running build
 
 Ops:
-  Canonical path: ops plan -> ops create -> ops run -> ops status -> ops results
+  Canonical path: ops plan -> ops execute -> ops wait
   ops plan "..."         Preview a prompt-first Op plan
     --blueprint NAME     monitor_companies|build_leads|enrich_list|route_signals|launch_campaign
     --target-count N     Target row count
     --cadence NAME       manual|hourly|daily|weekly
+    --wake-on-events a,b Event triggers such as company_funded,crm.updated
     --destinations a,b   Destinations such as slack,csv,google_sheets,webhook,airbyte,nango
+    --workspace-connection-id ID
+                         Nango workspace connection for API delivery
+    --provider-config-key KEY
+                         Nango integration/provider key
+    --action-name NAME   Nango action; use --proxy-path PATH for proxy mode
     --company-domains a,b
                          Company domains for monitor/list-based Ops
     --ai-prompt TEXT     Custom AI enrichment or scoring instruction
@@ -1195,7 +1341,21 @@ Ops:
     --confirm-spend      Acknowledge estimated credits/external writes
     --auto-run           Run immediately after create when safe
     --no-auto-run        Create only
+    --wait               Auto-run, poll status, and fetch results
+    --interval-ms N      Polling interval for --wait, default 5000
+    --max-polls N        Polling limit for --wait, default 12, max 30
+    --timeout-ms N       Total wait timeout for --wait, default 60000
+    --limit N            Result rows after terminal status
+    --no-results         Stop after final status without fetching results
+    --cadence NAME       manual|hourly|daily|weekly
+    --timezone TZ        IANA timezone for recurring Ops, e.g. America/Phoenix
+    --wake-on-events a,b Event triggers such as company_funded,crm.updated
     --destinations a,b   Destinations such as slack,csv,google_sheets,webhook,airbyte,nango
+    --workspace-connection-id ID
+                         Nango workspace connection for API delivery
+    --provider-config-key KEY
+                         Nango integration/provider key
+    --action-name NAME   Nango action; use --proxy-path PATH for proxy mode
     --company-domains a,b
                          Company domains for monitor/list-based Ops
     --ai-prompt TEXT     Custom AI enrichment or scoring instruction
@@ -1204,19 +1364,78 @@ Ops:
   ops create "..."       Create an Op from a prompt
     --confirm-spend      Acknowledge estimated credits/external writes
     --activate           Create as active instead of draft
+    --cadence NAME       manual|hourly|daily|weekly
+    --timezone TZ        IANA timezone for recurring Ops, e.g. America/Phoenix
+    --wake-on-events a,b Event triggers such as company_funded,crm.updated
+    --destinations a,b   Destinations such as slack,csv,google_sheets,webhook,airbyte,nango
+    --workspace-connection-id ID
+                         Nango workspace connection for API delivery
+    --provider-config-key KEY
+                         Nango integration/provider key
+    --action-name NAME   Nango action; use --proxy-path PATH for proxy mode
+    --company-domains a,b
+                         Company domains for monitor/list-based Ops
+    --ai-prompt TEXT     Custom AI enrichment or scoring instruction
+    --signal-prompt TEXT Custom signal-finding instruction
+    --output-prompt TEXT Clean result formatting instruction
+  ops schedule "..."     Create and activate a recurring Op, daily by default
+  ops recur "..."        Alias for ops schedule
+    --confirm-spend      Acknowledge estimated credits/external writes
+    --wait               Run first tick and fetch results through ops_schedule_and_wait
+    --interval-ms N      Polling interval for --wait, default 5000
+    --max-polls N        Polling limit for --wait, default 12, max 30
+    --timeout-ms N       Total wait timeout for --wait, default 60000
+    --limit N            Result rows after terminal status
+    --cadence NAME       hourly|daily|weekly (default: daily)
+    --timezone TZ        IANA timezone for recurring Ops, e.g. America/Phoenix
+    --wake-on-events a,b Event triggers such as company_funded,crm.updated
     --destinations a,b   Destinations such as slack,csv,google_sheets,webhook,airbyte,nango
+    --workspace-connection-id ID
+                         Nango workspace connection for API delivery
+    --provider-config-key KEY
+                         Nango integration/provider key
+    --action-name NAME   Nango action; use --proxy-path PATH for proxy mode
     --company-domains a,b
                          Company domains for monitor/list-based Ops
     --ai-prompt TEXT     Custom AI enrichment or scoring instruction
     --signal-prompt TEXT Custom signal-finding instruction
     --output-prompt TEXT Clean result formatting instruction
   ops run <op_id>        Run an Op immediately
+    --wait               Poll status and fetch results after queueing
+    --interval-ms N      Polling interval for --wait, default 5000
+    --max-polls N        Polling limit for --wait, default 12, max 30
+    --timeout-ms N       Total wait timeout for --wait, default 60000
+    --limit N            Result rows after terminal status
+    --no-results         Stop after final status without fetching results
   ops status <op_id>     Check simple Op status
   ops results <op_id>    Retrieve latest Op results
     --limit N            Page size, default 100, max 500
     --cursor ID          Pagination cursor
     --include-failed-runs
                          Include failed run output when supported
+  ops wait <op_id>       Wait for an Op and return results (MCP parity: ops_wait)
+    --interval-ms N      Polling interval, default 5000
+    --max-polls N        Polling limit, default 12, max 30
+    --timeout-ms N       Total wait timeout, default 60000
+    --limit N            Result page size after terminal status
+    --no-results         Stop after final status without fetching results
+  ops nango <subcommand> Connect, discover, call, schedule, and poll Nango tools
+    flow|search          Prepare a provider search/connect/Ops route plan
+    connect              Start Nango Connect auth for a provider
+    tools                List action tools for a workspace connection
+    call <action>        Dry-run or execute a Nango action
+    proof|audit|read-write
+                         Audit connected rows and optional live read/write probes
+      --read-proxy-path PATH
+                         Provider API path for approved live read proof
+      --write-proxy-path PATH
+                         Provider API path for approved live write proof
+      --execute-read-probe --confirm
+                         Run the read probe
+      --execute-write-probe --confirm-write
+                         Run the write probe with safe test input
+    schedule|recur       Create a recurring Nango-backed Op; add --wait for first results
+    result               Poll async Nango action result
   ops run-status <run_id>
                          Inspect a Trigger.dev run or batch with --run-ids a,b
     --watch              Poll until all runs reach a terminal state
@@ -1367,6 +1586,7 @@ Status and repair:
   provider-prepare        Build read-only recipe, route, and preview arguments
   activate-route          Dry-run or confirm provider route setup
   feedback-webhook        Prepare feedback ingress
+  feedback-pull           Dry-run or confirm Instantly feedback pull
   learning <id>           Plan Brain learning
   learning-run <id>       Queue Brain learning phases
   calibrate <id>          Calibrate deliverability
@@ -1770,6 +1990,35 @@ Options:
   readiness: `signaliz gtm readiness <campaign_id> [options]
 
 Alias for signaliz gtm execution.
+`,
+  "feedback-pull": `signaliz gtm feedback-pull [options]
+
+Dry-run or confirm an Instantly feedback pull. Dry-run is the default and
+counts provider records without writing feedback rows, memory, routine outcomes,
+or sync cursors. Confirmed writes require --confirm or --confirm-write.
+
+Options:
+  --source SOURCE         webhook_events or emails, default webhook_events
+  --provider-campaign-id ID
+                          Instantly campaign id
+  --campaign-id ID        Optional linked GTM campaign id
+  --campaign-build-id ID  Optional Campaign Builder build id
+  --provider-link-id ID   Optional provider link id
+  --integration-id ID     Optional Instantly integration id
+  --from DATE             Webhook-event pull window start
+  --to DATE               Webhook-event pull window end
+  --limit N               Page size, default server-side, max 100
+  --max-pages N           Max pages, default server-side, max 20
+  --email-type TYPE       received, sent, or manual when source=emails
+  --mode MODE             emode_focused, emode_others, or emode_all
+  --sort-order ORDER      asc or desc
+  --no-memory             Do not create memory rows on confirmed writes
+  --no-routine-outcomes   Do not write routine outcomes
+  --no-brain-cycle        Do not queue feedback-triggered Brain learning
+  --write-mode MODE       Brain-cycle mode, default dry_run
+  --confirm               Write feedback/memory rows; otherwise dry-run
+  --confirm-write         Alias for --confirm
+  --json                  Machine-readable output
 `,
   campaigns: `signaliz gtm campaigns [options]
 
@@ -1834,7 +2083,13 @@ Options:
   --blueprint NAME        monitor_companies|build_leads|enrich_list|route_signals|launch_campaign
   --target-count N        Target row count
   --cadence NAME          manual|hourly|daily|weekly
+  --wake-on-events a,b    Event triggers such as company_funded,crm.updated
   --destinations a,b      Destinations such as json,csv,slack,airbyte,nango
+  --workspace-connection-id ID
+                          Nango workspace connection for API delivery
+  --provider-config-key KEY
+                          Nango integration/provider key
+  --action-name NAME      Nango action; use --proxy-path PATH for proxy mode
   --company-domains a,b   Explicit account/domain list
   --json                  Machine-readable output
 
@@ -1850,12 +2105,52 @@ Options:
   --confirm-spend         Acknowledge estimated credits/external writes
   --activate              Create as active instead of draft
   --target-count N        Target row count
+  --cadence NAME          manual|hourly|daily|weekly
+  --timezone TZ           IANA timezone for recurring Ops, e.g. America/Phoenix
+  --wake-on-events a,b    Event triggers such as company_funded,crm.updated
   --destinations a,b      Destinations such as json,csv,slack,airbyte,nango
+  --workspace-connection-id ID
+                          Nango workspace connection for API delivery
+  --provider-config-key KEY
+                          Nango integration/provider key
+  --action-name NAME      Nango action; use --proxy-path PATH for proxy mode
   --company-domains a,b   Explicit account/domain list
   --json                  Machine-readable output
 
 Safe next step:
   signaliz ops run <op_id>
+`,
+  schedule: `signaliz ops schedule "plain-English recurring GTM goal" [options]
+
+Create and activate a recurring Op from a prompt. Defaults to daily cadence
+unless --cadence is provided. Requires --confirm-spend for spendful work.
+
+Options:
+  --confirm-spend         Acknowledge estimated credits/external writes
+  --wait                  Create the recurring Op, run the first tick, and fetch results
+  --interval-ms N         Polling interval for --wait, default 5000
+  --max-polls N           Polling limit for --wait, default 12, max 30
+  --timeout-ms N          Total wait timeout for --wait, default 60000
+  --limit N               Result rows after terminal status
+  --target-count N        Target row count
+  --cadence NAME          hourly|daily|weekly (default: daily)
+  --timezone TZ           IANA timezone for recurring Ops, e.g. America/Phoenix
+  --wake-on-events a,b    Event triggers such as company_funded,crm.updated
+  --destinations a,b      Destinations such as json,csv,slack,airbyte,nango
+  --workspace-connection-id ID
+                          Nango workspace connection for API delivery
+  --provider-config-key KEY
+                          Nango integration/provider key
+  --action-name NAME      Nango action; use --proxy-path PATH for proxy mode
+  --company-domains a,b   Explicit account/domain list
+  --json                  Machine-readable output
+
+Safe next step:
+  signaliz ops status <op_id>
+`,
+  recur: `signaliz ops recur "plain-English recurring GTM goal" [options]
+
+Alias for signaliz ops schedule.
 `,
   execute: `signaliz ops execute "plain-English GTM goal" [options]
 
@@ -1866,13 +2161,38 @@ Options:
   --confirm-spend         Acknowledge estimated credits/external writes
   --auto-run              Run immediately after create when safe
   --no-auto-run           Create only
+  --wait                  Auto-run, poll status, and fetch results
+  --interval-ms N         Polling interval for --wait, default 5000
+  --max-polls N           Polling limit for --wait, default 12, max 30
+  --timeout-ms N          Total wait timeout for --wait, default 60000
+  --limit N               Result rows to return after terminal status
+  --no-results            Stop after final status without fetching results
   --target-count N        Target row count
+  --cadence NAME          manual|hourly|daily|weekly
+  --timezone TZ           IANA timezone for recurring Ops, e.g. America/Phoenix
+  --wake-on-events a,b    Event triggers such as company_funded,crm.updated
   --destinations a,b      Destinations such as json,csv,slack,airbyte,nango
+  --workspace-connection-id ID
+                          Nango workspace connection for API delivery
+  --provider-config-key KEY
+                          Nango integration/provider key
+  --action-name NAME      Nango action; use --proxy-path PATH for proxy mode
   --json                  Machine-readable output
 `,
   run: `signaliz ops run <op_id> [options]
 
 Run a created Op immediately.
+
+Options:
+  --force                 Force a run when supported
+  --instruction TEXT      Optional run instruction
+  --wait                  Poll status and fetch results after queueing
+  --interval-ms N         Polling interval for --wait, default 5000
+  --max-polls N           Polling limit for --wait, default 12, max 30
+  --timeout-ms N          Total wait timeout for --wait, default 60000
+  --limit N               Result rows to return after terminal status
+  --no-results            Stop after final status without fetching results
+  --json                  Machine-readable output
 `,
   status: `signaliz ops status <op_id> [options]
 
@@ -1887,6 +2207,51 @@ Options:
   --cursor ID             Pagination cursor
   --include-failed-runs   Include failed run output when supported
   --json                  Machine-readable output
+`,
+  wait: `signaliz ops wait <op_id> [options]
+
+Poll Op status until it completes, blocks, fails, or needs action, then fetch
+the latest results automatically.
+
+Options:
+  --interval-ms N         Polling interval, default 5000
+  --max-polls N           Polling limit, default 12, max 30
+  --timeout-ms N          Total wait timeout, default 60000
+  --limit N               Result rows to return after terminal status
+  --include-failed-runs   Include failed run output when fetching results
+  --no-results            Only wait for terminal status; do not fetch results
+  --json                  Machine-readable output
+`,
+  nango: `signaliz ops nango <flow|search|connect|tools|call|proof|schedule|result> [options]
+
+Connect and operate customer-owned vendor APIs through Nango from the Ops
+namespace. This is the Ops-first route for "connect to any tool, do the work,
+and get the result" flows.
+
+Examples:
+  signaliz ops nango search hubspot
+  signaliz ops nango connect --provider-id hubspot
+  signaliz ops nango tools --workspace-connection-id <id> --provider-config-key hubspot
+  signaliz ops nango call upsert-contact --workspace-connection-id <id> --input-json '{"email":"buyer@example.com"}' --dry-run
+  signaliz ops nango call --workspace-connection-id <id> --proxy-path /v2/leads/list --method GET --dry-run
+  signaliz ops nango call upsert-contact --workspace-connection-id <id> --input-json '{"email":"buyer@example.com"}' --execute --confirm --wait
+  signaliz ops nango proof --json
+  signaliz ops nango proof --workspace-connection-id <id> --read-proxy-path /v2/accounts --execute-read-probe --confirm
+  signaliz ops nango proof --workspace-connection-id <id> --write-proxy-path /v2/custom-tags --method POST --write-input-json '{"label":"safe-proof"}' --execute-write-probe --confirm-write
+  signaliz ops nango schedule "Monitor accounts daily and upsert approved rows" --workspace-connection-id <id> --provider-config-key hubspot --action-name upsert-contact --confirm-spend --wait
+  signaliz ops nango result --status-url /action/<action_id>
+
+Subcommands:
+  flow|search             Prepare provider search, connect, action, and Ops route calls
+  connect                 Start Nango Connect auth for a provider
+  tools                   List Nango action tools for a workspace connection
+  call <action>           Dry-run by default; add --execute --confirm for approved writes, --wait for result readback
+                          accepts --proxy-path for direct Nango proxy mode
+  proof|audit|read-write  Audit connected Nango rows, tools, proxy readiness, and optional live read/write probes
+                          accepts --read-proxy-path, --write-proxy-path, --execute-read-probe, --execute-write-probe
+  schedule|recur PROMPT   Create a recurring Nango-backed Op through ops_nango_schedule; --wait uses ops_nango_schedule_and_wait
+                          accepts --input-json/--input-file, --field-map-json, and --required-fields
+  result                  Poll async Nango action result
 `
 };
 function opsHelpFor(sub) {
@@ -1901,7 +2266,7 @@ Canonical path:
   signaliz ops results <op_id>
 
 Common commands:
-  proof, autopilot, plan, execute, create, run, status, results, doctor, connections
+  proof, autopilot, plan, execute, create, schedule, run, status, results, wait, nango, doctor, connections
 
 Run: signaliz ops help <command>
 `;
@@ -1932,6 +2297,13 @@ Options:
   --outputs json,csv      Delivery outputs, default json
   --dry-run               Validate and plan without launching spendful work
   --allow-downscale       Allow oversized target counts to be clamped
+  --learning-holdout      Assign explicit control vs learned cohorts
+  --holdout-control-percentage N
+                          Control share, e.g. 0.2 or 20 for 20%
+  --holdout-min-control-size N
+                          Minimum control rows for large builds, default 50
+  --holdout-experiment-key KEY
+                          Stable experiment key for feedback attribution
   --confirm-spend         Acknowledge spendful generation
   --input-file FILE       JSON config file from campaign scope or gtm prepare-build
   --wait                  Poll until completion
@@ -1953,12 +2325,22 @@ Options:
   --cursor ID             Pagination cursor
   --qualified             Only qualified rows
   --disqualified          Only disqualified rows
+  --include-data          Include rich row data such as generated copy
+  --include-raw           Include raw provider/qualification payloads
   --all                   Dump all rows
   --json                  Machine-readable output
 `,
   artifacts: `signaliz campaign artifacts <campaign_build_id> [options]
 
 List generated artifacts and signed download URLs.
+`,
+  download: `signaliz campaign download <campaign_build_id> [options]
+
+Generate fresh signed URLs for a downloadable artifact.
+
+Options:
+  --format csv|ndjson     Artifact format, default csv
+  --json                  Machine-readable output
 `,
   approve: `signaliz campaign approve <campaign_build_id> --destination-type <json|csv|webhook>
 
@@ -1979,9 +2361,10 @@ Canonical path:
   signaliz campaign build --prompt "VP Sales at B2B SaaS" --confirm-spend --wait
   signaliz campaign rows <campaign_build_id> --limit 100
   signaliz campaign artifacts <campaign_build_id>
+  signaliz campaign download <campaign_build_id> --format csv
 
 Commands:
-  scope, build, status, rows, artifacts, approve, cancel
+  scope, build, status, rows, artifacts, download, approve, cancel
 
 Run: signaliz campaign help <command>
 `;
@@ -2394,20 +2777,20 @@ function aiAttachmentsFromFlags() {
 }
 async function ai(sub, rest) {
   if (sub !== "multi-model" && sub !== "multimodel") {
-    die('Usage: signaliz ai multi-model --prompt "..." --model provider/model --confirm-spend');
+    die('Usage: signaliz ai multi-model --prompt "..." --confirm-spend');
+  }
+  if (flagArg("model") !== void 0 || hasFlag("model") || flagArg("analysis-models") !== void 0 || hasFlag("analysis-models") || flagArg("judge-model") !== void 0 || hasFlag("judge-model")) {
+    die("Custom AI model selection is no longer supported. Signaliz-hosted custom AI uses the default model and returns model readback metadata.");
   }
   const promptText = promptArg(rest);
-  const model = flagArg("model");
-  if (!promptText) die('Usage: signaliz ai multi-model --prompt "..." --model provider/model --confirm-spend');
-  if (!model) die("--model is required. Use an OpenRouter id such as google/gemini-2.5-flash.");
+  if (!promptText) die('Usage: signaliz ai multi-model --prompt "..." --confirm-spend');
   if (!hasFlag("confirm-spend")) {
-    die("This uses OpenRouter Fusion and can spend credits. Re-run with --confirm-spend to approve.");
+    die("This runs custom AI enrichment and can spend credits. Re-run with --confirm-spend to approve.");
   }
   const sdk = getSdk();
   const records = aiRecordsFromFlags();
   const result = await sdk.ai.multiModel({
     prompt: promptText,
-    model,
     records,
     systemPrompt: flagArg("system-prompt"),
     temperature: numberFlag("temperature"),
@@ -2418,15 +2801,12 @@ async function ai(sub, rest) {
     attachmentFields: csvFlag("attachment-fields") || csvFlag("attachment-field"),
     pdfEngine: flagArg("pdf-engine"),
     fusion: {
-      required: !hasFlag("no-require-fusion"),
-      analysis_models: csvFlag("analysis-models"),
-      judge_model: flagArg("judge-model"),
       include_raw_analysis: hasFlag("include-raw-analysis")
     }
   });
   return output(result, () => {
     console.log("Custom AI Enrichment - Multi Model complete");
-    console.log(`  Model:       ${result.model || model}`);
+    console.log(`  Model:       ${result.model || "google/gemini-2.5-flash"}`);
     console.log(`  Records:     ${result.results.length}`);
     console.log(`  Credits:     ${result.creditsUsed}`);
     console.log(`  Attachments: ${result.multimodalCount}`);
@@ -2462,6 +2842,16 @@ async function campaignBuild() {
     if (hasFlag("dry-run")) config.dryRun = true;
     if (hasFlag("allow-downscale")) config.allowDownscale = true;
     if (hasFlag("confirm-spend")) config.confirmSpend = true;
+    if (hasFlag("learning-holdout") || flagArg("holdout-control-percentage") || flagArg("holdout-min-control-size") || flagArg("holdout-experiment-key")) {
+      config.learningHoldout = {
+        enabled: true,
+        controlPercentage: numberFlag("holdout-control-percentage") ?? 0.2,
+        minControlSize: numberFlag("holdout-min-control-size") ?? 50,
+        experimentKey: flagArg("holdout-experiment-key") || void 0,
+        sourceCampaignId: flagArg("holdout-source-campaign-id") || void 0,
+        primaryMetric: flagArg("holdout-primary-metric") || void 0
+      };
+    }
     const outputs = (flagArg("outputs") || "json").split(",").map((s) => s.trim());
     const webhookUrl = flagArg("webhook-url");
     if (outputs.includes("csv") || outputs.includes("webhook") || webhookUrl) {
@@ -2504,6 +2894,7 @@ async function campaignBuild() {
       console.log(`  Planned:   ${result.plannedTargetCount ?? result.requestedTargetCount ?? config.targetCount ?? 50} leads`);
       if (result.estimatedCredits !== void 0) console.log(`  Credits:   ~${result.estimatedCredits}`);
       if (result.estimatedDurationSeconds !== void 0) console.log(`  Duration:  ~${result.estimatedDurationSeconds}s`);
+      if (result.learningHoldout?.enabled) console.log(`  Holdout:   enabled (${Math.round(Number(result.learningHoldout.control_percentage || 0) * 100)}% control)`);
       if (result.targetLimitApplied) console.log(`  Note:      ${result.targetLimitReason || "target count downscaled"}`);
       hint("Remove --dry-run and add --confirm-spend when ready to launch.");
     });
@@ -2517,6 +2908,7 @@ async function campaignBuild() {
       console.log(`  Status:      ${result.status}`);
       console.log(`  Phase:       ${result.currentPhase}`);
       console.log(`  Target:      ${config.targetCount || 50} leads`);
+      if (result.learningHoldout?.enabled) console.log(`  Holdout:     enabled (${Math.round(Number(result.learningHoldout.control_percentage || 0) * 100)}% control)`);
       hint(`signaliz campaign status ${result.campaignBuildId}`);
     });
   }
@@ -2546,6 +2938,7 @@ async function campaignBuild() {
 \u2713 Build ${finalStatus.status}`);
       console.log(`  Rows: ${finalStatus.recordsSucceeded}/${finalStatus.recordsTotal} succeeded`);
       console.log(`  Artifacts: ${finalStatus.artifactCount}`);
+      printCampaignArtifactDownloadHint(finalStatus, result.campaignBuildId);
       if (finalStatus.status === "completed") {
         hint(`signaliz campaign rows ${result.campaignBuildId} --limit 100`);
       }
@@ -2589,6 +2982,35 @@ async function campaignScope() {
     hint("Next: run signaliz campaign build --input-file with the buildCampaignArgs JSON, or call build_campaign with the returned dry-run args.");
   });
 }
+function campaignArtifactDownloads(status) {
+  const downloads = Array.isArray(status?.artifactDownloads) ? status.artifactDownloads : Array.isArray(status?.artifact_downloads) ? status.artifact_downloads : [];
+  return downloads.map(record);
+}
+function campaignArtifactDownloadUrl(download) {
+  const url = download.downloadUrl || download.download_url || download.signedUrl || download.signed_url;
+  return typeof url === "string" && url.trim() ? url.trim() : null;
+}
+function campaignPreferredArtifactDownload(status) {
+  const downloads = campaignArtifactDownloads(status);
+  if (downloads.length === 0) return null;
+  return downloads.find((download) => {
+    const format = String(download.format || download.artifactType || download.artifact_type || "").toLowerCase();
+    return format === "csv";
+  }) || downloads[0];
+}
+function printCampaignArtifactDownloadHint(status, buildId) {
+  const download = campaignPreferredArtifactDownload(status);
+  const url = download ? campaignArtifactDownloadUrl(download) : null;
+  if (url) {
+    const format = String(download?.format || download?.artifactType || download?.artifact_type || "artifact");
+    const rowCount = Number(download?.rowCount ?? download?.row_count ?? 0);
+    console.log(`Download: ${format}${rowCount > 0 ? `, ${rowCount} rows` : ""}`);
+    console.log(`  ${url}`);
+    return;
+  }
+  const artifactCount = Number(status?.artifactCount ?? status?.artifact_count ?? 0);
+  if (artifactCount > 0) hint(`signaliz campaign download ${buildId} --format csv`);
+}
 async function campaignStatus() {
   const buildId = positionalAfter("status") || flagArg("campaign-build-id");
   if (!buildId) die("Usage: signaliz campaign status <campaign_build_id>");
@@ -2600,7 +3022,9 @@ async function campaignStatus() {
     console.log(`Status:   ${status.status}`);
     console.log(`Phase:    ${status.currentPhase || "N/A"}`);
     console.log(`Rows:     ${status.recordsSucceeded}/${status.recordsTotal} succeeded, ${status.recordsFailed} failed`);
+    printCampaignCustomerRowCounts(status);
     console.log(`Artifacts: ${status.artifactCount}`);
+    printCampaignArtifactDownloadHint(status, buildId);
     if (status.triggerRunId) console.log(`Trigger:  ${status.triggerRunId}`);
     if (status.staleRunningPhase) {
       const age = typeof status.phaseAgeSeconds === "number" ? `${status.phaseAgeSeconds}s` : "unknown age";
@@ -2614,12 +3038,18 @@ async function campaignStatus() {
       console.log(`Errors:   ${status.errors.length}`);
       for (const error of status.errors.slice(0, 3)) console.log(`  - ${error}`);
     }
-    if (status.status === "completed") {
+    if (status.status === "completed" && status.nextAction) {
+      hint(status.nextAction);
+    } else 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" && status.approvalAction) {
+      hint(status.approvalAction);
+    } else if (status.status === "pending_approval" && status.nextAction) {
+      hint(status.nextAction);
     } else if (status.status === "pending_approval") {
       hint(`signaliz campaign approve ${buildId} --destination-type webhook`);
     } else if (status.status === "failed" && status.nextAction) {
@@ -2627,6 +3057,22 @@ async function campaignStatus() {
     }
   });
 }
+function printCampaignCustomerRowCounts(status) {
+  const counts = status?.customerRowCounts || status?.customer_row_counts;
+  if (!counts || typeof counts !== "object") return;
+  const value = (camel, snake) => counts[camel] ?? counts[snake] ?? "n/a";
+  const requested = value("requestedTarget", "requested_target");
+  console.log(`Customer rows: accepted ${value("acceptedRows", "accepted_rows")}/${requested}, copied ${value("copiedRows", "copied_rows")}, approval-ready ${value("approvalReadyRows", "approval_ready_rows")}, QA-ready ${value("qaReadyRows", "qa_ready_rows")}, delivered ${value("deliveredRows", "delivered_rows")}`);
+  const shortfalls = [
+    ["accepted", value("acceptedShortfall", "accepted_shortfall")],
+    ["usable", value("usableShortfall", "usable_shortfall")],
+    ["QA-ready", value("qaReadyShortfall", "qa_ready_shortfall")],
+    ["delivery", value("deliveryShortfall", "delivery_shortfall")]
+  ].filter(([, count]) => typeof count === "number" && count > 0);
+  if (shortfalls.length > 0) {
+    console.log(`Shortfalls: ${shortfalls.map(([label, count]) => `${label} ${count}`).join(", ")}`);
+  }
+}
 async function campaignRows() {
   const buildId = positionalAfter("rows") || flagArg("campaign-build-id");
   if (!buildId) die("Usage: signaliz campaign rows <campaign_build_id>");
@@ -2641,6 +3087,8 @@ async function campaignRows() {
     do {
       const opts = { limit: Math.min(limit, 500) };
       if (nextCursor) opts.cursor = nextCursor;
+      if (hasFlag("include-data")) opts.includeData = true;
+      if (hasFlag("include-raw")) opts.includeRaw = true;
       const segment = flagArg("segment");
       if (segment) opts.segment = segment;
       const rowStatus = flagArg("row-status");
@@ -2665,6 +3113,8 @@ async function campaignRows() {
   } else {
     const opts = { limit: Math.min(limit, 500) };
     if (cursor) opts.cursor = cursor;
+    if (hasFlag("include-data")) opts.includeData = true;
+    if (hasFlag("include-raw")) opts.includeRaw = true;
     const segment = flagArg("segment");
     if (segment) opts.segment = segment;
     const rowStatus = flagArg("row-status");
@@ -2690,6 +3140,7 @@ async function campaignRows() {
         status: r.status || "",
         score: r.score ?? ""
       })));
+      printCampaignCopySnippets(operatorResult.rows);
       console.log(`
 Showing ${operatorResult.rows.length} row(s)${operatorResult.hasMore ? " (more available)" : ""}`);
       if (operatorResult.nextCursor) {
@@ -2702,14 +3153,15 @@ function formatCampaignRowsForOperator(rows) {
   return rows.map((row) => {
     const rowRecord = record(row);
     const data = record(rowRecord.data);
+    const copyData = record(data.copy);
     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
+      subject: data.subject || copyData.subject || rawCopy.subject || null,
+      opener: data.opener || copyData.opener || rawCopy.opener || null,
+      body: data.body || copyData.body || rawCopy.body || null,
+      cta: data.cta || copyData.cta || rawCopy.cta || null,
+      engine: data.copy_engine || copyData.engine || rawCopy.engine || null,
+      model: data.copy_model || copyData.model || null
     };
     return {
       ...rowRecord,
@@ -2739,6 +3191,26 @@ function formatCampaignRowsForOperator(rows) {
     };
   });
 }
+function printCampaignCopySnippets(rows, limit = 5) {
+  const rowsWithCopy = rows.filter((row) => {
+    const copy = record(row.copy);
+    return Boolean(copy.subject || copy.opener || copy.body || copy.cta);
+  });
+  if (rowsWithCopy.length === 0) return;
+  console.log("\nCopy:");
+  for (const row of rowsWithCopy.slice(0, limit)) {
+    const copy = record(row.copy);
+    const label = row.email || row.name || row.company || `row ${row.index ?? ""}`.toString().trim();
+    console.log(`- ${label}`);
+    if (copy.subject) console.log(`  Subject: ${copy.subject}`);
+    if (copy.opener) console.log(`  Opener: ${copy.opener}`);
+    if (copy.body) console.log(`  Body: ${copy.body}`);
+    if (copy.cta) console.log(`  CTA: ${copy.cta}`);
+  }
+  if (rowsWithCopy.length > limit) {
+    console.log(`  ...${rowsWithCopy.length - limit} more row(s) with copy`);
+  }
+}
 async function campaignArtifacts() {
   const buildId = positionalAfter("artifacts") || flagArg("campaign-build-id");
   if (!buildId) die("Usage: signaliz campaign artifacts <campaign_build_id>");
@@ -2756,6 +3228,24 @@ async function campaignArtifacts() {
     }
   });
 }
+async function campaignDownload() {
+  const buildId = positionalAfter("download") || flagArg("campaign-build-id");
+  if (!buildId) die("Usage: signaliz campaign download <campaign_build_id> [--format csv|ndjson]");
+  const sdk = getSdk();
+  const format = flagArg("format") || "csv";
+  const result = await sdk.campaigns.downloadCampaignArtifact(buildId, { format });
+  output(result, () => {
+    console.log(`Artifact: ${result.format} (${result.rowCount} rows)`);
+    if (result.partCount > 1) console.log(`Parts:    ${result.partCount}`);
+    const parts = Array.isArray(result.parts) ? result.parts : [];
+    for (const part of parts) {
+      const url = part.signedUrl;
+      if (!url) continue;
+      const label = result.partCount > 1 ? `part ${part.partIndex}` : "download";
+      console.log(`${label}: ${url}`);
+    }
+  });
+}
 async function campaignApprove() {
   const buildId = positionalAfter("approve") || positionalAfter("approve-delivery") || flagArg("campaign-build-id");
   if (!buildId) die("Usage: signaliz campaign approve <campaign_build_id> --destination-type <json|csv|webhook>");
@@ -2811,6 +3301,8 @@ async function campaign(sub) {
       return campaignRows();
     case "artifacts":
       return campaignArtifacts();
+    case "download":
+      return campaignDownload();
     case "approve":
     case "approve-delivery":
       return campaignApprove();
@@ -2818,7 +3310,7 @@ async function campaign(sub) {
       return campaignCancel();
     default:
       die(`Unknown campaign subcommand: ${sub}
-Available: scope, build, status, rows, artifacts, approve, cancel`);
+Available: scope, build, status, rows, artifacts, download, approve, cancel`);
   }
 }
 var CAMPAIGN_AGENT_APPROVAL_TYPES = [
@@ -2864,9 +3356,9 @@ Examples:
   signaliz campaign-agent dry-run --goal "Build a local services campaign" --target-count 250 --use-local-leads --json
   signaliz campaign-agent build-approved --goal "Build a strategy-template campaign" --confirm-launch --approve-all --approved-by operator@example.com --spend-limit 500
   signaliz campaign-agent build-approved --request-file campaign-builder-agent-request.json --confirm-launch --approve-all --approved-by operator@example.com --spend-limit 500 --wait --approve-delivery --delivery-destination-type json
-  signaliz campaign-agent review <campaign_build_id> --limit 100 --json
+  signaliz campaign-agent review <campaign_build_id> --limit 100 --include-data --json
   signaliz campaign-agent status <campaign_build_id> --json
-  signaliz campaign-agent rows <campaign_build_id> --limit 100 --json
+  signaliz campaign-agent rows <campaign_build_id> --limit 100 --include-data --json
 
 Plan options:
   --goal TEXT             Campaign goal or brief
@@ -2874,7 +3366,7 @@ Plan options:
   --kit-file FILE         Write campaign-agent kit output to a JSON file
   --seed-manifest-file FILE
                           Manifest path for memory-kit seed dry-runs
-  --source NAME           memory-kit seed source: agency, workflow-patterns, instantly-feedback, or all
+  --source NAME           memory-kit seed source: north-star, agency, workflow-patterns, instantly-feedback, or all
   --request-output-file FILE
                           Request filename to reference inside kit commands
   --request-file FILE     Reusable JSON CampaignBuilderAgentRequest; flags override file fields
@@ -3118,6 +3610,8 @@ async function campaignAgentReview(sub, rest) {
       cursor: commandStringFlag(flags, "cursor"),
       segment: commandStringFlag(flags, "segment"),
       rowStatus: commandStringFlag(flags, "row-status"),
+      includeData: commandOptionalBooleanFlag(flags, "include-data"),
+      includeRaw: commandOptionalBooleanFlag(flags, "include-raw"),
       qualified: commandBooleanFlag(flags, "qualified") ? true : commandBooleanFlag(flags, "disqualified") ? false : void 0
     };
     const review = await agent.reviewBuild?.(buildId, rowOptions) || await campaignAgentBuildReviewFromCampaignApis(agent, campaigns, buildId, rowOptions);
@@ -3141,6 +3635,8 @@ async function campaignAgentReview(sub, rest) {
       cursor: commandStringFlag(flags, "cursor"),
       segment: commandStringFlag(flags, "segment"),
       rowStatus: commandStringFlag(flags, "row-status"),
+      includeData: commandOptionalBooleanFlag(flags, "include-data"),
+      includeRaw: commandOptionalBooleanFlag(flags, "include-raw"),
       qualified: commandBooleanFlag(flags, "qualified") ? true : commandBooleanFlag(flags, "disqualified") ? false : void 0
     };
     const result2 = await (agent.getBuildRows?.bind(agent) || campaigns.rows?.bind(campaigns) || campaigns.getCampaignBuildRows?.bind(campaigns))?.(buildId, rowOptions);
@@ -3732,7 +4228,9 @@ function printCampaignAgentBuildStatus(status) {
   console.log(`Status:   ${status.status}`);
   console.log(`Phase:    ${status.currentPhase || "N/A"}`);
   console.log(`Rows:     ${status.recordsSucceeded}/${status.recordsTotal} succeeded, ${status.recordsFailed} failed`);
+  printCampaignCustomerRowCounts(status);
   console.log(`Artifacts: ${status.artifactCount}`);
+  if (status.campaignBuildId) printCampaignArtifactDownloadHint(status, status.campaignBuildId);
   if (status.triggerRunId) console.log(`Trigger:  ${status.triggerRunId}`);
   if (Array.isArray(status.warnings) && status.warnings.length) {
     console.log(`Warnings: ${status.warnings.length}`);
@@ -3742,8 +4240,14 @@ function printCampaignAgentBuildStatus(status) {
     console.log(`Errors:   ${status.errors.length}`);
     for (const error of status.errors.slice(0, 3)) console.log(`  - ${error}`);
   }
-  if (status.status === "completed") {
+  if (status.status === "completed" && status.nextAction) {
+    hint(status.nextAction);
+  } else if (status.status === "completed") {
     hint(`signaliz campaign-agent rows ${status.campaignBuildId} --limit 100`);
+  } else if (status.status === "pending_approval" && status.approvalAction) {
+    hint(status.approvalAction);
+  } else if (status.status === "pending_approval" && status.nextAction) {
+    hint(status.nextAction);
   } else if (status.status === "pending_approval") {
     hint(`signaliz campaign-agent approve ${status.campaignBuildId} --destination-type webhook`);
   } else if ((status.status === "running" || status.status === "queued") && status.triggerRunId) {
@@ -3761,6 +4265,7 @@ function printCampaignAgentBuildReview(review) {
   console.log(`Emails:    ${summary.rowsWithEmail || 0}`);
   console.log(`Copy ready: ${summary.copyReadyRows || 0}`);
   console.log(`Artifacts: ${summary.artifactCount || 0}`);
+  if (review.campaignBuildId) printCampaignArtifactDownloadHint(status, review.campaignBuildId);
   console.log(`Delivery approval ready: ${summary.readyForDeliveryApproval === true ? "yes" : "no"}`);
   const gates = Array.isArray(review.gates) ? review.gates : [];
   if (gates.length) {
@@ -3898,6 +4403,7 @@ function printCampaignAgentRows(result) {
     status: row.status || "",
     score: row.score ?? ""
   })));
+  printCampaignCopySnippets(result.rows);
   console.log(`
 Showing ${result.rows.length} row(s)${result.hasMore ? " (more available)" : ""}`);
   if (result.nextCursor) {
@@ -4690,6 +5196,7 @@ async function gtm(sub, rest) {
       days: numberFlag("days"),
       networkDays: numberFlag("network-days"),
       minSampleSize: numberFlag("min-sample-size"),
+      holdoutMinSampleSize: numberFlag("holdout-min-sample-size"),
       minWorkspaceCount: numberFlag("min-workspace-count"),
       limit: numberFlag("limit")
     });
@@ -4700,6 +5207,10 @@ async function gtm(sub, rest) {
       console.log("GTM Brain learning plan");
       console.log(`  Campaign: ${campaignId}`);
       console.log(`  Lanes:    ${ready}/${lanes.length} ready`);
+      if (result.holdout_lift?.status) {
+        const delta = result.holdout_lift?.lift?.primary_metric_delta;
+        console.log(`  Holdout:  ${result.holdout_lift.status}${delta !== void 0 ? ` (${delta} ${result.holdout_lift.primary_metric || "primary_metric"})` : ""}`);
+      }
       console.log(`  Calls:    ${calls.length}`);
       for (const call of calls.slice(0, 5)) {
         const state = call.ready === false ? "blocked" : "ready";
@@ -4721,6 +5232,7 @@ async function gtm(sub, rest) {
       days: numberFlag("days"),
       networkDays: numberFlag("network-days"),
       minSampleSize: numberFlag("min-sample-size"),
+      holdoutMinSampleSize: numberFlag("holdout-min-sample-size"),
       minWorkspaceCount: numberFlag("min-workspace-count"),
       minPrivacyK: numberFlag("min-privacy-k"),
       limit: numberFlag("limit")
@@ -4974,6 +5486,103 @@ async function gtm(sub, rest) {
       hint(`signaliz gtm bootstrap${common.campaignId ? ` --campaign-id ${common.campaignId}` : ""} --include-samples`);
     });
   }
+  if (sub === "feedback-pull" || sub === "instantly-feedback-pull" || sub === "pull-feedback") {
+    const provider = (flagArg("provider") || "instantly").toLowerCase();
+    if (provider !== "instantly") {
+      die("gtm feedback-pull currently supports --provider instantly. Use gtm feedback-webhook for provider-agnostic ingress.");
+    }
+    const source = flagArg("source") || flagArg("pull-source") || "webhook_events";
+    if (!["webhook_events", "emails"].includes(source)) {
+      die("--source must be webhook_events or emails");
+    }
+    if (flagArg("source") && flagArg("pull-source") && flagArg("source") !== flagArg("pull-source")) {
+      die("--source and --pull-source must match when both are provided");
+    }
+    const campaignId = flagArg("campaign-id");
+    const campaignBuildId = flagArg("campaign-build-id") || flagArg("build-id");
+    const providerLinkId = flagArg("provider-link-id");
+    const providerCampaignId = flagArg("provider-campaign-id") || flagArg("instantly-campaign-id") || positionalAfter(sub);
+    if (!campaignId && !campaignBuildId && !providerLinkId && !providerCampaignId) {
+      die("Usage: signaliz gtm feedback-pull --provider-campaign-id <instantly_campaign_id> [--source webhook_events|emails] [--confirm]");
+    }
+    const hasEmailHistoryFlags = Boolean(flagArg("email-type") || flagArg("mode") || flagArg("sort-order"));
+    if (hasEmailHistoryFlags && source !== "emails") {
+      die("--email-type, --mode, and --sort-order require --source emails");
+    }
+    const emailType = source === "emails" ? flagArg("email-type") || "received" : void 0;
+    if (emailType !== void 0 && !["received", "sent", "manual"].includes(emailType)) {
+      die("--email-type must be received, sent, or manual");
+    }
+    const mode = source === "emails" ? flagArg("mode") || "emode_all" : void 0;
+    if (mode !== void 0 && !["emode_focused", "emode_others", "emode_all"].includes(mode)) {
+      die("--mode must be emode_focused, emode_others, or emode_all");
+    }
+    const sortOrder = source === "emails" ? flagArg("sort-order") || "asc" : void 0;
+    if (sortOrder !== void 0 && !["asc", "desc"].includes(sortOrder)) {
+      die("--sort-order must be asc or desc");
+    }
+    if (hasFlag("write") && !hasFlag("confirm") && !hasFlag("confirm-write")) {
+      die("Write-mode feedback pulls require --confirm or --confirm-write. Run without --confirm first for a dry-run count.");
+    }
+    const confirmed = hasFlag("confirm") || hasFlag("confirm-write");
+    const dryRun = !confirmed;
+    const result = await sdk.gtm.pullInstantlyFeedback({
+      campaignId,
+      campaignBuildId,
+      providerLinkId,
+      providerCampaignId,
+      instantlyCampaignId: flagArg("instantly-campaign-id"),
+      integrationId: flagArg("integration-id"),
+      source,
+      instantlyProfile: flagArg("instantly-profile") || flagArg("profile"),
+      cursor: flagArg("cursor"),
+      from: flagArg("from") || flagArg("since"),
+      to: flagArg("to") || flagArg("until"),
+      limit: numberFlag("limit"),
+      maxPages: numberFlag("max-pages"),
+      emailType,
+      mode,
+      sortOrder,
+      createMemory: !hasFlag("no-memory"),
+      writeRoutineOutcomes: !hasFlag("no-routine-outcomes"),
+      dryRun,
+      runBrainCycle: !hasFlag("no-brain-cycle"),
+      brainCycleWriteMode: flagArg("write-mode") || "dry_run",
+      brainCyclePhases: csvFlag("brain-cycle-phases"),
+      brainCycleMinIngested: numberFlag("brain-cycle-min-ingested"),
+      brainCycleMinIntervalMinutes: numberFlag("brain-cycle-min-interval-minutes")
+    });
+    return output(result, () => {
+      console.log("GTM Instantly feedback pull");
+      console.log(`  Mode:     ${dryRun ? "dry_run" : "write"}`);
+      console.log(`  Source:   ${result.source || source}`);
+      if (result.provider_campaign_id || providerCampaignId) console.log(`  Campaign: ${result.provider_campaign_id || providerCampaignId}`);
+      if (result.run_id) console.log(`  Run ID:   ${result.run_id}`);
+      if (result.status) console.log(`  Status:   ${result.status}`);
+      if (result.max_pages !== void 0) console.log(`  Pages:    ${result.max_pages}`);
+      const countFields = [
+        ["Seen", result.webhook_events_seen ?? result.email_records_seen ?? result.source_events],
+        ["Normalized", result.feedback_events_synced ?? result.events_normalized],
+        ["Ingested", result.ingested],
+        ["Duplicates", result.duplicates],
+        ["Unmatched", result.unmatched]
+      ];
+      for (const [label, value] of countFields) {
+        if (value !== void 0 && value !== null) console.log(`  ${label}: ${value}`);
+      }
+      if (Array.isArray(result.blockers) && result.blockers.length) console.log(`  Blockers: ${result.blockers.join("; ")}`);
+      if (dryRun) {
+        if (result.run_id) hint(`signaliz ops run-status ${result.run_id} --watch`);
+        hint("Review the dry-run counts before writing feedback, memory, and outcomes: rerun with --confirm.");
+      } else if (campaignId) {
+        hint(`signaliz gtm learning ${campaignId} --include-network`);
+      } else if (campaignBuildId) {
+        hint(`signaliz gtm execution --campaign-build-id ${campaignBuildId}`);
+      } else {
+        hint("After the pull completes, run signaliz gtm bootstrap --include-samples to verify feedback and memory readiness.");
+      }
+    });
+  }
   if (sub === "nango") return gtmNango(rest[0], rest.slice(1));
   if (!sub || sub === "list" || sub === "sources") {
     const result = await sdk.leads.listNativeGtmCapabilities(flagArg("category"));
@@ -5034,7 +5643,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|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>");
+  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|feedback-webhook|feedback-pull|list|find|run|status|nango>");
 }
 function nangoActionInput() {
   const fromFile = readJsonFlag("input-file");
@@ -5051,30 +5660,146 @@ function nangoBaseOptions() {
     nangoConnectionId: flagArg("nango-connection-id")
   };
 }
-function nangoConnectOptions() {
+function nangoConnectOptions(defaultSurface = "gtm_kernel") {
   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",
+    surface: flagArg("surface") || defaultSurface,
     source: flagArg("source") || "signaliz_cli",
     userEmail: flagArg("user-email"),
     userDisplayName: flagArg("user-display-name")
   };
 }
+function nangoPositionalValues(rest = []) {
+  const values = [];
+  for (let index = 0; index < rest.length; index++) {
+    const value = rest[index];
+    if (value.startsWith("--")) {
+      if (!value.includes("=") && rest[index + 1] && !rest[index + 1].startsWith("--")) index++;
+      continue;
+    }
+    values.push(value);
+  }
+  return values;
+}
+function nangoFlowOptions(rest = []) {
+  const positionalSearch = nangoPositionalValues(rest).join(" ");
+  const search = flagArg("search") || flagArg("query") || positionalSearch || void 0;
+  return {
+    ...nangoBaseOptions(),
+    query: flagArg("query"),
+    search,
+    providerId: flagArg("provider-id") || flagArg("provider"),
+    provider: flagArg("provider"),
+    intent: flagArg("intent"),
+    actionName: flagArg("action-name") || flagArg("action"),
+    toolName: flagArg("tool-name"),
+    proxyPath: flagArg("proxy-path") || flagArg("nango-proxy-path"),
+    method: flagArg("method"),
+    input: nangoActionInput(),
+    cadence: flagArg("cadence"),
+    fieldMap: readInlineJsonFlag("field-map-json") || readJsonFlag("field-map-file"),
+    requiredFields: csvFlag("required-fields") || csvFlag("required-field"),
+    confirmSpend: hasFlag("confirm-spend"),
+    writeConfirmed: hasFlag("write-confirmed") || hasFlag("confirm-write") || void 0,
+    layer: flagArg("layer"),
+    campaignId: flagArg("campaign-id"),
+    limit: numberFlag("limit"),
+    includeProviderCatalog: hasFlag("skip-provider-catalog") ? false : hasFlag("include-provider-catalog") ? true : void 0
+  };
+}
 function nangoStatusUrl(result) {
   return result?.status_url || result?.statusUrl || result?.nango_result?.status_url || result?.nango_result?.statusUrl;
 }
-async function gtmNango(sub, rest) {
+function nangoActionId(result) {
+  return result?.action_id || result?.actionId || result?.nango_result?.action_id || result?.nango_result?.actionId || result?.nango_result?.id;
+}
+function nangoActionStatus(result) {
+  return result?.status || result?.nango_result?.status;
+}
+function isTerminalNangoActionStatus(status) {
+  return ["completed", "succeeded", "success", "failed", "error", "cancelled", "canceled"].includes(String(status || "").toLowerCase());
+}
+async function waitForNangoActionResult(nango, call, opts = {}) {
+  const intervalMs = Math.max(250, Number(opts.intervalMs ?? 5e3));
+  const maxPolls = Math.max(1, Math.min(60, Math.trunc(Number(opts.maxPolls ?? 12))));
+  const timeoutMs = Math.max(250, Number(opts.timeoutMs ?? 6e4));
+  let statusUrl = nangoStatusUrl(call);
+  let actionId = nangoActionId(call);
+  let latest = statusUrl || actionId ? void 0 : call;
+  let polls = 0;
+  const startedAt = Date.now();
+  while ((statusUrl || actionId) && polls < maxPolls && Date.now() - startedAt <= timeoutMs) {
+    polls += 1;
+    latest = await nango.getNangoActionResult({ actionId, statusUrl });
+    statusUrl = nangoStatusUrl(latest) || statusUrl;
+    actionId = nangoActionId(latest) || actionId;
+    if (isTerminalNangoActionStatus(nangoActionStatus(latest))) break;
+    if (polls < maxPolls && Date.now() - startedAt < timeoutMs) await sleep(intervalMs);
+  }
+  const status = nangoActionStatus(latest || call);
+  const timedOut = Boolean((statusUrl || actionId) && !isTerminalNangoActionStatus(status) && (polls >= maxPolls || Date.now() - startedAt > timeoutMs));
+  return {
+    call,
+    result: latest,
+    status,
+    action_id: actionId,
+    actionId,
+    status_url: statusUrl,
+    statusUrl,
+    polls,
+    max_polls: maxPolls,
+    maxPolls,
+    interval_ms: intervalMs,
+    intervalMs,
+    timeout_ms: timeoutMs,
+    timeoutMs,
+    timed_out: timedOut,
+    timedOut
+  };
+}
+async function gtmNango(sub, rest, namespace = "gtm") {
   const sdk = getSdk();
+  const nango = namespace === "ops" ? sdk.ops : sdk.gtm;
+  const commandPrefix = namespace === "ops" ? "signaliz ops nango" : "signaliz gtm nango";
+  const defaultSurface = namespace === "ops" ? "ops_destinations" : "gtm_kernel";
+  if (sub === "flow" || sub === "plan" || sub === "prepare" || sub === "search") {
+    const result = await nango.prepareNangoIntegrationFlow(nangoFlowOptions(rest));
+    return output(result, () => {
+      console.log(`Nango integration flow: ${result?.status || "prepared"}`);
+      if (result?.provider_id) console.log(`  Provider: ${result.provider_id}`);
+      if (result?.integration_id) console.log(`  Integration: ${result.integration_id}`);
+      if (result?.selected_connection?.id) console.log(`  Workspace connection: ${result.selected_connection.id}`);
+      const providers = Array.isArray(result?.provider_library?.providers) ? result.provider_library.providers : [];
+      if (providers.length) {
+        console.log("  Provider matches:");
+        for (const provider of providers.slice(0, 5)) console.log(`  - ${provider.name || provider.id} (${provider.id})`);
+      }
+      const connections = Array.isArray(result?.matched_connections) ? result.matched_connections : [];
+      if (connections.length) {
+        console.log("  Saved connections:");
+        for (const connection of connections.slice(0, 5)) {
+          const ready = connection.ready_for_route ? "ready" : connection.needs_attention ? "needs reconnect" : "not ready";
+          console.log(`  - ${connection.connector_name || connection.provider_config_key || connection.id}: ${ready} (${connection.id})`);
+        }
+      }
+      const nextActions = Array.isArray(result?.next_actions) ? result.next_actions : [];
+      if (nextActions.length) {
+        console.log("  Next calls:");
+        for (const action of nextActions.slice(0, 5)) console.log(`  - ${action.tool}: ${action.reason || "next step"}`);
+      }
+      if (result?.next_action) hint(result.next_action);
+    });
+  }
   if (sub === "connect" || sub === "auth" || sub === "authorize") {
-    const options = nangoConnectOptions();
+    const options = nangoConnectOptions(defaultSurface);
     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]");
+      die(`Usage: ${commandPrefix} connect --provider-id <provider> [--integration-id <key>] [--allowed-integrations a,b]`);
     }
-    const result = await sdk.gtm.createNangoConnectSession(options);
+    const result = await nango.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}`);
@@ -5082,11 +5807,11 @@ async function gtmNango(sub, rest) {
       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>");
+      hint(`After authorization finishes, run ${commandPrefix} tools --workspace-connection-id <id> --provider-config-key <key>`);
     });
   }
   if (!sub || sub === "tools" || sub === "list") {
-    const result = await sdk.gtm.listNangoTools({
+    const result = await nango.listNangoTools({
       ...nangoBaseOptions(),
       format: flagArg("format"),
       includeRaw: hasFlag("include-raw")
@@ -5097,39 +5822,153 @@ async function gtmNango(sub, rest) {
       for (const tool of tools2.slice(0, 10)) {
         console.log(`- ${tool.name || tool.action_name || tool.id}: ${tool.description || tool.type || "action"}`);
       }
-      hint(`signaliz gtm nango call <action_name> --workspace-connection-id <id> --input-json '{"email":"buyer@example.com"}' --dry-run`);
+      hint(`${commandPrefix} call <action_name> --workspace-connection-id <id> --input-json '{"email":"buyer@example.com"}' --dry-run`);
+    });
+  }
+  if (namespace === "ops" && (sub === "proof" || sub === "audit" || sub === "read-write")) {
+    const result = await nango.proveNangoReadWrite({
+      ...nangoBaseOptions(),
+      limit: numberFlag("limit"),
+      includeRaw: hasFlag("include-raw"),
+      readProxyPath: flagArg("read-proxy-path") || flagArg("proxy-path"),
+      writeProxyPath: flagArg("write-proxy-path"),
+      method: flagArg("method") || flagArg("http-method"),
+      executeReadProbe: hasFlag("execute-read-probe"),
+      executeWriteProbe: hasFlag("execute-write-probe"),
+      confirm: hasFlag("confirm"),
+      confirmWrite: hasFlag("confirm-write") || hasFlag("confirm"),
+      input: nangoActionInput(),
+      writeInput: readInlineJsonFlag("write-input-json") || readJsonFlag("write-input-file")
+    });
+    return output(result, () => {
+      const summary = result?.summary || {};
+      const connectedRows = summary.connected_connection_rows ?? summary.connection_rows ?? 0;
+      const connectedUnique = summary.connected_unique_connections ?? summary.unique_connections ?? 0;
+      console.log(`Nango proof: ${result?.status || "unknown"}`);
+      console.log(`Connections: ${summary.connection_rows ?? 0} rows / ${summary.unique_connections ?? 0} unique`);
+      console.log(`Connected: ${connectedRows} rows / ${connectedUnique} unique`);
+      console.log(`Reconnect required: ${summary.reconnect_required ?? summary.needs_attention_connection_rows ?? 0}`);
+      console.log(`Action tools: ${summary.action_tools ?? 0}`);
+      console.log(`Runtime reads: ${summary.runtime_read_verified ?? 0}/${connectedRows}`);
+      console.log(`Writes: ${summary.write_verified ?? 0}/${connectedRows}`);
+      if (summary.duplicate_connection_rows) console.log(`Duplicates: ${summary.duplicate_connection_rows}`);
+      if (summary.duplicate_connected_connection_rows) console.log(`Connected duplicates: ${summary.duplicate_connected_connection_rows}`);
+      if (result?.next_action) console.log(`Next: ${result.next_action}`);
+    });
+  }
+  if (namespace === "ops" && (sub === "schedule" || sub === "recur")) {
+    const promptText = promptArg(rest);
+    if (!promptText) {
+      die(`Usage: ${commandPrefix} ${sub} "plain-English recurring goal" --workspace-connection-id <id> --action-name <action> [--confirm-spend] [--wait]`);
+    }
+    const scheduleInput = {
+      prompt: promptText,
+      blueprint: flagArg("blueprint"),
+      targetCount: numberFlag("target-count"),
+      cadence: flagArg("cadence") || "daily",
+      wakeOnEvents: csvFlag("wake-on-events") || csvFlag("wake-events") || csvFlag("wake-event"),
+      timezone: flagArg("timezone"),
+      companyDomains: csvFlag("company-domains") || csvFlag("domains"),
+      customAiPrompt: flagArg("ai-prompt") || flagArg("custom-ai-prompt"),
+      signalPrompt: flagArg("signal-prompt"),
+      outputPrompt: flagArg("output-prompt") || flagArg("result-prompt"),
+      confirmSpend: hasFlag("confirm-spend"),
+      ...nangoBaseOptions(),
+      actionName: flagArg("action-name") || flagArg("action") || flagArg("nango-action"),
+      toolName: flagArg("tool-name"),
+      proxyPath: flagArg("proxy-path") || flagArg("nango-proxy-path"),
+      method: flagArg("method") || flagArg("http-method"),
+      input: nangoActionInput(),
+      fieldMap: readInlineJsonFlag("field-map-json") || readJsonFlag("field-map-file"),
+      requiredFields: csvFlag("required-fields") || csvFlag("required-field"),
+      writeConfirmed: hasFlag("write-confirmed") || hasFlag("confirm") || hasFlag("confirm-write") || void 0,
+      agentWriteConfirmed: hasFlag("agent-write-confirmed") || void 0
+    };
+    if (hasFlag("wait")) {
+      const combined = await nango.scheduleNangoActionAndWait({
+        ...scheduleInput,
+        force: hasFlag("force"),
+        instruction: flagArg("instruction"),
+        intervalMs: numberFlag("interval-ms") ?? numberFlag("wait-interval-ms"),
+        maxPolls: numberFlag("max-polls") ?? numberFlag("wait-max-polls"),
+        timeoutMs: numberFlag("timeout-ms") ?? numberFlag("wait-timeout-ms"),
+        limit: numberFlag("limit"),
+        cursor: flagArg("cursor"),
+        includeFailedRuns: hasFlag("include-failed-runs"),
+        includeResults: !hasFlag("no-results")
+      });
+      return output(combined, () => {
+        console.log(`Nango Op scheduled: ${combined.schedule?.op_id || combined.op_id}`);
+        printOpsWaitForResults(combined);
+      });
+    }
+    const result = await nango.scheduleNangoAction(scheduleInput);
+    return output(result, () => {
+      if (result.approval_required || result.error_code === "APPROVAL_REQUIRED") {
+        console.log("Approval required");
+        if (result.plan) {
+          console.log(`Plan:    ${result.plan.title || result.plan.plan_id || "pending approval"}`);
+          if (result.plan.ui_summary) console.log(`Summary: ${result.plan.ui_summary}`);
+          printPlanSchedule(result.plan);
+          printOpsExecutionContract(result.plan);
+        }
+        console.log(`Next:    ${result.next_action || "Retry with --confirm-spend after review."}`);
+        hint(`${commandPrefix} ${sub} ${JSON.stringify(promptText)} --confirm-spend`);
+        return;
+      }
+      console.log(`Nango Op scheduled: ${result.op_id}`);
+      console.log(`Status:  ${result.status || "scheduled"}`);
+      if (result.plan) printOpsExecutionContract(result.plan);
+      console.log(`Next:    ${result.next_action || "Run or wait for the next scheduled tick."}`);
+      if (result.op_id) hint(`signaliz ops wait ${result.op_id}`);
     });
   }
   if (sub === "call" || sub === "run") {
-    const actionName = rest[0] || flagArg("action-name");
+    const actionName = nangoPositionalValues(rest)[0] || flagArg("action-name");
     const toolName = flagArg("tool-name");
-    if (!actionName && !toolName) {
-      die(`Usage: signaliz gtm nango call <action_name> --workspace-connection-id <id> --input-json '{"email":"buyer@example.com"}' [--execute --confirm]`);
+    const proxyPath = flagArg("proxy-path") || flagArg("nango-proxy-path");
+    if (!actionName && !toolName && !proxyPath) {
+      die(`Usage: ${commandPrefix} call <action_name> --workspace-connection-id <id> --input-json '{"email":"buyer@example.com"}' [--execute --confirm], or ${commandPrefix} call --workspace-connection-id <id> --proxy-path /provider/path --method GET`);
     }
-    const result = await sdk.gtm.callNangoTool({
+    const callOptions = {
       ...nangoBaseOptions(),
       actionName,
       toolName,
+      deliveryMode: proxyPath ? "proxy" : void 0,
+      proxyPath,
+      method: flagArg("method") || flagArg("http-method"),
       input: nangoActionInput(),
-      async: hasFlag("async") || void 0,
+      async: hasFlag("async") || hasFlag("wait") || void 0,
       maxRetries: numberFlag("max-retries"),
       dryRun: hasFlag("execute") ? false : hasFlag("dry-run") ? true : void 0,
       confirm: hasFlag("confirm") || void 0,
       confirmWrite: hasFlag("confirm-write") || void 0
-    });
-    return output(result, () => {
+    };
+    const waitOptions = {
+      intervalMs: numberFlag("interval-ms") ?? numberFlag("wait-interval-ms"),
+      maxPolls: numberFlag("max-polls") ?? numberFlag("wait-max-polls"),
+      timeoutMs: numberFlag("timeout-ms") ?? numberFlag("wait-timeout-ms")
+    };
+    const waited = hasFlag("wait") && namespace === "ops" ? await nango.callNangoToolAndWait({ ...callOptions, ...waitOptions }) : null;
+    const result = waited?.call || await nango.callNangoTool(callOptions);
+    const finalResult = waited || (hasFlag("wait") ? await waitForNangoActionResult(nango, result, waitOptions) : result);
+    return output(finalResult, () => {
       console.log(`Nango action ${result?.status || "submitted"}: ${actionName || toolName}`);
       const statusUrl = nangoStatusUrl(result);
       if (statusUrl) console.log(`  Status URL: ${statusUrl}`);
+      if (finalResult !== result) {
+        console.log(`  Result: ${finalResult.status || "unknown"} (${finalResult.polls}/${finalResult.max_polls} polls)`);
+        if (finalResult.timed_out) console.log("  Timed out before a terminal Nango result.");
+      }
       if (result?.next_action) console.log(`  Next: ${result.next_action}`);
-      if (statusUrl) hint(`signaliz gtm nango result --status-url ${statusUrl}`);
+      if (statusUrl && finalResult === result) hint(`${commandPrefix} result --status-url ${statusUrl}`);
     });
   }
   if (sub === "result" || sub === "status") {
-    const actionId = rest[0] || flagArg("action-id");
+    const actionId = nangoPositionalValues(rest)[0] || flagArg("action-id");
     const statusUrl = flagArg("status-url");
-    if (!actionId && !statusUrl) die("Usage: signaliz gtm nango result --action-id <id> OR --status-url /action/<id>");
-    const result = await sdk.gtm.getNangoActionResult({ actionId, statusUrl });
+    if (!actionId && !statusUrl) die(`Usage: ${commandPrefix} result --action-id <id> OR --status-url /action/<id>`);
+    const result = await nango.getNangoActionResult({ actionId, statusUrl });
     return output(result, () => {
       console.log(`Nango action result: ${result?.status || "unknown"}`);
       if (result?.action_id || actionId) console.log(`  Action ID: ${result?.action_id || actionId}`);
@@ -5137,7 +5976,7 @@ async function gtmNango(sub, rest) {
       if (nextStatusUrl) console.log(`  Status URL: ${nextStatusUrl}`);
     });
   }
-  die("Usage: signaliz gtm nango <connect|tools|call|result>");
+  die(`Usage: ${commandPrefix} <flow|search|connect|tools|call|schedule|result>`);
 }
 async function email(sub, rest) {
   const sdk = getSdk();
@@ -5342,26 +6181,74 @@ async function ops(sub, rest) {
     const savedRest = sub === "save" ? rest : rest.slice(1);
     return opsSaved(savedSub, savedRest);
   }
+  if (sub === "nango") return gtmNango(rest[0], rest.slice(1), "ops");
   if (sub === "plan" && !promptArg(rest)) {
     die('Usage: signaliz ops plan "monitor these companies daily..."');
   }
   if (sub === "create" && !promptArg(rest)) {
     die('Usage: signaliz ops create "build 100 leads that fit..." [--confirm-spend]');
   }
+  if ((sub === "schedule" || sub === "recur") && !promptArg(rest)) {
+    die('Usage: signaliz ops schedule "monitor these companies daily..." [--confirm-spend]');
+  }
   if (sub === "execute" && !promptArg(rest)) {
     die('Usage: signaliz ops execute "launch a campaign for this ICP..." [--dry-run|--confirm-spend]');
   }
   const sdk = getSdk();
+  const opsOptionalBooleanFlag = (name) => {
+    const value = flagArg(name);
+    if (value !== void 0) return !["0", "false", "no", "off"].includes(value.toLowerCase());
+    return hasFlag(name) ? true : void 0;
+  };
+  const opsNangoDestination = () => {
+    const destination = { type: "nango" };
+    let hasDetails = false;
+    const set = (key, value) => {
+      if (value === void 0 || value === null || value === "") return;
+      destination[key] = value;
+      hasDetails = true;
+    };
+    const nangoAction = flagArg("nango-action");
+    const nangoProxyPath = flagArg("nango-proxy-path");
+    set("connectionId", flagArg("workspace-connection-id") || flagArg("connection-id"));
+    set("providerConfigKey", flagArg("provider-config-key"));
+    set("integrationId", flagArg("integration-id"));
+    set("nangoConnectionId", flagArg("nango-connection-id"));
+    set("actionName", flagArg("action-name") || nangoAction);
+    set("nangoAction", nangoAction);
+    set("proxyPath", flagArg("proxy-path") || nangoProxyPath);
+    set("nangoProxyPath", nangoProxyPath);
+    set("method", flagArg("method") || flagArg("http-method"));
+    set("writeConfirmed", opsOptionalBooleanFlag("write-confirmed"));
+    set("agentWriteConfirmed", opsOptionalBooleanFlag("agent-write-confirmed"));
+    return hasDetails ? destination : void 0;
+  };
+  const isNangoDestinationType = (type) => {
+    const normalized = type.toLowerCase().replace(/[-\s]/g, "_");
+    return ["nango", "api", "managed_api", "customer_api", "external_api", "nango_api"].includes(normalized);
+  };
   const opsDestinations = () => {
     const destinations = csvFlag("destinations") || csvFlag("destination");
-    return destinations?.map((type) => ({ type }));
+    const nangoDestination = opsNangoDestination();
+    const out = (destinations || []).map((type) => nangoDestination && isNangoDestinationType(type) ? { ...nangoDestination, type } : { type });
+    if (nangoDestination && !out.some((destination) => isNangoDestinationType(String(destination.type)))) {
+      out.push(nangoDestination);
+    }
+    return out.length > 0 ? out : void 0;
   };
+  const opsWakeEvents = () => csvFlag("wake-on-events") || csvFlag("wake-events") || csvFlag("wake-event");
   const opsCompanyDomains = () => csvFlag("company-domains") || csvFlag("domains");
   const opsCustomPrompts = () => ({
     custom_ai_prompt: flagArg("ai-prompt") || flagArg("custom-ai-prompt"),
     signal_prompt: flagArg("signal-prompt"),
     output_prompt: flagArg("output-prompt") || flagArg("result-prompt")
   });
+  const printPlanSchedule2 = (plan) => {
+    if (!plan || typeof plan !== "object") return;
+    const wakeEvents = Array.isArray(plan.wake_on_events) ? plan.wake_on_events : plan.wakeOnEvents;
+    console.log(`Schedule: ${plan.cadence || "manual"}`);
+    console.log(`Wake:     ${Array.isArray(wakeEvents) && wakeEvents.length ? wakeEvents.join(", ") : "cadence only"}`);
+  };
   if (sub === "plan") {
     const promptText = promptArg(rest);
     const result = await sdk.ops.plan({
@@ -5369,6 +6256,7 @@ async function ops(sub, rest) {
       blueprint: flagArg("blueprint"),
       target_count: numberFlag("target-count"),
       cadence: flagArg("cadence"),
+      wake_on_events: opsWakeEvents(),
       destinations: opsDestinations(),
       company_domains: opsCompanyDomains(),
       ...opsCustomPrompts()
@@ -5378,10 +6266,11 @@ async function ops(sub, rest) {
       if (result.ui_summary) console.log(`Summary: ${result.ui_summary}`);
       console.log(`Status:  ${result.status}`);
       console.log(`Outcome: ${result.blueprint}`);
-      console.log(`Cadence: ${result.cadence}`);
+      printPlanSchedule2(result);
       console.log(`Target:  ${result.target_count}`);
       console.log(`Credits: ${result.estimated_credits}`);
       if (result.destination_status) console.log(`Deliver: ${result.destination_status}`);
+      printOpsExecutionContract(result);
       printPrimitiveGraph(result.primitive_graph);
       console.log(`Next:    ${result.next_action}`);
     });
@@ -5400,6 +6289,26 @@ async function ops(sub, rest) {
       console.log(`${primary.title}: ${primary.outcome}`);
       console.log(`Prompt:       ${primary.prompt}`);
       console.log(`CLI:          ${primary.cli_command}`);
+      const packet = primary.operating_packet || primary.operatingPacket || result.operating_packet || result.operatingPacket;
+      if (packet?.schedule) {
+        console.log(`Schedule:     ${packet.schedule.cadence} - ${packet.schedule.recurrence}`);
+        console.log(`Results:      ${packet.result_contract?.wait_tool || packet.resultContract?.waitTool || packet.result_contract?.retrieve_tool || packet.resultContract?.retrieveTool || "ops_wait"}`);
+      }
+      const nangoRoute = packet?.nango_route || packet?.nangoRoute;
+      if (nangoRoute?.enabled) {
+        console.log("\nNango route");
+        console.log(`- Discover: ${nangoRoute.discover_tool || nangoRoute.discoverTool}`);
+        console.log(`- Dry run:  ${nangoRoute.dry_run_tool || nangoRoute.dryRunTool}`);
+        console.log(`- Execute:  ${nangoRoute.execute_tool || nangoRoute.executeTool} after confirm=true`);
+        if (nangoRoute.execute_and_wait_tool || nangoRoute.executeAndWaitTool) {
+          console.log(`- Wait:     ${nangoRoute.execute_and_wait_tool || nangoRoute.executeAndWaitTool}`);
+        }
+        const nangoScheduleTool = nangoRoute.schedule_and_wait_tool || nangoRoute.scheduleAndWaitTool || nangoRoute.schedule_tool || nangoRoute.scheduleTool;
+        if (nangoScheduleTool) {
+          console.log(`- Schedule: ${nangoScheduleTool} after approval`);
+        }
+        console.log(`- Gate:     ${nangoRoute.write_gate || nangoRoute.writeGate}`);
+      }
       if (primary.mcp_sequence?.length) {
         console.log("\nMCP flow");
         for (const [index, step] of primary.mcp_sequence.entries()) {
@@ -5411,22 +6320,49 @@ async function ops(sub, rest) {
   }
   if (sub === "execute") {
     const promptText = promptArg(rest);
+    const shouldWait = hasFlag("wait");
     const result = await sdk.ops.execute({
       prompt: promptText,
       blueprint: flagArg("blueprint"),
       target_count: numberFlag("target-count"),
       cadence: flagArg("cadence"),
+      wake_on_events: opsWakeEvents(),
+      timezone: flagArg("timezone"),
       destinations: opsDestinations(),
       company_domains: opsCompanyDomains(),
       ...opsCustomPrompts(),
       confirm_spend: hasFlag("confirm-spend"),
       dry_run: hasFlag("dry-run"),
-      auto_run: hasFlag("auto-run") ? true : hasFlag("no-auto-run") ? false : void 0,
+      auto_run: hasFlag("auto-run") ? true : hasFlag("no-auto-run") ? false : shouldWait ? true : void 0,
       output_format: flagArg("output-format") === "markdown" ? "markdown" : "json"
     });
+    if (shouldWait && result.op_id && !result.approval_required && result.error_code !== "APPROVAL_REQUIRED" && !hasFlag("dry-run")) {
+      const waited = await sdk.ops.waitForResults({
+        op_id: result.op_id,
+        ...opsWaitOptions()
+      });
+      const combined = {
+        ...waited,
+        execute: result,
+        run_id: result.run_id ?? waited.status?.run_id ?? waited.status?.runId,
+        runId: result.runId ?? result.run_id ?? waited.status?.runId ?? waited.status?.run_id,
+        execution_refs: combineExecutionRefs(result.execution_refs, waited.execution_refs)
+      };
+      return output(combined, () => {
+        if (result.run_id || result.runId) console.log(`Run:     ${result.run_id || result.runId}`);
+        printOpsWaitForResults(combined);
+      });
+    }
     return output(result, () => {
       if (result.approval_required || result.error_code === "APPROVAL_REQUIRED") {
         console.log("Approval required");
+        if (result.plan) {
+          console.log(`Plan:    ${result.plan.title || result.plan.plan_id || "pending approval"}`);
+          if (result.plan.ui_summary) console.log(`Summary: ${result.plan.ui_summary}`);
+          console.log(`Status:  ${result.plan.status || result.status || "needs_approval"}`);
+          printPlanSchedule2(result.plan);
+          printOpsExecutionContract(result.plan);
+        }
         if (result.estimated_credits !== void 0) console.log(`Credits: ${result.estimated_credits}`);
         console.log(`Next:    ${result.next_action || "Retry with --confirm-spend after approval."}`);
         hint(`signaliz ops execute ${JSON.stringify(promptText)} --confirm-spend`);
@@ -5436,13 +6372,19 @@ async function ops(sub, rest) {
         console.log(`Dry run: ${result.plan.title}`);
         if (result.plan.ui_summary) console.log(`Summary: ${result.plan.ui_summary}`);
         console.log(`Status:  ${result.plan.status}`);
+        printPlanSchedule2(result.plan);
         console.log(`Credits: ${result.plan.estimated_credits}`);
+        printOpsExecutionContract(result.plan);
         console.log(`Next:    ${result.next_action || result.plan.next_action}`);
         return;
       }
       console.log(`Op:      ${result.op_id || "not created"}`);
       if (result.run_id) console.log(`Run:     ${result.run_id}`);
       console.log(`Status:  ${result.status || "unknown"}`);
+      if (result.plan) {
+        printPlanSchedule2(result.plan);
+        printOpsExecutionContract(result.plan);
+      }
       console.log(`Next:    ${result.next_action || "Check status for progress."}`);
       if (result.op_id) hint(`signaliz ops status ${result.op_id}`);
     });
@@ -5505,6 +6447,8 @@ Available: ${result.available_types.join(", ")}`);
       blueprint: flagArg("blueprint"),
       target_count: numberFlag("target-count"),
       cadence: flagArg("cadence"),
+      wake_on_events: opsWakeEvents(),
+      timezone: flagArg("timezone"),
       destinations: opsDestinations(),
       company_domains: opsCompanyDomains(),
       ...opsCustomPrompts(),
@@ -5512,15 +6456,99 @@ Available: ${result.available_types.join(", ")}`);
       activate: hasFlag("activate")
     });
     return output(result, () => {
+      if (result.approval_required || result.error_code === "APPROVAL_REQUIRED") {
+        console.log("Approval required");
+        if (result.plan) {
+          console.log(`Plan:       ${result.plan.title || result.plan.plan_id || "pending approval"}`);
+          if (result.plan.ui_summary) console.log(`Summary:    ${result.plan.ui_summary}`);
+          console.log(`Status:     ${result.plan.status || result.status || "needs_approval"}`);
+          printPlanSchedule2(result.plan);
+          printOpsExecutionContract(result.plan);
+        }
+        if (result.estimated_credits !== void 0) console.log(`Credits:    ${result.estimated_credits}`);
+        console.log(`Next:       ${result.next_action || "Retry with --confirm-spend after approval."}`);
+        hint(`signaliz ops create ${JSON.stringify(promptText)} --confirm-spend`);
+        return;
+      }
       console.log(`Op created: ${result.op_id}`);
       console.log(`Status:     ${result.status}`);
+      if (result.plan) {
+        printPlanSchedule2(result.plan);
+        printOpsExecutionContract(result.plan);
+      }
       console.log(`Next:       ${result.next_action}`);
       hint(`signaliz ops run ${result.op_id}`);
     });
   }
+  if (sub === "schedule" || sub === "recur") {
+    const promptText = promptArg(rest);
+    const shouldWait = hasFlag("wait");
+    const scheduleInput = {
+      prompt: promptText,
+      blueprint: flagArg("blueprint"),
+      target_count: numberFlag("target-count"),
+      cadence: flagArg("cadence") || "daily",
+      wake_on_events: opsWakeEvents(),
+      timezone: flagArg("timezone"),
+      destinations: opsDestinations(),
+      company_domains: opsCompanyDomains(),
+      ...opsCustomPrompts(),
+      confirm_spend: hasFlag("confirm-spend")
+    };
+    if (shouldWait) {
+      const combined = await sdk.ops.scheduleAndWait({
+        ...scheduleInput,
+        force: hasFlag("force"),
+        instruction: flagArg("instruction"),
+        ...opsWaitOptions()
+      });
+      return output(combined, () => {
+        console.log(`Op scheduled: ${combined.schedule?.op_id || combined.op_id}`);
+        printOpsWaitForResults(combined);
+      });
+    }
+    const result = await sdk.ops.schedule(scheduleInput);
+    return output(result, () => {
+      if (result.approval_required || result.error_code === "APPROVAL_REQUIRED") {
+        console.log("Approval required");
+        if (result.plan) {
+          console.log(`Plan:         ${result.plan.title || result.plan.plan_id || "pending approval"}`);
+          if (result.plan.ui_summary) console.log(`Summary:      ${result.plan.ui_summary}`);
+          console.log(`Status:       ${result.plan.status || result.status || "needs_approval"}`);
+          printPlanSchedule2(result.plan);
+          printOpsExecutionContract(result.plan);
+        }
+        if (result.estimated_credits !== void 0) console.log(`Credits:      ${result.estimated_credits}`);
+        console.log(`Next:         ${result.next_action || "Retry with --confirm-spend after approval."}`);
+        hint(`signaliz ops schedule ${JSON.stringify(promptText)} --confirm-spend`);
+        return;
+      }
+      console.log(`Op scheduled: ${result.op_id}`);
+      if (result.run_id) console.log(`Run:          ${result.run_id}`);
+      console.log(`Status:       ${result.status}`);
+      if (result.plan) {
+        printPlanSchedule2(result.plan);
+        printOpsExecutionContract(result.plan);
+      }
+      console.log(`Next:         ${result.next_action}`);
+      if (result.op_id) hint(`signaliz ops run ${result.op_id} --wait --limit 100`);
+    });
+  }
   if (sub === "run") {
     const opId = rest[0];
     if (!opId) die("Usage: signaliz ops run <op_id>");
+    if (hasFlag("wait")) {
+      const result2 = await sdk.ops.runAndWait({
+        op_id: opId,
+        force: hasFlag("force"),
+        instruction: flagArg("instruction"),
+        ...opsWaitOptions()
+      });
+      return output(result2, () => {
+        if (result2.run?.run_id || result2.run?.runId) console.log(`Run:     ${result2.run.run_id || result2.run.runId}`);
+        printOpsWaitForResults(result2);
+      });
+    }
     const result = await sdk.ops.run({ op_id: opId, force: hasFlag("force"), instruction: flagArg("instruction") });
     return output(result, () => {
       console.log(`Op running: ${result.op_id}`);
@@ -5553,14 +6581,38 @@ Available: ${result.available_types.join(", ")}`);
       include_failed_runs: hasFlag("include-failed-runs")
     });
     return output(result, () => {
-      const hasMore = result.has_more || result.hasMore;
-      const nextCursor = result.next_cursor ?? result.nextCursor;
-      console.log(`Results: ${result.results_count}${hasMore ? " (more available)" : ""}`);
-      for (const row of result.results.slice(0, 10)) console.log(JSON.stringify(row));
+      const summary = result.summary || {};
+      const hasMore = summary.has_more ?? summary.hasMore ?? result.has_more ?? result.hasMore;
+      const nextCursor = summary.next_cursor ?? summary.nextCursor ?? result.next_cursor ?? result.nextCursor;
+      const resultsCount = summary.results_count ?? summary.resultsCount ?? result.results_count ?? result.resultsCount ?? 0;
+      const resultsTotal = summary.results_total ?? summary.resultsTotal ?? result.results_total ?? result.resultsTotal;
+      const deliveryStatus = summary.delivery_status ?? summary.deliveryStatus ?? result.delivery_status ?? result.deliveryStatus;
+      const resultsUrl = summary.results_url ?? summary.resultsUrl ?? result.results_url ?? result.resultsUrl;
+      const nextAction = summary.next_action ?? summary.nextAction ?? result.next_action ?? result.nextAction;
+      console.log(`Results: ${resultsCount}${hasMore ? " (more available)" : ""}`);
+      if (summary.label) console.log(`Summary: ${summary.label}`);
+      console.log(`Status:  ${summary.status || result.status || "unknown"} (${summary.phase || result.phase || "unknown"})`);
+      if (resultsTotal !== void 0 && resultsTotal !== null) console.log(`Total:   ${resultsTotal}`);
+      if (deliveryStatus) console.log(`Deliver: ${deliveryStatus}`);
+      if (resultsUrl) console.log(`Open:    ${resultsUrl}`);
+      if (nextAction) console.log(`Next:    ${nextAction}`);
+      if (result.results.length) {
+        console.log("\nRows");
+        for (const row of result.results.slice(0, 10)) console.log(JSON.stringify(row));
+      }
       if (hasMore && nextCursor) hint(`signaliz ops results ${opId} --cursor ${nextCursor}`);
       printExecutionRefs(result.execution_refs);
     });
   }
+  if (sub === "wait" || sub === "await") {
+    const opId = rest[0] || flagArg("op-id");
+    if (!opId) die("Usage: signaliz ops wait <op_id>");
+    const result = await sdk.ops.waitForResults({
+      op_id: opId,
+      ...opsWaitOptions()
+    });
+    return output(result, () => printOpsWaitForResults(result));
+  }
   if (sub === "run-status" || sub === "trigger-status" || sub === "watch") {
     const runIds = csvFlag("run-ids");
     const runId = rest[0] || flagArg("run-id");
@@ -5889,13 +6941,15 @@ Available: ${result.available_types.join(", ")}`);
     const result = await sdk.ops.attachSinkToRoutine({ routine_id: routineId, sink_id: sinkId });
     return output(result);
   }
-  die("Usage: signaliz ops <proof|autopilot|plan|execute|quickstart|create|run|status|results|run-status|queue|logs|replay|dashboard|doctor|connections|sinks|routines|routine|attach-sink|saved>");
+  die("Usage: signaliz ops <proof|autopilot|plan|execute|quickstart|create|schedule|run|status|results|wait|nango|run-status|queue|logs|replay|dashboard|doctor|connections|sinks|routines|routine|attach-sink|saved>");
 }
 var OPS_SHORTCUTS = {
   "/plan": "plan",
   plan: "plan",
   "/goal": "create",
   goal: "create",
+  schedule: "schedule",
+  recur: "schedule",
   quickstart: "quickstart",
   template: "template",
   proof: "proof",
@@ -5904,6 +6958,7 @@ var OPS_SHORTCUTS = {
   run: "run",
   status: "status",
   results: "results",
+  wait: "wait",
   queue: "queue",
   debug: "debug",
   watch: "watch",