gloomberb 0.10.4 → 0.11.0

package/src/components/chart/composite/panel-series.ts

@@ -0,0 +1,101 @@
+import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
+
+function sameTime(left: Date | undefined, right: Date | undefined): boolean {
+  if (left === right) return true;
+  if (!left || !right) return left == right;
+  return left.getTime() === right.getTime();
+}
+
+function samePoint(left: TimeSeriesPoint, right: TimeSeriesPoint): boolean {
+  return left === right
+    || (
+      sameTime(left.date, right.date)
+      && sameTime(left.observedAt, right.observedAt)
+      && sameTime(left.availableAt, right.availableAt)
+      && left.value === right.value
+      && left.open === right.open
+      && left.high === right.high
+      && left.low === right.low
+      && left.close === right.close
+      && left.volume === right.volume
+      && left.periodLabel === right.periodLabel
+    );
+}
+
+function sameSeriesMeta(left: ResolvedSeries, right: ResolvedSeries): boolean {
+  return left.id === right.id
+    && left.label === right.label
+    && left.color === right.color
+    && left.unit === right.unit
+    && left.unitGroup === right.unitGroup
+    && left.nativeFrequency === right.nativeFrequency
+    && left.timestampMode === right.timestampMode
+    && left.dataShape === right.dataShape
+    && left.style === right.style
+    && left.transform === right.transform
+    && left.axis === right.axis
+    && left.panelId === right.panelId
+    && left.interpolation === right.interpolation
+    && left.warning === right.warning
+    && left.hidden === right.hidden
+    && left.timeBasis?.kind === right.timeBasis?.kind
+    && left.timeBasis?.timeZone === right.timeBasis?.timeZone
+    && left.timeBasis?.cadenceMs === right.timeBasis?.cadenceMs;
+}
+
+function prefixPointsEqual(left: readonly TimeSeriesPoint[], right: readonly TimeSeriesPoint[]): boolean {
+  if (left.length !== right.length || left.length === 0) return false;
+  for (let index = 0; index < left.length - 1; index += 1) {
+    if (!samePoint(left[index]!, right[index]!)) return false;
+  }
+  return true;
+}
+
+/**
+ * Reuses a previous ResolvedSeries object when a parent allocated a new wrapper
+ * for the same data, including live ticks that only change the last bar's
+ * close/time. Bitmap dirty detection keys off object identity, so this keeps
+ * an otherwise-stable plot from full-rerastering on every quote.
+ */
+export function reuseResolvedSeriesIdentity(
+  previous: ResolvedSeries | undefined,
+  next: ResolvedSeries,
+): ResolvedSeries {
+  if (!previous) return next;
+  if (previous === next) return next;
+  if (!sameSeriesMeta(previous, next)) return next;
+  if (previous.points === next.points && previous.latestChangePercent === next.latestChangePercent) {
+    return previous;
+  }
+  if (previous.points.length !== next.points.length) return next;
+  const lastPrev = previous.points[previous.points.length - 1]!;
+  const lastNext = next.points[next.points.length - 1]!;
+  if (!samePoint(lastPrev, lastNext)) {
+    if (!prefixPointsEqual(previous.points, next.points)) return next;
+    previous.points[previous.points.length - 1] = lastNext;
+    previous.latestChangePercent = next.latestChangePercent;
+    return previous;
+  }
+  if (previous.points.every((point, index) => samePoint(point, next.points[index]!))) {
+    if (previous.latestChangePercent === next.latestChangePercent) return previous;
+    previous.latestChangePercent = next.latestChangePercent;
+    return previous;
+  }
+  return next;
+}
+
+export function reuseResolvedSeriesList(
+  previous: readonly ResolvedSeries[] | undefined,
+  next: readonly ResolvedSeries[],
+): ResolvedSeries[] {
+  if (!previous) return next as ResolvedSeries[];
+  if (previous === next) return previous as ResolvedSeries[];
+  const reused = next.map((series, index) => reuseResolvedSeriesIdentity(previous[index], series));
+  if (
+    reused.length === previous.length
+    && reused.every((series, index) => series === previous[index])
+  ) {
+    return previous as ResolvedSeries[];
+  }
+  return reused;
+}

package/src/components/chart/multi-line/renderer.ts

