gloomberb 0.15.0 → 0.15.2

package/bin/gloomberb

@@ -1,3 +1,11 @@
 #!/usr/bin/env bun
 
-import "../src/cli/entry.ts"
+// Bun applies patchedDependencies only to the root project, so a global
+// `bun install -g gloomberb` runs react-reconciler without
+// patches/react-reconciler@0.33.0.patch. Its dev build then records a
+// performance.measure for every component render, which Bun keeps forever.
+// The reconciler reads console.timeStamp once at load to decide, so hide it
+// before React is imported.
+delete console.timeStamp;
+
+await import("../src/cli/entry.ts");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",

package/src/api-client/central-bank-rates.ts

@@ -26,6 +26,9 @@ export interface CentralBankRow {
   status: "available" | "stale" | "unavailable"
   unavailableReason: "source-unavailable" | "metadata-mismatch" | "metadata-unavailable" | "no-observations" | "no-policy-rate" | "no-unified-rate" | null
   notes: string[]
+  /** When the bank's own site last showed the same level as a lagging BIS observation. */
+  confirmedAt?: string | null
+  confirmationSourceUrl?: string | null
   nextMeeting: { date: string; sourceUrl: string; verifiedAt: string } | null
 }
 

package/src/api-client/types.ts

@@ -820,7 +820,7 @@ export interface CloudRiskReportListPayload {
     cik: string | null;
     name: string;
     shortName: string;
-  };
+  } | null;
   reports: CloudRiskReportSummaryPayload[];
 }
 

package/src/app/pane-runtime/index.tsx

