gloomberb 0.11.2 → 0.12.0

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

@@ -8,7 +8,9 @@ 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 { CommandBarCategoryPriorities } from "../../view-model";
 import type { CommandBarRoute } from "../../workflow/types";
+import { normalizeCommandTickerSearchText } from "../ticker-search/results";
 import { useTickerSearchRouteResults } from "../ticker-search/route";
 import { buildRootResultModel, type RootResultModel } from "./results";
 import { useRootProviderSearch } from "./provider-search";
@@ -33,7 +35,6 @@ interface UseCommandBarRootRuntimeOptions {
   availableCommands: Command[];
   buildLayoutItems(query: string, options?: { confirmDangerousActions?: boolean }): ResultItem[];
   buildPaneSettingItems(paneId: string | null, query: string): ResultItem[];
-  buildPluginItems(query: string): ResultItem[];
   buildTickerSearchResultItems(candidates: TickerSearchCandidate[], query: string): ResultItem[];
   buildWindowModeItems(arg: string): ResultItem[];
   createPaneTemplateItem(template: PaneTemplateDef, options?: {
@@ -55,7 +56,7 @@ interface UseCommandBarRootRuntimeOptions {
   localTickerSearchResultItems(query?: string, options?: { category?: string; limit?: number }): ResultItem[];
   nativeListScrollRef: RefObject<ScrollBoxRenderable | null>;
   nonShortcutPaneTemplateItems(filterQuery?: string): ResultItem[];
-  openModeRoute(screen: "ticker-search" | "plugins" | "layout", initialQuery?: string): void;
+  openModeRoute(screen: "ticker-search" | "layout", initialQuery?: string): void;
   paneShortcutItems(options?: {
     filterQuery?: string;
     createOptions?: PaneTemplateCreateOptions;
@@ -63,7 +64,9 @@ interface UseCommandBarRootRuntimeOptions {
   }): ResultItem[];
   pluginCommandItems(): ResultItem[];
   pluginCommandResultItems(command: CommandDef, shortcutArg: string): ResultItem[];
-  articleResultItems?: ResultItem[];
+  providerResultItems?: ResultItem[];
+  providerCategoryPriorities?: CommandBarCategoryPriorities;
+  providerSearching?: boolean;
   readTickerSearchCache(
     query: string,
     brokerId?: string | null,
@@ -97,7 +100,6 @@ export function useCommandBarRootRuntime({
   availableCommands,
   buildLayoutItems,
   buildPaneSettingItems,
-  buildPluginItems,
   buildTickerSearchResultItems,
   buildWindowModeItems,
   createPaneTemplateItem,
@@ -115,7 +117,9 @@ export function useCommandBarRootRuntime({
   paneShortcutItems,
   pluginCommandItems,
   pluginCommandResultItems,
-  articleResultItems = [],
+  providerResultItems = [],
+  providerCategoryPriorities,
+  providerSearching = false,
   readTickerSearchCache,
   rootModeKind,
   rootQuery,
@@ -173,7 +177,6 @@ export function useCommandBarRootRuntime({
     availableCommands,
     buildLayoutItems,
     buildPaneSettingItems,
-    buildPluginItems,
     buildWindowModeItems,
     createPaneTemplateItem,
     createPluginCommandItem,
@@ -189,7 +192,7 @@ export function useCommandBarRootRuntime({
     pluginCommandResultItems,
     rootQuery,
     rootShortcutIntent,
-    articleResultItems,
+    providerResultItems,
     runDirectCommand,
     runSecurityDescriptionShortcut,
     state,
@@ -202,7 +205,6 @@ export function useCommandBarRootRuntime({
     availableCommands,
     buildLayoutItems,
     buildPaneSettingItems,
-    buildPluginItems,
     buildWindowModeItems,
     createPaneTemplateItem,
     createPluginCommandItem,
@@ -218,7 +220,7 @@ export function useCommandBarRootRuntime({
     pluginCommandResultItems,
     rootQuery,
     rootShortcutIntent,
-    articleResultItems,
+    providerResultItems,
     runDirectCommand,
     runSecurityDescriptionShortcut,
     state,
@@ -228,27 +230,44 @@ export function useCommandBarRootRuntime({
   const rootSecurityDescriptionArg = activeMatch?.command.id === "security-description" && activeMatch.arg.length >= 1
     ? activeMatch.arg
     : null;
-  const rootTickerSearchArg = rootSecurityDescriptionArg;
+  // Free text that no prefix claims also goes to symbol search, so "nvidia"
+  // finds NVDA without the backtick. Skipped when a local row already carries
+  // that exact name, since an "Exact Match" symbol would otherwise outrank it.
+  const rootPlainTickerSearchArg = useMemo(() => {
+    if (currentRoute || activeMatch || rootShortcutIntent.kind !== "none") return null;
+    const trimmed = rootQuery.trim();
+    if (trimmed.length < 2) return null;
+    const normalizedQuery = normalizeCommandTickerSearchText(trimmed);
+    const hasExactLocalRow = rootResultModel.items.some((item) => (
+      item.kind !== "ticker"
+      && item.kind !== "search"
+      && normalizeCommandTickerSearchText(item.label) === normalizedQuery
+    ));
+    return hasExactLocalRow ? null : trimmed;
+  }, [activeMatch, currentRoute, rootQuery, rootResultModel.items, rootShortcutIntent.kind]);
+  const rootTickerSearchArg = rootSecurityDescriptionArg ?? rootPlainTickerSearchArg;
 
   const {
     activeRootProviderResultsKey,
     orderedRootResults,
-    rootSearching,
+    rootSearching: tickerSearching,
     rootSectionOrder,
   } = useRootProviderSearch({
     activeCollectionId,
     buildTickerSearchResultItems,
+    categoryPriorities: providerCategoryPriorities,
     currentRoute,
     dataProvider,
     localTickerSearchResultItems,
     portfolios: state.config.portfolios,
     readTickerSearchCache,
-    rootPlainTickerSearchArg: null,
+    rootPlainTickerSearchArg,
     rootResultItems: rootResultModel.items,
     rootTickerSearchArg,
     tickers: state.tickers,
     writeTickerSearchCache,
   });
+  const rootSearching = tickerSearching || providerSearching;
 
   useLayoutEffect(() => {
     if (currentRoute) return;
@@ -263,23 +282,21 @@ export function useCommandBarRootRuntime({
       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) {
+    if (selectionContextChanged) {
       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.
+      if (rootSelectionNavigatedRef.current) {
+        // The user picked this row. Async sections append below it, but an
+        // exact symbol match still lands above, so the row is tracked by id
+        // rather than by index.
         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.
+      // Untouched, the selection follows the best row on offer.
       const defaultIdx = orderedRootResults.findIndex(isDefaultSelectable);
       return clampSelectedIdx(Math.max(rootResultModel.initialIdx, defaultIdx), resultIds.length);
     });

package/src/components/command-bar/routes/root/search-providers.test.tsx

@@ -0,0 +1,224 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act, useState } from "react";
+import { testRender } from "../../../../renderers/opentui/test-utils";
+import type { CommandBarResultDef, CommandBarSearchProvider } from "../../../../types/plugin";
+import type { ResultItem } from "../../list/model";
+import { toProviderResultItem, useCommandBarSearchProviders } from "./search-providers";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let setHarnessQuery: ((query: string) => void) | null = null;
+let latestItems: ResultItem[] = [];
+let latestSearching = false;
+
+function ProvidersHarness({
+  providers,
+  initialQuery,
+}: {
+  providers: CommandBarSearchProvider[];
+  initialQuery: string;
+}) {
+  const [query, setQuery] = useState(initialQuery);
+  setHarnessQuery = setQuery;
+  const { providerResultItems, providerSearching } = useCommandBarSearchProviders({
+    providers,
+    query,
+    enabled: true,
+    context: { activeTicker: null, activeCollectionId: null },
+    onExecuted: () => {},
+  });
+  latestItems = providerResultItems;
+  latestSearching = providerSearching;
+  return <text>{String(providerResultItems.length)}</text>;
+}
+
+async function renderHarness(providers: CommandBarSearchProvider[], initialQuery = ""): Promise<void> {
+  testSetup = await testRender(
+    <ProvidersHarness providers={providers} initialQuery={initialQuery} />,
+    { width: 20, height: 1 },
+  );
+  await act(async () => {
+    await testSetup!.renderOnce();
+  });
+}
+
+async function typeQuery(query: string): Promise<void> {
+  await act(async () => {
+    setHarnessQuery?.(query);
+    await testSetup!.renderOnce();
+  });
+}
+
+async function settle(ms = 20): Promise<void> {
+  await act(async () => {
+    await Bun.sleep(ms);
+    await testSetup!.renderOnce();
+  });
+}
+
+function makeResult(id: string): CommandBarResultDef {
+  return { id, label: id, execute: () => {} };
+}
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
+    testSetup = undefined;
+  }
+  setHarnessQuery = null;
+  latestItems = [];
+  latestSearching = false;
+});
+
+describe("command bar search providers", () => {
+  test("shows only the answer to the query still in the bar, and aborts the rest", async () => {
+    const asked: string[] = [];
+    const aborted: string[] = [];
+    const provider: CommandBarSearchProvider = {
+      id: "docs",
+      category: "Documents",
+      debounceMs: 0,
+      async provide(query, _context, signal) {
+        asked.push(query);
+        signal.addEventListener("abort", () => aborted.push(query));
+        // The slower first request would otherwise land on top of the newer one.
+        await Bun.sleep(query === "margin" ? 40 : 0);
+        return [makeResult(query)];
+      },
+    };
+
+    await renderHarness([provider], "margin");
+    await settle(5);
+    await typeQuery("margin pressure");
+    await settle(60);
+
+    expect(asked).toEqual(["margin", "margin pressure"]);
+    expect(aborted).toEqual(["margin"]);
+    expect(latestItems.map((item) => item.label)).toEqual(["margin pressure"]);
+  });
+
+  test("does not ask again for a query it has already answered", async () => {
+    let calls = 0;
+    const provider: CommandBarSearchProvider = {
+      id: "docs",
+      category: "Documents",
+      debounceMs: 0,
+      async provide(query) {
+        calls += 1;
+        return [makeResult(query)];
+      },
+    };
+
+    await renderHarness([provider], "margin");
+    await settle();
+    await typeQuery("margin pressure");
+    await settle();
+    await typeQuery("margin");
+    await settle();
+
+    expect(calls).toBe(2);
+    expect(latestItems.map((item) => item.label)).toEqual(["margin"]);
+  });
+
+  test("contributes nothing when it fails, and stops reporting itself as loading", async () => {
+    const provider: CommandBarSearchProvider = {
+      id: "docs",
+      category: "Documents",
+      debounceMs: 0,
+      async provide() {
+        throw new Error("402");
+      },
+    };
+
+    await renderHarness([provider], "margin");
+    await settle();
+
+    expect(latestItems).toEqual([]);
+    expect(latestSearching).toBe(false);
+  });
+
+  test("stays quiet below the provider's minimum query length", async () => {
+    let calls = 0;
+    const provider: CommandBarSearchProvider = {
+      id: "docs",
+      category: "Documents",
+      debounceMs: 0,
+      minQueryLength: 4,
+      async provide(query) {
+        calls += 1;
+        return [makeResult(query)];
+      },
+    };
+
+    await renderHarness([provider], "mar");
+    await settle();
+    expect(calls).toBe(0);
+    expect(latestSearching).toBe(false);
+
+    await typeQuery("marg");
+    await settle();
+    expect(calls).toBe(1);
+  });
+
+  test("orders sections by provider priority", async () => {
+    const provider = (id: string, priority: number): CommandBarSearchProvider => ({
+      id,
+      category: id,
+      priority,
+      debounceMs: 0,
+      async provide() {
+        return [makeResult(id)];
+      },
+    });
+
+    await renderHarness([provider("late", 50), provider("early", 10)], "margin");
+    await settle();
+
+    expect(latestItems.map((item) => item.category)).toEqual(["early", "late"]);
+  });
+});
+
+describe("toProviderResultItem", () => {
+  test("namespaces the row, keeps its lines, and closes the bar after it runs", async () => {
+    let executed = 0;
+    let closed = 0;
+    const item = toProviderResultItem(
+      { id: "docs", category: "Documents", provide: async () => [] },
+      {
+        id: "hit-1",
+        label: "Q3 call",
+        detail: "CALL · Feb 02, 26",
+        right: "AAPL",
+        keywords: ["transcript"],
+        lines: [{ segments: [{ text: "margin ", emphasis: "muted" }, { text: "pressure", emphasis: "match" }] }],
+        execute: () => { executed += 1; },
+      },
+      () => { closed += 1; },
+    );
+
+    expect(item.id).toBe("search-provider:docs:hit-1");
+    expect(item.category).toBe("Documents");
+    expect(item.right).toBe("AAPL");
+    expect(item.lines?.[0]?.segments[1]?.emphasis).toBe("match");
+    expect(item.searchText).toContain("transcript");
+
+    await item.action();
+    expect(executed).toBe(1);
+    expect(closed).toBe(1);
+  });
+
+  test("does not run or close for a disabled row", async () => {
+    let executed = 0;
+    let closed = 0;
+    const item = toProviderResultItem(
+      { id: "docs", category: "Documents", provide: async () => [] },
+      { id: "gate", label: "Upgrade", disabled: true, execute: () => { executed += 1; } },
+      () => { closed += 1; },
+    );
+
+    await item.action();
+    expect(executed).toBe(0);
+    expect(closed).toBe(0);
+  });
+});

package/src/components/command-bar/routes/root/search-providers.ts

@@ -0,0 +1,205 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import type { PluginRegistry } from "../../../../plugins/registry";
+import type {
+  CommandBarResultDef,
+  CommandBarSearchContext,
+  CommandBarSearchProvider,
+} from "../../../../types/plugin";
+import type { ResultItem } from "../../list/model";
+
+const DEFAULT_MIN_QUERY_LENGTH = 3;
+const DEFAULT_DEBOUNCE_MS = 300;
+
+export function getAvailableCommandBarSearchProviders(
+  pluginRegistry: Pick<PluginRegistry, "commandBarSearchProviders" | "getCommandBarSearchProviderPluginId">,
+  disabledPlugins: readonly string[],
+): CommandBarSearchProvider[] {
+  const disabledPluginIds = new Set(disabledPlugins);
+  return [...pluginRegistry.commandBarSearchProviders.values()].filter((provider) => {
+    const pluginId = pluginRegistry.getCommandBarSearchProviderPluginId(provider.id);
+    return !pluginId || !disabledPluginIds.has(pluginId);
+  });
+}
+
+/**
+ * Turns one provider row into a list row. The command bar owns the row model, so
+ * a provider never gets to decide selection, kind, or what closing means.
+ */
+export function toProviderResultItem(
+  provider: CommandBarSearchProvider,
+  result: CommandBarResultDef,
+  onExecuted: () => void,
+): ResultItem {
+  return {
+    id: `search-provider:${provider.id}:${result.id}`,
+    label: result.label,
+    detail: result.detail ?? "",
+    category: result.category ?? provider.category,
+    kind: "action",
+    lines: result.lines,
+    badge: result.badge,
+    right: result.right,
+    searchText: [result.label, result.detail ?? "", ...(result.keywords ?? [])].join(" "),
+    disabled: result.disabled,
+    action: async () => {
+      if (result.disabled) return;
+      await result.execute();
+      onExecuted();
+    },
+  };
+}
+
+interface ProviderResults {
+  /** The exact query these rows answer; anything else on screen is stale. */
+  query: string;
+  items: ResultItem[];
+}
+
+interface UseCommandBarSearchProvidersOptions {
+  providers: readonly CommandBarSearchProvider[];
+  query: string;
+  /** False while a route is open or a prefix already claimed the query. */
+  enabled: boolean;
+  context: CommandBarSearchContext;
+  onExecuted: () => void;
+}
+
+/**
+ * Runs plugin search providers for the root list. Each provider debounces and
+ * aborts on its own, answers are memoized for the life of the bar, and rows are
+ * only ever added to the static list: a provider that fails, hangs, or answers
+ * late leaves what the command bar already resolved exactly as it was.
+ */
+export function useCommandBarSearchProviders({
+  providers,
+  query,
+  enabled,
+  context,
+  onExecuted,
+}: UseCommandBarSearchProvidersOptions): {
+  providerResultItems: ResultItem[];
+  providerSearching: boolean;
+} {
+  const [resultsByProvider, setResultsByProvider] = useState<Record<string, ProviderResults>>({});
+  const [loadingProviderIds, setLoadingProviderIds] = useState<readonly string[]>([]);
+  const cacheRef = useRef(new Map<string, CommandBarResultDef[]>());
+  const timersRef = useRef(new Map<string, ReturnType<typeof setTimeout>>());
+  const abortsRef = useRef(new Map<string, AbortController>());
+  /**
+   * Query each provider has already been asked for. Rendered state lags a tick
+   * behind, so reading it instead would let a re-render start a second request
+   * for text that is already in flight.
+   */
+  const handledQueriesRef = useRef(new Map<string, string>());
+  /** Read at request time only: selecting a ticker is not a new question. */
+  const contextRef = useRef(context);
+  contextRef.current = context;
+  const onExecutedRef = useRef(onExecuted);
+  onExecutedRef.current = onExecuted;
+
+  useEffect(() => {
+    const trimmed = query.trim();
+    const cancel = (providerId: string) => {
+      const timer = timersRef.current.get(providerId);
+      if (timer) {
+        clearTimeout(timer);
+        timersRef.current.delete(providerId);
+      }
+      abortsRef.current.get(providerId)?.abort();
+      abortsRef.current.delete(providerId);
+      handledQueriesRef.current.delete(providerId);
+    };
+    const setLoading = (providerId: string, loading: boolean) => {
+      setLoadingProviderIds((current) => {
+        const isLoading = current.includes(providerId);
+        if (loading === isLoading) return current;
+        return loading ? [...current, providerId] : current.filter((id) => id !== providerId);
+      });
+    };
+    const publish = (provider: CommandBarSearchProvider, forQuery: string, results: CommandBarResultDef[]) => {
+      setResultsByProvider((current) => ({
+        ...current,
+        [provider.id]: {
+          query: forQuery,
+          items: results.map((result) => toProviderResultItem(
+            provider,
+            result,
+            () => onExecutedRef.current(),
+          )),
+        },
+      }));
+    };
+
+    const activeProviderIds = new Set(providers.map((provider) => provider.id));
+    for (const providerId of [...handledQueriesRef.current.keys()]) {
+      if (!activeProviderIds.has(providerId)) cancel(providerId);
+    }
+
+    for (const provider of providers) {
+      const minLength = provider.minQueryLength ?? DEFAULT_MIN_QUERY_LENGTH;
+      if (!enabled || trimmed.length < minLength) {
+        cancel(provider.id);
+        setLoading(provider.id, false);
+        continue;
+      }
+      if (handledQueriesRef.current.get(provider.id) === trimmed) continue;
+
+      cancel(provider.id);
+      handledQueriesRef.current.set(provider.id, trimmed);
+
+      const cached = cacheRef.current.get(`${provider.id}\n${trimmed}`);
+      if (cached) {
+        setLoading(provider.id, false);
+        publish(provider, trimmed, cached);
+        continue;
+      }
+
+      setLoading(provider.id, true);
+      timersRef.current.set(provider.id, setTimeout(() => {
+        timersRef.current.delete(provider.id);
+        const controller = new AbortController();
+        abortsRef.current.set(provider.id, controller);
+        void (async () => {
+          try {
+            const results = await provider.provide(trimmed, contextRef.current, controller.signal);
+            if (controller.signal.aborted) return;
+            cacheRef.current.set(`${provider.id}\n${trimmed}`, results);
+            publish(provider, trimmed, results);
+          } catch {
+            // A provider is an extra, never a precondition: its failure leaves
+            // the rows the command bar resolved locally untouched.
+            if (controller.signal.aborted) return;
+            publish(provider, trimmed, []);
+          } finally {
+            if (abortsRef.current.get(provider.id) === controller) {
+              abortsRef.current.delete(provider.id);
+              setLoading(provider.id, false);
+            }
+          }
+        })();
+      }, provider.debounceMs ?? DEFAULT_DEBOUNCE_MS));
+    }
+  }, [enabled, providers, query]);
+
+  useEffect(() => () => {
+    for (const timer of timersRef.current.values()) clearTimeout(timer);
+    timersRef.current.clear();
+    for (const controller of abortsRef.current.values()) controller.abort();
+    abortsRef.current.clear();
+  }, []);
+
+  const providerResultItems = useMemo(() => {
+    const trimmed = query.trim();
+    if (!enabled) return [];
+    return [...providers]
+      .sort((left, right) => (left.priority ?? 0) - (right.priority ?? 0))
+      .flatMap((provider) => {
+        const results = resultsByProvider[provider.id];
+        return results?.query === trimmed ? results.items : [];
+      });
+  }, [enabled, providers, query, resultsByProvider]);
+
+  const providerSearching = enabled && providers.some((provider) => loadingProviderIds.includes(provider.id));
+
+  return { providerResultItems, providerSearching };
+}

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

@@ -32,7 +32,7 @@ interface RootSelectionCommandOptions {
   getAvailablePaneShortcutTemplates: (query: string) => PaneTemplateDef[];
   getAvailablePluginCommands: () => CommandDef[];
   openModeRoute: (
-    screen: "ticker-search" | "plugins" | "layout",
+    screen: "ticker-search" | "layout",
     initialQuery?: string,
     payload?: Record<string, unknown>,
   ) => void;
@@ -185,17 +185,6 @@ export function buildImmediateRootSelection(options: RootSelectionCommandOptions
     };
   }
 
-  if (match.command.id === "plugins") {
-    return {
-      id: "plugins-route",
-      label: "Manage Plugins",
-      detail: "Toggle optional plugins without leaving the command bar",
-      category: "Plugins",
-      kind: "command",
-      action: () => options.openModeRoute("plugins", match.arg),
-    };
-  }
-
   if (match.command.id === "layout") {
     return {
       id: "layout-route",

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

@@ -40,11 +40,11 @@ const paneTemplates: PaneTemplateDef[] = [
   },
   tickerTemplate("earnings-estimates-pane", "EE"),
   {
-    id: "provider-search-pane",
-    paneId: "provider-search-results",
-    label: "Provider Search",
-    description: "Search provider instruments",
-    shortcut: { prefix: "SRCH", argPlaceholder: "query", argKind: "text" },
+    id: "research-search-pane",
+    paneId: "research-search",
+    label: "Research Search",
+    description: "Full-text document search",
+    shortcut: { prefix: "SRCH", argPlaceholder: "query", argKind: "text", argOptional: true },
   },
   {
     id: "cds-pane",
@@ -125,19 +125,19 @@ describe("ticker data root shortcuts", () => {
     if (intent.kind === "none") throw new Error("Expected shortcut intent");
     expect(intent.source).toBe("pane-template");
     if (intent.source === "pane-template") {
-      expect(intent.template.id).toBe("provider-search-pane");
+      expect(intent.template.id).toBe("research-search-pane");
       expect(intent.argText).toBe("apple inc");
       expect(intent.completionQuery).toBeNull();
     }
   });
 
-  test("SRCH without a query remains a provider search shortcut", () => {
+  test("SRCH without a query remains a document search shortcut", () => {
     const intent = parse("SRCH");
     expect(intent.kind).toBe("partial");
     if (intent.kind === "none") throw new Error("Expected shortcut intent");
     expect(intent.source).toBe("pane-template");
     if (intent.source === "pane-template") {
-      expect(intent.template.id).toBe("provider-search-pane");
+      expect(intent.template.id).toBe("research-search-pane");
       expect(intent.argText).toBe("");
     }
   });