gloomberb 0.10.2 → 0.10.4

package/src/components/command-bar/routes/root/runtime.ts

@@ -5,6 +5,7 @@ import type { DataProvider } from "../../../../types/data-provider";
 import type { CommandDef, PaneTemplateCreateOptions, PaneTemplateDef } from "../../../../types/plugin";
 import type { TickerRecord } from "../../../../types/ticker";
 import type { TickerSearchCandidate } from "../../../../tickers/search";
+import type { AssistRowHandlers } from "../../assist/model";
 import { matchPrefix, type Command } from "../../commands/registry";
 import type { ResultItem } from "../../list/model";
 import type { CommandBarRoute } from "../../workflow/types";
@@ -12,13 +13,23 @@ import { useTickerSearchRouteResults } from "../ticker-search/route";
 import { buildRootResultModel, type RootResultModel } from "./results";
 import { useRootProviderSearch } from "./provider-search";
 import { buildRootShortcutFeedback } from "./shortcut-feedback";
-import { parseRootShortcutIntent } from "./shortcuts";
+import type { ShortcutIntent } from "./shortcuts";
+
+function clampSelectedIdx(index: number, length: number): number {
+  return Math.max(0, Math.min(index, length - 1));
+}
+
+/** A row plain Enter can run, so the untouched selection may rest on it. */
+function isDefaultSelectable(item: ResultItem): boolean {
+  return item.disabled !== true && item.defaultSelectable !== false;
+}
 
 interface UseCommandBarRootRuntimeOptions {
   activeCollectionId: string | null;
   activePortfolio?: AppState["config"]["portfolios"][number];
   activeTickerData: TickerRecord | null | undefined;
   activeTickerSymbol: string | null;
+  assist: AssistRowHandlers;
   availableCommands: Command[];
   buildLayoutItems(query: string, options?: { confirmDangerousActions?: boolean }): ResultItem[];
   buildPaneSettingItems(paneId: string | null, query: string): ResultItem[];
@@ -39,7 +50,6 @@ interface UseCommandBarRootRuntimeOptions {
     rawInput?: string,
   ): void | Promise<void>;
   getAvailablePaneShortcutTemplates(query: string): PaneTemplateDef[];
-  getAvailablePluginCommands(): CommandDef[];
   getTickers(): AppState["tickers"];
   hasPaneSettings(paneId: string): boolean;
   localTickerSearchResultItems(query?: string, options?: { category?: string; limit?: number }): ResultItem[];
@@ -60,6 +70,8 @@ interface UseCommandBarRootRuntimeOptions {
   ): TickerSearchCandidate[] | null;
   rootModeKind: string;
   rootQuery: string;
+  rootSelectionNavigatedRef: RefObject<boolean>;
+  rootShortcutIntent: ShortcutIntent;
   runDirectCommand(command: Command, arg: string): void;
   runSecurityDescriptionShortcut(query?: string): void | Promise<void>;
   setRootHoveredIdx: Dispatch<SetStateAction<number | null>>;
@@ -80,6 +92,7 @@ export function useCommandBarRootRuntime({
   activePortfolio,
   activeTickerData,
   activeTickerSymbol,
+  assist,
   availableCommands,
   buildLayoutItems,
   buildPaneSettingItems,
@@ -92,7 +105,6 @@ export function useCommandBarRootRuntime({
   dataProvider,
   executeCollectionCommand,
   getAvailablePaneShortcutTemplates,
-  getAvailablePluginCommands,
   getTickers,
   hasPaneSettings,
   localTickerSearchResultItems,
@@ -105,6 +117,8 @@ export function useCommandBarRootRuntime({
   readTickerSearchCache,
   rootModeKind,
   rootQuery,
+  rootSelectionNavigatedRef,
+  rootShortcutIntent,
   runDirectCommand,
   runSecurityDescriptionShortcut,
   setRootHoveredIdx,
@@ -121,21 +135,14 @@ export function useCommandBarRootRuntime({
   rootSearching: boolean;
   rootSectionOrder: ReturnType<typeof useRootProviderSearch>["rootSectionOrder"];
   rootShortcutFeedback: string | null;
-  rootShortcutIntent: ReturnType<typeof parseRootShortcutIntent>;
+  rootShortcutIntent: ShortcutIntent;
   tickerSearchPending: boolean;
   tickerSearchResults: ResultItem[];
 } {
   const previousRootSelectionContextRef = useRef<{ query: string; mode: string } | null>(null);
+  const previousRootResultIdsRef = useRef<string[]>([]);
   const activeMatch = matchPrefix(rootQuery, availableCommands);
 
-  const rootShortcutIntent = useMemo(() => parseRootShortcutIntent({
-    query: rootQuery,
-    commands: availableCommands,
-    pluginCommands: getAvailablePluginCommands(),
-    paneTemplates: getAvailablePaneShortcutTemplates(rootQuery),
-    activeTicker: activeTickerSymbol,
-  }), [activeTickerSymbol, availableCommands, getAvailablePaneShortcutTemplates, getAvailablePluginCommands, rootQuery]);
-
   const tickerSearchRouteQuery = currentRoute?.kind === "mode" && currentRoute.screen === "ticker-search"
     ? currentRoute.query
     : null;
@@ -160,6 +167,7 @@ export function useCommandBarRootRuntime({
     activeCollectionId,
     activeTickerData,
     activeTickerSymbol,
+    assist,
     availableCommands,
     buildLayoutItems,
     buildPaneSettingItems,
@@ -187,6 +195,7 @@ export function useCommandBarRootRuntime({
     activeCollectionId,
     activeTickerData,
     activeTickerSymbol,
+    assist,
     availableCommands,
     buildLayoutItems,
     buildPaneSettingItems,
@@ -217,30 +226,6 @@ export function useCommandBarRootRuntime({
     : null;
   const rootTickerSearchArg = rootSecurityDescriptionArg;
 
-  useEffect(() => {
-    if (currentRoute) return;
-
-    setRootHoveredIdx((current) => (current != null && current < rootResultModel.items.length ? current : null));
-    const selectionContextChanged =
-      previousRootSelectionContextRef.current?.query !== rootQuery
-      || previousRootSelectionContextRef.current?.mode !== rootModeKind;
-    if (activeMatch?.command.id === "plugins" || !selectionContextChanged) {
-      setRootSelectedIdx((current) => Math.max(0, Math.min(current, rootResultModel.items.length - 1)));
-    } else {
-      setRootSelectedIdx(Math.max(0, Math.min(rootResultModel.initialIdx, rootResultModel.items.length - 1)));
-    }
-    previousRootSelectionContextRef.current = { query: rootQuery, mode: rootModeKind };
-  }, [
-    activeMatch?.command.id,
-    currentRoute,
-    rootModeKind,
-    rootQuery,
-    rootResultModel.initialIdx,
-    rootResultModel.items.length,
-    setRootHoveredIdx,
-    setRootSelectedIdx,
-  ]);
-
   const {
     activeRootProviderResultsKey,
     orderedRootResults,
@@ -261,6 +246,51 @@ export function useCommandBarRootRuntime({
     writeTickerSearchCache,
   });
 
+  useEffect(() => {
+    if (currentRoute) return;
+
+    const resultIds = orderedRootResults.map((item) => item.id);
+    const previousResultIds = previousRootResultIdsRef.current;
+    previousRootResultIdsRef.current = resultIds;
+
+    setRootHoveredIdx((current) => (current != null && current < resultIds.length ? current : null));
+
+    const selectionContextChanged =
+      previousRootSelectionContextRef.current?.query !== rootQuery
+      || previousRootSelectionContextRef.current?.mode !== rootModeKind;
+    previousRootSelectionContextRef.current = { query: rootQuery, mode: rootModeKind };
+    // Filtering the plugin list is not meant to move the row being toggled.
+    const keepSelectionAcrossQueries = activeMatch?.command.id === "plugins";
+    if (selectionContextChanged && !keepSelectionAcrossQueries) {
+      rootSelectionNavigatedRef.current = false;
+    }
+
+    setRootSelectedIdx((current) => {
+      if (rootSelectionNavigatedRef.current || keepSelectionAcrossQueries) {
+        // The user picked this row: rows arriving above it — an AI answer, a
+        // provider result — may renumber it, never take the highlight from it.
+        const selectedId = previousResultIds[current];
+        const shiftedIdx = selectedId ? resultIds.indexOf(selectedId) : -1;
+        if (shiftedIdx >= 0) return shiftedIdx;
+        return clampSelectedIdx(current, resultIds.length);
+      }
+      // Untouched, the selection follows the best row on offer, which is what
+      // an AI answer becomes the moment it lands at the top of the list.
+      const defaultIdx = orderedRootResults.findIndex(isDefaultSelectable);
+      return clampSelectedIdx(Math.max(rootResultModel.initialIdx, defaultIdx), resultIds.length);
+    });
+  }, [
+    activeMatch?.command.id,
+    currentRoute,
+    orderedRootResults,
+    rootModeKind,
+    rootQuery,
+    rootResultModel.initialIdx,
+    rootSelectionNavigatedRef,
+    setRootHoveredIdx,
+    setRootSelectedIdx,
+  ]);
+
   useEffect(() => {
     if (!activeRootProviderResultsKey) return;
     setRootSelectedIdx(0);

package/src/components/command-bar/routes/root/shortcuts.ts

@@ -2,7 +2,7 @@ import type { CommandDef, PaneTemplateDef } from "../../../../types/plugin";
 import { getCommandPrefixes, type Command } from "../../commands/registry";
 import { getPaneTemplateDisplayLabel } from "../../pane-templates/items";
 
-type RootShortcutArgKind = "text" | "ticker" | "ticker-list";
+export type RootShortcutArgKind = "text" | "ticker" | "ticker-list";
 type ShortcutIntentKind = "none" | "complete" | "inferred-complete" | "partial" | "ambiguous";
 
 interface ShortcutIntentBase {
@@ -60,14 +60,18 @@ function mapPlaceholderToArgKind(value: string | undefined): RootShortcutArgKind
   return null;
 }
 
-function getPaneShortcutArgKind(template: PaneTemplateDef): RootShortcutArgKind | null {
+export function getPaneShortcutArgKind(template: PaneTemplateDef): RootShortcutArgKind | null {
   return template.shortcut?.argKind ?? mapPlaceholderToArgKind(template.shortcut?.argPlaceholder);
 }
 
-function getCommandShortcutArgKind(command: Command): RootShortcutArgKind | null {
+export function getCommandShortcutArgKind(command: Command): RootShortcutArgKind | null {
   return mapPlaceholderToArgKind(command.argPlaceholder) ?? (command.hasArg ? "text" : null);
 }
 
+export function getPluginCommandShortcutArgKind(command: CommandDef): RootShortcutArgKind | null {
+  return command.shortcutArg?.kind ?? (command.shortcutArg ? "text" : null);
+}
+
 function inferShortcutArg(argKind: RootShortcutArgKind | null, activeTicker: string | null): string | null {
   if (!activeTicker) return null;
   if (argKind === "ticker" || argKind === "ticker-list") {
@@ -98,7 +102,7 @@ function buildShortcutCandidates(
         prefix: normalizeShortcutPrefix(command.shortcut!),
         label: command.label,
         description: command.description ?? "",
-        argKind: command.shortcutArg?.kind ?? (command.shortcutArg ? "text" : null),
+        argKind: getPluginCommandShortcutArgKind(command),
         argPlaceholder: command.shortcutArg?.placeholder,
         source: "plugin-command" as const,
         pluginCommand: command,

package/src/components/command-bar/routing/navigation-state.ts

@@ -24,6 +24,8 @@ interface UseCommandBarNavigationStateResult {
   currentRouteRef: RefObject<CommandBarRoute | null>;
   dismissCommandBar: () => void;
   lastMainBrowseRef: RefObject<CommandBarMainSnapshot>;
+  /** Records that the user moved the root selection themselves. */
+  markRootSelectionNavigated: () => void;
   popRoute: () => void;
   pushRoute: (route: CommandBarRoute) => void;
   rootHoveredIdx: number | null;
@@ -31,6 +33,8 @@ interface UseCommandBarNavigationStateResult {
   rootModeKindRef: RefObject<ReturnType<typeof resolveCommandBarMode>["kind"]>;
   rootQuery: string;
   rootQueryRef: RefObject<string>;
+  /** True once the user picked a row; cleared when the query context changes. */
+  rootSelectionNavigatedRef: RefObject<boolean>;
   rootSelectedIdx: number;
   routeStack: CommandBarRoute[];
   setRootHoveredIdx: Dispatch<SetStateAction<number | null>>;
@@ -56,6 +60,15 @@ export function useCommandBarNavigationState({
 
   const [rootSelectedIdx, setRootSelectedIdx] = useState(0);
   const [rootHoveredIdx, setRootHoveredIdx] = useState<number | null>(null);
+  /**
+   * Whether the highlighted row is the user's own choice. Rows that arrive
+   * later — an AI answer, provider results — may only shift a chosen row, never
+   * replace it, while an untouched selection keeps following the top match.
+   */
+  const rootSelectionNavigatedRef = useRef(false);
+  const markRootSelectionNavigated = useCallback(() => {
+    rootSelectionNavigatedRef.current = true;
+  }, []);
   const [routeStack, setRouteStack] = useState<CommandBarRoute[]>([]);
   const lastMainBrowseRef = useRef<CommandBarMainSnapshot>({ query: "", selectedIdx: 0 });
 
@@ -70,6 +83,7 @@ export function useCommandBarNavigationState({
     setRootQueryValue(initialQuery);
     setRootSelectedIdx(0);
     setRootHoveredIdx(null);
+    rootSelectionNavigatedRef.current = false;
   }, [initialQuery]);
 
   const closeAll = useCallback((options?: CloseCommandBarOptions) => {
@@ -80,6 +94,7 @@ export function useCommandBarNavigationState({
     setRouteStack([]);
     setRootSelectedIdx(0);
     setRootHoveredIdx(null);
+    rootSelectionNavigatedRef.current = false;
   }, [dispatch, restoreThemePreview]);
 
   const setRootQuery = useCallback((query: string) => {
@@ -138,6 +153,7 @@ export function useCommandBarNavigationState({
     currentRouteRef,
     dismissCommandBar,
     lastMainBrowseRef,
+    markRootSelectionNavigated,
     popRoute,
     pushRoute,
     rootHoveredIdx,
@@ -145,6 +161,7 @@ export function useCommandBarNavigationState({
     rootModeKindRef,
     rootQuery,
     rootQueryRef,
+    rootSelectionNavigatedRef,
     rootSelectedIdx,
     routeStack,
     setRootHoveredIdx,

package/src/components/command-bar/selection-runtime.ts

@@ -195,6 +195,31 @@ export function useCommandBarSelectionRuntime({
     startThemePicker,
   ]);
 
+  /**
+   * Runs `query` exactly as if it had been typed into the root bar and
+   * submitted, so AI-suggested inputs take the same prefix/arg path as anything
+   * the user types. Argless prefixes reject a trailing argument outright
+   * ("ERN NVDA" resolves to nothing), so the bare prefix gets a second try
+   * before the text is merely dropped into the input.
+   */
+  const runRootQuery = useCallback((query: string, options?: { fallbackPrefix?: string }) => {
+    const item = resolveImmediateRootSelection(query);
+    if (item && !item.disabled) {
+      void item.action();
+      return;
+    }
+    const trimmed = query.trim();
+    const fallbackPrefix = (options?.fallbackPrefix ?? trimmed.split(/\s+/)[0] ?? "").trim();
+    if (fallbackPrefix && fallbackPrefix.toUpperCase() !== trimmed.toUpperCase()) {
+      const fallbackItem = resolveImmediateRootSelection(fallbackPrefix);
+      if (fallbackItem && !fallbackItem.disabled) {
+        void fallbackItem.action();
+        return;
+      }
+    }
+    setRootQuery(query);
+  }, [resolveImmediateRootSelection, setRootQuery]);
+
   const setActiveListQuery = useCallback((nextQuery: string) => {
     const route = currentRouteRef.current;
     if (!route) {
@@ -286,6 +311,7 @@ export function useCommandBarSelectionRuntime({
     acceptRootShortcutTab,
     acceptSelectedShortcutTab,
     activateListSelection,
+    runRootQuery,
     setActiveListQuery,
   };
 }

package/src/components/command-bar/surface/assist.test.tsx

@@ -0,0 +1,276 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { apiClient, setCloudApiFetchTransport } from "../../../api-client";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import type { PluginRegistry } from "../../../plugins/registry";
+import type { PaneTemplateCreateOptions } from "../../../types/plugin";
+import {
+  CommandBarHarness,
+  createCommandBarTestControls,
+  emitKeypress,
+} from "./test-harness";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+afterEach(() => {
+  setCloudApiFetchTransport(null);
+  apiClient.setSessionToken(null);
+  if (testSetup) {
+    testSetup.renderer.destroy();
+    testSetup = undefined;
+  }
+});
+
+const { waitForFrameToContain } = createCommandBarTestControls(() => testSetup!);
+
+function signInVerified(): void {
+  apiClient.setSessionToken("assist-test-token");
+  apiClient.restoreCachedUser({
+    id: "user-1",
+    name: "Tester",
+    email: "tester@example.com",
+    username: "tester",
+    emailVerified: true,
+    plan: "free",
+  } as never);
+}
+
+/**
+ * Answers `/assist/command` locally and returns the asks that were made. Other
+ * cloud calls are refused: ambient client traffic (a session refresh) must
+ * never be mistaken for the bar asking a question.
+ */
+function mockAssistTransport(respond: (body: unknown) => Response | Promise<Response>): string[] {
+  const requests: string[] = [];
+  setCloudApiFetchTransport(async (url, init) => {
+    if (!url.endsWith("/assist/command")) {
+      throw new Error(`unexpected cloud request: ${url}`);
+    }
+    requests.push(url);
+    return await respond(JSON.parse(String(init?.body ?? "{}")));
+  });
+  return requests;
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+/** Records pane creations and registers "ERN", an argless pane shortcut. */
+function configureEarningsRegistry(
+  created: Array<{ templateId: string; options?: PaneTemplateCreateOptions }>,
+) {
+  return (pluginRegistry: PluginRegistry) => {
+    pluginRegistry.paneTemplates.set("earnings-calendar-pane", {
+      id: "earnings-calendar-pane",
+      paneId: "portfolio-list",
+      label: "Earnings Calendar",
+      description: "Upcoming earnings dates and estimates",
+      shortcut: { prefix: "ERN" },
+    } as never);
+    (pluginRegistry as unknown as {
+      createPaneFromTemplateAsyncFn: (templateId: string, options?: PaneTemplateCreateOptions) => Promise<void>;
+    }).createPaneFromTemplateAsyncFn = async (templateId, options) => {
+      created.push({ templateId, options });
+    };
+  };
+}
+
+/** Wide enough to cover the ask debounce plus the round trip. */
+const ASSIST_WAIT_ATTEMPTS = 40;
+
+async function waitForRequest(requests: string[]): Promise<void> {
+  for (let attempt = 0; attempt < ASSIST_WAIT_ATTEMPTS; attempt++) {
+    if (requests.length > 0) return;
+    await Bun.sleep(50);
+    await testSetup!.renderOnce();
+  }
+  throw new Error("Timed out waiting for the assist request.");
+}
+
+async function waitForFrameWithout(text: string): Promise<string> {
+  for (let attempt = 0; attempt < ASSIST_WAIT_ATTEMPTS; attempt++) {
+    const frame = testSetup!.captureCharFrame();
+    if (!frame.includes(text)) return frame;
+    await Bun.sleep(50);
+    await testSetup!.renderOnce();
+  }
+  throw new Error(`Timed out waiting for "${text}" to disappear.`);
+}
+
+describe("CommandBar AI assist", () => {
+  test("asks on its own, with no Enter, and leads the list with the answer", async () => {
+    signInVerified();
+    let sentCommandCount = 0;
+    let releaseResponse = () => {};
+    const held = new Promise<void>((resolve) => { releaseResponse = resolve; });
+    const requests = mockAssistTransport(async (body) => {
+      sentCommandCount = (body as { commands: unknown[] }).commands.length;
+      await held;
+      return jsonResponse({
+        candidates: [{ input: "CHAT #general", title: "Open the general channel", prefix: "CHAT", confidence: 0.9 }],
+      });
+    });
+    const created: Array<{ templateId: string; options?: PaneTemplateCreateOptions }> = [];
+
+    testSetup = await testRender(
+      <CommandBarHarness
+        query="new chat pane"
+        configurePluginRegistry={configureEarningsRegistry(created)}
+      />,
+      { width: 100, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Thinking…");
+    // Nobody pressed Enter; the debounce fires the one request by itself.
+    await waitForRequest(requests);
+    expect(requests).toHaveLength(1);
+    expect(sentCommandCount).toBeGreaterThan(0);
+
+    releaseResponse();
+    const answered = await waitForFrameToContain("CHAT #general — Open the general channel", ASSIST_WAIT_ATTEMPTS);
+    expect(answered).not.toContain("Thinking…");
+    expect(requests).toHaveLength(1);
+    // Above the local matches, and holding the selection an untouched query
+    // never moved: plain Enter runs the AI's best guess.
+    expect(answered.indexOf("Ask AI")).toBeLessThan(answered.indexOf("Panes"));
+
+    await emitKeypress(testSetup, { name: "return", sequence: "\r" });
+    expect(created).toEqual([{ templateId: "new-chat-pane", options: { arg: "#general" } }]);
+  });
+
+  test("keeps the row the user picked when an answer lands above it", async () => {
+    signInVerified();
+    mockAssistTransport(() => jsonResponse({
+      candidates: [
+        { input: "CHAT #general", title: "Open the general channel", prefix: "CHAT", confidence: 0.9 },
+        { input: "CHAT #random", title: "Open the random channel", prefix: "CHAT", confidence: 0.4 },
+      ],
+    }));
+    const created: Array<{ templateId: string; options?: PaneTemplateCreateOptions }> = [];
+
+    testSetup = await testRender(
+      <CommandBarHarness
+        query="new chat pane"
+        configurePluginRegistry={configureEarningsRegistry(created)}
+      />,
+      { width: 100, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    // Down lands on the local match while a single "Thinking…" row sits above.
+    await emitKeypress(testSetup, { name: "down" });
+    await waitForFrameToContain("CHAT #random — Open the random channel", ASSIST_WAIT_ATTEMPTS);
+
+    // Two answers replaced that one row, so the chosen row moved down by one —
+    // Enter still runs it rather than whatever now sits at its old index.
+    await emitKeypress(testSetup, { name: "return", sequence: "\r" });
+    expect(created).toEqual([{ templateId: "new-chat-pane", options: undefined }]);
+  });
+
+  test("runs an argless prefix candidate that still carries an argument", async () => {
+    signInVerified();
+    // Unclamped on purpose: "ERN" takes no argument, so the client has to fall
+    // back to the bare prefix instead of dropping the text into the input.
+    mockAssistTransport(() => jsonResponse({
+      candidates: [{ input: "ERN NVDA", title: "Earnings Calendar for NVDA", prefix: "ERN", confidence: 0.8 }],
+    }));
+    const created: Array<{ templateId: string; options?: PaneTemplateCreateOptions }> = [];
+
+    testSetup = await testRender(
+      <CommandBarHarness
+        query="nvda earnings"
+        configurePluginRegistry={configureEarningsRegistry(created)}
+      />,
+      { width: 100, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    await waitForFrameToContain("ERN NVDA — Earnings Calendar for NVDA", ASSIST_WAIT_ATTEMPTS);
+
+    await emitKeypress(testSetup, { name: "return", sequence: "\r" });
+    expect(created).toEqual([{ templateId: "earnings-calendar-pane", options: undefined }]);
+  });
+
+  test("claims the answer still in flight when Enter lands on the thinking row", async () => {
+    signInVerified();
+    let releaseResponse = () => {};
+    const held = new Promise<void>((resolve) => { releaseResponse = resolve; });
+    const requests = mockAssistTransport(async () => {
+      await held;
+      return jsonResponse({
+        candidates: [{ input: "CHAT #general", title: "Open the general channel", prefix: "CHAT", confidence: 0.9 }],
+      });
+    });
+    const created: Array<{ templateId: string; options?: PaneTemplateCreateOptions }> = [];
+
+    testSetup = await testRender(
+      <CommandBarHarness
+        query="new chat pane"
+        configurePluginRegistry={configureEarningsRegistry(created)}
+      />,
+      { width: 100, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Thinking…");
+
+    // Enter on "Thinking…" is a promise, not a dead key: there is nothing to
+    // run yet, so the ask is claimed and its answer runs when it arrives.
+    await emitKeypress(testSetup, { name: "return", sequence: "\r" });
+    expect(created).toEqual([]);
+
+    releaseResponse();
+    for (let attempt = 0; attempt < ASSIST_WAIT_ATTEMPTS && created.length === 0; attempt++) {
+      await Bun.sleep(50);
+      await testSetup.renderOnce();
+    }
+    expect(created).toEqual([{ templateId: "new-chat-pane", options: { arg: "#general" } }]);
+    expect(requests).toHaveLength(1);
+  });
+
+  test("drops the section when a background ask fails", async () => {
+    signInVerified();
+    const requests = mockAssistTransport(() => jsonResponse({ error: "assist-unavailable" }, 503));
+
+    testSetup = await testRender(
+      <CommandBarHarness query="show me the newest filings" />,
+      { width: 100, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Ask AI");
+
+    const frame = await waitForFrameWithout("Ask AI");
+    expect(requests).toHaveLength(1);
+    expect(frame).not.toContain("unavailable");
+  });
+
+  test("sends signed-out users to sign up instead of the endpoint", async () => {
+    const requests = mockAssistTransport(() => jsonResponse({ candidates: [] }));
+    const created: Array<{ templateId: string; options?: PaneTemplateCreateOptions }> = [];
+
+    testSetup = await testRender(
+      <CommandBarHarness
+        query="new chat pane"
+        configurePluginRegistry={configureEarningsRegistry(created)}
+      />,
+      { width: 100, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Ask AI — sign up to enable");
+
+    await Bun.sleep(700);
+    await testSetup.renderOnce();
+    expect(requests).toEqual([]);
+
+    // The offer leads the list but never takes the Enter that belongs to the
+    // local match the user was already looking at.
+    await emitKeypress(testSetup, { name: "return", sequence: "\r" });
+    expect(created).toEqual([{ templateId: "new-chat-pane", options: undefined }]);
+  });
+});