@pellux/goodvibes-tui 0.19.32 → 0.19.33

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.33] — 2026-04-26
+
+### Changed
+- `/config-tts` now opens an interactive TTS configuration modal instead of only printing provider and voice lists.
+- `/config-tts providers` and `/config-tts voices [provider]` open selectable provider/voice pickers in the TUI and persist the selected SDK config keys.
+- `/config-tts llm` opens the model picker for a separate `/tts` response-model override; `/tts` still defaults to the current chat provider/model when no override is configured.
+
+### Fixed
+- `/tts` now honors configured `tts.llmProvider`/`tts.llmModel` for that spoken turn without changing the main chat model or global provider settings.
+- Changing the TTS provider clears the provider-specific voice selection so a stale voice id is not reused against a different provider.
+
 ## [0.19.32] — 2026-04-25
 
 ### Added

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.19.32-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.33-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 
@@ -1269,7 +1269,7 @@ Those pieces cover conversation-noise routing, panel-health/performance budgets,
 | `/notify [action]` | `/ntf` | Manage webhook notifications (ntfy.sh): add, remove, list, clear, test |
 | `/voice [action]` | — | Review optional voice posture and export/inspect voice bundles |
 | `/tts <prompt>` | — | Submit a normal prompt and play the assistant response through live TTS |
-| `/config-tts [action]` | `/tts-config` | Configure TTS provider, voice, and optional spoken-turn LLM overrides |
+| `/config-tts [action]` | `/tts-config` | Open TTS configuration for provider, voice, and optional `/tts` response-model override |
 | `/diff [target]` | `/d` | Show unified diff: session, head, working, staged, or a git ref |
 | `/mcp [tools]` | — | List connected MCP servers and their tools |
 | `/help [command]` | `/h`, `/?` | Show available commands and keyboard shortcuts |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.32",
+  "version": "0.19.33",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",

package/src/audio/spoken-turn-model-routing.ts

