@pellux/goodvibes-tui 2.0.20 → 2.1.0

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

@@ -225,6 +225,14 @@ export function buildFilteredModels(
     result = [...recent, ...rest];
   }
 
+  // Pinned models lead (before recent), so the picker's Pinned group sits at
+  // the top and up/down walks the list in the order it is drawn. Pins may be
+  // recorded by model id or by registry key.
+  if (pinnedIds.size > 0) {
+    const isPinned = (m: ModelDefinition): boolean => pinnedIds.has(m.id) || pinnedIds.has(m.registryKey);
+    result = [...result.filter(isPinned), ...result.filter((m) => !isPinned(m))];
+  }
+
   const newCache: FilteredModelsCache = {
     modelsRef: models,
     configuredProvidersKey,

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

@@ -0,0 +1,99 @@
+/**
+ * model-picker-open.ts, opening the model picker without waiting on slow reads.
+ *
+ * The picker's model and provider lists come from the provider registry's
+ * cached catalog, which is synchronous. What used to hold the open back for
+ * seconds were the reads awaited before the modal appeared: one credential
+ * store lookup per configured provider (which credential source configured
+ * it) and the embedding registry's status probe (the Embeddings tab). Those
+ * only decorate rows or feed other tabs, so the picker now opens at once on
+ * the cached catalog with a muted "loading catalog…" row, and those reads,
+ * plus the live re-check of each provider's served models, fill in when they
+ * land. A close or a newer open drops any load still in flight.
+ */
+
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
+import type {
+  EmbeddingProviderPickerEntry,
+  ModelPickerCatalogFill,
+  ModelPickerModal,
+  ModelPickerTargetInfo,
+} from './model-picker.ts';
+
+type ConfiguredVia = Map<string, 'env' | 'secrets' | 'subscription' | 'anonymous'>;
+
+export interface ModelPickerOpenDeps {
+  readonly picker: ModelPickerModal;
+  /** Register the picker as the open modal (input focus, modal stack). */
+  readonly modalOpened: () => void;
+  readonly render: () => void;
+  /** The selectable models from the cached catalog (synchronous). */
+  readonly listModels: () => ModelDefinition[];
+  /** The selectable provider ids from the cached catalog (synchronous). */
+  readonly listProviders: () => string[];
+  readonly currentModelId: () => string;
+  readonly currentProviderId: () => string;
+  readonly configuredProviderIds: () => ReadonlySet<string>;
+  /** Which credential source configured each provider, given the providers the credential store holds keys for. */
+  readonly buildConfiguredVia: (providerIds: readonly string[], configured: ReadonlySet<string>, secretProviderIds: ReadonlySet<string>) => ConfiguredVia;
+  readonly buildTargets: (embeddingProviders: EmbeddingProviderPickerEntry[]) => ModelPickerTargetInfo[];
+  /** Slow: one credential store read per configured provider. */
+  readonly resolveSecretProviderIds: () => Promise<ReadonlySet<string>>;
+  /** Slow: the embedding registry's status probe. */
+  readonly resolveEmbeddingProviders: () => Promise<EmbeddingProviderPickerEntry[]>;
+  /** Optional live re-check of each provider's served models; resolves true when a list changed. */
+  readonly refreshLiveModels?: () => Promise<boolean>;
+  /** Best-effort prefetches (pinned and recent models); failures stay silent. */
+  readonly prefetch?: () => Promise<void>;
+  readonly onError: (error: unknown) => void;
+}
+
+/**
+ * Open the picker on the cached catalog right now (it is visible when this
+ * returns), then fill in the slow parts. `mode` picks the model list (/model)
+ * or the provider list (/provider). The returned promise settles when every
+ * fill has landed or been dropped; callers do not need to await it.
+ */
+export function openModelPickerNow(deps: ModelPickerOpenDeps, mode: 'models' | 'providers' = 'models'): Promise<void> {
+  const { picker } = deps;
+  const configured = new Set(deps.configuredProviderIds());
+  const models = deps.listModels();
+  const providers = mode === 'providers' ? deps.listProviders() : [...new Set(models.map((m) => m.provider))];
+  picker.configuredProviders = configured;
+  picker.configuredViaMap = deps.buildConfiguredVia(providers, configured, new Set());
+  deps.modalOpened();
+  picker.setTargetInfos(deps.buildTargets(picker.embeddingProviders));
+  if (mode === 'providers') picker.openProviders(providers, deps.currentProviderId());
+  else picker.openAllModels(models, deps.currentModelId());
+  const ticket = picker.beginCatalogLoad();
+  deps.render();
+
+  const prefetch = (deps.prefetch?.() ?? Promise.resolve()).catch(() => {}).then(() => deps.render());
+
+  const decorations = (async () => {
+    const [secretIds, embedding] = await Promise.all([deps.resolveSecretProviderIds(), deps.resolveEmbeddingProviders()]);
+    const fill: ModelPickerCatalogFill = {
+      configuredViaMap: deps.buildConfiguredVia(providers, configured, secretIds),
+      embeddingProviders: embedding,
+      targetInfos: deps.buildTargets(embedding),
+    };
+    if (picker.fillCatalog(ticket, fill, false)) deps.render();
+  })();
+
+  const live = (async () => {
+    if (!deps.refreshLiveModels) return;
+    const changed = await deps.refreshLiveModels().catch(() => false);
+    if (!changed) return;
+    const fresh = mode === 'providers' ? { providers: deps.listProviders() } : { models: deps.listModels() };
+    if (picker.fillCatalog(ticket, fresh, false)) deps.render();
+  })();
+
+  return Promise.all([decorations, live])
+    .catch((error: unknown) => deps.onError(error))
+    .finally(() => {
+      // Loaded or failed, the loading row goes: the picker keeps what it has.
+      if (picker.fillCatalog(ticket, {})) deps.render();
+      return prefetch;
+    })
+    .then(() => {});
+}

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

@@ -13,7 +13,7 @@ export type PickerMode = 'model' | 'provider' | 'effort' | 'contextCap' | 'embed
  */
 export type ModelPickerTarget = 'main' | 'helper' | 'tool' | 'tts' | 'embeddings';
 
-export type ModelPickerFocusPane = 'targets' | 'items';
+export type ModelPickerFocusRegion = 'targets' | 'items';
 
 export interface ModelPickerTargetInfo {
   readonly target: ModelPickerTarget;

package/src/input/model-picker.ts

@@ -6,6 +6,7 @@ import {
 } 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 { compositeScore } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { detectFamily, POPULAR_PROVIDERS, tierToCategoryFilter } from './model-picker-types.ts';
 import type {
@@ -17,7 +18,7 @@ import type {
   FilteredProvidersCache,
   GroupByMode,
   ModelItemsCache,
-  ModelPickerFocusPane,
+  ModelPickerFocusRegion,
   ModelPickerTarget,
   ModelPickerTargetInfo,
   PickerItem,
@@ -42,6 +43,15 @@ import {
 } from './model-picker-items.ts';
 
 export { detectFamily, POPULAR_PROVIDERS, tierToCategoryFilter } from './model-picker-types.ts';
+
+/** Catalog data that arrives after the picker opened (see ModelPickerModal.fillCatalog). */
+export interface ModelPickerCatalogFill {
+  readonly models?: ModelDefinition[];
+  readonly providers?: string[];
+  readonly configuredViaMap?: Map<string, 'env' | 'secrets' | 'subscription' | 'anonymous'>;
+  readonly embeddingProviders?: EmbeddingProviderPickerEntry[];
+  readonly targetInfos?: ModelPickerTargetInfo[];
+}
 export type {
   BenchmarkSort,
   CapabilityFilter,
@@ -49,7 +59,7 @@ export type {
   EmbeddingProviderPickerEntry,
   GroupByMode,
   ModelFamily,
-  ModelPickerFocusPane,
+  ModelPickerFocusRegion,
   ModelPickerTarget,
   ModelPickerTargetInfo,
   PickerItem,
@@ -81,7 +91,7 @@ export class ModelPickerModal {
   public mode: PickerMode = 'model';
   /** Which config target this picker session will write to on commit. */
   public target: ModelPickerTarget = 'main';
-  public focusPane: ModelPickerFocusPane = 'items';
+  public focusRegion: ModelPickerFocusRegion = 'items';
   public targetInfos: ModelPickerTargetInfo[] = [];
   public targetIndex = 0;
   public searchFocused = false;
@@ -135,6 +145,15 @@ export class ModelPickerModal {
   /** Current group-by mode. */
   public groupBy: GroupByMode = 'provider';
 
+  /**
+   * True from the moment the picker opens on its cached catalog until the
+   * slower reads (credential sources, embedding providers, the live model
+   * lists) land through fillCatalog. The list shows a muted "loading catalog…"
+   * row meanwhile; the picker is usable the whole time.
+   */
+  public catalogLoading = false;
+  private catalogTicket = 0;
+
   private filteredModelsCache: FilteredModelsCache | null = null;
   private filteredProvidersCache: FilteredProvidersCache | null = null;
   private modelItemsCache: ModelItemsCache | null = null;
@@ -151,12 +170,12 @@ export class ModelPickerModal {
   }
 
   focusTargets(): void {
-    this.focusPane = 'targets';
+    this.focusRegion = 'targets';
     this.searchFocused = false;
   }
 
   focusItems(): void {
-    this.focusPane = 'items';
+    this.focusRegion = 'items';
   }
 
   moveTarget(delta: number): void {
@@ -294,7 +313,7 @@ export class ModelPickerModal {
     this.mode = 'model';
     this.active = true;
     this.pendingModel = null;
-    this.focusPane = 'items';
+    this.focusRegion = 'items';
     this.searchFocused = false;
     this.focusSearch();
     this.query = '';
@@ -314,7 +333,7 @@ export class ModelPickerModal {
     this.mode = 'provider';
     this.active = true;
     this.pendingModel = null;
-    this.focusPane = 'items';
+    this.focusRegion = 'items';
     this.searchFocused = false;
     this.focusSearch();
     this.query = '';
@@ -339,7 +358,7 @@ export class ModelPickerModal {
     this.mode = 'embeddingProvider';
     this.active = true;
     this.pendingModel = null;
-    this.focusPane = 'items';
+    this.focusRegion = 'items';
     this.searchFocused = false;
     this.query = '';
     const idx = providers.findIndex((provider) => provider.id === currentId);
@@ -379,12 +398,53 @@ export class ModelPickerModal {
     this.scrollOffset = 0;
   }
 
+  /** Mark the catalog as loading; the returned ticket lets fillCatalog drop a load that a close or a newer open overtook. */
+  beginCatalogLoad(): number {
+    this.catalogLoading = true;
+    return ++this.catalogTicket;
+  }
+
+  /**
+   * Land catalog data that finished loading after the picker opened. The
+   * query, filters and the selected row (matched by id) stay as they are.
+   * Returns false, changing nothing, when the picker closed or a newer load
+   * started since `ticket` was issued.
+   */
+  fillCatalog(ticket: number, fill: ModelPickerCatalogFill, done = true): boolean {
+    if (!this.active || ticket !== this.catalogTicket) return false;
+    const selectedId = this.selectedItemId();
+    if (fill.models) this.models = fill.models;
+    if (fill.providers) this.providers = fill.providers;
+    if (fill.configuredViaMap) this.configuredViaMap = fill.configuredViaMap;
+    if (fill.embeddingProviders) this.embeddingProviders = fill.embeddingProviders;
+    if (fill.targetInfos) this.targetInfos = fill.targetInfos;
+    this.clearCaches();
+    if (selectedId !== null && this.mode !== 'effort') {
+      const ids = this.mode === 'model' ? this.getFilteredModels().map((m) => m.id)
+        : this.mode === 'provider' ? this.getFilteredProviders()
+        : this.embeddingProviders.map((provider) => provider.id);
+      const idx = ids.indexOf(selectedId);
+      this.selectedIndex = idx >= 0 ? idx : Math.min(this.selectedIndex, Math.max(0, ids.length - 1));
+    }
+    if (done) this.catalogLoading = false;
+    return true;
+  }
+
+  private selectedItemId(): string | null {
+    if (this.mode === 'model') return this.getFilteredModels()[this.selectedIndex]?.id ?? null;
+    if (this.mode === 'provider') return this.getFilteredProviders()[this.selectedIndex] ?? null;
+    if (this.mode === 'embeddingProvider') return this.embeddingProviders[this.selectedIndex]?.id ?? null;
+    return null;
+  }
+
   /** Close the picker entirely. */
   close(): void {
+    this.catalogLoading = false;
+    this.catalogTicket++;
     this.active = false;
     this.mode = 'model';
     this.target = 'main';
-    this.focusPane = 'items';
+    this.focusRegion = 'items';
     this.targetInfos = [];
     this.targetIndex = 0;
     this.models = [];
@@ -407,6 +467,29 @@ export class ModelPickerModal {
 
   // ── Search helpers ─────────────────────────────────────────────────────────────────────
 
+  /** Composite benchmark score (0..1) for a model, or null when there is no benchmark data. */
+  benchmarkScore(model: ModelDefinition): number | null {
+    const record = this.benchmarkStore.getBenchmarks(model.id) ?? this.benchmarkStore.getBenchmarks(model.displayName);
+    return record ? compositeScore(record.benchmarks) : null;
+  }
+
+  /** Whether a model is pinned (pins may be recorded by id or registry key). */
+  isPinned(model: ModelDefinition): boolean {
+    return this.pinnedIds.has(model.id) || this.pinnedIds.has(model.registryKey);
+  }
+
+  /** Flip a model's pin locally (the caller persists it); returns the new state. */
+  togglePinnedLocal(model: ModelDefinition): boolean {
+    const pinned = this.isPinned(model);
+    const next = new Set(this.pinnedIds);
+    next.delete(model.id);
+    next.delete(model.registryKey);
+    if (!pinned) next.add(model.registryKey);
+    this.pinnedIds = next;
+    this.clearCaches();
+    return !pinned;
+  }
+
   /** Append a character to the search query and clamp selectedIndex. */
   appendChar(ch: string): void {
     this.query += ch;

package/src/input/notifications-modal.ts

@@ -0,0 +1,123 @@
+/**
+ * notifications-modal.ts, the notification history (/notifications, ctrl+p
+ * "notifications").
+ *
+ * ↑↓ move, Enter goes to what the notification is about (when it is about
+ * something that can be opened), x dismisses the selected one, ctrl+x clears
+ * them all. Opening the modal marks everything as seen.
+ */
+
+import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import type { SurfaceModal, SurfaceModalHost } from './surface-modal-host.ts';
+import type { SurfaceLayer } from '../renderer/surface-kit.ts';
+import { renderNotificationsModal, type NotificationsModalView } from '../renderer/notifications-modal.ts';
+import type { NotificationFeedEntry, NotificationFeed } from '../views/notifications-feed.ts';
+
+export interface NotificationsModalOptions {
+  readonly feed: NotificationFeed;
+  /**
+   * The opener for the view a notification is about (views.ts resolves the
+   * name), or null when nothing holds it.
+   */
+  readonly resolveSubject: (subject: string) => (() => void) | null;
+  /** Clock (tests pass a fixed one). */
+  readonly now?: () => number;
+}
+
+export class NotificationsModal implements SurfaceModal, NotificationsModalView {
+  readonly name = 'notifications';
+  selectedIndex = 0;
+  status: string | null = null;
+  /** Unread when the modal opened (opening marks everything seen). */
+  readonly unread: number;
+  private readonly unreadKeys: ReadonlySet<string>;
+  private readonly unsubscribe: () => void;
+
+  constructor(private readonly options: NotificationsModalOptions) {
+    const feed = options.feed;
+    this.unread = feed.unreadCount();
+    this.unreadKeys = new Set(feed.list().filter((entry) => feed.isUnread(entry)).map((entry) => entry.key));
+    feed.markAllSeen();
+    this.unsubscribe = feed.subscribe(() => {
+      this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, this.entries.length - 1));
+    });
+  }
+
+  get entries(): readonly NotificationFeedEntry[] {
+    return this.options.feed.list();
+  }
+
+  get now(): number {
+    return (this.options.now ?? Date.now)();
+  }
+
+  isUnread = (entry: NotificationFeedEntry): boolean => this.unreadKeys.has(entry.key);
+
+  onClose(): void {
+    this.unsubscribe();
+    this.options.feed.markAllSeen();
+  }
+
+  private selected(): NotificationFeedEntry | undefined {
+    return this.entries[this.selectedIndex];
+  }
+
+  private move(delta: number): void {
+    const count = this.entries.length;
+    if (count === 0) return;
+    this.selectedIndex = Math.max(0, Math.min(count - 1, this.selectedIndex + delta));
+  }
+
+  private dismissSelected(): void {
+    const entry = this.selected();
+    if (!entry) return;
+    this.options.feed.dismiss(entry.key);
+    this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, this.entries.length - 1));
+    this.status = `Dismissed "${entry.title}".`;
+  }
+
+  private goTo(host: SurfaceModalHost): void {
+    const entry = this.selected();
+    if (!entry) return;
+    if (!entry.subject) {
+      this.status = 'This notification is not about anything that can be opened.';
+      return;
+    }
+    const open = this.options.resolveSubject(entry.subject);
+    if (!open) {
+      this.status = `Nothing to open for "${entry.subject}".`;
+      return;
+    }
+    host.close(this, 'done');
+    open();
+  }
+
+  handleToken(token: InputToken, host: SurfaceModalHost): void {
+    if (token.type === 'text') {
+      if (token.value === 'x') this.dismissSelected();
+      else if (token.value === 'j') this.move(1);
+      else if (token.value === 'k') this.move(-1);
+      return;
+    }
+    if (token.type !== 'key') return;
+    const key = token.logicalName ?? '';
+    if (token.ctrl && key === 'x') {
+      const count = this.entries.length;
+      this.options.feed.clear();
+      this.selectedIndex = 0;
+      this.status = count > 0 ? `Cleared ${count} notification${count === 1 ? '' : 's'}.` : null;
+      return;
+    }
+    if (key === 'up') this.move(-1);
+    else if (key === 'down') this.move(1);
+    else if (key === 'pageup') this.move(-10);
+    else if (key === 'pagedown') this.move(10);
+    else if (key === 'home') this.selectedIndex = 0;
+    else if (key === 'end') this.selectedIndex = Math.max(0, this.entries.length - 1);
+    else if (key === 'enter') this.goTo(host);
+  }
+
+  render(screenWidth: number, screenHeight: number): SurfaceLayer {
+    return renderNotificationsModal(this, screenWidth, screenHeight);
+  }
+}

package/src/input/overlay-filter.ts

@@ -0,0 +1,26 @@
+/**
+ * overlay-filter.ts, the always-live search row state for the help and
+ * keyboard-shortcuts overlays. Their visibility and scroll offsets are plain
+ * handler fields copied through the feed context; the query lives in these
+ * long-lived objects instead, shared by reference between the input route
+ * (which types into it) and the renderer (which filters with it and records
+ * how far the list can scroll, so ↓ never runs past the end).
+ */
+
+export class OverlayFilter {
+  /** Typed filter text. */
+  public query = '';
+  /** Largest useful scroll offset for the current query, recorded by the renderer. */
+  public maxScroll = 0;
+
+  clear(): void {
+    this.query = '';
+    this.maxScroll = 0;
+  }
+}
+
+/** One filter per overlay. */
+export class OverlayFilters {
+  public readonly help = new OverlayFilter();
+  public readonly shortcuts = new OverlayFilter();
+}

package/src/input/profile-picker-modal.ts

@@ -57,6 +57,8 @@ export class ProfilePickerModal {
 
   /** Last status message (success/error feedback). */
   public statusMessage = '';
+  /** The always-live search row's query; selectedIndex indexes visibleProfiles. */
+  public query = '';
 
   public constructor(private readonly profileManager: ProfileManager) {}
 
@@ -69,6 +71,7 @@ export class ProfilePickerModal {
     this.scrollOffset = 0;
     this.statusMessage = '';
     this.deleteConfirmationTarget = null;
+    this.query = '';
     this.active = true;
   }
 
@@ -76,18 +79,44 @@ export class ProfilePickerModal {
     this.active = false;
     this.statusMessage = '';
     this.deleteConfirmationTarget = null;
+    this.query = '';
+  }
+
+  /** The profiles the search row lets through, in order. */
+  get visibleProfiles(): ProfileInfo[] {
+    const q = this.query.trim().toLowerCase();
+    if (!q) return this.profiles;
+    return this.profiles.filter((profile) => profile.name.toLowerCase().includes(q));
+  }
+
+  /** Replace the query; the selection moves to the first match and any armed delete is dropped. */
+  setQuery(query: string): void {
+    this.query = query;
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.deleteConfirmationTarget = null;
+  }
+
+  /** Esc's first level: drop an armed delete. Returns true when one was armed. */
+  cancelDeleteConfirmation(): boolean {
+    if (this.deleteConfirmationTarget === null) return false;
+    this.deleteConfirmationTarget = null;
+    this.statusMessage = '';
+    return true;
   }
 
   moveUp(): void {
-    if (this.profiles.length === 0) return;
-    this.selectedIndex = (this.selectedIndex - 1 + this.profiles.length) % this.profiles.length;
+    const n = this.visibleProfiles.length;
+    if (n === 0) return;
+    this.selectedIndex = (this.selectedIndex - 1 + n) % n;
     this._clampScroll();
     this.deleteConfirmationTarget = null;
   }
 
   moveDown(): void {
-    if (this.profiles.length === 0) return;
-    this.selectedIndex = (this.selectedIndex + 1) % this.profiles.length;
+    const n = this.visibleProfiles.length;
+    if (n === 0) return;
+    this.selectedIndex = (this.selectedIndex + 1) % n;
     this._clampScroll();
     this.deleteConfirmationTarget = null;
   }
@@ -98,7 +127,7 @@ export class ProfilePickerModal {
   }
 
   getSelected(): ProfileInfo | null {
-    return this.profiles[this.selectedIndex] ?? null;
+    return this.visibleProfiles[this.selectedIndex] ?? null;
   }
 
   /**
@@ -162,8 +191,8 @@ export class ProfilePickerModal {
         return false;
       }
       this.profiles = this.profileManager.list();
-      if (this.selectedIndex >= this.profiles.length) {
-        this.selectedIndex = Math.max(0, this.profiles.length - 1);
+      if (this.selectedIndex >= this.visibleProfiles.length) {
+        this.selectedIndex = Math.max(0, this.visibleProfiles.length - 1);
       }
       this._clampScroll();
       this.deleteConfirmationTarget = null;
@@ -216,7 +245,7 @@ export class ProfilePickerModal {
     } else if (this.selectedIndex >= this.scrollOffset + visRows) {
       this.scrollOffset = this.selectedIndex - visRows + 1;
     }
-    const maxOffset = Math.max(0, this.profiles.length - visRows);
+    const maxOffset = Math.max(0, this.visibleProfiles.length - visRows);
     this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
   }
 }

package/src/input/search.ts

@@ -146,7 +146,7 @@ export class SearchManager {
           // attempt to reveal a header-corpus hit, since there is no single
           // member to isolate it to.
           const headerHits = countOccurrences(block.rawContent.toLowerCase(), lowerQuery);
-          const allKeys = [block.collapseKey, ...block.groupMemberIndexes.map((idx) => `msg_${idx}`)];
+          const allKeys = [block.collapseKey, ...block.groupMemberIndexes.map((idx, k) => block.groupMemberKeys?.[k] ?? `msg_${idx}`)];
           for (let i = 0; i < headerHits; i++) {
             hiddenMatches.push({
               line: block.startLine, col: 0, length: query.length,
@@ -159,10 +159,10 @@ export class SearchManager {
             // whole message array and search() runs on every keystroke, so a
             // per-member read would stall typing outright.
             const snapshot = conversationManager.getMessageSnapshot();
-            for (const memberIdx of block.groupMemberIndexes) {
+            for (const [k, memberIdx] of block.groupMemberIndexes.entries()) {
               const content = snapshot[memberIdx]?.content;
               if (typeof content !== 'string') continue;
-              const memberKey = `msg_${memberIdx}`;
+              const memberKey = block.groupMemberKeys?.[k] ?? `msg_${memberIdx}`;
               const memberHits = countOccurrences(content.toLowerCase(), lowerQuery);
               for (let i = 0; i < memberHits; i++) {
                 hiddenMatches.push({

package/src/input/selection-modal-queue.ts

@@ -40,6 +40,8 @@ export interface SelectionOpenOpts {
   allowSearch?: boolean;
   customActions?: Map<string, SelectionAction>;
   primaryVerbLabel?: string;
+  /** Called with the highlighted row whenever the cursor lands on a different row (live preview). */
+  onHighlight?: (item: SelectionItem | null) => void;
 }
 
 export interface PendingSelectionRequest {