@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/renderer/conversation-overlays.ts

@@ -8,11 +8,9 @@ import { renderModelWorkspace } from './model-workspace.ts';
 import { renderSelectionModalOverlay } from './selection-modal-overlay.ts';
 import { renderSearchOverlay } from './search-overlay.ts';
 import { renderHistorySearchOverlay } from './history-search-overlay.ts';
-import { renderProcessModal } from './process-modal.ts';
-import { renderAgentDetailModal } from './agent-detail-modal.ts';
-import { renderLiveTailModal } from './live-tail-modal.ts';
 import { renderContextInspector } from './context-inspector.ts';
 import { renderSettingsModal } from './settings-modal.ts';
+import { renderConfigModal } from './config-modal.ts';
 import { renderMcpWorkspace } from './mcp-workspace.ts';
 import { renderSessionPickerModal } from './session-picker-modal.ts';
 import { renderProfilePickerModal } from './profile-picker-modal.ts';
@@ -78,20 +76,9 @@ export function applyConversationOverlays(
     next.push(...renderHistorySearchOverlay(input.historySearch, conversationWidth));
   }
 
-  if (!fullscreenClaimed && input.processModal.active) {
-    const lines = renderProcessModal(input.processModal, conversationWidth, viewportHeight);
-    next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
-  }
-
-  if (!fullscreenClaimed && input.agentDetailModal.active) {
-    const lines = renderAgentDetailModal(input.agentDetailModal, conversationWidth, viewportHeight);
-    next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
-  }
-
-  if (!fullscreenClaimed && input.liveTailModal.active) {
-    const lines = renderLiveTailModal(input.liveTailModal, conversationWidth, viewportHeight);
-    next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
-  }
+  // W6.1 retirement: the process, agent-detail, and live-tail modal overlays
+  // were removed with those modals — F2 now opens the Fleet panel, which
+  // subsumes the live process tree.
 
   if (!fullscreenClaimed && input.contextInspectorModal.active) {
     const lines = renderContextInspector(conversation, conversationWidth, viewportHeight, contextWindow);
@@ -104,6 +91,12 @@ export function applyConversationOverlays(
     fullscreenClaimed = true;
   }
 
+  if (!fullscreenClaimed && input.configModal.active) {
+    const lines = renderConfigModal(input.configModal, conversationWidth, viewportHeight);
+    next = replaceViewportWithOverlay(lines, conversationWidth, viewportHeight);
+    fullscreenClaimed = true;
+  }
+
   if (input.mcpWorkspace.active) {
     const lines = renderMcpWorkspace(input.mcpWorkspace, conversationWidth, viewportHeight);
     next = replaceViewportWithOverlay(lines, conversationWidth, viewportHeight);

package/src/renderer/fleet-tab-strip.ts

@@ -0,0 +1,56 @@
+// ---------------------------------------------------------------------------
+// fleet-tab-strip.ts
+//
+// Wave-3 (W3.1 Part C3) — renders FleetPanel's session-tab strip by reusing
+// renderTabStrip exactly as panel-workspace-bar.ts does for the workspace
+// tab bar. Deliberately a SEPARATE, visually distinct strip from the
+// workspace bar: workspace tabs switch PANELS, fleet session tabs switch
+// ATTACHED PROCESSES within one panel — conflating their styling would blur
+// that distinction for the operator.
+// ---------------------------------------------------------------------------
+
+import type { Line } from '../types/grid.ts';
+import type { FleetTabsState } from '../panels/fleet-tabs.ts';
+import { renderTabStrip, type TabHitRegion } from './tab-strip.ts';
+import { UI_TONES } from './ui-primitives.ts';
+
+const ACTIVE_FG = UI_TONES.fg.primary;
+const ACTIVE_BG = UI_TONES.bg.selected;
+const INACTIVE_FG = UI_TONES.fg.muted;
+const SEPARATOR_FG = UI_TONES.fg.dim;
+const LABEL_FG = UI_TONES.fg.secondary;
+
+/**
+ * Render the fleet session-tab strip, or `null` when there are no attached
+ * tabs — the panel omits the strip entirely in that case (root-tab-only),
+ * which is what keeps the pre-Wave-3 fleet-panel goldens byte-identical.
+ */
+export function renderFleetTabStrip(
+  state: FleetTabsState,
+  width: number,
+  onLayout?: (regions: readonly TabHitRegion[]) => void,
+): Line | null {
+  if (state.tabs.length === 0) return null;
+  return renderTabStrip({
+    width,
+    onLayout,
+    tabs: [
+      { label: 'Tree', active: state.activeTabIndex === 0 },
+      ...state.tabs.map((tab, index) => ({
+        label: tab.label,
+        active: state.activeTabIndex === index + 1,
+      })),
+    ],
+    prefixLabel: ' SESSIONS ',
+    style: {
+      activeFg: ACTIVE_FG,
+      activeBg: ACTIVE_BG,
+      activeBold: true,
+      inactiveFg: INACTIVE_FG,
+      separatorFg: SEPARATOR_FG,
+      labelFg: LABEL_FG,
+      overflowFg: SEPARATOR_FG,
+      trailingFg: INACTIVE_FG,
+    },
+  });
+}

package/src/renderer/footer-tips.ts

@@ -24,10 +24,22 @@ export function isAgentActive(composerStatus: string | undefined): boolean {
   return composerStatus !== undefined && ACTIVE_TURN_STATUSES.has(composerStatus);
 }
 
-const TIP_PANELS = 'Ctrl+P panels';
-const TIP_PROCESSES = 'F2 processes';
+// UX-C: Ctrl+P is a TOGGLE (open+focus when nothing is open or unfocused,
+// hide when the workspace already has focus — see openPanelPicker in
+// shell/ui-openers.ts). The bare noun 'panels' undersold that; naming the verb
+// keeps the tip honest about what the chord actually does.
+const TIP_PANELS = 'Ctrl+P toggle panels';
+// W6.2 e: F2 now opens the Fleet panel (the process modal was retired), so the
+// tip names 'fleet', not 'processes'.
+const TIP_PROCESSES = 'F2 fleet';
 const TIP_HELP = '? help';
-const TIP_QUIT = 'Ctrl+C quit';
+// W6.2 f: an empty-composer Ctrl+C does NOT quit on the first press — it arms a
+// ~1s "press again to exit" confirm, and only a SECOND Ctrl+C within that window
+// exits (an intentional accidental-exit guard). The old 'Ctrl+C quit' tip
+// implied a single press quits, so two presses seconds apart appeared to do
+// nothing. 'Ctrl+C x2 quit' matches the real double-press contract (and the
+// help overlay's "Ctrl+C x2  Exit" row).
+const TIP_QUIT = 'Ctrl+C x2 quit';
 
 /**
  * Build the footer discoverability tip. Segments join with the shared middle

package/src/renderer/fullscreen-primitives.ts

@@ -2,30 +2,40 @@ import type { Line } from '../types/grid.ts';
 import { createEmptyLine, createStyledCell } from '../types/grid.ts';
 import { getDisplayWidth } from '../utils/terminal-width.ts';
 import { GLYPHS } from './ui-primitives.ts';
-import { resolveUiTones } from './theme.ts';
+import { activeUiTones, registerThemeRefresh } from './theme.ts';
 
-// FULLSCREEN_PALETTE is built from the mode-resolved chrome tones
-// (resolveUiTones) rather than the static UI_TONES constant — WO-001 single
-// read path. Mode is fixed to 'dark' until the terminal-bg-probe lands.
-const TONES = resolveUiTones('dark');
+// Built from the mode-resolved chrome tones (activeUiTones) and rebuilt IN PLACE
+// on a mode flip via the registered refresher (read by reference across the
+// fullscreen workspace surfaces — see theme.ts's active-mode runtime note).
+function buildFullscreenPalette(): Record<string, string> {
+  const t = activeUiTones();
+  return {
+    border: t.border,
+    title: t.accent.browser,
+    subtitle: t.accent.conversation,
+    text: t.fg.primary,
+    muted: t.fg.muted,
+    dim: t.border,
+    selectedBg: t.bg.selected,
+    categoryBg: t.bg.section,
+    contextBg: t.bg.surface,
+    controlsBg: t.bg.base,
+    footerBg: t.bg.footer,
+    good: t.state.good,
+    warn: t.state.warn,
+    bad: t.state.bad,
+    info: t.state.info,
+  };
+}
 
-export const FULLSCREEN_PALETTE = {
-  border: TONES.border,
-  title: TONES.accent.browser,
-  subtitle: TONES.accent.conversation,
-  text: TONES.fg.primary,
-  muted: TONES.fg.muted,
-  dim: TONES.border,
-  selectedBg: TONES.bg.selected,
-  categoryBg: TONES.bg.section,
-  contextBg: TONES.bg.surface,
-  controlsBg: TONES.bg.base,
-  footerBg: TONES.bg.footer,
-  good: TONES.state.good,
-  warn: TONES.state.warn,
-  bad: TONES.state.bad,
-  info: TONES.state.info,
-} as const;
+export const FULLSCREEN_PALETTE = buildFullscreenPalette() as {
+  readonly border: string; readonly title: string; readonly subtitle: string;
+  readonly text: string; readonly muted: string; readonly dim: string;
+  readonly selectedBg: string; readonly categoryBg: string; readonly contextBg: string;
+  readonly controlsBg: string; readonly footerBg: string; readonly good: string;
+  readonly warn: string; readonly bad: string; readonly info: string;
+};
+registerThemeRefresh(() => Object.assign(FULLSCREEN_PALETTE as Record<string, string>, buildFullscreenPalette()));
 
 export type FullscreenTextStyle = Partial<Omit<Line[number], 'char'>>;
 

package/src/renderer/git-status.ts

@@ -24,6 +24,7 @@ export class GitStatusProvider {
   private lastFetch = 0;
   private readonly ttlMs = 2000;
   private fetching = false;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
 
   constructor(private readonly workingDirectory: string) {}
 
@@ -53,6 +54,45 @@ export class GitStatusProvider {
     return this.cache;
   }
 
+  /**
+   * Start a lightweight live-repo-state poll. Mirrors DiffPanel's principle of
+   * never trusting a cached "is this a repo" flag (see diff-panel.ts
+   * showGitDiff/showFileDiffs/showStagedDiff, all gated on a fresh
+   * GitService.isGitRepo() check) but amortizes the cost for the header: the
+   * cheap synchronous isGitRepo() spawn runs every tick; the heavier async
+   * status()+branch() fetch (this.refresh()) only runs when that boolean
+   * actually flips — e.g. an external `git init`, or `.git` removed.
+   */
+  startPolling(intervalMs: number, onChange: (info: GitHeaderInfo) => void): void {
+    if (this.pollTimer !== null) return;
+    const checkIsRepo = (): boolean | null => {
+      try {
+        return GitService.isGitRepo(this.workingDirectory);
+      } catch (err) {
+        logger.debug('GitStatusProvider: isGitRepo poll check failed', { error: summarizeError(err) });
+        return null;
+      }
+    };
+    let lastKnownIsRepo = checkIsRepo();
+    this.pollTimer = setInterval(() => {
+      const isRepoNow = checkIsRepo();
+      if (isRepoNow !== null && isRepoNow !== lastKnownIsRepo) {
+        lastKnownIsRepo = isRepoNow;
+        this.refresh().then(onChange).catch((err) => {
+          logger.debug('GitStatusProvider: poll-triggered refresh failed', { error: summarizeError(err) });
+        });
+      }
+    }, intervalMs);
+  }
+
+  /** Stop the live-repo-state poll started by startPolling(). No-op if not polling. */
+  stopPolling(): void {
+    if (this.pollTimer !== null) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+
   private async _fetch(): Promise<void> {
     if (this.fetching) return;
     this.fetching = true;
@@ -70,7 +110,9 @@ export class GitStatusProvider {
         statusResult.conflicted.length > 0 ||
         statusResult.not_added.length > 0;
       this.cache = {
-        branch: branchResult.current || '?',
+        // Empty `current` means an unborn HEAD — a repo with no commits yet.
+        // Show "new" instead of an unfriendly "?" for that first-run case. (5a)
+        branch: branchResult.current || 'new',
         dirty,
         ahead: statusResult.ahead ?? 0,
         behind: statusResult.behind ?? 0,

package/src/renderer/help-overlay.ts

@@ -289,7 +289,7 @@ export function renderShortcutsOverlay(
     row(kb('block-copy'), 'Copy block to clipboard'),
     row(kb('block-save'), 'Save block to file'),
     row(kb('copy-selection'), 'Copy selection'),
-    row('F2', 'Process monitor'),
+    row('F2', 'Open the Fleet panel'),
     row('?', 'Help overlay'),
     row(`${kb('clear-cancel')} x2`, 'Exit'),
     '',
@@ -303,7 +303,7 @@ export function renderShortcutsOverlay(
     row(kb('panel-focus-toggle'), 'Swap focus between top / bottom pane'),
     row(kb('panel-close'), 'Close active panel'),
     row(kb('panel-close-all'), 'Close all panels'),
-    row(kb('panel-ops'), 'Open the Ops Control panel'),
+    row(kb('panel-ops'), 'Open and focus the Fleet panel'),
     '',
     '  In-Panel Controls',
     '  ' + '\u2500'.repeat(40),

package/src/renderer/layout.ts

@@ -20,10 +20,6 @@ export const TOOL_STATUS = {
   TOOL_NAME_PAD: 8,
 } as const;
 
-export const COLORS = {
-  DIM_TEXT: UI_TONES.fg.dim,
-} as const;
-
 export const BORDERS = {
   THINKING: { char: '▌', color: UI_TONES.state.reasoning },
   ERROR:    { char: '▌', color: UI_TONES.state.bad },

package/src/renderer/markdown.ts

@@ -3,10 +3,11 @@ import { UIFactory } from './ui-factory.ts';
 import { renderCodeBlock } from './code-block.ts';
 import { getDisplayWidth } from '../utils/terminal-width.ts';
 import { LAYOUT } from './layout.ts';
-import { DARK_THEME } from './theme.ts';
+import { activeTheme } from './theme.ts';
 
-/** Module-level resolved token set (dark default; replace with resolveTheme(mode) when mode detection lands). */
-const T = DARK_THEME;
+// Transcript tokens are read live per render (const T = activeTheme() at the top
+// of each render function below) so a dark→light repaint re-resolves with no
+// module reload. See theme.ts's active-mode runtime note.
 
 export interface MarkdownRenderOptions {
   codeBlockLineNumbers?: boolean;
@@ -62,6 +63,7 @@ export function renderMarkdownTracked(
   width: number,
   options: MarkdownRenderOptions = {},
 ): { lines: ReturnType<typeof renderMarkdown>; codeBlocks: CodeBlockSpan[] } {
+  const T = activeTheme();
   const lines: ReturnType<typeof renderMarkdown> = [];
   const codeBlocks: CodeBlockSpan[] = [];
   const rawLines = text.split('\n');
@@ -236,6 +238,7 @@ function stripMarkdown(text: string): string {
  * truncates long content, and renders with proper styling.
  */
 function renderTable(rows: string[], width: number, indent: number): Line[] {
+  const T = activeTheme();
   const lines: Line[] = [];
 
   // Parse rows into cells, skip separator
@@ -542,6 +545,7 @@ function compositeInlineLine(
   prefixStyle: Partial<Cell>,
   textStartX: number
 ): Line[] {
+  const T = activeTheme();
   const lines: Line[] = [];
 
   // Flatten tokens to [char, style] pairs

package/src/renderer/modal-factory.ts

@@ -9,7 +9,7 @@ import {
 } from './overlay-box.ts';
 import { getOverlayMaxWidth } from './overlay-viewport.ts';
 import { GLYPHS } from './ui-primitives.ts';
-import { resolveUiTones } from './theme.ts';
+import { activeUiTones, registerThemeRefresh } from './theme.ts';
 import { HINT_SEPARATOR } from './hint-grammar.ts';
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
@@ -92,25 +92,30 @@ export interface ModalConfig {
 
 // ── Defaults ─────────────────────────────────────────────────────────────────
 
-// DEFAULT_STYLE is built from the mode-resolved chrome tones (resolveUiTones)
-// rather than the static UI_TONES constant — WO-001 single read path. Mode is
-// fixed to 'dark' until the terminal-bg-probe lands.
-const TONES = resolveUiTones('dark');
-
-const DEFAULT_STYLE: Required<ModalStyle> = {
-  titleFg: TONES.fg.primary,
-  borderFg: TONES.fg.dim,
-  hintFg: TONES.fg.muted,
-  selectedFg: TONES.fg.primary,
-  selectedBg: TONES.bg.selected,
-  textFg: TONES.fg.primary,
-  accentFg: TONES.state.info,
-  titleRowFg: TONES.fg.secondary,
-  titleBg: TONES.bg.title,
-  sectionBg: TONES.bg.section,
-  inputBg: TONES.bg.input,
-  surfaceBg: TONES.bg.surface,
-};
+// DEFAULT_STYLE is built from the mode-resolved chrome tones (activeUiTones) and
+// rebuilt IN PLACE on a mode flip via the registered refresher. createModal reads
+// it per call via `{ ...DEFAULT_STYLE, ...config.style }`, so the in-place rebuild
+// reaches every modal — see theme.ts's active-mode runtime note.
+function buildDefaultModalStyle(): Required<ModalStyle> {
+  const t = activeUiTones();
+  return {
+    titleFg: t.fg.primary,
+    borderFg: t.fg.dim,
+    hintFg: t.fg.muted,
+    selectedFg: t.fg.primary,
+    selectedBg: t.bg.selected,
+    textFg: t.fg.primary,
+    accentFg: t.state.info,
+    titleRowFg: t.fg.secondary,
+    titleBg: t.bg.title,
+    sectionBg: t.bg.section,
+    inputBg: t.bg.input,
+    surfaceBg: t.bg.surface,
+  };
+}
+
+const DEFAULT_STYLE: Required<ModalStyle> = buildDefaultModalStyle();
+registerThemeRefresh(() => Object.assign(DEFAULT_STYLE, buildDefaultModalStyle()));
 
 // ── ModalFactory ─────────────────────────────────────────────────────────────
 

package/src/renderer/model-workspace.ts

@@ -124,6 +124,10 @@ function modelKey(model: ModelDefinition): string {
 
 function targetSummary(info: ModelPickerTargetInfo): string {
   if (!info.enabled) return 'disabled';
+  // 'embeddings' has no model concept — configuredNote carries the honest
+  // provider id + dimensions + configured-state summary instead of a
+  // computed provider:model route (which would print a phantom "model:").
+  if (info.configuredNote) return info.configuredNote;
   const route = formatRoute(info.provider, info.model);
   if (info.inherited) return `inherits ${route}`;
   return route;
@@ -145,6 +149,7 @@ function targetLabelFor(target: string): string {
   if (target === 'helper') return 'Helper Model';
   if (target === 'tool') return 'Tool LLM';
   if (target === 'tts') return 'TTS LLM';
+  if (target === 'embeddings') return 'Embeddings';
   return 'Main Chat';
 }
 
@@ -174,10 +179,25 @@ function detailLines(picker: ModelPickerModal, width: number): string[] {
     }
   } else if (picker.mode === 'effort') {
     lines.push(`Reasoning effort applies to the main chat model. Select the default effort for this model.`);
+  } else if (picker.mode === 'embeddingProvider') {
+    lines.push('Embedding provider selection: choose the provider memory search and the code index use to embed content.');
+    const selectedEmbedding = picker.embeddingProviders[picker.selectedIndex];
+    if (selectedEmbedding) {
+      const status = selectedEmbedding.configured ? 'configured' : 'unconfigured';
+      lines.push(`Selected: ${selectedEmbedding.id} | ${selectedEmbedding.dimensions} dimensions | ${status}${selectedEmbedding.detail ? ` | ${selectedEmbedding.detail}` : ''}`);
+    }
   } else {
     lines.push(`Context cap overrides the detected local-model context window for this selection.`);
   }
-  const filterText = `Search: ${picker.query || '(none)'} | Price: ${picker.categoryFilter} | Capability: ${picker.capabilityFilter} | Group: ${picker.groupBy} | Available only: ${picker.availableOnly ? 'yes' : 'no'}`;
+  // W3-T2: a visible cursor glyph on the query itself when search is focused —
+  // the only prior affordance was a footer-hint text swap ('/ search' vs.
+  // 'Typing filters search...'), buried at the end of a long hint line and
+  // easy to miss (confirmed via live tmux repro). This puts the "you are
+  // typing here" signal where the eye already is, on the Search: value.
+  const searchDisplay = picker.query.length > 0
+    ? `${picker.query}${picker.searchFocused ? GLYPHS.surface.cursor : ''}`
+    : (picker.searchFocused ? GLYPHS.surface.cursor : '(none)');
+  const filterText = `Search: ${searchDisplay} | Price: ${picker.categoryFilter} | Capability: ${picker.capabilityFilter} | Group: ${picker.groupBy} | Available only: ${picker.availableOnly ? 'yes' : 'no'}`;
   lines.push(filterText);
   return lines.flatMap((line) => wrapText(line, Math.max(1, width)));
 }
@@ -288,6 +308,28 @@ function renderContextCapRows(picker: ModelPickerModal, lines: Line[], rows: num
   }
 }
 
+function renderEmbeddingProviderRows(picker: ModelPickerModal, lines: Line[], rows: number, startX: number, width: number): void {
+  const providers = picker.embeddingProviders;
+  const { start, end } = stableWindow(providers.length, picker.selectedIndex, rows);
+  for (let visibleRow = 0; visibleRow < rows; visibleRow += 1) {
+    const absolute = start + visibleRow;
+    const provider = providers[absolute];
+    const line = lines[visibleRow]!;
+    if (!provider) continue;
+    const selected = absolute === picker.selectedIndex;
+    const bg = selected ? PALETTE.selectedBg : PALETTE.bodyBg;
+    fillRange(line, startX, startX + width - 1, bg);
+    const marker = selected ? (picker.focusPane === 'items' ? GLYPHS.navigation.selected : '•') : ' ';
+    const status = provider.configured ? 'configured' : 'unconfigured';
+    writeText(line, startX + 1, width, padDisplay(marker, 2), { fg: PALETTE.text, bg, bold: selected });
+    writeText(line, startX + 3, Math.max(0, width - 30), padDisplay(provider.label, Math.max(0, width - 30)), { fg: selected ? PALETTE.text : PALETTE.muted, bg, bold: selected });
+    writeText(line, startX + Math.max(4, width - 25), 12, padDisplay(`${provider.dimensions}d`, 12), { fg: PALETTE.dim, bg });
+    writeText(line, startX + Math.max(4, width - 13), 12, padDisplay(status, 12), { fg: provider.configured ? PALETTE.good : PALETTE.warn, bg });
+  }
+  if (start > 0 && lines[0]) writeText(lines[0], startX + 1, width - 2, `${GLYPHS.navigation.moreAbove} ${start} more provider(s) above`, { fg: PALETTE.dim, bg: PALETTE.bodyBg, dim: true });
+  if (end < providers.length && lines[rows - 1]) writeText(lines[rows - 1]!, startX + 1, width - 2, `${GLYPHS.navigation.moreBelow} ${providers.length - end} more provider(s) below`, { fg: PALETTE.dim, bg: PALETTE.bodyBg, dim: true });
+}
+
 function writeTableHeader(line: Line, picker: ModelPickerModal, startX: number, width: number): void {
   fillRange(line, startX, startX + width - 1, PALETTE.footerBg);
   const style = { fg: PALETTE.muted, bg: PALETTE.footerBg, bold: true };
@@ -303,6 +345,10 @@ function writeTableHeader(line: Line, picker: ModelPickerModal, startX: number,
     writeText(line, startX + 1, width - 2, 'Context cap input', style);
     return;
   }
+  if (picker.mode === 'embeddingProvider') {
+    writeText(line, startX + 1, width - 2, 'Embedding provider                Dimensions   Status', style);
+    return;
+  }
   const providerW = clamp(Math.floor(width * 0.14), 10, 18);
   const ctxW = 8;
   const tierW = 8;
@@ -337,7 +383,7 @@ export function renderModelWorkspace(picker: ModelPickerModal, width: number, vi
   const header = contentLine(safeWidth, PALETTE.footerBg);
   writeText(header, 2, targetW - 2, 'Targets', { fg: PALETTE.subtitle, bold: true, bg: PALETTE.footerBg });
   drawVertical(header, targetW, PALETTE.footerBg);
-  const modeLabel = picker.mode === 'provider' ? 'Provider list' : picker.mode === 'model' ? 'Model list' : picker.mode === 'effort' ? 'Reasoning effort' : 'Context cap';
+  const modeLabel = picker.mode === 'provider' ? 'Provider list' : picker.mode === 'model' ? 'Model list' : picker.mode === 'effort' ? 'Reasoning effort' : picker.mode === 'embeddingProvider' ? 'Embedding providers' : 'Context cap';
   writeText(header, contentX + 1, contentW - 2, `${modeLabel}  •  ${picker.getItemCount()} item(s)`, { fg: PALETTE.subtitle, bold: true, bg: PALETTE.footerBg });
   lines.push(header);
 
@@ -380,14 +426,23 @@ export function renderModelWorkspace(picker: ModelPickerModal, width: number, vi
     renderModelRows(picker, listLines, listLines.length, contentX, contentW - 1);
   } else if (picker.mode === 'contextCap') {
     renderContextCapRows(picker, listLines, listLines.length, contentX, contentW - 1);
+  } else if (picker.mode === 'embeddingProvider') {
+    renderEmbeddingProviderRows(picker, listLines, listLines.length, contentX, contentW - 1);
   } else {
     renderEffortRows(picker, listLines, listLines.length, contentX, contentW - 1);
   }
 
   const footer = contentLine(safeWidth, PALETTE.footerBg);
   const targetHint = picker.focusPane === 'targets' ? 'Focus targets' : 'Focus list';
-  const searchHint = picker.searchFocused ? 'Typing filters search; Esc clears search' : '/ search';
-  const hints = `${targetHint} • Up/Down navigate • Left/Right pane • Enter select • ${searchHint} • Tab price • C caps • A available • B benchmark • G group • Esc close`;
+  // W3 Finding 2: while search is focused, every printable key (including
+  // c/a/b/g) types into the query — handler-picker-routes.ts guards those
+  // single-key shortcuts with `!searchFocused` (Up/Down blur search first).
+  // Advertising them here regardless of focus state was a footer that lied
+  // about what the keys currently do. Tab still cycles price in both states
+  // (its handler has no searchFocused guard), so it stays in both hint sets.
+  const hints = picker.searchFocused
+    ? `${targetHint} • Typing filters search; Esc clears search • Down: list shortcuts • Tab price • Esc close`
+    : `${targetHint} • Up/Down navigate • Left/Right pane • Enter select • / search • Tab price • C caps • A available • B benchmark • G group • Esc close`;
   writeText(footer, 2, safeWidth - 4, hints, { fg: PALETTE.muted, bg: PALETTE.footerBg });
   lines.push(footer);
   lines.push(borderLine(safeWidth, GLYPHS.frame.bottomLeft, GLYPHS.frame.horizontal, GLYPHS.frame.bottomRight));
@@ -432,6 +487,8 @@ function getRenderCacheKey(picker: ModelPickerModal, width: number, viewportHeig
     base.push(objectId(picker.effortLevels), picker.effortLevels.join('\u001f'), picker.pendingModel?.registryKey ?? picker.pendingModel?.id ?? '');
   } else if (picker.mode === 'contextCap') {
     base.push(picker.contextCapQuery, picker.contextCapPendingModel?.registryKey ?? picker.contextCapPendingModel?.id ?? '');
+  } else if (picker.mode === 'embeddingProvider') {
+    base.push(objectId(picker.embeddingProviders), picker.embeddingProviders.length);
   }
 
   return base.join('\u001e');
@@ -467,6 +524,7 @@ function keyForTargets(values: readonly ModelPickerTargetInfo[]): string {
       entry.model,
       entry.enabled ? 1 : 0,
       entry.inherited ? 1 : 0,
+      entry.configuredNote ?? '',
     ].join('\u001d'))
     .join('\u001f');
 }

package/src/renderer/overlay-box.ts

@@ -1,14 +1,9 @@
 import { createStyledCell, type Line } from '../types/grid.ts';
 import { getOverlayMaxWidth } from './overlay-viewport.ts';
 import { GLYPHS } from './ui-primitives.ts';
-import { resolveUiTones } from './theme.ts';
+import { activeUiTones, registerThemeRefresh } from './theme.ts';
 import { fillWidth, makeLine, writeText } from './fullscreen-primitives.ts';
 
-// DEFAULT_OVERLAY_PALETTE is built from the mode-resolved chrome tones
-// (resolveUiTones) rather than the static UI_TONES constant — WO-001 single
-// read path. Mode is fixed to 'dark' until the terminal-bg-probe lands.
-const TONES = resolveUiTones('dark');
-
 export interface OverlayBoxPalette {
   readonly borderFg: string;
   readonly titleFg: string;
@@ -21,17 +16,26 @@ export interface OverlayBoxPalette {
   readonly bodyBg: string;
 }
 
-export const DEFAULT_OVERLAY_PALETTE: Readonly<OverlayBoxPalette> = {
-  borderFg: TONES.fg.secondary,
-  titleFg: TONES.fg.primary,
-  bodyFg: TONES.fg.primary,
-  mutedFg: TONES.fg.dim,
-  selectedBg: TONES.bg.selected,
-  titleBg: TONES.bg.title,
-  sectionBg: TONES.bg.section,
-  inputBg: TONES.bg.input,
-  bodyBg: TONES.bg.surface,
-} as const;
+// Built from the mode-resolved chrome tones (activeUiTones) and rebuilt IN PLACE
+// on a mode flip via the registered refresher (60+ call sites read it by
+// reference — see theme.ts's active-mode runtime note).
+function buildOverlayPalette(): OverlayBoxPalette {
+  const t = activeUiTones();
+  return {
+    borderFg: t.fg.secondary,
+    titleFg: t.fg.primary,
+    bodyFg: t.fg.primary,
+    mutedFg: t.fg.dim,
+    selectedBg: t.bg.selected,
+    titleBg: t.bg.title,
+    sectionBg: t.bg.section,
+    inputBg: t.bg.input,
+    bodyBg: t.bg.surface,
+  };
+}
+
+export const DEFAULT_OVERLAY_PALETTE: Readonly<OverlayBoxPalette> = buildOverlayPalette();
+registerThemeRefresh(() => Object.assign(DEFAULT_OVERLAY_PALETTE as OverlayBoxPalette, buildOverlayPalette()));
 
 export interface OverlayBoxLayout {
   readonly margin: number;

package/src/renderer/panel-workspace-bar.ts

@@ -21,12 +21,18 @@ export function renderPanelWorkspaceBar(
   return renderTabStrip({
     width,
     onLayout,
-    tabs: tabs.map((tab) => ({
+    tabs: tabs.map((tab, i) => ({
       // tab.active = selected in its own pane (drives highlighted background).
       // tab.focused = has keyboard focus (drives brighter text / focus indicator).
       // A tab can be active-but-not-focused (selected in the unfocused pane) or
       // active-and-focused (selected in the focused pane).
-      label: `${tab.pane === 'bottom' ? 'v' : '^'} ${tab.icon} ${tab.name}${tab.focused ? ' ▸' : ''}`,
+      //
+      // A14: the pane marker uses ▲/▼ (top/bottom pane). The old '^'/'v'
+      // prefixes read as a Ctrl caret (^) implying a non-existent Ctrl+<tab>
+      // hotkey. The REAL per-tab jump key is Alt+N (panel-tab-1..9), rendered
+      // here as ⌥N for the first nine tabs so the shown affordance matches the
+      // binding (tabs past nine have no Alt+N chord, so no index is shown).
+      label: `${tab.pane === 'bottom' ? '▼' : '▲'}${i < 9 ? ` ⌥${i + 1}` : ''} ${tab.icon} ${tab.name}${tab.focused ? ' ▸' : ''}`,
       active: tab.active,
     })),
     prefixLabel: ' PANELS ',