@@ -172,11 +172,14 @@ export function useAppPaneRuntime({
     options?: PaneTemplateInstanceConfig,
   ) => {
     const { width, height } = pluginRegistry.getTermSizeFn();
+    // Templates can await ticker resolution before placing their pane, so the
+    // layout from the render that started the request may be out of date.
+    const { config: { layout }, focusedPaneId } = stateRef.current;
     const relativeTo = options?.relativeToPaneId
-      ? resolvePaneTarget(options.relativeToPaneId)
-      : (state.focusedPaneId && isPaneInLayout(state.config.layout, state.focusedPaneId) ? state.focusedPaneId : null);
+      ? resolvePaneTarget(options.relativeToPaneId, layout)
+      : (focusedPaneId && isPaneInLayout(layout, focusedPaneId) ? focusedPaneId : null);
     const relativePosition = options?.relativePosition ?? "right";
-    let nextLayout = state.config.layout;
+    let nextLayout = layout;
     const dockedPaneIds = getDockedPaneIds(nextLayout);
 
     if (options?.placement === "floating" || (options?.placement !== "docked" && paneDef.defaultMode === "floating")) {
@@ -204,8 +207,7 @@ export function useAppPaneRuntime({
     persistLayout,
     pluginRegistry,
     resolvePaneTarget,
-    state.config.layout,
-    state.focusedPaneId,
+    stateRef,
   ]);
 
   const showPane = useCallback((paneId: string) => {

package/src/app/runtime/broker-import.test.tsx

@@ -0,0 +1,89 @@
+import { afterEach, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../renderers/opentui/test-utils";
+import { setConfigStoreHost, type ConfigStoreHost } from "../../data/config/store";
+import { addPaneToLayout, getDockedPaneIds, isPaneInLayout } from "../../plugins/pane-manager";
+import { appReducer, createInitialState, type AppAction, type AppState } from "../../state/app/context";
+import { createDefaultConfig, createPaneInstance, type AppConfig, type BrokerInstanceConfig } from "../../types/config";
+import type { BrokerAdapter } from "../../types/broker";
+import type { TickerRecord } from "../../types/ticker";
+import { useBrokerImportRuntime } from "./broker-import";
+
+const saved: AppConfig[] = [];
+setConfigStoreHost({
+  saveConfig: async (config: AppConfig) => { saved.push(config); },
+} as unknown as ConfigStoreHost);
+
+let rendered: Awaited<ReturnType<typeof testRender>> | undefined;
+afterEach(async () => {
+  saved.length = 0;
+  if (rendered) await act(async () => { rendered!.renderer.destroy(); });
+  rendered = undefined;
+});
+
+// The startup broker sync runs while the app is already usable, and a broker
+// such as IBKR Flex takes seconds to answer. It used to commit the whole config
+// it had copied before asking, which closed any pane opened in the meantime.
+test("the startup broker sync keeps a pane opened while the broker was answering", async () => {
+  const instance: BrokerInstanceConfig = { id: "demo-broker", brokerType: "demo", label: "Demo", config: {}, enabled: true };
+  const config = { ...createDefaultConfig("/tmp/gloomberb-broker-import-test"), brokerInstances: [instance] };
+  let answer!: () => void;
+  const answered = new Promise<void>((resolve) => { answer = resolve; });
+  const broker = {
+    id: "demo",
+    name: "Demo",
+    configSchema: [],
+    validate: async () => true,
+    listAccounts: async () => [{ accountId: "ACC-1", name: "Primary", currency: "USD" }],
+    importPositions: async () => { await answered; return []; },
+  } as unknown as BrokerAdapter;
+  const tickers = new Map<string, TickerRecord>();
+  const tickerRepository = {
+    loadAllTickers: async () => [...tickers.values()],
+    loadTicker: async (symbol: string) => tickers.get(symbol) ?? null,
+    saveTicker: async (ticker: TickerRecord) => { tickers.set(ticker.metadata.ticker, ticker); },
+  } as any;
+
+  // AppProvider's dispatch reduces into the ref synchronously.
+  const stateRef: { current: AppState } = { current: createInitialState(config) };
+  const dispatch = (action: AppAction) => { stateRef.current = appReducer(stateRef.current, action); };
+  let runtime!: ReturnType<typeof useBrokerImportRuntime>;
+  function Harness() {
+    runtime = useBrokerImportRuntime({
+      dispatch,
+      pluginRegistry: {
+        brokers: new Map([["demo", broker]]),
+        persistence: { resources: undefined },
+        events: { emit() {} },
+      } as any,
+      refreshQuote: () => {},
+      stateRef,
+      tickerRepository,
+    });
+    return <text>harness</text>;
+  }
+  rendered = await testRender(<Harness />, { width: 20, height: 2 });
+  await act(async () => { await rendered!.renderOnce(); });
+
+  const importing = runtime.autoImportBrokerPositions(new Map(tickers));
+  await new Promise((resolve) => setTimeout(resolve, 10));
+  const pane = createPaneInstance("news", { instanceId: "news:opened-during-sync" });
+  const docked = getDockedPaneIds(stateRef.current.config.layout);
+  dispatch({ type: "PUSH_LAYOUT_HISTORY" });
+  dispatch({
+    type: "UPDATE_LAYOUT",
+    layout: addPaneToLayout(stateRef.current.config.layout, pane, { relativeTo: docked[docked.length - 1]!, position: "right" }),
+  });
+  answer();
+  await importing;
+
+  const { config: live } = stateRef.current;
+  expect(isPaneInLayout(live.layout, pane.instanceId)).toBe(true);
+  expect(live.portfolios.some((portfolio) => portfolio.brokerInstanceId === instance.id)).toBe(true);
+  expect(live.brokerInstances[0]?.lastSyncedAt).toBeNumber();
+  expect(saved.length).toBeGreaterThan(0);
+  expect(saved.every((entry) => isPaneInLayout(entry.layout, pane.instanceId))).toBe(true);
+  // The sync leaves the layout alone, so opening the pane can still be undone.
+  dispatch({ type: "UNDO_LAYOUT" });
+  expect(isPaneInLayout(stateRef.current.config.layout, pane.instanceId)).toBe(false);
+});

package/src/app/runtime/broker-import.ts

@@ -1,5 +1,10 @@
 import { useCallback, type Dispatch } from "react";
-import { restoreBrokerPortfoliosFromTickerPositions, syncBrokerInstance, syncBrokerInstances } from "../../brokers/sync-broker-instance";
+import {
+  rebaseBrokerSyncConfig,
+  restoreBrokerPortfoliosFromTickerPositions,
+  syncBrokerInstance,
+  syncBrokerInstances,
+} from "../../brokers/sync-broker-instance";
 import type { SyncBrokerInstanceResult } from "../../brokers/sync-broker-instance";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import type { PluginRegistry } from "../../plugins/registry";
@@ -7,6 +12,7 @@ import { saveConfigImmediately } from "../../state/config-save-scheduler";
 import type { AppAction, AppState } from "../../state/app/context";
 import type { AppConfig } from "../../types/config";
 import type { TickerRecord } from "../../types/ticker";
+import { getBrokerInstance } from "../../utils/broker-instances";
 
 export interface AppBrokerImportRuntime {
   importBrokerPositions: (
@@ -49,17 +55,24 @@ export function useBrokerImportRuntime({
     instanceId: string,
     result: SyncBrokerInstanceResult,
     baseConfig: AppConfig,
-    options?: Pick<BrokerImportOptions, "refreshImportedTickers" | "signal">,
+    options?: Pick<BrokerImportOptions, "refreshImportedTickers" | "signal"> & {
+      /** The caller passed its own draft config, so the result replaces the live one. */
+      callerOwnsConfig?: boolean;
+    },
   ) => {
     throwIfBrokerImportCancelled(options?.signal);
     dispatch({ type: "SET_BROKER_ACCOUNTS", instanceId, accounts: result.brokerAccounts });
 
-    if (result.config !== baseConfig) {
+    const liveConfig = stateRef.current.config;
+    const nextConfig = options?.callerOwnsConfig
+      ? (result.config !== baseConfig ? result.config : liveConfig)
+      : rebaseBrokerSyncConfig(liveConfig, baseConfig, result.config, instanceId);
+    if (nextConfig !== liveConfig) {
       throwIfBrokerImportCancelled(options?.signal);
-      dispatch({ type: "SET_CONFIG", config: result.config });
-      await saveConfigImmediately(result.config);
+      dispatch({ type: "SET_CONFIG", config: nextConfig });
+      await saveConfigImmediately(nextConfig);
       throwIfBrokerImportCancelled(options?.signal);
-      pluginRegistry.events.emit("config:changed", { config: result.config });
+      pluginRegistry.events.emit("config:changed", { config: nextConfig });
     }
 
     for (const ticker of result.addedTickers) {
@@ -79,7 +92,7 @@ export function useBrokerImportRuntime({
         refreshQuote(position.ticker, position.exchange, undefined, 1);
       }
     }
-  }, [dispatch, pluginRegistry.events, refreshQuote]);
+  }, [dispatch, pluginRegistry.events, refreshQuote, stateRef]);
 
   const importBrokerPositions = useCallback(async (
     instanceId: string,
@@ -99,6 +112,8 @@ export function useBrokerImportRuntime({
       deferPersistence: true,
     });
 
+    // A profile removed while its broker was answering stays removed, positions included.
+    if (!options?.config && !getBrokerInstance(stateRef.current.config.brokerInstances, instanceId)) return result;
     let commitStarted = false;
     try {
       throwIfBrokerImportCancelled(options?.signal);
@@ -106,7 +121,10 @@ export function useBrokerImportRuntime({
       commitStarted = true;
       await result.commit();
       throwIfBrokerImportCancelled(options?.signal);
-      await applyBrokerImportResult(instanceId, result, baseConfig, options);
+      await applyBrokerImportResult(instanceId, result, baseConfig, {
+        ...options,
+        callerOwnsConfig: options?.config !== undefined,
+      });
 
       return result;
     } finally {
@@ -128,7 +146,10 @@ export function useBrokerImportRuntime({
       tickerRepository,
       existingTickers: tickerMap,
       resources: pluginRegistry.persistence.resources,
+      deferPersistence: true,
       onResult: async (result, instance, previousConfig) => {
+        if (!getBrokerInstance(stateRef.current.config.brokerInstances, instance.id)) return;
+        await result.commit();
         await applyBrokerImportResult(instance.id, result, previousConfig, {
           refreshImportedTickers: false,
         });

package/src/brokers/sync-broker-instance.ts

@@ -48,6 +48,8 @@ export interface SyncBrokerInstancesArgs {
   existingTickers: Map<string, TickerRecord>;
   resources?: AppResourceStorePort;
   persistResolvedBrokerConfig?: boolean;
+  /** Leave each result's ticker writes to `onResult`, which calls `result.commit()`. */
+  deferPersistence?: boolean;
   onResult?: (result: SyncBrokerInstanceResult, instance: BrokerInstanceConfig, previousConfig: AppConfig) => void | Promise<void>;
 }
 
@@ -77,6 +79,69 @@ function throwIfBrokerImportCancelled(signal?: AbortSignal): void {
   }
 }
 
+/** The fields a sync changed, over an entry the user may have edited meanwhile (a rename, a disable). */
+function rebaseFields<T extends object>(live: T, base: T, synced: T): T {
+  const next = { ...live } as Record<string, unknown>;
+  const before = base as Record<string, unknown>;
+  const after = synced as Record<string, unknown>;
+  for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+    if (after[key] === before[key]) continue;
+    if (key in after) next[key] = after[key];
+    else delete next[key];
+  }
+  return next as T;
+}
+
+/** Applies the entries a sync added, changed or removed (by id) onto the live list. */
+function rebaseEntriesById<T extends { id: string }>(live: T[], base: T[], synced: T[]): T[] {
+  if (synced === base) return live;
+  const baseById = new Map(base.map((entry) => [entry.id, entry]));
+  const syncedById = new Map(synced.map((entry) => [entry.id, entry]));
+  const liveIds = new Set(live.map((entry) => entry.id));
+  let changed = false;
+  const next: T[] = [];
+  for (const entry of live) {
+    const before = baseById.get(entry.id);
+    const after = syncedById.get(entry.id);
+    if (before && !after) {
+      changed = true;
+      continue;
+    }
+    if (after && after !== before) {
+      changed = true;
+      next.push(before ? rebaseFields(entry, before, after) : after);
+      continue;
+    }
+    next.push(entry);
+  }
+  for (const entry of synced) {
+    if (baseById.has(entry.id) || liveIds.has(entry.id)) continue;
+    changed = true;
+    next.push(entry);
+  }
+  return changed ? next : live;
+}
+
+/**
+ * A broker can take seconds to answer, and the app is usable meanwhile. A sync
+ * only touches portfolios and broker instances, so only its changes to those
+ * are carried onto the live config; a pane opened or a tab switched while the
+ * broker was answering stays. A profile removed meanwhile stays removed.
+ */
+export function rebaseBrokerSyncConfig(
+  live: AppConfig,
+  base: AppConfig,
+  synced: AppConfig,
+  instanceId: string,
+): AppConfig {
+  if (synced === base || !getBrokerInstance(live.brokerInstances, instanceId)) return live;
+  const portfolios = rebaseEntriesById(live.portfolios, base.portfolios, synced.portfolios);
+  const brokerInstances = rebaseEntriesById(live.brokerInstances, base.brokerInstances, synced.brokerInstances);
+  return portfolios === live.portfolios && brokerInstances === live.brokerInstances
+    ? live
+    : { ...live, portfolios, brokerInstances };
+}
+
 async function maybePersistResolvedBrokerConfig(
   config: AppConfig,
   instance: BrokerInstanceConfig,
@@ -311,6 +376,7 @@ export async function syncBrokerInstances({
   existingTickers,
   resources,
   persistResolvedBrokerConfig = false,
+  deferPersistence = false,
   onResult,
 }: SyncBrokerInstancesArgs): Promise<SyncBrokerInstancesResult> {
   let nextConfig = config;
@@ -331,6 +397,7 @@ export async function syncBrokerInstances({
         existingTickers: nextTickers,
         resources,
         persistResolvedBrokerConfig,
+        deferPersistence,
       });
 
       nextConfig = result.config;

package/src/cli/commands/overview.ts

@@ -9,7 +9,7 @@ import {
   rankScreenerQuotes,
   type ScreenerCategory,
 } from "../../plugins/builtin/market-movers/screener";
-import { formatMoverPrice } from "../../plugins/builtin/market-movers/model";
+import { formatMoverPrice, moverReferencePrice } from "../../plugins/builtin/market-movers/model";
 import { loadCalendar, matchesCountry, matchesImpact, type CountryFilter, type ImpactFilter } from "../../plugins/builtin/econ/calendar-model";
 import { isoDate, requireArg, takeOption } from "./command-utils";
 import { buildCorrelationSeries } from "../../plugins/builtin/correlation/matrix/model";
@@ -32,7 +32,11 @@ const BASKET_NAMES = new Map<string, string>([
 // Priced like the MOST pane. Index and yield levels (^GSPC, ^TNX) carry no currency sign.
 const PRICE_COLUMN = { key: "price", header: "Last", align: "right" as const,
   format: (value: unknown, row: Record<string, unknown>) => typeof value === "number"
-    ? formatMoverPrice(value, typeof row.currency === "string" && !String(row.symbol ?? "").startsWith("^") ? row.currency : "") : "" };
+    ? formatMoverPrice(
+      value,
+      typeof row.currency === "string" && !String(row.symbol ?? "").startsWith("^") ? row.currency : "",
+      moverReferencePrice(row as Parameters<typeof moverReferencePrice>[0]),
+    ) : "" };
 const MOVER_COLUMNS = [
   { key: "symbol", header: "Symbol" },
   { key: "name", header: "Name" },

package/src/cli/native-smoke.ts

@@ -8,6 +8,8 @@ export async function smokeOpenTuiNative(): Promise<void> {
 
 export async function smokeOpenTuiRuntime(): Promise<void> {
   await import("../renderers/opentui/start");
+  const { assertRendersLeaveNoTimingEntries } = await import("../renderers/opentui/render-timing-smoke");
+  await assertRendersLeaveNoTimingEntries();
 }
 
 /**

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

@@ -53,6 +53,7 @@ import {
   formatCompositeCursorValue,
   formatCompositePointDetails,
   formatCompositeSeriesValue,
+  seriesPriceReference,
   formatCompositeTimeAxisDate,
   type CompositeAxisValueFormatter,
 } from "./format";
@@ -1450,9 +1451,27 @@ function legendValue(
   series: ResolvedSeries,
   value: number | null,
   formatValue: CompositeChartProps["formatValue"],
+  scene: CompositeChartScene | null,
 ): string {
   if (value === null) return "—";
-  return formatValue ? formatValue(value, series) : formatCompositeSeriesValue(value, series);
+  return formatValue ? formatValue(value, series) : formatCompositeSeriesValue(value, series, axisPriceReference(scene, series));
+}
+
+/** The reference the axis holding a series keeps for its asset, so an average
+ * of the price shows the price's decimals rather than its own float tail. A
+ * series far from that price (another coin on a shared axis) keeps its own. */
+function axisPriceReference(scene: CompositeChartScene | null, series: ResolvedSeries): number | undefined {
+  const own = seriesPriceReference(series);
+  for (const panel of scene?.panels ?? []) {
+    for (const domain of [panel.axes.left, panel.axes.right]) {
+      if (!domain?.seriesIds.includes(series.id)) continue;
+      const shared = domain.priceReferences?.[series.priceAssetCategory ?? ""];
+      if (shared === undefined || own === undefined) return own ?? shared;
+      const ratio = Math.abs(own / shared);
+      return ratio > 0.1 && ratio < 10 ? shared : own;
+    }
+  }
+  return own;
 }
 
 const LISTED_TICKER_PATTERN = /(^|[\s(])([A-Z0-9^][A-Z0-9.^=/-]*):([A-Z0-9]{2,})(?=$|[\s),])/g;
@@ -1511,6 +1530,7 @@ function CompositeLegend({
         entry,
         cursorValue?.value ?? null,
         formatValue,
+        scene,
       )}${changeText}`;
     const fullText = [entry.label, valueText].filter(Boolean).join(" ");
     const details = formatCompositePointDetails(cursorValue?.point);

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

@@ -1,4 +1,4 @@
-import { formatMarketPriceWithCurrency, type MarketFormatOptions } from "../../../market-data/market/format";
+import { formatMarketPriceWithCurrency, stablePriceFractionDigits, type MarketFormatOptions } from "../../../market-data/market/format";
 import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
 import type { CompositeAxisDomain, CompositePanelScene } from "./types";
 
@@ -48,12 +48,55 @@ function formatFullCurrencyValue(
   return currency ? formatMarketPriceWithCurrency(value, currency, { ...options, assetCategory }) : null;
 }
 
+function pointPriceValue(point: TimeSeriesPoint | undefined): number | undefined {
+  const value = point && Number.isFinite(point.value) ? point.value : point?.close;
+  return typeof value === "number" && Number.isFinite(value) && value !== 0 ? value : undefined;
+}
+
+/**
+ * The value a live price label takes its decimals from: the last completed
+ * bar, which holds still while the live one moves and sits near today's price
+ * even on a ten-year chart. Only market prices have one; fundamentals such as
+ * EPS keep formatting each value on its own.
+ */
+export function seriesPriceReference(series: ResolvedSeries): number | undefined {
+  if (series.observationKind !== "market" && series.dataShape !== "ohlcv" && series.priceAssetCategory === undefined) {
+    return undefined;
+  }
+  for (let index = series.points.length - 2; index >= 0; index -= 1) {
+    const value = pointPriceValue(series.points[index]);
+    if (value !== undefined) return value;
+  }
+  return pointPriceValue(series.points.at(-1));
+}
+
+/** A price label that moves with live data (the last price, the cursor, a
+ * legend value) keeps one decimal count for its asset, read from a reference
+ * price rather than the value itself: $150.10 does not become $150.1. */
+function stablePriceOptions(unit: string, assetCategory: string | undefined, referencePrice: number | undefined): MarketFormatOptions {
+  if (referencePrice === undefined) return {};
+  return {
+    referencePrice,
+    fixedFractionDigits: stablePriceFractionDigits({
+      assetCategory,
+      currency: unitCurrencyCode(unit) ?? undefined,
+      referencePrice,
+      sessionPrices: [referencePrice],
+    }),
+  };
+}
+
 /** An axis can serve several price series. Keep the most precise value the
  * shared formatter produces, rather than inheriting the first asset's rounding. */
-function formatAxisPriceValue(value: number, domain: CompositeAxisDomain, options: MarketFormatOptions = {}): string {
+function formatAxisPriceValue(
+  value: number,
+  domain: CompositeAxisDomain,
+  options: MarketFormatOptions | ((category: string | undefined) => MarketFormatOptions) = {},
+): string {
   const categories = domain.priceAssetCategories?.length ? domain.priceAssetCategories : [undefined];
   return categories.reduce<string>((best, category) => {
-    const formatted = formatFullCurrencyValue(value, domain.unit, category, options) ?? "";
+    const categoryOptions = typeof options === "function" ? options(category) : options;
+    const formatted = formatFullCurrencyValue(value, domain.unit, category, categoryOptions) ?? "";
     return formatted.length > best.length ? formatted : best;
   }, "");
 }
@@ -190,11 +233,24 @@ function compactResolution(value: number): number {
   return absolute > 0 ? 10 ** (Math.floor(Math.log10(absolute)) - 2) : 0;
 }
 
-export function formatCompositeSeriesValue(value: number, series: ResolvedSeries): string {
-  return formatChartLegendValue(value, series.unit, series.unitGroup, series.priceAssetCategory);
+/** `referencePrice` defaults to the series' own; a study on a price axis
+ * passes the axis's reference so it shares the price's decimals. */
+export function formatCompositeSeriesValue(
+  value: number,
+  series: ResolvedSeries,
+  referencePrice = seriesPriceReference(series),
+): string {
+  return formatChartLegendValue(value, series.unit, series.unitGroup, series.priceAssetCategory, referencePrice);
 }
 
-export function formatChartLegendValue(value: number, unit: string, unitGroup = "", assetCategory?: string): string {
+export function formatChartLegendValue(
+  value: number,
+  unit: string,
+  unitGroup = "",
+  assetCategory?: string,
+  /** Set for a live series: its price keeps the decimals this reference calls for. */
+  referencePrice?: number,
+): string {
   const trimmed = unit.trim();
   const group = unitGroup.toLowerCase();
   const compact = compactNumber(value);
@@ -212,7 +268,12 @@ export function formatChartLegendValue(value: number, unit: string, unitGroup =
       return prefix ? `${value < 0 ? "-" : ""}${prefix}${amount}` : `${amount} ${trimmed}`.trim();
     }
   }
-  const fullPrice = formatFullCurrencyValue(value, trimmed, assetCategory);
+  const fullPrice = formatFullCurrencyValue(
+    value,
+    trimmed,
+    assetCategory,
+    referencePrice === undefined ? {} : stablePriceOptions(trimmed, assetCategory, referencePrice),
+  );
   if (fullPrice) return fullPrice;
   return trimmed && trimmed.length <= 6 ? `${compact}${trimmed.startsWith("/") ? "" : " "}${trimmed}` : compact;
 }
@@ -267,7 +328,9 @@ export function formatCompositeCursorValue(value: number, domain: CompositeAxisD
   if (group.split(":")[0] === "currency-total") {
     return formatChartLegendValue(value, domain.unit, domain.unitGroup);
   }
-  const fullPrice = formatAxisPriceValue(value, domain);
+  const fullPrice = formatAxisPriceValue(value, domain, (category) => (
+    stablePriceOptions(domain.unit, category, domain.priceReferences?.[category ?? ""])
+  ));
   if (fullPrice) return fullPrice;
   return formatCompositeAxisValue(value, domain);
 }

package/src/components/chart/composite/fx-precision.test.ts

@@ -6,9 +6,10 @@ import { buildPriceChartPreset } from "../../../plugins/builtin/chart-composer/p
 import { formatMarketPriceWithCurrency } from "../../../market-data/market/format";
 import { applyResolvedSeriesTransform } from "../../../time-series/transforms";
 import type { HeadlessPaneContext } from "../../../types/headless";
-import { formatCompositeCursorValue, formatCompositeSeriesValue } from "./format";
+import { formatCompositeCursorValue, formatCompositeSeriesValue, seriesPriceReference } from "./format";
 import { applyCompositeChartCursor, buildCompositeChartScene, resolveCompositeCursorDate } from "./scene";
 import { reuseResolvedSeriesIdentity } from "./panel-series";
+import { pricePointsToResolvedSeries } from "./price-series";
 
 const cases = [
   ["EURUSD=X", "USD", "CURRENCY", 1.1602274179458618, "$1.160227"],
@@ -26,7 +27,9 @@ const cases = [
 
 async function priceModel(symbol: string, currency: string, instrumentType: string, value: number) {
   const step = Math.min(0.0001, value / 10);
-  const points = [0, 1, 2].map((offset) => ({ date: new Date(Date.UTC(2026, 8, 9 + offset)), close: value + (offset - 2) * step }));
+  // The last completed bar closed where the quote is: a live label takes its
+  // decimals from that close, which a real feed writes like the quote.
+  const points = [value + step, value, value].map((close, offset) => ({ date: new Date(Date.UTC(2026, 8, 9 + offset)), close }));
   const spec = buildPriceChartPreset(symbol);
   spec.viewport = { ...spec.viewport, range: "1M", resolution: "1d", dateWindow: { start: "2026-09-09", end: "2026-09-11" } };
   spec.studies = [{ id: "sma", kind: "sma", inputSeriesIds: [spec.series[0]!.id], parameters: { period: 2 }, panelId: "main", axis: "left" }];
@@ -64,7 +67,9 @@ for (const [symbol, currency, category, value, expected] of cases) {
     expect(formatCompositeCursorValue(cursor.value!, panel.axes[series.axis]!)).toBe(expected);
     const average = model.chart.series.find((entry) => entry.id === "sma")!;
     const averageValue = average.points.at(-1)!.value!;
-    expect(formatCompositeSeriesValue(averageValue, average)).toBe(formatMarketPriceWithCurrency(averageValue, currency, { assetCategory: category }));
+    // On the price's axis, a study of the price is written like the price.
+    expect(formatCompositeSeriesValue(averageValue, average, seriesPriceReference(series)))
+      .toBe(formatCompositeSeriesValue(averageValue, series));
   });
 }
 
@@ -91,3 +96,16 @@ test("FX metadata does not turn normalized returns or ratios into currency price
   expect(formatCompositeSeriesValue(latest.value!, percent)).toEndWith("%");
   expect(formatCompositeSeriesValue(1.25, { ...fx, unit: "x", unitGroup: "ratio" })).toBe("1.25x");
 });
+
+// Live labels read their decimals from the last completed bar, not the start
+// of the window: a ten-year chart that began under $1 still prints cents.
+test("a long-range chart labels today's price at today's precision", () => {
+  const closes = [0.0376, 12.5, 180.07, 180.12];
+  const series = pricePointsToResolvedSeries(
+    closes.map((close, day) => ({ date: new Date(Date.UTC(2016 + day * 3, 0, 1)), close })),
+    { id: "nvda", label: "NVDA", color: "#fff", unit: "USD" },
+  );
+  expect(formatCompositeSeriesValue(180.12, series)).toBe("$180.12");
+  const earnings = { ...series, dataShape: "scalar" as const, unitGroup: "currency-per-share" };
+  expect(formatCompositeSeriesValue(2.35, earnings)).toBe("$2.35");
+});

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

@@ -20,7 +20,7 @@ import {
   projectCompositeTimestamp,
   unprojectCompositeTimestamp,
 } from "./time-scale";
-import { compositeAxisMaxTicks } from "./format";
+import { compositeAxisMaxTicks, seriesPriceReference } from "./format";
 import type { CompositeLastPriceMarker, CompositeTimeScale } from "./types";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -290,6 +290,17 @@ function signBounded(rawMin: number, rawMax: number, padded: { min: number; max:
   };
 }
 
+function axisPriceReferences(axisSeries: ResolvedSeries[]): Record<string, number> {
+  const references: Record<string, number> = {};
+  for (const entry of axisSeries) {
+    const key = entry.priceAssetCategory ?? "";
+    if (key in references) continue;
+    const value = seriesPriceReference(entry);
+    if (value !== undefined) references[key] = value;
+  }
+  return references;
+}
+
 function buildAxisDomain(
   side: CompositeAxisSide,
   series: ResolvedSeries[],
@@ -308,6 +319,7 @@ function buildAxisDomain(
     unit: first.unit,
     unitGroup: first.unitGroup,
     priceAssetCategories: [...new Set(axisSeries.flatMap((entry) => entry.priceAssetCategory ? [entry.priceAssetCategory] : []))],
+    priceReferences: axisPriceReferences(axisSeries),
     seriesIds: axisSeries.map((entry) => entry.id),
     maxTicks: compositeAxisMaxTicks(rows),
     tickRows: rows,

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

@@ -26,6 +26,10 @@ export interface CompositeAxisDomain {
   unitGroup: string;
   /** Each source's price category, retained when different assets share an axis. */
   priceAssetCategories?: string[];
+  /** The reference price of the axis's first market series of each price
+   * category (keyed by category, "" for none). It sets the decimals of the
+   * cursor and last-price labels, so they do not follow the live value. */
+  priceReferences?: Record<string, number>;
   seriesIds: string[];
   /** Most labeled ticks the axis shows, sized to the panel height. */
   maxTicks?: number;