@pellux/goodvibes-tui 0.19.33 → 0.19.34

package/src/input/model-picker-types.ts

@@ -0,0 +1,125 @@
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers/registry';
+
+export type PickerMode = 'model' | 'provider' | 'effort' | 'contextCap';
+
+/**
+ * Which config keys the model picker writes to on commit.
+ * 'main'   -> provider.provider + provider.model (default)
+ * 'helper' -> helper.globalProvider + helper.globalModel (+ helper.enabled: true)
+ * 'tool'   -> tools.llmProvider + tools.llmModel (+ tools.llmEnabled: true)
+ * 'tts'    -> tts.llmProvider + tts.llmModel
+ */
+export type ModelPickerTarget = 'main' | 'helper' | 'tool' | 'tts';
+
+/**
+ * Pricing tier filter.
+ * 'paid' matches ModelDefinition tiers 'standard' and 'premium' for forward-compat
+ * with future CatalogModel tiers ('free' | 'paid' | 'subscription').
+ */
+export type CategoryFilter = 'all' | 'free' | 'paid' | 'subscription';
+
+export type ModelFamily =
+  | 'GPT'
+  | 'Claude'
+  | 'Gemini'
+  | 'Llama'
+  | 'Qwen'
+  | 'GLM'
+  | 'MiniMax'
+  | 'DeepSeek'
+  | 'Mistral'
+  | 'Command'
+  | 'Grok'
+  | 'Kimi'
+  | 'Other';
+
+export type CapabilityFilter = 'reasoning' | 'toolUse' | 'multimodal' | 'none';
+export type BenchmarkSort = 'none' | 'composite' | 'swe' | 'gpqa';
+export type GroupByMode = 'provider' | 'family' | 'pricingTier' | 'qualityTier';
+
+const FAMILY_PATTERNS: Array<{ pattern: RegExp; family: ModelFamily }> = [
+  { pattern: /claude/i,          family: 'Claude' },
+  { pattern: /gpt|\bo1\b|\bo3\b|\bo4\b/i, family: 'GPT' },
+  { pattern: /gemini/i,          family: 'Gemini' },
+  { pattern: /llama/i,           family: 'Llama' },
+  { pattern: /qwen/i,            family: 'Qwen' },
+  { pattern: /glm|chatglm/i,     family: 'GLM' },
+  { pattern: /minimax|abab/i,    family: 'MiniMax' },
+  { pattern: /deepseek/i,        family: 'DeepSeek' },
+  { pattern: /mistral|mixtral/i, family: 'Mistral' },
+  { pattern: /command|cohere/i,  family: 'Command' },
+  { pattern: /grok/i,            family: 'Grok' },
+  { pattern: /kimi|moonshot/i,   family: 'Kimi' },
+];
+
+export function detectFamily(model: ModelDefinition): ModelFamily {
+  const haystack = `${model.id} ${model.displayName}`;
+  for (const { pattern, family } of FAMILY_PATTERNS) {
+    if (pattern.test(haystack)) return family;
+  }
+  return 'Other';
+}
+
+export function tierToCategoryFilter(tier: string | undefined): CategoryFilter {
+  if (tier === 'free') return 'free';
+  if (tier === 'subscription') return 'subscription';
+  return 'paid';
+}
+
+export interface PickerItem {
+  id: string;
+  label: string;
+  detail?: string;
+  isGroupHeader?: boolean;
+  qualityTier?: string;
+  isPinned?: boolean;
+  isFree?: boolean;
+  isConfigured?: boolean;
+  configuredVia?: 'env' | 'secrets' | 'subscription' | 'anonymous';
+}
+
+export const POPULAR_PROVIDERS: ReadonlySet<string> = new Set([
+  'anthropic',
+  'google',
+  'groq',
+  'mistral',
+  'nvidia',
+  'ollama',
+  'openai',
+  'openrouter',
+  'synthetic',
+]);
+
+export interface FilteredModelsCache {
+  readonly modelsRef: ModelDefinition[];
+  readonly configuredProvidersKey: string;
+  readonly pinnedIdsKey: string;
+  readonly recentIdsKey: string;
+  readonly query: string;
+  readonly categoryFilter: CategoryFilter;
+  readonly capabilityFilter: CapabilityFilter;
+  readonly availableOnly: boolean;
+  readonly benchmarkSort: BenchmarkSort;
+  readonly groupBy: GroupByMode;
+  readonly result: ModelDefinition[];
+}
+
+export interface FilteredProvidersCache {
+  readonly providersRef: string[];
+  readonly query: string;
+  readonly result: string[];
+}
+
+export interface ModelItemsCache {
+  readonly filteredModelsRef: ModelDefinition[];
+  readonly pinnedIdsKey: string;
+  readonly groupBy: GroupByMode;
+  readonly result: PickerItem[];
+}
+
+export interface ProviderItemsCache {
+  readonly filteredProvidersRef: string[];
+  readonly configuredProvidersKey: string;
+  readonly configuredViaKey: string;
+  readonly result: PickerItem[];
+}

