gloomberb 0.18.0 → 0.18.2

package/src/plugins/builtin/insider/base-values.ts

@@ -0,0 +1,72 @@
+import type { HeadlessPaneColumn, HeadlessPaneRow } from "../../../types/headless";
+import { fxCloseOnOrBefore, loadDailyFxCloses, type FxCloses, type FxHistoryClient } from "../../../market-data/fx-closes";
+import { logFailure } from "../../../utils/log-failure";
+import { formatCompact, formatNumber } from "../../../utils/format";
+
+/** A Form 4 states its prices and values in US dollars. */
+export const FORM4_CURRENCY = "USD";
+
+/** The rows with their currency, and for a base currency other than USD each value in it, with the columns and note that say so. */
+export interface InsiderBaseValues {
+  rows: HeadlessPaneRow[];
+  /** The money columns labelled with their currency, and the converted value and its rate; null for a USD base, whose columns stay as they are. */
+  columns: HeadlessPaneColumn[] | null;
+  note: string | null;
+}
+
+const dash = (value: unknown, format: (value: number) => string) => (typeof value === "number" && Number.isFinite(value) ? format(value) : "-");
+
+/**
+ * Every row carries the currency its price and value are in (USD, as a Form 4
+ * states them). With another base currency (CAD), each value is also given
+ * in it at the daily close of USD/CAD on its transaction day, or the last
+ * close before a weekend or holiday (`fxCloseOnOrBefore` over the history
+ * PORT and PEB read), with the rate and that close's date beside it. When the
+ * closes cannot be read the values stay in USD and the note says why.
+ */
+export async function withInsiderBaseValues(
+  rows: readonly HeadlessPaneRow[],
+  baseCurrency: string,
+  client: FxHistoryClient,
+  now = new Date(),
+): Promise<InsiderBaseValues> {
+  const labelled: HeadlessPaneRow[] = rows.map((row) => ({ ...row, currency: FORM4_CURRENCY }));
+  const base = baseCurrency.trim().toUpperCase();
+  if (!base || base === FORM4_CURRENCY) return { rows: labelled, columns: null, note: null };
+  const pair = `${FORM4_CURRENCY}/${base}`;
+  const days = labelled.flatMap((row) => typeof row.transactionDate === "string" && typeof row.totalValue === "number"
+    ? [row.transactionDate.slice(0, 10)] : []).sort();
+  let closes: FxCloses | null = null;
+  if (days.length > 0) {
+    try {
+      closes = await loadDailyFxCloses(base, days[0]!, client, now);
+    } catch (error) {
+      logFailure("insider.base-values", `Daily ${pair} closes failed`)(error);
+    }
+  }
+  const converted = labelled.map((row) => {
+    const day = typeof row.transactionDate === "string" ? row.transactionDate.slice(0, 10) : null;
+    const reading = closes && day && typeof row.totalValue === "number" ? fxCloseOnOrBefore(closes, day) : null;
+    // The close is USD per unit of the base currency; the rate is the base currency per dollar.
+    const fxRate = reading ? 1 / reading.rate : null;
+    return {
+      ...row,
+      baseCurrency: base,
+      valueBase: fxRate != null ? (row.totalValue as number) * fxRate : null,
+      fxRate,
+      fxDate: reading?.date ?? null,
+    };
+  });
+  const columns: HeadlessPaneColumn[] = [
+    { key: "pricePerShare", header: `Price (${FORM4_CURRENCY})`, align: "right", format: (value) => dash(value, (price) => formatNumber(price, 2)) },
+    { key: "totalValue", header: `Value (${FORM4_CURRENCY})`, align: "right", format: (value) => dash(value, formatCompact) },
+    ...closes ? [
+      { key: "valueBase", header: `Value (${base})`, align: "right" as const, format: (value: unknown) => dash(value, formatCompact) },
+      { key: "fxRate", header: pair, align: "right" as const, stackPriority: 1, format: (value: unknown) => dash(value, (rate) => formatNumber(rate, 4)) },
+    ] : [],
+  ];
+  const note = days.length === 0 ? null
+    : closes ? `Value (${base}) is each value at the ${pair} daily close of its transaction day, or of the trading day before it; ${pair} is that rate.`
+      : `Daily ${pair} closes are unavailable, so values stay in ${FORM4_CURRENCY}.`;
+  return { rows: closes ? converted : labelled, columns, note };
+}

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

