gloomberb 0.11.2 → 0.12.0

package/src/components/command-bar/view-model.ts

@@ -21,7 +21,7 @@ export function dedupeById<T extends { id: string }>(items: T[]): T[] {
   return result;
 }
 
-export type CommandBarMode = "default" | "search" | "themes" | "plugins" | "layout" | "direct-command";
+export type CommandBarMode = "default" | "search" | "themes" | "layout" | "direct-command";
 
 export interface CommandBarModeInfo {
   kind: CommandBarMode;
@@ -36,6 +36,14 @@ export interface CommandBarSection<T> {
 
 export type CommandBarSectionOrder = "default" | "app-first" | "ranked";
 
+/** Sort positions contributed by plugin search providers, keyed by section heading. */
+export type CommandBarCategoryPriorities = ReadonlyMap<string, number>;
+
+export interface CommandBarSectionOptions {
+  sectionOrder?: CommandBarSectionOrder;
+  categoryPriorities?: CommandBarCategoryPriorities;
+}
+
 export interface CommandBarItemView {
   id: string;
   label: string;
@@ -74,8 +82,6 @@ export function resolveCommandBarMode(query: string, commandList?: Command[]): C
       return { kind: "search", badge: match.prefix, hint: t("Open security details for a ticker") };
     case "theme":
       return { kind: "themes", badge: "THEMES", hint: t("Preview with arrows, Enter to save, Esc to revert") };
-    case "plugins":
-      return { kind: "plugins", badge: "PLUGINS", hint: t("Toggle plugins without leaving the list") };
     case "layout":
       return { kind: "layout", badge: "LAYOUT", hint: t("Organize panes, history, and saved layouts") };
     default:
@@ -85,9 +91,10 @@ export function resolveCommandBarMode(query: string, commandList?: Command[]): C
 
 /**
  * A section whose every row is disabled or unselectable is an offer, not an
- * answer, so it sorts below real matches however its category is prioritized.
+ * answer, so it sorts below real matches however its category is prioritized:
+ * past the async bands (100 to 200) and the AI's lead, short of danger (900).
  */
-const OFFER_SECTION_DEMOTION = 200;
+const OFFER_SECTION_DEMOTION = 500;
 
 interface SectionSortableItem {
   category: string;
@@ -102,7 +109,7 @@ function isOfferOnlySection<T extends SectionSortableItem>(items: T[]): boolean
 
 export function buildSections<T extends SectionSortableItem>(
   items: T[],
-  options?: { sectionOrder?: CommandBarSectionOrder },
+  options?: CommandBarSectionOptions,
 ): Array<CommandBarSection<T>> {
   const sections: Array<CommandBarSection<T>> = [];
   for (const item of items) {
@@ -116,9 +123,9 @@ export function buildSections<T extends SectionSortableItem>(
   return sections
     .map((section, index) => ({ section, index }))
     .sort((a, b) => {
-      const leftPriority = getCategoryPriority(a.section.category, options?.sectionOrder)
+      const leftPriority = getCategoryPriority(a.section.category, options)
         + (isOfferOnlySection(a.section.items) ? OFFER_SECTION_DEMOTION : 0);
-      const rightPriority = getCategoryPriority(b.section.category, options?.sectionOrder)
+      const rightPriority = getCategoryPriority(b.section.category, options)
         + (isOfferOnlySection(b.section.items) ? OFFER_SECTION_DEMOTION : 0);
       const priorityDiff = leftPriority - rightPriority;
       return priorityDiff !== 0 ? priorityDiff : a.index - b.index;
@@ -133,8 +140,6 @@ export function getEmptyState(mode: CommandBarMode, query: string, searchQuery?:
         return { label: t("Type a ticker symbol"), detail: t("Open security details after resolving a ticker") };
       }
       return { label: tf('No matches for "{query}"', { query: searchQuery }), detail: t("Try a symbol, company name, or exchange variant") };
-    case "plugins":
-      return { label: t("No plugins match"), detail: query.trim() || t("Toggleable plugins will appear here") };
     case "themes":
       return { label: t("No themes match"), detail: query.trim() || t("Installed themes will appear here") };
     case "layout":
@@ -172,12 +177,36 @@ export function truncateText(text: string, width: number): string {
   return truncateToDisplayWidth(text, width);
 }
 
-function getCategoryPriority(category: string, sectionOrder: CommandBarSectionOrder = "default"): number {
+/**
+ * An exactly matching symbol is the most certain answer the terminal has, so
+ * nothing outranks it. Typing "sive" put the AI's "DES SIVE" above the SIVE row
+ * it was derived from, which is a guess sitting above the fact behind it.
+ */
+const EXACT_MATCH_SECTION_PRIORITY = -150;
+/**
+ * The AI leads the rest even though it is the slowest source (~600ms+): it
+ * translates the sentence the user typed into commands, which is the answer to
+ * what they asked when no symbol matched outright. Its Thinking placeholder
+ * reserves the rows from the start, so the arrival replaces a row instead of
+ * shifting the list.
+ */
+const ASSIST_SECTION_PRIORITY = -100;
+/**
+ * The other async sections sit below the local matches in arrival order, so
+ * each answer only ever pushes rows below itself: instruments at 100, then news
+ * at 190 and the rest of the corpus at 200 (both contributed by their provider).
+ */
+const INSTRUMENTS_SECTION_PRIORITY = 100;
+
+function getCategoryPriority(category: string, options?: CommandBarSectionOptions): number {
+  const contributed = options?.categoryPriorities?.get(category);
+  if (contributed !== undefined) return contributed;
+  const sectionOrder = options?.sectionOrder ?? "default";
   const normalized = category.trim().toLowerCase();
   if (sectionOrder === "ranked") return 0;
-  // The AI answers the question the user actually typed, so it leads the list.
-  if (normalized === "ask ai") return -100;
-  if (normalized === "exact match") return -50;
+  if (normalized === "ask ai") return ASSIST_SECTION_PRIORITY;
+  if (normalized === "exact match") return EXACT_MATCH_SECTION_PRIORITY;
+  if (normalized === "instruments") return INSTRUMENTS_SECTION_PRIORITY;
   if (sectionOrder === "app-first") {
     if (normalized === "saved") return 100;
     if (normalized === "primary listing") return 110;

package/src/components/command-bar/workflow/tickers.ts

@@ -36,6 +36,7 @@ function getTickerSearchContext(state: AppState, collectionId: string | null) {
   const activePortfolio = state.config.portfolios.find((portfolio) => portfolio.id === collectionId);
   return {
     preferBroker: true,
+    interactive: true,
     brokerId: activePortfolio?.brokerId,
     brokerInstanceId: activePortfolio?.brokerInstanceId,
   };

package/src/components/command-bar/workflow/types.ts

@@ -39,7 +39,7 @@ interface CommandBarRouteBase {
 
 interface CommandBarModeRoute extends CommandBarRouteBase {
   kind: "mode";
-  screen: "ticker-search" | "plugins" | "layout";
+  screen: "ticker-search" | "layout";
   query: string;
   selectedIdx: number;
   hoveredIdx: number | null;

package/src/components/data-table/export.test.ts

@@ -0,0 +1,21 @@
+import { expect, test } from "bun:test";
+import { EXCEL_CSV_BOM } from "../../utils/csv";
+import { createDataTableCsv } from "./export";
+
+test("exports displayed table cells and skips section headers", () => {
+  const items = [
+    { type: "section", name: "Americas", value: "" },
+    { type: "row", name: "S&P 500", value: "+1.25%" },
+  ];
+  const csv = createDataTableCsv({
+    columns: [
+      { id: "name", label: "Name", width: 20, align: "left" },
+      { id: "value", label: "Change", width: 10, align: "right" },
+    ],
+    items,
+    renderSectionHeader: (item) => item.type === "section" ? { text: item.name } : null,
+    renderCell: (item, column) => ({ text: item[column.id as "name" | "value"] }),
+  });
+
+  expect(csv).toBe(`${EXCEL_CSV_BOM}Name,Change\nS&P 500,'+1.25%`);
+});

package/src/components/data-table/export.ts

@@ -0,0 +1,21 @@
+import type { DataTableColumn, DataTableProps } from "../ui";
+import { serializeCsv } from "../../utils/csv";
+
+export function createDataTableCsv<
+  T,
+  C extends DataTableColumn = DataTableColumn,
+>({
+  columns,
+  items,
+  renderCell,
+  renderSectionHeader,
+}: Pick<DataTableProps<T, C>, "columns" | "items" | "renderCell" | "renderSectionHeader">): string {
+  const rows = items.flatMap((item, index) => {
+    if (renderSectionHeader?.(item, index)) return [];
+    return [columns.map((column) => renderCell(item, column, index, { selected: false }).text)];
+  });
+  return serializeCsv([
+    columns.map((column) => column.label),
+    ...rows,
+  ], { excelCompatible: true });
+}

package/src/components/data-table/view.test.tsx

@@ -43,7 +43,7 @@ afterEach(async () => {
   testSetup = undefined;
 });
 
-function Harness() {
+function Harness({ onCursor = () => {} }: { onCursor?: () => void }) {
   const [selectedIndex, setSelectedIndex] = useState(1);
   const [cursorIndex, setCursorIndex] = useState(1);
   const [activatedTitle, setActivatedTitle] = useState("");
@@ -64,7 +64,10 @@ function Harness() {
             selectedIndex,
             onChange: (index) => setSelectedIndex(index),
           }}
-          onCursorChange={(_row, index) => setCursorIndex(index)}
+          onCursorChange={(_row, index) => {
+            onCursor();
+            setCursorIndex(index);
+          }}
           onActivate={(row) => {
             if (row.type === "row") setActivatedTitle(row.title);
           }}
@@ -122,6 +125,7 @@ function LargeSelectionHarness({
             return { text: row.title + (index === 500 ? "" : "") };
           }}
           emptyStateTitle="No rows"
+          scrollToIndex={500}
         />
       </PaneInstanceProvider>
     </AppContext>
@@ -228,6 +232,20 @@ describe("DataTableView", () => {
     expect(testSetup.captureCharFrame()).toContain("cursor=Second row selected=First row activated=First row");
   });
 
+  test("does no cursor or scroll work when navigation is already at an edge", async () => {
+    let cursorChanges = 0;
+    testSetup = await testRender(
+      <Harness onCursor={() => { cursorChanges += 1; }} />,
+      { width: 60, height: 12 },
+    );
+
+    await renderSettled();
+    await emitKeypress({ name: "up", sequence: "\u001B[A" });
+    await renderSettled();
+
+    expect(cursorChanges).toBe(0);
+  });
+
   test("keeps selection current across repeated keypresses before the next render", async () => {
     testSetup = await testRender(<Harness />, { width: 60, height: 12 });
 
@@ -242,19 +260,40 @@ describe("DataTableView", () => {
     expect(testSetup.captureCharFrame()).toContain("selected=Third row activated=Third row");
   });
 
-  test("does not scan every row when the selected index is explicit", async () => {
-    let isSelectedCalls = 0;
+  test("keeps the immediate cursor visible while a controlled selection is deferred", async () => {
+    testSetup = await testRender(
+      <LargeSelectionHarness onIsSelected={() => {}} />,
+      { width: 60, height: 12 },
+    );
+
+    await renderSettled();
+    await emitKeypressBatch(Array.from({ length: 30 }, () => ({
+      name: "down",
+      sequence: "\u001B[B",
+    })));
+    await renderSettled();
+
+    expect(testSetup.captureCharFrame()).toContain("Row 530");
+  });
+
+  test("renders only the visible rows and the rows changed by navigation", async () => {
+    let renderedCells = 0;
     testSetup = await testRender(
       <LargeSelectionHarness
         onIsSelected={() => {
-          isSelectedCalls += 1;
+          renderedCells += 1;
         }}
       />,
       { width: 60, height: 12 },
     );
 
+    await renderSettled();
+    expect(renderedCells).toBeLessThan(150);
+
+    const beforeNavigation = renderedCells;
+    await emitKeypress({ name: "down", sequence: "\u001B[B" });
     await renderSettled();
 
-    expect(isSelectedCalls).toBeLessThan(150);
+    expect(renderedCells - beforeNavigation).toBeLessThanOrEqual(4);
   });
 });

package/src/components/data-table/view.tsx

@@ -80,6 +80,11 @@ export interface DataTableViewProps<
   focused?: boolean;
   selection: DataTableSelection<T>;
   onActivate?: (item: T, index: number) => void;
+  /**
+   * Fires immediately as the lightweight visual cursor moves. Expensive detail
+   * work and persisted selection belong in selection.onChange, which is
+   * coalesced across keyboard repeats.
+   */
   onCursorChange?: (
     item: T,
     index: number,
@@ -198,20 +203,54 @@ export function DataTableView<
   effectiveSelectedIndexRef.current = effectiveSelectedIndex;
   const [selectionScrollVersion, setSelectionScrollVersion] = useState(0);
   const [selectionScrollTarget, setSelectionScrollTarget] = useState<number | null>(null);
+  const selectionScrollTargetRef = useRef<number | null>(null);
   const lastExternalSelectionScrollRef = useRef<{
     kind: DataTableSelection<T>["kind"];
     key: string | number | null;
     resolved: boolean;
   } | null>(null);
-  const effectiveScrollToIndex = scrollToIndex !== undefined
+  const lastControlledScrollRequestRef = useRef({
+    index: scrollToIndex,
+    version: scrollToIndexVersion,
+  });
+  const controlledScrollRequestChanged = scrollToIndex !== undefined
+    && (
+      lastControlledScrollRequestRef.current.index !== scrollToIndex
+      || lastControlledScrollRequestRef.current.version !== scrollToIndexVersion
+    );
+  const effectiveScrollToIndex = controlledScrollRequestChanged
     ? scrollToIndex
-    : selectionScrollTarget;
+    : selectionScrollTarget ?? scrollToIndex;
 
   const requestSelectionScroll = useCallback((index: number) => {
-    if (scrollToIndex !== undefined || index < 0) return;
+    if (index < 0 || selectionScrollTargetRef.current === index) return;
+    const scrollBox = effectiveScrollRef.current;
+    const viewportHeight = scrollBox?.viewport?.height;
+    const scrollTop = scrollBox?.scrollTop;
+    if (
+      typeof viewportHeight === "number"
+      && typeof scrollTop === "number"
+      && index >= Math.floor(scrollTop)
+      && index < Math.floor(scrollTop) + Math.max(1, Math.floor(viewportHeight))
+    ) return;
+    selectionScrollTargetRef.current = index;
     setSelectionScrollTarget(index);
     setSelectionScrollVersion((current) => current + 1);
-  }, [scrollToIndex]);
+  }, [effectiveScrollRef]);
+  const clearSelectionScrollTarget = useCallback(() => {
+    if (selectionScrollTargetRef.current === null) return;
+    selectionScrollTargetRef.current = null;
+    setSelectionScrollTarget(null);
+  }, []);
+
+  useEffect(() => {
+    lastControlledScrollRequestRef.current = {
+      index: scrollToIndex,
+      version: scrollToIndexVersion,
+    };
+    if (scrollToIndex === undefined) return;
+    clearSelectionScrollTarget();
+  }, [clearSelectionScrollTarget, scrollToIndex, scrollToIndexVersion]);
 
   const clearPendingCommit = useCallback(() => {
     if (pendingCommitTimerRef.current) {
@@ -220,7 +259,8 @@ export function DataTableView<
     }
     pendingCommitRef.current = false;
     pendingCommitTargetRef.current = null;
-  }, []);
+    clearSelectionScrollTarget();
+  }, [clearSelectionScrollTarget]);
 
   useEffect(() => {
     if (selection.kind === "none") {
@@ -268,7 +308,7 @@ export function DataTableView<
     lastExternalSelectionScrollRef.current = current;
 
     if (selection.kind === "none") {
-      if (scrollToIndex === undefined) setSelectionScrollTarget(null);
+      clearSelectionScrollTarget();
       return;
     }
     if (effectiveSelectedIndex < 0) return;
@@ -281,6 +321,7 @@ export function DataTableView<
       requestSelectionScroll(effectiveSelectedIndex);
     }
   }, [
+    clearSelectionScrollTarget,
     effectiveSelectedIndex,
     requestSelectionScroll,
     scrollToIndex,
@@ -360,9 +401,10 @@ export function DataTableView<
       pendingCommitRef.current = false;
       const pendingTarget = pendingCommitTargetRef.current;
       pendingCommitTargetRef.current = null;
+      clearSelectionScrollTarget();
       commitTarget(pendingTarget, "keyboard");
     }, DATA_TABLE_SELECTION_COMMIT_DELAY_MS);
-  }, [commitTarget, getCommitTarget, selection.kind]);
+  }, [clearSelectionScrollTarget, commitTarget, getCommitTarget, selection.kind]);
 
   const updateCursorIndex = useCallback((
     index: number,
@@ -375,13 +417,17 @@ export function DataTableView<
     if (index < 0 || index >= tableProps.items.length) return;
     const item = tableProps.items[index]!;
     if (isNavigable && !isNavigable(item, index)) return;
-    effectiveSelectedIndexRef.current = index;
-    setCursorIndex(index);
     const reason = options.reason ?? (options.commit === "deferred"
       ? "keyboard"
       : options.commit === "immediate"
         ? "pointer"
         : "keyboard");
+    if (effectiveSelectedIndexRef.current === index) {
+      if (options.commit === "immediate") commitIndexImmediately(index, reason);
+      return;
+    }
+    effectiveSelectedIndexRef.current = index;
+    setCursorIndex(index);
     onCursorChange?.(item, index, reason);
     if (options.commit === "deferred") {
       requestSelectionScroll(index);

package/src/components/index.ts

@@ -1,6 +1,6 @@
 
 export { PriceSelectorDialog } from "./price-selector-dialog";
-export { StaticChartSurface } from "./chart/static/chart/surface";
+export { StaticChartSurface } from "./chart/static";
 export {
   buildMetricTreemapNavigationTiles,
   findMetricTreemapNeighbor,
@@ -13,10 +13,15 @@ export type { SpeedometerSegment } from "./speedometer-gauge";
 export { TickerListTableView } from "./ticker/list-table-view";
 export type { TickerListVisibleRange } from "./ticker/list-table-view";
 export { TickerBadgeList } from "./ticker/badge/list";
+export { TickerBadgeText } from "./ticker/badge/text";
 export { InputSearchBar } from "./input-search-bar";
 export { isTableScrollNearEnd, useTableLoadMore } from "./table-view-shared";
 export { DataTableView } from "./data-table/view";
-export type { DataTableKeyEvent, DataTableRootKeyContext } from "./data-table/view";
+export type {
+  DataTableKeyEvent,
+  DataTableRootKeyContext,
+  DataTableSelectionChangeReason,
+} from "./data-table/view";
 export { DataTableStackView } from "./data-table/stack-view";
 export { FeedDataTableStackView } from "./feed-data-table/stack-view";
 export type { FeedDataTableItem } from "./feed-data-table/stack-view";
@@ -47,6 +52,9 @@ export { EmptyState, PaneStatusBody, loadingText, unavailableText } from "./ui/s
 export { getMessageComposerBlockHeight, MessageComposer } from "./ui/message-composer";
 export { NumberField, TextField } from "./ui/fields";
 export { SegmentedControl } from "./ui/toggle";
+export { SelectButton } from "./ui/select-button";
+export type { SelectButtonOption, SelectButtonProps } from "./ui/select-button";
 export { Spinner } from "./ui/loading";
+export { RemoteImage } from "./ui";
 export { Tabs } from "./ui/tabs";
 export { usePaneTicker } from "../state/app/context";

package/src/components/input-search-bar.test.tsx

@@ -21,9 +21,13 @@ afterEach(async () => {
 function Harness({
   actions,
   onNavigateDown,
+  onBlur,
+  onQueryChange,
 }: {
   actions: AppAction[];
   onNavigateDown?: () => void;
+  onBlur?: () => void;
+  onQueryChange?: (query: string) => void;
 }) {
   const state = createInitialState(createDefaultConfig("/tmp/gloomberb-input-search-bar"));
   const inputRef = useRef<InputRenderable | null>(null);
@@ -46,8 +50,8 @@ function Harness({
         debounceMs={100}
         onNavigateDown={onNavigateDown}
         onFocus={() => {}}
-        onBlur={() => {}}
-        onQueryChange={() => {}}
+        onBlur={onBlur ?? (() => {})}
+        onQueryChange={onQueryChange ?? (() => {})}
       />
     </AppContext>
   );
@@ -76,6 +80,36 @@ describe("InputSearchBar", () => {
     ]);
   });
 
+  test("Escape clears the query and releases the field", async () => {
+    // The input consumes every key while focused, so without this there is no
+    // way out of a search once it is entered.
+    const actions: AppAction[] = [];
+    const queries: string[] = [];
+    let blurred = false;
+
+    testSetup = await testRender(
+      <Harness
+        actions={actions}
+        onBlur={() => {
+          blurred = true;
+        }}
+        onQueryChange={(query) => queries.push(query)}
+      />,
+      { width: 40, height: 4 },
+    );
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      testSetup!.renderer.keyInput.emit("keypress", { name: "escape" });
+      await testSetup!.renderOnce();
+    });
+
+    expect(queries).toEqual([""]);
+    expect(blurred).toBe(true);
+  });
+
   test("moves from the active search input to the table with Down", async () => {
     const actions: AppAction[] = [];
     let navigatedDown = 0;

package/src/components/input-search-bar.tsx

@@ -14,6 +14,7 @@ export function InputSearchBar({
   inputRef,
   placeholder,
   debounceMs,
+  glyph = "/",
   normalizeValue = identity,
   onNavigateDown,
   onFocus,
@@ -28,6 +29,8 @@ export function InputSearchBar({
   inputRef: RefObject<InputRenderable | null>;
   placeholder: string;
   debounceMs: number;
+  /** Leading marker; override when a pane shows more than one field. */
+  glyph?: string;
   normalizeValue?: (value: string) => string;
   onNavigateDown?: () => void;
   onFocus: () => void;
@@ -47,6 +50,20 @@ export function InputSearchBar({
     phase: "before",
   });
 
+  // A focused input consumes every key, so Escape has to be intercepted before
+  // it reaches the field. Without this there is no way back out of a search.
+  useShortcut((event) => {
+    if (event.name !== "escape") return;
+    stopSearchFocusNavigation(event);
+    setDraft("");
+    onQueryChange("");
+    onBlur();
+  }, {
+    allowEditable: true,
+    enabled: focused && active,
+    phase: "before",
+  });
+
   useEffect(() => {
     setDraft(value);
   }, [value]);
@@ -81,7 +98,7 @@ export function InputSearchBar({
         inputRef.current?.focus?.();
       }}
     >
-      <Text fg={active ? colors.textBright : colors.textDim}>/</Text>
+      <Text fg={active ? colors.textBright : colors.textDim}>{glyph}</Text>
       <Box width={1} />
       <Input
         ref={inputRef}

package/src/components/layout/header.test.tsx

@@ -2,34 +2,81 @@ import { afterEach, expect, test } from "bun:test";
 import { testRender } from "../../renderers/opentui/test-utils";
 import { AppContext, createInitialState } from "../../state/app/context";
 import { createDefaultConfig } from "../../types/config";
-import { VERSION } from "../../version";
 import { act } from "react";
 import { Header } from "./header";
+import { publishCommandBarPrompt } from "../command-bar/panel/prompt-binding";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
 afterEach(() => {
+  publishCommandBarPrompt(null);
   testSetup?.renderer.destroy();
   testSetup = undefined;
 });
 
-test("opens the current version changelog from the header", async () => {
-  let openedVersion = "";
+test("opens the command bar by clicking the header prompt", async () => {
   const state = createInitialState(createDefaultConfig("/tmp/gloomberb-header-test"));
+  const actions: Array<{ type: string; open?: boolean; query?: string }> = [];
   testSetup = await testRender(
-    <AppContext value={{ state, dispatch: () => {} }}>
-      <Header onOpenChangelog={(version) => { openedVersion = version; }} />
+    <AppContext value={{ state, dispatch: (action) => actions.push(action as { type: string }) }}>
+      <Header />
     </AppContext>,
-    { width: 100, height: 1 },
+    { width: 120, height: 1 },
   );
 
   await testSetup.renderOnce();
-  const versionX = testSetup.captureCharFrame().indexOf(`v${VERSION}`);
-  expect(versionX).toBeGreaterThanOrEqual(0);
+  const promptX = testSetup.captureCharFrame().indexOf(">");
+  expect(promptX).toBeGreaterThanOrEqual(0);
+
+  await act(async () => {
+    await testSetup!.mockMouse.click(promptX + 2, 0);
+    await testSetup!.renderOnce();
+  });
+
+  expect(actions).toContainEqual({ type: "SET_COMMAND_BAR", open: true, query: "" });
+});
+
+/**
+ * While the bar is open the header prompt is its input: what the panel
+ * publishes is what the user types into, and a screen without a binding (a
+ * workflow with its own fields) must not put a focused input in the header.
+ */
+test("hosts the command bar input while a list screen is published", async () => {
+  const state = {
+    ...createInitialState(createDefaultConfig("/tmp/gloomberb-header-test")),
+    commandBarOpen: true,
+  };
+  const typed: string[] = [];
+  testSetup = await testRender(
+    <AppContext value={{ state, dispatch: () => {} }}>
+      <Header />
+    </AppContext>,
+    { width: 120, height: 1 },
+  );
+  await testSetup.renderOnce();
+  expect(testSetup.captureCharFrame()).not.toContain("Search or run a command");
+
+  await act(async () => {
+    publishCommandBarPrompt({
+      screenKey: "root:Commands",
+      query: "QQ",
+      placeholder: "Command or plain English…",
+      ghostSuffix: " AAPL",
+      onQueryChange: (query) => typed.push(query),
+    });
+    await testSetup!.renderOnce();
+  });
+  expect(testSetup.captureCharFrame()).toContain("QQ AAPL");
+
+  await act(async () => {
+    await testSetup!.mockInput.typeText("x");
+    await testSetup!.renderOnce();
+  });
+  expect(typed).toEqual(["QQx"]);
 
   await act(async () => {
-    await testSetup!.mockMouse.click(versionX + 1, 0);
+    publishCommandBarPrompt(null);
     await testSetup!.renderOnce();
   });
-  expect(openedVersion).toBe(VERSION);
+  expect(testSetup.captureCharFrame()).not.toContain("QQ");
 });