gloomberb 0.16.4 → 0.16.6

package/src/plugins/builtin/chart-composer/pane.tsx

@@ -1,4 +1,5 @@
 import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../../../utils/financial-statements";
+import { usePaneSharePreparation } from "../../../shares/prepare";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, useUiCapabilities } from "../../../ui";
 import {
@@ -116,13 +117,14 @@ import { getActiveQuoteDisplay } from "../../../market-data/market/status";
 import { resolveEntryData } from "../../../market-data/selectors";
 import { editPriceLevels, parsePriceLevels, PRICE_LEVELS_KEY, priceLevelTickerKey } from "./price-levels";
 import { canonicalExchange } from "../../../utils/exchanges";
-import { isPlainKey } from "../../../utils/keyboard";
 import { resolveInstrumentForPane } from "../../../core/state/app/instrument";
 import { CHART_FOLLOW_SERIES_SETTING_KEY, rebindFollowChartSpec, resolveFollowSeriesIds } from "./follow-binding";
 import type { InstrumentRef } from "../../../market-data/request-types";
 
 const RANGE_OPTIONS = RANGES.map((range, index) => ({ label: range, value: range, hint: String(index + 1) }));
 const AUTO_VIEWPORT_DEBOUNCE_MS = 350;
+/** A load for a moving view that has not answered in this long no longer holds the next one back. */
+const LOAD_AHEAD_TIMEOUT_MS = 4_000;
 /**
  * Drawings persist into pane settings on a short debounce after the pointer
  * settles. A share reads those settings, so it waits at least that long for a
@@ -144,6 +146,22 @@ interface RuntimeChartViewportState {
   requestViewport: RuntimeChartViewport;
 }
 
+/** The oldest and newest market bars loaded, and whether every listing has said it keeps nothing older. */
+function loadedMarketHistory(series: readonly ResolvedSeries[]): { start: number; end: number; complete: boolean } | null {
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  let complete = true;
+  for (const entry of series) {
+    if (entry.observationKind !== "market" || entry.points.length === 0) continue;
+    const first = entry.points[0]!.date.getTime();
+    const last = entry.points.at(-1)!.date.getTime();
+    if (Number.isFinite(first)) start = Math.min(start, first);
+    if (Number.isFinite(last)) end = Math.max(end, last);
+    if (!entry.historyStart) complete = false;
+  }
+  return Number.isFinite(start) && Number.isFinite(end) ? { start, end, complete } : null;
+}
+
 function runtimeViewportFromSetting(
   setting: ChartInteractionViewport | null,
   authoredViewportKey: string,
@@ -258,7 +276,7 @@ function ChartComposerSurface({
 }: ChartComposerSurfaceProps) {
   const dialog = useDialog();
   const dispatch = useAppDispatch();
-  const { publicSharing, cellWidthPx = 8 } = useUiCapabilities();
+  const { cellWidthPx = 8 } = useUiCapabilities();
   const desktopWeb = useUiCapabilities().nativePaneChrome === true;
   const paneId = usePaneInstanceId();
   const liveStreaming = useLiveStreamingSetting();
@@ -351,9 +369,15 @@ function ChartComposerSurface({
     spec.viewport.range,
     spec.viewport.resolution,
   ]);
+  // Auto names the bars it is on, which change as the view moves: a pan back
+  // past where a source keeps 30-minute bars charts days instead.
+  const autoBars = spec.viewport.resolution === "auto" ? resolution.resolution ?? null : null;
   const resolutionOptions = useMemo(
-    () => availableResolutions.map((value) => ({ label: formatChartResolution(value), value })),
-    [availableResolutions],
+    () => availableResolutions.map((value) => ({
+      label: value === "auto" && autoBars ? `Auto (${formatChartResolution(autoBars)})` : formatChartResolution(value),
+      value,
+    })),
+    [autoBars, availableResolutions],
   );
   const selectedStudies = getSelectedBuiltinStudies(spec);
   const selectedPairStudies = getSelectedPairStudies(spec);
@@ -396,7 +420,7 @@ function ChartComposerSurface({
     ),
     [resolution.bufferedSeries, resolution.legendSeries, resolution.series, spec],
   );
-  const { sharePane, notify } = usePluginAppActions();
+  const { notify } = usePluginAppActions();
   const { runtime } = usePluginRenderContext();
   const [levelStore, setLevelStore] = usePluginConfigState<unknown>(PRICE_LEVELS_KEY, null);
   const alertsJson = useAppSelector((state) => state.config.pluginConfig[PRICE_ALERTS_STORE.pluginId]?.[PRICE_ALERTS_STORE.key]);
@@ -472,10 +496,6 @@ function ChartComposerSurface({
       ...(alertsOn ? { action: { label: "alert", title: "Alert at Level", run: (level) => { void alertAtLevel(level.value); } } } : {}),
     };
   }, [alertAtLevel, alertsJson, alertsOn, editLevels, levelStore, listing]);
-  const shareTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  useEffect(() => () => {
-    if (shareTimerRef.current !== null) clearTimeout(shareTimerRef.current);
-  }, []);
   const [interactionCaptured, setInteractionCapturedState] = useState(false);
   // Typing in quick-add must not freeze the plot: it only takes the keyboard.
   const [modalCaptured, setModalCaptured] = useState(false);
@@ -631,7 +651,19 @@ function ChartComposerSurface({
   const activatePane = useCallback(() => {
     if (!focused) dispatch({ type: "FOCUS_PANE", paneId });
   }, [dispatch, focused, paneId]);
+  useEffect(() => () => {
+    if (runtimeViewportTimerRef.current !== null) {
+      clearTimeout(runtimeViewportTimerRef.current);
+      runtimeViewportTimerRef.current = null;
+    }
+  }, []);
+  // The view this pane last saved, so its own write coming back through the
+  // settings is not mistaken for another device's view: that would cancel the
+  // load a pan still in progress has scheduled and put its window back.
+  const savedInteractionViewportRef = useRef<string | null>(null);
   useEffect(() => {
+    if (persistedInteractionViewport && requestViewportOwnerRef.current === authoredViewportKey
+      && JSON.stringify(persistedInteractionViewport) === savedInteractionViewportRef.current) return;
     if (runtimeViewportTimerRef.current !== null) {
       clearTimeout(runtimeViewportTimerRef.current);
       runtimeViewportTimerRef.current = null;
@@ -645,30 +677,41 @@ function ChartComposerSurface({
     requestViewportOwnerRef.current = authoredViewportKey;
     setRuntimeViewportState((current) => current?.key === authoredViewportKey ? current : restored);
     if (persistedInteractionViewport && !restored) setStoredInteractionViewport(null);
-    return () => {
-      if (runtimeViewportTimerRef.current !== null) {
-        clearTimeout(runtimeViewportTimerRef.current);
-        runtimeViewportTimerRef.current = null;
-      }
-    };
   }, [authoredViewportKey, persistedInteractionViewport, setStoredInteractionViewport]);
-  const commitRuntimeViewport = useCallback(() => {
+  // The bars loaded so far, and whether the source has said nothing older exists.
+  const loadedHistory = useMemo(() => loadedMarketHistory(plottedSeries), [plottedSeries]);
+  const loadedHistoryRef = useRef(loadedHistory);
+  loadedHistoryRef.current = loadedHistory;
+  // The newest bar seen at all: bars loaded for a moved view (finer ones, after
+  // a zoom) can end before it, and a pan forward then has more to ask for.
+  const newestBarRef = useRef(Number.NEGATIVE_INFINITY);
+  if (loadedHistory) newestBarRef.current = Math.max(newestBarRef.current, loadedHistory.end);
+  // A window asked for and not answered yet: the result's view ends where the request does once it lands.
+  const loadingWindowRef = useRef<{ end: number; at: number } | null>(null);
+  const resultViewportEnd = resolution.viewport?.end.getTime() ?? null;
+  if (loadingWindowRef.current && resultViewportEnd !== null
+    && Math.abs(resultViewportEnd - loadingWindowRef.current.end) < 1_000) loadingWindowRef.current = null;
+  const commitRuntimeViewport = useCallback((save = true) => {
     const requestViewport = requestViewportRef.current;
     if (!requestViewport) return;
     const adaptiveViewport = spec.viewport.resolution === "auto"
       ? adaptiveViewportRef.current
       : null;
+    loadingWindowRef.current = { end: requestViewport.end.getTime(), at: Date.now() };
     setRuntimeViewportState({
       key: authoredViewportKey,
       adaptiveViewport,
       requestViewport,
     });
-    setStoredInteractionViewport({
+    if (!save) return;
+    const saved = {
       authoredViewportKey,
       start: requestViewport.start.toISOString(),
       end: requestViewport.end.toISOString(),
       adaptive: adaptiveViewport !== null,
-    } satisfies ChartInteractionViewport);
+    } satisfies ChartInteractionViewport;
+    savedInteractionViewportRef.current = JSON.stringify(parseChartInteractionViewport(saved));
+    setStoredInteractionViewport(saved);
   }, [authoredViewportKey, setStoredInteractionViewport, spec.viewport.resolution]);
   const handleChartViewportChange = useCallback((
     next: { start: Date; end: Date } | null,
@@ -681,6 +724,7 @@ function ChartComposerSurface({
     if (!next) {
       adaptiveViewportRef.current = null;
       requestViewportRef.current = null;
+      loadingWindowRef.current = null;
       setRuntimeViewportState(null);
       setStoredInteractionViewport(null);
       return;
@@ -694,24 +738,31 @@ function ChartComposerSurface({
     // A pan can leave the window a provider serves at the current resolution
     // just as a zoom can, so both re-pick.
     if (spec.viewport.resolution === "auto") adaptiveViewportRef.current = viewport;
+    // Bars are asked for while the view is still moving, once it comes within
+    // half a screen of the oldest loaded one (or of the newest, when newer
+    // ones exist), so a long pan keeps going instead of running into the end
+    // of what is loaded and waiting for the pointer to rest.
+    const loaded = loadedHistoryRef.current;
+    const loading = loadingWindowRef.current;
+    const reach = (end - start) / 2;
+    const nearOldest = !!loaded && !loaded.complete && start - loaded.start < reach;
+    const nearNewest = !!loaded && loaded.end < newestBarRef.current - reach / 10 && loaded.end - end < reach;
+    if ((nearOldest || nearNewest) && (!loading || Date.now() - loading.at > LOAD_AHEAD_TIMEOUT_MS)) {
+      commitRuntimeViewport(false);
+    }
     runtimeViewportTimerRef.current = globalThis.setTimeout(() => {
       runtimeViewportTimerRef.current = null;
       commitRuntimeViewport();
     }, AUTO_VIEWPORT_DEBOUNCE_MS);
-  }, [authoredViewportKey, commitRuntimeViewport, spec.viewport.resolution]);
-  const shareChart = useCallback(() => {
-    // The share reads pane settings, so the gesture in flight lands there first.
+  }, [authoredViewportKey, commitRuntimeViewport, setStoredInteractionViewport, spec.viewport.resolution]);
+  usePaneSharePreparation(paneId, async () => {
     if (runtimeViewportTimerRef.current !== null) {
       clearTimeout(runtimeViewportTimerRef.current);
       runtimeViewportTimerRef.current = null;
       commitRuntimeViewport();
     }
-    if (shareTimerRef.current !== null) return;
-    shareTimerRef.current = globalThis.setTimeout(() => {
-      shareTimerRef.current = null;
-      sharePane(paneId);
-    }, SHARE_SETTLE_DELAY_MS);
-  }, [commitRuntimeViewport, paneId, sharePane]);
+    await new Promise((resolve) => setTimeout(resolve, SHARE_SETTLE_DELAY_MS));
+  });
 
   useRemoteUiNode({
     role: "chart-data",
@@ -800,12 +851,6 @@ function ChartComposerSurface({
   );
   useShortcut((event) => {
     if (interactionCaptureRef.current || dialogOpen) return;
-    if (publicSharing && isPlainKey(event, "y")) {
-      event.preventDefault();
-      event.stopPropagation();
-      shareChart();
-      return;
-    }
     const shortcut = resolveChartComposerShortcut(event, RANGES.length);
     if (!shortcut) return;
     event.preventDefault();
@@ -871,11 +916,10 @@ function ChartComposerSurface({
   });
 
   // Footer registrations compare presentation, so their callbacks must read current actions.
-  const currentActionsRef = useRef({ openSeriesEditor, openResolutionPicker, shareChart });
-  currentActionsRef.current = { openSeriesEditor, openResolutionPicker, shareChart };
+  const currentActionsRef = useRef({ openSeriesEditor, openResolutionPicker });
+  currentActionsRef.current = { openSeriesEditor, openResolutionPicker };
   const footerSeries = useCallback(() => { void currentActionsRef.current.openSeriesEditor(); }, []);
   const footerResolution = useCallback(() => { void currentActionsRef.current.openResolutionPicker(); }, []);
-  const footerShare = useCallback(() => { currentActionsRef.current.shareChart(); }, []);
   const openIndicators = useCallback((event?: PaneFooterPressEvent) => {
     indicatorsDialogRef.current?.open(footerAnchorPoint(event));
   }, []);
@@ -901,9 +945,8 @@ function ChartComposerSurface({
       { id: "formulas", key: "f", label: "ormulas", onPress: openFormulas, disabled: formulasDisabled },
       { id: "resolution", key: "t", label: "imeframe", onPress: footerResolution },
       ...(anchorable ? [{ id: "vwap-anchor", key: "v", label: "wap anchor", title: "Anchor VWAP", onPress: footerAnchor }] : []),
-      ...(publicSharing ? [{ id: "share", key: "y", label: " share", onPress: footerShare }] : []),
     ],
-  }), [resolution.loading, pickingAnchor, footerSeries, openIndicators, indicatorsDisabled, openFormulas, formulasDisabled, footerResolution, anchorable, footerAnchor, publicSharing, footerShare]);
+  }), [resolution.loading, pickingAnchor, footerSeries, openIndicators, indicatorsDisabled, openFormulas, formulasDisabled, footerResolution, anchorable, footerAnchor]);
 
   // A fixed window (a GIP session) highlights no range, so the bar names it.
   const dateWindowLabel = useMemo(() => {

package/src/plugins/builtin/chart-composer/series-catalog.ts

@@ -7,11 +7,7 @@ import {
   type ChartSeriesCatalogItem,
 } from "../../../capabilities";
 import type { TimeSeriesFieldDefinition } from "../../../time-series/types";
-import {
-  FUTURES_CONTRACTS,
-  FUTURES_SECTOR_LABELS,
-} from "../futures/contracts";
-import { TREASURY_MATURITIES } from "../yield-curve/treasury-data";
+import type { SeriesCatalogEntry } from "../../../series/types";
 import {
   canonicalExchange,
   parsePublicTickerKey,
@@ -271,50 +267,61 @@ function matchesAliasQuery(query: string, ...values: string[]): boolean {
   return tokens.length > 0 && tokens.every((token) => searchable.includes(token));
 }
 
-function coreAliasSuggestions(query: string): SeriesCatalogSuggestion[] {
-  const futures = FUTURES_CONTRACTS
-    .filter((contract) => matchesAliasQuery(
-      query,
-      `FUT:${contract.code}`,
-      contract.code,
-      contract.name,
-      `${contract.name} futures`,
-      contract.sector,
-      FUTURES_SECTOR_LABELS[contract.sector],
-    ))
-    .map((contract): SeriesCatalogSuggestion => ({
-      id: `${contract.symbol}:market.ohlcv`,
-      label: `FUT:${contract.code} · ${contract.name}`,
-      description: `${FUTURES_SECTOR_LABELS[contract.sector]} futures`,
-      detail: "Futures",
-      expression: {
-        kind: "security",
-        symbol: contract.symbol,
-        fieldId: "market.ohlcv",
-        label: contract.name,
-      },
-    }));
-  const treasuries = TREASURY_MATURITIES
-    .filter((treasury) => matchesAliasQuery(
-      query,
-      `UST:${treasury.maturity}`,
-      treasury.maturity,
-      treasury.seriesId,
-      `${treasury.maturity.replace("M", " month").replace("Y", " year")} US Treasury yield`,
-    ))
-    .map((treasury): SeriesCatalogSuggestion => ({
-      id: `fred:${treasury.seriesId}`,
-      label: `UST:${treasury.maturity} · Treasury Yield`,
-      description: `U.S. Treasury ${treasury.maturity} yield · FRED ${treasury.seriesId}`,
-      detail: "Treasury",
-      expression: {
-        kind: "economic",
-        provider: "fred",
-        seriesId: treasury.seriesId,
-        label: `${treasury.maturity} Treasury Yield`,
-      },
-    }));
-  return [...futures, ...treasuries];
+function suggestionId(expression: ParsedSeriesExpression): string {
+  if (expression.kind === "economic") return `fred:${expression.seriesId}`;
+  if (expression.kind === "capability") {
+    return chartSeriesSourceKey({ kind: "capability", capabilityId: expression.capabilityId, seriesId: expression.seriesId });
+  }
+  return `${publicTickerKey(expression.symbol, expression.exchange)}:${expression.fieldId}`;
+}
+
+function registeredMatchRank(entry: SeriesCatalogEntry, query: string): number {
+  const name = compact(entry.name);
+  const needle = compact(query);
+  if (name === needle || compact(entry.expression) === needle) return 0;
+  if (name.startsWith(needle)) return 1;
+  return 2;
+}
+
+/**
+ * Registered catalog series the query names: by name, expression, group or
+ * tags. A series that takes a ticker is filled in with the one the query
+ * names, or the chart's own; ticker fields come from the field ranking instead.
+ */
+function registeredSeriesSuggestions(
+  query: string,
+  registered: readonly SeriesCatalogEntry[],
+  analysis: SeriesSearchAnalysis,
+  defaultInstrument: SeriesCatalogInstrument,
+): SeriesCatalogSuggestion[] {
+  if (!query.trim() || registered.length === 0) return [];
+  const instrument = analysis.directInstrument ?? defaultInstrument;
+  const tickerQuery = analysis.directInstrument ? analysis.metricQuery : query;
+  const hits: Array<{ entry: SeriesCatalogEntry; rank: number; expression: ParsedSeriesExpression }> = [];
+  for (const entry of registered) {
+    let template = entry.expression;
+    let text = query;
+    if (entry.input) {
+      // Ticker fields are ranked against the security below; options and pairs need their own symbol.
+      if (entry.input !== "ticker" || /^\{ticker\}:[A-Za-z]/.test(template) || !tickerQuery.trim()) continue;
+      const symbol = publicTickerKey(instrument.symbol, instrument.exchange);
+      template = template.replaceAll("{ticker}", template.startsWith("CAP:") ? encodeURIComponent(symbol) : symbol);
+      text = tickerQuery;
+    }
+    if (!matchesAliasQuery(text, entry.name, entry.expression, entry.id, entry.group ?? "", ...(entry.tags ?? []))) continue;
+    const parsed = parseSeriesExpression(template);
+    if (!parsed) continue;
+    const label = entry.input ? `${publicTickerKey(instrument.symbol, instrument.exchange)} · ${entry.name}` : entry.name;
+    hits.push({ entry, rank: registeredMatchRank(entry, text), expression: { ...parsed, label } });
+  }
+  hits.sort((left, right) => left.rank - right.rank || left.entry.name.length - right.entry.name.length);
+  return hits.map(({ entry, expression }): SeriesCatalogSuggestion => ({
+    id: suggestionId(expression),
+    label: expression.kind === "capability" ? expression.label ?? entry.name : `${entry.expression} · ${entry.name}`,
+    description: [entry.group, entry.unit, entry.frequency].filter(Boolean).join(" · "),
+    detail: entry.group ?? "Series",
+    expression,
+  }));
 }
 
 export function buildCapabilitySeriesSuggestions(
@@ -345,6 +352,7 @@ export function buildSeriesCatalogSuggestions(
   defaultInstrument: SeriesCatalogInstrument,
   searchedInstruments: readonly SeriesCatalogInstrument[] = [],
   limit = 8,
+  registered: readonly SeriesCatalogEntry[] = [],
 ): SeriesCatalogSuggestion[] {
   const exact = exactExpressionSuggestion(query.trim());
   const analysis = analyzeSeriesSearchQuery(query);
@@ -362,7 +370,7 @@ export function buildSeriesCatalogSuggestions(
     .sort((left, right) => right.score - left.score || left.field.label.localeCompare(right.field.label));
 
   const suggestions: SeriesCatalogSuggestion[] = exact ? [exact] : [];
-  for (const suggestion of coreAliasSuggestions(query)) {
+  for (const suggestion of registeredSeriesSuggestions(query, registered, analysis, defaultInstrument)) {
     if (!suggestions.some((entry) => entry.id === suggestion.id)) suggestions.push(suggestion);
   }
   const fieldLimit = instruments.length > 1 && !analysis.metricQuery ? 1 : rankedFields.length;

package/src/plugins/builtin/chart-composer/series-expression.ts

@@ -15,7 +15,8 @@ import {
   isValidChartCapabilityId,
   isValidChartSeriesId,
 } from "../../../capabilities/chart-series";
-import { FUTURES_CONTRACTS } from "../futures/contracts";
+import { futuresContractByCode } from "../../../market-data/futures-board";
+import { getSharedRegistry } from "../../registry";
 import { TREASURY_MATURITIES } from "../yield-curve/treasury-data";
 
 export const CHART_FIELD_IDS = {
@@ -100,9 +101,9 @@ export function parseSeriesExpression(value: string): ParsedSeriesExpression | n
     if (separator < 0) return null;
     const capabilityId = trimmed.slice(4, separator);
     const seriesId = trimmed.slice(separator + 1);
-    return isValidChartCapabilityId(capabilityId) && isValidChartSeriesId(seriesId)
-      ? { kind: "capability", capabilityId, seriesId }
-      : null;
+    if (!isValidChartCapabilityId(capabilityId) || !isValidChartSeriesId(seriesId)) return null;
+    const label = registeredSeriesName({ capabilityId, seriesId });
+    return { kind: "capability", capabilityId, seriesId, ...(label ? { label } : {}) };
   }
   if (parts[0]?.trim().toUpperCase() === "GEO") {
     const seriesId = trimmed.slice(trimmed.indexOf(":") + 1).trim();
@@ -112,13 +113,13 @@ export function parseSeriesExpression(value: string): ParsedSeriesExpression | n
   }
   if (parts[0]?.trim().toUpperCase() === "FRED") {
     const seriesId = parts.length === 2 ? parts[1]?.trim().toUpperCase() ?? "" : "";
-    return /^[A-Z0-9._-]{1,80}$/.test(seriesId)
-      ? { kind: "economic", provider: "fred", seriesId }
-      : null;
+    if (!/^[A-Z0-9._-]{1,80}$/.test(seriesId)) return null;
+    // The catalog's name for a listed series, so the legend says what the catalog said.
+    const label = getSharedRegistry()?.series?.findByExpression(`FRED:${seriesId}`)?.definition.name;
+    return { kind: "economic", provider: "fred", seriesId, ...(label ? { label } : {}) };
   }
   if (parts.length === 2 && parts[0]?.trim().toUpperCase() === "FUT") {
-    const code = parts[1]?.trim().toUpperCase();
-    const contract = FUTURES_CONTRACTS.find((entry) => entry.code === code);
+    const contract = futuresContractByCode(parts[1]);
     return contract
       ? { kind: "security", symbol: contract.symbol, fieldId: CHART_FIELD_IDS.price, label: contract.name }
       : null;
@@ -189,10 +190,17 @@ export function formatSeriesExpression(series: ChartSeriesSpec): string {
   return `${publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange)}:${series.source.fieldId}`;
 }
 
+/** A registered catalog series' name, with the ticker it was charted for. */
+export function registeredSeriesName(source: { capabilityId: string; seriesId: string }): string | null {
+  const found = getSharedRegistry()?.series?.findLoaded(source.capabilityId, source.seriesId);
+  if (!found) return null;
+  return found.ticker ? `${found.ticker} ${found.series.definition.name}` : found.series.definition.name;
+}
+
 export function chartSeriesLabel(series: ChartSeriesSpec): string {
   if (series.label?.trim()) return series.label.trim();
   if (series.source.kind === "economic") return `FRED ${series.source.seriesId}`;
-  if (series.source.kind === "capability") return series.source.seriesId;
+  if (series.source.kind === "capability") return registeredSeriesName(series.source) ?? series.source.seriesId;
   const generic = getTimeSeriesField(series.source.fieldId)?.unitGroup === "price"
     ? futuresGenericListing(series.source.instrument.symbol, series.source.instrument.exchange) : null;
   if (generic) return futuresGenericCaption(generic);

package/src/plugins/builtin/chart-composer/use-series-catalog.ts

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import {
   buildTickerSearchCandidates,
   searchTickerCandidates,
@@ -6,6 +6,8 @@ import {
 import { useOptionalAppSelector } from "../../../state/app/context";
 import type { TickerRecord } from "../../../types/ticker";
 import { searchChartSeriesCapabilities } from "../../../capabilities";
+import { SERIES_CATALOG_CAPABILITY_ID } from "../../../series/capability";
+import type { SeriesCatalogEntry } from "../../../series/types";
 import { getSharedRegistry } from "../../registry";
 import {
   analyzeSeriesSearchQuery,
@@ -17,6 +19,9 @@ import {
 
 const EMPTY_TICKERS: ReadonlyMap<string, TickerRecord> = new Map();
 const EMPTY_RECENT: readonly string[] = [];
+const EMPTY_PLUGINS: readonly string[] = [];
+const EMPTY_ENTRIES: readonly SeriesCatalogEntry[] = [];
+const NO_SUBSCRIPTION = () => () => {};
 const MAX_SERIES_SUGGESTIONS = 8;
 const DEFAULT_CATALOG_INSTRUMENTS: readonly SeriesCatalogInstrument[] = [
   { symbol: "AAPL", exchange: "NASDAQ", name: "Apple Inc." },
@@ -72,6 +77,56 @@ function candidateToInstrument(candidate: {
   };
 }
 
+/**
+ * Every registered series of the plugins that are switched on. On the
+ * desktop, series only the Bun process has (files in the profile's series
+ * folder) are asked for once and listed after the rest; elsewhere, sources
+ * that change while the app runs catch up when the catalog opens.
+ */
+export function useRegisteredSeries(): readonly SeriesCatalogEntry[] {
+  const registry = getSharedRegistry();
+  const series = registry?.series;
+  const version = useSyncExternalStore(
+    series ? series.subscribe.bind(series) : NO_SUBSCRIPTION,
+    () => series?.getVersion() ?? 0,
+    () => 0,
+  );
+  const disabledPlugins = useOptionalAppSelector((state) => state.config.disabledPlugins, EMPTY_PLUGINS);
+  const [remote, setRemote] = useState<readonly SeriesCatalogEntry[] | null>(null);
+
+  useEffect(() => {
+    if (!registry || !series) return;
+    if (!registry.usesRemoteCapabilities) {
+      void series.refresh();
+      return;
+    }
+    let cancelled = false;
+    void registry.invokeCapability<{ entries: SeriesCatalogEntry[] }>(SERIES_CATALOG_CAPABILITY_ID, "list", {})
+      .then((result) => {
+        if (!cancelled && Array.isArray(result?.entries)) setRemote(result.entries);
+      })
+      .catch(() => {
+        // The view's own series still list; only the Bun process's extras are missing.
+      });
+    return () => { cancelled = true; };
+  }, [registry, series]);
+
+  return useMemo(() => {
+    const local = series?.catalog() ?? EMPTY_ENTRIES;
+    let entries = local;
+    if (remote?.length) {
+      const known = new Set(local.map((entry) => entry.id));
+      const extra = remote.filter((entry) => !known.has(entry.id));
+      if (extra.length) entries = [...local, ...extra];
+    }
+    if (disabledPlugins.length === 0) return entries;
+    const disabled = new Set(disabledPlugins);
+    return entries.some((entry) => disabled.has(entry.pluginId))
+      ? entries.filter((entry) => !disabled.has(entry.pluginId))
+      : entries;
+  }, [disabledPlugins, remote, series, version]);
+}
+
 export function useCatalogUniverse(query: string): {
   instruments: SeriesCatalogInstrument[];
   loading: boolean;
@@ -193,6 +248,7 @@ export function useSeriesCatalogSuggestions({
   enabled: boolean;
 }): SeriesCatalogSearchResult {
   const tickers = useOptionalAppSelector((state) => state.tickers, EMPTY_TICKERS);
+  const registered = useRegisteredSeries();
   const analysis = useMemo(() => analyzeSeriesSearchQuery(query), [query]);
   const [providerSearch, setProviderSearch] = useState<{
     query: string;
@@ -298,11 +354,11 @@ export function useSeriesCatalogSuggestions({
   // and they arrive well before plugin catalogs (which can take seconds), so
   // late plugin results append below instead of pushing the list around.
   const suggestions = useMemo(() => {
-    const builtIn = buildSeriesCatalogSuggestions(query, defaultInstrument, instruments);
+    const builtIn = buildSeriesCatalogSuggestions(query, defaultInstrument, instruments, MAX_SERIES_SUGGESTIONS, registered);
     const provider = providerSearch.query === query.trim() ? providerSearch.suggestions : [];
     return [...builtIn, ...provider.filter((entry) => !builtIn.some((candidate) => candidate.id === entry.id))]
       .slice(0, MAX_SERIES_SUGGESTIONS);
-  }, [defaultInstrument, instruments, providerSearch, query]);
+  }, [defaultInstrument, instruments, providerSearch, query, registered]);
 
   return {
     suggestions,

package/src/plugins/builtin/chart-composer/user-series.ts

@@ -0,0 +1,84 @@
+import { getCurrentPluginTarget } from "../../current-target";
+import { getSharedRegistry } from "../../registry";
+import { listSeriesFiles, seriesFromFile } from "../../../series/files";
+import type { SeriesDefinition } from "../../../series/types";
+import type { GloomPluginContext } from "../../../types/plugin";
+import type { PluginModule } from "../plugin-module";
+
+interface RegisteredFile {
+  mtimeMs: number;
+  dispose: () => void;
+}
+
+/**
+ * Keeps the catalog in step with the profile's series folder: a file added,
+ * changed or removed shows up the next time the catalog opens.
+ */
+function watchUserSeriesFolder(ctx: GloomPluginContext): () => void {
+  const registered = new Map<string, RegisteredFile>();
+  let running: Promise<void> = Promise.resolve();
+
+  const sync = async () => {
+    const files = await listSeriesFiles(ctx.getConfig().dataDir);
+    const present = new Set(files.map((file) => file.name));
+    for (const [name, entry] of registered) {
+      if (present.has(name)) continue;
+      entry.dispose();
+      registered.delete(name);
+    }
+    for (const file of files) {
+      const existing = registered.get(file.name);
+      if (existing?.mtimeMs === file.mtimeMs) continue;
+      existing?.dispose();
+      registered.delete(file.name);
+      let definitions: SeriesDefinition[];
+      try {
+        definitions = seriesFromFile(file.name, await file.readText(), file.readText);
+      } catch (error) {
+        ctx.log.warn("Series file skipped", { file: file.name, error: error instanceof Error ? error.message : String(error) });
+        continue;
+      }
+      const disposers = definitions.flatMap((definition) => {
+        try {
+          return [ctx.registerSeries(definition)];
+        } catch (error) {
+          ctx.log.warn("Series skipped", { file: file.name, error: error instanceof Error ? error.message : String(error) });
+          return [];
+        }
+      });
+      registered.set(file.name, { mtimeMs: file.mtimeMs, dispose: () => { for (const dispose of disposers) dispose(); } });
+    }
+  };
+  const refresh = () => {
+    running = running.then(sync, sync);
+    return running;
+  };
+
+  void refresh();
+  const removeRefresher = getSharedRegistry()?.series.addRefresher(refresh);
+  return () => {
+    removeRefresher?.();
+    for (const entry of registered.values()) entry.dispose();
+    registered.clear();
+  };
+}
+
+let stopWatching: (() => void) | null = null;
+
+/**
+ * CSV files in `<data dir>/series/` as catalog series, chartable against
+ * anything else. Files are read where the app can reach the disk: the
+ * terminal, and the desktop's Bun process, which lists them for its view.
+ */
+export const userSeriesModule: PluginModule = {
+  setup(ctx) {
+    const target = getCurrentPluginTarget();
+    if (target !== "cli" && target !== "tui") return;
+    stopWatching?.();
+    stopWatching = watchUserSeriesFolder(ctx);
+  },
+  dispose() {
+    stopWatching?.();
+    stopWatching = null;
+  },
+};

package/src/plugins/builtin/chat/content/composer-runtime.ts

@@ -11,6 +11,8 @@ import type { ChatContentController } from "./types";
 import { getComposerCursorOffset, moveComposerCursorToOffset } from "./composer-cursor";
 import { insertedText, pastedImagePaths } from "../attachments/transfer";
 import { chatTextWithImages } from "../attachments/model";
+import { isManagedBot } from "../ghost-user";
+import { CHAT_AI_BADGE_WIDTH } from "../message/ai-badge";
 
 interface MutableRef<T> {
   current: T;
@@ -398,7 +400,10 @@ export function useChatComposerRuntime({
   const replyPreview = replyTo
     ? formatInlinePreview(
       chatTextWithImages(replyTo.content, replyTo.attachments?.length ?? 0),
-      Math.max(contentWidth - ` replying to @${replyTo.user.username}: `.length - COMPOSER_ACTION_WIDTH - 1, 0),
+      Math.max(
+        contentWidth - ` replying to @${replyTo.user.username}`.length - (isManagedBot(replyTo.user) ? CHAT_AI_BADGE_WIDTH + 1 : 2) - COMPOSER_ACTION_WIDTH - 1,
+        0,
+      ),
     )
     : "";
   const editingPreview = editingMessage