@@ -8,6 +8,7 @@ import type {
 import { formatCompact, formatCurrency } from "../../../utils/format";
 import { loadParsedInsiderFilings, type InsiderFilingsLoad } from "./client";
 import { insiderEmptyNotice } from "./issuer";
+import { FORM4_CURRENCY, withInsiderBaseValues } from "./base-values";
 import {
   buildInsiderRows,
   buildInsiderSummary,
@@ -58,6 +59,7 @@ import {
   insiderUsualRatio,
 } from "./signals-model";
 import { REPORT_ROWS } from "../shared/headless-options";
+import type { FxHistoryClient } from "../../../market-data/fx-closes";
 
 const INSIDER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "form", header: "Form" },
@@ -106,6 +108,20 @@ const INSIDER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "note", header: "Note", underRow: true, format: (value) => typeof value === "string" ? value : "" },
 ];
 
+/** With a base currency other than USD, the dollar columns say they are in USD ("Bought (USD)"), as $ alone is several currencies' sign. */
+function labelDollarColumns(columns: HeadlessPaneColumn[], keys: readonly string[], baseCurrency: string): HeadlessPaneColumn[] {
+  if (baseCurrency.trim().toUpperCase() === FORM4_CURRENCY) return columns;
+  return columns.map((column) => keys.includes(column.key) ? { ...column, header: `${column.header} (${FORM4_CURRENCY})` } : column);
+}
+
+/** The trades' columns with the money ones labelled by currency and the converted value and rate after them (`withInsiderBaseValues`). */
+function withMoneyColumns(money: readonly HeadlessPaneColumn[]): HeadlessPaneColumn[] {
+  const byKey = new Map(money.map((column) => [column.key, column]));
+  return INSIDER_COLUMNS.flatMap((column) => column.key === "totalValue"
+    ? money.filter((entry) => entry.key !== "pricePerShare")
+    : [byKey.get(column.key) ?? column]);
+}
+
 const figureOrDash = (value: unknown) => (typeof value === "number" ? value : null);
 
 /**
@@ -183,6 +199,7 @@ function insidersRows(activity: InsiderCompanyActivity, side: InsiderSignalSide)
       stakeBothWays: line.buyer.twoWay === true,
       bought: line.bought,
       sold: line.sold,
+      currency: FORM4_CURRENCY,
       shares: line.buyer.shares ?? null,
       last: line.buyer.lastBuy,
     }));
@@ -211,6 +228,7 @@ function signalRows(payload: InsiderSignalsPayload): HeadlessPaneRow[] {
       insiders: row.insiders,
       buys: row.buys,
       value: row.value,
+      currency: FORM4_CURRENCY,
       shares: row.shares,
       firstBuy: row.firstBuy,
       lastBuy: row.lastBuy,
@@ -251,6 +269,8 @@ function amendmentNote(entry: ParsedInsiderFiling): string {
 }
 
 export interface InsiderHeadlessDependencies {
+  /** Daily FX closes for values in a base currency other than USD; the report's API client unless a test stands in. */
+  fxHistory?: FxHistoryClient;
   loadSignals?(query: InsiderSignalsQuery, limit: number, ctx: HeadlessPaneContext): Promise<InsiderSignalsPayload>;
   loadCompany?(query: InsiderCompanyQuery, ctx: HeadlessPaneContext): Promise<InsiderCompanyActivity>;
   loadParsed(
@@ -441,9 +461,9 @@ export function createInsiderHeadless(
         const payload = await (dependencies.loadSignals ?? defaultDependencies.loadSignals!)(query, Number(args.options.limit), ctx);
         const side = payload.side ?? "buy";
         return {
-          columns: signalColumns(side),
+          columns: labelDollarColumns(signalColumns(side), ["value"], ctx.config.baseCurrency),
           // The exports carry each row's insiders; the text leaves them to fn INS <ticker> --view insiders.
-          textColumns: signalColumns(side).filter((column) => column.key !== "buyers"),
+          textColumns: labelDollarColumns(signalColumns(side).filter((column) => column.key !== "buyers"), ["value"], ctx.config.baseCurrency),
           rows: signalRows(payload),
           ...(payload.rows.length === 0 ? { empty: insiderSignalsEmptyTitle(payload.window, side, insiderSignalsFiltered(query)) } : {}),
           metadata: {
@@ -472,7 +492,7 @@ export function createInsiderHeadless(
           .filter((notice): notice is string => !!notice))];
         const rows = insidersRows(activity, side);
         return {
-          columns: INSIDERS_COLUMNS,
+          columns: labelDollarColumns(INSIDERS_COLUMNS, ["bought", "sold"], ctx.config.baseCurrency),
           rows,
           ...(rows.length === 0 ? { empty: insiderActivityEmptyTitle(window) } : {}),
           metadata: {
@@ -503,12 +523,17 @@ export function createInsiderHeadless(
         .filter((row) => row.status !== "parsed" && row.status !== "disclosure")
         .map((row) => row.accessionNumber))];
       // A filing's lines sit together, so its note goes once, under the last of them.
-      const rows: HeadlessPaneRow[] = buildInsiderRows(filtered, parsed).map((row, index) => {
+      const filed: HeadlessPaneRow[] = buildInsiderRows(filtered, parsed).map((row, index) => {
         const entry = filtered[index]!;
         const last = filtered[index + 1]?.filing.accessionNumber !== entry.filing.accessionNumber;
         return isAmendedInsiderFiling(entry) && last ? { ...row, note: amendmentNote(entry) || null } : row;
       });
+      // Every value says its currency; a base currency other than USD gets each value converted beside it.
+      const based = await withInsiderBaseValues(filed, ctx.config.baseCurrency, dependencies.fxHistory ?? ctx.apiClient);
+      const rows = based.rows;
       return {
+        ...(based.columns ? { columns: withMoneyColumns(based.columns) } : {}),
+        ...(based.note ? { notes: [based.note] } : {}),
         rows,
         // Nothing at all: the company has no Form 4 of its own, which is the whole answer.
         ...(empty ? { empty, unavailableSymbols: [] } : {}),

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

@@ -183,11 +183,11 @@ export const jobsHeadless: HeadlessPaneDefinition<"bundle"> = {
     const symbol = args.symbols[0];
     if (symbol) {
       const state = await fetchJobs(symbol, { force: true, client: ctx.apiClient as JobsCloudClient });
-      if (state.kind === "denied") throw explainRefusal(new ApiRequestError(state.message, state.status), jobsLockNote, { symbol });
+      if (state.kind === "denied") throw await explainRefusal(new ApiRequestError(state.message, state.status), jobsLockNote, { symbol, context: ctx });
       return companyBundle(symbol, state, limit);
     }
     const payload = await fetchJobsMovers(ctx.apiClient as JobsCloudClient)
-      .catch((error: unknown) => { throw explainRefusal(error, jobsLockNote, { symbol: null }); });
+      .catch(async (error: unknown) => { throw await explainRefusal(error, jobsLockNote, { symbol: null }); });
     const rows = buildMoverRows(payload.movers).slice(0, Math.max(limit, 15)).map((row) => ({
       ticker: row.ticker,
       company: row.company,

package/src/plugins/builtin/jobs/lock-note.ts

@@ -1,16 +1,27 @@
 import type { PaneLock } from "../../../types/plugin";
-import { proLockNote } from "../shared/pro-lock-note";
+import type { HiringPayload } from "../../../api-client/hiring";
+import { fetchAttention } from "../company-attention/client";
+import { proLockNote, type FreeRoute } from "../shared/pro-lock-note";
+
+/** HIRE's preview, for a company whose careers system it reads: Coffee Holding (JVA) is mapped but uncovered. */
+const HIRE_ROUTE: FreeRoute = {
+  text: (ticker, company) => `gloomberb fn HIRE ${ticker} previews ${company}'s hiring with its latest roles, without the full history.`,
+  answers: async (symbol, context) => {
+    const data = await fetchAttention("hiring", symbol, { limit: 1 }, context.apiClient, context.signal) as HiringPayload;
+    return data.evidence.length + data.series.length + data.functions.length > 0;
+  },
+};
 
 /**
  * JOBS is Pro whole. HIRE reads the same careers systems and needs no
  * account: a company's latest roles, without the full history.
  */
-export function jobsLockNote(lock: PaneLock): string {
+export function jobsLockNote(lock: PaneLock): Promise<string> {
   return proLockNote(lock, {
     token: "JOBS",
     argument: "optional",
     does: "it reads each company's careers system into open roles, hiring pace and the mix by function and country",
     shows: "it",
-    free: (ticker, company) => `gloomberb fn HIRE ${ticker} previews ${company}'s hiring with its latest roles, without the full history.`,
+    free: [HIRE_ROUTE],
   });
 }

package/src/plugins/builtin/market-halts/model.ts

@@ -180,14 +180,33 @@ const DAY_MS = 86_400_000;
 /** Unresolved halts move out of the recent views at 30 elapsed days. */
 const LONG_TERM_MS = 30 * DAY_MS;
 
-export function formatHaltAge(record: HaltRecord, now: number): string {
+/** How long a halt has kept trading stopped: to the trade resumption, or to now while it lasts. Quotes resuming do not end it. */
+function haltDurationMs(record: HaltRecord, now: number): number {
   const end = record.tradeResumeAt == null ? now : Math.min(now, record.tradeResumeAt);
-  const elapsed = Math.max(0, end - record.haltedAt);
+  return Math.max(0, end - record.haltedAt);
+}
+
+/** How long since the halt began, whether or not trading has resumed. */
+function haltAgeMs(record: HaltRecord, now: number): number {
+  return Math.max(0, now - record.haltedAt);
+}
+
+function formatElapsed(elapsed: number): string {
   if (elapsed >= DAY_MS) return `${Math.floor(elapsed / DAY_MS)}d`;
   if (elapsed >= 3_600_000) return `${Math.floor(elapsed / 3_600_000)}h`;
   return `${Math.floor(elapsed / 60_000)}m`;
 }
 
+/** HALTED FOR: RAIL halted 16:40 and resumed 17:15 was halted for 35m, read at any later time. */
+export function formatHaltDuration(record: HaltRecord, now: number): string {
+  return formatElapsed(haltDurationMs(record, now));
+}
+
+/** AGE: RAIL's 16:40 halt is 1h old at 17:45, though it lasted 35m. */
+export function formatHaltAge(record: HaltRecord, now: number): string {
+  return formatElapsed(haltAgeMs(record, now));
+}
+
 export const HALT_FILTERS: ReadonlyArray<{ label: string; value: HaltFilter }> = [
   { label: "All", value: "all" },
   { label: "Active", value: "active" },
@@ -221,6 +240,7 @@ export type HaltColumnId =
   | "halted"
   | "quote"
   | "trade"
+  | "duration"
   | "status";
 
 export type HaltColumn = DataTableColumn & { id: HaltColumnId };
@@ -235,6 +255,7 @@ export const HALT_SORT_COLUMN_IDS: readonly HaltColumnId[] = [
   "halted",
   "quote",
   "trade",
+  "duration",
   "status",
 ];
 
@@ -262,16 +283,18 @@ const HALT_COLUMNS: readonly HaltColumn[] = [
   { id: "halted", label: "HALT ET", width: 9, align: "left" },
   { id: "quote", label: "QUOTE ET", width: 11, align: "left" },
   { id: "trade", label: "TRADE ET", width: 11, align: "left" },
+  { id: "duration", label: "HALTED FOR", width: 12, align: "right" },
   { id: "status", label: "STATUS", width: 8, align: "left" },
 ];
 
 /**
  * What a narrow pane gives up first, so STATUS never scrolls out of view. MKT
  * is only the venue, STATUS already reads QUOTE once quoting resumes, and
- * REASON spells out CODE. Trade resumption and halt time give way only in
- * the narrowest panes; symbol, reason, halt date, age and status always stay.
+ * REASON spells out CODE. Trade resumption, halt time and then the age, which
+ * the date and halt time also give, go only in the narrowest panes; symbol,
+ * reason, halt date, how long it was halted for and status always stay.
  */
-const NARROW_DROP_ORDER: readonly HaltColumnId[] = ["market", "quote", "code", "company", "trade", "halted"];
+const NARROW_DROP_ORDER: readonly HaltColumnId[] = ["market", "quote", "code", "company", "trade", "halted", "age"];
 
 export function buildHaltColumns(width: number): HaltColumn[] {
   const columns = fitChartTableColumns(HALT_COLUMNS, width, NARROW_DROP_ORDER);
@@ -304,7 +327,9 @@ function haltSortValue(columnId: HaltColumnId, record: HaltRecord, now: number):
     case "halted":
       return record.haltedAt;
     case "age":
-      return Math.max(0, Math.min(now, record.tradeResumeAt ?? now) - record.haltedAt);
+      return haltAgeMs(record, now);
+    case "duration":
+      return haltDurationMs(record, now);
     case "quote":
       return record.quoteResumeAt;
     case "trade":

package/src/plugins/builtin/market-halts/pane.tsx

@@ -29,6 +29,7 @@ import {
   formatEtResumption,
   formatEtTime,
   formatHaltAge,
+  formatHaltDuration,
   haltStatusColor,
   haltStatusLabel,
   nextHaltFilter,
@@ -179,6 +180,8 @@ export function MarketHaltsPane({ focused, width, height }: PaneProps) {
           text: formatEtResumption(row.tradeResumeAt, row.haltedAt),
           color: selectedColor ?? colors.textDim,
         };
+      case "duration":
+        return { text: formatHaltDuration(row, now), color: selectedColor ?? colors.textMuted };
       case "status": {
         const rowStatus = resolveHaltStatus(row, now);
         return {

package/src/plugins/builtin/market-movers/client.ts

@@ -110,10 +110,10 @@ export async function loadMarketMoverTab(
   return { ...result, quotes: quotes.slice(0, LIST_ROWS), rankedBy, tab };
 }
 
-/** The server refused the list for the account's plan. */
+/** The server refused the list for the account's plan (gaps, without Pro). */
 export class SessionMoversAccessError extends Error {
   constructor() {
-    super("Pre-market, after-hours and gap lists need Pro");
+    super("Gap lists need Pro");
     this.name = "SessionMoversAccessError";
   }
 }

package/src/plugins/builtin/market-movers/index.tsx

@@ -8,7 +8,6 @@ import type { PluginModule } from "../plugin-module";
 import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
 import { publicTickerKey } from "../../../utils/exchanges";
 import { usePaneSettingValue } from "../../../state/app/context";
-import { usePlanAccess } from "../../../api-client/plan-access";
 import { useAssetData, usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { useAutoRefresh } from "../../../react/auto-refresh";
@@ -87,7 +86,6 @@ function MarketMoversPane({ focused, width, height }: PaneProps) {
   const [savedTab, setSavedTab] = usePluginPaneState<TabId>("activeTab", tabs[0]!.id);
   const [pickedIn, setPickedIn] = usePluginPaneState<string | null>("activeTabSession", null);
   const [requestedTab, setRequestedTab] = usePluginPaneState<TabId | null>("requestedTab", null);
-  const access = usePlanAccess();
   const session = useUsSession();
   const tabIds = useMemo(() => tabs.map((tab) => tab.id), [tabs]);
   const activeTab = resolveActiveTab({
@@ -96,7 +94,6 @@ function MarketMoversPane({ focused, width, height }: PaneProps) {
     pickedIn,
     session,
     requested: requestedTab,
-    sessionListsOpen: access.signedIn && access.emailVerified && access.hasProAccess,
   });
 
   // The index summary is a quote board like any other, so it runs on the shared

package/src/plugins/builtin/market-movers/session-body.tsx

@@ -24,6 +24,7 @@ import { summaryFooterSegments } from "./footer";
 import type { MarketSummaryQuote } from "./screener";
 import {
   earlierSessionLabel,
+  listAsOfLabel,
   overlaySessionMovers,
   resolveSide,
   sessionListIsLive,
@@ -46,7 +47,13 @@ interface LoadedList {
   payload: CloudSessionMoversPayload;
 }
 
-/** Pre-market, after-hours and gap lists: Pro only, like the ranked lists they sit beside. */
+/**
+ * Pre-market, after-hours and gap lists. Pre-market and after hours open on
+ * every plan: without Pro the server answers with the list as it was built a
+ * delay before (`access: "delayed"`), as old as the account's quotes, and the
+ * footer gives that time. Gaps are Pro only, like the ranked lists they sit
+ * beside.
+ */
 export function SessionMoversBody(props: {
   view: CloudSessionMoversCategory;
   session: UsSession;
@@ -57,29 +64,31 @@ export function SessionMoversBody(props: {
   liveStreaming: boolean;
 }) {
   const access = usePlanAccess();
+  const proOnly = props.view === "gaps";
   const [denied, setDenied] = useState(false);
   const deny = useCallback(() => setDenied(true), []);
   // A refusal is about the plan the account had then; a new plan asks again.
   useEffect(() => setDenied(false), [access.signedIn, access.emailVerified, access.hasProAccess]);
-  const entitled = access.emailVerified && access.hasProAccess && !denied;
+  const entitled = !proOnly || (access.emailVerified && access.hasProAccess && !denied);
   // Behind a wall the footer still carries the index summary; the list registers its own.
   usePaneFooter("market-movers-wall", () => (
     entitled ? null : { info: summaryFooterSegments(props.summaryQuotes) }
   ), [entitled, props.summaryQuotes]);
 
-  if (!access.signedIn) return <SignInWall placement="most-signin" width={props.width} height={props.height} action="see pre-market, after-hours and gap movers" />;
-  if (!access.emailVerified) return <SignInWall placement="most-signin" width={props.width} height={props.height} action="see pre-market, after-hours and gap movers" needsVerification />;
+  if (proOnly && !access.signedIn) return <SignInWall placement="most-signin" width={props.width} height={props.height} action="see gap movers" />;
+  if (proOnly && !access.emailVerified) return <SignInWall placement="most-signin" width={props.width} height={props.height} action="see gap movers" needsVerification />;
   if (!entitled) {
     return (
       <ProWall
         placement="most-wall"
         width={props.width} height={props.height}
-        title="Pre-market, after-hours and gap movers are part of Gloom Cloud Pro."
-        message="The whole listed US market from 04:00 to 20:00, with relative volume, VWAP, float and catalysts."
+        title="Gap movers are part of Gloom Cloud Pro."
+        message="Every listed US stock that opened away from its prior close, with relative volume, VWAP, float and catalysts."
       />
     );
   }
-  return <SessionMoversTable {...props} onDenied={deny} />;
+  // A new plan reads the list again: live with Pro, a delay before without.
+  return <SessionMoversTable key={access.hasProAccess ? "pro" : "free"} {...props} onDenied={proOnly ? deny : undefined} />;
 }
 
 function SessionMoversTable({ view, session, focused, width, summaryQuotes, liveStreaming, onDenied }: {
@@ -89,7 +98,8 @@ function SessionMoversTable({ view, session, focused, width, summaryQuotes, live
   width: number;
   summaryQuotes: MarketSummaryQuote[];
   liveStreaming: boolean;
-  onDenied: () => void;
+  /** Gaps: the server refused the list for the account's plan. */
+  onDenied?: () => void;
 }) {
   const { pinTicker } = usePluginTickerActions();
   const [savedSide, setSavedSide] = usePluginPaneState<CloudSessionMoversSide>("sessionSide", "up");
@@ -106,7 +116,10 @@ function SessionMoversTable({ view, session, focused, width, summaryQuotes, live
 
   const payload = loaded?.key === listKey ? loaded.payload : null;
   const listRows = payload?.items ?? NO_ROWS;
-  const live = !!payload && sessionListIsLive(view, payload.session, session);
+  // A free account's list is the one built a delay before: no live prices on its rows.
+  const delayed = payload?.access === "delayed";
+  const sessionTrading = !!payload && sessionListIsLive(view, payload.session, session);
+  const live = sessionTrading && !delayed;
   // While the list's session trades it is rebuilt every minute, and a failed or
   // stale answer is asked for again as often; a finished list does not change,
   // so it follows the refresh interval the user set.
@@ -126,7 +139,7 @@ function SessionMoversTable({ view, session, focused, width, summaryQuotes, live
       setLastLoadedAt(Date.now());
     } catch (error) {
       if (fetchGenRef.current !== gen) return;
-      if (error instanceof SessionMoversAccessError) {
+      if (error instanceof SessionMoversAccessError && onDenied) {
         onDenied();
         return;
       }
@@ -172,11 +185,14 @@ function SessionMoversTable({ view, session, focused, width, summaryQuotes, live
   }, [rows, selectedId]);
 
   const sessionLabel = payload ? earlierSessionLabel(payload.session, session) : null;
+  // While its session trades, a free list says when it was built; a finished one is final and its date says enough.
+  const asOfLabel = payload && delayed && sessionTrading ? listAsOfLabel(payload.asOf, payload.session, session) : null;
   usePaneFooter("market-movers", () => ({
     info: [
       ...(loadError ? [{ id: "load-error", parts: [{ text: loadError, tone: "warning" as const }] }] : []),
       ...summaryFooterSegments(summaryQuotes),
       ...(sessionLabel ? [{ id: "session", parts: [{ text: sessionLabel, tone: "muted" as const }] }] : []),
+      ...(asOfLabel ? [{ id: "as-of", asOf: true, parts: [{ text: asOfLabel, tone: "muted" as const }] }] : []),
       ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
       ...(feedStatus ? [{
         id: "feed",
@@ -184,7 +200,7 @@ function SessionMoversTable({ view, session, focused, width, summaryQuotes, live
       }] : []),
       ...(payload?.stale ? [{ id: "stale", parts: [{ text: "stale", tone: "muted" as const }] }] : []),
     ],
-  }), [feedStatus, loadError, loading, payload?.stale, sessionLabel, summaryQuotes]);
+  }), [asOfLabel, feedStatus, loadError, loading, payload?.stale, sessionLabel, summaryQuotes]);
 
   const openRow = useCallback((row: SessionMoverRow) => {
     pinTicker(rowKey(row), { floating: true, paneType: TICKER_RESEARCH_PANE_ID, instrument: null });

package/src/plugins/builtin/market-movers/session.ts

@@ -11,7 +11,7 @@ import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors"
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { Quote } from "../../../types/financials";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
-import { zonedDateKey, zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
+import { zonedDateKey, zonedDateTimeParts, zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
 import type { SessionTabId } from "./model";
 
 const NEW_YORK = "America/New_York";
@@ -67,9 +67,8 @@ export function usSessionAt(now: number): UsSession {
  * stays while the session it was picked in lasts; otherwise the pane follows
  * the session that is trading: Pre-market before 09:30, the day's lists during
  * the regular session, After hours after the close. Overnight and on closed
- * days the last pick stands. An account that cannot open the session lists
- * (signed out, unverified, free) keeps the day's lists instead of being moved
- * onto a wall.
+ * days the last pick stands. Every plan opens the two lists it follows, a
+ * free one as of a delay before (session-body.tsx).
  */
 export function resolveActiveTab<T extends string>(args: {
   tabs: readonly T[];
@@ -77,14 +76,13 @@ export function resolveActiveTab<T extends string>(args: {
   pickedIn: string | null | undefined;
   session: UsSession;
   requested?: string | null;
-  sessionListsOpen: boolean;
 }): T {
   const { tabs, session } = args;
   const requested = tabs.find((tab) => tab === args.requested);
   if (requested) return requested;
   const saved = tabs.find((tab) => tab === args.saved) ?? tabs[0]!;
   if (session.phase === "closed" || args.pickedIn === session.key) return saved;
-  if (session.phase === "regular" || !args.sessionListsOpen) {
+  if (session.phase === "regular") {
     return REGULAR_TABS.has(saved) ? saved : tabs.find((tab) => REGULAR_TABS.has(tab)) ?? saved;
   }
   const sessionTab = session.phase === "pre" ? "premarket" : "afterhours";
@@ -223,11 +221,28 @@ export function sortSessionRows(rows: SessionMoverRow[], preference: SessionMove
   return [...rows].sort((left, right) => compareSortValues(sortValue(columnId, left), sortValue(columnId, right), preference.direction));
 }
 
+function shortDay(date: string): string | null {
+  const day = new Date(`${date}T12:00:00Z`);
+  return Number.isFinite(day.getTime())
+    ? day.toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" })
+    : null;
+}
+
 /** The session date when it is not today's, e.g. last evening's after-hours list. */
 export function earlierSessionLabel(listSession: string | null, session: UsSession): string | null {
   if (!listSession || listSession === session.date) return null;
-  const date = new Date(`${listSession}T12:00:00Z`);
-  return Number.isFinite(date.getTime())
-    ? date.toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" })
-    : null;
+  return shortDay(listSession);
+}
+
+/**
+ * When a free account's list was built, New York time: "as of 07:42 ET", and
+ * "as of Oct 19 19:58 ET" when that is not on the list's own session day.
+ */
+export function listAsOfLabel(asOf: string, listSession: string | null, session: UsSession): string | null {
+  const at = Date.parse(asOf);
+  if (!Number.isFinite(at)) return null;
+  const { hour, minute } = zonedDateTimeParts(at, NEW_YORK);
+  const clock = `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")} ET`;
+  const day = zonedDateKey(at, NEW_YORK);
+  return day === (listSession ?? session.date) ? `as of ${clock}` : `as of ${shortDay(day) ?? day} ${clock}`;
 }

package/src/plugins/builtin/market-valuation/pane.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from "react";
 import {
+  DELAYED_SEGMENT,
   PaneStatusBody, type DataTableCell,
   type DataTableColumn,
   type PaneFooterSegment
@@ -140,7 +141,7 @@ export function MarketValuationPane({ focused, width, height }: PaneProps) {
     if (!selectedView) return [];
     const info: PaneFooterSegment[] = [
       { id: "as-of", parts: [{ text: `as of ${selectedView.asOf}`, tone: "muted" }] },
-      ...(width >= 80 ? [{ id: "delayed", parts: [{ text: "delayed", tone: "muted" as const }] }] : []),
+      ...(width >= 80 ? [DELAYED_SEGMENT] : []),
     ];
     if (selectedView.observationStale) {
       info.push({ id: "stale", parts: [{ text: "STALE", tone: "warning", bold: true }] });

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

@@ -1,6 +1,6 @@
 import { useCallback, useMemo, useRef, useState } from "react";
 import type { FundChange, FundMember } from "../../../api-client/members";
-import { DataTableStackView, DataTableView, DetailScrollBody, EmptyState, KeyValueRow, PaneFooterScope, PaneStatusBody, Prose, QueryBar, StatGrid,
+import { delayedFooterSegment, DataTableStackView, DataTableView, DetailScrollBody, EmptyState, KeyValueRow, PaneFooterScope, PaneStatusBody, Prose, QueryBar, StatGrid,
   isSectionedItemRow, renderSectionedRowHeader, useExternalLinkFooter, usePaneNoticeFooter, usePaneStatusFooter, usePaneTabs, useQueryBarSearch,
   type DataTableCell, type DataTableColumn, type PaneFooterSegment, type SectionedRow } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
@@ -49,8 +49,13 @@ function Holdings({ fund, tab, width, height, focused, active }: ViewProps & { t
     return [
       { id: "coverage", parts: [{ text: coverageText(data.aggregate, width < 60), tone: partial ? "warning" : "muted" }] },
       // A capture's status line says the quotes' date and delay too; it does not say returns are unavailable.
-      { id: "quote-date", title: `${date ?? "Quote date unavailable"} · 15m delayed · holdings ${data.asOf}`, quoteStatus: !data.quotesUnavailable,
-        parts: [{ text: data.quotesUnavailable ? "returns unavailable" : width < 60 && dates.length === 1 ? `${date!.slice(5)} delayed` : `${date ? `${date} · ` : ""}15m delayed`, tone: "muted" }] },
+      ...(data.quotesUnavailable
+        ? [{ id: "quote-date", title: `${date ?? "Quote date unavailable"} · 15m delayed · holdings ${data.asOf}`, parts: [{ text: "returns unavailable", tone: "muted" as const }] }]
+        : [
+          delayedFooterSegment({ id: "quote-delay", detail: "15m delayed", delay: "15m", quoteStatus: true }),
+          ...(date ? [{ id: "quote-date", title: `${date} · 15m delayed · holdings ${data.asOf}`, quoteStatus: true,
+            parts: [{ text: width < 60 && dates.length === 1 ? date.slice(5) : date, tone: "muted" as const }] }] : []),
+        ]),
       ...(width >= 60 ? [{ id: "holdings-date", asOf: true, parts: [{ text: `holdings ${data.asOf}`, tone: "muted" as const }] }] : []),
     ];
   }, [data, width]);