gloomberb 0.10.4 → 0.11.0

package/src/cli/commands/overview.ts

@@ -95,7 +95,7 @@ async function runFearGreed(_args: string[], ctx: Parameters<CliCommandDef["exec
       "fear-greed",
     ));
     try {
-      const data = await loadFearGreed(ctx.cliOptions.refresh);
+      const { data } = await loadFearGreed(ctx.cliOptions.refresh);
       ctx.printResult({
         data: [{
           score: data.overall.score,
@@ -119,7 +119,7 @@ async function runEcon(args: string[], ctx: Parameters<CliCommandDef["execute"]>
   const country = (takeOption(rawArgs, "--country") ?? "all") as CountryFilter;
   const impact = (takeOption(rawArgs, "--impact") ?? "all") as ImpactFilter;
   await withCliServices(ctx, async (services) => {
-    const events = await loadCalendar(ctx.cliOptions.refresh);
+    const { data: events } = await loadCalendar(ctx.cliOptions.refresh);
     const rows = events
       .filter((event) => matchesCountry(event, country) && matchesImpact(event, impact))
       .sort((left, right) => left.date.getTime() - right.date.getTime())

package/src/cli/desktop-pane-shot.ts

@@ -3,6 +3,7 @@ import { tmpdir } from "os";
 import { join } from "path";
 import { pathToFileURL } from "url";
 import type { AppConfig } from "../types/config";
+import type { ResolvedSeries } from "../time-series/types";
 import type { OptionsChain, TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
 import type { PaneRuntimeState } from "../core/state/app/state";
@@ -24,6 +25,7 @@ export interface DesktopPaneShotPayload {
   financials: Array<[string, TickerFinancials]>;
   optionsChains: Array<[string, OptionsChain]>;
   fredSeries: Array<[string, FredSeriesCacheEntry]>;
+  capabilitySeries: Array<[string, ResolvedSeries]>;
   paneState: Record<string, PaneRuntimeState>;
 }
 

package/src/cli/entry.ts

@@ -2,7 +2,12 @@ import { dispatchCli } from "./index";
 import { fail, inferCliErrorOptions, printCliError } from "./errors";
 import { loadExternalPlugins } from "../plugins/loader";
 import type { CliLaunchRequest } from "../types/plugin";
-import { OPEN_TUI_NATIVE_SMOKE_COMMAND, smokeOpenTuiNative } from "./native-smoke";
+import {
+  OPEN_TUI_NATIVE_SMOKE_COMMAND,
+  OPEN_TUI_RUNTIME_SMOKE_COMMAND,
+  smokeOpenTuiNative,
+  smokeOpenTuiRuntime,
+} from "./native-smoke";
 
 async function launchOpenTuiApp(options: {
   externalPlugins: Awaited<ReturnType<typeof loadExternalPlugins>>;
@@ -26,6 +31,11 @@ export async function runCliEntrypoint(rawArgs = process.argv.slice(2)): Promise
     process.exit(0);
   }
 
+  if (command === OPEN_TUI_RUNTIME_SMOKE_COMMAND) {
+    await smokeOpenTuiRuntime();
+    process.exit(0);
+  }
+
   const externalPlugins = await loadExternalPlugins();
 
   if (!command) {

package/src/cli/native-smoke.ts

@@ -1,5 +1,10 @@
 export const OPEN_TUI_NATIVE_SMOKE_COMMAND = "__gloomberb-smoke-opentui-native";
+export const OPEN_TUI_RUNTIME_SMOKE_COMMAND = "__gloomberb-smoke-opentui-runtime";
 
 export async function smokeOpenTuiNative(): Promise<void> {
   await import("../renderers/opentui/native-smoke");
 }
+
+export async function smokeOpenTuiRuntime(): Promise<void> {
+  await import("../renderers/opentui/start");
+}

package/src/cli/pane-functions/catalog.ts

@@ -55,8 +55,12 @@ function registerResolverToken(
 
 export function buildPaneFunctionLookup(registry: PaneFunctionCatalog): Map<string, PaneTemplateDef | PaneDef> {
   const lookup = new Map<string, PaneTemplateDef | PaneDef>();
+  // Shortcut prefixes first: "AI" must open the pane that owns the shortcut, not
+  // one that happens to list "ai" as a keyword.
   for (const template of registry.paneTemplates.values()) {
     registerResolverToken(lookup, template.shortcut?.prefix, template);
+  }
+  for (const template of registry.paneTemplates.values()) {
     registerResolverToken(lookup, template.id, template);
     registerResolverToken(lookup, template.label, template);
     for (const keyword of template.keywords ?? []) registerResolverToken(lookup, keyword, template);

package/src/cli/pane-functions/data.ts

@@ -93,9 +93,14 @@ export function collectShotSymbols(resolved: ResolvedPaneFunction, rawArg: strin
       )).filter(Boolean))];
     }
   }
+  // A text argument is a phrase, not a symbol, so it must never be looked up as one.
+  const argIsTicker = resolved.template?.shortcut?.argKind !== "text";
   let symbols = resolved.createOptions?.symbols?.length
     ? resolved.createOptions.symbols
-    : [resolved.createOptions?.symbol ?? normalizeTickerInput(null, cleanTickerInput(rawArg))].filter((symbol): symbol is string => !!symbol);
+    : [
+      resolved.createOptions?.symbol
+        ?? (argIsTicker ? normalizeTickerInput(null, cleanTickerInput(rawArg)) : null),
+    ].filter((symbol): symbol is string => !!symbol);
   if (resolved.capability.id === "security-relationship" && symbols.length === 1) {
     symbols = [...symbols, "SPY"];
   }

package/src/cli/pane-functions/discovery.ts

@@ -1,3 +1,6 @@
+import { ConnectionHealthRegistry } from "../../core/connection-health";
+import type { AppConfig } from "../../types/config";
+import type { DataProvider } from "../../types/data-provider";
 import type {
   GloomPlugin,
   GloomPluginContext,
@@ -6,17 +9,69 @@ import type {
   PluginPersistence,
 } from "../../types/plugin";
 import type { PersistedResourceValue } from "../../types/persistence";
+import type { TickerRepository } from "../../data/ticker-repository";
 import type { MarketContext } from "../types";
 import type { PaneFunctionCatalog } from "./catalog";
 
-export async function createPaneCatalog(context: MarketContext, plugins: GloomPlugin[]): Promise<PaneFunctionCatalog> {
-  const panes = new Map<string, PaneDef>();
-  const paneTemplates = new Map<string, PaneTemplateDef>();
-  const setupPlugins: GloomPlugin[] = [];
+export interface PaneDiscoveryOptions {
+  getConfig: () => AppConfig;
+  marketData?: DataProvider;
+  tickerRepository?: TickerRepository;
+  panes?: Map<string, PaneDef>;
+  paneTemplates?: Map<string, PaneTemplateDef>;
+}
+
+/** Throws only if a plugin actually reaches for a dependency discovery has no answer for. */
+function unavailable<T>(name: string): T {
+  return new Proxy({}, {
+    get() {
+      throw new Error(`${name} is unavailable during pane discovery.`);
+    },
+  }) as T;
+}
+
+/**
+ * Context that collects `setup()`-registered panes and templates without
+ * booting the real plugin runtime or its polling engines. Keep this object
+ * exhaustively typed so additions to GloomPluginContext fail at compile time
+ * instead of crashing `gloomberb catalog` at runtime.
+ */
+export function createPaneDiscoveryContext(options: PaneDiscoveryOptions): GloomPluginContext & {
+  panes: Map<string, PaneDef>;
+  paneTemplates: Map<string, PaneTemplateDef>;
+} {
+  const panes = options.panes ?? new Map<string, PaneDef>();
+  const paneTemplates = options.paneTemplates ?? new Map<string, PaneTemplateDef>();
+  return {
+    ...buildDiscoveryContext({
+      panes,
+      paneTemplates,
+      getConfig: options.getConfig,
+      marketData: options.marketData ?? unavailable<DataProvider>("Market data"),
+      tickerRepository: options.tickerRepository ?? unavailable<TickerRepository>("The ticker repository"),
+      connectionHealth: new ConnectionHealthRegistry(),
+    }),
+    panes,
+    paneTemplates,
+  };
+}
+
+function buildDiscoveryContext({
+  panes,
+  paneTemplates,
+  getConfig,
+  marketData,
+  tickerRepository,
+  connectionHealth,
+}: {
+  panes: Map<string, PaneDef>;
+  paneTemplates: Map<string, PaneTemplateDef>;
+  getConfig: () => AppConfig;
+  marketData: DataProvider;
+  tickerRepository: TickerRepository;
+  connectionHealth: ConnectionHealthRegistry;
+}): GloomPluginContext {
   const fakePersistence = createDiscoveryPluginPersistence();
-  // Collect setup-registered panes without booting the real plugin runtime or polling engines.
-  // Keep this object exhaustively typed so additions to GloomPluginContext fail at
-  // compile time instead of crashing `gloomberb catalog` at runtime.
   const discoveryContext: GloomPluginContext = {
     registerPane: (pane: PaneDef) => panes.set(pane.id, pane),
     registerPaneTemplate: (template: PaneTemplateDef) => paneTemplates.set(template.id, template),
@@ -33,10 +88,11 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
     watchNewsQuery: () => () => {},
     getData: () => null,
     getTicker: () => null,
-    getConfig: () => context.config,
+    getConfig,
     getPaneDef: (paneId: string) => panes.get(paneId),
-    marketData: context.dataProvider,
-    tickerRepository: context.store,
+    marketData,
+    connectionHealth,
+    tickerRepository,
     persistence: fakePersistence,
     log: {
       debug: () => {},
@@ -84,6 +140,16 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
     emit: () => {},
     notify: () => {},
   };
+  return discoveryContext;
+}
+
+export async function createPaneCatalog(context: MarketContext, plugins: GloomPlugin[]): Promise<PaneFunctionCatalog> {
+  const setupPlugins: GloomPlugin[] = [];
+  const { panes, paneTemplates, ...discoveryContext } = createPaneDiscoveryContext({
+    getConfig: () => context.config,
+    marketData: context.dataProvider,
+    tickerRepository: context.store,
+  });
 
   for (const plugin of plugins) {
     for (const pane of plugin.panes ?? []) panes.set(pane.id, pane);

package/src/cli/pane-functions/report.test.ts

@@ -0,0 +1,76 @@
+import { afterEach, expect, test } from "bun:test";
+import { createDefaultConfig } from "../../types/config";
+import { CHART_SPEC_VERSION, type ChartSpec } from "../../time-series/types";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import { setSharedRegistryForTests } from "../../plugins/registry";
+import { buildFunctionReport } from "./report";
+import type { ResolvedPaneFunction } from "./resolver";
+import type { MarketContext } from "../types";
+
+const spec: ChartSpec = {
+  version: CHART_SPEC_VERSION,
+  viewport: { range: "1M", resolution: "auto" },
+  panels: [{ id: "main" }],
+  series: [{
+    id: "prediction",
+    source: { kind: "capability", capabilityId: "prediction.series", seriesId: "market-one" },
+    style: "area",
+    transform: "raw",
+    axis: "auto",
+    panelId: "main",
+    interpolation: "none",
+  }],
+  studies: [],
+};
+
+afterEach(() => setSharedRegistryForTests(undefined));
+
+test("chart composer reports accept capability-backed series", async () => {
+  const date = new Date(Date.now() - 24 * 60 * 60 * 1_000);
+  setSharedRegistryForTests({
+    capabilityManifests: () => [{
+      id: "prediction.series",
+      kind: "chart-series",
+      name: "Prediction",
+      operations: [{ id: "resolve", kind: "query", rendererSafe: true }],
+    }],
+    invokeCapability: async () => ({
+      id: "provider-id",
+      label: "Prediction",
+      color: "#fff",
+      unit: "probability",
+      unitGroup: "probability",
+      nativeFrequency: "daily",
+      dataShape: "scalar",
+      style: "line",
+      transform: "raw",
+      axis: "left",
+      panelId: "main",
+      interpolation: "none",
+      points: [{ date, observedAt: date, value: 0.62 }],
+    }),
+  } as any);
+  const resolved = {
+    token: "chart-composer",
+    label: "Chart Composer",
+    description: "",
+    pane: { id: "chart-composer", name: "Chart Composer" },
+    instance: { settings: { chartSpec: spec } },
+    capability: { id: "chart-composer", reportReadiness: "ready" },
+  } as unknown as ResolvedPaneFunction;
+  const context = {
+    config: createDefaultConfig("/tmp/gloomberb-chart-report"),
+    dataProvider: createTestDataProvider(),
+    store: { loadTicker: async () => null },
+  } as unknown as MarketContext;
+
+  const report = await buildFunctionReport(resolved, context, "");
+  expect(report.data).toMatchObject({
+    kind: "chart-composer",
+    complete: true,
+    empty: false,
+    unavailableSymbols: [],
+    rowCount: 1,
+  });
+  expect(report.text).toContain("Prediction");
+});

package/src/cli/pane-functions/report.ts

@@ -29,6 +29,8 @@ import { publicTickerKey } from "../../utils/exchanges";
 import { apiClient } from "../../api-client";
 import { parseChartSpec } from "../../plugins/builtin/chart-composer/chart-spec";
 import { resolveChartSpecData } from "../../time-series/resolve";
+import { createChartSeriesResolver } from "../../capabilities";
+import { getSharedRegistry } from "../../plugins/registry";
 import { formatTimestamp } from "../helpers";
 import { buildTickerReport } from "../commands/ticker";
 import { createBaseConverter } from "../base-converter";
@@ -226,8 +228,10 @@ async function buildChartComposerReport(
         : series;
     })),
   };
+  const capabilityInvoker = getSharedRegistry();
   const result = await resolveChartSpecData(spec, {
     dataProvider: context.dataProvider,
+    ...(capabilityInvoker ? { resolveCapabilitySeries: createChartSeriesResolver(capabilityInvoker) } : {}),
     loadFredSeries: async (request) => ({
       data: await apiClient.getCloudFredSeries(request.seriesId, {
         startDate: request.startDate,
@@ -261,7 +265,9 @@ async function buildChartComposerReport(
     if (output?.points.length) return [];
     return [entry.source.kind === "security"
       ? publicTickerKey(entry.source.instrument.symbol, entry.source.instrument.exchange)
-      : `FRED:${entry.source.seriesId}`];
+      : entry.source.kind === "economic"
+        ? `FRED:${entry.source.seriesId}`
+        : `CAP:${entry.source.capabilityId}:${entry.source.seriesId}`];
   });
   const rowCount = series.reduce((count, entry) => count + entry.observations.length, 0);
   const tableRows = series.map((entry) => {

package/src/cli/pane-functions/resolver.ts

@@ -45,9 +45,12 @@ async function buildPaneInstance(
   context: MarketContext,
   target: string,
 ): Promise<PaneInstanceConfig> {
+  // A text argument is a phrase, not a symbol: uppercasing it and binding it as
+  // a ticker makes the pane look for a provider for "HIGH GROWTH SOFTWARE".
+  const argKind = resolved.template?.shortcut?.argKind;
   const primarySymbol = resolved.createOptions?.symbol
     ?? resolved.createOptions?.symbols?.[0]
-    ?? normalizeTickerInput(null, cleanTickerInput(target));
+    ?? (argKind === "text" ? null : normalizeTickerInput(null, cleanTickerInput(target)));
   const templateContext = buildTemplateContext(context, primarySymbol ?? null);
   const spec = await resolved.template?.createInstance?.(templateContext, resolved.createOptions) ?? {};
   const instanceId = `${resolved.pane.id}:cli-${slugifyName(target || resolved.pane.id, "pane")}`;

package/src/cli/pane-functions/screenshot.test.ts

@@ -5,6 +5,7 @@ import {
   chartEvidenceMismatchesFor,
   missingActiveTabSelections,
   shotDataEvidenceFor,
+  shotExpectedText,
   shotPriceHistoryRange,
   shotSemanticRowCount,
   shotUnavailableSymbols,
@@ -130,6 +131,18 @@ describe("pane screenshot chart-data verification", () => {
           panelId: "macro",
           visible: true,
         },
+        {
+          id: "prediction",
+          sourceKind: "capability",
+          capabilityId: "prediction-markets.series",
+          providerSeriesId: "polymarket/event-1/market-1",
+          first: { date: "2026-01-01T00:00:00.000Z", value: 0.4 },
+          last: { date: "2026-01-02T00:00:00.000Z", value: 0.6 },
+          style: "area",
+          transform: "raw",
+          panelId: "prediction",
+          visible: true,
+        },
       ],
     };
     const metadata = {
@@ -137,12 +150,18 @@ describe("pane screenshot chart-data verification", () => {
       projectedPointCount: 42,
       baseSeries: expectedComposer.baseSeries?.map((series) => ({ ...series, pointCount: 12 })),
     };
-    expect(chartEvidenceMismatchesFor([{
+    const semanticUi = [{
       id: "chart-composer-data",
-      role: "chart-data",
+      role: "chart-data" as const,
       actions: [],
       metadata,
-    }], expectedComposer)).toEqual([]);
+    }];
+    expect(chartEvidenceMismatchesFor(semanticUi, expectedComposer)).toEqual([]);
+
+    const wrong = structuredClone(semanticUi);
+    (wrong[0]!.metadata.baseSeries![3]!.last as { value: number }).value = 0.7;
+    expect(chartEvidenceMismatchesFor(wrong, expectedComposer))
+      .toContain("rendered chart series prediction does not match");
   });
 });
 
@@ -178,6 +197,40 @@ describe("pane screenshot chart-composer inputs", () => {
     expect(shotUnavailableSymbols(composer, payload([]), semanticUi)).toEqual([]);
   });
 
+  test("accepts capability-backed composer evidence and reports an empty provider series", () => {
+    const composer = resolved("chart-composer", {});
+    const populated: RemoteUiNodeSnapshot[] = [{
+      id: "chart-composer-data",
+      role: "chart-data",
+      actions: [],
+      metadata: {
+        kind: "chart-composer",
+        baseSeries: [{
+          sourceKind: "capability",
+          capabilityId: "prediction-markets.series",
+          providerSeriesId: "polymarket:one",
+          pointCount: 5,
+        }],
+      },
+    }];
+    expect(shotSemanticRowCount(composer, payload([]), populated)).toBe(5);
+    expect(shotUnavailableSymbols(composer, payload([]), populated)).toEqual([]);
+
+    const empty = structuredClone(populated);
+    (empty[0]!.metadata as any).baseSeries[0].pointCount = 0;
+    expect(shotUnavailableSymbols(composer, payload([]), empty))
+      .toEqual(["CAP:prediction-markets.series:polymarket:one"]);
+  });
+
+  test("expects the composer legend short label, not the catalog metric label", () => {
+    const valuation = {
+      ...resolved("valuation-series", { metric: "priceSales", period: "annual" }),
+      pane: { id: CHART_COMPOSER_PANE_ID },
+    } as unknown as ResolvedPaneFunction;
+
+    expect(shotExpectedText(valuation, ["AAPL"], payload([]))).toEqual(["AAPL", "P/S"]);
+  });
+
   test("reports an empty FRED composer source as unavailable", () => {
     const semanticUi: RemoteUiNodeSnapshot[] = [{
       id: "chart-composer-data",

package/src/cli/pane-functions/screenshot.ts

@@ -20,6 +20,7 @@ import {
   limitGraphRowsBySymbol,
   metricDef,
 } from "../../time-series/reporting";
+import { getTimeSeriesField } from "../../time-series/field-catalog";
 import {
   buildFinancialTableModel,
   formatFinancialHeader,
@@ -31,6 +32,7 @@ import type {
 } from "../../time-series/reporting";
 import type { TimeRange } from "../../time-series/range";
 import { appendLiveQuotePoint } from "../../time-series/chart-data";
+import { applyResolvedSeriesTransform } from "../../time-series/transforms";
 import { subtractTimeRange } from "../../time-series/date-window";
 import {
   buildPresetDateWindow,
@@ -40,6 +42,9 @@ import { parseChartSpec } from "../../plugins/builtin/chart-composer/chart-spec"
 import { publicTickerKey } from "../../utils/exchanges";
 import { apiClient } from "../../api-client";
 import type { FredSeriesCacheEntry } from "../../data/fred-series";
+import type { ResolvedSeries } from "../../time-series/types";
+import { chartSeriesSourceKey, createChartSeriesResolver } from "../../capabilities";
+import { getSharedRegistry } from "../../plugins/registry";
 import {
   collectShotSymbols,
   clipPriceHistoryToRange,
@@ -76,6 +81,23 @@ async function collectShotFredSeries(
   return loaded.filter((entry): entry is [string, FredSeriesCacheEntry] => !!entry);
 }
 
+async function collectShotCapabilitySeries(
+  resolved: ResolvedPaneFunction,
+): Promise<Array<[string, ResolvedSeries]>> {
+  if (resolved.pane.id !== CHART_COMPOSER_PANE_ID) return [];
+  const spec = parseChartSpec(resolved.instance.settings?.chartSpec);
+  const invoker = getSharedRegistry();
+  if (!spec || !invoker) return [];
+  const resolveSeries = createChartSeriesResolver(invoker);
+  return (await Promise.all(spec.series.flatMap((series) => {
+    if (series.source.kind !== "capability") return [];
+    const source = series.source;
+    return [resolveSeries(source, spec.viewport, series)
+      .then((value) => [chartSeriesSourceKey(source), value] as [string, ResolvedSeries])
+      .catch(() => null)];
+  }))).filter((entry): entry is [string, ResolvedSeries] => entry !== null);
+}
+
 export interface PaneScreenshotExpectedSelection {
   control: "metric" | "statement" | "period";
   value?: string;
@@ -106,10 +128,14 @@ export interface PaneScreenshotExpectedChartEvidence {
   sourceSeries?: PaneScreenshotChartSeriesEvidence[];
   baseSeries?: Array<{
     id: string;
-    sourceKind: "security" | "economic";
+    sourceKind: "security" | "economic" | "capability";
     symbol?: string;
     fieldId?: string;
     economicSeriesId?: string;
+    capabilityId?: string;
+    providerSeriesId?: string;
+    first?: { date: string; value: number | null } | null;
+    last?: { date: string; value: number | null } | null;
     style: string;
     transform: string;
     panelId: string;
@@ -259,7 +285,10 @@ async function buildDesktopShotPayload(
   const tickers: TickerRecord[] = [];
   const financials: Array<[string, TickerFinancials]> = [];
   const optionsChains: Array<[string, OptionsChain]> = [];
-  const fredSeries = await collectShotFredSeries(resolved);
+  const [fredSeries, capabilitySeries] = await Promise.all([
+    collectShotFredSeries(resolved),
+    collectShotCapabilitySeries(resolved),
+  ]);
   const includeOptionsChains = resolved.pane.id === OPTIONS_PANE_ID || resolved.template?.paneId === OPTIONS_PANE_ID;
   for (const symbol of collectShotSymbols(resolved, rawArg)) {
     const entry = await fetchTickerFinancials(context, symbol);
@@ -302,6 +331,7 @@ async function buildDesktopShotPayload(
     financials,
     optionsChains,
     fredSeries,
+    capabilitySeries,
     paneState,
   };
 }
@@ -612,6 +642,13 @@ function shotExpectedChart(
   if (resolved.pane.id === CHART_COMPOSER_PANE_ID) {
     const spec = parseChartSpec(resolved.instance.settings?.chartSpec);
     if (!spec) return null;
+    const capabilitySeries = new Map(payload.capabilitySeries);
+    const capabilityPoint = (point: ResolvedSeries["points"][number] | undefined) => point
+      ? {
+          date: point.date.toISOString(),
+          value: typeof (point.value ?? point.close) === "number" ? point.value ?? point.close ?? null : null,
+        }
+      : null;
     return {
       kind: "chart-composer",
       symbols: [...new Set(spec.series.flatMap((series) => (
@@ -629,7 +666,18 @@ function shotExpectedChart(
             symbol: publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange),
             fieldId: series.source.fieldId,
           }
-          : { economicSeriesId: series.source.seriesId }),
+          : series.source.kind === "economic"
+            ? { economicSeriesId: series.source.seriesId }
+            : (() => {
+                const loaded = capabilitySeries.get(chartSeriesSourceKey(series.source));
+                const resolvedSeries = loaded ? applyResolvedSeriesTransform(loaded, series.transform) : undefined;
+                return {
+                  capabilityId: series.source.capabilityId,
+                  providerSeriesId: series.source.seriesId,
+                  first: capabilityPoint(resolvedSeries?.points[0]),
+                  last: capabilityPoint(resolvedSeries?.points.at(-1)),
+                };
+              })()),
         style: series.style,
         transform: series.transform,
         panelId: series.panelId,
@@ -780,6 +828,12 @@ export function chartEvidenceMismatchesFor(
           || actual.symbol !== series.symbol
           || actual.fieldId !== series.fieldId
           || actual.economicSeriesId !== series.economicSeriesId
+          || actual.capabilityId !== series.capabilityId
+          || actual.providerSeriesId !== series.providerSeriesId
+          || (series.sourceKind === "capability" && (
+            JSON.stringify(actual.first) !== JSON.stringify(series.first)
+            || JSON.stringify(actual.last) !== JSON.stringify(series.last)
+          ))
           || actual.style !== series.style
           || actual.transform !== series.transform
           || actual.panelId !== series.panelId
@@ -886,6 +940,9 @@ export function shotUnavailableSymbols(
       if (entry.sourceKind === "economic" && typeof entry.economicSeriesId === "string") {
         return [`FRED:${entry.economicSeriesId}`];
       }
+      if (entry.sourceKind === "capability" && typeof entry.capabilityId === "string" && typeof entry.providerSeriesId === "string") {
+        return [`CAP:${entry.capabilityId}:${entry.providerSeriesId}`];
+      }
       return [];
     });
   }
@@ -966,7 +1023,7 @@ export function shotSemanticRowCount(
   return payload.financials.filter(([, financials]) => !!financials.quote).length;
 }
 
-function shotExpectedText(
+export function shotExpectedText(
   resolved: ResolvedPaneFunction,
   symbols: string[],
   payload: DesktopPaneShotPayload,
@@ -978,8 +1035,14 @@ function shotExpectedText(
     const definition = metricDef(graphKind, metric);
     const period = resolved.options.period as FundamentalPeriod;
     const periodCount = resolved.options.periods == null ? null : Number(resolved.options.periods);
+    if (resolved.pane.id === CHART_COMPOSER_PANE_ID) {
+      // Chart series are labelled with the field short label ("P/S"), not the
+      // catalog label ("Price / Sales").
+      const field = getTimeSeriesField(`${graphKind}.${metric}`);
+      expected.push(field?.shortLabel ?? definition.label);
+      return expected.filter(Boolean);
+    }
     expected.push(definition.label);
-    if (resolved.pane.id === CHART_COMPOSER_PANE_ID) return expected.filter(Boolean);
     for (const [symbol, financials] of payload.financials) {
       const latestRow = limitGraphRowsBySymbol(
         graphRowsForFinancials(financials, graphKind, metric, period, symbol),

package/src/components/chart/composite/composite-chart.test.tsx

@@ -25,6 +25,8 @@ import {
   type KeyEventLike,
 } from "../../../react/input";
 import { CompositeChart } from "./composite-chart";
+import { createDefaultConfig } from "../../../types/config";
+import { AppContext, createInitialState, PaneInstanceProvider } from "../../../state/app/context";
 import {
   resolveCompositeMinimumSpanMs,
   zoomCompositeViewport,
@@ -1517,6 +1519,58 @@ describe("CompositeChart", () => {
     expect(recoveredFrame).toContain("Jan 9");
   });
 
+  test("restores persisted drawings from pane settings on mount", async () => {
+    const renderWithSettings = async (settings: Record<string, unknown>) => {
+      const config = createDefaultConfig("/tmp/gloomberb-composite-drawings");
+      config.layout.instances.push({
+        instanceId: "chart:test",
+        paneId: "chart-composer",
+        title: "Chart",
+        binding: { kind: "fixed", symbol: "ACME" },
+        settings,
+      });
+      testSetup = await testRender(
+        <AppContext value={{ state: createInitialState(config), dispatch: () => {} }}>
+          <PaneInstanceProvider paneId="chart:test">
+            <CaptureChartSurfaceProvider>
+              <CompositeChart
+                width={60}
+                height={12}
+                series={[series("price", "main", "left", "USD", [100, 101, 102, 103, 104, 105, 106, 107, 108])]}
+                panels={[{ id: "main" }]}
+              />
+            </CaptureChartSurfaceProvider>
+          </PaneInstanceProvider>
+        </AppContext>,
+        { width: 62, height: 14 },
+      );
+      await act(async () => {
+        await testSetup!.renderOnce();
+        await testSetup!.renderOnce();
+      });
+      const bitmap = capturedSurfaceProps!.bitmaps?.[0] as { pixels: Uint8Array };
+      const pixels = Buffer.from(bitmap.pixels);
+      await act(async () => testSetup!.renderer.destroy());
+      testSetup = undefined;
+      return pixels;
+    };
+
+    const blank = await renderWithSettings({});
+    const restored = await renderWithSettings({
+      chartDrawings: [{
+        id: "drawing-1",
+        panelId: "main",
+        color: "#f5a524",
+        points: [
+          { time: Date.UTC(2025, 0, 2), value: 101 },
+          { time: Date.UTC(2025, 0, 8), value: 107 },
+        ],
+      }],
+    });
+
+    expect(restored.equals(blank)).toBe(false);
+  });
+
   test("shows useful UTC times for an intraday shared cursor and time axis", async () => {
     const intraday = {
       ...series("price", "main", "left", "USD", []),