@pellux/goodvibes-tui 1.20.1 → 1.21.1

package/src/input/composer-capture.ts

@@ -14,6 +14,53 @@
  * written and where.
  */
 
+/** The provider-registry surface the `@model:` directive needs. */
+export interface AtModelRegistry {
+  setCurrentModel(reference: string): void;
+  getCurrentModel(): { id: string; provider: string; registryKey: string; displayName: string };
+}
+
+export interface AtModelDeps {
+  readonly providerRegistry: AtModelRegistry;
+  /** Session runtime whose model/provider labels follow an explicit switch. */
+  readonly runtime: { model: string; provider: string };
+  readonly configManager: { set(key: string, value: unknown): void };
+  /** Surfaces the switch confirmation / unknown-model message. */
+  readonly notify: (message: string) => void;
+}
+
+const AT_MODEL_PATTERN = /@model:([^\s]+)/g;
+
+/**
+ * Apply every `@model:<id>` directive in a composer submission and return the
+ * text with the directives stripped.
+ *
+ * The switch is a real, persisted selection (config `provider.model`), not a
+ * per-turn override, so the runtime labels are updated alongside it and each
+ * one is announced. An unknown id is reported as unknown rather than silently
+ * dropped — the user asked for a specific backend and did not get it.
+ */
+export function applyAtModelDirective(input: string, deps: AtModelDeps): string {
+  let text = input;
+  let match: RegExpExecArray | null;
+  const pattern = new RegExp(AT_MODEL_PATTERN.source, 'g');
+  while ((match = pattern.exec(input)) !== null) {
+    const modelId = match[1]!;
+    try {
+      deps.providerRegistry.setCurrentModel(modelId);
+      const def = deps.providerRegistry.getCurrentModel();
+      deps.runtime.model = def.id;
+      deps.runtime.provider = def.provider;
+      deps.configManager.set('provider.model', def.registryKey);
+      deps.notify(`[Model] Switched to ${def.displayName} (${def.provider}) via @model:`);
+    } catch {
+      deps.notify(`[Model] Unknown model: ${modelId}`);
+    }
+    text = text.replace(match[0], '').trim();
+  }
+  return text;
+}
+
 export interface ComposerCaptureDeps {
   readonly sessionMemoryStore: { add(text: string): string };
   /** Surfaces the confirmation / usage message (a system message the shell renders). */

package/src/input/handler-command-route.ts

@@ -86,6 +86,10 @@ export function handleCommandModeToken(state: CommandModeRouteState, token: Inpu
     const raw = selectedCmd ? `/${selectedCmd.name}` : state.prompt.trim();
     if (raw.startsWith('/') && state.commandRegistry && state.commandContext) {
       closeCommandMode();
+      // Submitting a command is a submission: the splash yields to command
+      // input exactly as it does to text input (owner rule), whether or not
+      // the command puts anything in the transcript.
+      state.conversationManager?.dismissSplash();
       const parts = raw.slice(1).trim().split(/\s+/);
       const name = parts[0];
       const args = parts.slice(1);

package/src/input/handler-content-actions.ts

@@ -303,6 +303,11 @@ export function handleBlockCopy(
   }
   copyToClipboard(nearest.rawContent);
   onCopied();
+  // An explicit action on this block permanently exempts it from the
+  // search-close auto-re-collapse (see ConversationManager.noteUserTouch) —
+  // copying content the user just had search reveal is a deliberate choice
+  // to keep it visible, not an accident of typing a query.
+  conversationManager.searchExpansion.noteUserTouch(nearest.collapseKey);
   conversationManager.log(`[Copied ${describeBlockForReceipt(nearest)}]`, { fg: '#22c55e' });
   requestRender();
   setTimeout(() => requestRender(), 2005);
@@ -324,6 +329,8 @@ export function handleBookmark(
   }
   const label = `${nearest.type}: ${nearest.rawContent.slice(0, 40).replace(/\n/g, ' ')}`;
   const added = bookmarkManager.toggle(nearest.collapseKey, label);
+  // See handleBlockCopy's note — bookmarking is an explicit block action too.
+  conversationManager.searchExpansion.noteUserTouch(nearest.collapseKey);
   const target = describeBlockForReceipt(nearest);
   const msg = added
     ? `[Bookmarked: ${target}]`
@@ -346,6 +353,8 @@ export function handleBlockSave(
     requestRender();
     return;
   }
+  // See handleBlockCopy's note — saving to a file is an explicit block action too.
+  conversationManager.searchExpansion.noteUserTouch(nearest.collapseKey);
   const target = describeBlockForReceipt(nearest);
   try {
     const filePath = bookmarkManager.saveToFile(nearest.rawContent, nearest.type);

package/src/input/handler-feed-routes.ts

@@ -468,6 +468,7 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
         prompt = '';
         cursorPos = 0;
         if (name) {
+          state.conversationManager?.dismissSplash(); // command input retires the splash, same as text input
           const executeCommand = state.commandContext.executeCommand;
           void executeCommand(name, args).then((handled) => {
             if (!handled) {

package/src/input/handler-modal-routes.ts

@@ -1,4 +1,5 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import { servingEffortForLevel, toEffortModel } from '../providers/reasoning-effort-surface.ts';
 import type { SelectionResult, SelectionAction } from './selection-modal.ts';
 import type { CommandContext } from './command-registry.ts';
 import type { ConfigModal } from './config-modal.ts';
@@ -286,7 +287,17 @@ type SettingsRouteState = {
 function syncRuntimeAfterSettingReset(ctx: CommandContext | undefined, key: string, value: unknown): void {
   if (!ctx) return;
   if (key === 'provider.model') ctx.session.runtime.model = String(value);
-  if (key === 'provider.reasoningEffort') ctx.session.runtime.reasoningEffort = String(value);
+  if (key === 'provider.reasoningEffort') {
+    // config holds the REQUESTED level; the session holds the EFFECTIVE one for
+    // whichever model is serving, so the reset value is resolved rather than
+    // copied straight across. A context with no reachable provider registry
+    // (a surface that routes only through the provider API) stores the reset
+    // value unresolved rather than failing the whole reset.
+    const serving = ctx.provider?.providerRegistry?.getCurrentModel?.();
+    ctx.session.runtime.reasoningEffort = serving
+      ? servingEffortForLevel(String(value), toEffortModel(serving)).effective ?? ''
+      : String(value);
+  }
 }
 
 function consumeSettingsPickerRequest(state: SettingsRouteState): void {

package/src/input/handler-picker-routes.ts

@@ -7,6 +7,7 @@ import { ensureProviderKeyThenSelect } from './provider-key-intake.ts';
 import { resolveAndValidatePath } from '@pellux/goodvibes-sdk/platform/utils';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { BlockActionId } from '../renderer/block-actions.ts';
+import { offersConfigurableEffort, requestedEffortLevel, servingEffortForLevel, toEffortModel } from '../providers/reasoning-effort-surface.ts';
 
 type ModelPickerRouteState = {
   modelPicker: ModelPickerModal;
@@ -18,6 +19,31 @@ type ModelPickerRouteState = {
   onModelPickerCommit?: () => boolean;
 };
 
+/**
+ * The user's REQUESTED reasoning level for this session, or undefined when the
+ * command context is not attached. Read from config through the shared helper —
+ * never from `session.runtime.reasoningEffort`, which holds the EFFECTIVE level
+ * for whichever model is serving and would re-seed a resolution with an already
+ * snapped-down value.
+ */
+function readRequestedEffort(state: ModelPickerRouteState): string | undefined {
+  const configManager = state.commandContext?.platform?.configManager;
+  if (!configManager) return undefined;
+  return requestedEffortLevel(configManager) || undefined;
+}
+
+/**
+ * The level the effort step should open on for a model about to be selected:
+ * the requested level SNAPPED to that model. Opening on the raw requested level
+ * would miss the list entirely whenever the target model caps lower, and
+ * showEffortPicker falls back to index 0 — landing the cursor on the LOWEST
+ * level rather than on what pressing Enter would actually give you.
+ */
+function effortStepPreselect(state: ModelPickerRouteState, model: { id: string; provider?: string; displayName?: string }): string {
+  const requested = readRequestedEffort(state) ?? 'medium';
+  return servingEffortForLevel(requested, toEffortModel(model as never)).effective ?? requested;
+}
+
 export function handleModelPickerToken(state: ModelPickerRouteState, token: InputToken): boolean {
   if (!state.modelPicker.active) return false;
 
@@ -61,9 +87,17 @@ export function handleModelPickerToken(state: ModelPickerRouteState, token: Inpu
       if (mode === 'model') {
         const selected = state.modelPicker.getSelected();
         if (selected) {
-          const currentEffort = state.commandContext?.session.runtime.reasoningEffort ?? 'medium';
-          if (state.modelPicker.target === 'main' && selected.reasoningEffort && selected.reasoningEffort.length > 0) {
-            state.modelPicker.showEffortPicker(selected, currentEffort);
+          // Preselect the REQUESTED level, not the effective one: the effort step
+          // re-chooses the preference, so it must open on what the user asked for
+          // even while a model that caps lower is serving.
+          const currentEffort = readRequestedEffort(state) ?? 'medium';
+          // Whether an effort step appears at all is now this model's own
+          // resolved spec: a model with no configurable reasoning level — or
+          // one whose levels are only a labelled best guess the adapters will
+          // discard — skips straight to commit instead of showing a list it
+          // does not honour.
+          if (state.modelPicker.target === 'main' && offersConfigurableEffort(toEffortModel(selected))) {
+            state.modelPicker.showEffortPicker(selected, effortStepPreselect(state, selected));
           } else {
             const target = state.modelPicker.target;
             const handled = state.onModelPickerCommit?.() ?? false;
@@ -75,6 +109,9 @@ export function handleModelPickerToken(state: ModelPickerRouteState, token: Inpu
               // (concealed prompt → secrets manager → live re-register) and
               // only then completes the original selection.
               ensureProviderKeyThenSelect(ctx, selected.provider, () => {
+                // No effort step ran, so `currentEffort` is carried over, not
+                // chosen: the commit path re-resolves from the stored
+                // preference instead of treating this as a new choice.
                 ctx.completeModelSelection?.({ model: selected, effort: currentEffort, target });
               });
             }
@@ -98,7 +135,8 @@ export function handleModelPickerToken(state: ModelPickerRouteState, token: Inpu
         const ctx = state.commandContext;
         if (model && effort && !handled && ctx) {
           ensureProviderKeyThenSelect(ctx, model.provider, () => {
-            ctx.completeModelSelection?.({ model, effort, target });
+            // The effort STEP: the level below is one the user just picked.
+            ctx.completeModelSelection?.({ model, effort, target, effortChosenByUser: true });
           });
         }
       } else if (mode === 'embeddingProvider') {
@@ -119,7 +157,7 @@ export function handleModelPickerToken(state: ModelPickerRouteState, token: Inpu
           } else {
             state.modelPicker.contextCapError = null;
             const validCap = parsedCap !== null && parsedCap > 0 && parsedCap <= 10_000_000 ? parsedCap : null;
-            const effort = state.commandContext?.session.runtime.reasoningEffort ?? 'medium';
+            const effort = readRequestedEffort(state) ?? 'medium';
             const target = state.modelPicker.target;
             const handled = state.onModelPickerCommit?.() ?? false;
             state.modelPicker.close();

package/src/input/handler-shortcuts.ts

@@ -256,7 +256,7 @@ export function handleGlobalShortcutToken(
       return true;
 
     case 'search':
-      if (state.searchManager.active) state.searchManager.close();
+      if (state.searchManager.active) state.searchManager.close(state.conversationManager);
       else state.searchManager.open();
       state.requestRender();
       return true;

package/src/input/handler-ui-state.ts

@@ -223,10 +223,11 @@ export function handleSearchModeToken(
       searchManager.search(newQuery, history, state.conversationManager);
     } else if (token.type === 'key') {
       if (token.logicalName === 'escape') {
-        searchManager.close();
+        searchManager.close(state.conversationManager);
       } else if (token.logicalName === 'enter' || token.logicalName === 'tab') {
         if (searchManager.query.length > 0) {
           searchManager.lock();
+          searchManager.revealCurrentMatch(history, state.conversationManager);
           const matchLine = searchManager.getCurrentMatchLine();
           if (matchLine >= 0) {
             state.scroll(matchLine - state.getScrollTop() - Math.floor(state.getViewportHeight() / 2));
@@ -236,21 +237,23 @@ export function handleSearchModeToken(
         const newQuery = searchManager.query.slice(0, -1);
         searchManager.search(newQuery, history, state.conversationManager);
       } else if (matchesSearchShortcut) {
-        searchManager.close();
+        searchManager.close(state.conversationManager);
       }
     }
   } else {
     if (token.type === 'key') {
       if (token.logicalName === 'escape' || matchesSearchShortcut) {
-        searchManager.close();
+        searchManager.close(state.conversationManager);
       } else if (token.logicalName === 'right' || token.logicalName === 'down') {
         searchManager.nextMatch();
+        searchManager.revealCurrentMatch(history, state.conversationManager);
         const matchLine = searchManager.getCurrentMatchLine();
         if (matchLine >= 0) {
           state.scroll(matchLine - state.getScrollTop() - Math.floor(state.getViewportHeight() / 2));
         }
       } else if (token.logicalName === 'left' || token.logicalName === 'up') {
         searchManager.prevMatch();
+        searchManager.revealCurrentMatch(history, state.conversationManager);
         const matchLine = searchManager.getCurrentMatchLine();
         if (matchLine >= 0) {
           state.scroll(matchLine - state.getScrollTop() - Math.floor(state.getViewportHeight() / 2));
@@ -261,12 +264,14 @@ export function handleSearchModeToken(
     } else if (token.type === 'text') {
       if (token.value === 'n' || token.value === 'j' || token.value === 'l') {
         searchManager.nextMatch();
+        searchManager.revealCurrentMatch(history, state.conversationManager);
         const matchLine = searchManager.getCurrentMatchLine();
         if (matchLine >= 0) {
           state.scroll(matchLine - state.getScrollTop() - Math.floor(state.getViewportHeight() / 2));
         }
       } else if (token.value === 'N' || token.value === 'k' || token.value === 'h') {
         searchManager.prevMatch();
+        searchManager.revealCurrentMatch(history, state.conversationManager);
         const matchLine = searchManager.getCurrentMatchLine();
         if (matchLine >= 0) {
           state.scroll(matchLine - state.getScrollTop() - Math.floor(state.getViewportHeight() / 2));

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

@@ -203,6 +203,21 @@ export function buildProviderItems(
 // buildEffortItems — effort levels -> PickerItem[]
 // ---------------------------------------------------------------------------
 
-export function buildEffortItems(effortLevels: readonly string[]): PickerItem[] {
-  return effortLevels.map(e => ({ id: e, label: e, detail: EFFORT_DESCRIPTIONS[e] ?? '' }));
+/**
+ * Effort levels as picker items.
+ *
+ * `choices` carries the per-spec descriptions (a budget-typed model shows the
+ * thinking-token budget each level sends, a toggle says on/off), so it is used
+ * when the caller has a resolved presentation. The bare level table is only the
+ * fallback for a caller that has levels but no spec.
+ */
+export function buildEffortItems(
+  effortLevels: readonly string[],
+  choices?: readonly { readonly level: string; readonly description: string }[],
+): PickerItem[] {
+  return effortLevels.map((e) => ({
+    id: e,
+    label: e,
+    detail: choices?.find((choice) => choice.level === e)?.description ?? EFFORT_DESCRIPTIONS[e] ?? '',
+  }));
 }

package/src/input/model-picker.ts

@@ -1,4 +1,9 @@
 import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
+import {
+  effortPresentationForModel,
+  toEffortModel,
+  type EffortPresentation,
+} from '../providers/reasoning-effort-surface.ts';
 import type { FavoritesStore } from '@pellux/goodvibes-sdk/platform/providers';
 import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
@@ -87,7 +92,14 @@ export class ModelPickerModal {
   public scrollOffset = 0;
   public models: ModelDefinition[] = [];
   public providers: string[] = [];
+  /** Levels the model chosen in model-mode actually offers (see showEffortPicker). */
   public effortLevels: string[] = [];
+  /**
+   * How to present those levels honestly: the spec kind decides the headline
+   * (named levels vs a token budget vs an on/off toggle), and a best-guess
+   * spec carries a caveat. Null outside effort mode.
+   */
+  public effortPresentation: EffortPresentation | null = null;
   /** Entries for PickerMode 'embeddingProvider' — the 'embeddings' target's own tiny item list. */
   public embeddingProviders: EmbeddingProviderPickerEntry[] = [];
   /** Mode to restore when navigating the targets rail away from 'embeddings'. */
@@ -356,7 +368,11 @@ export class ModelPickerModal {
     this.previousMode = 'model';
     this.pendingModel = model;
     this.searchFocused = false;
-    this.effortLevels = model.reasoningEffort ?? [];
+    // Only this model's real levels: the picker used to read a raw list off
+    // the definition, which was the same four values for every model.
+    const presentation = effortPresentationForModel(toEffortModel(model));
+    this.effortPresentation = presentation;
+    this.effortLevels = presentation.choices.map((choice) => choice.level);
     this.mode = 'effort';
     const idx = this.effortLevels.indexOf(currentEffort);
     this.selectedIndex = idx >= 0 ? idx : 0;
@@ -376,6 +392,7 @@ export class ModelPickerModal {
     this.embeddingProviders = [];
     this.nonEmbeddingMode = 'model';
     this.pendingModel = null;
+    this.effortPresentation = null;
     this.contextCapPendingModel = null;
     this.contextCapQuery = '';
     this.contextCapError = null;
@@ -548,7 +565,7 @@ export class ModelPickerModal {
       }));
     }
     // effort mode
-    return buildEffortItems(this.effortLevels);
+    return buildEffortItems(this.effortLevels, this.effortPresentation?.choices);
   }
 
   /** Get count of selectable (non-header) items in current mode. */