@signaliz/cli 1.0.2 → 1.0.3

package/dist/bin.js

@@ -214,13 +214,14 @@ var require_dist = __commonJS({
                 details: { responseText: text.slice(0, 500) }
               });
             }
-            if (data.error) {
+            const responseError = isRecord(data) && isRecord(data.error) ? data.error : null;
+            if (responseError) {
               const err = new SignalizError({
-                code: data.error.code?.toString() || data.error.data?.error_code || "MCP_ERROR",
-                message: data.error.message || "MCP request failed",
-                errorType: mapMcpErrorType(data.error),
-                retryAfter: data.error.data?.retry_after,
-                details: data.error.data
+                code: firstString(responseError.code, isRecord(responseError.data) ? responseError.data.error_code : void 0) || "MCP_ERROR",
+                message: firstString(responseError.message) || "MCP request failed",
+                errorType: mapMcpErrorType(responseError),
+                retryAfter: isRecord(responseError.data) && typeof responseError.data.retry_after === "number" ? responseError.data.retry_after : void 0,
+                details: isRecord(responseError.data) ? responseError.data : void 0
               });
               if (err.isRetryable && attempt < this.maxRetries) {
                 lastError = err;
@@ -297,35 +298,63 @@ var require_dist = __commonJS({
         }
       };
     }
+    function isRecord(value) {
+      return typeof value === "object" && value !== null;
+    }
+    function firstString(...values) {
+      const value = values.find((item) => typeof item === "string" && item.length > 0);
+      return typeof value === "string" ? value : void 0;
+    }
+    function firstPayloadError(payload) {
+      const errors = payload.errors;
+      const first = Array.isArray(errors) ? errors[0] : void 0;
+      return isRecord(first) ? first : {};
+    }
     function unwrapMcpResponse(data) {
-      if (data?.result?.structuredContent !== void 0) {
-        return unwrapMcpPayload(data.result.structuredContent);
+      const result = isRecord(data) ? data.result : void 0;
+      if (isRecord(result) && result.structuredContent !== void 0) {
+        return unwrapMcpPayload(result.structuredContent);
       }
-      const text = data?.result?.content?.[0]?.text;
+      const content = isRecord(result) ? result.content : void 0;
+      const firstContent = Array.isArray(content) ? content[0] : void 0;
+      const text = isRecord(firstContent) ? firstContent.text : void 0;
       if (typeof text === "string") {
         const parsed = safeJson(text);
         return unwrapMcpPayload(parsed ?? text);
       }
-      return unwrapMcpPayload(data?.result);
+      return unwrapMcpPayload(result);
     }
     function unwrapMcpPayload(payload) {
-      if (payload && typeof payload === "object") {
+      if (isRecord(payload)) {
         if (payload.ok === true && Object.prototype.hasOwnProperty.call(payload, "result")) {
           return payload.result;
         }
+        if (payload.ok === false) {
+          const first = firstPayloadError(payload);
+          const code = firstString(first.code, payload.error_code, payload.code) || (payload.approval_required ? "APPROVAL_REQUIRED" : "MCP_ERROR");
+          throw new SignalizError({
+            code,
+            message: firstString(first.message, payload.message, payload.summary, payload.error) || "MCP request failed",
+            errorType: mapErrorTypeFromCode(code),
+            details: {
+              ...payload,
+              ...isRecord(first.details) ? first.details : {}
+            }
+          });
+        }
         if (payload.success === true && Object.prototype.hasOwnProperty.call(payload, "data")) {
           return payload.data;
         }
         if (payload.success === false) {
-          const first = Array.isArray(payload.errors) ? payload.errors[0] ?? {} : {};
-          const code = first.code || payload.error_code || (payload.approval_required ? "APPROVAL_REQUIRED" : "MCP_ERROR");
+          const first = firstPayloadError(payload);
+          const code = firstString(first.code, payload.error_code) || (payload.approval_required ? "APPROVAL_REQUIRED" : "MCP_ERROR");
           throw new SignalizError({
             code,
-            message: first.message || payload.message || payload.summary || "MCP request failed",
+            message: firstString(first.message, payload.message, payload.summary) || "MCP request failed",
             errorType: mapErrorTypeFromCode(code),
             details: {
               ...payload,
-              ...first.details && typeof first.details === "object" ? first.details : {}
+              ...isRecord(first.details) ? first.details : {}
             }
           });
         }
@@ -333,8 +362,10 @@ var require_dist = __commonJS({
       return payload;
     }
     function mapMcpErrorType(error) {
-      const code = String(error?.data?.error_code || error?.code || "");
-      const message = String(error?.message || "").toLowerCase();
+      const errorRecord = isRecord(error) ? error : {};
+      const data = isRecord(errorRecord.data) ? errorRecord.data : {};
+      const code = String(data.error_code || errorRecord.code || "");
+      const message = String(errorRecord.message || "").toLowerCase();
       if (code === "429" || message.includes("rate limit")) return "rate_limited";
       if (code === "401" || code === "AUTH_001" || message.includes("auth")) return "auth_expired";
       if (code === "400" || code === "-32602" || message.includes("invalid")) return "validation";
@@ -895,14 +926,14 @@ var require_dist = __commonJS({
       async waitForCompletion(campaignBuildId, options) {
         const interval = options?.intervalMs ?? 5e3;
         const timeout = options?.timeoutMs ?? 6e5;
-        const start = Date.now();
+        const start2 = Date.now();
         while (true) {
           const s = await this.getCampaignBuildStatus(campaignBuildId);
           options?.onStatus?.(s);
           if (["completed", "failed", "canceled"].includes(s.status)) {
             return s;
           }
-          if (Date.now() - start > timeout) {
+          if (Date.now() - start2 > timeout) {
             throw new Error(`Campaign build ${campaignBuildId} timed out after ${timeout}ms (status: ${s.status})`);
           }
           await new Promise((r) => setTimeout(r, interval));
@@ -2943,6 +2974,10 @@ var require_dist = __commonJS({
           failed30d: numberValue(summary.failed_30d ?? summary.failed30d),
           external_delivered_30d: numberValue(summary.external_delivered_30d ?? summary.externalDelivered30d),
           externalDelivered30d: numberValue(summary.external_delivered_30d ?? summary.externalDelivered30d),
+          nango_proofs_30d: numberValue(summary.nango_proofs_30d ?? summary.nangoProofs30d),
+          nangoProofs30d: numberValue(summary.nango_proofs_30d ?? summary.nangoProofs30d),
+          nango_failures_30d: numberValue(summary.nango_failures_30d ?? summary.nangoFailures30d),
+          nangoFailures30d: numberValue(summary.nango_failures_30d ?? summary.nangoFailures30d),
           airbyte_configured: numberValue(summary.airbyte_configured ?? summary.airbyteConfigured),
           airbyteConfigured: numberValue(summary.airbyte_configured ?? summary.airbyteConfigured),
           airbyte_proofs_30d: numberValue(summary.airbyte_proofs_30d ?? summary.airbyteProofs30d),
@@ -3357,9 +3392,10 @@ var require_dist = __commonJS({
     }
     function buildCreateRoutineBody(params) {
       const { outputSinks, wakeOnEvents, ...rest } = params;
+      const sinks = rest.output_sinks ?? outputSinks;
       return {
         ...rest,
-        output_sinks: rest.output_sinks ?? outputSinks,
+        output_sinks: Array.isArray(sinks) ? sinks.map(normalizeOpsSinkRequest) : sinks,
         wake_on_events: rest.wake_on_events ?? wakeOnEvents
       };
     }
@@ -3393,6 +3429,97 @@ var require_dist = __commonJS({
         webhook_url: rest.webhook_url ?? webhookUrl
       };
     }
+    function normalizeOpsSinkRequest(sink) {
+      const {
+        sinkId,
+        connectionId,
+        connectorId,
+        connectorName,
+        deliveryMode,
+        providerConfigKey,
+        integrationId,
+        nangoConnectionId,
+        actionName,
+        nangoAction,
+        proxyPath,
+        nangoProxyPath,
+        fieldMap,
+        requiredFields,
+        writeConfirmed,
+        agentWriteConfirmed,
+        config,
+        ...rest
+      } = sink;
+      const normalizedConfig = normalizeOpsSinkConfigRequest(config);
+      const connection_id = rest.connection_id ?? connectionId;
+      const connector_id = rest.connector_id ?? connectorId;
+      const delivery_mode = rest.delivery_mode ?? deliveryMode;
+      const provider_config_key = rest.provider_config_key ?? providerConfigKey;
+      const integration_id = rest.integration_id ?? integrationId;
+      const nango_connection_id = rest.nango_connection_id ?? nangoConnectionId;
+      const action_name = rest.action_name ?? actionName;
+      const nango_action = rest.nango_action ?? nangoAction;
+      const proxy_path = rest.proxy_path ?? proxyPath;
+      const nango_proxy_path = rest.nango_proxy_path ?? nangoProxyPath;
+      const field_map = rest.field_map ?? fieldMap;
+      const required_fields = rest.required_fields ?? requiredFields;
+      const write_confirmed = rest.write_confirmed ?? writeConfirmed;
+      const agent_write_confirmed = rest.agent_write_confirmed ?? agentWriteConfirmed;
+      if (connection_id !== void 0 && normalizedConfig.connection_id === void 0) normalizedConfig.connection_id = connection_id;
+      if (connector_id !== void 0 && normalizedConfig.connector_id === void 0) normalizedConfig.connector_id = connector_id;
+      if (delivery_mode !== void 0 && normalizedConfig.delivery_mode === void 0) normalizedConfig.delivery_mode = delivery_mode;
+      if (provider_config_key !== void 0 && normalizedConfig.provider_config_key === void 0) normalizedConfig.provider_config_key = provider_config_key;
+      if (integration_id !== void 0 && normalizedConfig.integration_id === void 0) normalizedConfig.integration_id = integration_id;
+      if (nango_connection_id !== void 0 && normalizedConfig.nango_connection_id === void 0) normalizedConfig.nango_connection_id = nango_connection_id;
+      if (action_name !== void 0 && normalizedConfig.action_name === void 0) normalizedConfig.action_name = action_name;
+      if (nango_action !== void 0 && normalizedConfig.nango_action === void 0) normalizedConfig.nango_action = nango_action;
+      if (proxy_path !== void 0 && normalizedConfig.proxy_path === void 0) normalizedConfig.proxy_path = proxy_path;
+      if (nango_proxy_path !== void 0 && normalizedConfig.nango_proxy_path === void 0) normalizedConfig.nango_proxy_path = nango_proxy_path;
+      if (field_map !== void 0 && normalizedConfig.field_map === void 0) normalizedConfig.field_map = field_map;
+      if (required_fields !== void 0 && normalizedConfig.required_fields === void 0) normalizedConfig.required_fields = required_fields;
+      if (write_confirmed !== void 0 && normalizedConfig.write_confirmed === void 0) normalizedConfig.write_confirmed = write_confirmed;
+      if (agent_write_confirmed !== void 0 && normalizedConfig.agent_write_confirmed === void 0) normalizedConfig.agent_write_confirmed = agent_write_confirmed;
+      if (sink.type === "nango" && normalizedConfig.integration_platform === void 0) normalizedConfig.integration_platform = "nango";
+      return {
+        ...rest,
+        sink_id: rest.sink_id ?? sinkId,
+        connection_id,
+        connector_id,
+        connector_name: rest.connector_name ?? connectorName,
+        delivery_mode,
+        provider_config_key,
+        integration_id,
+        nango_connection_id,
+        action_name,
+        nango_action,
+        proxy_path,
+        nango_proxy_path,
+        field_map,
+        required_fields,
+        write_confirmed,
+        agent_write_confirmed,
+        config: normalizedConfig
+      };
+    }
+    function normalizeOpsSinkConfigRequest(config) {
+      const out = { ...config ?? {} };
+      if (out.connection_id === void 0 && out.connectionId !== void 0) out.connection_id = out.connectionId;
+      if (out.connector_id === void 0 && out.connectorId !== void 0) out.connector_id = out.connectorId;
+      if (out.connector_name === void 0 && out.connectorName !== void 0) out.connector_name = out.connectorName;
+      if (out.delivery_mode === void 0 && out.deliveryMode !== void 0) out.delivery_mode = out.deliveryMode;
+      if (out.provider_config_key === void 0 && out.providerConfigKey !== void 0) out.provider_config_key = out.providerConfigKey;
+      if (out.integration_id === void 0 && out.integrationId !== void 0) out.integration_id = out.integrationId;
+      if (out.nango_connection_id === void 0 && out.nangoConnectionId !== void 0) out.nango_connection_id = out.nangoConnectionId;
+      if (out.action_name === void 0 && out.actionName !== void 0) out.action_name = out.actionName;
+      if (out.nango_action === void 0 && out.nangoAction !== void 0) out.nango_action = out.nangoAction;
+      if (out.proxy_path === void 0 && out.proxyPath !== void 0) out.proxy_path = out.proxyPath;
+      if (out.nango_proxy_path === void 0 && out.nangoProxyPath !== void 0) out.nango_proxy_path = out.nangoProxyPath;
+      if (out.field_map === void 0 && out.fieldMap !== void 0) out.field_map = out.fieldMap;
+      if (out.required_fields === void 0 && out.requiredFields !== void 0) out.required_fields = out.requiredFields;
+      if (out.write_confirmed === void 0 && out.writeConfirmed !== void 0) out.write_confirmed = out.writeConfirmed;
+      if (out.agent_write_confirmed === void 0 && out.agentWriteConfirmed !== void 0) out.agent_write_confirmed = out.agentWriteConfirmed;
+      return out;
+    }
     function buildApproveBody(params) {
       const { tokenId, tokenIds, reviewerNotes, ...rest } = params;
       return {
@@ -3537,6 +3664,57 @@ var require_dist = __commonJS({
           limit: options.limit
         });
       }
+      /** Discover existing provider campaigns, starting with live/Kernel-linked Instantly campaigns, before audit or import preview. */
+      async discoverExistingCampaigns(options = {}) {
+        return this.callMcp("gtm_existing_campaign_discover", {
+          provider: options.provider,
+          integration_id: options.integrationId,
+          search: options.search,
+          limit: options.limit,
+          include_kernel_linked: options.includeKernelLinked,
+          include_provider_live: options.includeProviderLive
+        });
+      }
+      /** Run a read-only existing campaign audit with completeness, recommendations, safe next MCP JSON, and approval boundaries. */
+      async auditExistingCampaign(options) {
+        return this.callMcp("gtm_existing_campaign_audit", {
+          campaign_id: options.campaignId,
+          provider: options.provider,
+          provider_campaign_id: options.providerCampaignId,
+          campaign_name: options.campaignName,
+          days: options.days,
+          include_route_preview: options.includeRoutePreview,
+          include_memory: options.includeMemory,
+          include_brain: options.includeBrain
+        });
+      }
+      /** Discover the first matching existing provider campaign, then run the same read-only audit against that match. */
+      async auditExistingCampaignBySearch(options) {
+        const discovery = await this.discoverExistingCampaigns({
+          provider: options.provider,
+          integrationId: options.integrationId,
+          search: options.search,
+          limit: 1,
+          includeKernelLinked: options.includeKernelLinked,
+          includeProviderLive: options.includeProviderLive
+        });
+        const match = discovery.campaigns?.[0];
+        const campaignId = match?.linked_kernel_campaign_id || void 0;
+        const providerCampaignId = match?.provider_campaign_id || void 0;
+        if (!campaignId && !providerCampaignId) {
+          throw new Error(`No existing ${options.provider || discovery.provider || "provider"} campaign matched "${options.search}"`);
+        }
+        return this.auditExistingCampaign({
+          provider: options.provider || discovery.provider || match?.provider,
+          campaignId,
+          providerCampaignId,
+          campaignName: match?.name || match?.linked_kernel_campaign_name || void 0,
+          days: options.days,
+          includeRoutePreview: options.includeRoutePreview,
+          includeMemory: options.includeMemory,
+          includeBrain: options.includeBrain
+        });
+      }
       /** Create a first-class GTM campaign object in the current workspace. */
       async createCampaign(input) {
         return this.callMcp("gtm_campaign_create", campaignCreateArgs(input));
@@ -3742,6 +3920,47 @@ var require_dist = __commonJS({
           brain_cycle_min_interval_minutes: input.brainCycleMinIntervalMinutes
         });
       }
+      /** Preview anonymized Instantly workspace sources registered for Kernel import. */
+      async previewKernelImport(input = {}) {
+        return this.callMcp("gtm_kernel_import_preview", {
+          source_ids: input.sourceIds,
+          include_leads: input.includeLeads,
+          include_replies: input.includeReplies,
+          include_private_copy: input.includePrivateCopy,
+          max_pages: input.maxPages,
+          limit: input.limit
+        });
+      }
+      /** Queue the read-only Instantly-to-GTM Kernel import. Live writes require writeApproved. */
+      async runKernelImport(input = {}) {
+        return this.callMcp("gtm_kernel_import_run", {
+          source_ids: input.sourceIds,
+          dry_run: input.dryRun,
+          write_approved: input.writeApproved,
+          include_leads: input.includeLeads,
+          include_replies: input.includeReplies,
+          include_private_copy: input.includePrivateCopy,
+          private_copy_approved: input.privateCopyApproved,
+          promote_global_patterns: input.promoteGlobalPatterns,
+          min_global_privacy_k: input.minGlobalPrivacyK,
+          max_pages: input.maxPages,
+          limit: input.limit
+        });
+      }
+      /** Queue Brain distillation over imported Instantly memory with abstracted-only outputs. */
+      async runBrainDistillation(input = {}) {
+        return this.callMcp("gtm_brain_distill_run", {
+          source_ids: input.sourceIds,
+          write_mode: input.writeMode,
+          write_approved: input.writeApproved,
+          brain_cycle_phases: input.brainCyclePhases,
+          days: input.days,
+          network_days: input.networkDays,
+          min_sample_size: input.minSampleSize,
+          min_workspace_count: input.minWorkspaceCount,
+          min_privacy_k: input.minPrivacyK
+        });
+      }
       /** Prepare a provider-agnostic feedback webhook URL for Smartlead, HeyReach, Airbyte, or custom sender events. */
       async prepareFeedbackWebhook(input) {
         return this.callMcp("gtm_feedback_webhook_prepare", {
@@ -4169,6 +4388,43 @@ var require_dist = __commonJS({
           context: input.context
         });
       }
+      /** List Nango-backed action tools for a workspace connection without executing them. */
+      async listNangoTools(options = {}) {
+        return this.callMcp("nango_mcp_tools_list", {
+          workspace_connection_id: options.workspaceConnectionId,
+          connection_id: options.connectionId,
+          provider_config_key: options.providerConfigKey,
+          integration_id: options.integrationId,
+          nango_connection_id: options.nangoConnectionId,
+          format: options.format,
+          include_raw: options.includeRaw
+        });
+      }
+      /** Dry-run or execute a Nango-backed action tool through the approval-aware MCP bridge. */
+      async callNangoTool(input) {
+        return this.callMcp("nango_mcp_tool_call", {
+          workspace_connection_id: input.workspaceConnectionId,
+          connection_id: input.connectionId,
+          provider_config_key: input.providerConfigKey,
+          integration_id: input.integrationId,
+          nango_connection_id: input.nangoConnectionId,
+          action_name: input.actionName,
+          tool_name: input.toolName,
+          input: input.input,
+          async: input.async,
+          max_retries: input.maxRetries,
+          dry_run: input.dryRun,
+          confirm: input.confirm,
+          confirm_write: input.confirmWrite
+        });
+      }
+      /** Poll an async Nango action result by action id or status URL. */
+      async getNangoActionResult(input) {
+        return this.callMcp("nango_mcp_action_result_get", {
+          action_id: input.actionId,
+          status_url: input.statusUrl
+        });
+      }
       /** Deliver approved campaign-layer records to a webhook recipe, starting with Clay-style webhooks. */
       async deliverWebhook(input) {
         return this.callMcp("gtm_webhook_deliver", {
@@ -4301,6 +4557,59 @@ var require_dist = __commonJS({
       }
       return out;
     }
+    function inferMcpToolCategory2(toolName) {
+      if (typeof toolName !== "string" || !toolName) return void 0;
+      if (toolName.startsWith("ops_") || toolName === "get_ops_readiness" || toolName === "get_gtm_ops_readiness" || toolName.startsWith("gtm_") || [
+        "list_routines",
+        "create_routine",
+        "update_routine",
+        "run_routine_now",
+        "get_routine",
+        "get_routine_ticks",
+        "get_tick_items",
+        "get_last_tick_items",
+        "chain_routines",
+        "get_chain_status",
+        "launch_campaign",
+        "quickstart_gtm_book",
+        "list_campaigns",
+        "campaign_performance",
+        "tune_campaign",
+        "emit_event",
+        "approvals_list",
+        "list_output_sinks",
+        "create_output_sink",
+        "update_output_sink",
+        "delete_output_sink",
+        "attach_sink_to_routine"
+      ].includes(toolName)) {
+        return "ops";
+      }
+      if ([
+        "find_emails_with_verification",
+        "verify_email",
+        "enrich_company_signals",
+        "company_intelligence",
+        "find_contacts_with_email",
+        "execute_primitive"
+      ].includes(toolName)) {
+        return "enrichment";
+      }
+      if (toolName.includes("icp")) return "icp";
+      if (toolName.startsWith("ai_clean_")) return "data_cleaning";
+      if (toolName.includes("system") || toolName.includes("workflow")) return "automation";
+      if (toolName.includes("agent") || toolName.includes("platform_health") || toolName === "discover_capabilities") return "observability";
+      return void 0;
+    }
+    function asRecord3(value) {
+      return value && typeof value === "object" ? value : void 0;
+    }
+    function asStringArray(value) {
+      return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+    }
+    function asObjectSchema(value) {
+      return asRecord3(value);
+    }
     var Signaliz = class {
       constructor(config) {
         this.client = new HttpClient(config);
@@ -4359,21 +4668,21 @@ var require_dist = __commonJS({
         const data = await this.client.mcp("tools/list", {});
         const tools2 = data?.tools ?? data ?? [];
         return tools2.map((t) => ({
-          name: t.name,
-          description: (t.description ?? "").slice(0, 120),
-          category: t.annotations?.category,
-          costCredits: t.annotations?.cost_credits,
-          contractVersion: t.annotations?.contract_version ?? t.annotations?.contract?.contract_version,
-          permissionLevel: t.annotations?.permission_level ?? t.annotations?.contract?.permission_level,
-          authScopes: t.annotations?.auth_scopes ?? t.annotations?.contract?.auth_scopes,
-          idempotent: t.annotations?.idempotentHint ?? t.annotations?.idempotent ?? t.annotations?.contract?.idempotent,
-          destructive: t.annotations?.destructiveHint ?? t.annotations?.destructive ?? t.annotations?.contract?.destructive,
-          retryable: t.annotations?.retryable ?? t.annotations?.contract?.retryable,
-          rateLimitKey: t.annotations?.rate_limit_key ?? t.annotations?.contract?.rate_limit_key,
-          observability: t.annotations?.observability ?? t.annotations?.contract?.observability,
-          inputSchema: t.inputSchema ?? t.input_schema ?? t.annotations?.contract?.input_schema,
-          outputSchema: t.outputSchema ?? t.output_schema ?? t.annotations?.contract?.output_schema,
-          annotations: t.annotations
+          name: typeof t.name === "string" ? t.name : "",
+          description: String(t.description ?? "").slice(0, 120),
+          category: typeof t.annotations?.category === "string" ? t.annotations.category : inferMcpToolCategory2(t.name),
+          costCredits: typeof t.annotations?.cost_credits === "number" ? t.annotations.cost_credits : void 0,
+          contractVersion: typeof (t.annotations?.contract_version ?? t.annotations?.contract?.contract_version) === "string" ? t.annotations?.contract_version ?? t.annotations?.contract?.contract_version : void 0,
+          permissionLevel: typeof (t.annotations?.permission_level ?? t.annotations?.contract?.permission_level) === "string" ? t.annotations?.permission_level ?? t.annotations?.contract?.permission_level : void 0,
+          authScopes: asStringArray(t.annotations?.auth_scopes ?? t.annotations?.contract?.auth_scopes),
+          idempotent: typeof (t.annotations?.idempotentHint ?? t.annotations?.idempotent ?? t.annotations?.contract?.idempotent) === "boolean" ? t.annotations?.idempotentHint ?? t.annotations?.idempotent ?? t.annotations?.contract?.idempotent : void 0,
+          destructive: typeof (t.annotations?.destructiveHint ?? t.annotations?.destructive ?? t.annotations?.contract?.destructive) === "boolean" ? t.annotations?.destructiveHint ?? t.annotations?.destructive ?? t.annotations?.contract?.destructive : void 0,
+          retryable: typeof (t.annotations?.retryable ?? t.annotations?.contract?.retryable) === "boolean" ? t.annotations?.retryable ?? t.annotations?.contract?.retryable : void 0,
+          rateLimitKey: typeof (t.annotations?.rate_limit_key ?? t.annotations?.contract?.rate_limit_key) === "string" ? t.annotations?.rate_limit_key ?? t.annotations?.contract?.rate_limit_key : void 0,
+          observability: asRecord3(t.annotations?.observability ?? t.annotations?.contract?.observability),
+          inputSchema: asObjectSchema(t.inputSchema ?? t.input_schema ?? t.annotations?.contract?.input_schema),
+          outputSchema: asObjectSchema(t.outputSchema ?? t.output_schema ?? t.annotations?.contract?.output_schema),
+          annotations: asRecord3(t.annotations)
         }));
       }
       /** Discover tools by natural language query */
@@ -4469,40 +4778,194 @@ function readJsonFlag(name) {
   if (!file) return void 0;
   return JSON.parse((0, import_node_fs.readFileSync)(file, "utf8"));
 }
+function readInlineJsonFlag(name) {
+  const raw = flagArg(name);
+  if (!raw) return void 0;
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    die(`--${name} must be a JSON object`);
+  }
+  return parsed;
+}
+function readJsonObjectInput(inlineFlag, fileFlag) {
+  const inline = readInlineJsonFlag(inlineFlag);
+  if (inline) return inline;
+  const file = flagArg(fileFlag);
+  if (!file) return void 0;
+  const parsed = readJsonValue(file);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    die(`--${fileFlag} must point to a JSON object`);
+  }
+  return parsed;
+}
+function normalizeCampaignBuildInput(raw) {
+  const source = raw?.build_campaign_arguments || raw?.buildCampaignArguments || raw?.build_campaign_args || raw?.buildCampaignArgs || raw || {};
+  if (!source || typeof source !== "object" || Array.isArray(source)) return {};
+  const get = (snake, camel) => source[snake] ?? source[camel];
+  const nested = (snake, camel) => {
+    const value = get(snake, camel);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  };
+  const policy = nested("policy", "policy");
+  const signals = nested("signals", "signals");
+  const copy = nested("copy", "copy");
+  const delivery = nested("delivery", "delivery");
+  return {
+    name: get("name", "name"),
+    prompt: get("prompt", "prompt"),
+    gtmCampaignId: get("gtm_campaign_id", "gtmCampaignId"),
+    description: get("description", "description"),
+    targetCount: get("target_count", "targetCount"),
+    dryRun: get("dry_run", "dryRun"),
+    allowDownscale: get("allow_downscale", "allowDownscale"),
+    confirmSpend: get("confirm_spend", "confirmSpend"),
+    dedupKeys: get("dedup_keys", "dedupKeys"),
+    brainPreflight: get("brain_preflight", "brainPreflight"),
+    brainDefaults: get("brain_defaults", "brainDefaults"),
+    deliveryRisk: get("delivery_risk", "deliveryRisk"),
+    icp: nested("icp", "icp"),
+    policy: policy ? {
+      ...policy,
+      maxCredits: policy.max_credits ?? policy.maxCredits,
+      verifyEmails: policy.verify_emails ?? policy.verifyEmails
+    } : void 0,
+    signals: signals ? {
+      ...signals,
+      customPrompt: signals.custom_prompt ?? signals.customPrompt,
+      confidenceThreshold: signals.confidence_threshold ?? signals.confidenceThreshold,
+      lookbackDays: signals.lookback_days ?? signals.lookbackDays
+    } : void 0,
+    qualification: nested("qualification", "qualification"),
+    copy: copy ? {
+      ...copy,
+      maxBodyWords: copy.max_body_words ?? copy.maxBodyWords,
+      senderContext: copy.sender_context ?? copy.senderContext,
+      offerContext: copy.offer_context ?? copy.offerContext
+    } : void 0,
+    delivery: delivery ? {
+      ...delivery,
+      destinationType: delivery.destination_type ?? delivery.destinationType,
+      approvalRequired: delivery.approval_required ?? delivery.approvalRequired,
+      includeDisqualified: delivery.include_disqualified ?? delivery.includeDisqualified,
+      destinationConfig: delivery.destination_config ?? delivery.destinationConfig
+    } : void 0,
+    enhancers: nested("enhancers", "enhancers")
+  };
+}
 var promptValueFlags = /* @__PURE__ */ new Set([
+  "action-id",
+  "action-name",
+  "actor-id",
+  "actor-type",
   "analysis-models",
   "attachment-field",
   "attachment-fields",
   "attachment-file",
   "attachment-url",
   "blueprint",
+  "brain-config-file",
+  "brain-config-json",
+  "build-id",
   "cadence",
+  "campaign-build-id",
+  "campaign-id",
+  "campaign-brief",
+  "brief",
   "company-domains",
   "company-domain",
   "company-name",
+  "connection-id",
+  "context-json",
+  "copy-file",
+  "copy-json",
   "destination",
   "destinations",
+  "days",
+  "dedup-keys",
+  "delivery-file",
+  "delivery-json",
+  "delivery-risk-file",
+  "delivery-risk-json",
   "domains",
+  "enhancers-file",
+  "enhancers-json",
   "file-url",
+  "integration-id",
   "image-url",
   "input-file",
   "input-json",
+  "instantly-campaign-id",
+  "idempotency-key",
   "judge-model",
+  "layer",
+  "layers",
+  "limit",
+  "lead-count",
+  "log-limit",
   "max-concurrency",
+  "max-retries",
   "max-tokens",
+  "memory-limit",
+  "memory-type",
   "model",
+  "name",
+  "min-sample-size",
+  "min-workspace-count",
+  "nango-connection-id",
+  "network-days",
   "output-format",
   "output-fields",
   "output-fields-file",
+  "outcome-type",
   "pdf-engine",
   "pdf-url",
+  "phases",
+  "policy-file",
+  "policy-json",
+  "provider",
+  "providers",
+  "preferred-providers",
+  "provider-account-id",
+  "provider-campaign-id",
+  "provider-config-key",
+  "provider-id",
+  "provider-link-id",
+  "provider-name",
+  "provider-workspace-id",
+  "qualification-file",
+  "qualification-json",
   "records-file",
   "records-json",
+  "readiness-json",
+  "rationale",
+  "route-config-json",
+  "route-status",
+  "secret-ref",
+  "search",
+  "send-config-file",
+  "send-config-json",
+  "signals-file",
+  "signals-json",
+  "status",
+  "status-url",
   "system-prompt",
   "target-count",
+  "target-icp-file",
+  "target-icp-json",
   "temperature",
+  "tool-name",
   "url",
-  "video-url"
+  "video-url",
+  "write-mode",
+  "workspace-connection-id",
+  "workspace-integration-id",
+  "workspace-mcp-server-id",
+  "memory-dimension-filters-file",
+  "memory-dimension-filters-json",
+  "metadata-file",
+  "metadata-json",
+  "plan-file",
+  "plan-json"
 ]);
 function promptArg(rest) {
   const explicit = flagArg("prompt");
@@ -4537,6 +5000,26 @@ function hint(msg) {
   if (!jsonMode()) console.log(`
 \u2192 ${msg}`);
 }
+function labelize(value) {
+  return String(value || "").replace(/[_-]+/g, " ").trim();
+}
+function arrayCount(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function firstExistingCampaignSafeAction(result) {
+  const packet = result?.improvement_packet || result?.audit_packet?.improvement_packet || {};
+  const groups = [
+    packet.fix_before_scale || packet.fixBeforeScale,
+    packet.improve_next || packet.improveNext,
+    packet.verify
+  ];
+  for (const group of groups) {
+    const match = Array.isArray(group) ? group.find((item) => ["read_only", "dry_run"].includes(String(item?.approval_boundary || item?.approvalBoundary || ""))) : null;
+    if (match) return match;
+  }
+  const recommendations = Array.isArray(result?.recommendations) ? result.recommendations : [];
+  return recommendations.find((item) => ["read_only", "dry_run"].includes(String(item?.approval_boundary || item?.approvalBoundary || ""))) || null;
+}
 function formatToolSafety(tool) {
   const parts = [
     tool.permissionLevel || "unknown",
@@ -4546,6 +5029,53 @@ function formatToolSafety(tool) {
   ].filter(Boolean);
   return parts.join(" | ") || "-";
 }
+function inferMcpToolCategory(toolName) {
+  if (typeof toolName !== "string" || !toolName) return void 0;
+  if (toolName.startsWith("ops_") || toolName === "get_ops_readiness" || toolName === "get_gtm_ops_readiness" || toolName.startsWith("gtm_") || [
+    "list_routines",
+    "create_routine",
+    "update_routine",
+    "run_routine_now",
+    "get_routine",
+    "get_routine_ticks",
+    "get_tick_items",
+    "get_last_tick_items",
+    "chain_routines",
+    "get_chain_status",
+    "launch_campaign",
+    "quickstart_gtm_book",
+    "list_campaigns",
+    "campaign_performance",
+    "tune_campaign",
+    "emit_event",
+    "approvals_list",
+    "list_output_sinks",
+    "create_output_sink",
+    "update_output_sink",
+    "delete_output_sink",
+    "attach_sink_to_routine"
+  ].includes(toolName)) {
+    return "ops";
+  }
+  if ([
+    "find_emails_with_verification",
+    "verify_email",
+    "enrich_company_signals",
+    "company_intelligence",
+    "find_contacts_with_email",
+    "execute_primitive"
+  ].includes(toolName)) {
+    return "enrichment";
+  }
+  if (toolName.includes("icp")) return "icp";
+  if (toolName.startsWith("ai_clean_")) return "data_cleaning";
+  if (toolName.includes("system") || toolName.includes("workflow")) return "automation";
+  if (toolName.includes("agent") || toolName.includes("platform_health") || toolName === "discover_capabilities") return "observability";
+  return void 0;
+}
+function normalizeMcpToolCategory(tool) {
+  return typeof tool.category === "string" ? tool.category : typeof tool.annotations?.category === "string" ? tool.annotations.category : inferMcpToolCategory(tool.name);
+}
 function printToolMetadata(tool, indent = "") {
   const metadata = [];
   if (tool.contractVersion) metadata.push(`contract ${tool.contractVersion}`);
@@ -4822,7 +5352,7 @@ function getSdk() {
   try {
     const { Signaliz } = require("@signaliz/sdk");
     const sdk = createSdk(Signaliz);
-    if (sdk.campaigns?.buildCampaign && sdk.ops?.listOutputSinks && sdk.leads?.generate && sdk.emails?.verify && sdk.ai?.multiModel && sdk.getPlatformHealth) return sdk;
+    if (sdk.campaigns?.buildCampaign && sdk.ops?.listOutputSinks && sdk.leads?.generate && sdk.emails?.verify && sdk.ai?.multiModel && sdk.gtm?.campaignBuildPlan && sdk.gtm?.commitCampaignBuildPlan && sdk.gtm?.prepareCampaignBuildExecution && sdk.gtm?.listNangoTools && sdk.gtm?.callNangoTool && sdk.gtm?.getNangoActionResult && sdk.getPlatformHealth) return sdk;
     primaryError = new Error("SDK missing required GTM workflow APIs");
   } catch (err) {
     primaryError = err;
@@ -4848,6 +5378,12 @@ var HELP = `signaliz <command> [options]
 
 Quick Start:
   signaliz auth login
+  signaliz start
+  signaliz build "Build a campaign for industrial maintenance buyers"
+  signaliz connect
+  signaliz audit
+  signaliz improve <campaign_id>
+  signaliz prove
   signaliz health
   signaliz tools
   signaliz /plan "Monitor key accounts daily and alert Slack"
@@ -4867,6 +5403,16 @@ Auth:
   auth workspace clear    Clear saved workspace context
   whoami                  Show current workspace and credits
   health                  Show workspace health and MCP platform latency/error signals
+  start                   Recommend where to begin across Build, Connect, Audit, Improve, and Ops proof
+    --campaign-brief "..." Optional brief for the suggested campaign-plan command
+    --json                Machine-readable onboarding state
+
+Simple Jobs:
+  build "brief"           Plan a campaign without spending credits
+  connect                 Inspect blocked provider/tool routes
+  audit                   Find previous campaigns to audit
+  improve <campaign_id>   Plan Brain learning for a campaign
+  prove                   Prove Ops delivery readiness
 
 Discovery:
   tools                   List available MCP tools
@@ -4912,11 +5458,95 @@ Lead Generation:
     --confirm-spend       Required to launch spendful work
   lead status <job_id>    Check lead-generation job status
 
-GTM (31 native data sources \u2014 YouTube, TikTok, Instagram, LinkedIn, Facebook, Google Maps, Indeed, etc.):
+GTM Kernel:
+  Use this when you want Signaliz to plan, audit, route, approve, and learn from
+  campaigns. Use "signaliz start" first if you are not sure which command to run.
+  gtm context             Inspect GTM Kernel workspace context
+    --limit N             Max rows per section
+    --no-campaigns        Exclude campaign rows
+    --no-memory           Exclude memory rows
+    --no-brain            Exclude Brain rows
+    --no-connections      Exclude connection rows
+  gtm bootstrap           Inspect Kernel + Brain readiness gates
+    --campaign-id ID      Optional campaign scope
+    --days N              Lookback window, default server-side
+    --include-samples     Include diagnostic samples when supported
+  gtm plan "brief"        Compose a read-only GTM Kernel campaign build plan
+    --layers a,b          Optional GTM layers to plan
+    --target-count N      Desired lead count
+    --preferred-providers a,b
+                          Provider preferences for route planning
+  gtm commit-plan         Dry-run or write a reviewed Kernel campaign plan
+    --plan-file FILE      JSON output from gtm plan --json
+    --write --confirm     Required together for writes; otherwise dry-run
+  gtm prepare-build <id>  Derive exact build_campaign dry-run args
+    --target-count N      Optional launch target count
+    --allow-downscale     Permit smaller launch counts when readiness requires it
+    --build-input         Output campaign build input instead of prepare receipt
+  gtm campaigns           List first-class GTM Kernel campaigns
+    --status STATUS       Optional campaign status
+    --provider PROVIDER   Optional linked provider
+    --search TEXT         Optional search text
+  gtm campaign <id>       Inspect one GTM Kernel campaign
+  gtm existing-campaigns  Discover linked/provider campaigns for audit
+    --provider NAME       Provider, default instantly
+    --search TEXT         Optional campaign search
+    --no-provider-live    Skip live provider lookup
+  gtm audit-existing      Audit an existing provider campaign
+    --campaign-id ID      Optional linked Kernel campaign id
+    --provider-campaign-id ID
+                          Existing provider campaign id, e.g. Instantly
+    --search TEXT         If no id is provided, discover and audit the first match
+  gtm memory "<query>"    Search ranked workspace memory
+    --campaign-id ID      Optional campaign scope
+    --outcome-type TYPE   Optional desired outcome
+    --memory-type TYPE    Optional memory type
+  gtm learning <id>       Plan Brain learning for a campaign
+    --include-network     Include privacy-safe network lanes
+    --write-mode MODE     dry_run or write
+  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
+  gtm calibrate <id>      Calibrate deliverability predictions
+    --min-sample-size N   Default server-side
+    --write               Write calibrations/patterns; otherwise dry-run
+  gtm execution <id>      Inspect campaign execution/provider readiness
+  gtm integrations        Inspect provider activation cards
+    --campaign-id ID      Optional campaign scope
+    --layer LAYER         Optional layer filter
+    --include-planned     Include planned provider presets
+  gtm route-preview       Preview the effective provider route for a layer
+    --campaign-id ID      Optional campaign scope
+    --layer LAYER         Required campaign layer
+  gtm activate-route      Dry-run or confirm provider route setup
+    --provider-id ID      Required provider ID
+    --layer LAYER         Single layer, or use --layers a,b
+    --write --confirm     Required together for writes; otherwise dry-run
+  gtm feedback-webhook    Prepare feedback webhook and Brain-cycle policy
+    --provider NAME       instantly, smartlead, heyreach, airbyte, custom_webhook
+    --campaign-id ID      Optional campaign scope
+    --write-mode MODE     Brain-cycle mode, default dry_run
+
+Native GTM Data Sources:
+  Use these when you already know the exact source you want to run.
   gtm list [--category C] List GTM capabilities
   gtm find "<intent>"     Auto-route a free-text intent to the right capability
   gtm run --capability ID Run a GTM capability (use --query, --urls, --confirm-spend)
   gtm status <job_id>     Check GTM job status
+  gtm nango tools         List Nango action tools for a workspace connection
+    --workspace-connection-id ID
+                          Signaliz workspace connection id
+    --provider-config-key KEY
+                          Optional Nango provider config key
+  gtm nango call <action> Dry-run or execute a Nango action
+    --input-json JSON     Action input object
+    --input-file FILE     Action input object from a JSON file
+    --execute --confirm   Required pair for a confirmed write
+    --async               Queue async action execution when supported
+  gtm nango result        Poll async Nango action result
+    --action-id ID        Nango action id
+    --status-url URL      Relative status URL returned by call
+  nango ...               Shortcut for gtm nango ...
 
 Email:
   email verify <email>    Verify one email address
@@ -4993,7 +5623,7 @@ Ops:
     --blueprint NAME     monitor_companies|build_leads|enrich_list|route_signals|launch_campaign
     --target-count N     Target row count
     --cadence NAME       manual|hourly|daily|weekly
-    --destinations a,b   Destinations such as slack,csv,google_sheets,webhook
+    --destinations a,b   Destinations such as slack,csv,google_sheets,webhook,airbyte,nango
     --company-domains a,b
                          Company domains for monitor/list-based Ops
     --ai-prompt TEXT     Custom AI enrichment or scoring instruction
@@ -5010,7 +5640,7 @@ Ops:
     --confirm-spend      Acknowledge estimated credits/external writes
     --auto-run           Run immediately after create when safe
     --no-auto-run        Create only
-    --destinations a,b   Destinations such as slack,csv,google_sheets,webhook
+    --destinations a,b   Destinations such as slack,csv,google_sheets,webhook,airbyte,nango
     --company-domains a,b
                          Company domains for monitor/list-based Ops
     --ai-prompt TEXT     Custom AI enrichment or scoring instruction
@@ -5019,7 +5649,7 @@ Ops:
   ops create "..."       Create an Op from a prompt
     --confirm-spend      Acknowledge estimated credits/external writes
     --activate           Create as active instead of draft
-    --destinations a,b   Destinations such as slack,csv,google_sheets,webhook
+    --destinations a,b   Destinations such as slack,csv,google_sheets,webhook,airbyte,nango
     --company-domains a,b
                          Company domains for monitor/list-based Ops
     --ai-prompt TEXT     Custom AI enrichment or scoring instruction
@@ -5065,7 +5695,7 @@ Ops:
     --window-hours N    Lookback window for recent runs (default: 24)
     --skip-acquisition-probe
                         Skip the zero-credit fresh acquisition auth/config probe
-  ops connections         List active Airbyte/output destinations
+  ops connections         List active Airbyte, Nango, and output destinations
     --category NAME       Filter by connection category
     --status STATUS       Filter by status (default: active)
   ops sinks               Alias for ops connections
@@ -5079,7 +5709,7 @@ Ops:
   ops routine <id> items   Inspect last tick items
     --state STATE          Filter item state, e.g. failed
   ops attach-sink <routine_id> <sink_id>
-                           Attach an Airbyte/output sink to a routine
+                           Attach an Airbyte, Nango, or output sink to a routine
   ops saved list           List saved local Ops commands
   ops saved search QUERY   Search saved commands by name, prompt, flags, or description
   ops saved save NAME -- <ops command args>
@@ -5104,6 +5734,344 @@ Environment:
   SIGNALIZ_API_URL        Override base URL
   SIGNALIZ_WORKSPACE_ID   Workspace UUID
 `;
+var GTM_HELP = `signaliz gtm <command> [options]
+
+New-user path:
+  signaliz auth login
+  signaliz gtm context
+  signaliz gtm bootstrap --include-samples
+  signaliz gtm plan "Find CTOs at Series B fintech companies" --target-count 100 --json > plan.json
+  signaliz gtm commit-plan --plan-file plan.json
+  signaliz gtm commit-plan --plan-file plan.json --write --confirm
+  signaliz gtm integrations --include-planned
+  signaliz gtm activate-route --provider-id instantly --layer sender
+  signaliz gtm prepare-build <campaign_id> --build-input --json > build-args.json
+  signaliz campaign build --input-file build-args.json
+
+Read-only planning:
+  context                 Inspect GTM Kernel workspace context
+  bootstrap               Inspect Kernel + Brain readiness gates
+  plan "brief"            Compose Memory, Brain, failure, and provider-route plan
+    --campaign-id ID      Optional existing campaign scope
+    --campaign-build-id ID
+                          Optional Campaign Builder build scope
+    --target-count N      Desired lead count
+    --layers a,b          GTM layers to include
+    --preferred-providers a,b
+                          Provider preferences for route planning
+    --target-icp-json JSON
+                          Structured ICP object
+    --include-planned     Include planned/needs-setup providers
+    --no-memory           Skip workspace memory
+    --no-brain            Skip Brain defaults/failure intelligence
+    --no-provider-routes  Skip provider route readiness
+    --no-failure-patterns Skip Brain failure-pattern scan
+
+Reviewed writes:
+  commit-plan             Dry-run or write a reviewed campaign plan
+    --plan-file FILE      JSON output from gtm plan --json
+    --name NAME           Campaign name for the committed object
+    --write --confirm     Required together for writes; otherwise dry-run
+  prepare-build           Derive exact build_campaign dry-run args
+    <campaign_id>         Committed GTM Kernel campaign id
+    --target-count N      Optional launch target count
+    --allow-downscale     Permit smaller launch counts when readiness requires it
+
+Status and repair:
+  campaigns               List first-class GTM Kernel campaigns
+  campaign <id>           Inspect one campaign
+  existing-campaigns      Discover existing linked/provider campaigns
+  audit-existing          Audit an existing provider campaign
+  execution <id>          Inspect execution/provider readiness
+  integrations            Inspect provider activation cards
+  route-preview           Preview effective route for a layer
+  activate-route          Dry-run or confirm provider route setup
+  feedback-webhook        Prepare feedback ingress
+  learning <id>           Plan Brain learning
+  learning-run <id>       Queue Brain learning phases
+  calibrate <id>          Calibrate deliverability
+  memory "query"          Search ranked workspace memory
+  nango ...               List/dry-run/execute Nango-backed API action tools
+
+Use --json on any command for machine-readable output.
+`;
+var GTM_COMMAND_HELP = {
+  context: `signaliz gtm context [options]
+
+Inspect the active workspace context the GTM Kernel will use.
+
+Options:
+  --no-memory             Skip memory preview
+  --limit N               Max memory/context rows to include
+  --json                  Machine-readable output
+`,
+  bootstrap: `signaliz gtm bootstrap [options]
+
+Inspect Kernel, Brain, memory, feedback, and provider-readiness gates before
+planning or running a campaign.
+
+Options:
+  --campaign-id ID        Optional existing campaign scope
+  --include-samples       Include safe sample rows/evidence where available
+  --min-sample-size N     Minimum sample size for Brain/readiness checks
+  --json                  Machine-readable output
+`,
+  doctor: `signaliz gtm doctor [options]
+
+Alias for signaliz gtm bootstrap. Use this before any spendful GTM action.
+
+Options:
+  --campaign-id ID        Optional existing campaign scope
+  --include-samples       Include safe sample rows/evidence where available
+  --min-sample-size N     Minimum sample size for Brain/readiness checks
+  --json                  Machine-readable output
+`,
+  plan: `signaliz gtm plan "campaign brief" [options]
+
+Compose a read-only GTM Kernel campaign plan from workspace memory, Brain
+defaults, failure intelligence, provider routes, and approval boundaries.
+
+Options:
+  --campaign-id ID        Optional existing campaign scope
+  --campaign-build-id ID  Optional Campaign Builder build scope
+  --target-count N        Desired lead count
+  --layers a,b            GTM layers to include
+  --preferred-providers a,b
+                          Provider preferences for route planning
+  --target-icp-json JSON  Structured ICP object
+  --target-icp-file FILE  Structured ICP JSON file
+  --include-planned       Include planned/needs-setup providers
+  --no-memory             Skip workspace memory
+  --no-brain              Skip Brain defaults/failure intelligence
+  --no-provider-routes    Skip provider route readiness
+  --no-failure-patterns   Skip Brain failure-pattern scan
+  --json                  Machine-readable output
+
+Safe next step:
+  signaliz gtm plan "Find CTOs at fintech startups" --target-count 100 --json > plan.json
+  signaliz gtm commit-plan --plan-file plan.json
+`,
+  "build-plan": `signaliz gtm build-plan "campaign brief" [options]
+
+Alias for signaliz gtm plan.
+`,
+  "campaign-plan": `signaliz gtm campaign-plan "campaign brief" [options]
+
+Alias for signaliz gtm plan.
+`,
+  "commit-plan": `signaliz gtm commit-plan --plan-file plan.json [options]
+
+Dry-run or write a reviewed GTM Kernel campaign plan into a campaign object.
+Dry-run is the default. Writes require both --write and --confirm.
+
+Options:
+  --plan-file FILE        JSON output from gtm plan --json
+  --plan-json JSON        Inline plan JSON
+  --name NAME             Campaign name for the committed object
+  --campaign-id ID        Override campaign id from the plan snapshot
+  --target-count N        Override target lead count
+  --write --confirm       Required together for writes; otherwise dry-run
+  --json                  Machine-readable output
+
+Safe next step:
+  signaliz gtm commit-plan --plan-file plan.json --write --confirm
+  signaliz gtm prepare-build <campaign_id> --build-input --json > build-args.json
+  signaliz campaign build --input-file build-args.json
+`,
+  "plan-commit": `signaliz gtm plan-commit --plan-file plan.json [options]
+
+Alias for signaliz gtm commit-plan.
+`,
+  "commit-build-plan": `signaliz gtm commit-build-plan --plan-file plan.json [options]
+
+Alias for signaliz gtm commit-plan.
+`,
+  "existing-campaigns": `signaliz gtm existing-campaigns [options]
+
+Discover existing linked/provider campaigns, starting with Instantly, before
+running a read-only Kernel/Brain audit or history import preview.
+
+Options:
+  --provider NAME         Provider to discover, default instantly
+  --integration-id ID     Optional Signaliz integration scope
+  --search TEXT           Optional campaign search text
+  --limit N               Max campaigns to return
+  --no-kernel-linked      Skip Kernel-linked campaign rows
+  --no-provider-live      Skip live provider discovery
+  --json                  Machine-readable output
+`,
+  "discover-existing": `signaliz gtm discover-existing [options]
+
+Alias for signaliz gtm existing-campaigns.
+`,
+  "audit-existing": `signaliz gtm audit-existing [options]
+
+Run a read-only existing campaign audit with completeness, recommendation cards,
+analysis surfaces, approval boundaries, and post-action verification JSON.
+
+Options:
+  --campaign-id ID        Optional linked Kernel campaign id
+  --provider NAME         Provider, default instantly
+  --provider-campaign-id ID
+                          Existing provider campaign id, e.g. Instantly
+  --campaign-name NAME    Optional display name for manual provider ids
+  --search TEXT           If no id is provided, discover and audit the first match
+  --days N                Lookback window
+  --no-route-preview      Skip route-preview surfaces
+  --no-memory             Skip memory surfaces
+  --no-brain              Skip Brain surfaces
+  --json                  Machine-readable output
+`,
+  "existing-audit": `signaliz gtm existing-audit [options]
+
+Alias for signaliz gtm audit-existing.
+`,
+  "prepare-build": `signaliz gtm prepare-build <campaign_id> [options]
+
+Derive exact build_campaign arguments from a committed GTM Kernel campaign
+without creating a build. Dry-run and confirm_spend=false are the defaults.
+
+Options:
+  --campaign-id ID        Campaign id when not passed positionally
+  --target-count N        Optional launch target count
+  --allow-downscale       Permit smaller launch counts when readiness requires it
+  --dedup-keys a,b        Override dedup keys
+  --policy-json JSON      Optional spend/policy object
+  --policy-file FILE      Optional spend/policy JSON file
+  --delivery-json JSON    Optional delivery object
+  --delivery-file FILE    Optional delivery JSON file
+  --delivery-risk-json JSON
+                          Optional delivery-risk clearance object
+  --delivery-risk-file FILE
+                          Optional delivery-risk JSON file
+  --no-brain-context      Skip compact Brain context in prepared args
+  --no-delivery-risk-clearance
+                          Do not require delivery-risk clearance
+  --write --confirm       Prepare approved launch args; otherwise dry-run args
+  --build-input           Output campaign build input instead of prepare receipt
+  --json                  Machine-readable output
+
+Safe next step:
+  signaliz gtm prepare-build <campaign_id> --build-input --json > build-args.json
+  signaliz campaign build --input-file build-args.json
+`,
+  "execution-prepare": `signaliz gtm execution-prepare <campaign_id> [options]
+
+Alias for signaliz gtm prepare-build.
+`,
+  "prepare-execution": `signaliz gtm prepare-execution <campaign_id> [options]
+
+Alias for signaliz gtm prepare-build.
+`,
+  integrations: `signaliz gtm integrations [options]
+
+Inspect provider activation cards for each GTM layer across routes, recipes,
+connections, planned providers, and fallback state.
+
+Options:
+  --campaign-id ID        Optional campaign scope
+  --layer NAME            Inspect one layer
+  --include-planned       Include planned/needs-setup providers
+  --no-connections        Skip connection details
+  --json                  Machine-readable output
+`,
+  activation: `signaliz gtm activation [options]
+
+Alias for signaliz gtm integrations.
+`,
+  "route-preview": `signaliz gtm route-preview --layer <layer> [options]
+
+Preview the effective provider route for a GTM layer without writing state.
+
+Options:
+  --campaign-id ID        Optional campaign scope
+  --layer NAME            GTM layer to preview
+  --records-json JSON     Optional sample records
+  --records-file FILE     Optional sample records JSON file
+  --context-json JSON     Optional route context
+  --json                  Machine-readable output
+`,
+  "preview-route": `signaliz gtm preview-route --layer <layer> [options]
+
+Alias for signaliz gtm route-preview.
+`,
+  "activate-route": `signaliz gtm activate-route --provider-id <provider_id> --layer <layer> [options]
+
+Dry-run or confirm provider route setup. Dry-run is the default. Confirmed
+writes require both --write and --confirm.
+
+Options:
+  --campaign-id ID        Optional campaign scope
+  --provider-id ID        Provider to activate, for example instantly
+  --layer NAME            Single layer to activate
+  --layers a,b            Multiple layers to activate
+  --keep-existing-routes  Do not archive competing routes
+  --no-signaliz-fallback  Disable Signaliz fallback for this route
+  --write --confirm       Required together for writes; otherwise dry-run
+  --json                  Machine-readable output
+`,
+  "route-activate": `signaliz gtm route-activate --provider-id <provider_id> --layer <layer> [options]
+
+Alias for signaliz gtm activate-route.
+`,
+  execution: `signaliz gtm execution <campaign_id> [options]
+
+Inspect campaign execution and provider readiness before launch handoff.
+
+Options:
+  --campaign-id ID        Campaign id
+  --campaign-build-id ID  Optional Campaign Builder build id
+  --no-provider-readiness Skip provider readiness details
+  --no-feedback           Skip feedback details
+  --no-memory             Skip memory details
+  --no-log                Skip recent log details
+  --json                  Machine-readable output
+`,
+  readiness: `signaliz gtm readiness <campaign_id> [options]
+
+Alias for signaliz gtm execution.
+`,
+  campaigns: `signaliz gtm campaigns [options]
+
+List first-class GTM Kernel campaigns.
+
+Options:
+  --status STATUS         Filter by campaign status
+  --provider ID           Filter by provider
+  --search TEXT           Search campaigns
+  --limit N               Max campaigns
+  --include-archived      Include archived campaigns
+  --json                  Machine-readable output
+`,
+  campaign: `signaliz gtm campaign <campaign_id> [options]
+
+Inspect one first-class GTM Kernel campaign.
+
+Options:
+  --log-limit N           Max campaign log rows
+  --memory-limit N        Max memory rows
+  --json                  Machine-readable output
+`,
+  memory: `signaliz gtm memory "query" [options]
+
+Search ranked workspace memory for GTM evidence.
+
+Options:
+  --campaign-id ID        Optional campaign scope
+  --memory-type TYPE      Filter by memory type
+  --outcome-type TYPE     Filter by outcome type
+  --days N                Lookback window
+  --limit N               Max memory rows
+  --json                  Machine-readable output
+`
+};
+function gtmHelpFor(sub) {
+  if (!sub) return GTM_HELP;
+  return GTM_COMMAND_HELP[sub] || GTM_HELP;
+}
+function isHelpRequest(args) {
+  return args[0] === "help" || args.includes("--help") || args.includes("-h");
+}
 async function authLogin() {
   info("Signaliz Authentication Setup");
   info("\u2500".repeat(40));
@@ -5243,11 +6211,131 @@ async function health() {
     }
   );
 }
+async function start() {
+  const sdk = getSdk();
+  const read = async (name, fn) => {
+    try {
+      return { name, ok: true, data: await fn() };
+    } catch (err) {
+      return { name, ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  };
+  const [workspaceState, platformState, proofState, bootstrapState, integrationsState] = await Promise.all([
+    read("workspace", () => sdk.getWorkspace()),
+    read("platform", () => sdk.getPlatformHealth()),
+    read("ops_proof", () => sdk.ops.proof({ windowHours: numberFlag("window-hours") || numberFlag("lookback-hours") || 720 })),
+    read("gtm_bootstrap", () => sdk.gtm.bootstrapStatus({
+      includeConnections: true,
+      includeSamples: false,
+      limit: numberFlag("limit") || 10
+    })),
+    read("gtm_integrations", () => sdk.gtm.integrationsActivationStatus({
+      includePlanned: true,
+      includeConnections: true
+    }))
+  ]);
+  const workspace = workspaceState.ok ? workspaceState.data : null;
+  const platform = platformState.ok ? platformState.data : null;
+  const proof = proofState.ok ? proofState.data : null;
+  const bootstrap = bootstrapState.ok ? bootstrapState.data : null;
+  const integrations = integrationsState.ok ? integrationsState.data : null;
+  const integrationSummary = integrations?.summary || {};
+  const gates = Array.isArray(bootstrap?.gates) ? bootstrap.gates : [];
+  const readyGates = gates.filter((gate) => gate.ready === true || gate.status === "ready").length;
+  const blockedLayers = Number(integrationSummary.blocked_layers || 0);
+  const readyLayers = Number(integrationSummary.ready_layers || 0);
+  const totalLayers = Number(integrationSummary.total_layers || 0);
+  const proofStatus = String(proof?.status || "unknown");
+  const brief = flagArg("campaign-brief") || flagArg("brief") || "Build a focused campaign for my ICP";
+  let nextMove = "Build a read-only campaign plan";
+  let nextCommand = `signaliz gtm plan ${JSON.stringify(brief)} --target-count 50`;
+  let why = "This is the safest starting point: it plans the campaign, memory, routes, and blockers without spending credits or writing to providers.";
+  if (blockedLayers > 0) {
+    nextMove = "Connect or fix blocked provider routes";
+    nextCommand = "signaliz gtm integrations --include-planned";
+    why = `${blockedLayers} GTM layer${blockedLayers === 1 ? "" : "s"} are blocked. Resolve routes before launch approval or sender/export work.`;
+  } else if (proofStatus === "blocked" || proofStatus === "partial") {
+    nextMove = "Prove Ops delivery before scaling";
+    nextCommand = "signaliz ops proof";
+    why = "Ops has some proof gaps. Use proof before relying on always-on routines or external delivery.";
+  } else if (gates.length && readyGates < gates.length) {
+    nextMove = "Inspect GTM Kernel readiness";
+    nextCommand = "signaliz gtm bootstrap --include-samples";
+    why = `Kernel readiness is ${readyGates}/${gates.length}; inspect the missing gates before committing a campaign.`;
+  }
+  const commands = [
+    { label: "Build a campaign plan", command: `signaliz gtm plan ${JSON.stringify(brief)} --target-count 50`, safety: "read-only" },
+    { label: "Connect tools/routes", command: "signaliz gtm integrations --include-planned", safety: "read-only" },
+    { label: "Audit past campaigns", command: "signaliz gtm existing-campaigns --provider instantly --limit 5", safety: "read-only" },
+    { label: "Prove Ops delivery", command: "signaliz ops proof", safety: "read-only" },
+    { label: "Let Signaliz recommend a motion", command: "signaliz ops autopilot", safety: "read-only" }
+  ];
+  const result = {
+    success: true,
+    mode: "read_only_start",
+    product_positioning: {
+      plain_english: "Signaliz is the GTM brain over any stack. Start in CLI/Codex/MCP for agent-run work; use the UI as the cockpit for humans to inspect, connect, approve, and monitor.",
+      recommended_primary_surface: "CLI/MCP for building and auditing; UI for approvals, route setup, and monitoring."
+    },
+    workspace,
+    platform,
+    readiness: {
+      ops_proof_status: proofStatus,
+      kernel_gates_ready: readyGates,
+      kernel_gates_total: gates.length,
+      provider_layers_ready: readyLayers,
+      provider_layers_total: totalLayers,
+      provider_layers_blocked: blockedLayers
+    },
+    next_move: {
+      title: nextMove,
+      why,
+      command: nextCommand
+    },
+    safe_commands: commands,
+    raw_status: {
+      workspace: workspaceState,
+      platform: platformState,
+      ops_proof: proofState,
+      gtm_bootstrap: bootstrapState,
+      gtm_integrations: integrationsState
+    }
+  };
+  return output(result, () => {
+    console.log("Signaliz start");
+    console.log("  What it is: Signaliz is the GTM brain over any stack.");
+    console.log("  Best surface: CLI/MCP/Codex to build and audit; UI to inspect, connect, approve, and monitor.");
+    if (workspace) {
+      console.log(`  Workspace: ${workspace.name} (${workspace.plan})`);
+      console.log(`  Credits:   ${workspace.creditsRemaining}`);
+    }
+    if (platform) {
+      console.log(`  MCP:       ${platform.status} | errors ${platform.errorRate} | p95 ${platform.latency.p95}ms`);
+    }
+    console.log("");
+    console.log(`Next safest move: ${nextMove}`);
+    console.log(`Why: ${why}`);
+    console.log(`Run: ${nextCommand}`);
+    console.log("");
+    console.log("Safe starting commands");
+    for (const command of commands) console.log(`- ${command.label}: ${command.command} (${command.safety})`);
+    const failedReads = [workspaceState, platformState, proofState, bootstrapState, integrationsState].filter((item) => !item.ok);
+    if (failedReads.length) {
+      console.log("");
+      console.log("Some read-only checks failed");
+      for (const item of failedReads) console.log(`- ${item.name}: ${item.error}`);
+    }
+  });
+}
 async function tools() {
   const sdk = getSdk();
   const category = flagArg("category");
   const allTools = await sdk.listTools();
-  const filtered = category ? allTools.filter((tool) => tool.category === category) : allTools;
+  const toolsWithCategories = allTools.map((tool) => ({
+    ...tool,
+    category: normalizeMcpToolCategory(tool)
+  }));
+  const filtered = category ? toolsWithCategories.filter((tool) => tool.category === category) : toolsWithCategories;
   output(
     { success: true, data: filtered, count: filtered.length, category },
     () => {
@@ -5423,7 +6511,7 @@ async function campaignBuild() {
   const inputFile = flagArg("input-file");
   if (inputFile) {
     const raw = (0, import_node_fs.readFileSync)(inputFile, "utf8");
-    config = JSON.parse(raw);
+    config = normalizeCampaignBuildInput(JSON.parse(raw));
   } else {
     const promptText = flagArg("prompt");
     if (!promptText) {
@@ -5804,7 +6892,577 @@ async function lead(sub, rest) {
   die("Usage: signaliz lead <generate|local|sources|source|status>");
 }
 async function gtm(sub, rest) {
+  if (isHelpRequest(rest)) {
+    process.stdout.write(gtmHelpFor(sub));
+    return;
+  }
   const sdk = getSdk();
+  if (sub === "plan" || sub === "build-plan" || sub === "campaign-plan") {
+    const campaignBrief = promptArg(rest) || flagArg("campaign-brief") || flagArg("brief");
+    if (!campaignBrief && !flagArg("campaign-id") && !flagArg("campaign-build-id") && !flagArg("build-id")) {
+      die('Usage: signaliz gtm plan "campaign brief" [--target-count N] [--layers a,b] [--preferred-providers a,b]');
+    }
+    const result = await sdk.gtm.campaignBuildPlan({
+      campaignId: flagArg("campaign-id"),
+      campaignBuildId: flagArg("campaign-build-id") || flagArg("build-id"),
+      campaignBrief,
+      targetIcp: readJsonObjectInput("target-icp-json", "target-icp-file"),
+      leadCount: numberFlag("lead-count") || numberFlag("target-count"),
+      layers: csvFlag("layers"),
+      preferredProviders: csvFlag("preferred-providers") || csvFlag("providers"),
+      memoryDimensionFilters: readJsonObjectInput("memory-dimension-filters-json", "memory-dimension-filters-file"),
+      requireMemoryDimensionMatch: hasFlag("require-memory-dimension-match") || void 0,
+      includeMemory: !hasFlag("no-memory"),
+      includeBrain: !hasFlag("no-brain"),
+      includeProviderRoutes: !hasFlag("no-provider-routes"),
+      includeFailurePatterns: !hasFlag("no-failure-patterns"),
+      includePlannedProviders: hasFlag("include-planned"),
+      days: numberFlag("days"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      const blockers = Array.isArray(result.blockers) ? result.blockers : [];
+      const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+      const flow = Array.isArray(result.mcp_flow) ? result.mcp_flow : [];
+      const activation = result.provider_activation?.summary || {};
+      console.log("GTM campaign build plan");
+      console.log(`  Brief:    ${campaignBrief || result.campaign?.name || result.campaign?.id || "workspace plan"}`);
+      console.log(`  Blockers: ${blockers.length}`);
+      console.log(`  Warnings: ${warnings.length}`);
+      if (activation.total_layers !== void 0) {
+        console.log(`  Routes:   ${activation.ready_layers || 0}/${activation.total_layers || 0} layers ready`);
+      }
+      const rankedMemory = result.memory_retrieval?.total_ranked;
+      if (rankedMemory !== void 0) console.log(`  Memory:   ${rankedMemory} ranked rows`);
+      if (flow.length) {
+        console.log("  Next MCP flow:");
+        for (const step of flow.slice(0, 5)) console.log(`  - ${step.tool || step.name || "unknown_tool"}`);
+      }
+      if (blockers.length) console.log(`  First blocker: ${blockers[0]}`);
+      hint("Review the plan. Save JSON with --json, then dry-run a commit with signaliz gtm commit-plan --plan-file plan.json");
+    });
+  }
+  if (sub === "commit-plan" || sub === "plan-commit" || sub === "commit-build-plan") {
+    const planSnapshot = readJsonObjectInput("plan-json", "plan-file");
+    const planQuery = planSnapshot?.query && typeof planSnapshot.query === "object" ? planSnapshot.query : {};
+    const planCampaign = planSnapshot?.campaign && typeof planSnapshot.campaign === "object" ? planSnapshot.campaign : {};
+    const campaignBrief = promptArg(rest) || flagArg("campaign-brief") || flagArg("brief") || String(planQuery.campaign_brief || "");
+    const write = hasFlag("write");
+    const confirm = hasFlag("confirm");
+    if (!planSnapshot && !campaignBrief && !flagArg("campaign-id") && !flagArg("campaign-build-id") && !flagArg("build-id")) {
+      die("Usage: signaliz gtm commit-plan --plan-file plan.json [--write --confirm]");
+    }
+    const leadCount = numberFlag("lead-count") || numberFlag("target-count") || Number(planQuery.lead_count) || void 0;
+    const result = await sdk.gtm.commitCampaignBuildPlan({
+      campaignId: flagArg("campaign-id") || planCampaign.id,
+      campaignBuildId: flagArg("campaign-build-id") || flagArg("build-id") || String(planSnapshot?.campaign_build_id || "") || void 0,
+      name: flagArg("name") || planCampaign.name,
+      campaignBrief: campaignBrief || void 0,
+      targetIcp: readJsonObjectInput("target-icp-json", "target-icp-file") || planQuery.target_icp,
+      leadCount,
+      layers: csvFlag("layers") || planQuery.layers,
+      preferredProviders: csvFlag("preferred-providers") || csvFlag("providers") || planQuery.preferred_providers,
+      planSnapshot,
+      sendConfig: readJsonObjectInput("send-config-json", "send-config-file"),
+      brainConfig: readJsonObjectInput("brain-config-json", "brain-config-file"),
+      metadata: readJsonObjectInput("metadata-json", "metadata-file"),
+      status: flagArg("status") || "draft",
+      approvalRequired: !hasFlag("no-approval-required"),
+      actorType: flagArg("actor-type") || "agent",
+      actorId: flagArg("actor-id") || "signaliz_cli",
+      rationale: flagArg("rationale") || "Committed a reviewed GTM campaign build plan through the Signaliz CLI.",
+      idempotencyKey: flagArg("idempotency-key"),
+      dryRun: !(write && confirm),
+      confirm: write && confirm
+    });
+    return output(result, () => {
+      const commitPlan = result.commit_plan || {};
+      const blockers = Array.isArray(result.blockers) ? result.blockers : Array.isArray(commitPlan.blockers) ? commitPlan.blockers : [];
+      const warnings = Array.isArray(result.warnings) ? result.warnings : Array.isArray(commitPlan.warnings) ? commitPlan.warnings : [];
+      console.log("GTM campaign plan commit");
+      console.log(`  Mode:     ${write && confirm ? "write" : "dry_run"}`);
+      console.log(`  Write:    ${commitPlan.ready_to_write === false ? "blocked" : commitPlan.ready_to_write === true ? "ready" : "review"}`);
+      if (result.campaign?.id) console.log(`  Campaign: ${result.campaign.id}`);
+      if (blockers.length) console.log(`  Blockers: ${blockers.join("; ")}`);
+      if (warnings.length) console.log(`  Warnings: ${warnings.join("; ")}`);
+      if (!(write && confirm)) hint("Review the dry-run. To write the campaign object: add --write --confirm.");
+    });
+  }
+  if (sub === "prepare-build" || sub === "execution-prepare" || sub === "prepare-execution") {
+    const campaignId = rest[0] || flagArg("campaign-id");
+    if (!campaignId) die("Usage: signaliz gtm prepare-build <campaign_id> [--target-count N] [--json]");
+    const write = hasFlag("write");
+    const confirm = hasFlag("confirm");
+    const result = await sdk.gtm.prepareCampaignBuildExecution({
+      campaignId,
+      targetCount: numberFlag("target-count") || numberFlag("lead-count"),
+      allowDownscale: hasFlag("allow-downscale") || void 0,
+      dryRun: !(write && confirm),
+      confirmSpend: write && confirm,
+      includeBrainContext: !hasFlag("no-brain-context"),
+      requireDeliveryRiskClearance: !hasFlag("no-delivery-risk-clearance"),
+      deliveryRisk: readJsonObjectInput("delivery-risk-json", "delivery-risk-file"),
+      dedupKeys: csvFlag("dedup-keys"),
+      policy: readJsonObjectInput("policy-json", "policy-file"),
+      signals: readJsonObjectInput("signals-json", "signals-file"),
+      qualification: readJsonObjectInput("qualification-json", "qualification-file"),
+      copy: readJsonObjectInput("copy-json", "copy-file"),
+      delivery: readJsonObjectInput("delivery-json", "delivery-file"),
+      enhancers: readJsonObjectInput("enhancers-json", "enhancers-file")
+    });
+    if (hasFlag("build-input")) {
+      return output(normalizeCampaignBuildInput(result));
+    }
+    return output(result, () => {
+      const blockers = Array.isArray(result.blockers) ? result.blockers : [];
+      const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+      const buildArgs = result.build_campaign_arguments || result.buildCampaignArguments || {};
+      console.log("GTM campaign build prepare");
+      console.log(`  Campaign: ${result.campaign?.id || campaignId}`);
+      console.log(`  Mode:     ${write && confirm ? "approved_launch_args" : "dry_run_args"}`);
+      console.log(`  Ready:    ${result.ready_to_launch === true ? "yes" : result.ready_to_launch === false ? "no" : "review"}`);
+      if (Object.keys(buildArgs).length) console.log(`  Build args: ready`);
+      if (blockers.length) console.log(`  Blockers: ${blockers.join("; ")}`);
+      if (warnings.length) console.log(`  Warnings: ${warnings.join("; ")}`);
+      if (!(write && confirm)) {
+        hint("Save build input with --build-input --json, then run signaliz campaign build --input-file build-args.json.");
+      }
+    });
+  }
+  if (sub === "context" || sub === "kernel" || sub === "workspace") {
+    const result = await sdk.gtm.context({
+      includeCampaigns: !hasFlag("no-campaigns"),
+      includeMemory: !hasFlag("no-memory"),
+      includeBrain: !hasFlag("no-brain"),
+      includeConnections: !hasFlag("no-connections"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      const workspace = result.workspace || {};
+      const connections = result.connections || {};
+      const connectionCount = ["integrations", "mcp_servers", "app_connections", "integration_recipes", "layer_routes"].reduce((sum, key) => sum + (Array.isArray(connections[key]) ? connections[key].length : 0), 0);
+      console.log("GTM Kernel context");
+      console.log(`  Workspace:   ${workspace.name || workspace.id || "unknown"}`);
+      console.log(`  Campaigns:   ${Array.isArray(result.campaigns) ? result.campaigns.length : 0}`);
+      console.log(`  Memory:      ${Array.isArray(result.memory) ? result.memory.length : 0}`);
+      console.log(`  Brain rows:  ${Array.isArray(result.brain_patterns) ? result.brain_patterns.length : 0}`);
+      console.log(`  Connections: ${connectionCount}`);
+      hint("signaliz gtm bootstrap --include-samples");
+    });
+  }
+  if (sub === "bootstrap" || sub === "doctor") {
+    const result = await sdk.gtm.bootstrapStatus({
+      campaignId: flagArg("campaign-id"),
+      days: numberFlag("days"),
+      minSampleSize: numberFlag("min-sample-size"),
+      includeConnections: !hasFlag("no-connections"),
+      includeSamples: hasFlag("include-samples"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      const gates = Array.isArray(result.gates) ? result.gates : [];
+      const ready = gates.filter((gate) => gate.ready === true || gate.status === "ready").length;
+      const nextTools = [...new Set(gates.flatMap((gate) => Array.isArray(gate.next_tools) ? gate.next_tools : []))].slice(0, 5);
+      console.log("GTM Kernel bootstrap");
+      console.log(`  Status: ${result.status || result.overall_status || (ready === gates.length ? "ready" : "needs_setup")}`);
+      console.log(`  Gates:  ${ready}/${gates.length || 0} ready`);
+      if (Array.isArray(result.blockers) && result.blockers.length) console.log(`  Blockers: ${result.blockers.length}`);
+      if (Array.isArray(result.warnings) && result.warnings.length) console.log(`  Warnings: ${result.warnings.length}`);
+      if (nextTools.length) console.log(`  Next tools: ${nextTools.join(", ")}`);
+      hint("signaliz gtm campaigns");
+    });
+  }
+  if (sub === "campaigns") {
+    const result = await sdk.gtm.listCampaigns({
+      status: flagArg("status"),
+      provider: flagArg("provider"),
+      search: flagArg("search"),
+      limit: numberFlag("limit"),
+      includeArchived: hasFlag("include-archived")
+    });
+    return output(result, () => {
+      const campaigns = Array.isArray(result.campaigns) ? result.campaigns : Array.isArray(result) ? result : [];
+      console.log(`GTM Kernel campaigns (${campaigns.length})`);
+      for (const campaign2 of campaigns) {
+        const build = campaign2.campaign_build_id ? ` build=${campaign2.campaign_build_id}` : "";
+        console.log(`- ${campaign2.id}: ${campaign2.name || "Untitled"} [${campaign2.status || "unknown"}]${build}`);
+      }
+      if (campaigns[0]?.id) hint(`signaliz gtm campaign ${campaigns[0].id}`);
+    });
+  }
+  if (sub === "campaign") {
+    const campaignId = rest[0] || flagArg("campaign-id");
+    if (!campaignId) die("Usage: signaliz gtm campaign <campaign_id>");
+    const result = await sdk.gtm.getCampaign(campaignId, {
+      logLimit: numberFlag("log-limit"),
+      memoryLimit: numberFlag("memory-limit")
+    });
+    return output(result, () => {
+      const campaign2 = result.campaign || result;
+      console.log("GTM Kernel campaign");
+      console.log(`  ID:     ${campaign2.id || campaignId}`);
+      console.log(`  Name:   ${campaign2.name || "Untitled"}`);
+      console.log(`  Status: ${campaign2.status || "unknown"}`);
+      console.log(`  Source: ${campaign2.source || "unknown"}`);
+      if (campaign2.campaign_build_id) console.log(`  Build:  ${campaign2.campaign_build_id}`);
+      const links = Array.isArray(result.provider_links) ? result.provider_links.length : 0;
+      const memory = Array.isArray(result.memory) ? result.memory.length : 0;
+      const logs = Array.isArray(result.logs) ? result.logs.length : 0;
+      console.log(`  Provider links: ${links}`);
+      console.log(`  Memory:         ${memory}`);
+      console.log(`  Logs:           ${logs}`);
+      hint(`signaliz gtm learning ${campaign2.id || campaignId}`);
+    });
+  }
+  if (sub === "existing-campaigns" || sub === "discover-existing" || sub === "campaign-discover") {
+    const provider = (flagArg("provider") || rest[0] || "instantly").toLowerCase();
+    const result = await sdk.gtm.discoverExistingCampaigns({
+      provider,
+      integrationId: flagArg("integration-id"),
+      search: flagArg("search"),
+      limit: numberFlag("limit"),
+      includeKernelLinked: !hasFlag("no-kernel-linked"),
+      includeProviderLive: !hasFlag("no-provider-live")
+    });
+    return output(result, () => {
+      const campaigns = Array.isArray(result.campaigns) ? result.campaigns : [];
+      const counts = result.counts || {};
+      console.log(`Existing ${provider} campaigns (${campaigns.length})`);
+      if (counts.total_returned !== void 0) console.log(`  Returned:       ${counts.total_returned}`);
+      if (counts.kernel_linked !== void 0) console.log(`  Kernel linked:  ${counts.kernel_linked}`);
+      if (counts.provider_live !== void 0) console.log(`  Provider live:  ${counts.provider_live}`);
+      for (const campaign2 of campaigns.slice(0, 10)) {
+        const providerId = campaign2.provider_campaign_id ? ` provider=${campaign2.provider_campaign_id}` : "";
+        const linked = campaign2.linked_kernel_campaign_id ? ` kernel=${campaign2.linked_kernel_campaign_id}` : "";
+        console.log(`- ${campaign2.name || campaign2.provider_campaign_id || "Untitled"} [${campaign2.status || "unknown"}]${providerId}${linked}`);
+      }
+      const first = campaigns[0];
+      if (first?.provider_campaign_id || first?.linked_kernel_campaign_id) {
+        hint(`signaliz gtm audit-existing --provider ${provider}${first.provider_campaign_id ? ` --provider-campaign-id ${first.provider_campaign_id}` : ""}${first.linked_kernel_campaign_id ? ` --campaign-id ${first.linked_kernel_campaign_id}` : ""}`);
+      }
+    });
+  }
+  if (sub === "audit-existing" || sub === "existing-audit" || sub === "campaign-audit") {
+    let campaignId = flagArg("campaign-id");
+    let providerCampaignId = flagArg("provider-campaign-id") || flagArg("instantly-campaign-id") || positionalAfter(sub);
+    const provider = (flagArg("provider") || "instantly").toLowerCase();
+    let campaignName = flagArg("campaign-name") || flagArg("name");
+    const search = flagArg("search");
+    if (!campaignId && !providerCampaignId && search) {
+      const discovery = await sdk.gtm.discoverExistingCampaigns({
+        provider,
+        search,
+        limit: 1,
+        includeKernelLinked: !hasFlag("no-kernel-linked"),
+        includeProviderLive: !hasFlag("no-provider-live")
+      });
+      const match = Array.isArray(discovery.campaigns) ? discovery.campaigns[0] : null;
+      campaignId = match?.linked_kernel_campaign_id || void 0;
+      providerCampaignId = match?.provider_campaign_id || void 0;
+      campaignName = campaignName || match?.name || match?.linked_kernel_campaign_name;
+      if (!campaignId && !providerCampaignId) {
+        die(`No existing ${provider} campaign matched "${search}". Try signaliz gtm existing-campaigns --provider ${provider} --search "${search}".`);
+      }
+    }
+    if (!campaignId && !providerCampaignId) die("Usage: signaliz gtm audit-existing --provider-campaign-id <id> [--campaign-id ID] or --search <campaign name>");
+    const result = await sdk.gtm.auditExistingCampaign({
+      campaignId,
+      provider,
+      providerCampaignId,
+      campaignName,
+      days: numberFlag("days"),
+      includeRoutePreview: !hasFlag("no-route-preview"),
+      includeMemory: !hasFlag("no-memory"),
+      includeBrain: !hasFlag("no-brain")
+    });
+    return output(result, () => {
+      const completeness = Array.isArray(result.completeness) ? result.completeness : [];
+      const ready = completeness.filter((step) => step.ready === true).length;
+      const recommendations = Array.isArray(result.recommendations) ? result.recommendations : [];
+      const surfaces = Array.isArray(result.analysis_surfaces) ? result.analysis_surfaces : [];
+      const packet = result.improvement_packet || result.audit_packet?.improvement_packet || {};
+      const keepCount = arrayCount(packet.keep);
+      const fixCount = arrayCount(packet.fix_before_scale || packet.fixBeforeScale);
+      const improveCount = arrayCount(packet.improve_next || packet.improveNext);
+      const approveCount = arrayCount(packet.approve_only_after_review || packet.approveOnlyAfterReview);
+      const verifyCount = arrayCount(packet.verify);
+      const nextSafeAction = firstExistingCampaignSafeAction(result);
+      const nextSafeTool = nextSafeAction?.tool || nextSafeAction?.suggested_tool || nextSafeAction?.next_safe_request?.tool;
+      const nextSafeBoundary = nextSafeAction?.approval_boundary || nextSafeAction?.approvalBoundary;
+      const nextSafeTitle = nextSafeAction?.title || nextSafeAction?.id || nextSafeTool;
+      console.log("Existing campaign audit");
+      console.log(`  Provider:        ${result.provider || provider}`);
+      if (result.provider_campaign_id || providerCampaignId) console.log(`  Provider ID:     ${result.provider_campaign_id || providerCampaignId}`);
+      if (result.campaign?.id || campaignId) console.log(`  Kernel campaign: ${result.campaign?.id || campaignId}`);
+      if (result.audit_score !== void 0) console.log(`  Audit score:     ${result.audit_score}`);
+      console.log(`  Completeness:    ${ready}/${completeness.length} ready`);
+      console.log(`  Recommendations: ${recommendations.length}`);
+      if (surfaces.length) console.log(`  Proof surfaces:  ${surfaces.length}`);
+      if (keepCount || fixCount || improveCount || approveCount || verifyCount) {
+        console.log(`  Packet:          keep ${keepCount} | fix ${fixCount} | improve ${improveCount} | approve ${approveCount} | verify ${verifyCount}`);
+      }
+      if (nextSafeAction) {
+        console.log(`  Next safe:       ${nextSafeTitle || "Review next action"}${nextSafeBoundary ? ` [${labelize(nextSafeBoundary)}]` : ""}`);
+        if (nextSafeTool) console.log(`  Next tool:       ${nextSafeTool}`);
+      }
+      if (Array.isArray(result.blockers) && result.blockers.length) console.log(`  Blockers:        ${result.blockers.join("; ")}`);
+      hint(`Use --json to inspect exact MCP requests before running any gated action.`);
+    });
+  }
+  if (sub === "memory") {
+    const query = promptArg(rest) || flagArg("query");
+    const result = await sdk.gtm.searchMemory({
+      query,
+      campaignId: flagArg("campaign-id"),
+      memoryType: flagArg("memory-type"),
+      outcomeType: flagArg("outcome-type"),
+      days: numberFlag("days"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      const memories = Array.isArray(result.memories) ? result.memories : [];
+      console.log(`GTM Kernel memory (${memories.length})`);
+      for (const memory of memories) {
+        const score = typeof memory.rank_score === "number" ? ` score=${memory.rank_score.toFixed(2)}` : "";
+        console.log(`- ${memory.title || memory.id || "Untitled"} [${memory.memory_type || "memory"}]${score}`);
+      }
+      if (!memories.length) console.log("No matching memory rows returned.");
+    });
+  }
+  if (sub === "learning") {
+    const campaignId = rest[0] || flagArg("campaign-id");
+    if (!campaignId) die("Usage: signaliz gtm learning <campaign_id>");
+    const result = await sdk.gtm.learningCyclePlan({
+      campaignId,
+      includeNetwork: hasFlag("include-network"),
+      writeMode: flagArg("write-mode") || "dry_run",
+      days: numberFlag("days"),
+      networkDays: numberFlag("network-days"),
+      minSampleSize: numberFlag("min-sample-size"),
+      minWorkspaceCount: numberFlag("min-workspace-count"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      const lanes = Array.isArray(result.learning_lanes) ? result.learning_lanes : [];
+      const calls = Array.isArray(result.recommended_tool_calls) ? result.recommended_tool_calls : [];
+      const ready = lanes.filter((lane) => lane.state === "ready").length;
+      console.log("GTM Brain learning plan");
+      console.log(`  Campaign: ${campaignId}`);
+      console.log(`  Lanes:    ${ready}/${lanes.length} ready`);
+      console.log(`  Calls:    ${calls.length}`);
+      for (const call of calls.slice(0, 5)) {
+        const state = call.ready === false ? "blocked" : "ready";
+        console.log(`- ${call.tool || call.name || "unknown_tool"} [${state}]`);
+      }
+      hint(`signaliz gtm bootstrap --campaign-id ${campaignId}`);
+    });
+  }
+  if (sub === "learning-run" || sub === "run-learning") {
+    const campaignId = rest[0] || flagArg("campaign-id");
+    if (!campaignId) die("Usage: signaliz gtm learning-run <campaign_id>");
+    const result = await sdk.gtm.learningCycleRun({
+      campaignId,
+      includeMemory: !hasFlag("no-memory"),
+      includeNetwork: hasFlag("include-network"),
+      writeMode: flagArg("write-mode") || "dry_run",
+      phases: csvFlag("phases"),
+      continueOnError: !hasFlag("fail-fast"),
+      days: numberFlag("days"),
+      networkDays: numberFlag("network-days"),
+      minSampleSize: numberFlag("min-sample-size"),
+      minWorkspaceCount: numberFlag("min-workspace-count"),
+      minPrivacyK: numberFlag("min-privacy-k"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      console.log("GTM Brain learning run");
+      console.log(`  Campaign: ${campaignId}`);
+      console.log(`  Mode:     ${flagArg("write-mode") || "dry_run"}`);
+      if (result.run_id) console.log(`  Run ID:   ${result.run_id}`);
+      if (result.status) console.log(`  Status:   ${result.status}`);
+      const blocked = Array.isArray(result.blocked_phases) ? result.blocked_phases : [];
+      const queued = Array.isArray(result.queued_phases) ? result.queued_phases : Array.isArray(result.phases) ? result.phases : [];
+      if (queued.length) console.log(`  Queued:   ${queued.join(", ")}`);
+      if (blocked.length) console.log(`  Blocked:  ${blocked.join(", ")}`);
+      hint(`signaliz gtm learning ${campaignId}`);
+    });
+  }
+  if (sub === "calibrate" || sub === "calibration") {
+    const campaignId = rest[0] || flagArg("campaign-id");
+    if (!campaignId) die("Usage: signaliz gtm calibrate <campaign_id>");
+    const write = hasFlag("write");
+    const result = await sdk.gtm.calibrateDeliverability({
+      campaignId,
+      days: numberFlag("days"),
+      dimensionTypes: csvFlag("dimension-types"),
+      minSampleSize: numberFlag("min-sample-size"),
+      dryRun: !write,
+      writeCalibrations: write,
+      writePatterns: write && !hasFlag("no-patterns"),
+      replaceExisting: !hasFlag("keep-existing"),
+      limit: numberFlag("limit")
+    });
+    return output(result, () => {
+      console.log("GTM deliverability calibration");
+      console.log(`  Campaign: ${campaignId}`);
+      console.log(`  Mode:     ${write ? "write" : "dry_run"}`);
+      const calibrations = Array.isArray(result.calibrations) ? result.calibrations.length : Array.isArray(result.written_calibrations) ? result.written_calibrations.length : 0;
+      if (calibrations) console.log(`  Rows:     ${calibrations}`);
+      if (Array.isArray(result.blockers) && result.blockers.length) console.log(`  Blockers: ${result.blockers.join("; ")}`);
+      if (Array.isArray(result.warnings) && result.warnings.length) console.log(`  Warnings: ${result.warnings.join("; ")}`);
+      if (!write) hint("Review dry-run results. To write calibration rows: add --write.");
+    });
+  }
+  if (sub === "execution" || sub === "campaign-status" || sub === "readiness") {
+    const campaignId = rest[0] || flagArg("campaign-id");
+    const campaignBuildId = flagArg("campaign-build-id") || flagArg("build-id");
+    if (!campaignId && !campaignBuildId) die("Usage: signaliz gtm execution <campaign_id> [--campaign-build-id ID]");
+    const result = await sdk.gtm.campaignExecutionStatus({
+      campaignId,
+      campaignBuildId,
+      includeProviderReadiness: !hasFlag("no-provider-readiness"),
+      includeFeedback: !hasFlag("no-feedback"),
+      includeMemory: !hasFlag("no-memory"),
+      includeRecentLog: !hasFlag("no-log"),
+      logLimit: numberFlag("log-limit"),
+      memoryLimit: numberFlag("memory-limit")
+    });
+    return output(result, () => {
+      const summary = result.provider_readiness?.summary || {};
+      console.log("GTM campaign execution");
+      console.log(`  Campaign: ${result.campaign?.id || campaignId || "unknown"}`);
+      console.log(`  Stage:    ${result.execution_stage || "unknown"}`);
+      console.log(`  Ready:    ${result.ready === true ? "yes" : "no"}`);
+      if (summary.total_layers !== void 0) console.log(`  Routes:   ${summary.ready_layers || 0}/${summary.total_layers} ready`);
+      if (Array.isArray(result.blockers) && result.blockers.length) console.log(`  Blockers: ${result.blockers.join("; ")}`);
+      if (Array.isArray(result.next_actions) && result.next_actions[0]?.tool) console.log(`  Next:     ${result.next_actions[0].tool}`);
+      hint(`signaliz gtm integrations --campaign-id ${result.campaign?.id || campaignId || "<campaign_id>"} --include-planned`);
+    });
+  }
+  if (sub === "integrations" || sub === "activation") {
+    const result = await sdk.gtm.integrationsActivationStatus({
+      campaignId: flagArg("campaign-id"),
+      layer: flagArg("layer"),
+      includePlanned: hasFlag("include-planned"),
+      includeConnections: !hasFlag("no-connections")
+    });
+    return output(result, () => {
+      const summary = result.summary || {};
+      console.log("GTM provider activation");
+      console.log(`  Layers:  ${summary.ready_layers || 0}/${summary.total_layers || 0} ready`);
+      console.log(`  Blocked: ${summary.blocked_layers || 0}`);
+      for (const layer of (Array.isArray(result.layers) ? result.layers : []).slice(0, 8)) {
+        console.log(`- ${layer.layer}: ${layer.status || "unknown"} via ${layer.selected_provider_id || "none"}`);
+      }
+      hint("signaliz gtm route-preview --layer sender --campaign-id <campaign_id>");
+    });
+  }
+  if (sub === "route-preview" || sub === "preview-route") {
+    const layer = flagArg("layer") || rest[0];
+    if (!layer) die("Usage: signaliz gtm route-preview --layer <layer> [--campaign-id ID]");
+    const result = await sdk.gtm.previewLayerRoute({
+      campaignId: flagArg("campaign-id"),
+      layer,
+      sampleRecords: flagArg("records-file") ? readJsonValue(flagArg("records-file")) : readJsonFlag("records-json"),
+      context: readJsonFlag("context-json")
+    });
+    return output(result, () => {
+      const readiness = result.readiness || {};
+      console.log("GTM route preview");
+      console.log(`  Layer:    ${result.layer || layer}`);
+      console.log(`  Provider: ${result.selected_route?.provider_id || result.selected_recipe?.provider_id || "none"}`);
+      console.log(`  Ready:    ${readiness.ready === true ? "yes" : "no"}`);
+      if (Array.isArray(readiness.blockers) && readiness.blockers.length) console.log(`  Blockers: ${readiness.blockers.join("; ")}`);
+      if (Array.isArray(result.next_actions) && result.next_actions[0]?.action) console.log(`  Next:     ${result.next_actions[0].action}`);
+      hint("signaliz gtm activate-route --provider-id <provider> --layer <layer> --campaign-id <campaign_id>");
+    });
+  }
+  if (sub === "activate-route" || sub === "route-activate") {
+    const providerId = flagArg("provider-id") || rest[0];
+    if (!providerId) die("Usage: signaliz gtm activate-route --provider-id <provider_id> --layer <layer> [--write --confirm]");
+    const layers = csvFlag("layers");
+    const layer = flagArg("layer");
+    if (!layer && !layers?.length) die("--layer or --layers is required");
+    const write = hasFlag("write");
+    const confirm = hasFlag("confirm");
+    const result = await sdk.gtm.activateProviderRoute({
+      providerId,
+      providerName: flagArg("provider-name"),
+      campaignId: flagArg("campaign-id"),
+      layer,
+      layers,
+      invocationType: flagArg("invocation-type"),
+      authStrategy: flagArg("auth-strategy"),
+      endpointUrl: flagArg("endpoint-url"),
+      secretRef: flagArg("secret-ref"),
+      workspaceIntegrationId: flagArg("workspace-integration-id"),
+      workspaceMcpServerId: flagArg("workspace-mcp-server-id"),
+      workspaceConnectionId: flagArg("workspace-connection-id"),
+      useSignalizFallback: !hasFlag("no-signaliz-fallback"),
+      priority: numberFlag("priority"),
+      routeConfig: readJsonFlag("route-config-json"),
+      readiness: readJsonFlag("readiness-json"),
+      status: flagArg("status"),
+      routeStatus: flagArg("route-status"),
+      replaceExistingRoutes: !hasFlag("keep-existing-routes"),
+      dryRun: !(write && confirm),
+      confirm: write && confirm,
+      sampleRecords: flagArg("records-file") ? readJsonValue(flagArg("records-file")) : readJsonFlag("records-json"),
+      context: readJsonFlag("context-json")
+    });
+    return output(result, () => {
+      const plan = result.activation_plan || {};
+      console.log("GTM provider route activation");
+      console.log(`  Provider: ${providerId}`);
+      console.log(`  Mode:     ${write && confirm ? "write" : "dry_run"}`);
+      if (plan.execution_ready !== void 0) console.log(`  Execute:  ${plan.execution_ready ? "ready" : "not ready"}`);
+      if (plan.ready_to_write !== void 0) console.log(`  Write:    ${plan.ready_to_write ? "ready" : "blocked"}`);
+      const routes = Array.isArray(result.routes) ? result.routes.length : Array.isArray(result.route_candidates) ? result.route_candidates.length : 0;
+      if (routes) console.log(`  Routes:   ${routes}`);
+      const blockers = Array.isArray(result.blockers) ? result.blockers : Array.isArray(plan.blockers) ? plan.blockers : [];
+      const warnings = Array.isArray(result.warnings) ? result.warnings : Array.isArray(plan.warnings) ? plan.warnings : [];
+      if (blockers.length) console.log(`  Blockers: ${blockers.join("; ")}`);
+      if (warnings.length) console.log(`  Warnings: ${warnings.join("; ")}`);
+      if (!(write && confirm)) hint("Review the dry-run. To write: add --write --confirm.");
+    });
+  }
+  if (sub === "feedback-webhook" || sub === "prepare-feedback") {
+    const provider = (flagArg("provider") || rest[0] || "custom_webhook").toLowerCase();
+    const common = {
+      campaignId: flagArg("campaign-id"),
+      campaignBuildId: flagArg("campaign-build-id") || flagArg("build-id"),
+      providerLinkId: flagArg("provider-link-id"),
+      providerCampaignId: flagArg("provider-campaign-id"),
+      integrationId: flagArg("integration-id"),
+      providerWorkspaceId: flagArg("provider-workspace-id"),
+      providerAccountId: flagArg("provider-account-id"),
+      rotateSecret: hasFlag("rotate-secret"),
+      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")
+    };
+    const result = provider === "instantly" ? await sdk.gtm.prepareInstantlyFeedbackWebhook({
+      ...common,
+      instantlyCampaignId: flagArg("instantly-campaign-id")
+    }) : await sdk.gtm.prepareFeedbackWebhook({ provider, ...common });
+    return output(result, () => {
+      console.log("GTM feedback webhook");
+      console.log(`  Provider:    ${provider}`);
+      console.log(`  Brain cycle: ${common.runBrainCycle ? "enabled" : "disabled"} (${common.brainCycleWriteMode})`);
+      if (result.webhook_url_redacted) {
+        console.log(`  Webhook:     ${result.webhook_url_redacted}`);
+        console.log("  Private URL: available in --json output as webhook_url");
+      } else if (result.webhook_url) {
+        console.log("  Webhook:     ready");
+        console.log("  Private URL: available in --json output as webhook_url");
+      }
+      if (Array.isArray(result.blockers) && result.blockers.length) console.log(`  Blockers:    ${result.blockers.join("; ")}`);
+      hint(`signaliz gtm bootstrap${common.campaignId ? ` --campaign-id ${common.campaignId}` : ""} --include-samples`);
+    });
+  }
+  if (sub === "nango") return gtmNango(rest[0], rest.slice(1));
   if (!sub || sub === "list" || sub === "sources") {
     const result = await sdk.leads.listNativeGtmCapabilities(flagArg("category"));
     return output(result, () => {
@@ -5864,7 +7522,81 @@ ${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 <list|find|run|status>");
+  die("Usage: signaliz gtm <context|bootstrap|plan|commit-plan|prepare-build|campaigns|campaign|existing-campaigns|audit-existing|memory|learning|execution|integrations|activate-route|list|find|run|status|nango>");
+}
+function nangoActionInput() {
+  const fromFile = readJsonFlag("input-file");
+  const fromInline = readInlineJsonFlag("input-json");
+  if (fromFile && fromInline) die("Use --input-file or --input-json, not both");
+  return fromFile || fromInline;
+}
+function nangoBaseOptions() {
+  return {
+    workspaceConnectionId: flagArg("workspace-connection-id"),
+    connectionId: flagArg("connection-id"),
+    providerConfigKey: flagArg("provider-config-key"),
+    integrationId: flagArg("integration-id"),
+    nangoConnectionId: flagArg("nango-connection-id")
+  };
+}
+function nangoStatusUrl(result) {
+  return result?.status_url || result?.statusUrl || result?.nango_result?.status_url || result?.nango_result?.statusUrl;
+}
+async function gtmNango(sub, rest) {
+  const sdk = getSdk();
+  if (!sub || sub === "tools" || sub === "list") {
+    const result = await sdk.gtm.listNangoTools({
+      ...nangoBaseOptions(),
+      format: flagArg("format"),
+      includeRaw: hasFlag("include-raw")
+    });
+    return output(result, () => {
+      const tools2 = Array.isArray(result?.tools) ? result.tools : [];
+      console.log(`Nango tools: ${result?.tools_count ?? tools2.length}`);
+      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`);
+    });
+  }
+  if (sub === "call" || sub === "run") {
+    const actionName = 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 result = await sdk.gtm.callNangoTool({
+      ...nangoBaseOptions(),
+      actionName,
+      toolName,
+      input: nangoActionInput(),
+      async: hasFlag("async") || 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, () => {
+      console.log(`Nango action ${result?.status || "submitted"}: ${actionName || toolName}`);
+      const statusUrl = nangoStatusUrl(result);
+      if (statusUrl) console.log(`  Status URL: ${statusUrl}`);
+      if (result?.next_action) console.log(`  Next: ${result.next_action}`);
+      if (statusUrl) hint(`signaliz gtm nango result --status-url ${statusUrl}`);
+    });
+  }
+  if (sub === "result" || sub === "status") {
+    const actionId = 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 });
+    return output(result, () => {
+      console.log(`Nango action result: ${result?.status || "unknown"}`);
+      if (result?.action_id || actionId) console.log(`  Action ID: ${result?.action_id || actionId}`);
+      const nextStatusUrl = nangoStatusUrl(result);
+      if (nextStatusUrl) console.log(`  Status URL: ${nextStatusUrl}`);
+    });
+  }
+  die("Usage: signaliz gtm nango <tools|call|result>");
 }
 async function email(sub, rest) {
   const sdk = getSdk();
@@ -6200,6 +7932,7 @@ Available: ${result.available_types.join(", ")}`);
       }
       console.log(`Apps:      ${result.summary.connectedDestinations} connected, ${result.summary.failingDestinations} failing`);
       console.log(`Receipts:  ${result.summary.delivered30d} delivered, ${result.summary.externalDelivered30d} external`);
+      console.log(`Nango API: ${result.summary.nangoProofs30d ?? 0} receipts, ${result.summary.nangoFailures30d ?? 0} failures`);
       console.log(`CRM proof: ${result.summary.airbyteProofs30d} receipts, ${result.summary.airbyteFailures30d} failures`);
       if (result.destinations.length) {
         console.log("\nDestinations");
@@ -6637,6 +8370,109 @@ var OPS_SHORTCUTS = {
   "attach-sink": "attach-sink",
   saved: "saved"
 };
+async function withSyntheticArgs(args, fn) {
+  if (!args.length) return fn();
+  const originalArgv = process.argv;
+  process.argv = [...process.argv, ...args];
+  try {
+    return await fn();
+  } finally {
+    process.argv = originalArgv;
+  }
+}
+async function simpleJob(cmd, rest) {
+  if (cmd === "build") {
+    if (isHelpRequest(rest) || !promptArg(rest) && !flagArg("prompt") && !flagArg("brief") && !flagArg("campaign-brief")) {
+      process.stdout.write(`signaliz build "campaign brief" [options]
+
+Plan a campaign without spending credits or writing to providers.
+
+Examples:
+  signaliz build "Build a campaign for industrial maintenance buyers" --target-count 50
+  signaliz build "Audit prior Instantly performance and build the next campaign" --preferred-providers instantly
+
+Equivalent:
+  signaliz gtm plan "campaign brief"
+`);
+      return;
+    }
+    return gtm("plan", rest);
+  }
+  if (cmd === "connect") {
+    if (isHelpRequest(rest)) {
+      process.stdout.write(`signaliz connect [options]
+
+Inspect provider/tool route readiness across the GTM stack.
+
+Examples:
+  signaliz connect
+  signaliz connect --campaign-id <campaign_id>
+  signaliz connect --layer sender
+
+Equivalent:
+  signaliz gtm integrations --include-planned
+`);
+      return;
+    }
+    const defaults = rest.includes("--include-planned") ? [] : ["--include-planned"];
+    return withSyntheticArgs(defaults, () => gtm("integrations", rest));
+  }
+  if (cmd === "audit") {
+    if (isHelpRequest(rest)) {
+      process.stdout.write(`signaliz audit [options]
+
+Find previous campaigns to audit before building the next motion.
+
+Examples:
+  signaliz audit
+  signaliz audit --provider instantly --limit 10
+  signaliz gtm audit-existing --search "industrial maintenance"
+
+Equivalent:
+  signaliz gtm existing-campaigns --provider instantly --limit 5
+`);
+      return;
+    }
+    const defaults = [];
+    if (!rest.includes("--provider") && !rest.some((arg2) => arg2.startsWith("--provider="))) defaults.push("--provider", "instantly");
+    if (!rest.includes("--limit") && !rest.some((arg2) => arg2.startsWith("--limit="))) defaults.push("--limit", "5");
+    return withSyntheticArgs(defaults, () => gtm("existing-campaigns", rest));
+  }
+  if (cmd === "improve") {
+    if (isHelpRequest(rest) || !rest[0] && !flagArg("campaign-id")) {
+      process.stdout.write(`signaliz improve <campaign_id> [options]
+
+Plan Brain learning and improvement lanes for an existing campaign.
+
+Examples:
+  signaliz improve <campaign_id>
+  signaliz improve <campaign_id> --include-network --write-mode dry_run
+
+Equivalent:
+  signaliz gtm learning <campaign_id>
+`);
+      return;
+    }
+    return gtm("learning", rest);
+  }
+  if (cmd === "prove") {
+    if (isHelpRequest(rest)) {
+      process.stdout.write(`signaliz prove [options]
+
+Prove Ops delivery readiness before scaling a GTM motion.
+
+Examples:
+  signaliz prove
+  signaliz prove --json
+
+Equivalent:
+  signaliz ops proof
+`);
+      return;
+    }
+    return ops("proof", rest);
+  }
+}
 async function main() {
   const [, , cmd, ...rest] = process.argv;
   if (!cmd || cmd === "--help" || cmd === "-h") {
@@ -6645,6 +8481,9 @@ async function main() {
   }
   const opsShortcut = OPS_SHORTCUTS[cmd];
   if (opsShortcut) return ops(opsShortcut, rest);
+  if (["build", "connect", "audit", "improve", "prove"].includes(cmd)) {
+    return simpleJob(cmd, rest);
+  }
   switch (cmd) {
     case "auth": {
       const sub = rest[0];
@@ -6662,6 +8501,9 @@ async function main() {
       return whoami();
     case "health":
       return health();
+    case "start":
+    case "where-do-i-start":
+      return start();
     case "tools":
       return tools();
     case "discover":
@@ -6672,7 +8514,17 @@ async function main() {
     case "leads":
       return lead(rest[0], rest.slice(1));
     case "gtm":
+      if (!rest[0] || rest[0] === "--help" || rest[0] === "-h") {
+        process.stdout.write(GTM_HELP);
+        return;
+      }
+      if (rest[0] === "help") {
+        process.stdout.write(gtmHelpFor(rest[1]));
+        return;
+      }
       return gtm(rest[0], rest.slice(1));
+    case "nango":
+      return gtm("nango", rest);
     case "email":
     case "emails":
       return email(rest[0], rest.slice(1));