@@ -6,6 +6,7 @@ import { valueToPixelY, type MultiLineChartScene, type MultiLineProjectedPoint }
 export {
   buildMultiLineChartScene,
   resolveMultiLineCursorDate,
+  valueToPixelY,
 } from "./scene";
 export type {
   MultiLineChartColors,

package/src/components/chart/native/kitty/index.test.ts

@@ -11,7 +11,11 @@ import {
 } from "../chart-rasterizer";
 import { KittyImageManager } from "./manager";
 import { chunkBase64Payload, encodeKittyTransmitRgba } from "./protocol";
-import { ensureKittySupport, getCachedKittySupport } from "./support";
+import {
+  ensureKittySupport,
+  getCachedKittySupport,
+  resolveKittySupport,
+} from "./support";
 import { resolveChartRendererState } from "../renderer-selection";
 import { computeSurfaceVisibleFragments, NativeSurfaceManager } from "../surface/manager";
 import { syncCachedNativeSurface } from "../surface/sync";
@@ -42,9 +46,27 @@ describe("resolveChartRendererState", () => {
   });
 });
 
+describe("resolveKittySupport", () => {
+  const noMultiplexer = { TERM: "xterm-kitty" } as Record<string, string | undefined>;
+
+  test("never claims support behind a multiplexer, whatever it advertises", () => {
+    expect(resolveKittySupport({ kitty_graphics: true, multiplexer: "tmux" }, noMultiplexer)).toBe(false);
+    expect(resolveKittySupport({ kitty_graphics: true }, { TERM: "tmux-256color" })).toBe(false);
+    expect(resolveKittySupport({ kitty_graphics: true }, { TERM_PROGRAM: "tmux" })).toBe(false);
+    expect(resolveKittySupport({ kitty_graphics: true }, { TMUX: "/tmp/tmux-501/default,1,0" })).toBe(false);
+  });
+
+  test("keeps confirmed support and leaves an unanswered query undecided", () => {
+    expect(resolveKittySupport({ kitty_graphics: true, multiplexer: "none" }, noMultiplexer)).toBe(true);
+    expect(resolveKittySupport({ kitty_graphics: false }, noMultiplexer)).toBe(false);
+    expect(resolveKittySupport({}, noMultiplexer)).toBe(null);
+    expect(resolveKittySupport(null, noMultiplexer)).toBe(null);
+  });
+});
+
 describe("getCachedKittySupport", () => {
   test("prefers later renderer capabilities over a failed query cache", async () => {
-    let capabilities: { kitty_graphics?: boolean } | null = null;
+    let capabilities: { kitty_graphics?: boolean; multiplexer?: string } | null = null;
     const renderer = {
       isDestroyed: false,
       get capabilities() {
@@ -60,7 +82,7 @@ describe("getCachedKittySupport", () => {
     expect(await ensureKittySupport(renderer)).toBe(false);
     expect(getCachedKittySupport(renderer)).toBe(false);
 
-    capabilities = { kitty_graphics: true };
+    capabilities = { kitty_graphics: true, multiplexer: "none" };
     expect(getCachedKittySupport(renderer)).toBe(true);
   });
 });

package/src/components/chart/native/kitty/support.ts

@@ -2,8 +2,9 @@ import { type NativeRendererHost as CliRenderer } from "../../../../ui";
 import { writeRendererRaw } from "./adapter";
 import { buildKittyGraphicsQuery } from "./protocol";
 
-interface RendererCapabilities {
+export interface RendererCapabilities {
   kitty_graphics?: boolean;
+  multiplexer?: string;
 }
 
 interface SupportCacheEntry {
@@ -14,11 +15,42 @@ interface SupportCacheEntry {
 const supportCache = new WeakMap<CliRenderer, SupportCacheEntry>();
 const QUERY_TIMEOUT_MS = 250;
 
-function readKnownSupport(renderer: CliRenderer): boolean | null {
-  const capabilities = renderer.capabilities as RendererCapabilities | null;
+/**
+ * A multiplexer swallows the graphics query and then passes image payloads
+ * through as literal text, which shreds the screen. Whatever it advertises,
+ * kitty graphics are not usable behind one.
+ */
+export function isMultiplexedTerminal(
+  capabilities: RendererCapabilities | null | undefined,
+  env: Record<string, string | undefined> = process.env,
+): boolean {
+  const reported = capabilities?.multiplexer;
+  // The renderer's own detection wins when it has one; the environment is only
+  // consulted when nothing was reported.
+  if (typeof reported === "string") return reported !== "none";
+  if (env.TMUX) return true;
+  const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
+  if (termProgram === "tmux" || termProgram === "screen") return true;
+  const term = (env.TERM ?? "").toLowerCase();
+  return term.startsWith("tmux") || term.startsWith("screen");
+}
+
+/**
+ * What is known about kitty graphics before querying: `null` means undecided,
+ * so the query result (or its absence) decides.
+ */
+export function resolveKittySupport(
+  capabilities: RendererCapabilities | null | undefined,
+  env: Record<string, string | undefined> = process.env,
+): boolean | null {
+  if (isMultiplexedTerminal(capabilities, env)) return false;
   return typeof capabilities?.kitty_graphics === "boolean" ? capabilities.kitty_graphics : null;
 }
 
+function readKnownSupport(renderer: CliRenderer): boolean | null {
+  return resolveKittySupport(renderer.capabilities as RendererCapabilities | null);
+}
+
 export function getCachedKittySupport(renderer: CliRenderer): boolean | null {
   const known = readKnownSupport(renderer);
   if (known !== null) return known;
@@ -54,6 +86,8 @@ export function ensureKittySupport(renderer: CliRenderer): Promise<boolean> {
       if (supported !== null) finish(supported);
     };
 
+    // No answer means unsupported: a terminal that speaks the protocol answers,
+    // and anything that swallows the query would also swallow the image.
     const timer = setTimeout(() => finish(false), QUERY_TIMEOUT_MS);
     renderer.on("capabilities", onCapabilities);
     if (!writeRendererRaw(renderer, `${buildKittyGraphicsQuery()}\x1b[c`)) {

package/src/components/chart/native/use-chart-text-fallback.ts

@@ -0,0 +1,19 @@
+import { useNativeRenderer } from "../../../ui";
+import { useOptionalAppSelector } from "../../../state/app/context";
+import type { ChartRendererPreference } from "../core/types";
+import { useResolvedChartRendererState } from "./renderer-selection";
+
+/**
+ * Cell-character plot text is only visible when kitty is not the active chart
+ * renderer. Skip rebuilding braille/ASCII fallback while the native bitmap is
+ * on screen.
+ */
+export function useShowChartTextFallback(): boolean {
+  const renderer = useNativeRenderer();
+  const preferredRenderer = useOptionalAppSelector<ChartRendererPreference>(
+    (state) => state.config.chartPreferences.renderer,
+    "braille",
+  );
+  const rendererState = useResolvedChartRendererState(preferredRenderer, renderer);
+  return rendererState.renderer !== "kitty";
+}

package/src/components/chart/static/chart/surface.tsx

@@ -8,8 +8,10 @@ import {
   computeGridLines,
   renderChart,
   type RenderChartOptions,
+  type RenderChartResult,
 } from "../../core/renderer";
 import { renderNativeChartBase, type NativeChartBitmap } from "../../native/chart-rasterizer";
+import { useShowChartTextFallback } from "../../native/use-chart-text-fallback";
 import { useStaticChartBitmapSize } from "./bitmap";
 import {
   StaticXAxisLabels,
@@ -103,6 +105,7 @@ export function StaticChartSurface({
 }: StaticChartSurfaceProps) {
   const themeColors = useThemeColors();
   const { cellWidthPx = 8, cellHeightPx = 18 } = useUiCapabilities();
+  const showTextFallback = useShowChartTextFallback();
   const plotRef = useRef<BoxRenderable | null>(null);
   const [cursor, setCursor] = useState<{ x: number; y: number } | null>(null);
   const xAxisRows = showTimeAxis || (xAxisLabels?.length ?? 0) > 0 ? 1 : 0;
@@ -157,13 +160,13 @@ export function StaticChartSurface({
   const axisGap = axisWidth > 0 ? 1 : 0;
   const plotWidth = Math.max(1, totalWidth - axisWidth - axisGap);
   const bitmapSize = useStaticChartBitmapSize(plotWidth, plotHeight);
-  const renderOptions = useMemo<RenderChartOptions>(() => ({
+  const plotOptions = useMemo<RenderChartOptions>(() => ({
     width: plotWidth,
     height: plotHeight,
     showVolume,
     volumeHeight,
-    cursorX: cursor?.x ?? null,
-    cursorY: cursor?.y ?? null,
+    cursorX: null,
+    cursorY: null,
     mode,
     axisMode,
     currency,
@@ -180,15 +183,45 @@ export function StaticChartSurface({
     mode,
     plotHeight,
     plotWidth,
-    cursor,
     showVolume,
     timeAxisDates,
     volumeHeight,
   ]);
-  const textResult = useMemo(
-    () => renderChart(points, renderOptions),
-    [points, renderOptions],
+  const cursorOptions = useMemo<RenderChartOptions>(() => ({
+    ...plotOptions,
+    cursorX: cursor?.x ?? null,
+    cursorY: cursor?.y ?? null,
+  }), [cursor, plotOptions]);
+  const plotScene = useMemo(
+    () => buildChartScene(points, plotOptions),
+    [plotOptions, points],
+  );
+  const cursorScene = useMemo(
+    () => {
+      if (showTextFallback || !cursor) return plotScene;
+      return buildChartScene(points, cursorOptions);
+    },
+    [cursor, cursorOptions, plotScene, points, showTextFallback],
   );
+  const textResult = useMemo<RenderChartResult>(() => {
+    if (showTextFallback) return renderChart(points, cursorOptions);
+    return {
+      lines: [],
+      axisLabels: [],
+      timeLabels: cursorScene?.timeLabels ?? "",
+      activePoint: cursorScene?.activePoint ?? null,
+      priceAtCursor: cursorScene?.priceAtCursor ?? null,
+      crosshairPrice: cursorScene?.crosshairPrice ?? null,
+      dateAtCursor: cursorScene?.dateAtCursor ?? null,
+      changeAtCursor: cursorScene?.changeAtCursor ?? null,
+      changePctAtCursor: cursorScene?.changePctAtCursor ?? null,
+      cursorColumn: cursorScene?.cursorColumn ?? null,
+      cursorRow: cursorScene?.cursorRow ?? null,
+      axisFractionDigits: null,
+      priceRange: cursorScene ? cursorScene.max - cursorScene.min : null,
+      pixelBuffer: null,
+    };
+  }, [cursorOptions, cursorScene, points, showTextFallback]);
   const effectiveAxisLabelsByRow = useMemo(() => {
     return new Map(axisLabels.map((entry) => [entry.row, entry.label] as const));
   }, [axisLabels]);
@@ -203,11 +236,9 @@ export function StaticChartSurface({
   const effectiveAxisWidth = axisWidth;
   const effectiveAxisGap = effectiveAxisWidth > 0 ? 1 : 0;
   const bitmap = useMemo<NativeChartBitmap | null>(() => {
-    if (!bitmapSize) return null;
-    const scene = buildChartScene(points, renderOptions);
-    if (!scene) return null;
-    return renderNativeChartBase(scene, bitmapSize.pixelWidth, bitmapSize.pixelHeight);
-  }, [bitmapSize, points, renderOptions]);
+    if (!bitmapSize || !plotScene) return null;
+    return renderNativeChartBase(plotScene, bitmapSize.pixelWidth, bitmapSize.pixelHeight);
+  }, [bitmapSize, plotScene]);
   const canvasCrosshair = useMemo<ChartSurfaceProps["crosshair"]>(() => {
     if (!bitmap || !cursor) return null;
     return {

package/src/components/chart/static/multi-line-chart-surface.tsx

@@ -1,8 +1,9 @@
 import { useCallback, useMemo, useRef } from "react";
-import { Box, ChartSurface, Text, type BoxRenderable } from "../../../ui";
+import { Box, ChartSurface, Text, type BoxRenderable, type ChartSurfaceProps } from "../../../ui";
 import { colors } from "../../../theme/colors";
 import { computeGridLines, formatAxisCell } from "../core/renderer";
 import type { NativeChartBitmap } from "../native/chart-rasterizer";
+import { useShowChartTextFallback } from "../native/use-chart-text-fallback";
 import { useStaticChartBitmapSize } from "./chart/bitmap";
 import {
   buildMultiLineChartScene,
@@ -10,6 +11,7 @@ import {
   renderMultiLineTimeAxis,
   renderNativeMultiLineChart,
   resolveMultiLineCursorDate,
+  valueToPixelY,
   type MultiLineChartColors,
   type MultiLineChartSeries,
 } from "../multi-line/renderer";
@@ -101,15 +103,27 @@ export function StaticMultiLineChartSurface({
     : 0;
   const axisGap = axisWidth > 0 ? 1 : 0;
   const plotWidth = Math.max(1, totalWidth - axisWidth - axisGap);
-  const scene = useMemo(() => buildMultiLineChartScene(series, {
+  const plotOptions = useMemo(() => ({
     width: plotWidth,
     height: plotHeight,
     colors: chartColors,
     dates,
-    cursorDate,
+    cursorDate: null as Date | null,
     yDomain,
-  }), [chartColors, cursorDate, dates, plotHeight, plotWidth, series, yDomain]);
-  const textLines = useMemo(() => scene ? renderMultiLineChart(scene) : [], [scene]);
+  }), [chartColors, dates, plotHeight, plotWidth, yDomain]);
+  const scene = useMemo(
+    () => buildMultiLineChartScene(series, plotOptions),
+    [plotOptions, series],
+  );
+  const cursorScene = useMemo(
+    () => cursorDate == null ? scene : buildMultiLineChartScene(series, { ...plotOptions, cursorDate }),
+    [cursorDate, plotOptions, scene, series],
+  );
+  const showTextFallback = useShowChartTextFallback();
+  const textLines = useMemo(() => {
+    if (!showTextFallback) return [];
+    return cursorScene ? renderMultiLineChart(cursorScene) : [];
+  }, [cursorScene, showTextFallback]);
   const timeLabels = useMemo(() => scene ? renderMultiLineTimeAxis(scene) : "", [scene]);
   const effectiveAxisLabelsByRow = useMemo(() => {
     return new Map(axisLabels.map((entry) => [entry.row, entry.label] as const));
@@ -119,6 +133,27 @@ export function StaticMultiLineChartSurface({
     if (!scene || !bitmapSize) return null;
     return renderNativeMultiLineChart(scene, bitmapSize.pixelWidth, bitmapSize.pixelHeight);
   }, [bitmapSize, scene]);
+  const canvasCrosshair = useMemo<ChartSurfaceProps["crosshair"]>(() => {
+    if (!bitmap || !cursorScene || cursorScene.cursorX === null) return null;
+    const pixelX = (cursorScene.cursorX / Math.max(cursorScene.width - 1, 1)) * Math.max(bitmap.width - 1, 0);
+    const cursorIndex = cursorScene.cursorIndex;
+    const markers = cursorIndex === null
+      ? []
+      : cursorScene.series.flatMap((item) => {
+        const point = item.points[cursorIndex];
+        if (!point) return [];
+        return [{
+          pixelY: valueToPixelY(point.value, cursorScene.min, cursorScene.max, bitmap.height),
+          color: item.color,
+        }];
+      });
+    return {
+      pixelX,
+      pixelY: markers[0]?.pixelY ?? bitmap.height / 2,
+      color: chartColors.crosshairColor,
+      markers: markers.length > 0 ? markers : undefined,
+    };
+  }, [bitmap, chartColors.crosshairColor, cursorScene]);
 
   const handleCursorEvent = useCallback((event: ChartMouseEventLike) => {
     if (!scene || !onCursorDateChange) return;
@@ -152,6 +187,7 @@ export function StaticMultiLineChartSurface({
           height={plotHeight}
           flexDirection="column"
           bitmaps={bitmap ? [bitmap] : null}
+          crosshair={canvasCrosshair}
           onMouseMove={handleCursorEvent}
           onMouseDown={handleCursorEvent}
         >

package/src/components/command-bar/commands/direct/index.ts

@@ -11,6 +11,7 @@ import {
   applyTheme,
   clearTransientThemePreview,
 } from "../../../../theme/colors";
+import { clampFontSize, MIN_FONT_SIZE_PX } from "../../../../theme/font-scale";
 import type { AppAction, AppState } from "../../../../state/app/context";
 import { isManualPortfolio } from "../../../../plugins/builtin/portfolio-list/mutations";
 import { CHART_RENDERER_PREFERENCES } from "../../../chart/core/types";
@@ -262,6 +263,23 @@ export function runDirectCommandAction(options: {
       closeAll({ revertThemePreview: false });
       return;
     }
+    case "font-size-increase":
+    case "font-size-decrease": {
+      const delta = command.id === "font-size-increase" ? 1 : -1;
+      const current = clampFontSize(state.config.fontSize);
+      const next = clampFontSize(current + delta);
+      if (next === current) {
+        notify(`Font size already at ${next === MIN_FONT_SIZE_PX ? "minimum" : "maximum"} (${next}px)`, { type: "info" });
+        closeAll({ revertThemePreview: false });
+        return;
+      }
+      const nextConfig = { ...state.config, fontSize: next };
+      dispatch({ type: "SET_CONFIG", config: nextConfig });
+      persistConfig(nextConfig);
+      notify(`Font size: ${next}px`, { type: "success" });
+      closeAll({ revertThemePreview: false });
+      return;
+    }
     case "check-for-updates":
       void onCheckForUpdates?.();
       closeAll({ revertThemePreview: false });

package/src/components/command-bar/commands/registry.ts

@@ -173,6 +173,20 @@ export const commands: Command[] = [
     description: "Turn quote update flashing on or off",
     category: "Config",
   },
+  {
+    id: "font-size-increase",
+    prefix: "FONT+",
+    label: "Increase Font Size",
+    description: "Increase the app-wide font size",
+    category: "Config",
+  },
+  {
+    id: "font-size-decrease",
+    prefix: "FONT-",
+    label: "Decrease Font Size",
+    description: "Decrease the app-wide font size",
+    category: "Config",
+  },
   {
     id: "check-for-updates",
     prefix: "",

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

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import type { NewsArticle } from "../../../../news/types";
+import { buildArticleSearchResultItems } from "./article-results";
+import { isArticleLookupShortcut } from "./results";
+
+function article(title: string, source: string): NewsArticle {
+  return {
+    id: title,
+    title,
+    source,
+    url: `https://example.com/${title}`,
+    publishedAt: new Date("2026-08-14T12:00:00Z"),
+    topic: "general",
+    topics: [],
+    sectors: [],
+    categories: [],
+    tickers: [],
+    scores: { importance: 50, urgency: 0, marketImpact: 0, novelty: 0, confidence: 0 },
+    isBreaking: false,
+    isDeveloping: false,
+    importance: 50,
+  };
+}
+
+describe("buildArticleSearchResultItems", () => {
+  test("offers the matching article to open", () => {
+    const opened: string[] = [];
+    const items = buildArticleSearchResultItems({
+      articles: [
+        article("Iran Threatens to Close the Strait of Hormuz", "Reuters"),
+        article("Fed holds rates", "CNBC Top News"),
+      ],
+      query: "article on the strait",
+      phase: "ready",
+      onOpen: (item) => {
+        opened.push(item.id);
+      },
+    });
+
+    expect(items).toHaveLength(1);
+    expect(items[0]?.label).toContain("Hormuz");
+    expect(items[0]?.detail).toBe("Reuters");
+    items[0]?.action();
+    expect(opened).toEqual(["Iran Threatens to Close the Strait of Hormuz"]);
+  });
+
+  test("shows a lookup row while subscribed feeds are still loading", () => {
+    const items = buildArticleSearchResultItems({
+      articles: [],
+      query: "article on the strait",
+      phase: "loading",
+      onOpen: () => {},
+    });
+    expect(items.map((item) => item.label)).toEqual(["Looking up articles…"]);
+  });
+
+  test("returns local matches without waiting on a still-loading lookup", () => {
+    const items = buildArticleSearchResultItems({
+      articles: [article("Trump administration pauses talks", "AP")],
+      query: "ART trum",
+      phase: "loading",
+      onOpen: () => {},
+    });
+    expect(items.map((item) => item.label)).toEqual(["Trump administration pauses talks"]);
+  });
+});
+
+describe("isArticleLookupShortcut", () => {
+  test("treats the ART plugin command as an article lookup", () => {
+    expect(isArticleLookupShortcut({ kind: "none" })).toBe(false);
+    expect(isArticleLookupShortcut({
+      kind: "partial",
+      source: "plugin-command",
+      prefix: "ART",
+      label: "Open Article",
+      description: "",
+      argKind: "text",
+      argText: "hormuz",
+      completionQuery: null,
+      command: { id: "open-news-article", label: "Open Article" } as never,
+    })).toBe(true);
+  });
+});

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

@@ -0,0 +1,55 @@
+import type { NewsArticle } from "../../../../news/types";
+import {
+  looksLikeArticleQuery,
+  searchNewsArticles,
+} from "../../../../plugins/builtin/news/wire/article-search";
+import type { ResultItem } from "../../list/model";
+
+/**
+ * Builds command-bar rows for an article-lookup (`ART`) query by matching the
+ * typed text against the loaded news feed.
+ */
+export function buildArticleSearchResultItems(options: {
+  articles: readonly NewsArticle[];
+  query: string;
+  phase?: "idle" | "loading" | "ready" | "refreshing" | "error";
+  onOpen: (article: NewsArticle) => void;
+}): ResultItem[] {
+  const query = options.query.trim();
+  if (!query || !looksLikeArticleQuery(query)) return [];
+
+  const matches = searchNewsArticles(options.articles, query);
+  const items = matches.map((article) => ({
+    id: `article:${article.id}`,
+    label: article.title,
+    detail: article.source,
+    category: "Articles",
+    kind: "action" as const,
+    right: "ART",
+    searchText: [
+      article.title,
+      article.source,
+      article.summary ?? "",
+      ...article.topics,
+      ...article.categories,
+      "article",
+      "news",
+      "press",
+    ].join(" "),
+    action: () => options.onOpen(article),
+  }));
+
+  if (items.length > 0) return items;
+  if (options.phase === "loading" || options.phase === "idle" || options.phase === "refreshing") {
+    return [{
+      id: "article:loading",
+      label: "Looking up articles…",
+      detail: "",
+      category: "Articles",
+      kind: "info",
+      defaultSelectable: false,
+      action: () => {},
+    }];
+  }
+  return [];
+}

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

@@ -142,6 +142,9 @@ export function createRootCommandItemBuilder({
         return command.description;
       case "toggle-value-flashing":
         return state.config.valueFlashingEnabled ? "Currently on" : "Currently off";
+      case "font-size-increase":
+      case "font-size-decrease":
+        return `Currently ${state.config.fontSize ?? 12}px`;
       default:
         return command.description;
     }

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

@@ -98,7 +98,7 @@ export function useRootProviderSearch(options: {
     );
     const localItems = localTickerSearchResultItems(searchQuery, { limit: 6 });
     setRootProviderResults(cachedCandidates
-      ? mergeTickerSearchResultItems(searchQuery, localItems, buildTickerSearchResultItems(cachedCandidates, searchQuery))
+      ? mergeTickerSearchResultItems(searchQuery, buildTickerSearchResultItems(cachedCandidates, searchQuery), localItems)
       : null);
     setRootProviderResultsQuery(cachedCandidates ? searchQuery : null);
 
@@ -125,8 +125,8 @@ export function useRootProviderSearch(options: {
         );
         setRootProviderResults(mergeTickerSearchResultItems(
           searchQuery,
-          localTickerSearchResultItems(searchQuery, { limit: 6 }),
           buildTickerSearchResultItems(combined, searchQuery),
+          localTickerSearchResultItems(searchQuery, { limit: 6 }),
         ));
         setRootProviderResultsQuery(searchQuery);
       } catch {
@@ -178,7 +178,11 @@ export function useRootProviderSearch(options: {
     rootResultItems,
     rootTickerSearchArg,
   ]);
-  const rootSectionOrder: CommandBarSectionOrder = rootPlainTickerSearchArg ? "app-first" : "default";
+  const rootSectionOrder: CommandBarSectionOrder = rootPlainTickerSearchArg
+    ? "app-first"
+    : rootTickerSearchArg
+      ? "ranked"
+      : "default";
   const orderedRootResults = useMemo(
     () => orderListResults(rootResults, { sectionOrder: rootSectionOrder }),
     [rootResults, rootSectionOrder],