gloomberb 0.16.0 → 0.16.2

package/src/plugins/builtin/rate-path/headless.ts

@@ -31,6 +31,8 @@ export const ratePathHeadless: HeadlessPaneDefinition<"bundle"> = {
   discovery: { aliases: ["WIRP", "FFIP"], dataRequirements: ["Gloom Cloud rate-path endpoint"],
     limitations: ["Conditional two-outcome probabilities", "SR3 history from hourly trades", "Maintained FOMC schedule and SEP snapshot"] },
   shape: "bundle", argument: { kind: "none" }, options: [], describe: "US rate path",
+  // Delayed futures quotes; each contract and policy rate says whether it is stale.
+  freshness: { status: "delayed" },
   async load(_args, ctx) {
     const data = await fetchRatePath(ctx.apiClient);
     const moves = meetingMoves(data.meetings);

package/src/plugins/builtin/realized-vol/headless.ts

@@ -4,10 +4,12 @@ import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { createRealizedVolatilityDependencies, loadCurrentAtmIv, loadRealizedVolatilityHistory } from "./client";
 import { projectRealizedVolatility, type CurrentAtmIvSnapshot } from "./model";
 import { ESTIMATOR_OPTIONS, selectedWindows } from "./settings";
+import { DAILY_CLOSES } from "../shared/report-freshness";
 
 export function realizedVolHeadless(initialView: "graph" | "cone"): HeadlessPaneDefinition<"bundle"> {
   return {
     shape: "bundle", argument: { kind: "ticker", description: "Underlying ticker" },
+    freshness: { ...DAILY_CLOSES, observedKey: "date", oldest: null },
     describe: (args) => `${initialView === "graph" ? "HVG" : "HVT"} ${args.symbols[0] ?? ""}`,
     discovery: { screenshotReadiness: "live-dom", limitations: ["IV is a dated current observation; HIVG has the stored IV history."] },
     options: [

package/src/plugins/builtin/relative-rotation/headless.ts

@@ -8,6 +8,8 @@ const fixed = (value: unknown, digits: number) =>
 
 export const rotationHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  // Weekly trails: a week without a new close, plus a few days' grace, has stopped updating.
+  freshness: { status: "not-a-feed", basis: "weekly closes", maxAgeMinutes: 10 * 24 * 60 },
   argument: {
     kind: "symbol-list",
     optional: true,

package/src/plugins/builtin/research/analyst-headless.ts

@@ -21,6 +21,7 @@ import {
   targetUpside,
   type RatingColumnId,
 } from "./analyst-model";
+import { REPORTED_DATA } from "../shared/report-freshness";
 
 const RATING_COLUMNS: HeadlessPaneColumn[] = [
   { key: "date", header: "Date" },
@@ -109,6 +110,7 @@ export function createAnalystResearchHeadless(
 ): HeadlessPaneDefinition<"bundle"> {
   return {
     shape: "bundle",
+    freshness: { ...REPORTED_DATA, basis: "analyst ratings" },
     argument: {
       kind: "ticker",
       placeholder: "ticker",
@@ -161,6 +163,7 @@ export function createAnalystResearchHeadless(
       return {
         sections,
         errors: data.stale ? ["Analyst research is stale"] : undefined,
+        ...(data.stale ? { freshness: { status: "stale" as const } } : {}),
         metadata: {
           symbol: data.symbol || symbol,
           name: data.name ?? null,

package/src/plugins/builtin/research/events-headless.ts

@@ -10,6 +10,7 @@ import type {
 } from "../../../types/plugin";
 import { buildEventRows, eventSourceNotice, CORPORATE_ACTION_COVERAGE } from "./event-model";
 import { EVENT_COLUMNS, loadEventSources } from "./event-sources";
+import { REPORTED_DATA } from "../shared/report-freshness";
 
 interface EventHeadlessData {
   actions: CorporateActionsData | null;
@@ -45,6 +46,7 @@ export function createEventsHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
+    freshness: { ...REPORTED_DATA, basis: "corporate actions", oldest: null },
     argument: {
       kind: "ticker",
       placeholder: "ticker",

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

@@ -11,6 +11,7 @@ import type {
 } from "../../../types/plugin";
 import { buildEventRows, eventSourceNotice, type EventRow } from "./event-model";
 import { EVENT_COLUMNS, loadEventSources } from "./event-sources";
+import { REPORTED_DATA } from "../shared/report-freshness";
 
 export interface EarningsEstimateSources {
   actions: CorporateActionsData | null;
@@ -92,6 +93,7 @@ export function createEarningsEstimatesHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
+    freshness: { ...REPORTED_DATA, basis: "estimates and reported earnings", oldest: null },
     argument: {
       kind: "ticker",
       placeholder: "ticker",

package/src/plugins/builtin/research/index.tsx

@@ -60,6 +60,7 @@ export const researchModule: PluginModule = {
     },
     {
       id: "equity-diagnostic",
+      reportFreshness: { status: "not-a-feed", basis: "analysis of filings" },
       name: "Equity Diagnostic",
       icon: "D",
       component: EquityDiagnosticView,

package/src/plugins/builtin/research/relative-valuation-headless.ts

@@ -1,7 +1,8 @@
-import { formatPriceEarnings, PRICE_EARNINGS_NOTICE } from "../../../utils/price-earnings";
+import { formatPriceEarnings, NOT_MEANINGFUL, PRICE_EARNINGS_NOTICE } from "../../../utils/price-earnings";
 import type { HeadlessPaneDefinition } from "../../../types/headless";
 import { formatCurrency, formatLevelPercent, formatNumber, formatPercent } from "../../../utils/format";
 import { loadHeadlessFinancials, loadHeadlessSymbols } from "../shared/headless-market-data";
+import { quoteFreshnessFields } from "../shared/report-freshness";
 import { RELATIVE_VALUATION_STALE_FUNDAMENTALS_NOTICE, RELATIVE_VALUATION_STALE_QUOTE_NOTICE, relativeValuationValues } from "./relative-valuation-model";
 import { paneSchemas } from "./headless-schema";
 
@@ -14,7 +15,10 @@ export const relativeValuationHeadless: HeadlessPaneDefinition<"rows"> = {
     { key: "price", header: "Last", align: "right", format: (value, row) => value == null || !row.currency ? "-" : formatCurrency(Number(value), String(row.currency)) },
     ...([ ["trailingPE", "P/E"], ["forwardPE", "Fwd P/E"] ] as const).map(([key, header]) => ({
       key, header, align: "right" as const,
-      format: (_value: unknown, row: Record<string, unknown>) => formatPriceEarnings((row.reportedMultiples as ReturnType<typeof relativeValuationValues>["reportedMultiples"] | undefined)?.[key]),
+      format: (_value: unknown, row: Record<string, unknown>) => {
+        const values = row as Partial<ReturnType<typeof relativeValuationValues>>;
+        return formatPriceEarnings(values.notMeaningful?.[key] ? NOT_MEANINGFUL : values.reportedMultiples?.[key]);
+      },
     })),
     ...[["evSales", "EV/S"]].map(([key, header]) => ({
       key: key!, header: header!, align: "right" as const,
@@ -27,7 +31,7 @@ export const relativeValuationHeadless: HeadlessPaneDefinition<"rows"> = {
   ],
   async load({ symbols }, ctx) {
     const loaded = await loadHeadlessSymbols(symbols, ctx, (symbol) => loadHeadlessFinancials(ctx, symbol));
-    const rows = loaded.entries.map(({ symbol, data }) => ({ symbol, ...relativeValuationValues(data) }));
+    const rows = loaded.entries.map(({ symbol, data }) => ({ symbol, ...relativeValuationValues(data), ...quoteFreshnessFields(data?.quote) }));
     const unavailableSymbols = [...loaded.unavailableSymbols, ...rows.filter((row) => ![
       row.marketCap, row.trailingPE, row.forwardPE, row.evSales, row.fcfYield, row.revenueGrowth, row.operatingMargin,
     ].some((value) => value != null)).map(({ symbol }) => symbol)];
@@ -42,8 +46,9 @@ export const relativeValuationHeadless: HeadlessPaneDefinition<"rows"> = {
       staleFundamentalsSymbols,
       quoteBasis: "Stale quote fields are excluded from comparison; reportedQuote retains the rejected observation and quoteAsOf retains its source timestamp.",
       fundamentalsBasis: "Provider multiples and operating metrics retain independent fundamentalsProvenance. Retrieval time does not establish the valuation date.",
-      notices: rows.some((row) => Object.values(row.reportedMultiples).some((value) => value != null && value <= 0)) ? [PRICE_EARNINGS_NOTICE] : [],
-      multipleBasis: "Comparable P/E fields require a positive finite multiple; reportedMultiples preserves the finite provider values.",
+      notices: rows.some((row) => Object.keys(row.notMeaningful).length > 0
+        || Object.values(row.reportedMultiples).some((value) => value != null && value <= 0)) ? [PRICE_EARNINGS_NOTICE] : [],
+      multipleBasis: "Comparable P/E fields require a positive finite multiple over positive EPS; notMeaningful says why one is null, and reportedMultiples preserves the finite provider values.",
       marketCapBasis: "Market caps retain their own currency and source. Fundamentals retrieval time is not a valuation date; quote timestamps do not date fallback caps.",
     } };
 

package/src/plugins/builtin/research/relative-valuation-model.ts

@@ -1,4 +1,4 @@
-import { comparablePriceEarnings } from "../../../utils/price-earnings";
+import { comparablePriceEarnings, notMeaningfulMultiples } from "../../../utils/price-earnings";
 import { selectMarketCapitalization } from "../../../utils/market-capitalization";
 import type { Quote, TickerFinancials } from "../../../types/financials";
 
@@ -16,6 +16,12 @@ export function relativeValuationValues(financials: TickerFinancials | null) {
     trailingPE: fundamentals?.trailingPE != null && Number.isFinite(fundamentals.trailingPE) ? fundamentals.trailingPE : null,
     forwardPE: fundamentals?.forwardPE != null && Number.isFinite(fundamentals.forwardPE) ? fundamentals.forwardPE : null,
   };
+  // A multiple over a loss reads N/M even when the source served a positive one beside it.
+  const { trailingPE: trailingNotMeaningful, forwardPE: forwardNotMeaningful } = notMeaningfulMultiples(fundamentals);
+  const notMeaningful = {
+    ...(trailingNotMeaningful ? { trailingPE: trailingNotMeaningful } : {}),
+    ...(forwardNotMeaningful ? { forwardPE: forwardNotMeaningful } : {}),
+  };
   return {
     price: quoteStale ? null : quote?.price ?? null,
     quoteStale: quote?.stale ?? null,
@@ -35,9 +41,11 @@ export function relativeValuationValues(financials: TickerFinancials | null) {
     marketCap: capitalization?.value ?? null,
     marketCapCurrency: capitalization?.currency ?? null,
     marketCapProvenance: capitalization?.provenance ?? null,
-    trailingPE: comparablePriceEarnings(reportedMultiples.trailingPE),
-    forwardPE: comparablePriceEarnings(reportedMultiples.forwardPE),
+    trailingPE: trailingNotMeaningful ? null : comparablePriceEarnings(reportedMultiples.trailingPE),
+    forwardPE: forwardNotMeaningful ? null : comparablePriceEarnings(reportedMultiples.forwardPE),
     reportedMultiples,
+    /** Why a multiple is N/M: its earnings base is zero or a loss. */
+    notMeaningful,
     // Vendor ADR ratios can mix unverified valuation and reporting units too.
     evSales: !compatibleCurrency ? null
       : fundamentals?.enterpriseToRevenue != null && Number.isFinite(fundamentals.enterpriseToRevenue)

package/src/plugins/builtin/research/relative-valuation-pane.tsx

@@ -1,4 +1,4 @@
-import { formatPriceEarnings } from "../../../utils/price-earnings";
+import { formatPriceEarnings, NOT_MEANINGFUL } from "../../../utils/price-earnings";
 import { useCallback, useMemo, useState } from "react";
 import { TextAttributes } from "../../../ui";
 import {
@@ -198,9 +198,9 @@ export function RelativeValuationPane({ focused, width, height }: PaneProps) {
       case "marketCap":
         return { text: formatCompact(row.marketCap ?? undefined, { fixedDecimals: true }), color: colors.textDim };
       case "trailingPE":
-        return { text: formatPriceEarnings(row.reportedMultiples.trailingPE), color: colors.text };
+        return { text: formatPriceEarnings(row.notMeaningful.trailingPE ? NOT_MEANINGFUL : row.reportedMultiples.trailingPE), color: colors.text };
       case "forwardPE":
-        return { text: formatPriceEarnings(row.reportedMultiples.forwardPE), color: colors.text };
+        return { text: formatPriceEarnings(row.notMeaningful.forwardPE ? NOT_MEANINGFUL : row.reportedMultiples.forwardPE), color: colors.text };
       case "evSales":
         return { text: formatNumber(row.evSales ?? undefined, 1), color: colors.text };
       case "fcfYield":

package/src/plugins/builtin/research-search/index.tsx

@@ -37,6 +37,7 @@ export const researchSearchPlugin: GloomPlugin = {
   panes: [
     {
       id: RESEARCH_SEARCH_PANE_ID,
+      reportFreshness: { status: "not-a-feed", basis: "search results" },
       name: "Research Search",
       icon: "RS",
       component: ResearchSearchPane,

package/src/plugins/builtin/revenue-breakdown/headless.ts

@@ -2,9 +2,11 @@ import type { RevenueBreakdownView } from "../../../api-client/revenue-breakdown
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchRevenueBreakdown } from "./client";
 import { quarterLabel, reportedSpan } from "./model";
+import { SEC_FILINGS } from "../shared/report-freshness";
 
 export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  freshness: { ...SEC_FILINGS, basis: "10-Q and 10-K filings" },
   argument: {
     kind: "ticker",
     description: "SEC reporting issuer ticker.",

package/src/plugins/builtin/reverse-dcf/headless.ts

@@ -9,6 +9,7 @@ const implied = (value: ImpliedGrowth | null) => !value ? null : value.kind ===
 
 export const reverseDcfHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Ticker" },
+  freshness: { status: "not-a-feed", basis: "price and reported cash flows" },
   describe: (args) => `RDCF ${args.symbols[0] ?? ""}`,
   discovery: { screenshotReadiness: "live-dom", limitations: ["Trailing twelve-month free cash flow against the reported enterprise value."] },
   options: [
@@ -35,6 +36,7 @@ export const reverseDcfHeadless: HeadlessPaneDefinition<"bundle"> = {
           ...Object.fromEntries(row.implied.map((value, index) => [`t${index}`, implied(value)])) })) },
       ],
       complete: !inputs.stale && !inputs.error && !model.error,
+      ...(inputs.stale ? { freshness: { status: "stale" as const } } : {}),
       unavailableSymbols: model.implied ? [] : [instrument.symbol],
       errors: [inputs.error, model.error].filter((value): value is string => !!value),
       metadata: { currency: model.currency, discountRate, terminalGrowth: TERMINAL_GROWTH, discountRates: DISCOUNT_RATES,

package/src/plugins/builtin/risk-factors/headless.ts

@@ -1,8 +1,10 @@
 import type { HeadlessBundleSection, HeadlessPaneDefinition } from "../../../types/plugin";
 import { loadRiskReportWithClient, loadRiskReportsWithClient, type RiskReportsResult } from "./data";
+import { SEC_FILINGS } from "../shared/report-freshness";
 
 export const riskFactorsHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  freshness: { ...SEC_FILINGS, basis: "10-K filings" },
   argument: { kind: "ticker", placeholder: "ticker", description: "Company symbol." },
   options: [
     { key: "year", type: "string", defaultValue: "latest", description: "Filing year (for example 2025), or latest discovered report." },

package/src/plugins/builtin/scanner/flow-history.ts

@@ -5,6 +5,7 @@ import {
   type ScannerFlowHistoryPage,
   type ScannerFlowHistoryQuery,
 } from "../../../api-client";
+import { signalWithTimeout } from "../../../utils/async-deadline";
 import { flowHistorySearch, mergeFlowRows } from "./flow-model";
 
 export interface FlowHistoryState {
@@ -21,20 +22,8 @@ export type FlowHistoryLoader = (
   signal: AbortSignal,
 ) => Promise<ScannerFlowHistoryPage>;
 
-/** Aborts on the caller's signal or after `ms`; AbortSignal.any is too new for older system WebViews. */
-function withTimeout(signal: AbortSignal, ms: number): AbortSignal {
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  if (signal.aborted) abort();
-  else signal.addEventListener("abort", abort, { once: true });
-  const timeout = AbortSignal.timeout(ms);
-  if (timeout.aborted) abort();
-  else timeout.addEventListener("abort", abort, { once: true });
-  return controller.signal;
-}
-
 const loadRecordedPrints: FlowHistoryLoader = (query, signal) =>
-  apiClient.getScannerFlowHistory(flowHistorySearch(query), withTimeout(signal, 20_000));
+  apiClient.getScannerFlowHistory(flowHistorySearch(query), signalWithTimeout(signal, 20_000));
 
 function emptyHistory(key: string): FlowHistoryState {
   return { key, events: [], hasMore: true, loading: false, error: null };

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

@@ -7,6 +7,7 @@ import type {
 import type {
   HeadlessPaneApiClient,
   HeadlessPaneDefinition,
+  HeadlessPaneFreshness,
   HeadlessPaneLoadArgs,
   HeadlessPaneOptionDef,
   HeadlessSnapshotResult,
@@ -88,6 +89,17 @@ export function loadHiloSnapshot(
   return loadScannerSnapshot<ScannerHiloPayload>(client, "hilo", signal, timeoutMs);
 }
 
+/**
+ * The scanner says which instance served it, real-time or the delayed one free
+ * accounts get, and whether it is running: a closed session's scan is final,
+ * and a degraded one may have fallen behind.
+ */
+function scannerFreshness(payload: Pick<ScannerHiloPayload, "access" | "delayMinutes" | "status">): HeadlessPaneFreshness {
+  if (payload.status === "closed") return { status: "not-a-feed", basis: "closed session" };
+  if (payload.status === "degraded") return { status: "stale" };
+  return payload.access === "realtime" ? { status: "live" } : { status: "delayed", delayMinutes: payload.delayMinutes };
+}
+
 function projectHiloSnapshot(
   payload: ScannerHiloPayload,
   minPrice: HiloMinPrice,
@@ -99,6 +111,7 @@ function projectHiloSnapshot(
     asOf: new Date(payload.asOf).toISOString(),
     items: [...lows, ...highs],
     ...(payload.status === "degraded" ? { errors: ["Scanner feed degraded"] } : {}),
+    freshness: scannerFreshness(payload),
     metadata: {
       ...(payload.access === "delayed" ? { notices: [`Delayed ${payload.delayMinutes} minutes`] } : {}),
       status: payload.status,
@@ -214,6 +227,7 @@ function projectFlowSnapshot(
     asOf: new Date(payload.asOf).toISOString(),
     items: events.map((event) => ({ ...event })),
     ...(payload.status === "degraded" ? { errors: ["Scanner feed degraded"] } : {}),
+    freshness: scannerFreshness(payload),
     metadata: {
       status: payload.status,
       access: payload.access,

package/src/plugins/builtin/scanner/hilo-bars.tsx

@@ -1,4 +1,5 @@
-import { Box, Text, TextAttributes, useUiCapabilities } from "../../../ui";
+import { RatioBar } from "../../../components/ui/ratio-bar";
+import { Box, Text, TextAttributes } from "../../../ui";
 import { colors } from "../../../theme/colors";
 import type { ScannerHiloPayload } from "../../../api-client";
 import {
@@ -6,7 +7,6 @@ import {
   hiloBarLayout,
   hiloWindowLabel,
   HILO_LABEL_WIDTH,
-  terminalBarCells,
   type HiloBarRow,
 } from "./hilo-model";
 
@@ -33,74 +33,29 @@ function SideName({ name, width, align }: { name: string | null; width: number;
   );
 }
 
-/** Terminal bars are block runs at half-cell resolution, the densest option in cells. */
 /** Counts sit beside the label, so an empty window reads as zero rather than a missing bar. */
 function countWidthFor(rows: readonly HiloBarRow[]): number {
   return Math.max(...rows.flatMap((row) => [String(row.lows).length, String(row.highs).length]), 1) + 1;
 }
 
-function TerminalHiloBars({ rows, width }: { rows: HiloBarRow[]; width: number }) {
+/** Lows grow left from the window label and highs grow right, on one scale for every bar. */
+export function HiloBars({ windows, width }: HiloBarsProps) {
+  const rows = buildHiloBarRows(windows);
   const countWidth = countWidthFor(rows);
   const { halfWidth, barWidth, sideNameWidth } = hiloBarLayout(width, countWidth);
   return (
-    <Box flexDirection="column" width={width}>
-      {rows.map((row, index) => {
-        const low = terminalBarCells(row.lowRatio, barWidth);
-        const high = terminalBarCells(row.highRatio, barWidth);
-        const lowBar = `${low.half ? "▐" : ""}${"█".repeat(low.full)}`;
-        const highBar = `${"█".repeat(high.full)}${high.half ? "▌" : ""}`;
-        return (
-          <Box key={row.key} flexDirection="row" height={1} paddingX={1}>
-            <SideName name={index === 0 ? "LOWS" : null} width={sideNameWidth} align="left" />
-            <Box width={halfWidth} flexShrink={0} flexDirection="row" justifyContent="flex-end">
-              <Text fg={colors.negative}>{lowBar}</Text>
-              <Text fg={colors.textDim}>{String(row.lows).padStart(countWidth)}</Text>
-            </Box>
-            <RowLabel row={row} />
-            <Box width={halfWidth} flexShrink={0} flexDirection="row">
-              <Text fg={colors.textDim}>{String(row.highs).padEnd(countWidth)}</Text>
-              <Text fg={colors.positive}>{highBar}</Text>
-            </Box>
-            <SideName name={index === 0 ? "HIGHS" : null} width={sideNameWidth} align="right" />
-          </Box>
-        );
-      })}
-    </Box>
-  );
-}
-
-/** Desktop bars are real flex-sized divs, so length is fractional instead of cell-quantized. */
-function DesktopHiloBars({ rows, width }: { rows: HiloBarRow[]; width: number }) {
-  const { sideNameWidth } = hiloBarLayout(width, countWidthFor(rows));
-  return (
-    <Box flexDirection="column" width={width}>
+    <Box flexDirection="column" width={width} flexShrink={0}>
       {rows.map((row, index) => (
         <Box key={row.key} flexDirection="row" height={1} paddingX={1} alignItems="center">
           <SideName name={index === 0 ? "LOWS" : null} width={sideNameWidth} align="left" />
-          <Box flexGrow={1} flexDirection="row" justifyContent="flex-end" overflow="hidden" alignItems="center">
-            <Box
-              backgroundColor={colors.negative}
-              style={{
-                width: `${(row.lowRatio * 100).toFixed(2)}%`,
-                height: "11px",
-                borderRadius: "2px 0 0 2px",
-                minWidth: row.lows > 0 ? "2px" : "0",
-              }}
-            />
-            <Text fg={colors.textDim}>{` ${row.lows}`}</Text>
+          <Box width={halfWidth} flexShrink={0} flexDirection="row" justifyContent="flex-end" alignItems="center">
+            <RatioBar ratio={row.lowRatio} width={barWidth} color={colors.negative} align="end" thickness={11} />
+            <Text fg={colors.textDim}>{String(row.lows).padStart(countWidth)}</Text>
           </Box>
           <RowLabel row={row} />
-          <Box flexGrow={1} flexDirection="row" overflow="hidden" alignItems="center">
-            <Text fg={colors.textDim}>{`${row.highs} `}</Text>
-            <Box
-              backgroundColor={colors.positive}
-              style={{
-                width: `${(row.highRatio * 100).toFixed(2)}%`,
-                height: "11px",
-                borderRadius: "0 2px 2px 0",
-                minWidth: row.highs > 0 ? "2px" : "0",
-              }}
-            />
+          <Box width={halfWidth} flexShrink={0} flexDirection="row" alignItems="center">
+            <Text fg={colors.textDim}>{String(row.highs).padEnd(countWidth)}</Text>
+            <RatioBar ratio={row.highRatio} width={barWidth} color={colors.positive} thickness={11} />
           </Box>
           <SideName name={index === 0 ? "HIGHS" : null} width={sideNameWidth} align="right" />
         </Box>
@@ -108,16 +63,3 @@ function DesktopHiloBars({ rows, width }: { rows: HiloBarRow[]; width: number })
     </Box>
   );
 }
-
-export function HiloBars({ windows, width }: HiloBarsProps) {
-  const isDesktopWeb = useUiCapabilities().nativePaneChrome === true;
-  const rows = buildHiloBarRows(windows);
-
-  return (
-    <Box flexDirection="column" width={width} flexShrink={0}>
-      {isDesktopWeb
-        ? <DesktopHiloBars rows={rows} width={width} />
-        : <TerminalHiloBars rows={rows} width={width} />}
-    </Box>
-  );
-}

package/src/plugins/builtin/scanner/hilo-model.ts

@@ -79,24 +79,6 @@ export function hiloBarLayout(width: number, countWidth: number): HiloBarLayout
   return { halfWidth, barWidth: Math.max(0, halfWidth - countWidth), sideNameWidth };
 }
 
-export interface TerminalBarCells {
-  full: number;
-  /** Trailing half cell, so small-but-nonzero counts stay visible in cell units. */
-  half: boolean;
-}
-
-/** Converts a 0..1 bar ratio into terminal cells at half-cell resolution. */
-export function terminalBarCells(ratio: number, halfWidth: number): TerminalBarCells {
-  if (!(ratio > 0) || halfWidth <= 0) return { full: 0, half: false };
-  const capped = Math.min(1, ratio);
-  const cells = capped * halfWidth;
-  let full = Math.floor(cells);
-  let half = cells - full >= 0.5;
-  if (full >= halfWidth) return { full: halfWidth, half: false };
-  if (full === 0 && !half) half = true;
-  return { full, half };
-}
-
 function hiloMinPriceValue(setting: HiloMinPrice): number {
   return setting === "1" ? 1 : setting === "5" ? 5 : 0;
 }

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

@@ -7,6 +7,8 @@ const percent = (value: unknown) => typeof value === "number" ? `${(value * 100)
 
 export const seasonalityHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Ticker" },
+  // Dated by the month of its last monthly close.
+  freshness: { status: "not-a-feed", basis: "monthly closes", maxAgeMinutes: 45 * 24 * 60 },
   describe: (args) => `SEAS ${args.symbols[0] ?? ""}`,
   discovery: { screenshotReadiness: "live-dom", limitations: ["Local-price closes; dividends and FX are excluded."] },
   options: [

package/src/plugins/builtin/sec/command-bar-search.ts

@@ -116,6 +116,19 @@ function requestSecFilingFocus(symbol: string, accessionNumber: string): void {
   for (const listener of listeners.values()) listener(accessionNumber);
 }
 
+/**
+ * Opens a filing in the SEC pane for `symbol`, reusing an open one, the way a
+ * filing row in the command bar does.
+ */
+export function openSecFilingInPane(
+  ctx: Pick<GloomPluginContext, "createPaneFromTemplate">,
+  symbol: string,
+  accessionNumber: string,
+): void {
+  requestSecFilingFocus(symbol, accessionNumber);
+  void ctx.createPaneFromTemplate(SEC_TEMPLATE_ID, { symbol });
+}
+
 export function useSecFilingFocusRequest(symbol: string | null | undefined, onFocus: FocusListener): void {
   const [view] = useState(() => ({}));
   useEffect(() => {
@@ -173,10 +186,7 @@ function filingRow(
     badge: filing.form.replace(/\s+/g, "").slice(0, 6),
     right: filingDateLabel(filedAt(filing), now),
     keywords: [ticker, filing.form],
-    execute: () => {
-      requestSecFilingFocus(ticker, filing.accessionNumber);
-      void ctx.createPaneFromTemplate(SEC_TEMPLATE_ID, { symbol: ticker });
-    },
+    execute: () => openSecFilingInPane(ctx, ticker, filing.accessionNumber),
   };
 }
 

package/src/plugins/builtin/sec/filing-content.ts

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useResolvedEntryValue, useSecFilingContent } from "../../../market-data/hooks";
+import { useSecFilingContent } from "../../../market-data/hooks";
 import { getSharedMarketDataCoordinator, resolveEntryValue } from "../../../market-data/coordinator";
+import type { QueryEntry } from "../../../market-data/result-types";
 import type { SecFilingDocument, SecFilingItem } from "../../../types/data-provider";
 import { documentContentTarget, isInlineExhibitDocument } from "./filing-documents";
 
@@ -14,6 +15,22 @@ interface ScopedFilingContentCache {
 const EMPTY_CONTENT_CACHE = new Map<string, string | null>();
 const EMPTY_ERRORS = new Map<string, string>();
 
+/** What a finished content entry holds, or null while it is still loading. */
+function settledFilingContent(
+  entry: QueryEntry<string | null> | null | undefined,
+): { content: string | null; error: string | null } | null {
+  if (!entry) return null;
+  const resolved = resolveEntryValue(entry);
+  const settled = entry.phase === "ready"
+    || entry.phase === "error"
+    || (entry.phase === "refreshing" && resolved !== null);
+  if (!settled) return null;
+  return {
+    content: entry.phase === "error" ? null : resolved,
+    error: entry.error?.reasonCode === "NO_DATA" ? null : entry.error?.message ?? null,
+  };
+}
+
 export function buildInlineFilingContentTargets(
   filing: SecFilingItem | null | undefined,
   documents: readonly SecFilingDocument[],
@@ -69,28 +86,36 @@ export function useSecFilingContentCache({
     [contentCache, targets],
   );
   const contentEntry = useSecFilingContent(nextTarget);
-  const resolvedContent = useResolvedEntryValue(contentEntry);
 
   useEffect(() => {
     if (!nextTarget) return;
-    const phase = contentEntry?.phase;
-    const settled = phase === "ready"
-      || phase === "error"
-      || (phase === "refreshing" && resolvedContent !== null);
-    if (!settled) return;
-    const key = nextTarget.accessionNumber;
-    const content = phase === "error" ? null : resolvedContent;
-    const error = contentEntry?.error?.reasonCode === "NO_DATA" ? null : contentEntry?.error?.message;
+    const first = settledFilingContent(contentEntry);
+    if (!first) return;
+    const coordinator = getSharedMarketDataCoordinator();
     setState((current) => {
-      if (current.scopeKey !== scopeKey || current.values.has(key)) return current;
-      return {
-        scopeKey,
-        values: new Map(current.values).set(key, content),
-        errors: error ? new Map(current.errors).set(key, error) : current.errors,
-        retryingKey: current.retryingKey,
+      if (current.scopeKey !== scopeKey) return current;
+      let values = current.values;
+      let errors = current.errors;
+      const record = (key: string, settled: { content: string | null; error: string | null }) => {
+        if (values === current.values) values = new Map(values);
+        values.set(key, settled.content);
+        if (!settled.error) return;
+        if (errors === current.errors) errors = new Map(errors);
+        errors.set(key, settled.error);
       };
+      if (!values.has(nextTarget.accessionNumber)) record(nextTarget.accessionNumber, first);
+      // Content the coordinator already holds (a pane reopened, a ticker
+      // visited again) is taken in this same update. Taken one target per
+      // render, each one would expose the next, and a few dozen filings chain
+      // that many renders in a row, past React's limit of 50 nested updates.
+      for (const target of targets) {
+        if (values.has(target.accessionNumber)) continue;
+        const settled = settledFilingContent(coordinator?.getSecContentEntry(target.accessionNumber));
+        if (settled) record(target.accessionNumber, settled);
+      }
+      return values === current.values ? current : { ...current, values, errors };
     });
-  }, [contentEntry?.phase, contentEntry?.error, nextTarget, resolvedContent, scopeKey]);
+  }, [contentEntry, nextTarget, scopeKey, targets]);
 
   // Successful accession content is immutable. Retry only selected documents
   // that failed or had no readable content, preserving the sequential queue.

package/src/plugins/builtin/sec/forms.ts

@@ -52,3 +52,15 @@ export function filterFilingsByForms(filings: readonly SecFilingItem[], forms: r
     return accepted.has(form) || (form.endsWith("/A") && accepted.has(form.slice(0, -2)));
   });
 }
+
+/** A form as typed or filed, without punctuation or the `SC`/`SCHEDULE` prefix of ownership schedules. */
+function compactFilingForm(form: string): string {
+  return form.toUpperCase().replace(/[^A-Z0-9]/g, "").replace(/^(?:SCHEDULE|SC)(?=\d)/, "");
+}
+
+/** `13D` matches SC 13D, SCHEDULE 13D and their amendments; `10-K` matches 10-K and 10-K/A. */
+export function filingFormMatches(form: string, wanted: string): boolean {
+  const target = compactFilingForm(wanted);
+  const actual = compactFilingForm(form);
+  return !!target && (actual === target || actual === `${target}A`);
+}

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

@@ -8,6 +8,7 @@ import type { SecFilingItem } from "../../../types/data-provider";
 import { loadSecFilings } from "./client";
 import { filterFilingsByForms, SEC_FILING_FETCH_LIMIT } from "./forms";
 import { buildSecFilingRows, secFilingIssuers, SEC_ACCEPTANCE_NOTE } from "./model";
+import { SEC_FILINGS } from "../shared/report-freshness";
 
 const SEC_COLUMNS: HeadlessPaneColumn[] = [
   {
@@ -49,6 +50,7 @@ export function createSecHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
+    freshness: { ...SEC_FILINGS, observedKey: "acceptedAt" },
     argument: {
       kind: "ticker",
       placeholder: "ticker",

package/src/plugins/builtin/sectors/client.ts

@@ -87,6 +87,7 @@ export async function loadSectorRows(
         quoteIssue,
         lastReportedPrice,
         quoteUpdatedAt: quote && Number.isFinite(quote.lastUpdated) ? quote.lastUpdated : null,
+        quoteDataSource: quote?.dataSource,
         changePercent,
         return1M: month?.value ?? null,
         return1Y: year?.value ?? null,