package/src/input/model-picker.ts

@@ -4,118 +4,11 @@ import { EFFORT_DESCRIPTIONS } from '@pellux/goodvibes-sdk/platform/providers/ef
 import { getQualityTier, getQualityTierFromScore, compositeScore, A_TIER_THRESHOLD } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
 import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers/registry';
+import { detectFamily, POPULAR_PROVIDERS, tierToCategoryFilter } from './model-picker-types.ts';
+import type { BenchmarkSort, CapabilityFilter, CategoryFilter, FilteredModelsCache, FilteredProvidersCache, GroupByMode, ModelItemsCache, ModelPickerTarget, PickerItem, PickerMode, ProviderItemsCache } from './model-picker-types.ts';
 
-export type PickerMode = 'model' | 'provider' | 'effort' | 'contextCap';
-
-/**
- * Which config keys the model picker writes to on commit.
- * 'main'   → provider.provider + provider.model (default)
- * 'helper' → helper.globalProvider + helper.globalModel (+ helper.enabled: true)
- * 'tool'   → tools.llmProvider + tools.llmModel (+ tools.llmEnabled: true)
- * 'tts'    → tts.llmProvider + tts.llmModel
- */
-export type ModelPickerTarget = 'main' | 'helper' | 'tool' | 'tts';
-
-/**
- * Pricing tier filter.
- * 'paid' matches ModelDefinition tiers 'standard' and 'premium' for forward-compat
- * with future CatalogModel tiers ('free' | 'paid' | 'subscription').
- */
-export type CategoryFilter = 'all' | 'free' | 'paid' | 'subscription';
-
-/** Model family grouping names. */
-export type ModelFamily =
-  | 'GPT'
-  | 'Claude'
-  | 'Gemini'
-  | 'Llama'
-  | 'Qwen'
-  | 'GLM'
-  | 'MiniMax'
-  | 'DeepSeek'
-  | 'Mistral'
-  | 'Command'
-  | 'Grok'
-  | 'Kimi'
-  | 'Other';
-
-/** Capability filter — subset of ModelDefinition capabilities. */
-export type CapabilityFilter = 'reasoning' | 'toolUse' | 'multimodal' | 'none';
-
-/** Benchmark score sort order. */
-export type BenchmarkSort = 'none' | 'composite' | 'swe' | 'gpqa';
-
-/** Group-by cycling order. */
-export type GroupByMode = 'provider' | 'family' | 'pricingTier' | 'qualityTier';
-
-// ── Family detection helpers ──────────────────────────────────────────────────
-
-/** Patterns for detecting model family from id/displayName. */
-const FAMILY_PATTERNS: Array<{ pattern: RegExp; family: ModelFamily }> = [
-  { pattern: /claude/i,          family: 'Claude' },
-  { pattern: /gpt|\bo1\b|\bo3\b|\bo4\b/i, family: 'GPT' },
-  { pattern: /gemini/i,          family: 'Gemini' },
-  { pattern: /llama/i,           family: 'Llama' },
-  { pattern: /qwen/i,            family: 'Qwen' },
-  { pattern: /glm|chatglm/i,     family: 'GLM' },
-  { pattern: /minimax|abab/i,    family: 'MiniMax' },
-  { pattern: /deepseek/i,        family: 'DeepSeek' },
-  { pattern: /mistral|mixtral/i, family: 'Mistral' },
-  { pattern: /command|cohere/i,  family: 'Command' },
-  { pattern: /grok/i,            family: 'Grok' },
-  { pattern: /kimi|moonshot/i,   family: 'Kimi' },
-];
-
-/** Detect the model family from id and displayName. */
-export function detectFamily(model: ModelDefinition): ModelFamily {
-  const haystack = `${model.id} ${model.displayName}`;
-  for (const { pattern, family } of FAMILY_PATTERNS) {
-    if (pattern.test(haystack)) return family;
-  }
-  return 'Other';
-}
-
-/**
- * Map ModelDefinition tier to CategoryFilter bucket.
- * 'standard' and 'premium' both map to 'paid' for forward-compat.
- */
-export function tierToCategoryFilter(tier: string | undefined): CategoryFilter {
-  if (tier === 'free') return 'free';
-  if (tier === 'subscription') return 'subscription';
-  return 'paid';
-}
-
-/** A generic selectable item for non-model modes. */
-export interface PickerItem {
-  id: string;
-  label: string;
-  detail?: string;
-  /** If true, this item is a group header (not selectable). */
-  isGroupHeader?: boolean;
-  /** Quality tier badge for model items: S/A/B/C. */
-  qualityTier?: string;
-  /** Whether this model is pinned/favorited. */
-  isPinned?: boolean;
-  /** True when model tier is free. */
-  isFree?: boolean;
-  /** True when this provider item has a configured API key. */
-  isConfigured?: boolean;
-  /** How the provider is configured — shown as a badge in provider mode. */
-  configuredVia?: 'env' | 'secrets' | 'subscription' | 'anonymous';
-}
-
-/** Provider IDs treated as "Popular" in the provider picker. */
-export const POPULAR_PROVIDERS: ReadonlySet<string> = new Set([
-  'anthropic',
-  'google',
-  'groq',
-  'mistral',
-  'nvidia',
-  'ollama',
-  'openai',
-  'openrouter',
-  'synthetic',
-]);
+export { detectFamily, POPULAR_PROVIDERS, tierToCategoryFilter } from './model-picker-types.ts';
+export type { BenchmarkSort, CapabilityFilter, CategoryFilter, GroupByMode, ModelFamily, ModelPickerTarget, PickerItem, PickerMode } from './model-picker-types.ts';
 
 /**
  * ModelPickerModal - Multi-step interactive picker for model, provider, and effort.
@@ -180,12 +73,18 @@ export class ModelPickerModal {
   /** Current group-by mode. */
   public groupBy: GroupByMode = 'provider';
 
