gloomberb 0.11.0 → 0.11.2

package/src/components/chart/composite/format.ts

@@ -1,3 +1,4 @@
+import { formatMarketPriceWithCurrency } from "../../../market-data/market/format";
 import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
 import type { CompositeAxisDomain } from "./types";
 
@@ -25,23 +26,37 @@ function compactNumber(value: number): string {
   return value.toPrecision(3);
 }
 
-function currencyPrefix(unit: string): string {
+function unitCurrencyCode(unit: string): string | null {
   const currency = unit.trim().toUpperCase().split(/[\s/]/)[0] ?? "";
-  return CURRENCY_SYMBOLS[currency] ?? "";
+  return CURRENCY_SYMBOLS[currency] ? currency : null;
+}
+
+function currencyPrefix(unit: string): string {
+  const currency = unitCurrencyCode(unit);
+  return currency ? CURRENCY_SYMBOLS[currency] ?? "" : "";
+}
+
+function formatFullCurrencyValue(value: number, unit: string): string | null {
+  const currency = unitCurrencyCode(unit);
+  return currency ? formatMarketPriceWithCurrency(value, currency) : null;
 }
 
 export function formatCompositeSeriesValue(value: number, series: ResolvedSeries): string {
-  const unit = series.unit.trim();
-  const group = series.unitGroup.toLowerCase();
+  return formatChartLegendValue(value, series.unit, series.unitGroup);
+}
+
+export function formatChartLegendValue(value: number, unit: string, unitGroup = ""): string {
+  const trimmed = unit.trim();
+  const group = unitGroup.toLowerCase();
   const compact = compactNumber(value);
-  if (group.includes("percent") || unit === "%" || unit.toLowerCase().includes("percent")) {
+  if (group.includes("percent") || trimmed === "%" || trimmed.toLowerCase().includes("percent")) {
     return `${compact}%`;
   }
-  if (group.includes("ratio") || unit.toLowerCase() === "x") return `${compact}x`;
-  if (group.startsWith("derived-unit:")) return `${compact} ${unit}`;
-  const currency = currencyPrefix(unit);
-  if (currency) return `${currency}${compact}`;
-  return unit && unit.length <= 6 ? `${compact}${unit.startsWith("/") ? "" : " "}${unit}` : compact;
+  if (group.includes("ratio") || trimmed.toLowerCase() === "x") return `${compact}x`;
+  if (group.startsWith("derived-unit:")) return `${compact} ${trimmed}`;
+  const fullPrice = formatFullCurrencyValue(value, trimmed);
+  if (fullPrice) return fullPrice;
+  return trimmed && trimmed.length <= 6 ? `${compact}${trimmed.startsWith("/") ? "" : " "}${trimmed}` : compact;
 }
 
 export function formatCompositeAxisValue(value: number, domain: CompositeAxisDomain): string {
@@ -55,6 +70,14 @@ export function formatCompositeAxisValue(value: number, domain: CompositeAxisDom
   return `${currencyPrefix(domain.unit)}${compact}`;
 }
 
+export function formatCompositeCursorValue(value: number, domain: CompositeAxisDomain): string {
+  const group = domain.unitGroup.toLowerCase();
+  if (group.startsWith("derived-unit:")) return compactNumber(value);
+  const fullPrice = formatFullCurrencyValue(value, domain.unit);
+  if (fullPrice) return fullPrice;
+  return formatCompositeAxisValue(value, domain);
+}
+
 export function compositeAxisTicks(domain: CompositeAxisDomain, count = 3): Array<{ ratio: number; value: number; label: string }> {
   const tickCount = Math.max(2, Math.floor(count));
   return Array.from({ length: tickCount }, (_, index) => {

package/src/components/chart/composite/scene.ts

@@ -17,7 +17,6 @@ import type {
 import {
   buildCompositeTimeScale,
   projectCompositeTimestamp,
-  unprojectCompositeTimestamp,
 } from "./time-scale";
 import type { CompositeTimeScale } from "./types";
 
@@ -523,26 +522,6 @@ export function resolveCompositeCursorDate(scene: CompositeChartScene, localX: n
   return scene.dates[nearestIndex] ?? null;
 }
 
-export function resolveCompositeTimeAxisDate(
-  scene: CompositeChartScene,
-  ratio: number,
-): Date {
-  const safeRatio = Math.max(0, Math.min(1, ratio));
-  if (scene.timeScale.kind === "market" && scene.dates.length > 0) {
-    let nearestIndex = 0;
-    let nearestDistance = Number.POSITIVE_INFINITY;
-    scene.dateRatios.forEach((candidate, index) => {
-      const distance = Math.abs(candidate - safeRatio);
-      if (distance < nearestDistance) {
-        nearestIndex = index;
-        nearestDistance = distance;
-      }
-    });
-    return scene.dates[nearestIndex] ?? new Date(scene.startTime);
-  }
-  return new Date(unprojectCompositeTimestamp(scene.timeScale, safeRatio));
-}
-
 export function resolveAdjacentCompositeCursorDate(
   scene: CompositeChartScene,
   current: Date | null,

package/src/components/chart/composite/tools.ts

@@ -27,6 +27,55 @@ export interface ChartDrawing {
   color: string;
 }
 
+export const CHART_DRAWINGS_SETTING_KEY = "chartDrawings";
+const MAX_SHARED_CHART_DRAWINGS = 100;
+const MAX_SHARED_DRAWING_POINTS = 5_000;
+
+export function parseChartDrawings(value: unknown): ChartDrawing[] {
+  if (!Array.isArray(value) || value.length > MAX_SHARED_CHART_DRAWINGS) return [];
+  let pointCount = 0;
+  const drawings: ChartDrawing[] = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+    const drawing = entry as Record<string, unknown>;
+    if (!Object.keys(drawing).every((key) => ["id", "panelId", "points", "color"].includes(key))) return [];
+    if (
+      typeof drawing.id !== "string"
+      || drawing.id.length === 0
+      || drawing.id.length > 160
+      || typeof drawing.panelId !== "string"
+      || drawing.panelId.length === 0
+      || drawing.panelId.length > 120
+      || typeof drawing.color !== "string"
+      || !/^#[0-9a-f]{6}$/i.test(drawing.color)
+      || !Array.isArray(drawing.points)
+      || drawing.points.length < 2
+    ) return [];
+    pointCount += drawing.points.length;
+    if (pointCount > MAX_SHARED_DRAWING_POINTS) return [];
+    const points: ChartDrawingPoint[] = [];
+    for (const point of drawing.points) {
+      if (!point || typeof point !== "object" || Array.isArray(point)) return [];
+      const raw = point as Record<string, unknown>;
+      if (
+        !Object.keys(raw).every((key) => key === "time" || key === "value")
+        || typeof raw.time !== "number"
+        || !Number.isFinite(raw.time)
+        || typeof raw.value !== "number"
+        || !Number.isFinite(raw.value)
+      ) return [];
+      points.push({ time: raw.time, value: raw.value });
+    }
+    drawings.push({
+      id: drawing.id,
+      panelId: drawing.panelId,
+      points,
+      color: drawing.color,
+    });
+  }
+  return drawings;
+}
+
 export interface ChartDrawingHit {
   drawing: ChartDrawing;
   /** Grabbed endpoint, or null when the whole shape was grabbed. */

package/src/components/chart/core/axis-format.ts

@@ -1,4 +1,9 @@
-import { formatCompactMarketPriceWithCurrency, formatMarketPrice, resolveAssetDisplayKind } from "../../../market-data/market/format";
+import {
+  formatCompactMarketPriceWithCurrency,
+  formatMarketPrice,
+  formatMarketPriceWithCurrency,
+  resolveAssetDisplayKind,
+} from "../../../market-data/market/format";
 import type { ChartAxisMode } from "./types";
 
 export function formatPrice(
@@ -27,7 +32,7 @@ export function formatPriceWithCurrency(
   minimumFractionDigits = 0,
   fixedFractionDigits?: number,
 ): string {
-  return formatCompactMarketPriceWithCurrency(value, currency, {
+  return formatMarketPriceWithCurrency(value, currency, {
     assetCategory,
     fixedFractionDigits,
     minimumFractionDigits,
@@ -93,7 +98,11 @@ export function formatAxisValue(
   if (axisMode === "percent" && basePrice !== 0) {
     return formatPercentAxisValue(((value - basePrice) / basePrice) * 100);
   }
-  return formatPriceWithCurrency(value, currency, assetCategory, priceRange, 0, 0, fixedFractionDigits);
+  return formatCompactMarketPriceWithCurrency(value, currency, {
+    assetCategory,
+    fixedFractionDigits,
+    priceRange,
+  });
 }
 
 export function formatCursorAxisValue(
@@ -136,6 +145,7 @@ function getCursorAxisMinimumFractionDigits(value: number, assetCategory?: strin
     case "cash":
       return 4;
     case "crypto":
+      if (Math.abs(value) >= 100) return 2;
       return Math.abs(value) >= 1 ? 4 : 6;
     case "equity":
     case "contract":

package/src/components/chart/core/index.test.ts

@@ -448,6 +448,13 @@ describe("renderChart", () => {
     expect(formatAxisValue(1.17364, "price", 0, "USD", "CURRENCY")).toBe("$1.17364");
   });
 
+  test("keeps legend and cursor prices precise while axis ticks stay compact", () => {
+    expect(formatAxisValue(79_432.18, "price", 0, "USD", "CRYPTO")).toBe("$79.4K");
+    expect(formatCursorAxisValue(79_432.18, "price", 0, "USD", "CRYPTO")).toBe("$79,432.18");
+    expect(formatAxisValue(79_432.18, "price", 0, "USD", "STK")).toBe("$79.4K");
+    expect(formatCursorAxisValue(79_432.18, "price", 0, "USD", "STK")).toBe("$79,432.18");
+  });
+
   test("adapts FX axis precision to the visible price range", () => {
     expect(formatAxisValue(1.167815, "price", 0, "USD", "CURRENCY", 0.12)).toBe("$1.17");
     expect(formatAxisValue(1.167815, "price", 0, "USD", "CURRENCY", 0.0024)).toBe("$1.1678");

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

@@ -3,7 +3,6 @@ import type { ProjectedChartPoint } from "./data";
 import { buildTimeAxis } from "./time-axis";
 import {
   formatAxisValue,
-  formatPriceWithCurrency,
   getAxisFractionDigitFloor,
   resolveAxisFractionDigits,
 } from "./axis-format";
@@ -152,13 +151,13 @@ export function renderChart(
   const axisFractionDigits = axisMode === "price"
     ? resolveAxisFractionDigits(
       gridLines.map((line) => line.price),
-      (price, fixedFractionDigits) => formatPriceWithCurrency(
+      (price, fixedFractionDigits) => formatAxisValue(
         price,
+        axisMode,
+        points[0]!.close,
         currency,
         assetCategory,
         priceRange,
-        0,
-        0,
         fixedFractionDigits,
       ),
       getAxisFractionDigitFloor(assetCategory, priceRange),

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

@@ -87,6 +87,10 @@ export function runDirectCommandAction(options: {
       closeAll({ revertThemePreview: false });
       pluginRegistry.showPane("help");
       return;
+    case "layout-marketplace":
+      closeAll({ revertThemePreview: false });
+      pluginRegistry.showPane("layout-marketplace");
+      return;
     case "pane-settings":
       if (state.focusedPaneId) openPaneSettingsRoute(state.focusedPaneId);
       return;

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

@@ -138,8 +138,15 @@ export const commands: Command[] = [
     category: "Config",
   },
   {
-    id: "layout",
+    id: "layout-marketplace",
     prefix: "LAY",
+    label: "Layouts",
+    description: "Open the layout browser to switch, publish, or add layouts",
+    category: "Config",
+  },
+  {
+    id: "layout",
+    prefix: "LMA",
     label: "Layout Actions",
     description: "Organize panes and saved layouts",
     hasArg: true,

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

@@ -79,7 +79,7 @@ export function buildCurrentLayoutItems({
     },
     {
       id: "layout-gridlock",
-      label: "Gridlock All Windows",
+      label: "Tidy Windows",
       detail: currentLayout.floating.length > 0
         ? "Infer a tiled layout from the current window positions"
         : "Retile all panes from their current arrangement",

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

@@ -112,6 +112,10 @@ export function useCommandBarPaneTemplateActions({
     const trimmedArg = rawArg?.trim() || "";
     const argKind = template.shortcut?.argKind ?? template.shortcut?.argPlaceholder;
     if (argKind === "ticker") {
+      if (!trimmedArg && template.shortcut?.argOptional) {
+        await openPaneTemplateDirect(template);
+        return;
+      }
       const resolvedTicker = await resolveTickerInput(
         trimmedArg || undefined,
         activeTickerSymbol,

package/src/components/command-bar/routes/root/shortcut-feedback.ts

@@ -34,6 +34,9 @@ export function buildRootShortcutFeedback({
   if (rootShortcutIntent.source === "pane-template") {
     const argKind = getPaneTemplateArgKind(rootShortcutIntent.template);
     if (argKind === "ticker") {
+      if (rootShortcutIntent.template.shortcut?.argOptional && !rootShortcutIntent.argText) {
+        return `Shortcut: ${rootShortcutIntent.label}`;
+      }
       const symbol = normalizeTickerInput(activeTickerSymbol, rootShortcutIntent.argText);
       if (symbol) {
         return rootShortcutIntent.kind === "inferred-complete"

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

@@ -46,6 +46,13 @@ const paneTemplates: PaneTemplateDef[] = [
     description: "Search provider instruments",
     shortcut: { prefix: "SRCH", argPlaceholder: "query", argKind: "text" },
   },
+  {
+    id: "cds-pane",
+    paneId: "cds",
+    label: "Single-Name CDS",
+    description: "CDS shortcut",
+    shortcut: { prefix: "CDS", argPlaceholder: "ticker", argKind: "ticker", argOptional: true },
+  },
 ];
 
 const pluginCommands: CommandDef[] = [{
@@ -135,6 +142,18 @@ describe("ticker data root shortcuts", () => {
     }
   });
 
+  test("optional ticker shortcuts do not infer the active ticker", () => {
+    const bare = parse("CDS", "MSFT");
+    expect(bare.kind).toBe("partial");
+    if (bare.kind === "none") throw new Error("Expected shortcut intent");
+    expect(bare.completionQuery).toBeNull();
+
+    const scoped = parse("CDS ORCL", "MSFT");
+    expect(scoped.kind).toBe("complete");
+    if (scoped.kind === "none") throw new Error("Expected shortcut intent");
+    expect(scoped.argText).toBe("ORCL");
+  });
+
   test("EM accepts optional text tickers without active ticker inference", () => {
     const bare = parse("EM", "AAPL");
     expect(bare.kind).toBe("partial");

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

@@ -145,7 +145,9 @@ export function parseRootShortcutIntent({
   if (!match) return { kind: "none" };
 
   const argText = trimmed.slice(match.prefix.length).trim();
-  const inferredArg = inferShortcutArg(match.argKind, activeTicker);
+  const inferredArg = match.source === "pane-template" && match.template?.shortcut?.argOptional
+    ? null
+    : inferShortcutArg(match.argKind, activeTicker);
   const completionQuery = inferredArg ? `${match.prefix} ${inferredArg}` : null;
 
   let kind: Exclude<ShortcutIntentKind, "none">;

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

@@ -179,17 +179,17 @@ describe("CommandBar", () => {
     expect(testSetup.captureCharFrame()).not.toContain("GitHub Light");
   });
 
-  test("runs plugin command shortcuts from the root query", async () => {
+  test("finds the tidy windows command by its snap alias", async () => {
     const calls: string[] = [];
 
     testSetup = await testRender(<CommandBarHarness
-      query="GL"
+      query="snap"
       configurePluginRegistry={(pluginRegistry) => {
         (pluginRegistry.commands as Map<string, any>).set("gridlock-all", {
           id: "gridlock-all",
-          label: "Gridlock All Windows",
-          description: "Arrange all visible panes into a tiled grid",
-          keywords: ["grid", "gridlock", "tile", "arrange", "windows", "layout"],
+          label: "Tidy Windows",
+          description: "Arrange every window into one tiled layout",
+          keywords: ["tidy", "snap", "grid", "gridlock", "tile", "arrange", "organize", "organise", "cleanup", "dock", "floating", "windows", "layout"],
           shortcut: "GL",
           category: "config",
           execute: async () => {
@@ -215,7 +215,7 @@ describe("CommandBar", () => {
     await testSetup.renderOnce();
 
     const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("Gridlock All Windows");
+    expect(frame).toContain("Tidy Windows");
     expect(frame).toContain("GL");
 
     await act(async () => {

package/src/components/command-bar/surface/index.tsx

@@ -50,7 +50,7 @@ export function CommandBar({
     activePortfolio,
     activeTickerData,
     activeTickerSymbol,
-    availableCommands,
+    availableCommands: allAvailableCommands,
     cellHeightPx,
     cellWidthPx,
     dispatch,
@@ -67,6 +67,9 @@ export function CommandBar({
     titleBarOverlay,
     visibleListStateRef,
   } = useCommandBarEnvironment();
+  const availableCommands = useMemo(() => onCheckForUpdates
+    ? allAvailableCommands
+    : allAvailableCommands.filter((command) => command.id !== "check-for-updates"), [allAvailableCommands, onCheckForUpdates]);
   const {
     applyThemePreview,
     clearThemePreview,

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

@@ -142,6 +142,23 @@ function registerOptionalTextPane(pluginRegistry: MutablePaneRegistry): void {
   });
 }
 
+function registerOptionalTickerPane(pluginRegistry: MutablePaneRegistry): void {
+  mutableRegistryMap(pluginRegistry.panes).set("optional-ticker", {
+    id: "optional-ticker",
+    name: "Optional Ticker",
+    component: () => null,
+    defaultPosition: "right",
+    defaultMode: "floating",
+  });
+  mutableRegistryMap(pluginRegistry.paneTemplates).set("optional-ticker-pane", {
+    id: "optional-ticker-pane",
+    paneId: "optional-ticker",
+    label: "Optional Ticker",
+    description: "Open market-wide or for one ticker.",
+    shortcut: { prefix: "OT", argPlaceholder: "ticker", argKind: "ticker", argOptional: true },
+  });
+}
+
 function registerQueryOnlyPane(pluginRegistry: MutablePaneRegistry): void {
   mutableRegistryMap(pluginRegistry.panes).set("prediction-markets", {
     id: "prediction-markets",
@@ -204,7 +221,7 @@ describe("CommandBar pane and layout routes", () => {
 
   test("renders layout mode with focused pane actions", async () => {
     testSetup = await testRender(<CommandBarHarness
-      query="LAY "
+      query="LMA "
       configureConfig={layoutModeConfig}
       configureState={layoutModeState}
     />, {
@@ -248,9 +265,29 @@ describe("CommandBar pane and layout routes", () => {
     expect(actions.some((action) => action.type === "UNDO_LAYOUT")).toBe(true);
   });
 
+  test("opens Layouts as a normal pane from LAY", async () => {
+    const opened: string[] = [];
+    testSetup = await testRender(
+      <CommandBarHarness
+        query="LAY"
+        live
+        configurePluginRegistry={(pluginRegistry) => {
+          pluginRegistry.showPane = (paneId) => opened.push(paneId);
+        }}
+      />,
+      { width: 90, height: 18 },
+    );
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Layouts");
+
+    await clickFrameText("Layouts");
+
+    expect(opened).toEqual(["layout-marketplace"]);
+  });
+
   test("renders filtered saved layouts with textual previews", async () => {
     testSetup = await testRender(<CommandBarHarness
-      query="LAY Research"
+      query="LMA Research"
       configureConfig={layoutModeConfig}
       configureState={layoutModeState}
     />, {
@@ -353,6 +390,33 @@ describe("CommandBar pane and layout routes", () => {
     expect(testSetup.captureCharFrame()).not.toContain("Create Pane");
   });
 
+  test("keeps an optional ticker shortcut market-wide when a ticker is active", async () => {
+    const created: CreatedPaneCall[] = [];
+
+    testSetup = await testRender(<CommandBarHarness
+      query="OT"
+      selectedTicker="AAPL"
+      live
+      configurePluginRegistry={(pluginRegistry) => {
+        registerOptionalTickerPane(pluginRegistry);
+        recordPaneCreations(pluginRegistry, created);
+      }}
+    />, {
+      width: 100,
+      height: 18,
+    });
+
+    await testSetup.renderOnce();
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await Bun.sleep(0);
+      await testSetup!.renderOnce();
+    });
+
+    expect(created).toEqual([{ templateId: "optional-ticker-pane", options: undefined }]);
+  });
+
   for (const scenario of [
     {
       query: "prediction markets",

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

@@ -14,7 +14,8 @@ describe("command bar view model helpers", () => {
     expect(resolveCommandBarMode("T NVDA")).toMatchObject({ kind: "search", badge: "T" });
     expect(resolveCommandBarMode("TH ")).toMatchObject({ kind: "themes", badge: "THEMES" });
     expect(resolveCommandBarMode("PL notes")).toMatchObject({ kind: "plugins", badge: "PLUGINS" });
-    expect(resolveCommandBarMode("LAY ")).toMatchObject({ kind: "layout", badge: "LAYOUT" });
+    expect(resolveCommandBarMode("LAY")).toMatchObject({ kind: "direct-command", badge: "COMMAND" });
+    expect(resolveCommandBarMode("LMA ")).toMatchObject({ kind: "layout", badge: "LAYOUT" });
     expect(resolveCommandBarMode("NP ")).toMatchObject({ kind: "default", badge: "FILTER" });
     expect(resolveCommandBarMode("PS")).toMatchObject({ kind: "direct-command", badge: "COMMAND" });
     expect(resolveCommandBarMode("AW")).toMatchObject({ kind: "direct-command", badge: "COMMAND" });

package/src/components/command-bar/workflow/ops.test.ts

@@ -3,6 +3,7 @@ import { cloneLayout, createDefaultConfig, findPaneInstance, type LayoutConfig }
 import { createInitialState } from "../../../state/app/context";
 import { createTestDataProvider } from "../../../test-support/data-provider";
 import { applyPaneSettingFieldValue, createPaneTemplateOrThrow } from "./ops";
+import type { TickerRecord } from "../../../types/ticker";
 
 function makeDataProvider() {
   return createTestDataProvider({ id: "test" });
@@ -68,6 +69,59 @@ describe("createPaneTemplateOrThrow", () => {
     expect(placeCalls).toHaveLength(0);
   });
 
+  test("uses an explicit shared symbol instead of the recipient's active ticker", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-workflow-ops-test");
+    const state = createInitialState(config);
+    const msft: TickerRecord = {
+      metadata: {
+        ticker: "MSFT",
+        exchange: "NASDAQ",
+        currency: "USD",
+        name: "Microsoft",
+        portfolios: [],
+        watchlists: [],
+        positions: [],
+        broker_contracts: [],
+        custom: {},
+        tags: [],
+      },
+    };
+    state.tickers.set("MSFT", msft);
+    let createdSymbol: string | null | undefined;
+
+    await createPaneTemplateOrThrow("ticker-pane", { symbol: "MSFT" }, {
+      dataProvider: makeDataProvider() as any,
+      tickerRepository: makeTickerRepository() as any,
+      dispatch: () => {},
+      getState: () => state,
+      pluginRegistry: {
+        paneTemplates: new Map([["ticker-pane", {
+          id: "ticker-pane",
+          paneId: "ticker-view",
+          label: "Ticker View",
+          description: "Ticker View",
+          shortcut: { prefix: "TV", argPlaceholder: "ticker", argKind: "ticker" },
+          createInstance: (_context: unknown, options: { symbol?: string } | undefined) => {
+            createdSymbol = options?.symbol;
+            return { binding: { kind: "fixed", symbol: options?.symbol ?? "" } };
+          },
+        }]]),
+        panes: new Map([["ticker-view", {
+          id: "ticker-view",
+          name: "Ticker View",
+          component: () => null,
+          defaultPosition: "right",
+        }]]),
+        getPaneTemplatePluginId: () => undefined,
+        events: { emit: () => {} },
+      } as any,
+      buildPaneInstance: () => ({ instanceId: "ticker-view:1", paneId: "ticker-view" }) as any,
+      placePaneInstance: () => {},
+    });
+
+    expect(createdSymbol).toBe("MSFT");
+  });
+
   test("passes pane template instance ids through to pane creation", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-workflow-ops-test");
     const state = createInitialState(config);

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

@@ -152,7 +152,7 @@ async function resolvePaneTemplateOptions(
   let resolvedOptions = options;
   if (template.shortcut?.argPlaceholder === "ticker") {
     const resolvedTicker = await resolveTickerInputOrThrow(
-      resolvedOptions?.arg,
+      resolvedOptions?.symbol ?? resolvedOptions?.arg,
       baseContext.activeTicker,
       baseContext.activeCollectionId,
       deps,

package/src/components/company-logo.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { resolveCompanyLogoSrc } from "./company-logo";
+
+describe("resolveCompanyLogoSrc", () => {
+  test("builds a ticker logo URL", () => {
+    expect(resolveCompanyLogoSrc({ symbol: "aapl", assetCategory: "STK" }))
+      .toMatch(/\/cloud\/logos\/ticker\/AAPL$/);
+  });
+
+  test("maps crypto quote pairs onto the crypto path", () => {
+    expect(resolveCompanyLogoSrc({ symbol: "btc-usd", assetCategory: "CRYPTO" }))
+      .toMatch(/\/cloud\/logos\/crypto\/BTC$/);
+  });
+
+  test("skips cash and options", () => {
+    expect(resolveCompanyLogoSrc({ symbol: "USD", assetCategory: "CASH" })).toBeNull();
+    expect(resolveCompanyLogoSrc({ symbol: "AAPL  240119C00190000", assetCategory: "OPT" })).toBeNull();
+  });
+});