gloomberb 0.17.4 → 0.17.6

package/src/plugins/builtin/thirteenf/data.ts

@@ -58,6 +58,37 @@ async function loadReportsForFunds(
   return { reports, ...(failures.length ? { warning: failures.join(" ") } : {}) };
 }
 
+function copyReportFields(rows: FundBrowserRow[], nextRows: FundBrowserRow[]) {
+  const byId = new Map(nextRows.map((row) => [row.id, row]));
+  for (const row of rows) {
+    const next = byId.get(row.id);
+    if (!next) continue;
+    row.name = next.name;
+    row.periodOfReport = next.periodOfReport;
+    row.filedAsOfDate = next.filedAsOfDate;
+    row.tableValueTotal = next.tableValueTotal;
+    row.tableEntryTotal = next.tableEntryTotal;
+    if ("estQuarterReturn" in next) row.estQuarterReturn = next.estQuarterReturn;
+  }
+}
+
+function fillReports(
+  result: BrowserLoadResult,
+  rows: FundBrowserRow[],
+  pending: Promise<{ reports: Map<string, ThirteenFPeriodReport>; warning?: string }>,
+  rebuild: (reports: Map<string, ThirteenFPeriodReport>) => FundBrowserRow[],
+  signal?: AbortSignal,
+) {
+  result.reportsLoaded = pending.then(({ reports, warning }) => {
+    if (signal?.aborted) return;
+    copyReportFields(rows, rebuild(reports));
+    if (warning) result.warning = [result.warning, warning].filter(Boolean).join(" ");
+  }).catch((error: unknown) => {
+    if (signal?.aborted) return;
+    throw error;
+  });
+}
+
 export interface BrowserLoadResult {
   rows: FundBrowserRow[];
   period?: string;
@@ -65,6 +96,7 @@ export interface BrowserLoadResult {
   warning?: string;
   hasMore?: boolean;
   nextOffset?: number;
+  reportsLoaded?: Promise<void>;
 }
 
 export async function loadBrowserRows(
@@ -75,7 +107,8 @@ export async function loadBrowserRows(
 ): Promise<BrowserLoadResult> {
   const warnings: string[] = [];
   const result = await loadBrowserPage(tab, query, signal, { ...options, onWarning: warning => warnings.push(warning) });
-  return { ...result, warning: [...new Set([result.warning, ...warnings].filter(Boolean))].join(" ") || undefined };
+  if (warnings.length) result.warning = [...new Set([result.warning, ...warnings].filter(Boolean))].join(" ") || undefined;
+  return result;
 }
 
 async function loadBrowserPage(
@@ -106,34 +139,36 @@ async function loadBrowserPage(
       catch (error) { if (signal?.aborted) throw error; options.onWarning?.(`${previous}: performance ranking unavailable.`); return new Map<string, number | null>(); }
     }));
     const funds: ThirteenFFund[] = topFunds.map((fund) => ({ cik: fund.cik, name: fund.name }));
-    const { reports, warning } = await loadReportsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), {
-      from, to, signal, ...apiOptions,
-      periods: new Map(topFunds.map((fund) => [fund.cik, fund.periodOfReport])),
-    });
-    return {
-      rows: buildBrowserRows({ topFunds, reports, source: "performance" }).map(row => ({ ...row, priorReturns: quarters.map((previous, index) => ({ quarter: previous, value: history[index]?.get(row.cik) ?? null })) })),
-      warning,
+    const rows = buildBrowserRows({ topFunds, source: "performance" }).map(row => ({ ...row, priorReturns: quarters.map((previous, index) => ({ quarter: previous, value: history[index]?.get(row.cik) ?? null })) }));
+    const result: BrowserLoadResult = {
+      rows,
       quarter,
       period: topFunds[0]?.periodOfReport,
       hasMore: topFunds.length >= browserLimit,
       nextOffset: offset + topFunds.length,
     };
+    fillReports(result, rows, loadReportsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), {
+      from, to, signal, ...apiOptions,
+      periods: new Map(topFunds.map((fund) => [fund.cik, fund.periodOfReport])),
+    }), (reports) => buildBrowserRows({ topFunds, reports, source: "performance" }), signal);
+    return result;
   }
 
   if (tab === "latest") {
     const filings = await listThirteenFFilings(isoDateDaysAgo(21, now), to, latestLimit, signal, pageApiOptions);
     const selected = dedupeLatestForms(filings);
-    const { reports, warning } = await loadReportsForFunds(selected.map((form) => ({ cik: form.cik, name: form.companyName })), {
-      from, to, signal, ...apiOptions,
-      periods: new Map(selected.map((form) => [form.cik, form.periodOfReport])),
-    });
-    return {
-      rows: buildBrowserRows({ latestFilings: filings, reports, source: "latest" }),
-      warning,
+    const rows = buildBrowserRows({ latestFilings: filings, source: "latest" });
+    const result: BrowserLoadResult = {
+      rows,
       period: filings[0]?.periodOfReport,
       hasMore: filings.length >= latestLimit,
       nextOffset: offset + filings.length,
     };
+    fillReports(result, rows, loadReportsForFunds(selected.map((form) => ({ cik: form.cik, name: form.companyName })), {
+      from, to, signal, ...apiOptions,
+      periods: new Map(selected.map((form) => [form.cik, form.periodOfReport])),
+    }), (reports) => buildBrowserRows({ latestFilings: filings, reports, source: "latest" }), signal);
+    return result;
   }
 
   if (tab === "byTicker") {
@@ -155,18 +190,23 @@ async function loadBrowserPage(
     try {
       const holders = await lookupThirteenFHoldersByCusip(cusip, periodOfReport, signal, apiOptions);
       const pageCiks = holders.ciks.slice(offset, offset + browserLimit);
-      const { reports, warning } = await loadReportsForFunds(pageCiks.map((cik) => ({ cik, name: cik })), {
-        from, to, signal, ...apiOptions,
-        periods: new Map(pageCiks.map((cik) => [cik, holders.periodOfReport])),
-      });
-      const funds = pageCiks.map((cik) => ({ cik, name: reports.get(cik)?.filings.at(-1)?.companyName || cik }));
-      return {
-        rows: buildBrowserRows({ funds, reports, source: "ticker" }),
-        warning,
+      const funds = pageCiks.map((cik) => ({ cik, name: cik }));
+      const rows = buildBrowserRows({ funds, source: "ticker" });
+      const result: BrowserLoadResult = {
+        rows,
         period: holders.periodOfReport,
         hasMore: holders.ciks.length > offset + pageCiks.length,
         nextOffset: offset + pageCiks.length,
       };
+      fillReports(result, rows, loadReportsForFunds(funds, {
+        from, to, signal, ...apiOptions,
+        periods: new Map(pageCiks.map((cik) => [cik, holders.periodOfReport])),
+      }), (reports) => buildBrowserRows({
+        funds: pageCiks.map((cik) => ({ cik, name: reports.get(cik)?.filings.at(-1)?.companyName || cik })),
+        reports,
+        source: "ticker",
+      }), signal);
+      return result;
     } catch (error) {
       return {
         rows: [],
@@ -195,26 +235,27 @@ async function loadBrowserPage(
   }
   const found = await searchThirteenFFunds(trimmed, browserLimit, signal, pageApiOptions);
   const funds = oneFundPerCik(found);
-  const [{ reports, warning }, topFunds] = await Promise.all([
-    loadReportsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, ...apiOptions }),
-    listTopThirteenFFunds(quarter, browserLimit, signal, apiOptions).catch(() => []),
-  ]);
+  const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, apiOptions).catch((): ThirteenFTopFund[] => []);
   const topByCik = new Map(topFunds.map((fund) => [fund.cik, fund]));
   const matchedTopFunds = funds
     .map((fund) => topByCik.get(fund.cik))
     .filter((fund): fund is ThirteenFTopFund => !!fund);
-  return {
-    rows: buildBrowserRows({
-      funds: oneFundPerCik(found, reports),
-      topFunds: matchedTopFunds,
-      reports,
-      source: "funds",
-    }),
+  const rows = buildBrowserRows({ funds: oneFundPerCik(found), topFunds: matchedTopFunds, source: "funds" });
+  const result: BrowserLoadResult = {
+    rows,
     quarter,
-    warning,
     hasMore: found.length >= browserLimit,
     nextOffset: offset + found.length,
   };
+  fillReports(result, rows, loadReportsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), {
+    from, to, signal, ...apiOptions,
+  }), (reports) => buildBrowserRows({
+    funds: oneFundPerCik(found, reports),
+    topFunds: matchedTopFunds,
+    reports,
+    source: "funds",
+  }), signal);
+  return result;
 }
 
 export async function loadFundDetail(

package/src/plugins/builtin/thirteenf/headless.ts

@@ -257,6 +257,7 @@ async function findThirteenFFund(
   if (isCikQuery(query)) return { cik: normalizeCik(query), name: query };
   // A small output limit must not hide other matching managers during lookup.
   const result = await search(query, 25);
+  await result.reportsLoaded;
   const candidates = [...new Map(result.rows.map((row) => [row.cik, row])).values()];
   const exact = candidates.filter((row) => row.name.toLocaleLowerCase() === query.toLocaleLowerCase());
   if (exactOnly) return exact.length === 1 ? { cik: exact[0]!.cik, name: exact[0]!.name } : null;
@@ -603,6 +604,7 @@ export function createThirteenFHeadless(
 
       const tab = browserTab(view === "ticker-holdings" ? requestedView : view, query);
       const result = await dependencies.loadBrowser(tab, query, limit, args, ctx);
+      await result.reportsLoaded;
       const more = result.hasMore || result.rows.length > limit;
       const browserRows = sortBrowserRows(result.rows, browserSortFor(DEFAULT_BROWSER_SORT, tab)).slice(0, limit);
       // A search finds managers that stopped filing; say which, since the Period column alone reads like any other.

package/src/plugins/builtin/thirteenf/pane.tsx

@@ -113,13 +113,21 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
   // A new query starts from an empty list; a refresh keeps the rows it has.
   const browser = usePagedRows(showTickerHoldings ? null : loadPage, { getId: rowId });
   const { loading, loadingMore, rows } = browser;
+  const [reportPaint, setReportPaint] = useState(0);
+  useEffect(() => {
+    let alive = true;
+    void Promise.all(browser.pages.map((page) => page.reportsLoaded ?? Promise.resolve())).then(() => {
+      if (alive) setReportPaint((value) => value + 1);
+    }, () => {});
+    return () => { alive = false; };
+  }, [browser.pages]);
   const error = browser.error?.message ?? null;
   // A refresh clears the pages' warnings until it answers.
   const pagesSettled = !loading && !browser.error;
   const warning = useMemo(() => {
     const notes = [...(pagesSettled ? browser.pages.map((page) => page.warning) : []), browser.moreError?.message];
     return [...new Set(notes.filter(Boolean))].join(" ") || null;
-  }, [browser.moreError, browser.pages, pagesSettled]);
+  }, [browser.moreError, browser.pages, pagesSettled, reportPaint]);
   const [detailSeed, setDetailSeed] = useState<FundSeed | null>(() => (
     initialCik ? { cik: String(initialCik), name: normalizedQuery || String(initialCik) } : null
   ));
@@ -157,7 +165,7 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
   }, { allowEditable: true });
 
   const browserSort = useMemo(() => browserSortFor(sortPreference, browserMode), [sortPreference, browserMode]);