+  private filteredModelsCache: FilteredModelsCache | null = null;
+  private filteredProvidersCache: FilteredProvidersCache | null = null;
+  private modelItemsCache: ModelItemsCache | null = null;
+  private providerItemsCache: ProviderItemsCache | null = null;
+
   // ── Category filter cycling ───────────────────────────────────────────────
   private static readonly CATEGORY_CYCLE: CategoryFilter[] = ['all', 'free', 'paid', 'subscription'];
   /** Cycle to next pricing tier filter. */
   cycleCategory(): void {
     const idx = ModelPickerModal.CATEGORY_CYCLE.indexOf(this.categoryFilter);
     this.categoryFilter = ModelPickerModal.CATEGORY_CYCLE[(idx + 1) % ModelPickerModal.CATEGORY_CYCLE.length];
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
@@ -195,6 +94,7 @@ export class ModelPickerModal {
   cycleGroupBy(): void {
     const idx = ModelPickerModal.GROUP_BY_CYCLE.indexOf(this.groupBy);
     this.groupBy = ModelPickerModal.GROUP_BY_CYCLE[(idx + 1) % ModelPickerModal.GROUP_BY_CYCLE.length];
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
@@ -204,6 +104,7 @@ export class ModelPickerModal {
   cycleBenchmarkSort(): void {
     const idx = ModelPickerModal.BENCHMARK_SORT_CYCLE.indexOf(this.benchmarkSort);
     this.benchmarkSort = ModelPickerModal.BENCHMARK_SORT_CYCLE[(idx + 1) % ModelPickerModal.BENCHMARK_SORT_CYCLE.length];
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
@@ -266,8 +167,9 @@ export class ModelPickerModal {
     this.query = '';
     this.categoryFilter = 'all';
     this.capabilityFilter = 'none';
-    // Start selection at the top of the Popular providers group.
-    this.selectedIndex = 0;
+    const filtered = this.getFilteredProviders();
+    const currentIndex = filtered.findIndex((provider) => provider === currentProvider);
+    this.selectedIndex = currentIndex >= 0 ? currentIndex : 0;
     this.scrollOffset = 0;
   }
 
@@ -315,6 +217,7 @@ export class ModelPickerModal {
     this.query = '';
     this.categoryFilter = 'all';
     this.capabilityFilter = 'none';
+    this.clearCaches();
   }
 
   // ── Search helpers ─────────────────────────────────────────────────────────
@@ -322,6 +225,7 @@ export class ModelPickerModal {
   /** Append a character to the search query and clamp selectedIndex. */
   appendChar(ch: string): void {
     this.query += ch;
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
@@ -329,6 +233,7 @@ export class ModelPickerModal {
   deleteChar(): void {
     if (this.query.length > 0) {
       this.query = this.query.slice(0, -1);
+      this.clearFilteredCaches();
       this._clampSelection();
     }
   }
@@ -336,6 +241,7 @@ export class ModelPickerModal {
   /** Clear the search query and clamp selectedIndex. */
   clearQuery(): void {
     this.query = '';
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
@@ -354,18 +260,21 @@ export class ModelPickerModal {
   /** Set category filter and clamp selectedIndex. */
   setCategoryFilter(filter: CategoryFilter): void {
     this.categoryFilter = filter;
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
   /** Set capability filter and clamp selectedIndex. */
   setCapabilityFilter(filter: CapabilityFilter): void {
     this.capabilityFilter = filter;
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
   /** Toggle the available-only filter. */
   toggleAvailableOnly(): void {
     this.availableOnly = !this.availableOnly;
+    this.clearFilteredCaches();
     this._clampSelection();
   }
 
@@ -396,15 +305,50 @@ export class ModelPickerModal {
 
   /** Return providers matching the current query (case-insensitive substring), in grouped order. */
   getFilteredProviders(): string[] {
+    const cached = this.filteredProvidersCache;
+    if (
+      cached !== null
+      && cached.providersRef === this.providers
+      && cached.query === this.query
+    ) {
+      return cached.result;
+    }
+
     const { popular, all } = this.getGroupedProviders();
     const ordered = [...popular, ...all];
-    if (this.query.trim().length === 0) return ordered;
-    const q = this.query.toLowerCase();
-    return ordered.filter(p => p.toLowerCase().includes(q));
+    const result = this.query.trim().length === 0
+      ? ordered
+      : ordered.filter(p => p.toLowerCase().includes(this.query.toLowerCase()));
+    this.filteredProvidersCache = {
+      providersRef: this.providers,
+      query: this.query,
+      result,
+    };
+    return result;
   }
 
   /** Return models matching all current filters, sorted per benchmarkSort. */
   getFilteredModels(): ModelDefinition[] {
+    const configuredProvidersKey = setKey(this.configuredProviders);
+    const pinnedIdsKey = setKey(this.pinnedIds);
+    const recentIdsKey = orderedListKey(this.recentIds);
+    const cached = this.filteredModelsCache;
+    if (
+      cached !== null
+      && cached.modelsRef === this.models
+      && cached.configuredProvidersKey === configuredProvidersKey
+      && cached.pinnedIdsKey === pinnedIdsKey
+      && cached.recentIdsKey === recentIdsKey
+      && cached.query === this.query
+      && cached.categoryFilter === this.categoryFilter
+      && cached.capabilityFilter === this.capabilityFilter
+      && cached.availableOnly === this.availableOnly
+      && cached.benchmarkSort === this.benchmarkSort
+      && cached.groupBy === this.groupBy
+    ) {
+      return cached.result;
+    }
+
     let result = this.models;
 
     // Available-only filter
@@ -520,6 +464,20 @@ export class ModelPickerModal {
       result = [...recent, ...rest];
     }
 
+    this.filteredModelsCache = {
+      modelsRef: this.models,
+      configuredProvidersKey,
+      pinnedIdsKey,
+      recentIdsKey,
+      query: this.query,
+      categoryFilter: this.categoryFilter,
+      capabilityFilter: this.capabilityFilter,
+      availableOnly: this.availableOnly,
+      benchmarkSort: this.benchmarkSort,
+      groupBy: this.groupBy,
+      result,
+    };
+    this.modelItemsCache = null;
     return result;
   }
 
@@ -529,6 +487,7 @@ export class ModelPickerModal {
    */
   async loadRecentModels(n = 10): Promise<void> {
     this.recentIds = await this.favoritesStore.getRecentModels(n);
+    this.clearFilteredCaches();
   }
 
   /**
@@ -574,6 +533,16 @@ export class ModelPickerModal {
   getItems(): PickerItem[] {
     if (this.mode === 'model') {
       const filtered = this.getFilteredModels();
+      const pinnedIdsKey = setKey(this.pinnedIds);
+      const cached = this.modelItemsCache;
+      if (
+        cached !== null
+        && cached.filteredModelsRef === filtered
+        && cached.pinnedIdsKey === pinnedIdsKey
+        && cached.groupBy === this.groupBy
+      ) {
+        return cached.result;
+      }
 
       // Separate pinned and unpinned
       const pinned = filtered.filter(m => this.pinnedIds.has(m.id));
@@ -600,33 +569,45 @@ export class ModelPickerModal {
         items.push(this._modelToItem(m, false));
       }
 
+      this.modelItemsCache = {
+        filteredModelsRef: filtered,
+        pinnedIdsKey,
+        groupBy: this.groupBy,
+        result: items,
+      };
       return items;
     }
     if (this.mode === 'provider') {
-      const q = this.query.trim().toLowerCase();
-      const { popular, all } = this.getGroupedProviders();
-
-      const filterGroup = (group: string[]) =>
-        q.length === 0 ? group : group.filter(p => p.toLowerCase().includes(q));
-
-      const filteredPopular = filterGroup(popular);
-      const filteredAll = filterGroup(all);
+      const filteredProviders = this.getFilteredProviders();
+      const configuredProvidersKey = setKey(this.configuredProviders);
+      const configuredViaKey = mapKey(this.configuredViaMap);
+      const cached = this.providerItemsCache;
+      if (
+        cached !== null
+        && cached.filteredProvidersRef === filteredProviders
+        && cached.configuredProvidersKey === configuredProvidersKey
+        && cached.configuredViaKey === configuredViaKey
+      ) {
+        return cached.result;
+      }
 
       const providerItems: PickerItem[] = [];
-
-      if (filteredPopular.length > 0) {
-        providerItems.push({ id: '__header__popular', label: 'Popular', isGroupHeader: true });
-        for (const p of filteredPopular) {
-          providerItems.push({ id: p, label: p, isConfigured: this.configuredProviders.has(p), configuredVia: this.configuredViaMap.get(p) });
-        }
-      }
-      if (filteredAll.length > 0) {
-        providerItems.push({ id: '__header__all', label: 'All Providers', isGroupHeader: true });
-        for (const p of filteredAll) {
-          providerItems.push({ id: p, label: p, isConfigured: this.configuredProviders.has(p), configuredVia: this.configuredViaMap.get(p) });
+      let currentGroup: 'Popular' | 'All Providers' | null = null;
+      for (const p of filteredProviders) {
+        const group: 'Popular' | 'All Providers' = POPULAR_PROVIDERS.has(p.toLowerCase()) ? 'Popular' : 'All Providers';
+        if (group !== currentGroup) {
+          providerItems.push({ id: `__header__${group}`, label: group, isGroupHeader: true });
+          currentGroup = group;
         }
+        providerItems.push({ id: p, label: p, isConfigured: this.configuredProviders.has(p), configuredVia: this.configuredViaMap.get(p) });
       }
 
+      this.providerItemsCache = {
+        filteredProvidersRef: filteredProviders,
+        configuredProvidersKey,
+        configuredViaKey,
+        result: providerItems,
+      };
       return providerItems;
     }
     // effort mode
@@ -743,4 +724,32 @@ export class ModelPickerModal {
   getBenchmarkEntry(model: ModelDefinition) {
     return this.benchmarkStore.getBenchmarks(model.id) ?? this.benchmarkStore.getBenchmarks(model.displayName);
   }
+
+  private clearFilteredCaches(): void {
+    this.filteredModelsCache = null;
+    this.filteredProvidersCache = null;
+    this.modelItemsCache = null;
+    this.providerItemsCache = null;
+  }
+
+  private clearCaches(): void {
+    this.clearFilteredCaches();
+  }
+}
+
+function setKey(values: ReadonlySet<string>): string {
+  if (values.size === 0) return '';
+  return [...values].sort().join('\u001f');
+}
+
+function orderedListKey(values: readonly string[]): string {
+  return values.length === 0 ? '' : values.join('\u001f');
+}
+
+function mapKey(values: ReadonlyMap<string, string | undefined>): string {
+  if (values.size === 0) return '';
+  return [...values.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${key}\u001e${value ?? ''}`)
+    .join('\u001f');
 }

package/src/input/onboarding/onboarding-wizard-apply.ts

@@ -1,5 +1,13 @@
 import type { OnboardingAcknowledgementTarget, OnboardingApplyOperation, OnboardingApplyRequest } from '../../runtime/onboarding/index.ts';
 import { getServerSurfaceFeatureFlags } from '../../runtime/surface-feature-flags.ts';
+import {
+  buildCloudflareApiTokenRef,
+  buildCloudflareOperationalTokenRef,
+  getCloudflareBatchMode,
+  getCloudflareComponentSelection,
+  getCloudflareSetupSource,
+  shouldShowCloudflareStep,
+} from './onboarding-wizard-cloudflare.ts';
 import {
   EXTERNAL_SURFACE_SPECS,
   getExternalSurfaceAutoStartDefaultValue,
@@ -111,6 +119,10 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
 
     setSecret('OPENAI_API_KEY', controller.getStringFieldValue('providers.openai-api-key', ''));
 
+    if (shouldShowCloudflareStep(controller)) {
+      addCloudflareOperations(controller, operations, setSecret);
+    }
+
     const externalIntegrations = controller.isCapabilitySelected('external-integrations');
     const enabledExternalSurfaceIds: string[] = [];
     for (const surface of EXTERNAL_SURFACE_SPECS) {
@@ -165,6 +177,75 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
     };
   }
 
+function addCloudflareOperations(
+  controller: OnboardingWizardController,
+  operations: OnboardingApplyOperation[],
+  setSecret: (key: string, value: string) => void,
+): void {
+    const setConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: unknown,
+    ): void => {
+      operations.push({ kind: 'set-config', key, value });
+    };
+
+    const config = controller.runtimeSnapshot?.config.cloudflare;
+    const enabledDefault = controller.isCapabilitySelected('cloudflare-batch') || config?.enabled === true;
+    const enabled = controller.getBooleanFieldValue('cloudflare.enabled', enabledDefault);
+    const components = getCloudflareComponentSelection(controller);
+    const batchMode = enabled ? getCloudflareBatchMode(controller) : 'off';
+    const setupSource = getCloudflareSetupSource(controller);
+    const existingApiTokenRef = config?.apiTokenRef ?? '';
+    let apiTokenRef = existingApiTokenRef;
+
+    if (!enabled) {
+      setConfig('cloudflare.enabled', false);
+      setConfig('batch.mode', 'off');
+      setConfig('batch.queueBackend', 'local');
+      return;
+    }
+
+    if (setupSource === 'operational-env') {
+      apiTokenRef = buildCloudflareApiTokenRef(
+        controller.getStringFieldValue('cloudflare.operational-env-name', 'CLOUDFLARE_API_TOKEN'),
+      );
+    } else if (setupSource === 'operational-token') {
+      const token = controller.getStringFieldValue('cloudflare.operational-token', '');
+      if (token.length > 0) {
+        setSecret('CLOUDFLARE_API_TOKEN', token);
+        apiTokenRef = buildCloudflareOperationalTokenRef();
+      }
+    }
+
+    setConfig('cloudflare.enabled', true);
+    setConfig('cloudflare.freeTierMode', controller.getStringFieldValue('cloudflare.free-tier-mode', config?.freeTierMode === false ? 'no' : 'yes') === 'yes');
+    setConfig('cloudflare.accountId', controller.getStringFieldValue('cloudflare.account-id', config?.accountId ?? ''));
+    setConfig('cloudflare.apiTokenRef', apiTokenRef);
+    setConfig('cloudflare.zoneId', controller.getStringFieldValue('cloudflare.zone-id', config?.zoneId ?? ''));
+    setConfig('cloudflare.zoneName', controller.getStringFieldValue('cloudflare.zone-name', config?.zoneName ?? ''));
+    setConfig('cloudflare.workerName', controller.getStringFieldValue('cloudflare.worker-name', config?.workerName ?? 'goodvibes-batch-worker'));
+    setConfig('cloudflare.workerSubdomain', controller.getStringFieldValue('cloudflare.worker-subdomain', config?.workerSubdomain ?? ''));
+    setConfig('cloudflare.workerHostname', controller.getStringFieldValue('cloudflare.worker-hostname', config?.workerHostname ?? ''));
+    setConfig('cloudflare.workerBaseUrl', controller.getStringFieldValue('cloudflare.worker-base-url', config?.workerBaseUrl ?? ''));
+    setConfig('cloudflare.daemonBaseUrl', controller.getStringFieldValue('cloudflare.daemon-base-url', config?.daemonBaseUrl ?? ''));
+    setConfig('cloudflare.daemonHostname', controller.getStringFieldValue('cloudflare.daemon-hostname', config?.daemonHostname ?? ''));
+    setConfig('cloudflare.workerCron', controller.getStringFieldValue('cloudflare.worker-cron', config?.workerCron ?? '*/5 * * * *'));
+    setConfig('cloudflare.queueName', controller.getStringFieldValue('cloudflare.queue-name', config?.queueName ?? 'goodvibes-batch'));
+    setConfig('cloudflare.deadLetterQueueName', controller.getStringFieldValue('cloudflare.dead-letter-queue-name', config?.deadLetterQueueName ?? 'goodvibes-batch-dlq'));
+    setConfig('cloudflare.tunnelName', controller.getStringFieldValue('cloudflare.tunnel-name', config?.tunnelName ?? 'goodvibes-daemon'));
+    setConfig('cloudflare.tunnelId', controller.getStringFieldValue('cloudflare.tunnel-id', config?.tunnelId ?? ''));
+    setConfig('cloudflare.kvNamespaceName', controller.getStringFieldValue('cloudflare.kv-namespace-name', config?.kvNamespaceName ?? 'goodvibes-runtime'));
+    setConfig('cloudflare.kvNamespaceId', controller.getStringFieldValue('cloudflare.kv-namespace-id', config?.kvNamespaceId ?? ''));
+    setConfig('cloudflare.durableObjectNamespaceName', controller.getStringFieldValue('cloudflare.do-namespace-name', config?.durableObjectNamespaceName ?? 'GoodVibesCoordinator'));
+    setConfig('cloudflare.durableObjectNamespaceId', controller.getStringFieldValue('cloudflare.do-namespace-id', config?.durableObjectNamespaceId ?? ''));
+    setConfig('cloudflare.r2BucketName', controller.getStringFieldValue('cloudflare.r2-bucket-name', config?.r2BucketName ?? 'goodvibes-artifacts'));
+    setConfig('cloudflare.secretsStoreName', controller.getStringFieldValue('cloudflare.secrets-store-name', config?.secretsStoreName ?? 'goodvibes'));
+    setConfig('cloudflare.secretsStoreId', controller.getStringFieldValue('cloudflare.secrets-store-id', config?.secretsStoreId ?? ''));
+    setConfig('cloudflare.maxQueueOpsPerDay', controller.getNumberFieldValue('cloudflare.max-queue-ops-per-day', config?.maxQueueOpsPerDay ?? 10000, 1));
+    setConfig('batch.mode', batchMode);
+    setConfig('batch.queueBackend', batchMode !== 'off' && components.queues ? 'cloudflare' : 'local');
+  }
+
 export function addNetworkOperations(
   controller: OnboardingWizardController,
     operations: OnboardingApplyOperation[],