@signaliz/sdk 1.0.15 → 1.0.17

package/dist/index.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   createCampaignBuilderAgentRequestTemplate: () => createCampaignBuilderAgentRequestTemplate,
   createCampaignBuilderApproval: () => createCampaignBuilderApproval,
   createCampaignBuilderBuildKit: () => createCampaignBuilderBuildKit,
+  createCampaignBuilderMemoryKit: () => createCampaignBuilderMemoryKit,
   createCampaignBuilderProofReceipt: () => createCampaignBuilderProofReceipt,
   createCampaignBuilderReadiness: () => createCampaignBuilderReadiness,
   createCampaignBuilderToolRoute: () => createCampaignBuilderToolRoute,
@@ -264,25 +265,31 @@ var HttpClient = class {
   async getToken() {
     if (this.apiKey) return this.apiKey;
     if (this.accessToken) return this.accessToken;
-    const res = await fetch("https://api.signaliz.com/token", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grant_type: "client_credentials",
-        client_id: this.clientId,
-        client_secret: this.clientSecret
-      })
-    });
-    if (!res.ok) {
-      throw new SignalizError({
-        code: "AUTH_FAILED",
-        message: "Failed to obtain access token",
-        errorType: "auth_expired"
+    if (this.accessTokenPromise) return this.accessTokenPromise;
+    this.accessTokenPromise = (async () => {
+      const res = await fetch("https://api.signaliz.com/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          grant_type: "client_credentials",
+          client_id: this.clientId,
+          client_secret: this.clientSecret
+        })
       });
-    }
-    const data = await res.json();
-    this.accessToken = data.access_token;
-    return this.accessToken;
+      if (!res.ok) {
+        throw new SignalizError({
+          code: "AUTH_FAILED",
+          message: "Failed to obtain access token",
+          errorType: "auth_expired"
+        });
+      }
+      const data = await res.json();
+      this.accessToken = data.access_token;
+      return this.accessToken;
+    })().finally(() => {
+      this.accessTokenPromise = void 0;
+    });
+    return this.accessTokenPromise;
   }
 };
 function sleep(ms) {
@@ -531,7 +538,6 @@ var Signals = class {
     if (params.online !== void 0) args.online = params.online;
     if (params.targetSignalCount) args.target_signal_count = params.targetSignalCount;
     if (params.lookbackDays) args.lookback_days = params.lookbackDays;
-    if (params.model) args.model = params.model;
     if (params.enableDeepSearch) args.enable_deep_search = params.enableDeepSearch;
     if (params.enableOutreachIntelligence) args.enable_outreach_intelligence = params.enableOutreachIntelligence;
     if (params.enablePredictiveIntelligence) args.enable_predictive_intelligence = params.enablePredictiveIntelligence;
@@ -826,6 +832,10 @@ var Campaigns = class {
   async artifacts(campaignBuildId) {
     return this.listCampaignBuildArtifacts(campaignBuildId);
   }
+  /** Generate fresh signed URLs for a downloadable campaign artifact. */
+  async downloadArtifact(campaignBuildId, options) {
+    return this.downloadCampaignArtifact(campaignBuildId, options);
+  }
   /** Cancel a queued or running build. */
   async cancel(campaignBuildId, reason) {
     return this.cancelCampaignBuild(campaignBuildId, reason);
@@ -870,12 +880,16 @@ var Campaigns = class {
       dryRun: isDryRun,
       requestedTargetCount: data.requested_target_count,
       plannedTargetCount: data.planned_target_count,
+      acquisitionMode: data.acquisition_mode,
+      acquisitionSource: data.acquisition_source,
+      cacheReusePolicy: data.cache_reuse_policy,
       estimatedCredits: data.estimated_credits,
       estimatedDurationSeconds: data.estimated_duration_seconds,
       targetLimitApplied: data.target_limit_applied,
       targetLimitReason: data.target_limit_reason,
       maxSupportedTargetCount: data.max_supported_target_count,
       brainContext: data.brain_context ?? {},
+      learningHoldout: data.learning_holdout ?? {},
       providerRoute: mapProviderRoute(data)
     };
   }
@@ -891,14 +905,24 @@ var Campaigns = class {
     });
     return (data.artifacts ?? []).map(mapArtifact);
   }
+  async downloadCampaignArtifact(campaignBuildId, options) {
+    const args = { campaign_build_id: campaignBuildId };
+    if (options?.format) args.format = options.format;
+    const data = await this.callMcp("download_campaign_artifact", args);
+    return mapArtifactDownloadResult(data);
+  }
   async getCampaignBuildRows(campaignBuildId, options) {
     const args = { campaign_build_id: campaignBuildId };
     if (options?.limit) args.page_size = options.limit;
     if (options?.cursor) args.cursor = options.cursor;
+    if (options?.includeData !== void 0) args.include_data = options.includeData;
+    if (options?.includeRaw !== void 0) args.include_raw = options.includeRaw;
     const filters = {};
     if (options?.segment) filters.segment = options.segment;
     if (options?.rowStatus) filters.row_status = options.rowStatus;
     if (options?.qualified !== void 0) filters.qualified = options.qualified;
+    if (options?.cached !== void 0) filters.cached = options.cached;
+    if (options?.exportReady !== void 0) filters.export_ready = options.exportReady;
     if (Object.keys(filters).length > 0) args.filters = filters;
     const data = await this.callMcp("get_campaign_build_rows", args);
     return {
@@ -923,6 +947,7 @@ var Campaigns = class {
     };
     if (options?.destinationId) args.destination_id = options.destinationId;
     if (options?.destinationConfig) args.destination_config = options.destinationConfig;
+    if (options?.allowPartialDelivery === true) args.allow_partial_delivery = true;
     const data = await this.callMcp("approve_campaign_delivery", args);
     return {
       campaignBuildId: data.campaign_build_id,
@@ -931,7 +956,10 @@ var Campaigns = class {
       message: data.message ?? "",
       deliveryId: data.delivery_id,
       deliveryIds: data.delivery_ids,
-      approvedCount: data.approved_count
+      approvedCount: data.approved_count,
+      partialDelivery: data.partial_delivery,
+      effectiveTargetCount: data.effective_target_count,
+      requestedTargetCount: data.requested_target_count
     };
   }
   async cancelCampaignBuild(campaignBuildId, reason) {
@@ -984,17 +1012,50 @@ function mapStatus(data) {
     warnings: diagnosticMessages(data.warnings),
     errors: diagnosticMessages(data.errors),
     artifactCount: data.artifact_count ?? 0,
+    artifactDownloads: Array.isArray(data.artifact_downloads) ? data.artifact_downloads.map(mapArtifactDownload) : [],
+    customerRowCounts: mapCustomerRowCounts(data.customer_row_counts),
+    phaseAttemptTotals: recordOrNull(data.phase_attempt_totals) ?? void 0,
     providerRoute: mapProviderRoute(data),
     triggerRunId: typeof data.trigger_run_id === "string" ? data.trigger_run_id : null,
     staleRunningPhase: data.stale_running_phase === true,
     phaseAgeSeconds: numberOrNull(data.phase_age_seconds),
     diagnostics: recordOrNull(data.diagnostics) ?? {},
     nextAction: formatNextAction(data.next_action),
+    approvalAction: formatNextAction(data.approval_action),
     createdAt: data.created_at,
     updatedAt: data.updated_at,
     completedAt: data.completed_at
   };
 }
+function mapCustomerRowCounts(value) {
+  const record = recordOrNull(value);
+  if (!record) return void 0;
+  return {
+    requestedTarget: numberOrNull(record.requested_target),
+    acquiredRows: numberOrNull(record.acquired_rows) ?? void 0,
+    acceptedRows: numberOrNull(record.accepted_rows) ?? void 0,
+    usableRows: numberOrNull(record.usable_rows) ?? void 0,
+    copiedRows: numberOrNull(record.copied_rows) ?? void 0,
+    approvalReadyRows: numberOrNull(record.approval_ready_rows) ?? void 0,
+    qaReadyRows: numberOrNull(record.qa_ready_rows) ?? void 0,
+    deliveredRows: numberOrNull(record.delivered_rows) ?? void 0,
+    disqualifiedRows: numberOrNull(record.disqualified_rows) ?? void 0,
+    reviewableRows: numberOrNull(record.reviewable_rows) ?? void 0,
+    rowFailures: numberOrNull(record.row_failures) ?? void 0,
+    acceptedShortfall: numberOrNull(record.accepted_shortfall),
+    usableShortfall: numberOrNull(record.usable_shortfall),
+    qaReadyShortfall: numberOrNull(record.qa_ready_shortfall),
+    deliveryShortfall: numberOrNull(record.delivery_shortfall),
+    fillRatio: numberOrNull(record.fill_ratio),
+    qaReadyFillRatio: numberOrNull(record.qa_ready_fill_ratio),
+    deliveredFillRatio: numberOrNull(record.delivered_fill_ratio),
+    terminalReason: typeof record.terminal_reason === "string" ? record.terminal_reason : null,
+    acceptedShortfallReason: typeof record.accepted_shortfall_reason === "string" ? record.accepted_shortfall_reason : null,
+    usableShortfallReason: typeof record.usable_shortfall_reason === "string" ? record.usable_shortfall_reason : null,
+    qaReadyShortfallReason: typeof record.qa_ready_shortfall_reason === "string" ? record.qa_ready_shortfall_reason : null,
+    deliveryShortfallReason: typeof record.delivery_shortfall_reason === "string" ? record.delivery_shortfall_reason : null
+  };
+}
 function mapProviderRoute(data) {
   const brainContext = recordOrNull(data?.brain_context);
   const plan = recordOrNull(data?.provider_route_plan) ?? recordOrNull(brainContext?.provider_route_plan);
@@ -1072,13 +1133,56 @@ function mapArtifact(a) {
     artifactType: a.artifact_type,
     destination: a.destination,
     storagePath: a.storage_path,
+    format: a.format ?? null,
     signedUrl: a.signed_url,
+    downloadUrl: a.download_url ?? null,
+    manifestUrl: a.manifest_url ?? null,
+    expiresAt: a.expires_at ?? null,
     rowCount: a.row_count ?? 0,
     checksum: a.checksum,
     metadata: a.metadata ?? {},
     createdAt: a.created_at
   };
 }
+function mapArtifactDownload(data) {
+  return {
+    id: data.id,
+    artifactType: data.artifact_type ?? null,
+    format: data.format ?? null,
+    rowCount: data.row_count ?? 0,
+    signedUrl: data.signed_url ?? null,
+    downloadUrl: data.download_url ?? null,
+    manifestUrl: data.manifest_url ?? null,
+    expiresAt: data.expires_at ?? null
+  };
+}
+function mapArtifactDownloadResult(data) {
+  return {
+    campaignBuildId: data.campaign_build_id,
+    artifactId: data.artifact_id,
+    format: data.format,
+    rowCount: data.row_count ?? 0,
+    byteSize: numberOrNull(data.byte_size),
+    partCount: data.part_count ?? 0,
+    checksum: data.checksum ?? null,
+    signedUrl: data.signed_url ?? null,
+    downloadUrl: data.download_url ?? null,
+    manifestUrl: data.manifest_url ?? null,
+    expiresAt: data.expires_at ?? null,
+    parts: Array.isArray(data.parts) ? data.parts.map(mapArtifactDownloadPart) : [],
+    downloadCommands: recordOrNull(data.download_commands) ?? {},
+    expiresInSeconds: numberOrNull(data.expires_in_seconds)
+  };
+}
+function mapArtifactDownloadPart(data) {
+  return {
+    partIndex: data.part_index ?? 0,
+    rowCount: data.row_count ?? 0,
+    byteSize: numberOrNull(data.byte_size),
+    checksum: data.checksum ?? null,
+    signedUrl: data.signed_url ?? null
+  };
+}
 function mapScope(data) {
   return {
     campaignScopeId: data.campaign_scope_id,
@@ -1132,8 +1236,29 @@ function buildArgs(request) {
   if (request.allowDownscale !== void 0) args.allow_downscale = request.allowDownscale;
   if (request.confirmSpend !== void 0) args.confirm_spend = request.confirmSpend;
   if (request.dedupKeys) args.dedup_keys = request.dedupKeys;
+  if (request.acquisitionMode) args.acquisition_mode = request.acquisitionMode;
+  if (request.cacheReusePolicy) {
+    args.cache_reuse_policy = {
+      allow_verified_cache: request.cacheReusePolicy.allowVerifiedCache,
+      suppress_prior_campaign_ids: request.cacheReusePolicy.suppressPriorCampaignIds,
+      suppress_prior_list_ids: request.cacheReusePolicy.suppressPriorListIds,
+      uniqueness: request.cacheReusePolicy.uniqueness,
+      require_usage_metadata: request.cacheReusePolicy.requireUsageMetadata
+    };
+  }
   if (request.brainPreflight) args.brain_preflight = request.brainPreflight;
   if (request.brainDefaults) args.brain_defaults = request.brainDefaults;
+  if (request.learningHoldout) {
+    args.learning_holdout = {
+      enabled: request.learningHoldout.enabled,
+      control_percentage: request.learningHoldout.controlPercentage,
+      min_control_size: request.learningHoldout.minControlSize,
+      experiment_key: request.learningHoldout.experimentKey,
+      source_campaign_id: request.learningHoldout.sourceCampaignId,
+      primary_metric: request.learningHoldout.primaryMetric
+    };
+  }
+  if (request.campaignStrategyContext) args.campaign_strategy_context = request.campaignStrategyContext;
   if (request.deliveryRisk) args.delivery_risk = request.deliveryRisk;
   if (request.icp) {
     args.icp = {
@@ -1175,7 +1300,17 @@ function buildArgs(request) {
       max_body_words: request.copy.maxBodyWords,
       sender_context: request.copy.senderContext,
       offer_context: request.copy.offerContext,
-      model: request.copy.model
+      model: request.copy.model,
+      style_source: request.copy.styleSource ? {
+        sample_text: request.copy.styleSource.sampleText,
+        campaign_ids: request.copy.styleSource.campaignIds,
+        artifact_ids: request.copy.styleSource.artifactIds
+      } : void 0,
+      sequence_steps: request.copy.sequenceSteps,
+      copy_schema: request.copy.copySchema,
+      banned_phrases: request.copy.bannedPhrases,
+      approval_required: request.copy.approvalRequired,
+      quality_tier: request.copy.qualityTier
     };
   }
   if (request.delivery) {
@@ -1238,6 +1373,8 @@ var DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS = {
   }
 };
 var DEFAULT_CAMPAIGN_BUILDER_BUILT_INS = [
+  "company_discovery",
+  "people_discovery",
   "lead_generation",
   "email_finding",
   "email_verification",
@@ -1246,6 +1383,8 @@ var DEFAULT_CAMPAIGN_BUILDER_BUILT_INS = [
 var CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS = {
   lead_generation: "signaliz-lead-generation",
   local_leads: "signaliz-local-leads",
+  company_discovery: "signaliz-company-discovery",
+  people_discovery: "signaliz-people-discovery",
   email_finding: "signaliz-email-finding",
   email_verification: "signaliz-email-verification",
   signals: "signaliz-signals"
@@ -1263,8 +1402,8 @@ var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
     slug: "cache-first-large-list",
     label: "Cache-First Large List",
     whenToUse: [
-      "The target count is high and reusable workspace lead or cache coverage may exist.",
-      "The deliverable is a verified list or top-up rather than a deeply custom one-off workflow."
+      "The operator explicitly references a previous campaign, prior list, seed list, or suppression baseline.",
+      "The deliverable is a top-up, continuation, or backfill where prior campaign context should guide reuse."
     ],
     sequence: [
       "Inventory reusable cache before paid sourcing.",
@@ -1470,7 +1609,7 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
       ],
       requireVerifiedEmail: true
     },
-    builtIns: ["lead_generation", "email_finding", "email_verification", "signals"],
+    builtIns: ["company_discovery", "people_discovery", "lead_generation", "email_finding", "email_verification", "signals"],
     preferredProviders: ["signaliz_native"],
     memoryQueries: [{
       query: "industrial OT net-new prior email suppression verified manufacturing embedded systems field service cyber resilience business continuity",
@@ -1544,7 +1683,7 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
       ],
       requireVerifiedEmail: true
     },
-    builtIns: ["lead_generation", "local_leads", "email_finding", "email_verification", "signals"],
+    builtIns: ["company_discovery", "people_discovery", "lead_generation", "local_leads", "email_finding", "email_verification", "signals"],
     preferredProviders: ["signaliz_native", "octave", "clay_webhook", "apify"],
     memoryQueries: [{
       query: "mature non-medical home care agencies billable hours franchise caregiver recruiting proof gate qualification export approval",
@@ -1610,7 +1749,7 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
       exclusions: ["enterprise holding company", "staffing", "recruiting", "software-only vendor", "freelancer-only profile"],
       requireVerifiedEmail: true
     },
-    builtIns: ["lead_generation", "email_finding", "email_verification", "signals"],
+    builtIns: ["company_discovery", "people_discovery", "lead_generation", "email_finding", "email_verification", "signals"],
     preferredProviders: ["signaliz_native", "octave"],
     memoryQueries: [{
       query: "agency founder owner CEO marketing services suppression domain pool email verification final approval gate",
@@ -1692,7 +1831,7 @@ var CAMPAIGN_BUILDER_STRATEGY_TEMPLATES = [
       ],
       requireVerifiedEmail: true
     },
-    builtIns: ["lead_generation", "email_finding", "email_verification", "signals"],
+    builtIns: ["company_discovery", "people_discovery", "lead_generation", "email_finding", "email_verification", "signals"],
     preferredProviders: ["signaliz_native", "octave"],
     memoryQueries: [{
       query: "cloud hosting infrastructure VMware Broadcom qualification verified email persona trigger SKU mapping",
@@ -1725,25 +1864,21 @@ var CampaignBuilderAgent = class {
   async createPlan(request, options = {}) {
     const resolvedRequest = applyCampaignBuilderStrategyTemplate(request);
     const warnings = [];
-    const workspaceContext = resolvedRequest.workspaceContext ?? await this.getWorkspaceContext(warnings);
-    const scopeResult = options.scopeCampaign === false ? void 0 : await this.scopeCampaign(resolvedRequest, warnings);
-    if (options.discoverCapabilities !== false) {
-      await this.discoverPlannedRoutes(resolvedRequest, warnings);
-    }
+    const [workspaceContext, scopeResult] = await Promise.all([
+      resolvedRequest.workspaceContext ? Promise.resolve(resolvedRequest.workspaceContext) : this.getWorkspaceContext(warnings),
+      options.scopeCampaign === false ? Promise.resolve(void 0) : this.scopeCampaign(resolvedRequest, warnings),
+      options.discoverCapabilities === false ? Promise.resolve(void 0) : this.discoverPlannedRoutes(resolvedRequest, warnings)
+    ]);
     const plan = createCampaignBuilderAgentPlan(resolvedRequest, {
       workspaceContext,
       scopeBuildArgs: asRecord(scopeResult?.build_campaign_args ?? scopeResult?.buildCampaignArgs),
       warnings
     });
-    if (options.includeStrategyMemoryStatus !== false) {
-      await this.attachStrategyMemoryStatus(plan, warnings);
-    }
-    if (options.includeKernelPlan !== false) {
-      await this.attachKernelCampaignBuildPlan(plan, warnings);
-    }
-    if (options.includeDeliveryRisk !== false) {
-      await this.attachDeliveryRiskPreflight(plan, warnings);
-    }
+    await Promise.all([
+      options.includeStrategyMemoryStatus === false ? Promise.resolve() : this.attachStrategyMemoryStatus(plan, warnings),
+      options.includeKernelPlan === false ? Promise.resolve() : this.attachKernelCampaignBuildPlan(plan, warnings),
+      options.includeDeliveryRisk === false ? Promise.resolve() : this.attachDeliveryRiskPreflight(plan, warnings)
+    ]);
     return plan;
   }
   async readiness(request, options = {}) {
@@ -1760,6 +1895,9 @@ var CampaignBuilderAgent = class {
   buildKit(options = {}) {
     return createCampaignBuilderBuildKit(options);
   }
+  memoryKit(options = {}) {
+    return createCampaignBuilderMemoryKit(options);
+  }
   async commitPlan(plan, options = {}) {
     const writeMode = options.confirm === true && options.dryRun === false;
     if (writeMode && !options.approvedBy) {
@@ -1788,6 +1926,7 @@ var CampaignBuilderAgent = class {
         },
         brain_defaults: plan.buildRequest.brainDefaults,
         brain_preflight: plan.buildRequest.brainPreflight,
+        campaign_strategy_context: plan.buildRequest.campaignStrategyContext,
         delivery_risk_preflight: plan.buildRequest.deliveryRisk,
         delivery_risk: plan.buildRequest.deliveryRisk
       }),
@@ -1909,7 +2048,8 @@ var CampaignBuilderAgent = class {
       const destinationType = options.deliveryDestinationType ?? plan.buildRequest.delivery?.destinationType ?? "json";
       result.deliveryApproval = await this.approveCampaignDelivery(campaignBuildId, destinationType, {
         destinationId: options.deliveryDestinationId,
-        destinationConfig: options.deliveryDestinationConfig ?? plan.buildRequest.delivery?.destinationConfig
+        destinationConfig: options.deliveryDestinationConfig ?? plan.buildRequest.delivery?.destinationConfig,
+        allowPartialDelivery: options.allowPartialDelivery
       });
       finalStatus = await this.waitForCampaignBuildStatus(
         campaignBuildId,
@@ -1932,8 +2072,12 @@ var CampaignBuilderAgent = class {
     const args = compact({
       campaign_build_id: campaignBuildId,
       page_size: options.limit,
-      cursor: options.cursor
+      cursor: options.cursor,
+      include_data: options.includeData,
+      include_raw: options.includeRaw
     });
+    if (options.cached !== void 0) filters.cached = options.cached;
+    if (options.exportReady !== void 0) filters.export_ready = options.exportReady;
     if (Object.keys(filters).length > 0) args.filters = filters;
     const data = await this.callMcp("get_campaign_build_rows", args);
     return mapAgentCampaignRowsResult(data);
@@ -1948,12 +2092,14 @@ var CampaignBuilderAgent = class {
     return this.approveCampaignDelivery(campaignBuildId, destinationType, options);
   }
   async reviewBuild(campaignBuildId, options = {}) {
-    const status = await this.getBuildStatus(campaignBuildId);
-    const rows = await this.getBuildRows(campaignBuildId, {
-      ...options,
-      limit: options.limit ?? 100
-    });
-    const artifacts = await this.listBuildArtifacts(campaignBuildId);
+    const [status, rows, artifacts] = await Promise.all([
+      this.getBuildStatus(campaignBuildId),
+      this.getBuildRows(campaignBuildId, {
+        ...options,
+        limit: options.limit ?? 100
+      }),
+      this.listBuildArtifacts(campaignBuildId)
+    ]);
     return createCampaignBuilderBuildReview(status, rows, artifacts);
   }
   async getCampaignBuildStatus(campaignBuildId) {
@@ -1981,7 +2127,8 @@ var CampaignBuilderAgent = class {
       campaign_build_id: campaignBuildId,
       destination_type: destinationType,
       destination_id: options?.destinationId,
-      destination_config: options?.destinationConfig
+      destination_config: options?.destinationConfig,
+      allow_partial_delivery: options?.allowPartialDelivery === true ? true : void 0
     });
     const data = await this.callMcp("approve_campaign_delivery", args);
     return {
@@ -1991,7 +2138,10 @@ var CampaignBuilderAgent = class {
       message: data.message ?? "",
       deliveryId: data.delivery_id,
       deliveryIds: data.delivery_ids,
-      approvedCount: data.approved_count
+      approvedCount: data.approved_count,
+      partialDelivery: data.partial_delivery,
+      effectiveTargetCount: data.effective_target_count,
+      requestedTargetCount: data.requested_target_count
     };
   }
   async getWorkspaceContext(warnings) {
@@ -2027,15 +2177,19 @@ var CampaignBuilderAgent = class {
     const providers = new Set(
       [...request.integrations ?? [], ...routesFromCustomerTools(request.customerTools ?? [])].filter((route) => route.provider !== "signaliz").map((route) => route.provider)
     );
-    for (const provider of providers) {
+    const warningsByProvider = await Promise.all(Array.from(providers, async (provider) => {
       try {
         await this.callMcp("discover_capabilities", {
           query: `campaign builder ${provider} ${request.goal}`,
           category: "campaign"
         });
+        return void 0;
       } catch (error) {
-        warnings.push(`Capability discovery for ${provider} failed: ${errorMessage(error)}`);
+        return `Capability discovery for ${provider} failed: ${errorMessage(error)}`;
       }
+    }));
+    for (const warning of warningsByProvider) {
+      if (warning) warnings.push(warning);
     }
   }
   async attachStrategyMemoryStatus(plan, warnings) {
@@ -2059,8 +2213,24 @@ var CampaignBuilderAgent = class {
       const kernelPlan = await this.callMcp("gtm_campaign_build_plan", asRecord(plannerStep.arguments));
       plan.kernelPlan = asRecord(kernelPlan);
       const brainDefaults = asRecord(plan.kernelPlan.brain_defaults ?? plan.kernelPlan.brainDefaults);
+      const corpusContext = asRecord(plan.kernelPlan.corpus_context ?? plan.kernelPlan.corpusContext);
+      const campaignStrategyContext = asRecord(plan.kernelPlan.campaign_strategy_context ?? plan.kernelPlan.campaignStrategyContext);
+      const memoryExamples = Array.isArray(plan.kernelPlan.memory_examples) ? plan.kernelPlan.memory_examples.map((item) => asRecord(item)).filter((item) => Object.keys(item).length > 0).slice(0, 15) : [];
       if (Object.keys(brainDefaults).length > 0 && Object.keys(asRecord(plan.buildRequest.brainDefaults)).length === 0) {
         plan.buildRequest.brainDefaults = brainDefaults;
+      }
+      if (Object.keys(campaignStrategyContext).length > 0) {
+        plan.buildRequest.campaignStrategyContext = campaignStrategyContext;
+      }
+      if (Object.keys(corpusContext).length > 0 || memoryExamples.length > 0 || Object.keys(brainDefaults).length > 0 || Object.keys(campaignStrategyContext).length > 0) {
+        plan.buildRequest.brainPreflight = compact({
+          ...asRecord(plan.buildRequest.brainPreflight),
+          corpus_context: Object.keys(corpusContext).length > 0 ? corpusContext : void 0,
+          memory_examples: memoryExamples.length > 0 ? memoryExamples : void 0,
+          brain_defaults: Object.keys(brainDefaults).length > 0 ? brainDefaults : void 0,
+          campaign_strategy_context: Object.keys(campaignStrategyContext).length > 0 ? campaignStrategyContext : void 0
+        });
+        plan.brainPreflight = asRecord(plan.buildRequest.brainPreflight);
         refreshBuildStepArguments(plan);
       }
     } catch (error) {
@@ -2241,6 +2411,9 @@ function createCampaignBuilderProofReceipt(plan, result) {
       campaign_build_id: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null
     }
   ];
+  const learnBackPlan = summarizeCampaignBuilderProofLearnBack(
+    asRecord(asRecord(plan.buildRequest.brainPreflight).learn_back_plan ?? asRecord(plan.brainPreflight).learn_back_plan)
+  );
   return {
     receipt_version: "campaign-agent-proof.v1",
     source: "signaliz.campaignBuilderAgent.proof",
@@ -2263,6 +2436,7 @@ function createCampaignBuilderProofReceipt(plan, result) {
     gates,
     strategy_memory_status: summarizeCampaignBuilderProofStrategyMemory(strategyMemory),
     dry_run_result: summarizeCampaignBuilderProofDryRun(dryRunResult),
+    learn_back_plan: learnBackPlan,
     recommended_next_actions: [
       "Review the plan, approvals, and dry-run result.",
       "Use campaign-agent commit-plan --confirm-write only after review.",
@@ -2480,6 +2654,12 @@ function createCampaignBuilderBuildKit(input = {}) {
         command: `${cliBase} campaign-agent init${strategyFlag}${targetFlag}${localLeadsFlag} --output-file ${shellArg(requestFile)}`,
         safety: "local file only; no MCP calls, credits, provider writes, sender loads, exports, or sends"
       },
+      {
+        id: "memory_kit",
+        label: "Inspect memory readiness and seed runner",
+        command: `${sdkCliBase} campaign-agent memory-kit${strategyFlag}${targetFlag}${localLeadsFlag} --request-file ${shellArg(requestFile)} --json`,
+        safety: "read-only memory readiness packet plus local seed dry-run commands"
+      },
       {
         id: "proof_shortcut",
         label: "Run no-spend campaign-builder proof",
@@ -2574,6 +2754,147 @@ function createCampaignBuilderBuildKit(input = {}) {
     ]
   };
 }
+function createCampaignBuilderMemoryKit(input = {}) {
+  const requestFile = input.requestFile || "campaign-request.json";
+  const seedManifestFile = input.seedManifestFile || ".gtm-kernel-import-state/campaign-memory-dry-run.json";
+  const cliPackage = input.cliPackage || "@signaliz/cli";
+  const sdkPackage = input.sdkPackage || "@signaliz/sdk";
+  const request = createCampaignBuilderAgentRequestTemplate(input);
+  const strategyTemplate = stringValue(request.strategyTemplate) ?? null;
+  const strategyFlag = strategyTemplate ? ` --strategy-template ${shellArg(strategyTemplate)}` : "";
+  const targetFlag = request.targetCount ? ` --target-count ${request.targetCount}` : "";
+  const localLeadsFlag = request.builtIns?.includes("local_leads") ? " --use-local-leads" : "";
+  const cliBase = `npx ${cliPackage}`;
+  const sdkCliBase = `npx ${sdkPackage}`;
+  const source = campaignBuilderMemoryKitSource(input.source);
+  const workspaceId = input.workspaceId || "your-workspace-id";
+  const brief = request.goal || "Build a strategy-template campaign for the target ICP.";
+  const statusArgs = compact({
+    strategy_template: strategyTemplate,
+    campaign_brief: brief,
+    target_icp: request.icp,
+    include_sources: true,
+    include_samples: false,
+    days: 90,
+    limit: 25
+  });
+  const searchArgs = compact({
+    query: request.memory?.queries?.[0]?.query || brief,
+    layers: ["lead_generation", "email_finding", "email_verification", "company_enrichment", "copy_enrichment"],
+    limit: 10
+  });
+  return {
+    kit_version: "campaign-memory-kit.v1",
+    source: "signaliz.campaignBuilderAgent.memoryKit",
+    read_only: true,
+    no_spend: true,
+    no_provider_writes: true,
+    client_names_allowed: false,
+    request_file: requestFile,
+    seed_manifest_file: seedManifestFile,
+    request,
+    strategy_template: strategyTemplate,
+    operating_playbooks: getCampaignBuilderOperatingPlaybooksForRequest(request).map((playbook) => playbook.slug),
+    memory_sources: source.memorySources,
+    seed_runner: {
+      local_script: "scripts/gtm-kernel/seed-import-runner.mjs",
+      dry_run_command: [
+        "node scripts/gtm-kernel/seed-import-runner.mjs",
+        `--source ${source.seedSource}`,
+        "--dry-run",
+        `--workspace-id ${shellArg(input.workspaceId || "00000000-0000-4000-8000-000000000000")}`,
+        `--manifest ${shellArg(seedManifestFile)}`,
+        "--reset"
+      ].join(" "),
+      verify_manifest_command: source.verifyScript ? `node ${source.verifyScript} ${shellArg(seedManifestFile)}` : null,
+      write_command: `GTM_KERNEL_WORKSPACE_ID=${shellArg(workspaceId)} node scripts/gtm-kernel/seed-import-runner.mjs --source ${source.seedSource} --write`,
+      write_requires: ["SUPABASE_URL", "SUPABASE_SERVICE_ROLE_KEY", "GTM_KERNEL_WORKSPACE_ID", "explicit operator approval"]
+    },
+    cli_commands: [
+      {
+        id: "memory_status",
+        label: "Check strategy memory readiness",
+        command: `${sdkCliBase} gtm strategy-memory${strategyFlag} --brief ${shellArg(brief)} --json`,
+        safety: "read-only MCP memory readiness; no credits, provider writes, sender loads, exports, or sends"
+      },
+      {
+        id: "memory_search",
+        label: "Search ranked campaign memory",
+        command: `${sdkCliBase} gtm memory search --query ${shellArg(String(searchArgs.query || brief))} --limit 10 --json`,
+        safety: "read-only ranked memory lookup"
+      },
+      {
+        id: "seed_dry_run",
+        label: "Dry-run private memory seed import",
+        command: [
+          "node scripts/gtm-kernel/seed-import-runner.mjs",
+          `--source ${source.seedSource}`,
+          "--dry-run",
+          `--workspace-id ${shellArg(input.workspaceId || "00000000-0000-4000-8000-000000000000")}`,
+          `--manifest ${shellArg(seedManifestFile)}`,
+          "--reset"
+        ].join(" "),
+        safety: "local extraction and manifest only; no database writes"
+      },
+      {
+        id: "write_request",
+        label: "Write reusable campaign request JSON",
+        command: `${cliBase} campaign-agent init${strategyFlag}${targetFlag}${localLeadsFlag} --output-file ${shellArg(requestFile)}`,
+        safety: "local file only; no MCP calls, credits, provider writes, sender loads, exports, or sends"
+      },
+      {
+        id: "proof",
+        label: "Run campaign proof after memory check",
+        command: `${cliBase} campaign-agent proof --request-file ${shellArg(requestFile)} --json`,
+        safety: "read-only planning plus forced build_campaign dry-run with confirm_spend=false"
+      }
+    ],
+    mcp_calls: [
+      {
+        id: "strategy_memory_status",
+        tool: "gtm_campaign_strategy_memory_status",
+        arguments: statusArgs,
+        safety: "read-only strategy/workflow memory readiness with sources and no raw samples"
+      },
+      {
+        id: "memory_search",
+        tool: "gtm_memory_search",
+        arguments: searchArgs,
+        safety: "read-only ranked memory lookup"
+      },
+      {
+        id: "campaign_agent_plan",
+        tool: "gtm_campaign_agent_plan",
+        arguments: campaignBuilderBuildKitMcpArgs(request),
+        safety: "read-only campaign-agent plan using built-in Signaliz lanes, memory, Brain, Nango, and BYO routes"
+      },
+      {
+        id: "campaign_agent_proof",
+        tool: "gtm_campaign_agent_proof",
+        arguments: { ...campaignBuilderBuildKitMcpArgs(request), idempotency_key: "campaign-agent-memory-proof-001" },
+        safety: "forces build_campaign dry_run=true and confirm_spend=false after readiness"
+      }
+    ],
+    sdk_example: {
+      language: "typescript",
+      code: campaignBuilderMemoryKitSdkExample(request, seedManifestFile)
+    },
+    privacy: {
+      client_names_allowed: false,
+      notes: [
+        "Use strategy templates, operating playbooks, memory dimensions, and anonymized campaign patterns instead of client names.",
+        "Do not expose raw leads, private replies, domains, secrets, provider payloads, or customer account labels in kit output.",
+        "Seed writes are workspace-private and require explicit operator approval plus Supabase service credentials."
+      ]
+    },
+    next_actions: [
+      "Run memory_status before plan/proof so missing strategy coverage is visible.",
+      `Run seed_dry_run and inspect ${seedManifestFile} before any memory write.`,
+      "Use write_request to save the reusable campaign request, then run proof with no spend.",
+      "Add BYO tools through campaign-agent --custom-tool only after route setup is reviewed."
+    ]
+  };
+}
 function createCampaignBuilderToolRoute(input) {
   return {
     provider: input.provider ?? "custom_mcp",
@@ -2643,6 +2964,96 @@ function campaignBuilderBuildKitSdkExample(request, requestFile) {
     "}"
   ].join("\n");
 }
+function campaignBuilderMemoryKitSdkExample(request, seedManifestFile) {
+  const input = {
+    goal: request.goal,
+    strategyTemplate: request.strategyTemplate,
+    targetCount: request.targetCount,
+    builtIns: request.builtIns
+  };
+  return [
+    "import { Signaliz, createCampaignBuilderMemoryKit } from '@signaliz/sdk';",
+    "",
+    `const kit = createCampaignBuilderMemoryKit({ seedManifestFile: ${JSON.stringify(seedManifestFile)}, ...${JSON.stringify(input, null, 2)} });`,
+    "console.log(kit.cli_commands.find((command) => command.id === 'memory_status')?.command);",
+    "",
+    "const signaliz = new Signaliz({ apiKey: process.env.SIGNALIZ_API_KEY! });",
+    "const status = await signaliz.gtm.campaignStrategyMemoryStatus({",
+    "  strategyTemplate: kit.request.strategyTemplate,",
+    "  campaignBrief: kit.request.goal,",
+    "  includeSources: true,",
+    "  includeSamples: false,",
+    "});",
+    "",
+    "if (status?.ready === false) {",
+    "  throw new Error('Strategy memory is not ready for this campaign request');",
+    "}"
+  ].join("\n");
+}
+function campaignBuilderMemoryKitSource(source) {
+  const normalized = normalizeTemplateKey(source || "agency");
+  const catalog = {
+    northStar: {
+      id: "north_star_campaign_builder",
+      label: "North Star campaign-builder acceptance patterns",
+      seed_source: "north-star",
+      scope: "redacted_acceptance_seed_packs",
+      privacy: "redacted aggregate counts, QA gates, and fixture shape only"
+    },
+    agency: {
+      id: "agency_campaign_builder",
+      label: "Agency campaign-builder strategy patterns",
+      seed_source: "agency",
+      scope: "private_strategy_docs",
+      privacy: "workspace-private sanitized docs and abstracted campaign summaries"
+    },
+    workflow: {
+      id: "workflow_pattern_corpus",
+      label: "Workflow and table-build pattern corpus",
+      seed_source: "building-clay",
+      scope: "read_only_workflow_docs",
+      privacy: "sanitized operating model and workflow patterns"
+    },
+    feedback: {
+      id: "campaign_feedback",
+      label: "Campaign feedback and reply patterns",
+      seed_source: "instantly",
+      scope: "workspace_private_feedback",
+      privacy: "aggregate feedback, reply, and sequence performance memory"
+    }
+  };
+  const sourceMap = {
+    agency: "agency",
+    "campaign-builder": "agency",
+    "north-star": "northStar",
+    northstar: "northStar",
+    "campaign-builder-north-star": "northStar",
+    acceptance: "northStar",
+    "strategy-memory": "agency",
+    "workflow-patterns": "workflow",
+    workflow: "workflow",
+    "building-clay": "workflow",
+    clay: "workflow",
+    "instantly-feedback": "feedback",
+    instantly: "feedback",
+    feedback: "feedback",
+    all: "all"
+  };
+  const selected = sourceMap[normalized] || "agency";
+  if (selected === "all") {
+    return {
+      seedSource: "all",
+      verifyScript: null,
+      memorySources: [catalog.northStar, catalog.agency, catalog.workflow, catalog.feedback]
+    };
+  }
+  const item = catalog[selected];
+  return {
+    seedSource: item.seed_source,
+    verifyScript: item.seed_source === "north-star" ? "scripts/gtm-kernel/verify-north-star-import-manifest.mjs" : item.seed_source === "agency" ? "scripts/gtm-kernel/verify-agency-import-manifest.mjs" : item.seed_source === "building-clay" ? "scripts/gtm-kernel/verify-building-clay-import-manifest.mjs" : null,
+    memorySources: [item]
+  };
+}
 function shellArg(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
@@ -2819,11 +3230,11 @@ function builtInRoutesFor(request) {
     routes.push({
       id: "signaliz-lead-generation",
       layer: "source",
-      gtmLayers: ["find_company", "find_people", "lead_generation"],
+      gtmLayer: "lead_generation",
       provider: "signaliz",
       mode: "required",
       toolName: "generate_leads",
-      rationale: "Use Signaliz fresh workspace acquisition as the default source of truth."
+      rationale: "Inventory verified cache first, then use Signaliz fresh workspace acquisition for the remaining approved gap."
     });
   }
   if (builtIns.has("local_leads")) {
@@ -2837,6 +3248,28 @@ function builtInRoutesFor(request) {
       rationale: "Use Signaliz local-leads sourcing for geography-bound local business campaigns."
     });
   }
+  if (builtIns.has("company_discovery")) {
+    routes.push({
+      id: "signaliz-company-discovery",
+      layer: "source",
+      gtmLayer: "find_company",
+      provider: "signaliz",
+      mode: "if_available",
+      toolName: "find_companies_signaliz",
+      rationale: "Find and qualify company domains before people/email fill for account-led campaigns."
+    });
+  }
+  if (builtIns.has("people_discovery")) {
+    routes.push({
+      id: "signaliz-people-discovery",
+      layer: "source",
+      gtmLayer: "find_people",
+      provider: "signaliz",
+      mode: "if_available",
+      toolName: "find_people_signaliz",
+      rationale: "Find people directly when the brief is contact research or LinkedIn-style prospecting."
+    });
+  }
   if (builtIns.has("email_finding")) {
     routes.push({
       id: "signaliz-email-finding",
@@ -2881,7 +3314,7 @@ function normalizeBuiltIns(request) {
   return [...builtIns].filter(isCampaignBuilderBuiltInTool);
 }
 function isCampaignBuilderBuiltInTool(value) {
-  return ["lead_generation", "local_leads", "email_finding", "email_verification", "signals"].includes(String(value));
+  return ["lead_generation", "local_leads", "company_discovery", "people_discovery", "email_finding", "email_verification", "signals"].includes(String(value));
 }
 function looksLikeLocalLeadCampaign(request) {
   const text = [
@@ -2936,7 +3369,11 @@ function createBuildRequest(request, defaults, targetCount, campaignName, scopeB
     qualification: defaults.qualification,
     copy: defaults.copy,
     delivery: defaults.delivery,
-    enhancers: enhancerConfig(request)
+    enhancers: enhancerConfig(request),
+    sourceRouting: request.sourceRouting ?? {
+      mode: looksLikeLocalLeadCampaign(request) ? "local_leads" : "auto",
+      fillPolicy: "aggressive"
+    }
   };
   const scoped = asRecord(scopeBuildArgs);
   buildRequest.gtmCampaignId = request.gtmCampaignId ?? stringValue(scoped.gtm_campaign_id ?? scoped.gtmCampaignId);
@@ -3018,9 +3455,132 @@ function createBrainPreflight(request, buildRequest, routes, memory) {
       { tool: "gtm_brain_learning_cycle_plan", purpose: "Plan the Brain learning loop for this campaign.", arguments: learningArgs },
       { tool: "gtm_brain_seed_defaults", purpose: "Seed campaign defaults from workspace memory and safe aggregate patterns.", arguments: defaultsArgs },
       { tool: "gtm_brain_delivery_risk", purpose: "Check deliverability risk before launch or external writes.", arguments: riskArgs }
-    ]
+    ],
+    learn_back_plan: createCampaignBuilderLearnBackPlan(request, buildRequest)
+  };
+}
+function createCampaignBuilderLearnBackPlan(request, buildRequest) {
+  const instantlyFeedbackContext = campaignBuilderProviderFeedbackContext(request, buildRequest, "instantly");
+  const postBuildSequence = [
+    {
+      tool: "get_campaign_build_status",
+      approval_boundary: "read_only",
+      arguments_template: { campaign_build_id: "<build_campaign.campaign_build_id>" },
+      reason: "Wait for the Campaign Builder run to finish before deriving memory."
+    },
+    {
+      tool: "gtm_campaign_build_backfill_preview",
+      approval_boundary: "read_only",
+      arguments_template: { campaign_build_id: "<build_campaign.campaign_build_id>", create_memory: true },
+      reason: "Preview the provider-neutral Kernel import payload without writing rows."
+    },
+    {
+      tool: "gtm_campaign_build_backfill_run",
+      approval_boundary: "dry_run",
+      arguments_template: { campaign_build_ids: ["<build_campaign.campaign_build_id>"], dry_run: true, create_memory: true, run_brain_cycle: false },
+      reason: "Dry-run the Kernel history import before creating campaign memory."
+    },
+    {
+      tool: "gtm_campaign_build_backfill_run",
+      approval_boundary: "explicit_write_approval",
+      arguments_template: { campaign_build_ids: ["<build_campaign.campaign_build_id>"], dry_run: false, create_memory: true, run_brain_cycle: true, brain_cycle_write_mode: "dry_run" },
+      reason: "After review, queue the Kernel history import; Brain learning remains dry-run unless separately approved."
+    }
+  ];
+  if (instantlyFeedbackContext) {
+    postBuildSequence.push({
+      tool: "gtm_instantly_feedback_pull",
+      approval_boundary: "dry_run_first_explicit_write_approval",
+      arguments_template: {
+        campaign_id: buildRequest.gtmCampaignId || "<gtm_campaign_id_after_commit>",
+        campaign_build_id: "<build_campaign.campaign_build_id>",
+        source: "emails",
+        email_type: "received",
+        ...instantlyFeedbackContext,
+        dry_run: true,
+        create_memory: true,
+        write_routine_outcomes: true,
+        run_brain_cycle: true,
+        brain_cycle_write_mode: "dry_run"
+      },
+      reason: "After Instantly delivery has live outcomes, pull reply and bounce history into private feedback memory before Brain learning."
+    });
+  }
+  postBuildSequence.push(
+    {
+      tool: "gtm_campaign_learning_status",
+      approval_boundary: "read_only",
+      arguments_template: {
+        campaign_id: buildRequest.gtmCampaignId || "<gtm_campaign_id_after_commit>",
+        campaign_build_id: "<build_campaign.campaign_build_id>",
+        write_mode: "dry_run"
+      },
+      reason: "Confirm feedback, memory, and Brain learning readiness after the import."
+    },
+    {
+      tool: "gtm_memory_search",
+      approval_boundary: "read_only",
+      arguments_template: {
+        query: request.goal,
+        ...buildRequest.gtmCampaignId ? { campaign_id: buildRequest.gtmCampaignId } : {},
+        limit: 10
+      },
+      reason: "Verify the new private memory is retrievable for future campaign planning."
+    },
+    {
+      tool: "gtm_brain_learning_cycle_plan",
+      approval_boundary: "read_only",
+      arguments_template: {
+        ...buildRequest.gtmCampaignId ? { campaign_id: buildRequest.gtmCampaignId } : {},
+        include_memory: true,
+        write_mode: "dry_run"
+      },
+      reason: "Plan the Brain phases from the imported outcomes before any pattern writes."
+    }
+  );
+  return {
+    source_tool: "campaign-builder-agent",
+    gtm_campaign_id: buildRequest.gtmCampaignId ?? null,
+    trigger: "After build_campaign returns a campaign_build_id and the build reaches a terminal reviewed state.",
+    build_result_placeholders: {
+      campaign_build_id: "<build_campaign.campaign_build_id>"
+    },
+    memory_write_policy: {
+      target_tables: ["gtm_campaigns", "gtm_campaign_provider_links", "gtm_campaign_feedback_events", "gtm_memory_items", "gtm_brain_patterns"],
+      gtm_memory_items: {
+        shareable: false,
+        allowed_redaction_states: ["redacted", "abstracted"],
+        raw_private_fields_withheld: ["reply_text", "copy_body", "lead_email", "lead_domain", "company_domain", "provider_campaign_id", "provider_payload", "webhook_url", "secret"]
+      },
+      gtm_brain_patterns: "Workspace-scoped by default. Global promotion requires abstracted_only=true, shared opt-in, and privacy thresholds."
+    },
+    post_build_sequence: postBuildSequence.map((item, index) => ({ step: index + 1, ...item })),
+    approval_policy: "This agent plan never writes learn-back rows. Backfill and provider-feedback writes require dry_run=false after review, and Brain writes require their own approved learning-cycle run.",
+    privacy_policy: "Learn-back memory is workspace-private. Raw replies, copy bodies, leads, emails, domains, provider payloads, webhook URLs, secrets, private source paths, and raw client labels are withheld from memory rows and agent-visible outputs."
   };
 }
+function campaignBuilderProviderFeedbackContext(request, buildRequest, provider) {
+  const normalizedProvider = String(provider).toLowerCase();
+  const routes = [...request.integrations ?? [], ...routesFromCustomerTools(request.customerTools ?? [])];
+  const providerRoute = routes.find((route) => String(route.provider).toLowerCase() === normalizedProvider);
+  const routeConfig = asRecord(providerRoute?.config);
+  const deliveryConfig = asRecord(buildRequest.delivery?.destinationConfig);
+  const hasProviderContext = [
+    ...request.preferredProviders ?? [],
+    ...routes.map((route) => route.provider),
+    stringValue(deliveryConfig.provider),
+    stringValue(deliveryConfig.provider_id ?? deliveryConfig.providerId),
+    stringValue(deliveryConfig.destination_provider ?? deliveryConfig.destinationProvider),
+    stringValue(deliveryConfig.sink ?? deliveryConfig.sink_type ?? deliveryConfig.sinkType)
+  ].some((value) => String(value).toLowerCase() === normalizedProvider);
+  if (!hasProviderContext) return void 0;
+  return compact({
+    provider_link_id: stringValue(routeConfig.provider_link_id ?? routeConfig.providerLinkId ?? deliveryConfig.provider_link_id ?? deliveryConfig.providerLinkId),
+    provider_campaign_id: stringValue(routeConfig.provider_campaign_id ?? routeConfig.providerCampaignId ?? routeConfig.instantly_campaign_id ?? routeConfig.instantlyCampaignId ?? deliveryConfig.provider_campaign_id ?? deliveryConfig.providerCampaignId ?? deliveryConfig.instantly_campaign_id ?? deliveryConfig.instantlyCampaignId),
+    integration_id: stringValue(routeConfig.integration_id ?? routeConfig.integrationId ?? deliveryConfig.integration_id ?? deliveryConfig.integrationId),
+    instantly_profile: stringValue(routeConfig.instantly_profile ?? routeConfig.instantlyProfile ?? routeConfig.profile ?? deliveryConfig.instantly_profile ?? deliveryConfig.instantlyProfile ?? deliveryConfig.profile)
+  });
+}
 function gtmLayersForBuilderLayer(layer) {
   const map = {
     workspace_context: ["customer_data"],
@@ -3425,6 +3985,7 @@ function buildFallbackPlanSnapshot(plan) {
     target_count: plan.targetCount,
     approvals: plan.approvals,
     brain_preflight: plan.brainPreflight,
+    campaign_strategy_context: plan.buildRequest.campaignStrategyContext,
     operating_playbooks: plan.operatingPlaybooks
   });
 }
@@ -3557,6 +4118,7 @@ function buildCampaignArgs(request) {
   if (request.dedupKeys) args.dedup_keys = request.dedupKeys;
   if (request.brainPreflight) args.brain_preflight = request.brainPreflight;
   if (request.brainDefaults) args.brain_defaults = request.brainDefaults;
+  if (request.campaignStrategyContext) args.campaign_strategy_context = request.campaignStrategyContext;
   if (request.deliveryRisk) args.delivery_risk = request.deliveryRisk;
   if (request.icp) {
     args.icp = compact({
@@ -3576,6 +4138,15 @@ function buildCampaignArgs(request) {
       model: request.policy.model
     });
   }
+  if (request.sourceRouting) {
+    args.source_routing = compact({
+      mode: request.sourceRouting.mode,
+      fill_policy: request.sourceRouting.fillPolicy,
+      shard_size: request.sourceRouting.shardSize,
+      max_source_shard_size: request.sourceRouting.maxSourceShardSize,
+      max_local_source_shard_size: request.sourceRouting.maxLocalSourceShardSize
+    });
+  }
   if (request.signals) {
     args.signals = compact({
       enabled: request.signals.enabled,
@@ -3647,7 +4218,8 @@ function buildExecutionPrepareArgs(request, dryRun, confirmSpend) {
     qualification: buildArgs2.qualification,
     copy: buildArgs2.copy,
     delivery: buildArgs2.delivery,
-    enhancers: buildArgs2.enhancers
+    enhancers: buildArgs2.enhancers,
+    source_routing: buildArgs2.source_routing
   });
 }
 function buildDeliveryApprovalArgs(request) {
@@ -3696,17 +4268,62 @@ function mapAgentCampaignBuildStatus(data) {
     warnings: diagnosticMessages2(data.warnings),
     errors: diagnosticMessages2(data.errors),
     artifactCount: numberOrUndefined2(data.artifact_count) ?? 0,
+    artifactDownloads: Array.isArray(data.artifact_downloads) ? data.artifact_downloads.map(mapAgentCampaignArtifactDownload) : [],
+    customerRowCounts: mapAgentCustomerRowCounts(data.customer_row_counts),
+    phaseAttemptTotals: nullableRecord(data.phase_attempt_totals) ?? void 0,
     providerRoute: mapProviderRoute2(data),
     triggerRunId: stringValue(data.trigger_run_id) ?? null,
     staleRunningPhase: data.stale_running_phase === true,
     phaseAgeSeconds: numberOrNull2(data.phase_age_seconds),
     diagnostics: nullableRecord(data.diagnostics) ?? {},
     nextAction: formatAgentNextAction(data.next_action),
+    approvalAction: formatAgentNextAction(data.approval_action),
     createdAt: stringValue(data.created_at) ?? "",
     updatedAt: stringValue(data.updated_at) ?? "",
     completedAt: stringValue(data.completed_at) ?? null
   };
 }
+function mapAgentCampaignArtifactDownload(data) {
+  return {
+    id: stringValue(data.id) ?? "",
+    artifactType: stringValue(data.artifact_type) ?? null,
+    format: stringValue(data.format) ?? null,
+    rowCount: numberOrUndefined2(data.row_count) ?? 0,
+    signedUrl: stringValue(data.signed_url) ?? null,
+    downloadUrl: stringValue(data.download_url) ?? null,
+    manifestUrl: stringValue(data.manifest_url) ?? null,
+    expiresAt: stringValue(data.expires_at) ?? null
+  };
+}
+function mapAgentCustomerRowCounts(value) {
+  const record = nullableRecord(value);
+  if (!record) return void 0;
+  return {
+    requestedTarget: numberOrNull2(record.requested_target),
+    acquiredRows: numberOrUndefined2(record.acquired_rows),
+    acceptedRows: numberOrUndefined2(record.accepted_rows),
+    usableRows: numberOrUndefined2(record.usable_rows),
+    copiedRows: numberOrUndefined2(record.copied_rows),
+    approvalReadyRows: numberOrUndefined2(record.approval_ready_rows),
+    qaReadyRows: numberOrUndefined2(record.qa_ready_rows),
+    deliveredRows: numberOrUndefined2(record.delivered_rows),
+    disqualifiedRows: numberOrUndefined2(record.disqualified_rows),
+    reviewableRows: numberOrUndefined2(record.reviewable_rows),
+    rowFailures: numberOrUndefined2(record.row_failures),
+    acceptedShortfall: numberOrNull2(record.accepted_shortfall),
+    usableShortfall: numberOrNull2(record.usable_shortfall),
+    qaReadyShortfall: numberOrNull2(record.qa_ready_shortfall),
+    deliveryShortfall: numberOrNull2(record.delivery_shortfall),
+    fillRatio: numberOrNull2(record.fill_ratio),
+    qaReadyFillRatio: numberOrNull2(record.qa_ready_fill_ratio),
+    deliveredFillRatio: numberOrNull2(record.delivered_fill_ratio),
+    terminalReason: stringValue(record.terminal_reason) ?? null,
+    acceptedShortfallReason: stringValue(record.accepted_shortfall_reason) ?? null,
+    usableShortfallReason: stringValue(record.usable_shortfall_reason) ?? null,
+    qaReadyShortfallReason: stringValue(record.qa_ready_shortfall_reason) ?? null,
+    deliveryShortfallReason: stringValue(record.delivery_shortfall_reason) ?? null
+  };
+}
 function mapAgentCampaignRowsResult(data) {
   const rows = Array.isArray(data.rows) ? data.rows : [];
   return {
@@ -3734,7 +4351,11 @@ function mapAgentCampaignArtifact(data) {
     artifactType: stringValue(data.artifact_type) ?? "",
     destination: stringValue(data.destination) ?? "",
     storagePath: stringValue(data.storage_path) ?? "",
+    format: stringValue(data.format) ?? null,
     signedUrl: stringValue(data.signed_url) ?? null,
+    downloadUrl: stringValue(data.download_url) ?? null,
+    manifestUrl: stringValue(data.manifest_url) ?? null,
+    expiresAt: stringValue(data.expires_at) ?? null,
     rowCount: numberOrUndefined2(data.row_count) ?? 0,
     checksum: stringValue(data.checksum) ?? null,
     metadata: nullableRecord(data.metadata) ?? {},
@@ -3896,6 +4517,8 @@ function readinessLaneLabel(route, builtIn) {
     const labels = {
       lead_generation: "Signaliz lead generation",
       local_leads: "Signaliz local leads",
+      company_discovery: "Signaliz company discovery",
+      people_discovery: "Signaliz people discovery",
       email_finding: "Signaliz email finding",
       email_verification: "Signaliz email verification",
       signals: "Signaliz signals"
@@ -3980,6 +4603,35 @@ function summarizeCampaignBuilderProofDryRun(dryRunResult) {
     plannedTargetCount: dryRunResult.plannedTargetCount ?? dryRunResult.planned_target_count ?? null
   };
 }
+function summarizeCampaignBuilderProofLearnBack(plan) {
+  if (Object.keys(plan).length === 0) return { ready: false };
+  const memoryPolicy = asRecord(plan.memory_write_policy);
+  const memoryItemsPolicy = asRecord(memoryPolicy.gtm_memory_items);
+  const sequence = Array.isArray(plan.post_build_sequence) ? plan.post_build_sequence.map((step) => {
+    const record = asRecord(step);
+    return compact({
+      step: record.step,
+      tool: stringValue(record.tool),
+      approval_boundary: stringValue(record.approval_boundary),
+      reason: stringValue(record.reason)
+    });
+  }).filter((step) => typeof step.tool === "string") : [];
+  return {
+    ready: sequence.length > 0,
+    source_tool: firstNonEmptyString(plan.source_tool, plan.sourceTool),
+    post_build_sequence: sequence,
+    memory_write_policy: {
+      target_tables: Array.isArray(memoryPolicy.target_tables) ? memoryPolicy.target_tables : [],
+      gtm_memory_items: {
+        shareable: memoryItemsPolicy.shareable === false ? false : memoryItemsPolicy.shareable ?? null,
+        allowed_redaction_states: Array.isArray(memoryItemsPolicy.allowed_redaction_states) ? memoryItemsPolicy.allowed_redaction_states : [],
+        raw_private_fields_withheld: Array.isArray(memoryItemsPolicy.raw_private_fields_withheld) ? memoryItemsPolicy.raw_private_fields_withheld : []
+      }
+    },
+    approval_policy: firstNonEmptyString(plan.approval_policy, plan.approvalPolicy),
+    privacy_policy: firstNonEmptyString(plan.privacy_policy, plan.privacyPolicy)
+  };
+}
 function firstNonEmptyString(...values) {
   for (const value of values) {
     if (typeof value === "string" && value.trim()) return value;
@@ -4462,14 +5114,87 @@ var Ops = class {
     const body = typeof params === "string" ? { prompt: params } : buildOpsCreateBody(params);
     return normalizeOpsCreateResult(withExecutionRefs(await this.call("ops_create", body)));
   }
+  async schedule(params) {
+    const createBody = typeof params === "string" ? { prompt: params, cadence: "daily" } : { ...buildOpsCreateBody(params), cadence: params.cadence ?? "daily" };
+    const { activate: _activate, ...body } = createBody;
+    return normalizeOpsCreateResult(withExecutionRefs(await this.call("ops_schedule", body)));
+  }
+  async scheduleAndWait(params) {
+    const options = typeof params === "string" ? { schedule: { prompt: params, cadence: "daily" }, run: {}, wait: {} } : buildOpsScheduleAndWaitOptions(params);
+    const raw = await this.call("ops_schedule_and_wait", buildOpsScheduleAndWaitBody(options));
+    return normalizeOpsScheduleAndWaitCallResult(raw, options.wait, {
+      approvalMessage: "ops.scheduleAndWait requires an approved schedulable Op. Retry with confirmSpend=true after reviewing approval details.",
+      notCreatedMessage: "ops.scheduleAndWait requires ops_schedule_and_wait to create an op_id. Use ops.schedule for approval review flows."
+    });
+  }
+  /** Schedule a recurring Op that delivers through a customer-owned Nango API connection. */
+  async scheduleNangoAction(input) {
+    return normalizeOpsCreateResult(withExecutionRefs(await this.call("ops_nango_schedule", buildOpsNangoScheduleBody(input))));
+  }
+  /** Schedule a recurring Nango-backed Op, run the first tick, and return result readback. */
+  async scheduleNangoActionAndWait(input) {
+    const options = buildOpsNangoScheduleAndWaitOptions(input);
+    const raw = await this.call("ops_nango_schedule_and_wait", buildOpsNangoScheduleAndWaitBody(options));
+    return normalizeOpsScheduleAndWaitCallResult(raw, options.wait, {
+      approvalMessage: "ops.scheduleNangoActionAndWait requires an approved Nango-backed Op. Retry with confirmSpend=true after reviewing approval details.",
+      notCreatedMessage: "ops.scheduleNangoActionAndWait requires ops_nango_schedule_and_wait to create an op_id. Use ops.scheduleNangoAction for approval review flows."
+    });
+  }
   async execute(params) {
     const body = typeof params === "string" ? { prompt: params } : buildOpsExecuteBody(params);
     return normalizeOpsExecuteResult(withExecutionRefs(await this.call("ops_execute", body)));
   }
+  async executeAndWait(params) {
+    const options = typeof params === "string" ? { execute: { prompt: params, auto_run: true }, wait: {} } : buildOpsExecuteAndWaitOptions(params);
+    const execute = await this.execute(options.execute);
+    if (execute.approval_required || execute.error_code === "APPROVAL_REQUIRED") {
+      throw new SignalizError({
+        code: "APPROVAL_REQUIRED",
+        errorType: "validation",
+        message: "ops.executeAndWait requires an approved executable Op. Retry with confirmSpend=true after reviewing approval details.",
+        details: { execute }
+      });
+    }
+    if (!execute.op_id) {
+      throw new SignalizError({
+        code: "OP_NOT_CREATED",
+        errorType: "validation",
+        message: "ops.executeAndWait requires ops_execute to create an op_id. Use ops.execute for dry runs or approval review flows.",
+        details: { execute }
+      });
+    }
+    const waited = await this.waitForResults({
+      ...options.wait,
+      op_id: execute.op_id
+    });
+    const runId = execute.run_id ?? execute.runId ?? waited.status.run_id ?? waited.status.runId ?? null;
+    return {
+      ...waited,
+      execute,
+      run_id: runId,
+      runId,
+      execution_refs: mergeExecutionRefsFrom([execute, waited])
+    };
+  }
   async run(params) {
     const body = typeof params === "string" ? { op_id: params } : buildOpsRunBody(params);
     return normalizeOpsRunResult(withExecutionRefs(await this.call("ops_run", body)));
   }
+  async runAndWait(params) {
+    const options = typeof params === "string" ? { op_id: params } : buildOpsRunAndWaitOptions(params);
+    if (!options.op_id) throw new Error("ops.runAndWait requires op_id or opId");
+    const run = await this.run({
+      op_id: options.op_id,
+      instruction: options.instruction,
+      force: options.force
+    });
+    const waited = await this.waitForResults(options);
+    return {
+      ...waited,
+      run,
+      execution_refs: mergeExecutionRefsFrom([run, waited])
+    };
+  }
   async status(params) {
     const body = typeof params === "string" ? { op_id: params } : buildOpsStatusBody(params);
     return normalizeOpsStatusResult(withExecutionRefs(await this.call("ops_status", body)));
@@ -4478,77 +5203,250 @@ var Ops = class {
     const body = typeof params === "string" ? { op_id: params } : buildOpsResultsBody(params);
     return normalizeOpsResultsResult(withExecutionRefs(await this.call("ops_results", body)));
   }
-  async proof(params = {}) {
-    const data = await this.call("ops_proof", {
-      window_hours: params.windowHours,
-      output_format: "json"
+  async waitForResults(params) {
+    const options = typeof params === "string" ? { op_id: params } : buildOpsWaitForResultsOptions(params);
+    if (!options.op_id) throw new Error("ops.waitForResults requires op_id or opId");
+    const waitResult = await this.call("ops_wait", buildOpsWaitBody(options));
+    return normalizeOpsWaitForResultsResult(waitResult, options);
+  }
+  /** Create a short-lived Nango Connect session from the Ops namespace. */
+  async createNangoConnectSession(input) {
+    return this.call("nango_connect_session_create", {
+      provider_id: input.providerId,
+      integration_id: input.integrationId,
+      provider_display_name: input.providerDisplayName,
+      integration_display_name: input.integrationDisplayName,
+      allowed_integrations: input.allowedIntegrations,
+      surface: input.surface,
+      source: input.source,
+      user_email: input.userEmail,
+      user_display_name: input.userDisplayName
     });
-    return normalizeOpsProofResult(data);
   }
-  async debug(params) {
-    const options = typeof params === "string" ? { op_id: params } : buildOpsDebugOptions(params);
-    const diagnosticErrors = [];
-    const status = await this.status(options.op_id);
-    const refs = /* @__PURE__ */ new Map();
-    const addRefs = (items) => {
-      for (const ref of items ?? []) refs.set(`${ref.kind}:${ref.id}`, ref);
-    };
-    const recordError = (step, err) => {
-      diagnosticErrors.push({
-        step,
-        message: err instanceof Error ? err.message : String(err)
-      });
-    };
-    addRefs(status.execution_refs);
-    if (status.latest_run && typeof status.latest_run === "object") {
-      addRefs(collectExecutionReferences(status.latest_run));
-    }
-    const runRefs = Array.from(refs.values()).filter((ref) => ref.kind === "trigger_run" || ref.kind === "dataplane_run" || ref.kind === "replay_run");
-    const runStatuses = [];
-    for (const ref of runRefs) {
-      try {
-        const result = await this.getTriggerRunStatus(ref.id);
-        const runs = "runs" in result ? result.runs : [result];
-        runStatuses.push(...runs);
-        for (const run of runs) addRefs(run.execution_refs);
-      } catch (err) {
-        recordError(`run-status:${ref.id}`, err);
-      }
+  /** Prepare the full Nango provider search, connect, pull/export, Ops, and route flow. */
+  async prepareNangoIntegrationFlow(input = {}) {
+    return this.call("nango_integration_flow_prepare", {
+      query: input.query,
+      search: input.search,
+      provider_id: input.providerId,
+      provider: input.provider,
+      integration_id: input.integrationId,
+      provider_config_key: input.providerConfigKey,
+      workspace_connection_id: input.workspaceConnectionId,
+      connection_id: input.connectionId,
+      nango_connection_id: input.nangoConnectionId,
+      intent: input.intent,
+      action_name: input.actionName,
+      tool_name: input.toolName,
+      proxy_path: input.proxyPath,
+      method: input.method,
+      input: input.input,
+      cadence: input.cadence,
+      field_map: input.fieldMap,
+      required_fields: input.requiredFields,
+      confirm_spend: input.confirmSpend,
+      write_confirmed: input.writeConfirmed,
+      layer: input.layer,
+      campaign_id: input.campaignId,
+      limit: input.limit,
+      include_provider_catalog: input.includeProviderCatalog
+    });
+  }
+  /** List Nango-backed action tools for a workspace connection without executing them. */
+  async listNangoTools(options = {}) {
+    return this.call("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
+    });
+  }
+  /** Audit connected Nango rows, action/proxy readiness, and read/write proof gaps. */
+  async proveNangoReadWrite(options = {}) {
+    return this.call("nango_mcp_read_write_audit", {
+      workspace_connection_id: options.workspaceConnectionId,
+      connection_id: options.connectionId,
+      provider_config_key: options.providerConfigKey,
+      integration_id: options.integrationId,
+      nango_connection_id: options.nangoConnectionId,
+      limit: options.limit,
+      include_raw: options.includeRaw,
+      read_proxy_path: options.readProxyPath,
+      write_proxy_path: options.writeProxyPath,
+      method: options.method,
+      execute_read_probe: options.executeReadProbe,
+      execute_write_probe: options.executeWriteProbe,
+      confirm: options.confirm,
+      confirm_write: options.confirmWrite,
+      input: options.input,
+      write_input: options.writeInput
+    });
+  }
+  /** Dry-run or execute a Nango-backed action tool through the approval-aware MCP bridge. */
+  async callNangoTool(input) {
+    return this.call("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,
+      delivery_mode: input.deliveryMode,
+      proxy_path: input.proxyPath,
+      nango_proxy_path: input.nangoProxyPath,
+      method: input.method,
+      http_method: input.httpMethod,
+      proxy_headers: input.proxyHeaders,
+      input: input.input,
+      async: input.async,
+      max_retries: input.maxRetries,
+      dry_run: input.dryRun,
+      confirm: input.confirm,
+      confirm_write: input.confirmWrite
+    });
+  }
+  /** Execute a Nango action and poll its async result when a status URL/action id is returned. */
+  async callNangoToolAndWait(input) {
+    const result = await this.call("nango_mcp_tool_call_and_wait", {
+      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,
+      delivery_mode: input.deliveryMode,
+      proxy_path: input.proxyPath,
+      nango_proxy_path: input.nangoProxyPath,
+      method: input.method,
+      http_method: input.httpMethod,
+      proxy_headers: input.proxyHeaders,
+      input: input.input,
+      async: input.async ?? true,
+      max_retries: input.maxRetries,
+      dry_run: input.dryRun,
+      confirm: input.confirm,
+      confirm_write: input.confirmWrite,
+      interval_ms: input.intervalMs,
+      max_polls: input.maxPolls,
+      timeout_ms: input.timeoutMs
+    });
+    const packet = asRecord2(result);
+    const actionId = optionalString(packet.actionId) ?? optionalString(packet.action_id);
+    const statusUrl = optionalString(packet.statusUrl) ?? optionalString(packet.status_url);
+    const maxPolls = Number(packet.maxPolls ?? packet.max_polls ?? 0);
+    const intervalMs = Number(packet.intervalMs ?? packet.interval_ms ?? 0);
+    const timeoutMs = Number(packet.timeoutMs ?? packet.timeout_ms ?? 0);
+    const timedOut = Boolean(packet.timedOut ?? packet.timed_out);
+    return {
+      ...packet,
+      success: typeof packet.success === "boolean" ? packet.success : void 0,
+      call: packet.call,
+      result: packet.result,
+      status: optionalString(packet.status),
+      action_id: actionId,
+      actionId,
+      status_url: statusUrl,
+      statusUrl,
+      polls: Number(packet.polls ?? 0),
+      max_polls: maxPolls,
+      maxPolls,
+      interval_ms: intervalMs,
+      intervalMs,
+      timeout_ms: timeoutMs,
+      timeoutMs,
+      timed_out: timedOut,
+      timedOut
+    };
+  }
+  /** Poll an async Nango action result by action id or status URL. */
+  async getNangoActionResult(input) {
+    return this.call("nango_mcp_action_result_get", {
+      action_id: input.actionId,
+      status_url: input.statusUrl
+    });
+  }
+  async proof(params = {}) {
+    const data = await this.call("ops_proof", {
+      window_hours: params.windowHours,
+      output_format: "json"
+    });
+    return normalizeOpsProofResult(data);
+  }
+  async debug(params) {
+    const options = typeof params === "string" ? { op_id: params } : buildOpsDebugOptions(params);
+    const diagnosticErrors = [];
+    const status = await this.status(options.op_id);
+    const refs = /* @__PURE__ */ new Map();
+    const addRefs = (items) => {
+      for (const ref of items ?? []) refs.set(`${ref.kind}:${ref.id}`, ref);
+    };
+    const recordError = (step, err) => {
+      diagnosticErrors.push({
+        step,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    };
+    addRefs(status.execution_refs);
+    if (status.latest_run && typeof status.latest_run === "object") {
+      addRefs(collectExecutionReferences(status.latest_run));
     }
+    const runRefs = Array.from(refs.values()).filter((ref) => ref.kind === "trigger_run" || ref.kind === "dataplane_run" || ref.kind === "replay_run");
+    let runStatuses = [];
     let queue;
-    if (options.include_queue !== false) {
-      try {
-        queue = await this.getQueueStatus({ summary: true });
-        addRefs(queue.execution_refs);
-      } catch (err) {
-        recordError("queue", err);
-      }
-    }
     let dashboardRecent;
-    if (options.include_dashboard !== false) {
-      try {
-        dashboardRecent = await this.getDashboard({
-          section: "recent",
-          limit: options.dashboard_limit ?? 10,
-          timeRangeDays: options.time_range_days
-        });
-      } catch (err) {
-        recordError("dashboard:recent", err);
-      }
-    }
     let results;
-    if (options.include_results) {
-      try {
-        results = await this.results({
-          op_id: options.op_id,
-          limit: options.results_limit ?? 25,
-          include_failed_runs: true
-        });
-        addRefs(results.execution_refs);
-      } catch (err) {
-        recordError("results", err);
-      }
-    }
+    await Promise.all([
+      (async () => {
+        if (runRefs.length === 0) return;
+        try {
+          const result = await this.getTriggerRunStatus({ run_ids: runRefs.map((ref) => ref.id) });
+          const runs = "runs" in result ? result.runs : [result];
+          runStatuses = runs;
+          for (const run of runs) addRefs(run.execution_refs);
+        } catch (err) {
+          recordError(runRefs.length === 1 ? `run-status:${runRefs[0].id}` : "run-status:batch", err);
+        }
+      })(),
+      (async () => {
+        if (options.include_queue === false) return;
+        try {
+          queue = await this.getQueueStatus({ summary: true });
+          addRefs(queue.execution_refs);
+        } catch (err) {
+          recordError("queue", err);
+        }
+      })(),
+      (async () => {
+        if (options.include_dashboard === false) return;
+        try {
+          dashboardRecent = await this.getDashboard({
+            section: "recent",
+            limit: options.dashboard_limit ?? 10,
+            timeRangeDays: options.time_range_days
+          });
+        } catch (err) {
+          recordError("dashboard:recent", err);
+        }
+      })(),
+      (async () => {
+        if (!options.include_results) return;
+        try {
+          results = await this.results({
+            op_id: options.op_id,
+            limit: options.results_limit ?? 25,
+            include_failed_runs: true
+          });
+          addRefs(results.execution_refs);
+        } catch (err) {
+          recordError("results", err);
+        }
+      })()
+    ]);
     const executionRefs = Array.from(refs.values());
     const replayCandidates = executionRefs.filter((ref) => ref.kind === "execution_event");
     const nextActions = buildDebugNextActions(status, executionRefs, diagnosticErrors);
@@ -4750,6 +5648,69 @@ function mergeExecutionRefs(result) {
   for (const ref of collectExecutionReferences(result)) add(ref);
   return Array.from(refs.values());
 }
+function mergeExecutionRefsFrom(results) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (!result) continue;
+    for (const ref of mergeExecutionRefs(result)) refs.set(`${ref.kind}:${ref.id}`, ref);
+  }
+  return Array.from(refs.values());
+}
+function normalizeOpsScheduleAndWaitCallResult(raw, waitOptions, messages) {
+  if (raw.approval_required || raw.approvalRequired || raw.error_code === "APPROVAL_REQUIRED" || raw.errorCode === "APPROVAL_REQUIRED") {
+    throw new SignalizError({
+      code: "APPROVAL_REQUIRED",
+      errorType: "validation",
+      message: messages.approvalMessage,
+      details: { schedule: raw }
+    });
+  }
+  const opId = stringValue2(raw.op_id ?? raw.opId);
+  if (!opId) {
+    throw new SignalizError({
+      code: "OP_NOT_CREATED",
+      errorType: "validation",
+      message: messages.notCreatedMessage,
+      details: { schedule: raw }
+    });
+  }
+  const scheduleRaw = asRecord2(raw.schedule ?? raw.schedule_result ?? raw.scheduleResult);
+  const runRaw = asRecord2(raw.run ?? raw.run_result ?? raw.runResult);
+  const schedule = normalizeOpsCreateResult(withExecutionRefs(
+    Object.keys(scheduleRaw).length > 0 ? scheduleRaw : {
+      ...raw,
+      op_id: opId,
+      routine_id: raw.routine_id ?? raw.routineId ?? opId,
+      status: "ready",
+      phase: "scheduled",
+      next_action: raw.next_action ?? raw.nextAction
+    }
+  ));
+  const run = normalizeOpsRunResult(withExecutionRefs(
+    Object.keys(runRaw).length > 0 ? runRaw : {
+      success: raw.success !== false,
+      op_id: opId,
+      routine_id: raw.routine_id ?? raw.routineId ?? opId,
+      run_id: raw.run_id ?? raw.runId ?? null,
+      status: "running",
+      phase: "queued",
+      next_action: raw.next_action ?? raw.nextAction,
+      results_count: 0,
+      results_url: raw.results_url ?? raw.resultsUrl,
+      delivery_status: raw.delivery_status ?? raw.deliveryStatus
+    }
+  ));
+  const waited = normalizeOpsWaitForResultsResult(raw, { ...waitOptions, op_id: opId });
+  const runId = run.run_id ?? run.runId ?? waited.run_id ?? waited.runId ?? waited.status.run_id ?? waited.status.runId ?? null;
+  return {
+    ...waited,
+    schedule,
+    run,
+    run_id: runId,
+    runId,
+    execution_refs: mergeExecutionRefsFrom([schedule, run, waited])
+  };
+}
 function normalizeOpsPrimitiveRetryPolicy(policy = {}) {
   return {
     ...policy,
@@ -4825,8 +5786,122 @@ function normalizeOpsPrimitive(primitive) {
     observability: normalizeOpsPrimitiveObservabilityPolicy(primitive.observability)
   };
 }
+function normalizeOpsExecutionToolCall(rawCall) {
+  const call = asRecord2(rawCall);
+  return {
+    ...call,
+    tool: stringValue2(call.tool),
+    arguments: asRecord2(call.arguments),
+    purpose: stringValue2(call.purpose)
+  };
+}
+function normalizeOpsExecutionScheduleContract(rawSchedule) {
+  const schedule = asRecord2(rawSchedule);
+  const wakeOnEvents = Array.isArray(schedule.wake_on_events) ? schedule.wake_on_events.map(String) : Array.isArray(schedule.wakeOnEvents) ? schedule.wakeOnEvents.map(String) : [];
+  return {
+    ...schedule,
+    create_tool: stringValue2(schedule.create_tool ?? schedule.createTool),
+    createTool: stringValue2(schedule.createTool ?? schedule.create_tool),
+    activate_tool: stringValue2(schedule.activate_tool ?? schedule.activateTool),
+    activateTool: stringValue2(schedule.activateTool ?? schedule.activate_tool),
+    cadence: stringValue2(schedule.cadence, "manual"),
+    recurrence: stringValue2(schedule.recurrence),
+    wake_on_events: wakeOnEvents,
+    wakeOnEvents
+  };
+}
+function normalizeOpsExecutionApprovalContract(rawApproval) {
+  const approval = asRecord2(rawApproval);
+  return {
+    ...approval,
+    required: Boolean(approval.required),
+    tool: stringValue2(approval.tool),
+    reason: stringValue2(approval.reason)
+  };
+}
+function normalizeOpsExecutionMonitorContract(rawMonitor) {
+  const monitor = asRecord2(rawMonitor);
+  const pollAfterMs = numberValue(monitor.poll_after_ms ?? monitor.pollAfterMs);
+  return {
+    ...monitor,
+    status_tool: stringValue2(monitor.status_tool ?? monitor.statusTool),
+    statusTool: stringValue2(monitor.statusTool ?? monitor.status_tool),
+    wait_tool: stringValue2(monitor.wait_tool ?? monitor.waitTool),
+    waitTool: stringValue2(monitor.waitTool ?? monitor.wait_tool),
+    results_tool: stringValue2(monitor.results_tool ?? monitor.resultsTool),
+    resultsTool: stringValue2(monitor.resultsTool ?? monitor.results_tool),
+    poll_after_ms: pollAfterMs,
+    pollAfterMs
+  };
+}
+function normalizeOpsExecutionResultContract(rawResult) {
+  const result = asRecord2(rawResult);
+  const shape = Array.isArray(result.shape) ? result.shape.map(String) : [];
+  return {
+    ...result,
+    tool: stringValue2(result.tool),
+    wait_tool: stringValue2(result.wait_tool ?? result.waitTool),
+    waitTool: stringValue2(result.waitTool ?? result.wait_tool),
+    shape,
+    empty_result_recovery: stringValue2(result.empty_result_recovery ?? result.emptyResultRecovery),
+    emptyResultRecovery: stringValue2(result.emptyResultRecovery ?? result.empty_result_recovery)
+  };
+}
+function normalizeOpsExecutionNangoRouteContract(rawRoute) {
+  if (!rawRoute || typeof rawRoute !== "object" || Array.isArray(rawRoute)) return void 0;
+  const route = asRecord2(rawRoute);
+  const requiredFields = Array.isArray(route.required_fields) ? route.required_fields.map(String) : Array.isArray(route.requiredFields) ? route.requiredFields.map(String) : [];
+  return {
+    ...route,
+    enabled: route.enabled !== false,
+    connect_tool: stringValue2(route.connect_tool ?? route.connectTool),
+    connectTool: stringValue2(route.connectTool ?? route.connect_tool),
+    discover_tool: stringValue2(route.discover_tool ?? route.discoverTool),
+    discoverTool: stringValue2(route.discoverTool ?? route.discover_tool),
+    dry_run_tool: stringValue2(route.dry_run_tool ?? route.dryRunTool),
+    dryRunTool: stringValue2(route.dryRunTool ?? route.dry_run_tool),
+    execute_tool: stringValue2(route.execute_tool ?? route.executeTool),
+    executeTool: stringValue2(route.executeTool ?? route.execute_tool),
+    execute_and_wait_tool: stringValue2(route.execute_and_wait_tool ?? route.executeAndWaitTool),
+    executeAndWaitTool: stringValue2(route.executeAndWaitTool ?? route.execute_and_wait_tool),
+    schedule_tool: stringValue2(route.schedule_tool ?? route.scheduleTool),
+    scheduleTool: stringValue2(route.scheduleTool ?? route.schedule_tool),
+    schedule_and_wait_tool: stringValue2(route.schedule_and_wait_tool ?? route.scheduleAndWaitTool),
+    scheduleAndWaitTool: stringValue2(route.scheduleAndWaitTool ?? route.schedule_and_wait_tool),
+    result_tool: stringValue2(route.result_tool ?? route.resultTool),
+    resultTool: stringValue2(route.resultTool ?? route.result_tool),
+    write_gate: stringValue2(route.write_gate ?? route.writeGate),
+    writeGate: stringValue2(route.writeGate ?? route.write_gate),
+    required_fields: requiredFields,
+    requiredFields,
+    schedule_arguments: asRecord2(route.schedule_arguments ?? route.scheduleArguments),
+    scheduleArguments: asRecord2(route.scheduleArguments ?? route.schedule_arguments),
+    schedule_and_wait_arguments: asRecord2(route.schedule_and_wait_arguments ?? route.scheduleAndWaitArguments),
+    scheduleAndWaitArguments: asRecord2(route.scheduleAndWaitArguments ?? route.schedule_and_wait_arguments)
+  };
+}
+function normalizeOpsExecutionContract(rawContract) {
+  if (!rawContract || typeof rawContract !== "object" || Array.isArray(rawContract)) return void 0;
+  const contract = asRecord2(rawContract);
+  const nangoRoute = normalizeOpsExecutionNangoRouteContract(contract.nango_route ?? contract.nangoRoute);
+  const sequence = Array.isArray(contract.sequence) ? contract.sequence.map(normalizeOpsExecutionToolCall) : [];
+  return {
+    ...contract,
+    mode: stringValue2(contract.mode, "run_once"),
+    run_now: normalizeOpsExecutionToolCall(contract.run_now ?? contract.runNow),
+    runNow: normalizeOpsExecutionToolCall(contract.runNow ?? contract.run_now),
+    schedule: normalizeOpsExecutionScheduleContract(contract.schedule),
+    approval: normalizeOpsExecutionApprovalContract(contract.approval),
+    monitor: normalizeOpsExecutionMonitorContract(contract.monitor),
+    result_contract: normalizeOpsExecutionResultContract(contract.result_contract ?? contract.resultContract),
+    resultContract: normalizeOpsExecutionResultContract(contract.resultContract ?? contract.result_contract),
+    ...nangoRoute ? { nango_route: nangoRoute, nangoRoute } : {},
+    sequence
+  };
+}
 function normalizeOpsPlanResult(result) {
   const primitiveGraph = result.primitive_graph ?? result.primitiveGraph;
+  const executionContract = normalizeOpsExecutionContract(result.execution_contract ?? result.executionContract);
   return {
     ...result,
     plan_id: result.plan_id ?? result.planId,
@@ -4850,7 +5925,8 @@ function normalizeOpsPlanResult(result) {
     destination_status: result.destination_status ?? result.destinationStatus,
     destinationStatus: result.destinationStatus ?? result.destination_status,
     primitive_graph: primitiveGraph?.map(normalizeOpsPrimitive),
-    primitiveGraph: primitiveGraph?.map(normalizeOpsPrimitive)
+    primitiveGraph: primitiveGraph?.map(normalizeOpsPrimitive),
+    ...executionContract ? { execution_contract: executionContract, executionContract } : {}
   };
 }
 function normalizeOpsCreateResult(result) {
@@ -4872,7 +5948,18 @@ function normalizeOpsCreateResult(result) {
     deliveryStatus: result.deliveryStatus ?? result.delivery_status,
     estimated_credits: result.estimated_credits ?? result.estimatedCredits,
     estimatedCredits: result.estimatedCredits ?? result.estimated_credits,
-    plan: result.plan ? normalizeOpsPlanResult(result.plan) : result.plan
+    error_code: result.error_code ?? result.errorCode,
+    errorCode: result.errorCode ?? result.error_code,
+    approval_required: result.approval_required ?? result.approvalRequired,
+    approvalRequired: result.approvalRequired ?? result.approval_required,
+    retry_arguments: result.retry_arguments ?? result.retryArguments,
+    retryArguments: result.retryArguments ?? result.retry_arguments,
+    blockers: result.blockers,
+    plan: result.plan ? normalizeOpsPlanResult(result.plan) : result.plan,
+    next_step: result.next_step ?? result.nextStep,
+    nextStep: result.nextStep ?? result.next_step,
+    next_steps: result.next_steps ?? result.nextSteps,
+    nextSteps: result.nextSteps ?? result.next_steps
   };
 }
 function normalizeOpsExecuteResult(result) {
@@ -5000,6 +6087,40 @@ function normalizeOpsStatusResult(result) {
     diagnosis: result.diagnosis ? normalizeOpsDebugDiagnosis(result.diagnosis) : void 0
   };
 }
+function normalizeOpsResultsSummary(value) {
+  const summary = asRecord2(value);
+  if (Object.keys(summary).length === 0) return void 0;
+  const resultsTotal = summary.results_total ?? summary.resultsTotal;
+  const nextCursor = summary.next_cursor ?? summary.nextCursor ?? null;
+  const resultsUrl = summary.results_url ?? summary.resultsUrl;
+  const nextAction = summary.next_action ?? summary.nextAction;
+  const runId = summary.run_id ?? summary.runId ?? null;
+  const creditsUsed = summary.credits_used ?? summary.creditsUsed;
+  return {
+    ...summary,
+    label: optionalString(summary.label),
+    status: optionalString(summary.status),
+    phase: optionalString(summary.phase),
+    results_count: numberValue(summary.results_count ?? summary.resultsCount),
+    resultsCount: numberValue(summary.results_count ?? summary.resultsCount),
+    results_total: resultsTotal === null || resultsTotal === void 0 ? resultsTotal : numberValue(resultsTotal),
+    resultsTotal: resultsTotal === null || resultsTotal === void 0 ? resultsTotal : numberValue(resultsTotal),
+    delivery_status: optionalString(summary.delivery_status ?? summary.deliveryStatus),
+    deliveryStatus: optionalString(summary.delivery_status ?? summary.deliveryStatus),
+    has_more: Boolean(summary.has_more ?? summary.hasMore),
+    hasMore: Boolean(summary.has_more ?? summary.hasMore),
+    next_cursor: nextCursor === null ? null : optionalString(nextCursor),
+    nextCursor: nextCursor === null ? null : optionalString(nextCursor),
+    results_url: optionalString(resultsUrl),
+    resultsUrl: optionalString(resultsUrl),
+    next_action: optionalString(nextAction),
+    nextAction: optionalString(nextAction),
+    run_id: runId === null ? null : optionalString(runId),
+    runId: runId === null ? null : optionalString(runId),
+    credits_used: creditsUsed === void 0 ? void 0 : numberValue(creditsUsed),
+    creditsUsed: creditsUsed === void 0 ? void 0 : numberValue(creditsUsed)
+  };
+}
 function normalizeOpsResultsResult(result) {
   const nextCursor = result.next_cursor ?? result.nextCursor ?? null;
   const hasMore = result.has_more ?? result.hasMore ?? false;
@@ -5024,7 +6145,104 @@ function normalizeOpsResultsResult(result) {
     results_url: result.results_url ?? result.resultsUrl,
     resultsUrl: result.resultsUrl ?? result.results_url,
     delivery_status: result.delivery_status ?? result.deliveryStatus,
-    deliveryStatus: result.deliveryStatus ?? result.delivery_status
+    deliveryStatus: result.deliveryStatus ?? result.delivery_status,
+    summary: normalizeOpsResultsSummary(result.summary)
+  };
+}
+function normalizeOpsWaitForResultsPoll(value, fallbackPoll) {
+  const raw = asRecord2(value);
+  const checkedAt = stringValue2(raw.checked_at ?? raw.checkedAt);
+  const resultsCount = raw.results_count ?? raw.resultsCount;
+  const runId = raw.run_id ?? raw.runId ?? null;
+  const nextAction = raw.next_action ?? raw.nextAction;
+  return {
+    ...raw,
+    poll: numberValue(raw.poll) || fallbackPoll,
+    checked_at: checkedAt,
+    checkedAt,
+    status: stringValue2(raw.status, "unknown"),
+    phase: optionalString(raw.phase),
+    results_count: resultsCount === void 0 ? void 0 : numberValue(resultsCount),
+    resultsCount: resultsCount === void 0 ? void 0 : numberValue(resultsCount),
+    run_id: runId === null ? null : optionalString(runId),
+    runId: runId === null ? null : optionalString(runId),
+    next_action: optionalString(nextAction),
+    nextAction: optionalString(nextAction)
+  };
+}
+function normalizeOpsWaitForResultsResult(result, options) {
+  const opId = stringValue2(result.op_id ?? result.opId ?? options.op_id);
+  const routineId = stringValue2(result.routine_id ?? result.routineId ?? opId);
+  const runId = result.run_id ?? result.runId ?? null;
+  const timedOut = Boolean(result.timed_out ?? result.timedOut);
+  const statusRaw = asRecord2(result.status_result ?? result.statusResult);
+  const resultsRaw = asRecord2(result.results_result ?? result.resultsResult);
+  const historySource = Array.isArray(result.poll_history) ? result.poll_history : Array.isArray(result.history) ? result.history : [];
+  const history = historySource.map((item, index) => normalizeOpsWaitForResultsPoll(item, index + 1));
+  const status = normalizeOpsStatusResult(withExecutionRefs({
+    success: result.success !== false,
+    op_id: opId,
+    routine_id: routineId,
+    run_id: runId,
+    status: stringValue2(result.status, "unknown"),
+    phase: stringValue2(result.phase, "unknown"),
+    next_action: stringValue2(result.next_action ?? result.nextAction),
+    results_count: numberValue(result.results_count ?? result.resultsCount),
+    results_url: optionalString(result.results_url ?? result.resultsUrl),
+    delivery_status: optionalString(result.delivery_status ?? result.deliveryStatus),
+    ...statusRaw
+  }));
+  const includeResults = options.include_results !== false && options.includeResults !== false;
+  const hasResultsPacket = Object.keys(resultsRaw).length > 0 || Array.isArray(result.results);
+  const results = includeResults && hasResultsPacket ? normalizeOpsResultsResult(withExecutionRefs({
+    success: result.success !== false,
+    op_id: opId,
+    routine_id: routineId,
+    run_id: runId,
+    status: stringValue2(result.status, status.status),
+    phase: stringValue2(result.phase, status.phase),
+    results_count: numberValue(result.results_count ?? result.resultsCount),
+    results_total: result.results_total ?? result.resultsTotal ?? null,
+    results: Array.isArray(result.results) ? result.results : [],
+    next_cursor: result.next_cursor ?? result.nextCursor ?? null,
+    has_more: Boolean(result.has_more ?? result.hasMore),
+    next_action: stringValue2(result.next_action ?? result.nextAction),
+    results_url: optionalString(result.results_url ?? result.resultsUrl),
+    delivery_status: optionalString(result.delivery_status ?? result.deliveryStatus),
+    ...resultsRaw
+  })) : void 0;
+  const polls = numberValue(result.polls) || history.length;
+  const maxPolls = result.max_polls ?? result.maxPolls;
+  const intervalMs = result.interval_ms ?? result.intervalMs;
+  const timeoutMs = result.timeout_ms ?? result.timeoutMs;
+  const stopReason = result.stop_reason ?? result.stopReason;
+  const nextAction = result.next_action ?? result.nextAction ?? results?.next_action ?? status.next_action;
+  return {
+    ...result,
+    success: result.success !== false && !timedOut,
+    op_id: opId,
+    opId,
+    routine_id: routineId,
+    routineId,
+    run_id: runId === null ? null : optionalString(runId),
+    runId: runId === null ? null : optionalString(runId),
+    status,
+    results,
+    timed_out: timedOut,
+    timedOut,
+    polls,
+    max_polls: maxPolls === void 0 ? void 0 : numberValue(maxPolls),
+    maxPolls: maxPolls === void 0 ? void 0 : numberValue(maxPolls),
+    interval_ms: intervalMs === void 0 ? void 0 : numberValue(intervalMs),
+    intervalMs: intervalMs === void 0 ? void 0 : numberValue(intervalMs),
+    timeout_ms: timeoutMs === void 0 ? void 0 : numberValue(timeoutMs),
+    timeoutMs: timeoutMs === void 0 ? void 0 : numberValue(timeoutMs),
+    stop_reason: optionalString(stopReason),
+    stopReason: optionalString(stopReason),
+    history,
+    next_action: optionalString(nextAction),
+    nextAction: optionalString(nextAction),
+    execution_refs: mergeExecutionRefsFrom([result, status, results, { history }])
   };
 }
 function normalizeOpsProofResult(data) {
@@ -5104,11 +6322,107 @@ function normalizeOpsProofResult(data) {
     raw: data
   };
 }
+function normalizeOpsAutopilotSchedulePacket(rawPacket) {
+  const packet = asRecord2(rawPacket);
+  return {
+    ...packet,
+    cadence: stringValue2(packet.cadence, "manual"),
+    recurrence: stringValue2(packet.recurrence),
+    activate_with: stringValue2(packet.activate_with ?? packet.activateWith),
+    activateWith: stringValue2(packet.activate_with ?? packet.activateWith),
+    run_now_with: stringValue2(packet.run_now_with ?? packet.runNowWith),
+    runNowWith: stringValue2(packet.run_now_with ?? packet.runNowWith),
+    monitor_with: stringValue2(packet.monitor_with ?? packet.monitorWith),
+    monitorWith: stringValue2(packet.monitor_with ?? packet.monitorWith),
+    retrieve_with: stringValue2(packet.retrieve_with ?? packet.retrieveWith),
+    retrieveWith: stringValue2(packet.retrieve_with ?? packet.retrieveWith)
+  };
+}
+function normalizeOpsAutopilotNangoRoutePacket(rawPacket) {
+  if (!rawPacket || typeof rawPacket !== "object" || Array.isArray(rawPacket)) return void 0;
+  const packet = asRecord2(rawPacket);
+  const requiredFields = Array.isArray(packet.required_fields) ? packet.required_fields.map(String) : Array.isArray(packet.requiredFields) ? packet.requiredFields.map(String) : [];
+  return {
+    ...packet,
+    enabled: packet.enabled !== false,
+    route_label: stringValue2(packet.route_label ?? packet.routeLabel),
+    routeLabel: stringValue2(packet.route_label ?? packet.routeLabel),
+    connect_tool: stringValue2(packet.connect_tool ?? packet.connectTool),
+    connectTool: stringValue2(packet.connect_tool ?? packet.connectTool),
+    discover_tool: stringValue2(packet.discover_tool ?? packet.discoverTool),
+    discoverTool: stringValue2(packet.discover_tool ?? packet.discoverTool),
+    dry_run_tool: stringValue2(packet.dry_run_tool ?? packet.dryRunTool),
+    dryRunTool: stringValue2(packet.dry_run_tool ?? packet.dryRunTool),
+    execute_tool: stringValue2(packet.execute_tool ?? packet.executeTool),
+    executeTool: stringValue2(packet.execute_tool ?? packet.executeTool),
+    execute_and_wait_tool: stringValue2(packet.execute_and_wait_tool ?? packet.executeAndWaitTool),
+    executeAndWaitTool: stringValue2(packet.execute_and_wait_tool ?? packet.executeAndWaitTool),
+    schedule_tool: stringValue2(packet.schedule_tool ?? packet.scheduleTool),
+    scheduleTool: stringValue2(packet.schedule_tool ?? packet.scheduleTool),
+    schedule_and_wait_tool: stringValue2(packet.schedule_and_wait_tool ?? packet.scheduleAndWaitTool),
+    scheduleAndWaitTool: stringValue2(packet.schedule_and_wait_tool ?? packet.scheduleAndWaitTool),
+    result_tool: stringValue2(packet.result_tool ?? packet.resultTool),
+    resultTool: stringValue2(packet.result_tool ?? packet.resultTool),
+    write_gate: stringValue2(packet.write_gate ?? packet.writeGate),
+    writeGate: stringValue2(packet.write_gate ?? packet.writeGate),
+    required_fields: requiredFields,
+    requiredFields,
+    placeholders: asRecord2(packet.placeholders),
+    dry_run_arguments: asRecord2(packet.dry_run_arguments ?? packet.dryRunArguments),
+    dryRunArguments: asRecord2(packet.dry_run_arguments ?? packet.dryRunArguments),
+    execute_arguments: asRecord2(packet.execute_arguments ?? packet.executeArguments),
+    executeArguments: asRecord2(packet.execute_arguments ?? packet.executeArguments),
+    execute_and_wait_arguments: asRecord2(packet.execute_and_wait_arguments ?? packet.executeAndWaitArguments),
+    executeAndWaitArguments: asRecord2(packet.execute_and_wait_arguments ?? packet.executeAndWaitArguments),
+    schedule_arguments: asRecord2(packet.schedule_arguments ?? packet.scheduleArguments),
+    scheduleArguments: asRecord2(packet.schedule_arguments ?? packet.scheduleArguments),
+    schedule_and_wait_arguments: asRecord2(packet.schedule_and_wait_arguments ?? packet.scheduleAndWaitArguments),
+    scheduleAndWaitArguments: asRecord2(packet.schedule_and_wait_arguments ?? packet.scheduleAndWaitArguments),
+    result_arguments: asRecord2(packet.result_arguments ?? packet.resultArguments),
+    resultArguments: asRecord2(packet.result_arguments ?? packet.resultArguments)
+  };
+}
+function normalizeOpsAutopilotResultPacket(rawPacket) {
+  const packet = asRecord2(rawPacket);
+  const resultShape = Array.isArray(packet.result_shape) ? packet.result_shape.map(String) : Array.isArray(packet.resultShape) ? packet.resultShape.map(String) : [];
+  const deliveryReceipts = Array.isArray(packet.delivery_receipts) ? packet.delivery_receipts.map(String) : Array.isArray(packet.deliveryReceipts) ? packet.deliveryReceipts.map(String) : [];
+  return {
+    ...packet,
+    retrieve_tool: stringValue2(packet.retrieve_tool ?? packet.retrieveTool),
+    retrieveTool: stringValue2(packet.retrieve_tool ?? packet.retrieveTool),
+    result_shape: resultShape,
+    resultShape,
+    delivery_receipts: deliveryReceipts,
+    deliveryReceipts,
+    empty_result_recovery: stringValue2(packet.empty_result_recovery ?? packet.emptyResultRecovery),
+    emptyResultRecovery: stringValue2(packet.empty_result_recovery ?? packet.emptyResultRecovery)
+  };
+}
+function normalizeOpsAutopilotOperatingPacket(rawPacket) {
+  if (!rawPacket || typeof rawPacket !== "object" || Array.isArray(rawPacket)) return void 0;
+  const packet = asRecord2(rawPacket);
+  const nangoRoute = normalizeOpsAutopilotNangoRoutePacket(packet.nango_route ?? packet.nangoRoute);
+  const approvalBoundaries = Array.isArray(packet.approval_boundaries) ? packet.approval_boundaries.map(String) : Array.isArray(packet.approvalBoundaries) ? packet.approvalBoundaries.map(String) : [];
+  return {
+    ...packet,
+    north_star: stringValue2(packet.north_star ?? packet.northStar),
+    northStar: stringValue2(packet.north_star ?? packet.northStar),
+    schedule: normalizeOpsAutopilotSchedulePacket(packet.schedule),
+    ...nangoRoute ? { nango_route: nangoRoute, nangoRoute } : {},
+    result_contract: normalizeOpsAutopilotResultPacket(packet.result_contract ?? packet.resultContract),
+    resultContract: normalizeOpsAutopilotResultPacket(packet.result_contract ?? packet.resultContract),
+    approval_boundaries: approvalBoundaries,
+    approvalBoundaries,
+    saved_command_hint: stringValue2(packet.saved_command_hint ?? packet.savedCommandHint),
+    savedCommandHint: stringValue2(packet.saved_command_hint ?? packet.savedCommandHint)
+  };
+}
 function normalizeOpsAutopilotMotion(rawMotion) {
   const motion = asRecord2(rawMotion);
   const targetCount = numberValue(motion.target_count ?? motion.targetCount);
   const estimatedCredits = numberValue(motion.estimated_credits ?? motion.estimatedCredits);
   const mcpSequence = Array.isArray(motion.mcp_sequence) ? motion.mcp_sequence : Array.isArray(motion.mcpSequence) ? motion.mcpSequence : [];
+  const operatingPacket = normalizeOpsAutopilotOperatingPacket(motion.operating_packet ?? motion.operatingPacket);
   return {
     ...motion,
     id: stringValue2(motion.id),
@@ -5131,12 +6445,16 @@ function normalizeOpsAutopilotMotion(rawMotion) {
     cli_command: optionalString(motion.cli_command ?? motion.cliCommand),
     cliCommand: optionalString(motion.cli_command ?? motion.cliCommand),
     mcp_sequence: mcpSequence,
-    mcpSequence
+    mcpSequence,
+    ...operatingPacket ? { operating_packet: operatingPacket, operatingPacket } : {}
   };
 }
 function normalizeOpsAutopilotResult(result) {
   const primary = normalizeOpsAutopilotMotion(result.primary_motion ?? result.primaryMotion);
   const motions = Array.isArray(result.motions) ? result.motions.map(normalizeOpsAutopilotMotion) : [];
+  const operatingPacket = normalizeOpsAutopilotOperatingPacket(
+    result.operating_packet ?? result.operatingPacket ?? primary.operating_packet ?? primary.operatingPacket
+  );
   const queryErrors = Array.isArray(result.query_errors) ? result.query_errors.map(String) : Array.isArray(result.queryErrors) ? result.queryErrors.map(String) : [];
   return {
     ...result,
@@ -5152,6 +6470,7 @@ function normalizeOpsAutopilotResult(result) {
     scaleRule: optionalString(result.scale_rule ?? result.scaleRule),
     agent_handoff: optionalString(result.agent_handoff ?? result.agentHandoff),
     agentHandoff: optionalString(result.agent_handoff ?? result.agentHandoff),
+    ...operatingPacket ? { operating_packet: operatingPacket, operatingPacket } : {},
     proof_state: optionalString(result.proof_state ?? result.proofState),
     proofState: optionalString(result.proof_state ?? result.proofState),
     proof_summary: result.proof_summary ?? result.proofSummary,
@@ -5416,11 +6735,125 @@ function normalizeOpsRoutineTickItemsResult(result) {
     hasMore
   };
 }
+function buildOpsNangoScheduleBody(input) {
+  const {
+    workspaceConnectionId,
+    workspace_connection_id,
+    connectionId,
+    connection_id,
+    providerConfigKey,
+    provider_config_key,
+    integrationId,
+    integration_id,
+    nangoConnectionId,
+    nango_connection_id,
+    actionName,
+    action_name,
+    toolName,
+    tool_name,
+    proxyPath,
+    proxy_path,
+    nangoProxyPath,
+    nango_proxy_path,
+    method,
+    httpMethod,
+    http_method,
+    input: nangoInput,
+    arguments: nangoArguments,
+    fieldMap,
+    field_map,
+    requiredFields,
+    required_fields,
+    writeConfirmed,
+    write_confirmed,
+    agentWriteConfirmed,
+    agent_write_confirmed,
+    config,
+    destinations: _destinations,
+    ...schedule
+  } = input;
+  return {
+    ...buildOpsCreateBody({
+      ...schedule,
+      cadence: schedule.cadence ?? "daily"
+    }),
+    workspace_connection_id: workspace_connection_id ?? workspaceConnectionId,
+    connection_id: connection_id ?? connectionId,
+    provider_config_key: provider_config_key ?? providerConfigKey,
+    integration_id: integration_id ?? integrationId,
+    nango_connection_id: nango_connection_id ?? nangoConnectionId,
+    action_name: action_name ?? actionName,
+    tool_name: tool_name ?? toolName,
+    proxy_path: proxy_path ?? proxyPath ?? nango_proxy_path ?? nangoProxyPath,
+    nango_proxy_path: nango_proxy_path ?? nangoProxyPath,
+    method: method ?? http_method ?? httpMethod,
+    input: nangoInput ?? nangoArguments,
+    field_map: field_map ?? fieldMap,
+    required_fields: required_fields ?? requiredFields,
+    write_confirmed: write_confirmed ?? writeConfirmed,
+    agent_write_confirmed: agent_write_confirmed ?? agentWriteConfirmed,
+    config
+  };
+}
+function buildOpsNangoScheduleAndWaitOptions(params) {
+  const {
+    force,
+    instruction,
+    nextCursor,
+    includeFailedRuns,
+    intervalMs,
+    maxPolls,
+    timeoutMs,
+    includeResults,
+    cursor,
+    state,
+    limit,
+    include_failed_runs,
+    interval_ms,
+    max_polls,
+    timeout_ms,
+    include_results,
+    ...schedule
+  } = params;
+  return {
+    schedule: {
+      ...schedule,
+      cadence: schedule.cadence ?? "daily"
+    },
+    run: {
+      force,
+      instruction
+    },
+    wait: {
+      cursor: cursor ?? nextCursor,
+      state,
+      limit,
+      include_failed_runs: include_failed_runs ?? includeFailedRuns,
+      interval_ms: interval_ms ?? intervalMs,
+      max_polls: max_polls ?? maxPolls,
+      timeout_ms: timeout_ms ?? timeoutMs,
+      include_results: include_results ?? includeResults
+    }
+  };
+}
+function buildOpsNangoScheduleAndWaitBody(options) {
+  const waitBody = buildOpsWaitBody(options.wait);
+  const { op_id: _opId, ...waitWithoutOp } = waitBody;
+  return {
+    ...buildOpsNangoScheduleBody(options.schedule),
+    ...waitWithoutOp,
+    instruction: options.run.instruction,
+    force: options.run.force
+  };
+}
 function buildOpsPlanBody(params) {
-  const { targetCount, companyDomains, customAiPrompt, signalPrompt, outputPrompt, ...rest } = params;
+  const { targetCount, wakeOnEvents, companyDomains, customAiPrompt, signalPrompt, outputPrompt, ...rest } = params;
+  const destinations = Array.isArray(rest.destinations) ? rest.destinations.map(normalizeOpsDestinationRequest) : rest.destinations;
   return {
     ...rest,
+    destinations,
     target_count: rest.target_count ?? targetCount,
+    wake_on_events: rest.wake_on_events ?? wakeOnEvents,
     company_domains: rest.company_domains ?? companyDomains,
     custom_ai_prompt: rest.custom_ai_prompt ?? customAiPrompt,
     signal_prompt: rest.signal_prompt ?? signalPrompt,
@@ -5443,6 +6876,95 @@ function buildOpsExecuteBody(params) {
     output_format: rest.output_format ?? outputFormat
   };
 }
+function buildOpsExecuteAndWaitOptions(params) {
+  const {
+    nextCursor,
+    includeFailedRuns,
+    intervalMs,
+    maxPolls,
+    timeoutMs,
+    includeResults,
+    cursor,
+    state,
+    limit,
+    include_failed_runs,
+    interval_ms,
+    max_polls,
+    timeout_ms,
+    include_results,
+    ...execute
+  } = params;
+  return {
+    execute: {
+      ...execute,
+      auto_run: execute.auto_run ?? execute.autoRun ?? true
+    },
+    wait: {
+      cursor: cursor ?? nextCursor,
+      state,
+      limit,
+      include_failed_runs: include_failed_runs ?? includeFailedRuns,
+      interval_ms: interval_ms ?? intervalMs,
+      max_polls: max_polls ?? maxPolls,
+      timeout_ms: timeout_ms ?? timeoutMs,
+      include_results: include_results ?? includeResults
+    }
+  };
+}
+function buildOpsScheduleAndWaitOptions(params) {
+  const {
+    force,
+    instruction,
+    nextCursor,
+    includeFailedRuns,
+    intervalMs,
+    maxPolls,
+    timeoutMs,
+    includeResults,
+    cursor,
+    state,
+    limit,
+    include_failed_runs,
+    interval_ms,
+    max_polls,
+    timeout_ms,
+    include_results,
+    ...schedule
+  } = params;
+  return {
+    schedule: {
+      ...schedule,
+      cadence: schedule.cadence ?? "daily"
+    },
+    run: {
+      force,
+      instruction
+    },
+    wait: {
+      cursor: cursor ?? nextCursor,
+      state,
+      limit,
+      include_failed_runs: include_failed_runs ?? includeFailedRuns,
+      interval_ms: interval_ms ?? intervalMs,
+      max_polls: max_polls ?? maxPolls,
+      timeout_ms: timeout_ms ?? timeoutMs,
+      include_results: include_results ?? includeResults
+    }
+  };
+}
+function buildOpsScheduleAndWaitBody(options) {
+  const waitBody = buildOpsWaitBody(options.wait);
+  const { op_id: _opId, ...waitWithoutOp } = waitBody;
+  return {
+    ...buildOpsCreateBody({
+      ...options.schedule,
+      cadence: options.schedule.cadence ?? "daily"
+    }),
+    ...waitWithoutOp,
+    instruction: options.run.instruction,
+    force: options.run.force
+  };
+}
 function buildOpsRunBody(params) {
   const { opId, ...rest } = params;
   return {
@@ -5450,6 +6972,28 @@ function buildOpsRunBody(params) {
     op_id: rest.op_id ?? opId
   };
 }
+function buildOpsRunAndWaitOptions(params) {
+  const {
+    opId,
+    nextCursor,
+    includeFailedRuns,
+    intervalMs,
+    maxPolls,
+    timeoutMs,
+    includeResults,
+    ...rest
+  } = params;
+  return {
+    ...rest,
+    op_id: rest.op_id ?? opId,
+    cursor: rest.cursor ?? nextCursor,
+    include_failed_runs: rest.include_failed_runs ?? includeFailedRuns,
+    interval_ms: rest.interval_ms ?? intervalMs,
+    max_polls: rest.max_polls ?? maxPolls,
+    timeout_ms: rest.timeout_ms ?? timeoutMs,
+    include_results: rest.include_results ?? includeResults
+  };
+}
 function buildOpsStatusBody(params) {
   const { opId, ...rest } = params;
   return {
@@ -5466,6 +7010,50 @@ function buildOpsResultsBody(params) {
     include_failed_runs: rest.include_failed_runs ?? includeFailedRuns
   };
 }
+function buildOpsWaitForResultsOptions(params) {
+  const {
+    opId,
+    nextCursor,
+    includeFailedRuns,
+    intervalMs,
+    maxPolls,
+    timeoutMs,
+    includeResults,
+    ...rest
+  } = params;
+  return {
+    ...rest,
+    op_id: rest.op_id ?? opId,
+    cursor: rest.cursor ?? nextCursor,
+    include_failed_runs: rest.include_failed_runs ?? includeFailedRuns,
+    interval_ms: rest.interval_ms ?? intervalMs,
+    max_polls: rest.max_polls ?? maxPolls,
+    timeout_ms: rest.timeout_ms ?? timeoutMs,
+    include_results: rest.include_results ?? includeResults
+  };
+}
+function buildOpsWaitBody(params) {
+  const {
+    opId,
+    nextCursor,
+    includeFailedRuns,
+    intervalMs,
+    maxPolls,
+    timeoutMs,
+    includeResults,
+    ...rest
+  } = params;
+  return {
+    ...rest,
+    op_id: rest.op_id ?? opId,
+    cursor: rest.cursor ?? nextCursor,
+    include_failed_runs: rest.include_failed_runs ?? includeFailedRuns,
+    interval_ms: rest.interval_ms ?? intervalMs,
+    max_polls: rest.max_polls ?? maxPolls,
+    timeout_ms: rest.timeout_ms ?? timeoutMs,
+    include_results: rest.include_results ?? includeResults
+  };
+}
 function buildOpsDebugOptions(params) {
   const {
     opId,
@@ -5543,6 +7131,8 @@ function normalizeOpsSinkRequest(sink) {
     nangoAction,
     proxyPath,
     nangoProxyPath,
+    method,
+    httpMethod,
     fieldMap,
     requiredFields,
     writeConfirmed,
@@ -5561,6 +7151,7 @@ function normalizeOpsSinkRequest(sink) {
   const nango_action = rest.nango_action ?? nangoAction;
   const proxy_path = rest.proxy_path ?? proxyPath;
   const nango_proxy_path = rest.nango_proxy_path ?? nangoProxyPath;
+  const http_method = rest.http_method ?? httpMethod;
   const field_map = rest.field_map ?? fieldMap;
   const required_fields = rest.required_fields ?? requiredFields;
   const write_confirmed = rest.write_confirmed ?? writeConfirmed;
@@ -5575,6 +7166,9 @@ function normalizeOpsSinkRequest(sink) {
   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 (method !== void 0 && normalizedConfig.method === void 0) normalizedConfig.method = method;
+  if (http_method !== void 0 && normalizedConfig.http_method === void 0) normalizedConfig.http_method = http_method;
+  if (normalizedConfig.method === void 0 && http_method !== void 0) normalizedConfig.method = http_method;
   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;
@@ -5594,6 +7188,8 @@ function normalizeOpsSinkRequest(sink) {
     nango_action,
     proxy_path,
     nango_proxy_path,
+    method,
+    http_method,
     field_map,
     required_fields,
     write_confirmed,
@@ -5601,6 +7197,10 @@ function normalizeOpsSinkRequest(sink) {
     config: normalizedConfig
   };
 }
+function normalizeOpsDestinationRequest(destination) {
+  if (!destination || typeof destination !== "object" || Array.isArray(destination)) return destination;
+  return normalizeOpsSinkRequest(destination);
+}
 function normalizeOpsSinkConfigRequest(config) {
   const out = { ...config ?? {} };
   if (out.connection_id === void 0 && out.connectionId !== void 0) out.connection_id = out.connectionId;
@@ -5614,6 +7214,8 @@ function normalizeOpsSinkConfigRequest(config) {
   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.http_method === void 0 && out.httpMethod !== void 0) out.http_method = out.httpMethod;
+  if (out.method === void 0 && out.http_method !== void 0) out.method = out.http_method;
   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;
@@ -5687,7 +7289,6 @@ function toSnakeConfig(params) {
   return {
     system_prompt: params.systemPrompt || params.system_prompt || "You are a senior business research analyst. Use multi-model evidence carefully and return concise structured enrichment.",
     user_template: params.userTemplate || params.user_template || params.prompt,
-    model: params.model,
     temperature: params.temperature,
     max_concurrency: params.maxConcurrency || params.max_concurrency,
     max_tokens: params.maxTokens || params.max_tokens,
@@ -5711,13 +7312,10 @@ var Ai = class {
   /**
    * Run Custom AI Enrichment - Multi Model.
    *
-   * Uses OpenRouter Fusion for multi-model analysis with web search/fetch enabled
-   * inside Fusion, then synthesizes the requested structured output fields.
+   * Uses the hosted default model with bounded synthesis, then returns the
+   * requested structured output fields.
    */
   async multiModel(params) {
-    if (!params.model) {
-      throw new Error('model is required. Use an OpenRouter id such as "anthropic/claude-sonnet-4" or "google/gemini-2.5-flash".');
-    }
     if (!params.prompt && !params.userTemplate && !params.user_template) {
       throw new Error("prompt or userTemplate is required.");
     }
@@ -5934,6 +7532,10 @@ var GtmKernel = class {
       days: options.days,
       network_days: options.networkDays,
       min_sample_size: options.minSampleSize,
+      holdout_min_sample_size: options.holdoutMinSampleSize,
+      predictive_min_labeled_outcomes: options.predictiveMinLabeledOutcomes,
+      predictive_min_positive_outcomes: options.predictiveMinPositiveOutcomes,
+      predictive_min_memory_sample_size: options.predictiveMinMemorySampleSize,
       min_workspace_count: options.minWorkspaceCount,
       min_privacy_k: options.minPrivacyK,
       include_memory: options.includeMemory,
@@ -6000,9 +7602,11 @@ var GtmKernel = class {
       write_routine_outcomes: input.writeRoutineOutcomes
     });
   }
-  /** Start a background Instantly webhook-events pull and route results into the GTM feedback loop. */
+  /** Start a background Instantly webhook-events or email-history pull and route results into the GTM feedback loop. */
   async pullInstantlyFeedback(input) {
     return this.callMcp("gtm_instantly_feedback_pull", {
+      source: input.source,
+      instantly_profile: input.instantlyProfile,
       campaign_id: input.campaignId,
       campaign_build_id: input.campaignBuildId,
       provider_link_id: input.providerLinkId,
@@ -6014,6 +7618,9 @@ var GtmKernel = class {
       to: input.to,
       limit: input.limit,
       max_pages: input.maxPages,
+      email_type: input.emailType,
+      mode: input.mode,
+      sort_order: input.sortOrder,
       create_memory: input.createMemory,
       write_routine_outcomes: input.writeRoutineOutcomes,
       dry_run: input.dryRun,
@@ -6143,6 +7750,7 @@ var GtmKernel = class {
       days: input.days,
       network_days: input.networkDays,
       min_sample_size: input.minSampleSize,
+      holdout_min_sample_size: input.holdoutMinSampleSize,
       min_workspace_count: input.minWorkspaceCount,
       min_privacy_k: input.minPrivacyK,
       include_memory: input.includeMemory,
@@ -6163,6 +7771,7 @@ var GtmKernel = class {
       days: input.days,
       network_days: input.networkDays,
       min_sample_size: input.minSampleSize,
+      holdout_min_sample_size: input.holdoutMinSampleSize,
       min_workspace_count: input.minWorkspaceCount,
       min_privacy_k: input.minPrivacyK,
       include_memory: input.includeMemory,
@@ -6287,6 +7896,29 @@ var GtmKernel = class {
       include_details: options.includeDetails
     });
   }
+  /** Search the Agency Autopilot safe-action catalog for agency-style lead lists, Clay tables, and GTM motions. */
+  async agencyAutopilotCapabilityCatalog(options = {}) {
+    return this.callMcp("gtm_agency_autopilot_capability_catalog", {
+      query: options.query,
+      family: options.family,
+      phase: options.phase,
+      account_label: options.accountLabel,
+      workspace_label: options.workspaceLabel,
+      target_count: options.targetCount,
+      limit: options.limit,
+      include_agent_prompts: options.includeAgentPrompts
+    });
+  }
+  /** Search agency operating playbooks Agency Autopilot can use for lead lists, Clay tables, GTM motions, and proof gates. */
+  async agencyAutopilotPlaybookCatalog(options = {}) {
+    return this.callMcp("gtm_agency_autopilot_playbook_catalog", {
+      query: options.query,
+      playbook_slug: options.playbookSlug,
+      outcome_type: options.outcomeType,
+      limit: options.limit,
+      include_required_fields: options.includeRequiredFields
+    });
+  }
   /** Build the read-only Memory, Brain, risk, and provider-route runbook needed before planning a campaign. */
   async campaignStartContext(input = {}) {
     return this.callMcp("gtm_campaign_start_context", {
@@ -6645,6 +8277,35 @@ var GtmKernel = class {
       user_display_name: input.userDisplayName
     });
   }
+  /** Prepare the full Nango provider search, connect, pull/export, Ops, and campaign-route flow. */
+  async prepareNangoIntegrationFlow(input = {}) {
+    return this.callMcp("nango_integration_flow_prepare", {
+      query: input.query,
+      search: input.search,
+      provider_id: input.providerId,
+      provider: input.provider,
+      integration_id: input.integrationId,
+      provider_config_key: input.providerConfigKey,
+      workspace_connection_id: input.workspaceConnectionId,
+      connection_id: input.connectionId,
+      nango_connection_id: input.nangoConnectionId,
+      intent: input.intent,
+      action_name: input.actionName,
+      tool_name: input.toolName,
+      proxy_path: input.proxyPath,
+      method: input.method,
+      input: input.input,
+      cadence: input.cadence,
+      field_map: input.fieldMap,
+      required_fields: input.requiredFields,
+      confirm_spend: input.confirmSpend,
+      write_confirmed: input.writeConfirmed,
+      layer: input.layer,
+      campaign_id: input.campaignId,
+      limit: input.limit,
+      include_provider_catalog: input.includeProviderCatalog
+    });
+  }
   /** List Nango-backed action tools for a workspace connection without executing them. */
   async listNangoTools(options = {}) {
     return this.callMcp("nango_mcp_tools_list", {
@@ -6667,6 +8328,12 @@ var GtmKernel = class {
       nango_connection_id: input.nangoConnectionId,
       action_name: input.actionName,
       tool_name: input.toolName,
+      delivery_mode: input.deliveryMode,
+      proxy_path: input.proxyPath,
+      nango_proxy_path: input.nangoProxyPath,
+      method: input.method,
+      http_method: input.httpMethod,
+      proxy_headers: input.proxyHeaders,
       input: input.input,
       async: input.async,
       max_retries: input.maxRetries,
@@ -6816,6 +8483,7 @@ function compact2(value) {
 }
 
 // src/index.ts
+var MCP_TOOL_CACHE_TTL_MS = 3e4;
 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_") || [
@@ -6947,6 +8615,21 @@ var Signaliz = class {
   }
   /** List all available MCP tools */
   async listTools() {
+    const now = Date.now();
+    if (this.toolListCache && this.toolListCache.expiresAt > now) {
+      return this.toolListCache.promise;
+    }
+    const promise = this.fetchTools().catch((error) => {
+      if (this.toolListCache?.promise === promise) this.toolListCache = void 0;
+      throw error;
+    });
+    this.toolListCache = {
+      expiresAt: now + MCP_TOOL_CACHE_TTL_MS,
+      promise
+    };
+    return promise;
+  }
+  async fetchTools() {
     try {
       const manifest = await this.client.mcp("tools/call", {
         name: "get_tool_manifest",
@@ -7006,6 +8689,7 @@ var Signaliz = class {
   createCampaignBuilderAgentRequestTemplate,
   createCampaignBuilderApproval,
   createCampaignBuilderBuildKit,
+  createCampaignBuilderMemoryKit,
   createCampaignBuilderProofReceipt,
   createCampaignBuilderReadiness,
   createCampaignBuilderToolRoute,