@@ -0,0 +1,117 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
+import type { ModelDefinition, ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers/registry';
+import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers/interface';
+import type { Orchestrator, OrchestratorUserInputOptions } from '../core/orchestrator.ts';
+
+const SPOKEN_TURN_SOURCE = 'tts';
+
+type RunTurn = (
+  text: string,
+  content?: ContentPart[],
+  options?: OrchestratorUserInputOptions,
+) => Promise<void>;
+
+type PatchableOrchestrator = {
+  runTurn?: RunTurn;
+  setCoreServices: (services: { providerRegistry?: ProviderRegistry }) => void;
+};
+
+export interface SpokenTurnModelRoutingOptions {
+  readonly orchestrator: Orchestrator;
+  readonly providerRegistry: ProviderRegistry;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly notify?: (message: string) => void;
+}
+
+export function createSpokenTurnInputOptions(): OrchestratorUserInputOptions {
+  return {
+    origin: {
+      source: SPOKEN_TURN_SOURCE,
+      surface: 'tui',
+      metadata: { spokenOutput: true },
+    },
+  };
+}
+
+export function attachSpokenTurnModelRouting(options: SpokenTurnModelRoutingOptions): () => void {
+  const target = options.orchestrator as unknown as PatchableOrchestrator;
+  const originalRunTurn = target.runTurn?.bind(options.orchestrator);
+  if (!originalRunTurn) return () => {};
+
+  target.runTurn = async (text, content, inputOptions) => {
+    if (!isSpokenTurn(inputOptions)) {
+      await originalRunTurn(text, content, inputOptions);
+      return;
+    }
+
+    const override = resolveSpokenTurnModelOverride({
+      providerRegistry: options.providerRegistry,
+      configManager: options.configManager,
+      notify: options.notify,
+    });
+    if (!override) {
+      await originalRunTurn(text, content, inputOptions);
+      return;
+    }
+
+    const routedRegistry = createRoutedProviderRegistry(options.providerRegistry, override);
+    target.setCoreServices({ providerRegistry: routedRegistry });
+    try {
+      await originalRunTurn(text, content, inputOptions);
+    } finally {
+      target.setCoreServices({ providerRegistry: options.providerRegistry });
+    }
+  };
+
+  return () => {
+    target.runTurn = originalRunTurn;
+    target.setCoreServices({ providerRegistry: options.providerRegistry });
+  };
+}
+
+export function resolveSpokenTurnModelOverride(options: {
+  readonly providerRegistry: Pick<ProviderRegistry, 'listModels' | 'getCurrentModel'>;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly notify?: (message: string) => void;
+}): ModelDefinition | null {
+  const modelRef = readConfigString(options.configManager, 'tts.llmModel');
+  if (!modelRef) return null;
+
+  const providerId = readConfigString(options.configManager, 'tts.llmProvider');
+  const current = options.providerRegistry.getCurrentModel();
+  const model = options.providerRegistry.listModels().find((candidate) => {
+    const refMatches = candidate.registryKey === modelRef || candidate.id === modelRef;
+    const providerMatches = !providerId || candidate.provider === providerId;
+    return refMatches && providerMatches;
+  });
+
+  if (!model) {
+    options.notify?.(`[TTS] Configured TTS LLM '${modelRef}' was not found; using current chat model.`);
+    return null;
+  }
+  if (model.selectable === false) {
+    options.notify?.(`[TTS] Configured TTS LLM '${modelRef}' is not selectable; using current chat model.`);
+    return null;
+  }
+  if ((model.registryKey ?? model.id) === (current.registryKey ?? current.id)) return null;
+  return model;
+}
+
+function isSpokenTurn(options: OrchestratorUserInputOptions | undefined): boolean {
+  return options?.origin?.source === SPOKEN_TURN_SOURCE
+    || options?.origin?.metadata?.['spokenOutput'] === true;
+}
+
+function createRoutedProviderRegistry(providerRegistry: ProviderRegistry, model: ModelDefinition): ProviderRegistry {
+  return new Proxy(providerRegistry, {
+    get(target, prop, receiver) {
+      if (prop === 'getCurrentModel') return () => model;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
+}
+
+function readConfigString(configManager: Pick<ConfigManager, 'get'>, key: 'tts.llmProvider' | 'tts.llmModel'): string {
+  return String(configManager.get(key) ?? '').trim();
+}

package/src/input/command-registry.ts

@@ -79,6 +79,7 @@ export interface CommandShellUiOpeners {
   reloadSystemPrompt?: () => string;
   openOnboardingWizard?: (modeOrOptions?: OnboardingWizardMode | OpenOnboardingWizardOptions) => void;
   openModelPicker?: () => void;
+  openModelPickerWithTarget?: (target: import('./model-picker.ts').ModelPickerTarget) => boolean;
   openProviderPicker?: () => void;
   openContextInspector?: () => void;
   openBookmarkModal?: () => void;

package/src/input/commands/tts-runtime.ts

@@ -1,5 +1,6 @@
 import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config/schema';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { SelectionItem } from '../selection-modal.ts';
 
 const TTS_CONFIG_KEYS = new Set(['provider', 'voice', 'llm-provider', 'llm-model']);
 
@@ -33,21 +34,36 @@ export function registerTtsRuntimeCommands(registry: CommandRegistry): void {
     name: 'config-tts',
     aliases: ['tts-config'],
     description: 'Configure live TTS provider, voice, and optional spoken-turn LLM overrides',
-    usage: '[show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm-provider <id|clear>|llm-model <id|clear>]',
+    usage: '[show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm|llm clear|llm-provider <id|clear>|llm-model <id|clear>]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'show').toLowerCase();
       if (sub === 'show') {
+        if (args.length === 0 && openTtsConfigModal(ctx)) return;
         ctx.print(formatTtsConfig(ctx));
         return;
       }
       if (sub === 'providers') {
-        await printTtsProviders(ctx);
+        if (openTtsProviderPicker(ctx)) return;
+        printTtsProviders(ctx);
         return;
       }
       if (sub === 'voices') {
+        if (await openTtsVoicePicker(ctx, args[1])) return;
         await printTtsVoices(ctx, args[1]);
         return;
       }
+      if (sub === 'llm' || sub === 'model') {
+        const action = (args[1] ?? '').toLowerCase();
+        if (action === 'clear' || action === 'default') {
+          setTtsConfigValue(ctx, 'tts.llmProvider', '');
+          setTtsConfigValue(ctx, 'tts.llmModel', '');
+          ctx.print('TTS LLM override cleared. /tts will use the current chat model.');
+          return;
+        }
+        if (ctx.openModelPickerWithTarget?.('tts')) return;
+        ctx.print('TTS LLM picker is not available in this runtime. Use /config-tts llm-provider <id> and /config-tts llm-model <model>.');
+        return;
+      }
       if (TTS_CONFIG_KEYS.has(sub)) {
         const value = args.slice(1).join(' ').trim();
         if (!value) {
@@ -56,11 +72,17 @@ export function registerTtsRuntimeCommands(registry: CommandRegistry): void {
         }
         const key = ttsConfigKeyForSubcommand(sub);
         const nextValue = value.toLowerCase() === 'clear' ? '' : value;
-        ctx.platform.configManager.setDynamic(key, nextValue);
+        const previousProvider = key === 'tts.provider'
+          ? String(ctx.platform.configManager.get('tts.provider') ?? '').trim()
+          : '';
+        setTtsConfigValue(ctx, key, nextValue);
+        if (key === 'tts.provider' && previousProvider && previousProvider !== nextValue) {
+          setTtsConfigValue(ctx, 'tts.voice', '');
+        }
         ctx.print(`${key} ${nextValue ? `set to ${nextValue}` : 'cleared'}.`);
         return;
       }
-      ctx.print('Usage: /config-tts [show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm-provider <id|clear>|llm-model <id|clear>]');
+      ctx.print('Usage: /config-tts [show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm|llm clear|llm-provider <id|clear>|llm-model <id|clear>]');
     },
   });
 }
@@ -86,17 +108,139 @@ function formatTtsConfig(ctx: CommandContext): string {
     `  spoken-turn llm provider override: ${llmProvider || '(current chat provider)'}`,
     `  spoken-turn llm model override: ${llmModel || '(current chat model)'}`,
     '  playback: live streaming through local mpv or ffplay',
-    '  commands: /tts <prompt>, /tts stop, /config-tts providers, /config-tts voices [provider]',
+    '  commands: /tts <prompt>, /tts stop, /config-tts, /config-tts providers, /config-tts voices [provider], /config-tts llm',
   ].join('\n');
 }
 
-async function printTtsProviders(ctx: CommandContext): Promise<void> {
+function openTtsConfigModal(ctx: CommandContext): boolean {
+  if (!ctx.openSelection) return false;
+  const cm = ctx.platform.configManager;
+  const provider = String(cm.get('tts.provider') ?? '').trim() || '(default)';
+  const voice = String(cm.get('tts.voice') ?? '').trim() || '(provider default)';
+  const llmProvider = String(cm.get('tts.llmProvider') ?? '').trim();
+  const llmModel = String(cm.get('tts.llmModel') ?? '').trim();
+  const llm = llmProvider || llmModel ? `${llmProvider || 'provider'} / ${llmModel || 'model'}` : '(current chat model)';
+  const items: SelectionItem[] = [
+    {
+      id: 'provider',
+      label: 'TTS provider',
+      detail: provider,
+      category: 'speech output',
+      primaryAction: 'select',
+      actions: '[Enter] choose',
+    },
+    {
+      id: 'voice',
+      label: 'TTS voice',
+      detail: voice,
+      category: 'speech output',
+      primaryAction: 'select',
+      actions: '[Enter] choose',
+    },
+    {
+      id: 'llm',
+      label: 'TTS response model override',
+      detail: llm,
+      category: 'response generation',
+      primaryAction: 'select',
+      actions: '[Enter] choose model',
+    },
+    {
+      id: 'clear-voice',
+      label: 'Use provider default voice',
+      detail: 'clears tts.voice',
+      category: 'clear values',
+      primaryAction: 'select',
+    },
+    {
+      id: 'clear-llm',
+      label: 'Use current chat model for /tts',
+      detail: 'clears tts.llmProvider and tts.llmModel',
+      category: 'clear values',
+      primaryAction: 'select',
+    },
+  ];
+
+  ctx.openSelection('TTS Configuration', items, { allowSearch: true }, (result) => {
+    if (!result) return;
+    if (result.item.id === 'provider') {
+      openTtsProviderPicker(ctx);
+      return;
+    }
+    if (result.item.id === 'voice') {
+      void openTtsVoicePicker(ctx);
+      return;
+    }
+    if (result.item.id === 'llm') {
+      if (!ctx.openModelPickerWithTarget?.('tts')) {
+        ctx.print('TTS LLM picker is not available in this runtime.');
+      }
+      return;
+    }
+    if (result.item.id === 'clear-voice') {
+      setTtsConfigValue(ctx, 'tts.voice', '');
+      ctx.print('TTS voice cleared. The provider default voice will be used.');
+      return;
+    }
+    if (result.item.id === 'clear-llm') {
+      setTtsConfigValue(ctx, 'tts.llmProvider', '');
+      setTtsConfigValue(ctx, 'tts.llmModel', '');
+      ctx.print('TTS LLM override cleared. /tts will use the current chat model.');
+    }
+  });
+  return true;
+}
+
+function getStreamingTtsProviders(ctx: CommandContext): Array<{ id: string; label: string; capabilities: readonly string[] }> {
+  const registry = ctx.platform.voiceProviderRegistry;
+  if (!registry) {
+    return [];
+  }
+  return registry.list().filter((provider) => provider.capabilities.includes('tts-stream'));
+}
+
+function openTtsProviderPicker(ctx: CommandContext): boolean {
+  if (!ctx.openSelection) return false;
+  const registry = ctx.platform.voiceProviderRegistry;
+  if (!registry) {
+    ctx.print('Voice provider registry is not available in this runtime.');
+    return true;
+  }
+  const providers = getStreamingTtsProviders(ctx);
+  if (providers.length === 0) {
+    ctx.print('No streaming TTS providers are registered.');
+    return true;
+  }
+  const current = String(ctx.platform.configManager.get('tts.provider') ?? '').trim();
+  const items: SelectionItem[] = providers.map((provider) => ({
+    id: provider.id,
+    label: provider.label,
+    detail: provider.id === current ? `${provider.id}  (current)` : provider.id,
+    category: 'streaming TTS providers',
+    primaryAction: 'select',
+    actions: '[Enter] set provider',
+  }));
+  ctx.openSelection('Choose TTS Provider', items, { preSelectId: current, allowSearch: true }, (result) => {
+    if (!result) return;
+    const previous = String(ctx.platform.configManager.get('tts.provider') ?? '').trim();
+    setTtsConfigValue(ctx, 'tts.provider', result.item.id);
+    if (previous && previous !== result.item.id) {
+      setTtsConfigValue(ctx, 'tts.voice', '');
+      ctx.print(`TTS provider set to ${result.item.id}. TTS voice was cleared because voices are provider-specific.`);
+    } else {
+      ctx.print(`TTS provider set to ${result.item.id}.`);
+    }
+  });
+  return true;
+}
+
+function printTtsProviders(ctx: CommandContext): void {
   const registry = ctx.platform.voiceProviderRegistry;
   if (!registry) {
     ctx.print('Voice provider registry is not available in this runtime.');
     return;
   }
-  const providers = registry.list().filter((provider) => provider.capabilities.includes('tts-stream'));
+  const providers = getStreamingTtsProviders(ctx);
   if (providers.length === 0) {
     ctx.print('No streaming TTS providers are registered.');
     return;
@@ -104,9 +248,56 @@ async function printTtsProviders(ctx: CommandContext): Promise<void> {
   ctx.print([
     'Streaming TTS Providers',
     ...providers.map((provider) => `  ${provider.id}: ${provider.label}`),
+    '',
+    'Set provider: /config-tts provider <provider-id>',
   ].join('\n'));
 }
 
+async function openTtsVoicePicker(ctx: CommandContext, providerArg?: string): Promise<boolean> {
+  if (!ctx.openSelection) return false;
+  const service = ctx.platform.voiceService;
+  if (!service) {
+    ctx.print('Voice service is not available in this runtime.');
+    return true;
+  }
+  const providerId = (providerArg ?? String(ctx.platform.configManager.get('tts.provider') ?? '')).trim() || undefined;
+  try {
+    const voices = await service.listVoices(providerId);
+    if (voices.length === 0) {
+      ctx.print(providerId ? `No voices returned for ${providerId}.` : 'No TTS voices returned.');
+      return true;
+    }
+    const current = String(ctx.platform.configManager.get('tts.voice') ?? '').trim();
+    const items: SelectionItem[] = [
+      {
+        id: '__default__',
+        label: 'Use provider default voice',
+        detail: current ? 'clears tts.voice' : '(current)',
+        category: 'voice',
+        primaryAction: 'select',
+      },
+      ...voices.map((voice) => ({
+        id: voice.id,
+        label: voice.label || voice.id,
+        detail: voice.id === current ? `${voice.id}  (current)` : voice.id,
+        category: providerId ?? 'voices',
+        primaryAction: 'select' as const,
+        actions: '[Enter] set voice',
+      })),
+    ];
+    ctx.openSelection(`Choose TTS Voice${providerId ? ` (${providerId})` : ''}`, items, { preSelectId: current || '__default__', allowSearch: true }, (result) => {
+      if (!result) return;
+      const nextVoice = result.item.id === '__default__' ? '' : result.item.id;
+      setTtsConfigValue(ctx, 'tts.voice', nextVoice);
+      ctx.print(nextVoice ? `TTS voice set to ${nextVoice}.` : 'TTS voice cleared. The provider default voice will be used.');
+    });
+    return true;
+  } catch (error) {
+    ctx.print(`Unable to list TTS voices: ${error instanceof Error ? error.message : String(error)}`);
+    return true;
+  }
+}
+
 async function printTtsVoices(ctx: CommandContext, providerArg?: string): Promise<void> {
   const service = ctx.platform.voiceService;
   if (!service) {
@@ -124,12 +315,19 @@ async function printTtsVoices(ctx: CommandContext, providerArg?: string): Promis
       `TTS Voices${providerId ? ` (${providerId})` : ''}`,
       ...voices.slice(0, 60).map((voice) => `  ${voice.id}: ${voice.label}`),
       ...(voices.length > 60 ? [`  ... ${voices.length - 60} more`] : []),
+      '',
+      'Set voice: /config-tts voice <voice-id>',
+      'Use provider default voice: /config-tts voice clear',
     ].join('\n'));
   } catch (error) {
     ctx.print(`Unable to list TTS voices: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 
+function setTtsConfigValue(ctx: CommandContext, key: ConfigKey, value: string): void {
+  ctx.platform.configManager.setDynamic(key, value);
+}
+
 function formatValue(value: unknown): string {
   const text = String(value ?? '').trim();
   return text || '(default)';

package/src/input/model-picker.ts

@@ -12,8 +12,9 @@ export type PickerMode = 'model' | 'provider' | 'effort' | 'contextCap';
  * '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';
+export type ModelPickerTarget = 'main' | 'helper' | 'tool' | 'tts';
 
 /**
  * Pricing tier filter.

package/src/main.ts

@@ -52,6 +52,10 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-displ
 import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState } from './cli/tui-startup.ts';
 import { wireSpokenTurnRuntime } from './audio/spoken-turn-wiring.ts';
+import {
+  attachSpokenTurnModelRouting,
+  createSpokenTurnInputOptions,
+} from './audio/spoken-turn-model-routing.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h';
 const ALT_SCREEN_EXIT  = '\x1b[?1049l';
@@ -251,6 +255,12 @@ async function main() {
   });
   stopSpokenOutputForExit = () => spokenTurns.stop();
   unsubs.push(...spokenTurns.unsubs);
+  unsubs.push(attachSpokenTurnModelRouting({
+    orchestrator,
+    providerRegistry,
+    configManager,
+    notify: (message) => { systemMessageRouter.high(message); render(); },
+  }));
 
   const submitInput = (text: string, content?: ContentPart[], options: { readonly spokenOutput?: boolean } = {}) => {
     input.clearModalStack();
@@ -289,7 +299,8 @@ async function main() {
       if (options.spokenOutput && processedText) {
         spokenTurns.submitNextTurn(processedText);
       }
-      orchestrator.handleUserInput(processedText, content).catch((err: unknown) => {
+      const inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
+      orchestrator.handleUserInput(processedText, content, inputOptions).catch((err: unknown) => {
         logger.debug('handleUserInput safety catch (already handled by runTurn)', { error: summarizeError(err) });
       });
     } else {

package/src/runtime/bootstrap-command-parts.ts

@@ -203,6 +203,10 @@ export function createBootstrapCommandActions(
           configManager.set('tools.llmModel', key);
           configManager.setDynamic('tools.llmEnabled' as never, true);
           conversation.log(`Tool LLM set to: ${def.displayName} (${def.provider})`, { fg: '135' });
+        } else if (resolvedTarget === 'tts') {
+          configManager.set('tts.llmProvider', def.provider);
+          configManager.set('tts.llmModel', key);
+          conversation.log(`TTS LLM set to: ${def.displayName} (${def.provider})`, { fg: '135' });
         } else {
           // Default: main provider/model
           if (contextCap != null && contextCap > 0) {

package/src/shell/ui-openers.ts

@@ -111,6 +111,14 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     return new Set(results.filter((v): v is string => v !== null));
   }
 
+  const getCurrentModelForPickerTarget = (): string => {
+    const target = input.modelPicker.target;
+    if (target === 'helper') return String(configManager.get('helper.globalModel') || runtime.model);
+    if (target === 'tool') return String(configManager.get('tools.llmModel') || runtime.model);
+    if (target === 'tts') return String(configManager.get('tts.llmModel') || runtime.model);
+    return runtime.model;
+  };
+
   commandContext.openModelPicker = () => {
     void (async () => {
       const models = providerRegistry.getSelectableModels();
@@ -124,7 +132,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
       });
       void input.modelPicker.loadRecentModels().catch(() => {}); // best-effort: prefetch for UI, failure is non-visible
       input.modalOpened('modelPicker');
-      input.modelPicker.openAllModels(models, runtime.model);
+      input.modelPicker.openAllModels(models, getCurrentModelForPickerTarget());
       render();
     })().catch((error: unknown) => {
       commandContext.print?.(`Model picker failed to open: ${error instanceof Error ? error.message : String(error)}`);
@@ -132,6 +140,8 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     });
   };
 
+  commandContext.openModelPickerWithTarget = (target) => input.openModelPickerWithTarget(target);
+
   commandContext.openProviderPicker = () => {
     void (async () => {
       const providers = [...new Set(providerRegistry.listModels().map((model) => model.provider))];

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.19.32';
+let _version = '0.19.33';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;