gloomberb 0.8.1 → 0.9.0

package/src/app/global-shortcuts.ts

@@ -62,7 +62,12 @@ export function useAppGlobalShortcuts({
     if (!isDetachedWindow && event.name === "`" && !state.commandBarOpen) {
       event.preventDefault();
       event.stopPropagation();
-      dispatch({ type: "SET_COMMAND_BAR", open: true, query: "" });
+      dispatch({
+        type: "SET_COMMAND_BAR",
+        open: true,
+        query: "",
+        launch: { kind: "ticker-search", query: "" },
+      });
       return;
     }
     if (!isDetachedWindow && /^[1-9]$/.test(event.name ?? "") && event.ctrl && (state.config.layouts ?? []).length > 1) {
@@ -96,18 +101,19 @@ export function useAppGlobalShortcuts({
 
     if (state.inputCaptured) return;
 
-    if (!isDetachedWindow && event.name === "q") {
+    const hasShortcutModifier = event.ctrl || event.meta || event.super || event.alt;
+    if (!hasShortcutModifier && !isDetachedWindow && event.name === "q") {
       rendererHost.requestExit();
-    } else if (event.name === "r") {
+    } else if (!hasShortcutModifier && event.name === "r") {
       if (focusedTickerSymbol) {
         const ticker = state.tickers.get(focusedTickerSymbol);
         if (ticker) refreshTicker(ticker.metadata.ticker, ticker.metadata.exchange, ticker, 0);
       }
-    } else if (event.name === "R" || (event.name === "r" && event.shift)) {
+    } else if (!hasShortcutModifier && (event.name === "R" || (event.name === "r" && event.shift))) {
       for (const ticker of state.tickers.values()) {
         refreshTicker(ticker.metadata.ticker, ticker.metadata.exchange, ticker, 1);
       }
-    } else if (event.name === "u" && state.updateAvailable && !state.updateProgress && !state.updateCheckInProgress && canSelfUpdate(state.updateAvailable)) {
+    } else if (!hasShortcutModifier && event.name === "u" && state.updateAvailable && !state.updateProgress && !state.updateCheckInProgress && canSelfUpdate(state.updateAvailable)) {
       startUpdate(state.updateAvailable);
     } else {
       const disabledPlugins = new Set(state.config.disabledPlugins || []);

package/src/capabilities/factories.ts

@@ -52,6 +52,10 @@ export function assetDataProvider(provider: AssetDataProvider): AssetDataCapabil
         if (!provider.getEarningsCalendar) throw new Error(`${provider.name} does not provide earnings calendar.`);
         return provider.getEarningsCalendar(input.symbols ?? [], input.context);
       }, "query"),
+      getSecFilingDocuments: op((input: any) => {
+        if (!provider.getSecFilingDocuments) throw new Error(`${provider.name} does not provide SEC filing documents.`);
+        return provider.getSecFilingDocuments(input.filing);
+      }, "query"),
       getSecFilingContent: op((input: any) => {
         if (!provider.getSecFilingContent) throw new Error(`${provider.name} does not provide SEC filing content.`);
         return provider.getSecFilingContent(input.filing);

package/src/components/chart/comparison/data.test.ts

@@ -57,6 +57,60 @@ describe("projectComparisonChartData", () => {
     expect(projection.series[1]?.points.map((point) => point.rawValue)).toEqual([null, null, 20, 22]);
   });
 
+  test("carries the latest series value across shared timestamps from other markets", () => {
+    const projection = projectComparisonChartData([
+      makeSeries("DAX", "EUR", [
+        ["2024-01-02T08:00:00.000Z", 100],
+        ["2024-01-02T08:15:00.000Z", 101],
+        ["2024-01-03T08:00:00.000Z", 102],
+      ]),
+      makeSeries("AAPL", "USD", [
+        ["2024-01-02T14:30:00.000Z", 200],
+        ["2024-01-02T14:45:00.000Z", 201],
+      ]),
+    ], 8, {
+      panOffset: 0,
+      zoomLevel: 1,
+      renderMode: "line",
+    }, "price");
+
+    expect(projection.dates.map((date) => date.toISOString())).toEqual([
+      "2024-01-02T08:00:00.000Z",
+      "2024-01-02T08:15:00.000Z",
+      "2024-01-02T14:30:00.000Z",
+      "2024-01-02T14:45:00.000Z",
+      "2024-01-03T08:00:00.000Z",
+    ]);
+    expect(projection.series[0]?.points.map((point) => point.rawValue)).toEqual([100, 101, 101, 101, 102]);
+    expect(projection.series[1]?.points.map((point) => point.rawValue)).toEqual([null, null, 200, 201, 201]);
+  });
+
+  test("uses the same alternating close bucket selection as stock chart projection", () => {
+    const projection = projectComparisonChartData([
+      makeSeries("DAX", "EUR", [
+        ["2024-01-02T08:00:00.000Z", 100],
+        ["2024-01-02T08:15:00.000Z", 105],
+        ["2024-01-02T14:30:00.000Z", 101],
+        ["2024-01-02T14:45:00.000Z", 99],
+      ]),
+      makeSeries("AAPL", "USD", [
+        ["2024-01-02T14:30:00.000Z", 200],
+        ["2024-01-02T14:45:00.000Z", 201],
+      ]),
+    ], 2, {
+      panOffset: 0,
+      zoomLevel: 1,
+      renderMode: "line",
+    }, "price");
+
+    expect(projection.dates.map((date) => date.toISOString())).toEqual([
+      "2024-01-02T08:15:00.000Z",
+      "2024-01-02T14:45:00.000Z",
+    ]);
+    expect(projection.series[0]?.points.map((point) => point.rawValue)).toEqual([105, 99]);
+    expect(projection.series[1]?.points.map((point) => point.rawValue)).toEqual([null, 200]);
+  });
+
   test("normalizes percent mode from each series first visible point", () => {
     const projection = projectComparisonChartData([
       makeSeries("AAPL", "USD", [

package/src/components/chart/comparison/data.ts

@@ -7,6 +7,11 @@ import type {
 } from "../core/types";
 import { buildVisibleDateWindowFromRange } from "../core/date-window";
 import { getVisiblePointCount } from "../core/viewport";
+import {
+  buildIndexProjectionBuckets,
+  selectRepresentativeCloseValue,
+  type IndexProjectionBucket,
+} from "../core/projection";
 
 export interface ComparisonProjectedPoint {
   date: Date;
@@ -38,6 +43,14 @@ interface ComparisonAxisModeResolution {
   warning: string | null;
 }
 
+type ComparisonWindowViewState =
+  Pick<ComparisonChartViewState, "panOffset" | "zoomLevel">
+  & Partial<Pick<ComparisonChartViewState, "dateWindow">>;
+
+type ComparisonProjectionViewState =
+  ComparisonWindowViewState
+  & Pick<ComparisonChartViewState, "renderMode">;
+
 export interface ComparisonChartProjection {
   dates: Date[];
   series: ComparisonProjectedSeries[];
@@ -92,7 +105,7 @@ export function getMaxComparisonPanOffset(
 
 export function getVisibleComparisonWindow(
   series: ComparisonChartSeries[],
-  viewState: Pick<ComparisonChartViewState, "dateWindow" | "panOffset" | "zoomLevel">,
+  viewState: ComparisonWindowViewState,
 ): ComparisonVisibleWindow {
   const dates = getUniqueSortedDates(series);
 
@@ -138,10 +151,7 @@ function transformRawValue(rawValue: number | null, axisMode: ChartAxisMode, bas
 }
 
 function resolveRepresentativeValue(values: number[], index: number): number {
-  if (values.length === 1) return values[0]!;
-  return index % 2 === 0
-    ? Math.max(...values)
-    : Math.min(...values);
+  return selectRepresentativeCloseValue(values, index, (value) => value);
 }
 
 function buildSeriesMap(points: PricePoint[]): Map<number, number> {
@@ -155,6 +165,28 @@ function buildSeriesMap(points: PricePoint[]): Map<number, number> {
   return map;
 }
 
+function buildFilledRawValuesByDate(
+  rawByDate: ReadonlyMap<number, number>,
+  dates: readonly Date[],
+): Array<number | null> {
+  let latestRawValue: number | null = null;
+  return dates.map((date) => {
+    const timestamp = date.getTime();
+    if (rawByDate.has(timestamp)) {
+      latestRawValue = rawByDate.get(timestamp)!;
+      return latestRawValue;
+    }
+    return latestRawValue;
+  });
+}
+
+function getBucketDate(
+  dates: readonly Date[],
+  bucket: IndexProjectionBucket,
+): Date {
+  return dates[Math.max(bucket.end - 1, 0)] ?? dates[dates.length - 1] ?? new Date(0);
+}
+
 function resolveComparisonAxisMode(
   requestedAxisMode: ChartAxisMode,
   series: ComparisonChartSeries[],
@@ -194,7 +226,7 @@ function resolveComparisonAxisMode(
 export function projectComparisonChartData(
   series: ComparisonChartSeries[],
   chartWidth: number,
-  viewState: Pick<ComparisonChartViewState, "dateWindow" | "panOffset" | "zoomLevel" | "renderMode">,
+  viewState: ComparisonProjectionViewState,
   requestedAxisMode: ChartAxisMode,
 ): ComparisonChartProjection {
   const normalizedSeries = series.map((entry) => ({ ...entry, points: normalizeSeriesPoints(entry.points) }));
@@ -221,31 +253,26 @@ export function projectComparisonChartData(
       warning: axisResolution.warning,
     };
   }
-  const bucketCount = Math.min(Math.max(chartWidth, 1), Math.max(window.dates.length, 1));
-  const bucketSize = window.dates.length > 0 ? window.dates.length / bucketCount : 1;
+  const buckets = buildIndexProjectionBuckets(window.dates.length, chartWidth);
 
   const projectedSeries = normalizedSeries.map((entry) => {
     const rawByDate = buildSeriesMap(entry.points);
-    const visibleRawValues = window.dates
-      .map((date) => rawByDate.get(date.getTime()) ?? null)
+    const filledRawValues = buildFilledRawValuesByDate(rawByDate, window.dates);
+    const visibleRawValues = filledRawValues
       .filter((value): value is number => value !== null);
     const baseValue = visibleRawValues[0] ?? null;
     const latestRawValue = visibleRawValues[visibleRawValues.length - 1] ?? null;
 
-    const points = Array.from({ length: bucketCount }, (_, index) => {
-      const start = Math.floor(index * bucketSize);
-      const end = Math.min(window.dates.length, Math.max(Math.floor((index + 1) * bucketSize), start + 1));
-      const bucketDates = window.dates.slice(start, end);
-      const date = bucketDates[bucketDates.length - 1] ?? window.dates[window.dates.length - 1] ?? new Date(0);
-      const bucketRawValues = bucketDates
-        .map((bucketDate) => rawByDate.get(bucketDate.getTime()) ?? null)
+    const points = buckets.map((bucket) => {
+      const bucketRawValues = filledRawValues
+        .slice(bucket.start, bucket.end)
         .filter((value): value is number => value !== null);
       const rawValue = bucketRawValues.length > 0
-        ? resolveRepresentativeValue(bucketRawValues, index)
+        ? resolveRepresentativeValue(bucketRawValues, bucket.index)
         : null;
 
       return {
-        date,
+        date: getBucketDate(window.dates, bucket),
         rawValue,
         value: transformRawValue(rawValue, axisResolution.effectiveAxisMode, baseValue),
       };
@@ -264,11 +291,7 @@ export function projectComparisonChartData(
   });
 
   return {
-    dates: Array.from({ length: bucketCount }, (_, index) => {
-      const start = Math.floor(index * bucketSize);
-      const end = Math.min(window.dates.length, Math.max(Math.floor((index + 1) * bucketSize), start + 1));
-      return window.dates[Math.max(end - 1, 0)] ?? new Date(0);
-    }),
+    dates: buckets.map((bucket) => getBucketDate(window.dates, bucket)),
     series: projectedSeries,
     requestedMode,
     effectiveMode: requestedMode,

package/src/components/chart/core/projection.ts

@@ -24,6 +24,12 @@ export interface ProjectChartDataOptions {
   sourceIndexOffset?: number;
 }
 
+export interface IndexProjectionBucket {
+  index: number;
+  start: number;
+  end: number;
+}
+
 interface StableOhlcProjectionOptionsInput {
   pointCount: number;
   sourceIndexOffset: number;
@@ -131,6 +137,44 @@ function aggregateOhlcBucket(bucket: readonly ProjectedChartPoint[]): ProjectedC
   };
 }
 
+export function buildIndexProjectionBuckets(
+  itemCount: number,
+  targetWidth: number,
+): IndexProjectionBucket[] {
+  const normalizedItemCount = Math.max(Math.floor(itemCount), 0);
+  if (normalizedItemCount === 0) return [];
+
+  const bucketCount = Math.min(normalizedItemCount, Math.max(Math.floor(targetWidth), 1));
+  const bucketSize = normalizedItemCount / bucketCount;
+
+  return Array.from({ length: bucketCount }, (_, index) => {
+    const start = Math.floor(index * bucketSize);
+    const end = Math.min(
+      normalizedItemCount,
+      Math.max(Math.floor((index + 1) * bucketSize), start + 1),
+    );
+    return { index, start, end };
+  });
+}
+
+export function selectRepresentativeCloseValue<T>(
+  bucket: readonly T[],
+  index: number,
+  getClose: (item: T) => number,
+): T {
+  let best = bucket[0] as T;
+  if (index % 2 === 0) {
+    for (const item of bucket) {
+      if (getClose(item) > getClose(best)) best = item;
+    }
+  } else {
+    for (const item of bucket) {
+      if (getClose(item) < getClose(best)) best = item;
+    }
+  }
+  return best;
+}
+
 function bucketOhlcBySourceIndex(
   normalizedPoints: readonly ProjectedChartPoint[],
   bucketSize: number,
@@ -202,33 +246,13 @@ function projectCloseSeries(
   targetWidth: number,
 ): ProjectedChartPoint[] {
   if (points.length === 0) return [];
-  if (points.length <= targetWidth) return points.map(normalizePoint);
-
-  const result: ProjectedChartPoint[] = [];
-  const bucketSize = points.length / targetWidth;
-
-  for (let i = 0; i < targetWidth; i++) {
-    const start = Math.floor(i * bucketSize);
-    const end = Math.min(points.length, Math.max(Math.floor((i + 1) * bucketSize), start + 1));
-    const bucket = points.slice(start, end);
-
-    if (bucket.length === 0) continue;
-
-    // Alternate bucket extremes to preserve line/area shape after downsampling.
-    let best = bucket[0]!;
-    if (i % 2 === 0) {
-      for (const point of bucket) {
-        if (point.close > best.close) best = point;
-      }
-    } else {
-      for (const point of bucket) {
-        if (point.close < best.close) best = point;
-      }
-    }
-    result.push(normalizePoint(best));
-  }
-
-  return result;
+  return buildIndexProjectionBuckets(points.length, targetWidth).map((bucket) => (
+    normalizePoint(selectRepresentativeCloseValue(
+      points.slice(bucket.start, bucket.end),
+      bucket.index,
+      (point) => point.close,
+    ))
+  ));
 }
 
 /**

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

@@ -229,6 +229,7 @@ export function useCommandBarActionRuntime({
     activeTickerSymbol,
     commandBarLaunchRequest: state.commandBarLaunchRequest,
     commandBarOpen: state.commandBarOpen,
+    openModeRoute,
     openPluginCommandWorkflow,
     pluginRegistry,
   });

package/src/components/command-bar/layout-items/current-layout.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from "bun:test";
+import { createInitialState, type AppAction, type AppState } from "../../../state/app/context";
+import { cloneLayout, createDefaultConfig, type LayoutConfig } from "../../../types/config";
+import type { PluginRegistry } from "../../../plugins/registry";
+import type { CommandBarRoute } from "../workflow/types";
+import type { LayoutItemsContext } from "./types";
+import { buildCurrentLayoutItems } from "./current-layout";
+
+type InlineConfirmOptions = Parameters<LayoutItemsContext["openInlineConfirm"]>[0];
+
+function createFloatingLayoutFixture(): { layout: LayoutConfig; state: AppState } {
+  const config = createDefaultConfig("/tmp/gloomberb-layout-actions-test");
+  const mainPane = config.layout.instances.find((instance) => instance.instanceId === "portfolio-list:main");
+  const firstDetailPane = config.layout.instances.find((instance) => instance.instanceId === "ticker-detail:main");
+  if (!mainPane || !firstDetailPane) throw new Error("missing default panes");
+
+  const secondDetailPane = {
+    ...firstDetailPane,
+    instanceId: "ticker-detail:secondary",
+  };
+  const layout: LayoutConfig = {
+    dockRoot: { kind: "pane", instanceId: "portfolio-list:main" },
+    instances: [{ ...mainPane }, { ...firstDetailPane }, secondDetailPane],
+    floating: [
+      { instanceId: "ticker-detail:main", x: 4, y: 2, width: 30, height: 8 },
+      { instanceId: "ticker-detail:secondary", x: 8, y: 3, width: 30, height: 8 },
+    ],
+    detached: [],
+  };
+  const state = createInitialState({
+    ...config,
+    layout: cloneLayout(layout),
+    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
+  });
+  return { layout, state };
+}
+
+function createLayoutItemsContext(
+  options: {
+    confirmDangerousActions?: boolean;
+    layouts: LayoutConfig[];
+    confirmations: InlineConfirmOptions[];
+  },
+): LayoutItemsContext {
+  const { layout, state } = createFloatingLayoutFixture();
+  return {
+    closeAll: () => {},
+    currentLayout: layout,
+    dispatch: (_action: AppAction) => {},
+    duplicatePane: () => {},
+    focusedPaneId: state.focusedPaneId,
+    notifyGridlockRevert: () => {},
+    openBuiltInWorkflow: () => {},
+    openInlineConfirm: (confirmOptions) => {
+      options.confirmations.push(confirmOptions);
+    },
+    persistLayoutChange: (nextLayout) => {
+      options.layouts.push(nextLayout);
+    },
+    pluginRegistry: {
+      getTermSizeFn: () => ({ width: 80, height: 24 }),
+    } as PluginRegistry,
+    pushRoute: (_route: CommandBarRoute) => {},
+    state,
+    ...(options.confirmDangerousActions === undefined ? {} : { confirmDangerousActions: options.confirmDangerousActions }),
+  };
+}
+
+describe("buildCurrentLayoutItems", () => {
+  test("closes all floating panes from the current layout", () => {
+    const layouts: LayoutConfig[] = [];
+    const confirmations: InlineConfirmOptions[] = [];
+    const items = buildCurrentLayoutItems(createLayoutItemsContext({ layouts, confirmations }));
+
+    const item = items.find((entry) => entry.id === "layout-close-all-floating");
+    expect(item).toMatchObject({
+      label: "Close All Floating Panes",
+      disabled: false,
+    });
+
+    item?.action();
+
+    expect(confirmations).toEqual([]);
+    expect(layouts).toHaveLength(1);
+    expect(layouts[0]?.floating).toEqual([]);
+    expect(layouts[0]?.instances.map((instance) => instance.instanceId)).toEqual(["portfolio-list:main"]);
+    expect(layouts[0]?.dockRoot).toEqual({ kind: "pane", instanceId: "portfolio-list:main" });
+  });
+
+  test("confirms before closing all floating panes when dangerous actions are guarded", () => {
+    const layouts: LayoutConfig[] = [];
+    const confirmations: InlineConfirmOptions[] = [];
+    const items = buildCurrentLayoutItems(createLayoutItemsContext({
+      confirmDangerousActions: true,
+      layouts,
+      confirmations,
+    }));
+
+    items.find((entry) => entry.id === "layout-close-all-floating")?.action();
+
+    expect(layouts).toEqual([]);
+    expect(confirmations).toHaveLength(1);
+    expect(confirmations[0]).toMatchObject({
+      confirmId: "layout-close-all-floating",
+      title: "Close All Floating Panes",
+      confirmLabel: "Close Floating Panes",
+      tone: "danger",
+    });
+
+    confirmations[0]?.onConfirm();
+
+    expect(layouts).toHaveLength(1);
+    expect(layouts[0]?.floating).toEqual([]);
+  });
+});

package/src/components/command-bar/layout-items/current-layout.ts

@@ -1,5 +1,6 @@
 import {
   gridlockAllPanes,
+  removeFloatingPanes,
 } from "../../../plugins/pane-manager";
 import {
   DEFAULT_LAYOUT,
@@ -21,6 +22,8 @@ export function buildCurrentLayoutItems({
   state,
 }: LayoutItemsContext): ResultItem[] {
   const layoutHistory = state.layoutHistory[state.config.activeLayoutIndex];
+  const floatingPaneCount = currentLayout.floating.length;
+  const floatingPaneLabel = floatingPaneCount === 1 ? "floating pane" : "floating panes";
 
   return [
     {
@@ -89,6 +92,36 @@ export function buildCurrentLayoutItems({
         closeAll({ revertThemePreview: false });
       },
     },
+    {
+      id: "layout-close-all-floating",
+      label: "Close All Floating Panes",
+      detail: floatingPaneCount > 0
+        ? `Remove ${floatingPaneCount} ${floatingPaneLabel} from the current layout`
+        : "No floating panes in the current layout",
+      category: "Current Layout",
+      kind: "action",
+      disabled: floatingPaneCount === 0,
+      action: confirmDangerousActions
+        ? () => {
+          if (floatingPaneCount === 0) return;
+          openInlineConfirm({
+            confirmId: "layout-close-all-floating",
+            title: "Close All Floating Panes",
+            body: [`Close ${floatingPaneCount} ${floatingPaneLabel}?`],
+            confirmLabel: "Close Floating Panes",
+            cancelLabel: "Back",
+            tone: "danger",
+            onConfirm: () => {
+              persistLayoutChange(removeFloatingPanes(currentLayout));
+            },
+          });
+        }
+        : () => {
+          if (floatingPaneCount === 0) return;
+          persistLayoutChange(removeFloatingPanes(currentLayout));
+          closeAll({ revertThemePreview: false });
+        },
+    },
     {
       id: "layout-rename",
       label: "Rename Layout",

package/src/components/command-bar/list/view.tsx

@@ -19,6 +19,7 @@ export type CommandBarListScrollEvent = {
 
 interface CommandBarListHeaderProps {
   kind: ListScreenState["kind"];
+  title: string;
   query: string;
   queryDisplayWidth: number;
   nativePaneChrome: boolean;
@@ -36,6 +37,7 @@ interface CommandBarListHeaderProps {
 
 export const CommandBarListHeader = memo(function CommandBarListHeader({
   kind,
+  title,
   query,
   queryDisplayWidth,
   nativePaneChrome,
@@ -66,7 +68,7 @@ export const CommandBarListHeader = memo(function CommandBarListHeader({
             value={query}
             onInput={onQueryChange}
             onChange={onQueryChange}
-            placeholder={kind === "root" ? "Search" : "Filter"}
+            placeholder={kind === "root" ? "Search commands" : title === "Security Description" ? "Search tickers" : "Filter"}
             focused
             width={nativePaneChrome ? "100%" : queryDisplayWidth}
             backgroundColor={nativePaneChrome ? "transparent" : paletteBg}

package/src/components/command-bar/pane-templates/items.ts

@@ -141,7 +141,10 @@ export function buildPaneTemplateItem(options: {
   const arg = options.createOptions?.arg;
 
   const action = () => {
-    if (options.shortcutExecution && options.template.shortcut) {
+    if (
+      options.template.shortcut
+      && (options.shortcutExecution || getPaneTemplateArgKind(options.template) === "ticker")
+    ) {
       options.runPaneTemplateShortcut(options.template, arg);
       return;
     }

package/src/components/command-bar/panel/body.tsx

@@ -130,6 +130,7 @@ export function CommandBarPanelBody({
         {(visibleListState || currentRoute?.kind === "picker") && visibleListState && (
           <CommandBarListHeader
             kind={visibleListState.kind}
+            title={visibleListState.title}
             query={visibleListState.query}
             queryDisplayWidth={queryDisplayWidth}
             nativePaneChrome={nativePaneChrome}

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

@@ -6,12 +6,10 @@ import type {
 } from "../../../../types/plugin";
 import type { TickerRecord } from "../../../../types/ticker";
 import { fuzzyFilter } from "../../../../utils/fuzzy-search";
-import type { TickerSearchCandidate } from "../../../../tickers/search";
 import { matchPrefix, type Command } from "../../commands/registry";
 import { isCollectionCommand } from "../../helpers";
 import type { ResultItem } from "../../list/model";
 import type { parseRootShortcutIntent } from "./shortcuts";
-import { createQuickLookTickerCandidates } from "../ticker-search/results";
 import type { CommandBarRoute } from "../../workflow/types";
 import { createRootCommandItemBuilder } from "./command-items";
 import { buildRootShortcutItem } from "./shortcut-items";
@@ -55,7 +53,6 @@ export interface RootResultModelOptions {
   getAvailablePaneShortcutTemplates: (query: string) => PaneTemplateDef[];
   hasPaneSettings: (paneId: string) => boolean;
   localTickerSearchResultItems: (query?: string, options?: { category?: string; limit?: number }) => ResultItem[];
-  mapTickerSearchCandidateToResultItem: (candidate: TickerSearchCandidate) => ResultItem;
   nonShortcutPaneTemplateItems: (filterQuery?: string) => ResultItem[];
   openModeRoute: (screen: "ticker-search" | "plugins" | "layout", initialQuery?: string) => void;
   paneShortcutItems: (options?: PaneShortcutItemsOptions) => ResultItem[];
@@ -86,7 +83,6 @@ export function buildRootResultModel(options: RootResultModelOptions): RootResul
     getAvailablePaneShortcutTemplates,
     hasPaneSettings,
     localTickerSearchResultItems,
-    mapTickerSearchCandidateToResultItem,
     nonShortcutPaneTemplateItems,
     openModeRoute,
     paneShortcutItems,
@@ -180,30 +176,6 @@ export function buildRootResultModel(options: RootResultModelOptions): RootResul
     const item = commandToItem(match.command);
     if (item) items.push(item);
   } else if (!rootQuery) {
-    const maxDefaultTickers = 5;
-    const recentSymbols = state.recentTickers.slice(0, maxDefaultTickers);
-    const recentTickers = recentSymbols
-      .map((symbol) => state.tickers.get(symbol))
-      .filter((ticker): ticker is NonNullable<typeof ticker> => (
-        ticker != null && createQuickLookTickerCandidates([ticker]).length > 0
-      ));
-    if (recentTickers.length < maxDefaultTickers) {
-      const seen = new Set(recentSymbols);
-      for (const ticker of state.tickers.values()) {
-        if (recentTickers.length >= maxDefaultTickers) break;
-        if (createQuickLookTickerCandidates([ticker]).length === 0) continue;
-        if (!seen.has(ticker.metadata.ticker)) recentTickers.push(ticker);
-      }
-    }
-    items.push(...recentTickers.flatMap((ticker) => {
-      const candidate = createQuickLookTickerCandidates([ticker])[0];
-      return candidate
-        ? [{
-          ...mapTickerSearchCandidateToResultItem(candidate),
-          category: "Tickers",
-        }]
-        : [];
-    }));
     items.push(...paneShortcutItems());
     for (const command of availableCommands) {
       const item = commandToItem(command);
@@ -212,12 +184,10 @@ export function buildRootResultModel(options: RootResultModelOptions): RootResul
     items.push(...tickerActionItems());
     items.push(...pluginCommandItems());
   } else {
-    const tickerItems = localTickerSearchResultItems(undefined, { category: "Tickers" });
     const commandItems = availableCommands
       .map((command) => commandToItem(command))
       .filter((item): item is ResultItem => item !== null);
     const allItems = [
-      ...tickerItems,
       ...commandItems,
       ...buildLayoutItems("", { confirmDangerousActions: true }),
       ...buildPaneSettingItems(state.focusedPaneId, rootQuery),