-  const sortedRows = useMemo(() => sortBrowserRows(rows, browserSort), [rows, browserSort]);
+  const sortedRows = useMemo(() => sortBrowserRows(rows, browserSort), [rows, browserSort, reportPaint]);
   const columns = useMemo(() => {
     if (browserMode !== "performance") return buildBrowserColumns(false);
     const history = rows[0]?.priorReturns ?? [];

package/src/plugins/builtin/ticker-detail/data-panes/historical-prices.tsx

@@ -10,6 +10,7 @@ import {
   type DataTableCell,
   type DataTableColumn,
   type DataTableKeyEvent,
+  type PaneFooterSegment,
 } from "../../../../components";
 import { TIME_RANGES, type TimeRange } from "../../../../time-series/range";
 import type { PaneProps } from "../../../../types/plugin";
@@ -29,6 +30,18 @@ import {
 import { usePaneTicker } from "../../../../state/app/context";
 import { handleRefreshKey, useClampSelectedIndex } from "../../../../components/data-table/table-pane";
 import { useBoundTicker, useTickerRequest } from "../../shared/ticker-request";
+import { DAY_SO_FAR_TEXT, withSessionBar } from "../../../../time-series/session-bar";
+import {
+  formingHistoryBar,
+  formingHistoryBarText,
+  HISTORY_DEFAULT_RANGE,
+  historyBarDate,
+  historyBarSize,
+  historyBarSizeText,
+  historyBarSizeWord,
+  historyDateHeader,
+  type HistoryBarSize,
+} from "./history-bars";
 
 type HistoryColumnId = "date" | "open" | "high" | "low" | "close" | "change" | "changePercent" | "volume";
 type HistoryColumn = DataTableColumn & { id: HistoryColumnId };
@@ -36,7 +49,14 @@ type HistoryColumn = DataTableColumn & { id: HistoryColumnId };
 export type HistoricalPriceRow = {
   key: string;
   point: ReturnType<typeof pricePointValues>;
+  /** The bar's date as the table reads it: `2026-10 MTD` for a month still running, `2026-10-16 DTD` for today's session. */
   date: string;
+  /** What a CSV export writes for the date: the bar's own date, whatever the table says of its period. */
+  exportDate: string;
+  /** The bar carries a time of day, so the table dates it with one. */
+  timed: boolean;
+  /** The bar's period had not ended: a week or month still running, or the day's session still trading. */
+  partial: boolean;
   change: number | null;
   changePercent: number | null;
 };
@@ -90,25 +110,49 @@ function formatMaybeCompact(value: number | null | undefined): string {
   return value == null ? "-" : formatCompact(value);
 }
 
-function buildHistoricalPriceRows(points: PricePoint[]): HistoricalPriceRow[] {
+interface HistoricalPriceTable {
+  /** Newest first. */
+  rows: HistoricalPriceRow[];
+  size: HistoryBarSize;
+  /** The newest bar's week or month had not ended, and how far into it the bar runs. */
+  forming: ReturnType<typeof formingHistoryBar>;
+  /** The newest bar is a day whose session is still trading. */
+  dayToDate: boolean;
+  /** The newest bar's day, `YYYY-MM-DD`. */
+  newestDate: string | undefined;
+}
+
+function buildHistoricalPriceRows(points: PricePoint[], venue: string | undefined, now: number): HistoricalPriceTable {
   const sorted = points
     .flatMap((point, sourceIndex) => {
       const date = pricePointDate(point);
-      return date ? [{ point: pricePointValues(point), date, sourceIndex }] : [];
+      return date ? [{ point: pricePointValues(point), date, sourceIndex, partial: point.partial === true }] : [];
     })
     .sort((left, right) => left.date.getTime() - right.date.getTime());
-  return sorted.map((entry, index) => {
+  const size = historyBarSize(sorted.map((entry) => entry.date.getTime()));
+  const newestDate = sorted.at(-1)?.date.toISOString().slice(0, 10);
+  const forming = formingHistoryBar(size, newestDate, venue, now);
+  const dayToDate = size === "1d" && sorted.at(-1)?.partial === true;
+  const rows = sorted.map((entry, index) => {
     const previous = sorted[index - 1]?.point;
     const { point, date, sourceIndex } = entry;
+    const newest = index === sorted.length - 1;
+    const partial = newest && (!!forming || dayToDate);
     const change = previous?.close != null && point.close != null ? point.close - previous.close : null;
+    const shown = formatDateTime(date);
+    const timed = shown.length > 10;
     return {
       key: `${date.toISOString()}:${sourceIndex}`,
       point,
-      date: formatDateTime(date),
+      date: timed ? shown : historyBarDate(shown, size, partial),
+      exportDate: shown,
+      timed,
+      partial,
       change,
       changePercent: previous?.close && change !== null ? change / previous.close : null,
     };
   }).reverse();
+  return { rows, size, forming, dayToDate, newestDate };
 }
 
 const HISTORY_PRICE_WIDTH = 10;
@@ -123,8 +167,9 @@ const HISTORY_NUMERIC_IDS = ["open", "high", "low", "close", "change", "changePe
  * evenly, and give up cells down to a floor when it is narrow, so the volume
  * stays on screen.
  */
-function buildHistoryColumns(width: number, intraday: boolean): HistoryColumn[] {
-  const dateWidth = intraday ? 16 : 10;
+function buildHistoryColumns(width: number, intraday: boolean, size: HistoryBarSize, newestDate: string): HistoryColumn[] {
+  // A month reads as `2026-10`; the newest bar, when its week or month runs on, adds `MTD` or `WTD`.
+  const dateWidth = Math.max(intraday ? 16 : size === "1mo" ? 7 : 10, newestDate.length);
   const numeric: number[] = HISTORY_NUMERIC_IDS.map((id) => id === "changePercent" ? HISTORY_PERCENT_WIDTH : HISTORY_PRICE_WIDTH);
   // One gap per column plus the table's inset on both sides.
   const available = width - dateWidth - HISTORY_VOLUME_WIDTH - 8 - 2;
@@ -141,7 +186,7 @@ function buildHistoryColumns(width: number, intraday: boolean): HistoryColumn[]
   }
   const [open, high, low, close, change, changePercent] = numeric as [number, number, number, number, number, number];
   return [
-    { id: "date", label: intraday ? "DATE/TIME" : "DATE", width: dateWidth, align: "left" },
+    { id: "date", label: intraday ? "DATE/TIME" : historyDateHeader(size)?.toUpperCase() ?? "DATE", width: dateWidth, align: "left" },
     { id: "open", label: "OPEN", width: open, align: "right", flexGrow: 1 },
     { id: "high", label: "HIGH", width: high, align: "right", flexGrow: 1 },
     { id: "low", label: "LOW", width: low, align: "right", flexGrow: 1 },
@@ -162,7 +207,7 @@ function nextHistoryRange(current: TimeRange): TimeRange {
 export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
   const dataProvider = useAssetData();
   const { symbol, exchange, ticker } = useBoundTicker();
-  const [range, setRange] = usePluginPaneState<TimeRange>("range", "ALL");
+  const [range, setRange] = usePluginPaneState<TimeRange>("range", HISTORY_DEFAULT_RANGE);
   const [selectedIdx, setSelectedIdx] = useDebouncedPluginPaneState<number>("selectedIdx", 0);
   const loader = useCallback((nextSymbol: string, nextExchange: string, forceRefresh: boolean) => {
     if (!dataProvider) throw new Error("Market data unavailable");
@@ -174,14 +219,27 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
     );
   }, [dataProvider, range]);
   const { data, loading, error, reload } = useTickerRequest<PricePoint[]>(loader, symbol, exchange);
-  const rows = useMemo(() => buildHistoricalPriceRows(data ?? []), [data]);
-  const integrityNotice = priceHistoryIntegrityNotice(rows.filter((row) => row.point.integrity).length);
-  // Daily and longer bars are dates; only intraday bars carry a time.
-  const intraday = rows.length > 0 ? rows.some((row) => row.date.length > 10) : range === "1D" || range === "1W";
-  const columns = useMemo(() => buildHistoryColumns(width, intraday), [intraday, width]);
   // The quote knows the instrument type even when the saved ticker does not;
-  // resolve it the way every quote display does.
+  // resolve it the way every quote display does. It also names the venue
+  // whose sessions say whether a week or month is still running.
   const { financials } = usePaneTicker();
+  const venue = exchange || financials?.quote?.listingExchangeName || financials?.quote?.exchangeName || undefined;
+  // While the session trades the day's bar is the quote's: the history keeps a
+  // snapshot of it from whenever it was last fetched (withSessionBar).
+  const quote = financials?.quote;
+  const points = useMemo(
+    () => withSessionBar(data ?? [], quote, { now: Date.now(), venue }),
+    [data, quote, venue],
+  );
+  const { rows, size, forming, dayToDate, newestDate } = useMemo(
+    () => buildHistoricalPriceRows(points, venue, Date.now()),
+    [points, venue],
+  );
+  const integrityNotice = priceHistoryIntegrityNotice(rows.filter((row) => row.point.integrity).length);
+  // Daily and longer bars are dates; only intraday bars carry a time.
+  const intraday = rows.length > 0 ? rows.some((row) => row.timed) : range === "1D" || range === "1W";
+  const newestRowDate = rows[0]?.date ?? "";
+  const columns = useMemo(() => buildHistoryColumns(width, intraday, size, newestRowDate), [intraday, newestRowDate, size, width]);
   const assetCategory = quoteFormatOptions(
     financials?.quote,
     ticker?.metadata.assetCategory,
@@ -217,7 +275,7 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
   ): DataTableCell => {
     switch (column.id) {
       case "date":
-        return { text: row.date, color: colors.textDim };
+        return { text: row.date, value: row.exportDate, color: colors.textDim };
       case "open":
       case "high":
       case "low":
@@ -236,8 +294,15 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
     }
   }, [priceDecimals]);
 
-  // The range is picked in the query bar; t still steps through it.
-  usePaneStatusFooter({ registrationId: "historical-prices", loading, error });
+  // The range is picked in the query bar; t still steps through it. The range
+  // sets the bar size, which the footer says, and a week or month still
+  // running says how far the newest bar goes.
+  const barInfo = useMemo<PaneFooterSegment[]>(() => [
+    ...rows.length > 0 ? [{ id: "bars", parts: [{ text: historyBarSizeText(size), tone: "muted" as const }] }] : [],
+    ...forming && newestDate ? [{ id: "forming", parts: [{ text: formingHistoryBarText(forming, newestDate), tone: "muted" as const }] }] : [],
+    ...dayToDate ? [{ id: "forming", parts: [{ text: DAY_SO_FAR_TEXT, tone: "muted" as const }] }] : [],
+  ], [dayToDate, forming, newestDate, rows.length, size]);
+  usePaneStatusFooter({ registrationId: "historical-prices", loading, error, info: barInfo });
 
   usePaneNoticeFooter({
     registrationId: "historical-prices:integrity",
@@ -280,7 +345,10 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
       getExportMetadata={() => [
         ["Ticker", symbol ? publicTickerKey(symbol, exchange) : ""],
         ["Requested range", range],
+        ...(rows.length > 0 ? [["Bar size", historyBarSizeWord(size)]] : []),
         ["Time zone", "UTC"],
+        ...(forming && newestDate ? [["Partial bar", `${newestDate}, ${formingHistoryBarText(forming, newestDate)}`]] : []),
+        ...(dayToDate && newestDate ? [["Partial bar", `${newestDate}, ${DAY_SO_FAR_TEXT}`]] : []),
         ["Price units", "As served in the history; currency and price-basis metadata are unavailable"],
         ["Status", error ? (rows.length ? "Retained after refresh failure" : "Unavailable")
           : loading ? (rows.length ? "Refreshing" : "Loading") : rows.length ? "Available" : "Empty"],

package/src/plugins/builtin/ticker-detail/data-panes/history-bars.ts

@@ -0,0 +1,92 @@
+import { BAR_INTERVAL_LABELS } from "../../../../cli/history-rows";
+import { periodToDateText } from "../../../../cli/pane-functions/freshness";
+import { barPeriodToDate, type BarPeriod, type BarPeriodToDate } from "../../../../market-data/market/bar-period";
+import { barSizeFromGap, medianBarGap } from "../../../../time-series/bar-spacing";
+import type { TimeRange } from "../../../../time-series/range";
+import { CHART_RESOLUTION_STEP_MS, type ManualChartResolution } from "../../../../time-series/resolution";
+
+/**
+ * The range a price history opens on, in Historical Prices, `fn HP` and
+ * `shot HP`: a recent window in daily bars (RANGE_HISTORY_RESOLUTION serves
+ * 1M to 1Y daily). 5Y is weekly and ALL monthly, so neither is a place to start.
+ */
+export const HISTORY_DEFAULT_RANGE: TimeRange = "3M";
+
+/** The size of one bar of a price history; `intraday` when its minutes are not a size the source serves. */
+export type HistoryBarSize = ManualChartResolution | "intraday";
+
+const INTRADAY_SIZES: readonly ManualChartResolution[] = ["1m", "5m", "15m", "30m", "45m", "1h"];
+/** A day's bars can sit a little under a day apart where the clocks change. */
+const INTRADAY_BELOW_MS = 0.8 * CHART_RESOLUTION_STEP_MS["1d"];
+
+/**
+ * The bar size of a history, read from the usual spacing of its bars
+ * (medianBarGap), as `history` reads it, so the gap a holiday leaves does not
+ * make daily bars weekly. Daily when there is no gap to read.
+ */
+export function historyBarSize(times: readonly number[]): HistoryBarSize {
+  const gap = medianBarGap(times);
+  if (gap == null) return "1d";
+  if (gap < INTRADAY_BELOW_MS) return INTRADAY_SIZES.find((size) => CHART_RESOLUTION_STEP_MS[size] === gap) ?? "intraday";
+  return barSizeFromGap(gap);
+}
+
+/** Whether a bar of this size covers a day or more, so its date is a day and not a time. */
+export function isDailyOrLongerBar(size: HistoryBarSize): size is "1d" | "1wk" | "1mo" {
+  return size === "1d" || size === "1wk" || size === "1mo";
+}
+
+/** `daily`, `5-minute`, `hourly`, `weekly`, `monthly`; `intraday` when the minutes are not a known size. */
+export function historyBarSizeWord(size: HistoryBarSize): string {
+  return size === "intraday" ? size : BAR_INTERVAL_LABELS[size];
+}
+
+/** `daily bars`, `monthly bars`: what a history says its bars are, which the range it was asked for sets. */
+export function historyBarSizeText(size: HistoryBarSize): string {
+  return `${historyBarSizeWord(size)} bars`;
+}
+
+/**
+ * What a date column heads when its bars cover more than a day: `Week of`
+ * (each is dated by the day its week starts) or `Month`. Null for a day's bar,
+ * whose column is `Date`, or an intraday one, which is dated with a time.
+ */
+export function historyDateHeader(size: HistoryBarSize): string | null {
+  return size === "1wk" ? "Week of" : size === "1mo" ? "Month" : null;
+}
+
+/** The calendar period a weekly or monthly bar covers; null for any other. */
+function historyBarPeriod(size: HistoryBarSize): BarPeriod | null {
+  return size === "1mo" ? "month" : size === "1wk" ? "week" : null;
+}
+
+/**
+ * Whether the newest bar, dated `date`, is a week or month that had not ended
+ * at `now` on its `venue` (barPeriodToDate), and how far into it the bar runs.
+ * Null for a complete bar, and for any bar that is not weekly or monthly.
+ */
+export function formingHistoryBar(
+  size: HistoryBarSize,
+  date: string | undefined,
+  venue: string | undefined,
+  now: number,
+): BarPeriodToDate | null {
+  const period = historyBarPeriod(size);
+  return period && date ? barPeriodToDate(date, period, venue, now) : null;
+}
+
+/**
+ * A bar's day as its table dates it: a month's bar as the month (`2026-10`),
+ * a week's by the day it starts, and `MTD`, `WTD` or `DTD` after one whose
+ * period had not ended, so it never reads as a complete bar dated on its
+ * first day. `day` is `YYYY-MM-DD`.
+ */
+export function historyBarDate(day: string, size: HistoryBarSize, partial = false): string {
+  const text = size === "1mo" ? day.slice(0, 7) : day;
+  return partial ? `${text} ${size === "1mo" ? "MTD" : size === "1wk" ? "WTD" : "DTD"}` : text;
+}
+
+/** What the newest bar covers so far: `month to date, through Fri 16 Oct 2026`. */
+export function formingHistoryBarText(forming: BarPeriodToDate, date: string): string {
+  return periodToDateText({ period: forming.period, ...(forming.through ? { through: forming.through } : {}) }, date);
+}

package/src/plugins/builtin/ticker-detail/data-panes/returns-pane.tsx

@@ -42,6 +42,7 @@ import {
   type ReturnRow,
 } from "./returns-model";
 import { loadReturnSeries, type ReturnSeries } from "./returns-history";
+import { formingHistoryBar, formingHistoryBarText, historyBarDate } from "./history-bars";
 
 type ReturnColumnId = "time" | "price" | "intervalChange" | "intervalPercent" | "cumulativeChange" | "cumulativePercent";
 type ReturnColumn = DataTableColumn & { id: ReturnColumnId };
@@ -185,12 +186,21 @@ export function ReturnsPane({ focused, width, height }: PaneProps) {
   const hints = useMemo<PaneHint[]>(() => (
     table.searchable ? [{ id: "search", key: "/", label: "search", onPress: focusSearch }] : []
   ), [focusSearch, table.searchable]);
+  // A weekly or monthly interval's newest bar is its week or month so far when that has not ended.
+  const newestDate = returnRows[0] ? new Date(returnRows[0].timestamp).toISOString().slice(0, 10) : undefined;
+  const forming = useMemo(
+    () => data ? formingHistoryBar(data.resolution, newestDate, data.venue || undefined, Date.now()) : null,
+    [data, newestDate],
+  );
+  const formingKey = forming ? returnRows[0]?.key : undefined;
+  const barSize = data?.resolution ?? shownResolution;
   // A shut market's window ends at its last session, which the footer names.
-  const marketInfo = useMemo<PaneFooterSegment[]>(() => (
-    data?.lastSession
-      ? [{ id: "market", parts: [{ text: closedMarketNote(data.lastSession, data.visibleTo), tone: "muted" }] }]
-      : []
-  ), [data]);
+  const marketInfo = useMemo<PaneFooterSegment[]>(() => [
+    ...data?.lastSession
+      ? [{ id: "market", parts: [{ text: closedMarketNote(data.lastSession, data.visibleTo), tone: "muted" as const }] }]
+      : [],
+    ...forming && newestDate ? [{ id: "forming", parts: [{ text: formingHistoryBarText(forming, newestDate), tone: "muted" as const }] }] : [],
+  ], [data, forming, newestDate]);
   usePaneStatusFooter({ registrationId: "returns", loading, error, hints, info: marketInfo });
 
   const integrityNotice = priceHistoryIntegrityNotice(returnRows.filter((row) => row.inconsistent).length);
@@ -208,8 +218,15 @@ export function ReturnsPane({ focused, width, height }: PaneProps) {
 
   const renderCell = useCallback((row: ReturnRow, column: ReturnColumn): DataTableCell => {
     switch (column.id) {
-      case "time":
-        return { text: formatDateTime(new Date(row.timestamp)), value: new Date(row.timestamp).toISOString(), color: colors.textDim };
+      case "time": {
+        const shown = formatDateTime(new Date(row.timestamp));
+        // A daily or longer bar is a date; a month's reads as the month, and one still running says so.
+        return {
+          text: shown.length > 10 ? shown : historyBarDate(shown, barSize, row.key === formingKey),
+          value: new Date(row.timestamp).toISOString(),
+          color: colors.textDim,
+        };
+      }
       case "price":
         return { text: formatMaybePrice(row.price, priceDecimals, column.width), value: exportPrice(row.price, priceDecimals), color: colors.textBright, attributes: TextAttributes.BOLD };
       case "intervalChange":
@@ -221,7 +238,7 @@ export function ReturnsPane({ focused, width, height }: PaneProps) {
       case "cumulativePercent":
         return { text: formatMaybePercent(row.cumulativePercent), value: row.cumulativePercent === null ? null : row.cumulativePercent * 100, color: priceColor(row.cumulativePercent ?? 0) };
     }
-  }, [priceDecimals]);
+  }, [barSize, formingKey, priceDecimals]);
 
   return (
     <DataTableView<ReturnRow, ReturnColumn>
@@ -270,6 +287,7 @@ export function ReturnsPane({ focused, width, height }: PaneProps) {
         ["Ticker", symbol ? publicTickerKey(symbol, exchange) : ""],
         ["Range", data?.range ?? range],
         ["Interval", getChartResolutionLabel(data?.resolution ?? shownResolution)],
+        ...(forming && newestDate ? [["Partial bar", `${newestDate}, ${formingHistoryBarText(forming, newestDate)}`]] : []),
         ["Window", data ? `after ${new Date(data.visibleFrom).toISOString()} through ${new Date(data.visibleTo).toISOString()}` : ""],
         ...(data?.lastSession ? [["Market", closedMarketNote(data.lastSession, data.visibleTo)]] : []),
         ["Time zone", "UTC, bar open"],

package/src/plugins/builtin/ticker-detail/headless-schema.ts

@@ -1,5 +1,7 @@
 import type { HeadlessPaneDefinition } from "../../../types/headless";
 import { FINANCIAL_PERIOD_OPTION, HISTORY_RANGE_VALUES } from "../shared/headless-options";
+import { historyIntervalsByRange } from "../../../cli/history-rows";
+import { HISTORY_DEFAULT_RANGE } from "./data-panes/history-bars";
 import { RETURN_INTERVAL_VALUES, RETURN_RANGES } from "./data-panes/returns-model";
 
 type PaneSchema = Pick<HeadlessPaneDefinition, "argument" | "options" | "discovery">;
@@ -51,11 +53,11 @@ export const paneSchemas = {
     options: [
       {
         key: "range",
-        description: "Price-history window.",
+        description: `Price-history window, which also sets the bar size: ${historyIntervalsByRange()}.`,
         type: "enum",
         aliases: ["rangePreset"],
         values: HISTORY_RANGE_VALUES,
-        defaultValue: "ALL",
+        defaultValue: HISTORY_DEFAULT_RANGE,
         pluginState: { pluginId: "ticker-research" },
       },
     ],