gloomberb 0.17.5 → 0.18.0

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

@@ -19,10 +19,10 @@ import { isDetailBackNavigationKey } from "../../../utils/back-navigation";
 import { isPlainKey } from "../../../utils/keyboard";
 import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { nextHeaderSort } from "../../../utils/sort-values";
-import { usePluginPaneState, usePluginTickerActions } from "../../runtime";
+import { useAssetData, usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { useMineTickers } from "../shared/mine-tickers";
 import { usePaneStatusFooter, usePaneStatusLinkFooter } from "../../../components/layout/pane/status-footer";
-import { loadBrowserRows, loadFilingPositions, loadFundDetail } from "./data";
+import { corporateSplitFactor, loadBrowserRows, loadFilingPositions, loadFundDetail, loadSplitFactors } from "./data";
 import { FundOverlapView } from "./overlap-pane";
 import { ThirteenFCrowdingPane, ThirteenFTickerHoldingsView } from "./signals-pane";
 import { PaneFooterScope } from "../../../components/layout/pane/footer";
@@ -53,7 +53,7 @@ import {
   sortHoldingRows,
   sortTimelineRows,
 } from "./model";
-import { isOptionType, isStaleFiling, quartersOldText } from "./report-notes";
+import { filingGapText, holdingUnreadNotes, isOptionType, isStaleFiling, quartersOldText } from "./report-notes";
 import {
   renderBrowserCell,
   renderFilingPositionCell,
@@ -345,9 +345,14 @@ export function FundDetailView({
   const [openFilingId, setOpenFilingId] = usePluginPaneState<string | null>("openFilingId", null);
   const [filingReturnTab, setFilingReturnTab] = useState<ThirteenFDetailTab | null>(null);
   const [data, setData] = useState<FundDetailData | null>(null);
+  // The split factors of the lines that moved as across a split; null until their corporate actions answer.
+  const [splitFactors, setSplitFactors] = useState<ReadonlyMap<string, number | null> | null>(null);
   const [status, setStatus] = useState<LoadStatus>("loading");
   const [error, setError] = useState<string | null>(null);
   const abortRef = useRef<AbortController | null>(null);
+  const marketData = useAssetData();
+  const marketDataRef = useRef(marketData);
+  marketDataRef.current = marketData;
   // In the Research pane's 13F tab, h/l move between these sections while the
   // fund is open, as they do in the 13F pane.
   useClaimResearchTabKeys(focused);
@@ -362,7 +367,16 @@ export function FundDetailView({
       .then((nextData) => {
         if (abortRef.current !== controller) return;
         setData(nextData);
+        setSplitFactors(null);
         setStatus("loaded");
+        // The table is up already: a line that moved as across a split has no Est P&L until its corporate actions say whether one happened.
+        const provider = marketDataRef.current;
+        void (provider
+          ? loadSplitFactors(nextData, (ticker, after, through) => corporateSplitFactor(provider, ticker, after, through), controller.signal)
+          : Promise.resolve(new Map<string, number | null>())
+        ).then((factors) => {
+          if (abortRef.current === controller) setSplitFactors(factors);
+        }, () => {});
       })
       .catch((loadError) => {
         if (abortRef.current !== controller) return;
@@ -380,7 +394,7 @@ export function FundDetailView({
     };
   }, [load]);
 
-  const holdingRows = useMemo(() => buildFundHoldingRows(data), [data]);
+  const holdingRows = useMemo(() => buildFundHoldingRows(data, splitFactors ?? undefined), [data, splitFactors]);
   const visibleHoldingRows = useMemo(() => (
     sortHoldingRows(holdingRows.filter(row => !mineOnly || mine.has(row.ticker)).map(row => ({ ...row, mine: mine.has(row.ticker) })), holdingSort)
   ), [holdingRows, holdingSort, mineOnly, mine]);
@@ -507,9 +521,14 @@ export function FundDetailView({
       : []),
   ];
 
+  // A 13F-NT, or no 13F, for the newest quarter past its deadline; a stale filing's age is in the stats already.
+  const filingGap = data?.filingGap && (data.filingGap.filing || !staleFiling) ? filingGapText(data.filingGap, { command: false }) : null;
+  // Lines left without an Est P&L because their split could not be confirmed, said once their corporate actions have answered; a confirmed split is method, not a warning.
+  const splitNotices = useMemo(() => (activeTab === "holdings" && splitFactors ? holdingUnreadNotes(visibleHoldingRows) : []), [activeTab, splitFactors, visibleHoldingRows]);
+  const holdingNotices = useMemo(() => [...(filingGap ? [filingGap] : []), ...splitNotices, ...(data?.warnings ?? [])], [filingGap, splitNotices, data?.warnings]);
   usePaneNoticeFooter({
     registrationId: "thirteenf-holdings-notices",
-    notices: data?.warnings ?? [],
+    notices: holdingNotices,
     focused,
     enabled: !openFiling && activeTab !== "overlap",
   });

package/src/plugins/builtin/thirteenf/report-notes.ts

@@ -1,5 +1,7 @@
 import type { CrowdingRow, TickerHolderRow } from "./signals";
 import { formatMoneyCompact } from "./format";
+import { formatSplitRatio } from "./model";
+import type { ThirteenFFilingGap, ThirteenFOtherManager } from "./types";
 
 /**
  * Summary lines for the 13F text reports. Each says which quarters the rows
@@ -121,6 +123,82 @@ export function staleFundsText(funds: readonly { name: string; quarters: number
   return `Latest filing 2+ quarters old: ${named}${funds.length > shown ? ` and ${count(funds.length - shown)} more` : ""}`;
 }
 
+interface SplitLine {
+  ticker: string;
+  issuer: string;
+}
+
+const lineName = (line: SplitLine) => line.ticker || line.issuer;
+
+/** The first few lines as `text` gives them, then a count of the rest. */
+function listedLines<T>(lines: readonly T[], text: (line: T) => string, shown = 5): string {
+  return `${lines.slice(0, shown).map(text).join(", ")}${lines.length > shown ? ` and ${count(lines.length - shown)} more` : ""}`;
+}
+
+/** "Split-adjusted: NVDA 10:1, Odd Co 1:10 (split between the filings, as the corporate actions show)": lines priced on split-adjusted shares. */
+export function splitAdjustedText(lines: readonly (SplitLine & { ratio: number })[], prefix = "Split-adjusted"): string {
+  return `${prefix}: ${listedLines(lines, (line) => `${lineName(line)} ${formatSplitRatio(line.ratio)}`)} (split between the filings, as the corporate actions show)`;
+}
+
+/** "No Est P&L: XYZ (shares and value per share moved as across a split, and the corporate actions could not be read to tell)": lines left without a figure, `leftOut` opening it. */
+export function splitUnreadText(lines: readonly SplitLine[], leftOut: string): string {
+  return `${leftOut}: ${listedLines(lines, lineName)} (shares and value per share moved as across a split, and the corporate actions could not be read to tell)`;
+}
+
+/** The note for the lines of a Holdings table left without an Est P&L because their split could not be confirmed: a data limitation, the pane's notice as well as the report's. */
+export function holdingUnreadNotes(rows: readonly (SplitLine & { splitUnread?: boolean })[]): string[] {
+  const unread = rows.filter((row) => row.splitUnread);
+  return unread.length ? [splitUnreadText(unread, "No Est P&L")] : [];
+}
+
+/** What a Holdings report says of its lines that moved as across a split: the ones priced split-adjusted (method, so a report's note only), and the ones left without a figure. */
+export function holdingSplitNotes(rows: readonly (SplitLine & { splitRatio?: number; splitUnread?: boolean })[]): string[] {
+  const adjusted = rows.flatMap((row) => row.splitRatio ? [{ ...row, ratio: row.splitRatio }] : []);
+  return [...(adjusted.length ? [splitAdjustedText(adjusted, "Est P&L split-adjusted")] : []), ...holdingUnreadNotes(rows)];
+}
+
+/** "Q2 2026" for the quarter ending 30 Jun 2026. */
+function quarterText(period: string): string {
+  const day = calendarDay(period);
+  return day ? `Q${Math.floor(day.getUTCMonth() / 3) + 1} ${day.getUTCFullYear()}` : period;
+}
+
+/** The fund to open for a manager: its CIK, else its quoted name. */
+function openCommand(manager: ThirteenFOtherManager): string {
+  return manager.cik ? `fn 13F ${manager.cik}` : `fn 13F "${manager.name}"`;
+}
+
+/**
+ * What a fund filed for the newest quarter past its deadline instead of a
+ * holdings report: "13F-NT for Q2 2026, filed 14 Aug; holdings reported by
+ * PERSHING SQUARE INC. | open: fn 13F 0002026053", or "No 13F for Q2 2026,
+ * due 14 Aug" once EDGAR shows nothing. `command: false` names the CIK instead
+ * of the command, for the pane.
+ */
+export function filingGapText(gap: ThirteenFFilingGap, { command = true }: { command?: boolean } = {}): string {
+  const quarter = quarterText(gap.period);
+  const year = Number(gap.due.slice(0, 4));
+  const filing = gap.filing;
+  if (filing?.form.startsWith("13F-NT")) {
+    const [first, ...others] = filing.otherManagers ?? [];
+    const filed = `13F-NT for ${quarter}, filed ${filingDayText(filing.filed, year)}`;
+    if (!first) return `${filed}; another manager reported its holdings`;
+    const more = others.length ? ` and ${count(others.length)} more` : "";
+    return command
+      ? `${filed}; holdings reported by ${first.name}${more} | open: ${openCommand(first)}`
+      : `${filed}; holdings reported by ${first.name}${first.cik ? ` (CIK ${first.cik})` : ""}${more}`;
+  }
+  if (filing) return `${filing.form} for ${quarter} filed ${filingDayText(filing.filed, year)}; its holdings are not loaded yet`;
+  // Unasked, EDGAR may well hold a 13F-NT or a report the source has not loaded: say only what the loaded filings show.
+  if (!gap.checked) return `${quarter} 13F (due ${filingDayText(gap.due, year)}) not in the loaded filings; EDGAR not checked`;
+  return `No 13F for ${quarter}, due ${filingDayText(gap.due, year)}`;
+}
+
+/** A search asks EDGAR about a few lagging funds only: "EDGAR checked for the first 10 of 14 funds with no Q2 2026 13F loaded; ...". */
+export function uncheckedFundsText(asked: number, behind: number, period: string): string {
+  return `EDGAR checked for the first ${count(asked)} of ${count(behind)} funds with no ${quarterText(period)} 13F loaded; fn 13F <CIK> checks any other`;
+}
+
 /** "showing 50 of 374" from the start of the list, "showing 51-100 of 374" past it. */
 function shownRangeText(offset: number, end: number, total: number): string {
   return offset > 0

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

@@ -97,6 +97,51 @@ export interface FundDetailData {
   latestReport?: ThirteenFPeriodReport;
   previousReport?: ThirteenFPeriodReport;
   warnings?: string[];
+  /** Set when the latest report predates the newest quarter past its deadline. */
+  filingGap?: ThirteenFFilingGap | null;
+}
+
+/** A manager a 13F-NT names as reporting its holdings. */
+export interface ThirteenFOtherManager {
+  /** Null on a cover page that gives only the 028- file number. */
+  cik: string | null;
+  name: string;
+  fileNumber: string | null;
+}
+
+/** One 13F filing as EDGAR lists it, notices included. */
+export interface ThirteenFEdgarFiling {
+  /** 13F-HR, 13F-HR/A, 13F-NT or 13F-NT/A. */
+  form: string;
+  period: string;
+  filed: string;
+  accession: string;
+  url: string;
+  otherManagers?: ThirteenFOtherManager[];
+}
+
+/** A filer's 13F filings from EDGAR, newest first. */
+export interface ThirteenFFilerStatus {
+  cik: string;
+  name: string;
+  source: string;
+  filings: ThirteenFEdgarFiling[];
+}
+
+/**
+ * What a fund filed for the newest quarter past its deadline when no holdings
+ * report for it is loaded: a 13F-NT (another manager reported the holdings), a
+ * report EDGAR has that is not loaded yet, or nothing EDGAR shows.
+ */
+export interface ThirteenFFilingGap {
+  /** The quarter end, YYYY-MM-DD. */
+  period: string;
+  /** The day the 13F was due, YYYY-MM-DD. */
+  due: string;
+  /** The fund's own filing for that quarter, when EDGAR lists one. */
+  filing: ThirteenFEdgarFiling | null;
+  /** False when EDGAR could not be asked; a missing filing is then as far as the loaded reports know. */
+  checked: boolean;
 }
 
 /** The public report for one period, after applying known amendment types. */
@@ -126,6 +171,10 @@ export interface FundHoldingRow {
   previousShares: number | null;
   valueChange: number | null;
   estimatedPnl: number | null;
+  /** New shares per old (10 for 10:1) when the filings straddle a split its corporate actions show: Est P&L is priced, and sharesChange, sharesChangePercent and action measured, on the previous shares carried across it. */
+  splitRatio?: number;
+  /** The line moved as across a split and its corporate actions could not be read to tell: Est P&L is left empty, not priced as a crash or a surge, and its share change stays as filed. */
+  splitUnread?: boolean;
   sharesChange: number | null;
   sharesChangePercent: number | null;
   action: HoldingAction;

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";
@@ -20,7 +21,9 @@ import { isPlainKeyboardEvent } from "../../../../utils/keyboard";
 import { publicTickerKey } from "../../../../utils/exchanges";
 import { formatPriceObservation, quoteFormatOptions } from "../../../../market-data/market/format";
 import { cleanFloat32Price, historyPriceDecimals } from "../../../../cli/history-rows";
-import { pricePointValues, priceHistoryIntegrityNotice } from "../../../../utils/price-history-integrity";
+import {
+  MISSING_VOLUME_TEXT, missingVolumeCount, missingVolumeNotice, pricePointValues, priceHistoryIntegrityNotice,
+} from "../../../../utils/price-history-integrity";
 import {
   useAssetData,
   useDebouncedPluginPaneState,
@@ -29,6 +32,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 +51,18 @@ 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;
+  /** When the bar opens, or the time of the latest trade an intraday history can end with (latestTradeIndex). */
+  time: number;
+  /** The bar's period had not ended: a week or month still running, or the day's session still trading. */
+  partial: boolean;
+  /** A coin's day Gloom Cloud rebuilt from hourly bars, which has no volume of its own. */
+  filled: boolean;
   change: number | null;
   changePercent: number | null;
 };
@@ -86,29 +112,56 @@ function formatMaybePercent(value: number | null): string {
   return value == null ? "-" : formatPercent(value);
 }
 
-function formatMaybeCompact(value: number | null | undefined): string {
-  return value == null ? "-" : formatCompact(value);
+/** Volume as the table shows it; missing reads as missing (`volumeMissing`) in a history that reports volume, never 0. */
+function formatVolume(value: number | null | undefined, volumeMissing: boolean): string {
+  return value == null ? volumeMissing ? MISSING_VOLUME_TEXT : "-" : 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, filled: point.filled === 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 { point, date, sourceIndex, filled } = 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,
+      time: date.getTime(),
+      partial,
+      filled,
       change,
       changePercent: previous?.close && change !== null ? change / previous.close : null,
     };
   }).reverse();
+  return { rows, size, forming, dayToDate, newestDate };
 }
 
 const HISTORY_PRICE_WIDTH = 10;
@@ -123,8 +176,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 +195,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 +216,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 +228,31 @@ 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);
+  const volumeMissing = useMemo(() => missingVolumeCount(rows.map((row) => ({
+    ...row.point, date: row.time, partial: row.partial, filled: row.filled,
+  }))), [rows]);
+  const volumeNotice = missingVolumeNotice(volumeMissing, rows.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 +288,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":
@@ -232,16 +303,23 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
       case "changePercent":
         return { text: formatMaybePercent(row.changePercent), value: row.changePercent == null ? null : row.changePercent * 100, color: priceColor(row.changePercent ?? 0) };
       case "volume":
-        return { text: formatMaybeCompact(row.point.volume), value: row.point.volume ?? null, color: colors.textDim };
+        return { text: formatVolume(row.point.volume, volumeMissing > 0), value: row.point.volume ?? null, color: colors.textDim };
     }
-  }, [priceDecimals]);
+  }, [priceDecimals, volumeMissing]);
 
-  // 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",
-    notices: integrityNotice ? [integrityNotice] : [],
+    notices: [integrityNotice, volumeNotice].filter((notice): notice is string => !!notice),
     focused,
     title: "Price history data",
   });
@@ -280,11 +358,15 @@ 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"],
         ...(integrityNotice ? [["Warning", integrityNotice]] : []),
+        ...(volumeNotice ? [["Volume note", volumeNotice]] : []),
         ...(error ? [["Error", error]] : []),
       ]}
       emptyStateTitle={error

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

@@ -0,0 +1,108 @@
+import { BAR_INTERVAL_LABELS } from "../../../../cli/history-rows";
+import { periodToDateText } from "../../../../cli/pane-functions/freshness";
+import { barLastSession, 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;
+}
+
+/**
+ * The day the newest weekly or monthly bar, dated `date` by the start of its
+ * period, closed on once that period has ended (barLastSession): the week of
+ * Mon 12 Oct 2026 is Fri 16 Oct, the day its close is from. Null while it
+ * forms (formingHistoryBar dates it then), and for any other bar.
+ */
+export function closedHistoryBarDay(
+  size: HistoryBarSize,
+  date: string | undefined,
+  venue: string | undefined,
+  now: number,
+): string | null {
+  const period = historyBarPeriod(size);
+  return period && date && !barPeriodToDate(date, period, venue, now) ? barLastSession(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"],