gloomberb 0.17.6 → 0.18.0

package/src/plugins/builtin/portfolio-list/cli/render.ts

@@ -16,10 +16,19 @@ import { getPortfolioPositionMetrics, resolvePortfolioMarketValue, resolvePortfo
 import {
   getPortfolioValuationDisplay,
   getPortfolioValuationTime,
-  VALUATION_BASIS_LABELS,
+  valuationBasisLabel,
   valuationTimeIso,
+  valuesAtSettlement,
   type PortfolioValuationBasis,
 } from "../../../../portfolio/valuation-basis";
+import {
+  futuresQuantityText,
+  futuresSettlementDisplay,
+  isFuturesTicker,
+  withFuturesContractSize,
+  type PortfolioFuturesTerms,
+} from "../../../../portfolio/futures-positions";
+import { dailyFuturesHistory, loadPortfolioFuturesTerms, type PortfolioFuturesSources } from "../../../../portfolio/futures-terms";
 import { formatUtcDayTime, parseReportTime } from "../../../../utils/utc-time";
 import { quoteFreshnessFields } from "../../shared/report-freshness";
 import { resolvePortfolioTotalsCurrency } from "../summary/totals";
@@ -33,7 +42,7 @@ import {
   type ExtendedSession,
   type ExtendedSessionDisplay,
 } from "../../../../market-data/market/status";
-import { formatPerpetualRate, headlineQuoteDisplay } from "../column-values";
+import { formatPerpetualRate, headlineQuoteDisplay } from "../../../../portfolio/column-values";
 import type { AppConfig } from "../../../../types/config";
 import type { DataProvider } from "../../../../types/data-provider";
 import type { CliCommandContext } from "../../../../types/plugin";
@@ -63,13 +72,18 @@ import {
   formatAllocationWeight,
   formatTradeUnits,
   hasTargetWeights,
+  lotWeight,
   resolvePortfolioCash,
+  weightBasisNote,
   type AllocationHolding,
   type PortfolioAllocation,
-} from "../allocation";
+} from "../../../../portfolio/allocation";
 import { findCachedPortfolioAccount } from "../cached-account";
 import { importedFromText } from "../imported-from";
 import { findNamedCollection } from "../../../../portfolio/collection-name";
+import { isoDateToday } from "../../../../utils/calendar-date";
+import { lastTradeDate } from "../../../../tickers/listing-fate";
+import { DIVIDEND_READ_DEADLINE_MS, incomeGapNote, loadHoldingDividends, portfolioIncome, projectDrip, type DripYear, type HoldingDividend } from "../income";
 
 /** Money prices pad to the currency's minor unit ($337.90, not $337.9), as the ticker view does. */
 function priceFormatOptions(quote: Parameters<typeof quoteFormatOptions>[0] & { currency?: string }, assetCategory?: string) {
@@ -180,6 +194,12 @@ export interface ShowCollectionOptions {
   explain?: boolean;
   /** What a portfolio's value is priced at; the latest print when absent. */
   basis?: PortfolioValuationBasis;
+  /** `--drip`: project reinvested dividends this many years, with this percent withheld from each. */
+  drip?: { years: number; withholding: number };
+  /** How long every holding's dividend read may take together; a test shortens it. */
+  dividendDeadlineMs?: number;
+  /** Where futures' terms and settlements are read; Gloom Cloud's terms and the data provider's daily bars by default. */
+  futuresSources?: PortfolioFuturesSources;
 }
 
 export async function showCollection(name: string, ctx: CliCommandContext, options: ShowCollectionOptions = {}) {
@@ -260,6 +280,8 @@ interface PortfolioPositionValue {
   dayMove: { change: number; previousValue: number } | null;
   /** The `portfolio show --json` row. */
   row: Record<string, unknown>;
+  /** A future's contract size and settlement from its terms; null for any other holding. */
+  futures: PortfolioFuturesTerms | null;
 }
 
 /** What a row's value is priced at: exported after every other field, so existing columns keep their places. */
@@ -269,6 +291,8 @@ interface PortfolioValuationFields {
   valuationPrice: number | null;
   /** An ISO instant in UTC, or an ISO date for a close whose hour the venue's calendar does not give. */
   valuationAsOf: string | null;
+  /** Only on a future valued at its exchange settlement, which `valuationAsOf` dates by its session. */
+  valuationPriceKind?: "settle";
 }
 
 export interface PortfolioValuation {
@@ -281,13 +305,40 @@ export interface PortfolioValuation {
   unavailableCost: Set<string>;
   unavailableMarketValue: Set<string>;
   brokerPnlSymbols: Set<string>;
+  /** Futures held without a contract size: no value, cost or P&L, said once instead of as each. */
+  unknownContractSize: Set<string>;
+  /** Futures valued at the close without a confirmed settlement to value them at. */
+  unsettled: Set<string>;
+  /** Long and short market value of the priced lots, and their net and gross, in the portfolio's currency. */
+  exposure: PortfolioExposure;
+}
+
+/** A book's exposure: what its longs and its shorts are worth (short negative), net and gross. */
+export interface PortfolioExposure {
+  long: number;
+  short: number;
+  net: number;
+  gross: number;
+}
+
+/** The exposure of lots at their signed market values; an unpriced lot (null) is left out, as the total leaves it. */
+function portfolioExposure(values: Iterable<number | null | undefined>): PortfolioExposure {
+  let long = 0;
+  let short = 0;
+  for (const value of values) {
+    if (value == null || !Number.isFinite(value)) continue;
+    if (value >= 0) long += value;
+    else short += value;
+  }
+  return { long, short, net: long + short, gross: long - short };
 }
 
 /**
  * Values every position of a portfolio in the portfolio's currency, as
  * `portfolio show` prints it: cost basis, market value and unrealized P&L
  * from the current quote at `basis` (the latest print unless given), or the
- * broker's snapshot where that is the basis.
+ * broker's snapshot where that is the basis. A future counts contracts of the
+ * size `futures` gives for it, and at the close is valued at its settlement.
  */
 export async function valuePortfolioPositions({
   tickers,
@@ -297,6 +348,7 @@ export async function valuePortfolioPositions({
   baseCurrency,
   toBase,
   basis = "latest-print",
+  futures,
 }: {
   tickers: readonly TickerRecord[];
   quotes: ReadonlyMap<string, CollectionQuote>;
@@ -305,6 +357,8 @@ export async function valuePortfolioPositions({
   baseCurrency: string;
   toBase: (value: number, fromCurrency: string) => Promise<number>;
   basis?: PortfolioValuationBasis;
+  /** Each future's contract size and settlement (loadPortfolioFuturesTerms), by symbol. */
+  futures?: ReadonlyMap<string, PortfolioFuturesTerms>;
 }): Promise<PortfolioValuation> {
   const id = portfolioId;
   let totalPnl = 0;
@@ -312,16 +366,23 @@ export async function valuePortfolioPositions({
   const unavailableCost = new Set<string>();
   const unavailableMarketValue = new Set<string>();
   const brokerPnlSymbols = new Set<string>();
+  const unknownContractSize = new Set<string>();
+  const unsettled = new Set<string>();
   const values: PortfolioPositionValue[] = [];
   const holdings: AllocationHolding[] = [];
   const known = (value: number | null | undefined): number | null => value != null && Number.isFinite(value) ? value : null;
 
   for (const ticker of tickers) {
     const quote = quotes.get(ticker.metadata.ticker);
-    const positions = ticker.metadata.positions.filter((position) => position.portfolio === id && position.shares !== 0);
+    const futuresTerms = isFuturesTicker(ticker) ? futures?.get(ticker.metadata.ticker) ?? { size: null, settlement: null } : null;
+    // A lot entered without its contract size takes the one the terms state; the entries keep the saved record.
+    const sized = withFuturesContractSize(ticker, futuresTerms?.size);
+    const positions = sized.metadata.positions.filter((position) => position.portfolio === id && position.shares !== 0);
     const displayedQuote = getActiveQuoteDisplay(quote);
     const activeQuote = displayedQuote && Number.isFinite(displayedQuote.price) ? displayedQuote : null;
-    const { headline, extended } = collectionQuoteHeadline(quote);
+    // At the close a future's Last is the settlement it is valued at, and its move the one from the settlement before.
+    const settledHeadline = basis === "regular-close" && futuresTerms?.settlement ? futuresSettlementDisplay(futuresTerms.settlement) : null;
+    const { headline, extended } = settledHeadline ? { headline: settledHeadline, extended: null } : collectionQuoteHeadline(quote);
 
     if (positions.length === 0) {
       const quoteCurrency = quote?.currency || ticker.metadata.currency || baseCurrency;
@@ -329,8 +390,10 @@ export async function valuePortfolioPositions({
       const priced = basis === "regular-close" ? headline : activeQuote;
       const unitPrice = priced ? known(await toBase(priced.price, quoteCurrency)) : null;
       holdings.push({ symbol: ticker.metadata.ticker, held: false, marketValue: 0, units: 0, unitPrice });
-      values.push({ ticker, quote, activeQuote, headline, extended, position: null, metrics: null, pnl: null, dayMove: null,
-        valuation: { valuationBasis: basis, valuationPrice: known(priced?.price), valuationAsOf: valuationTimeIso(getPortfolioValuationTime(quote, basis)) },
+      values.push({ ticker, quote, activeQuote, headline, extended, position: null, metrics: null, pnl: null, dayMove: null, futures: futuresTerms,
+        valuation: { valuationBasis: basis, valuationPrice: known(priced?.price),
+          valuationAsOf: settledHeadline ? futuresTerms!.settlement!.date : valuationTimeIso(getPortfolioValuationTime(quote, basis)),
+          ...(settledHeadline ? { valuationPriceKind: "settle" as const } : {}) },
         row: { symbol: ticker.metadata.ticker, ...listingColumns(ticker, quote), exchange: ticker.metadata.exchange, shares: null, avgCost: null,
           positionCurrency: null, quotePrice: known(headline?.price), ...quoteMoveColumns(headline), ...extendedQuoteFields(extended), quoteCurrency: quote?.currency ?? null,
           volume: known(quote?.volume), costBasis: null, marketValue: null, unrealizedPnl: null, baseCurrency: currency } });
@@ -342,7 +405,9 @@ export async function valuePortfolioPositions({
     for (const position of positions) {
       const quoteCurrency = quote?.currency || ticker.metadata.currency || baseCurrency;
       const metrics = getPortfolioPositionMetrics({ ...ticker, metadata: { ...ticker.metadata, positions: [position] } }, id, quoteCurrency, undefined, quote);
-      const valuationQuote = getPortfolioValuationDisplay(metrics, quote, basis);
+      const settlement = futuresTerms?.settlement ?? null;
+      const valuationQuote = getPortfolioValuationDisplay(metrics, quote, basis, settlement);
+      const atSettlement = valuesAtSettlement(metrics, basis);
       const positionCurrency = metrics.positionCurrency;
       const costBasisBase = positionCurrency ? await toBase(metrics.totalCost, positionCurrency) : Number.NaN;
 
@@ -354,6 +419,8 @@ export async function valuePortfolioPositions({
       const selectedPnl = resolvePortfolioPositionPnl(baseMetrics,
         valuationQuote ? await toBase(valuationQuote.price, quoteCurrency) : null);
       const pnl = selectedPnl.value;
+      if (metrics.unknownContractSize) unknownContractSize.add(ticker.metadata.ticker);
+      else if (atSettlement && !settlement) unsettled.add(ticker.metadata.ticker);
       if (!metrics.hasCostBasis) unavailableCost.add(ticker.metadata.ticker);
       if (known(currentValueBase) === null) unavailableMarketValue.add(ticker.metadata.ticker);
       if (selectedPnl.basis === "broker-snapshot" || selectedPnl.basis === "mixed") brokerPnlSymbols.add(ticker.metadata.ticker);
@@ -369,10 +436,11 @@ export async function valuePortfolioPositions({
         ? { change: await toBase(metrics.totalPriceUnits * change, quoteCurrency),
           previousValue: await toBase(metrics.grossPriceUnits * (valuationQuote.price - change), quoteCurrency) }
         : null;
-      values.push({ ticker, quote, activeQuote, headline, extended, position, metrics, pnl,
+      values.push({ ticker, quote, activeQuote, headline, extended, position, metrics, pnl, futures: futuresTerms,
         dayMove: dayMove && Number.isFinite(dayMove.change) && Number.isFinite(dayMove.previousValue) ? dayMove : null,
         valuation: { valuationBasis: basis, valuationPrice: known(valuationQuote?.price),
-          valuationAsOf: valuationTimeIso(getPortfolioValuationTime(quote, basis, metrics)) },
+          valuationAsOf: valuationTimeIso(getPortfolioValuationTime(quote, basis, metrics, settlement)),
+          ...(atSettlement && settlement ? { valuationPriceKind: "settle" as const } : {}) },
         row: { symbol: ticker.metadata.ticker, ...listingColumns(ticker, quote), exchange: ticker.metadata.exchange,
           shares: metrics.totalShares, avgCost: known(position.avgCost), positionCurrency,
           priceBasis: position.priceBasis ?? null, quantityUnit: metrics.priceBasis === "percent-of-par" ? "face" : null, quotePriceBasis: quote?.priceBasis ?? null,
@@ -385,7 +453,9 @@ export async function valuePortfolioPositions({
     }
   }
 
-  return { basis, positions: values, holdings, totalPnl, unavailablePnl, unavailableCost, unavailableMarketValue, brokerPnlSymbols };
+  const exposure = portfolioExposure(values.map((entry) => entry.position ? entry.row.marketValue as number | null : null));
+  return { basis, positions: values, holdings, totalPnl, unavailablePnl, unavailableCost, unavailableMarketValue, brokerPnlSymbols,
+    unknownContractSize, unsettled, exposure };
 }
 
 /**
@@ -416,6 +486,25 @@ export function dayMoveLine(
   return `Day's move: ${color(`${formatAllocationMoney(move.change, currency, { signed: true })}${percent}`, move.change)}`;
 }
 
+/**
+ * `Exposure: long $600,000, short -$419,800,000, net -$419,200,000, gross $420,400,000`:
+ * what the priced holdings are worth on each side, in whole units, a short negative as every value is.
+ */
+export function exposureLine(exposure: PortfolioExposure, currency: string): string {
+  const money = (value: number) => formatAllocationMoney(value, currency, { whole: true });
+  return `Exposure: long ${money(exposure.long)}, short ${money(exposure.short)}, net ${money(exposure.net)}, gross ${money(exposure.gross)}`;
+}
+
+/** What a hedged book's weights divide, in whole units as the exposure line states it; null for a book weighed on its total. */
+export function weightBasisLine(allocation: Pick<PortfolioAllocation, "weightBasis" | "weightBase">, currency: string): string | null {
+  return weightBasisNote(allocation, (value) => formatAllocationMoney(value, currency, { whole: true }));
+}
+
+/** What the TOTAL row weighs: all of a total; nothing on a gross base, where the weights net to the book's net over its gross. */
+function totalWeight(allocation: Pick<PortfolioAllocation, "weightBasis" | "total">): number | null {
+  return allocation.weightBasis === "total" && allocation.total != null && allocation.total > 0 ? 100 : null;
+}
+
 /** A portfolio's cash line, as `portfolio show` and `fn PF` report it. */
 export interface PortfolioCashReport {
   /** In the cash's own currency. */
@@ -512,30 +601,49 @@ function portfolioValuationFreshness(
     source,
     observedKey: "valuationAsOf",
     citeOldest: true,
-    ...(note ? { note: `priced at ${VALUATION_BASIS_LABELS[valuation.basis]}` } : {}),
+    ...(note ? { note: `priced at ${valuationBasisLabel(valuation.basis, { futures: holdsFutures(valuation) })}` } : {}),
   }, undefined, now);
 }
 
+/** Whether a valued book holds a future, whose price at the close is its settlement. */
+export function holdsFutures(valuation: Pick<PortfolioValuation, "positions">): boolean {
+  return valuation.positions.some((entry) => entry.position && entry.futures);
+}
+
 /** `Priced at the latest print, extended hours included`: the line under a portfolio's title. */
-function valuationBasisLine(basis: PortfolioValuationBasis): string {
-  return `Priced at ${VALUATION_BASIS_LABELS[basis]}`;
+function valuationBasisLine(basis: PortfolioValuationBasis, futures: boolean): string {
+  return `Priced at ${valuationBasisLabel(basis, { futures })}`;
 }
 
 /**
  * An As of cell: when the price a row's value uses is from (`valuationAsOf`),
- * in UTC as its header says; a close dated only by its day says so.
+ * in UTC as its header says; a close dated only by its day says so, and a
+ * future's settlement names its session.
  */
-export function valuationTimeText(value: unknown, now = Date.now()): string {
+export function valuationTimeText(value: unknown, now = Date.now(), kind?: "settle"): string {
   const time = parseReportTime(value);
   if (!time) return "—";
-  return time.dateOnly ? `${formatUtcDayTime(time, now)} close` : formatUtcDayTime(time, now);
+  return time.dateOnly ? `${formatUtcDayTime(time, now)} ${kind ?? "close"}` : formatUtcDayTime(time, now);
+}
+
+/** A yield in percent with two decimals, as DVD shows one: 2.31%. */
+function formatIncomeYield(value: number | null | undefined): string {
+  return value != null && Number.isFinite(value) ? `${value.toFixed(2)}%` : "—";
+}
+
+/** One holding's projected years, for the DRIP table and its export. */
+interface DripProjection {
+  ticker: TickerRecord;
+  dividend: HoldingDividend & { perShare: number; currency: string; price: number };
+  shares: number;
+  years: DripYear[];
 }
 
 async function showCollectionWithMarketData(
   name: string,
   ctx: CliCommandContext,
   { config, store, dataProvider, persistence }: MarketContext,
-  { explain = false, basis = "latest-print" }: ShowCollectionOptions,
+  { explain = false, basis = "latest-print", drip, dividendDeadlineMs = DIVIDEND_READ_DEADLINE_MS, futuresSources }: ShowCollectionOptions,
 ) {
   const tickers = (await store.loadAllTickers()).sort((left, right) =>
     left.metadata.ticker.localeCompare(right.metadata.ticker)
@@ -553,6 +661,9 @@ async function showCollectionWithMarketData(
   if (!matchedPortfolio && basis === "regular-close") {
     ctx.fail(`--close values a portfolio; "${collection.name}" is a watchlist.`, "Usage: gloomberb portfolio show <portfolio> --close");
   }
+  if (!matchedPortfolio && drip) {
+    ctx.fail(`--drip projects a portfolio's dividends; "${collection.name}" is a watchlist.`, "Usage: gloomberb portfolio show <portfolio> --drip");
+  }
   const isPortfolio = !!matchedPortfolio;
   const id = collection.id;
   const displayName = collection.name;
@@ -575,24 +686,34 @@ async function showCollectionWithMarketData(
   // The terms the report shows, which --explain follows it with.
   let explained: GlossaryEntry[] = [];
 
-  const quotes = await loadCollectionQuotes(filtered, collection, dataProvider);
+  const futuresHeld = filtered.filter((ticker) => isFuturesTicker(ticker)
+    && ticker.metadata.positions.some((position) => position.portfolio === id && position.shares !== 0));
+  const [quotes, futures] = await Promise.all([
+    loadCollectionQuotes(filtered, collection, dataProvider),
+    isPortfolio ? loadPortfolioFuturesTerms(futuresHeld, {
+      settlement: basis === "regular-close",
+      sources: { history: dailyFuturesHistory(dataProvider), ...futuresSources },
+    }) : undefined,
+  ]);
   // Worst of across the holdings' quotes, as the PORT and watchlist reports state it.
   const broker = !!(matchedPortfolio?.brokerId || matchedPortfolio?.brokerInstanceId);
   const source = !isPortfolio ? "Local watchlist and Gloom Cloud"
     : broker ? "Your broker account and Gloom Cloud" : "Local portfolio and Gloom Cloud";
   let freshness = isPortfolio ? undefined : quotesFreshness(quotes.values(), { source });
+  // A watchlist's stale rows, named under the closing line that counts them.
+  let staleNote: string | null = null;
 
   if (!structured) {
     console.log(cliStyles.bold(displayName + (isPortfolio ? ` (${currency})` : "")));
     console.log(cliStyles.muted(`${filtered.length} ticker${filtered.length === 1 ? "" : "s"}`));
     const imported = matchedPortfolio ? importedFromText(matchedPortfolio) : null;
     if (imported) console.log(cliStyles.muted(imported));
-    if (isPortfolio) console.log(cliStyles.muted(valuationBasisLine(basis)));
+    if (isPortfolio) console.log(cliStyles.muted(valuationBasisLine(basis, futuresHeld.length > 0)));
     console.log("");
   }
 
   if (matchedPortfolio) {
-    const valuation = await valuePortfolioPositions({ tickers: filtered, quotes, portfolioId: id, currency, baseCurrency: config.baseCurrency, toBase, basis });
+    const valuation = await valuePortfolioPositions({ tickers: filtered, quotes, portfolioId: id, currency, baseCurrency: config.baseCurrency, toBase, basis, futures });
     // Exports carry no header line, so their source line names the basis.
     freshness = portfolioValuationFreshness(valuation, source, { note: structured });
     const {
@@ -602,22 +723,45 @@ async function showCollectionWithMarketData(
       unavailableCost,
       unavailableMarketValue,
       brokerPnlSymbols,
+      unknownContractSize,
+      unsettled,
+      exposure,
     } = valuation;
     const { allocation, cash } = await valuePortfolioAllocation({ valuation, portfolio: matchedPortfolio, account, toBase });
     const allocationBySymbol = new Map(allocation.rows.map((row) => [row.symbol, row]));
+    // What each holding pays a year: trailing dividends per share times its shares, in the portfolio's currency.
+    const held = filtered.filter((ticker) => valued.some((entry) => entry.ticker === ticker && entry.position));
+    const { dividends } = await loadHoldingDividends(held, quotes, dataProvider, { deadlineMs: dividendDeadlineMs });
+    // Lots without a position or shares are no lot of income; a row of their own keeps its place with none.
+    const income = await portfolioIncome(valued.map((entry) => ({
+      symbol: entry.position && entry.metrics ? entry.ticker.metadata.ticker : "",
+      shares: entry.metrics?.totalShares ?? 0,
+      value: typeof entry.row.marketValue === "number" ? entry.row.marketValue : null,
+    })), dividends, toBase);
+    const lotIncome = income.lots;
+    const totalIncome = income.totalIncome;
+    const portfolioYield = totalIncome != null && allocation.total != null && allocation.total > 0 ? (totalIncome / allocation.total) * 100 : null;
+    const incomeUnavailable = [...income.gaps].map(([symbol, gap]) => ({ symbol, ...gap }));
     const showTargets = allocation.targetSum != null;
     // Never dropped on a narrow terminal, so --explain reads the terms off them.
     const allocationHeaders = showTargets ? ["Weight", "Target", "Drift", "Trade", "Trade Value"] : ["Weight"];
     explained = reportGlossary("PF", allocationHeaders.join("  "));
-    // A ticker held in several lots carries its allocation on its first row.
+    // A ticker held in several lots carries its allocation, the whole position's, on its first row.
     const firstRows = new Set<string>();
-    const positionsExport = valued.map((entry): Record<string, unknown> & {
+    const lotCounts = new Map<string, number>();
+    for (const entry of valued) {
+      if (entry.position) lotCounts.set(entry.ticker.metadata.ticker, (lotCounts.get(entry.ticker.metadata.ticker) ?? 0) + 1);
+    }
+    const positionsExport = valued.map((entry, index): Record<string, unknown> & {
       weight: number | null; targetWeight: number | null; drift: number | null; tradeShares: number | null; tradeValue: number | null;
+      annualIncome: number | null; incomeYield: number | null;
     } => {
       const symbol = entry.ticker.metadata.ticker;
       const first = !firstRows.has(symbol);
       firstRows.add(symbol);
       const figures = first ? allocationBySymbol.get(symbol) : undefined;
+      const dividend = entry.position ? dividends.get(symbol) : undefined;
+      const lots = lotCounts.get(symbol) ?? 0;
       return {
         ...entry.row,
         weight: figures?.weight ?? null,
@@ -626,6 +770,18 @@ async function showCollectionWithMarketData(
         tradeShares: figures?.tradeUnits ?? null,
         tradeValue: figures?.tradeValue ?? null,
         ...entry.valuation,
+        // After the valuation fields, so every column an export had keeps its place.
+        dividendPerShare: dividend?.perShare ?? null,
+        dividendCurrency: dividend?.currency ?? null,
+        annualIncome: lotIncome[index]?.income ?? null,
+        incomeYield: lotIncome[index]?.yield ?? null,
+        // Only the rows of a ticker held in several lots: `lots` says the allocation on its first row is the whole position's, `lotWeight` is this lot's own share.
+        ...(lots > 1 ? { lots, lotWeight: lotWeight(typeof entry.row.marketValue === "number" ? entry.row.marketValue : null, allocation.weightBase) } : {}),
+        // Only on a future: `shares` counts contracts, each `contractMultiplier` units of the price, as the exchange sizes it.
+        ...(entry.futures && entry.position ? {
+          contractMultiplier: entry.position.multiplier ?? null,
+          contractSize: entry.futures.size?.size ?? null,
+        } : {}),
       };
     });
     const totalPnlValue = unavailablePnl.size > 0 ? null : totalPnl;
@@ -643,28 +799,91 @@ async function showCollectionWithMarketData(
       drift: allocation.cash.drift, tradeValue: allocation.cash.tradeValue,
     } : null;
 
+    // `--drip`: each holding with a known income and a price, its lots netted: a long reinvests, a short owes.
+    const dripNotProjected = new Set<string>();
+    const dripProjections: DripProjection[] = [];
+    if (drip) {
+      for (const ticker of held) {
+        const symbol = ticker.metadata.ticker;
+        const dividend = dividends.get(symbol);
+        if (!dividend) continue;
+        const shares = valued.filter((entry) => entry.ticker === ticker && entry.position && entry.metrics)
+          .reduce((sum, entry) => sum + entry.metrics!.totalShares, 0);
+        if (shares === 0) continue;
+        // Income the table could not show is not projected either; the note under it says why.
+        if (income.gaps.has(symbol) || dividend.perShare == null || !dividend.currency) continue;
+        if (dividend.perShare === 0) continue;
+        if (dividend.price == null || !(dividend.price > 0)) {
+          dripNotProjected.add(symbol);
+          continue;
+        }
+        const rate = await toBase(1, dividend.currency);
+        if (!Number.isFinite(rate) || rate <= 0) {
+          dripNotProjected.add(symbol);
+          continue;
+        }
+        dripProjections.push({
+          ticker, shares,
+          dividend: { ...dividend, perShare: dividend.perShare, currency: dividend.currency, price: dividend.price },
+          years: projectDrip({ symbol, shares, perShare: dividend.perShare, price: dividend.price, rate }, drip),
+        });
+      }
+    }
+    const dripAsOf = isoDateToday();
+    const dripMethod = drip
+      ? `Trailing twelve-month dividends per share, share prices and exchange rates as of ${dripAsOf} held flat; ${drip.withholding}% withheld from each dividend; what is left buys shares once a year, at the year's end. A short owes each dividend in full, every year, and reinvests nothing.`
+      : null;
+
     const accountingBasis = "Unrealized P&L on current positions; excludes realized trades, distributions and cash flows. This is not account investment return.";
     const manualAccounting = !matchedPortfolio.brokerId && !matchedPortfolio.brokerInstanceId
       ? "Manual holdings are snapshots. Reconcile shares and per-share cost after corporate actions using portfolio position set; cash distributions are not credited."
       : null;
+    if (structured && drip) {
+      const rows = dripProjections.flatMap(({ ticker, dividend, years }) => years.map((year) => ({
+        symbol: ticker.metadata.ticker, listing: listingLabel(ticker), year: year.year,
+        shares: year.shares, addedShares: year.addedShares,
+        dividendPerShare: dividend.perShare, dividendCurrency: dividend.currency, price: dividend.price,
+        grossIncome: year.grossIncome, withheld: year.withheld, netIncome: year.netIncome,
+        netIncomeBase: year.netIncomeBase, valueBase: year.valueBase, baseCurrency: currency,
+      })));
+      ctx.printResult({ data: rows, metadata: {
+        portfolioId: id, portfolioName: displayName, baseCurrency: currency,
+        years: drip.years, withholdingPercent: drip.withholding, asOf: dripAsOf, method: dripMethod,
+        annualIncome: totalIncome, knownAnnualIncome: income.knownIncome, portfolioYield,
+        incomeComplete: income.gaps.size === 0, incomeUnavailable,
+        notProjectedSymbols: [...dripNotProjected, ...income.gaps.keys()],
+        complete: income.gaps.size === 0 && dripNotProjected.size === 0,
+      }, freshness });
+      return;
+    }
     if (structured) {
       // CSV and NDJSON read the cash and the total as rows; JSON keeps them in the metadata.
       const extraRows: Record<string, unknown>[] = [
         ...(cashExport ? [{ symbol: CASH_SYMBOL, marketValue: cashExport.value, baseCurrency: currency, weight: cashExport.weight,
           targetWeight: cashExport.targetWeight, drift: cashExport.drift, tradeShares: null, tradeValue: cashExport.tradeValue }] : []),
         { symbol: "TOTAL", marketValue: allocation.total, unrealizedPnl: totalPnlValue, baseCurrency: currency,
-          weight: allocation.total != null && allocation.total > 0 ? 100 : null, targetWeight: allocation.targetSum, valuationBasis: basis },
+          weight: totalWeight(allocation), targetWeight: allocation.targetSum, valuationBasis: basis,
+          annualIncome: totalIncome, incomeYield: portfolioYield },
       ];
       ctx.printResult({ data: positionsExport, metadata: {
         portfolioId: id, portfolioName: displayName, baseCurrency: currency, currency,
         valuationBasis: basis,
         total: allocation.total, cash: cashExport, targetSum: allocation.targetSum,
+        // Only on a book that holds a short: its weights are shares of `weightBase`, its gross exposure, not of the total.
+        ...(allocation.weightBasis === "gross" ? { weightBasis: allocation.weightBasis, weightBase: allocation.weightBase } : {}),
         ...(basis === "regular-close" ? { dayChange: dayMove?.change ?? null, dayChangePercent: dayMove?.changePercent ?? null } : {}),
         unpricedCount: allocation.unpriced.length, unpricedSymbols: allocation.unpriced,
         totalUnrealizedPnl: totalPnlValue,
-        complete: unavailablePnl.size === 0 && unavailableCost.size === 0 && unavailableMarketValue.size === 0,
+        annualIncome: totalIncome, knownAnnualIncome: income.knownIncome, portfolioYield,
+        incomeComplete: income.gaps.size === 0, incomeUnavailable,
+        incomeBasis: "Trailing twelve-month dividends per share times shares held, in the portfolio's currency; a short owes the dividend, so its income is negative. Portfolio yield is the total over the total value; annualIncome is null when any holding's income is unknown, and knownAnnualIncome sums the holdings that have one.",
+        complete: unavailablePnl.size === 0 && unavailableCost.size === 0 && unavailableMarketValue.size === 0 && income.gaps.size === 0,
         unavailableSymbols: [...new Set([...unavailablePnl, ...unavailableCost, ...unavailableMarketValue])],
         unavailableCostSymbols: [...unavailableCost], brokerPnlSymbols: [...brokerPnlSymbols],
+        // The priced holdings' market value: longs, shorts (negative), net and gross. Cash and unpriced holdings are not in it.
+        exposure,
+        ...(unknownContractSize.size > 0 ? { unknownContractSizeSymbols: [...unknownContractSize] } : {}),
+        ...(unsettled.size > 0 ? { unsettledSymbols: [...unsettled] } : {}),
         accountingBasis, ...(manualAccounting ? { manualAccounting } : {}),
         ...(matchedPortfolio.importedFrom ? { importedFrom: matchedPortfolio.importedFrom } : {}),
         ...(explain ? { glossary: glossaryExport(explained) } : {}),
@@ -692,54 +911,85 @@ async function showCollectionWithMarketData(
       return [weight, target, drift, trade, tradeValue];
     };
 
+    // Income and its yield, once any share or fund has one; with none known, the note under the table says why.
+    const showIncome = income.knownHoldings > 0;
+    const incomeCells = (income: number | null | undefined, yieldPercent: number | null | undefined): string[] =>
+      showIncome ? [money(income), formatIncomeYield(yieldPercent)] : [];
     const extendedSessions = extendedSessionsOf(valued.map(({ extended }) => extended?.session));
     const now = Date.now();
-    const rows: string[][] = valued.map(({ ticker, quote, headline, extended, position, metrics, pnl, row, valuation: priced }, index) => {
-      const asOf = valuationTimeText(priced.valuationAsOf, now);
+    // Where each ticker's lots end, to put its position line there.
+    const lastLot = new Map<string, number>();
+    valued.forEach((entry, index) => { if (entry.position) lastLot.set(entry.ticker.metadata.ticker, index); });
+    const rows: string[][] = valued.flatMap(({ ticker, quote, headline, extended, position, metrics, pnl, row, valuation: priced, futures: contract }, index): string[][] => {
+      const asOf = valuationTimeText(priced.valuationAsOf, now, priced.valuationPriceKind);
       const priceText = quote && headline
         ? colorBySign(formatListPrice(headline.price, quote, ticker.metadata.assetCategory), headline.change)
         : "—";
       const changeText = headline ? colorBySign(formatPercentRaw(headline.changePercent), headline.change) : "—";
       const quoteCells = [priceText, changeText, ...extendedCells(extendedSessions, extended, quote, ticker.metadata.assetCategory)];
       const exported = positionsExport[index]!;
-      const figures = exported.weight != null || exported.targetWeight != null || exported.tradeValue != null
-        ? { weight: exported.weight, targetWeight: exported.targetWeight, drift: exported.drift, tradeValue: exported.tradeValue, tradeUnits: exported.tradeShares }
-        : undefined;
-      const symbolUnits = allocationBySymbol.get(ticker.metadata.ticker)?.units ?? 0;
+      const symbol = ticker.metadata.ticker;
+      const lots = lotCounts.get(symbol) ?? 0;
+      // A lot of several weighs by its own value; its target, drift and trade belong to the position, on the line under its lots.
+      const figures = lots > 1
+        ? { weight: exported.lotWeight as number | null, targetWeight: null, drift: null, tradeValue: null, tradeUnits: null }
+        : exported.weight != null || exported.targetWeight != null || exported.tradeValue != null
+          ? { weight: exported.weight, targetWeight: exported.targetWeight, drift: exported.drift, tradeValue: exported.tradeValue, tradeUnits: exported.tradeShares }
+          : undefined;
+      const symbolUnits = allocationBySymbol.get(symbol)?.units ?? 0;
       if (!position || !metrics) {
-        return [listingLabel(ticker), ...quoteCells, "—", "—", "—",
-          ...allocationCells(figures, { unpriced: false, units: symbolUnits, assetCategory: ticker.metadata.assetCategory }), "—", asOf];
+        return [[listingLabel(ticker), ...quoteCells, "—", "—", "—",
+          ...allocationCells(figures, { unpriced: false, units: symbolUnits, assetCategory: ticker.metadata.assetCategory }),
+          ...incomeCells(null, null), "—", asOf]];
       }
       const positionCurrency = metrics.positionCurrency;
       const marketValue = row.marketValue as number | null;
       const unpriced = marketValue == null;
-      return [
+      const quantityOptions = { assetCategory: ticker.metadata.assetCategory, multiplier: position.multiplier, priceBasis: metrics.priceBasis, quantityCurrency: positionCurrency };
+      // A future counts contracts, each the size its terms give: 1,000 × 100 oz.
+      const quantity = (units: number) => contract
+        ? futuresQuantityText(formatMarketQuantity(units, quantityOptions), contract.size
+          ?? (position.multiplier ? { size: formatMarketQuantity(position.multiplier) } : null))
+        : formatMarketQuantity(units, quantityOptions);
+      const lotRow = [
         listingLabel(ticker),
         ...quoteCells,
-        formatMarketQuantity(metrics.totalShares, { assetCategory: ticker.metadata.assetCategory, multiplier: position.multiplier, priceBasis: metrics.priceBasis, quantityCurrency: positionCurrency }),
+        quantity(metrics.totalShares),
         formatMarketCostWithCurrency(position.avgCost, positionCurrency, { assetCategory: ticker.metadata.assetCategory, multiplier: position.multiplier, priceBasis: metrics.priceBasis }),
         unpriced ? NOT_AVAILABLE : wholeMoney(marketValue),
         ...allocationCells(figures, { unpriced, units: symbolUnits, assetCategory: ticker.metadata.assetCategory }),
+        ...incomeCells(exported.annualIncome, exported.incomeYield),
         pnl == null || !Number.isFinite(pnl) ? "—" : colorBySign(money(pnl, { signed: true }), pnl),
         asOf,
       ];
+      if (lots < 2 || lastLot.get(symbol) !== index) return [lotRow];
+      // The whole position under its lots: its shares and value, and the weight, target, drift and trade they add up to.
+      const whole = allocationBySymbol.get(symbol);
+      const wholeValue = whole?.marketValue ?? null;
+      return [lotRow, [`${listingLabel(ticker)} (${lots} lots)`, "", "", ...extendedSessions.map(() => ""),
+        quantity(symbolUnits), "", wholeValue == null ? NOT_AVAILABLE : wholeMoney(wholeValue),
+        ...allocationCells(whole, { unpriced: wholeValue == null, units: symbolUnits, assetCategory: ticker.metadata.assetCategory }),
+        ...(showIncome ? ["", ""] : []), "", ""]];
     });
     if (cashExport) {
       const label = cashExport.currency && cashExport.currency !== currency ? `${CASH_SYMBOL} ${cashExport.currency}` : CASH_SYMBOL;
       rows.push([label, "", "", ...extendedSessions.map(() => ""), "", "", cashExport.value == null ? NOT_AVAILABLE : wholeMoney(cashExport.value),
-        ...allocationCells(cashExport, { unpriced: cashExport.value == null }), "", ""]);
+        ...allocationCells(cashExport, { unpriced: cashExport.value == null }), ...(showIncome ? ["", ""] : []), "", ""]);
     }
     const total = allocation.total;
     rows.push([
       cliStyles.bold("TOTAL"), "", "", ...extendedSessions.map(() => ""), "", "",
       cliStyles.bold(wholeMoney(total)),
-      total != null && total > 0 ? formatAllocationWeight(100) : "—",
+      formatAllocationWeight(totalWeight(allocation)),
       ...(showTargets ? [formatAllocationWeight(allocation.targetSum), "", "", ""] : []),
+      ...(showIncome ? [cliStyles.bold(money(totalIncome)), formatIncomeYield(portfolioYield)] : []),
       totalPnlValue == null ? "—" : colorBySign(money(totalPnlValue, { signed: true }), totalPnlValue),
       "",
     ]);
 
-    const quantityHeader = filtered.some(ticker => ticker.metadata.assetCategory?.toUpperCase() === "BOND") || positionsExport.some(row => row.quantityUnit === "face") ? "Qty" : "Shares";
+    // Face amounts and contracts are not shares.
+    const quantityHeader = filtered.some(ticker => ticker.metadata.assetCategory?.toUpperCase() === "BOND") || positionsExport.some(row => row.quantityUnit === "face")
+      || holdsFutures(valuation) ? "Qty" : "Shares";
     // A narrow terminal drops the cost, then the quote, then P&L, before any of the allocation.
     console.log(renderTable(
       [
@@ -752,6 +1002,11 @@ async function showCollectionWithMarketData(
         { header: "Avg Cost", align: "right", optional: true, dropPriority: 3 },
         { header: "Value", align: "right" },
         ...allocationHeaders.map((header) => ({ header, align: "right" as const })),
+        // A year of trailing dividends on the shares held, dropped after the quote and before P&L.
+        ...(showIncome ? [
+          { header: "Income", align: "right" as const, optional: true, dropPriority: 0.5 },
+          { header: "Yield", align: "right" as const, optional: true, dropPriority: 0.5 },
+        ] : []),
         { header: "P&L", align: "right", optional: true },
         // When each row's price is from, so a Friday close never hides behind a newer row.
         { header: "As of (UTC)" },
@@ -760,10 +1015,15 @@ async function showCollectionWithMarketData(
     ));
     console.log("");
     if (basis === "regular-close") console.log(dayMoveLine(dayMove, currency, colorBySign));
+    if (valued.some((entry) => entry.position)) console.log(exposureLine(exposure, currency));
     const notes: string[] = [];
+    const weightNote = weightBasisLine(allocation, currency);
+    if (weightNote) notes.push(cliStyles.muted(weightNote));
     // The notes name the rows as the table does.
     const labels = new Map(filtered.map((ticker) => [ticker.metadata.ticker, listingLabel(ticker)]));
     const named = (symbols: Iterable<string>) => [...symbols].map((symbol) => labels.get(symbol) ?? symbol).join(", ");
+    // A future without its contract size or settlement is said once, not as a missing cost, value and P&L.
+    const unsized = (symbols: ReadonlySet<string>) => [...symbols].filter((symbol) => !unknownContractSize.has(symbol) && !unsettled.has(symbol));
     if (allocation.unpriced.length > 0) {
       const count = allocation.unpriced.length;
       notes.push(cliStyles.warning(`Total and weights exclude ${count} unpriced holding${count === 1 ? "" : "s"}: ${named(allocation.unpriced)}.`));
@@ -775,12 +1035,58 @@ async function showCollectionWithMarketData(
         ? `No ${cashExport.currency}/${currency} rate for the cash, so the total and weights are unavailable.`
         : "The cash's currency is unknown, so the total and weights are unavailable."));
     }
-    const targetNote = describeTargetSum(allocation.targetSum);
+    const targetNote = describeTargetSum(allocation.targetSum, allocation.weightBasis);
     if (targetNote) notes.push(cliStyles.muted(targetNote));
     if (brokerPnlSymbols.size > 0) notes.push(cliStyles.muted(`P&L for ${named(brokerPnlSymbols)} is the broker's last snapshot.`));
-    if (unavailableCost.size > 0) notes.push(cliStyles.muted(`Cost unavailable for ${named(unavailableCost)}.`));
-    if (unavailablePnl.size > 0) notes.push(cliStyles.muted(`P&L unavailable for ${named(unavailablePnl)}.`));
+    if (unknownContractSize.size > 0) {
+      notes.push(cliStyles.warning(`No contract size for ${named(unknownContractSize)}, so ${unknownContractSize.size === 1 ? "its" : "their"} value, cost and P&L are not shown.`));
+    }
+    if (unsettled.size > 0) {
+      notes.push(cliStyles.warning(`No confirmed settlement for ${named(unsettled)}, so ${unsettled.size === 1 ? "it is" : "they are"} not valued at the close.`));
+    }
+    if (unsized(unavailableCost).length > 0) notes.push(cliStyles.muted(`Cost unavailable for ${named(unsized(unavailableCost))}.`));
+    if (unsized(unavailablePnl).length > 0) notes.push(cliStyles.muted(`P&L unavailable for ${named(unsized(unavailablePnl))}.`));
+    const incomeNote = incomeGapNote(income, { name: named, money: (value) => money(value), deadlineMs: dividendDeadlineMs });
+    if (incomeNote) notes.push(cliStyles.muted(incomeNote));
     for (const note of notes) console.log(note);
+    if (drip) {
+      console.log("");
+      console.log(renderSection(`DRIP projection, ${drip.years} year${drip.years === 1 ? "" : "s"}`));
+      if (dripProjections.length === 0) {
+        console.log(cliStyles.muted(dividends.size === 0 ? "No shares or funds to project."
+          : income.gaps.size > 0 ? "Nothing to project: the income above is unavailable." : "No holding paid a dividend in the past year."));
+      } else {
+        const yearNumbers = Array.from({ length: drip.years }, (_, index) => index + 1);
+        const finalYear = `Shares Y${drip.years}`;
+        const quantity = (value: number, ticker: TickerRecord) => formatMarketQuantity(value, { assetCategory: ticker.metadata.assetCategory });
+        const dripRows = dripProjections.map(({ ticker, shares, years }) => [
+          listingLabel(ticker),
+          quantity(shares, ticker),
+          quantity(years.at(-1)!.shares, ticker),
+          ...years.map((year) => money(year.netIncomeBase)),
+        ]);
+        dripRows.push([
+          cliStyles.bold("TOTAL"), "", "",
+          ...yearNumbers.map((year) => cliStyles.bold(money(dripProjections.reduce((sum, entry) => sum + entry.years[year - 1]!.netIncomeBase, 0)))),
+        ]);
+        console.log(renderTable(
+          [
+            { header: "Ticker" },
+            { header: "Shares", align: "right" },
+            { header: finalYear, align: "right" },
+            ...yearNumbers.map((year) => ({ header: `Y${year} income`, align: "right" as const })),
+          ],
+          dripRows,
+        ));
+        const shorts = dripProjections.some((entry) => entry.shares < 0) ? "; shorts owe each dividend in full" : "";
+        console.log(cliStyles.muted(`As of ${dripAsOf}: trailing dividends, prices and FX held flat; ${drip.withholding}% withheld; reinvested once a year${shorts}.`));
+      }
+      const unprojected = [
+        ...(income.gaps.size > 0 && dripProjections.length > 0 ? [`${named([...income.gaps.keys()])} (income unavailable above)`] : []),
+        ...(dripNotProjected.size > 0 ? [`${named(dripNotProjected)} (no price to reinvest at)`] : []),
+      ];
+      if (unprojected.length > 0) console.log(cliStyles.muted(`Not projected: ${unprojected.join("; ")}.`));
+    }
   } else {
     const watched = await valueWatchlistRows({ tickers: filtered, quotes, dataProvider, currency, toBase });
     if (structured) {
@@ -794,7 +1100,9 @@ async function showCollectionWithMarketData(
     const extendedSessions = extendedSessionsOf(watched.map(({ extended }) => extended?.session));
     // Funding is the one column a list earns by holding perpetual markets; any other list's table is unchanged.
     const showFunding = watched.some(({ funding }) => funding !== undefined);
-    const rows = watched.map(({ ticker, quote, headline, extended, venue, marketCap, funding }) => {
+    // So is Last Trade, by holding a stale quote: the rows the closing line counts stale, dated as `quote` dates them.
+    const stale = watched.filter((entry) => entry.stale);
+    const rows = watched.map(({ ticker, quote, headline, extended, venue, marketCap, funding, stale: rowStale, lastTrade }) => {
       const priceText = quote && headline
         ? colorBySign(formatListPrice(headline.price, quote, ticker.metadata.assetCategory), headline.change)
         : "—";
@@ -804,6 +1112,7 @@ async function showCollectionWithMarketData(
         venue ?? "—",
         priceText,
         changeText,
+        ...stale.length > 0 ? [rowStale ? cliStyles.warning(lastTrade ? `STALE ${lastTrade}` : "STALE") : ""] : [],
         ...extendedCells(extendedSessions, extended, quote, ticker.metadata.assetCategory),
         ...showFunding ? [funding == null ? "—" : colorBySign(formatPerpetualRate(funding, 4), funding)] : [],
         marketCap == null ? "—" : `${formatCompact(marketCap)} ${currency}`,
@@ -816,6 +1125,7 @@ async function showCollectionWithMarketData(
         { header: "Exchange" },
         { header: "Last", align: "right" },
         { header: "Chg", align: "right" },
+        ...stale.length > 0 ? [{ header: "Last Trade", shrink: false }] : [],
         ...extendedSessions.map((session) => ({ header: EXTENDED_SESSION_LABELS[session], align: "right" as const, optional: true, dropPriority: 1 })),
         // As the TUI's FUND 8H: per eight hours whatever interval the venue pays on.
         ...showFunding ? [{ header: "Fund 8H", align: "right" as const, optional: true, dropPriority: 1 }] : [],
@@ -826,8 +1136,12 @@ async function showCollectionWithMarketData(
     ));
     const notes = marketCapNotes(watched);
     if (notes.length > 0) console.log(["", ...notes.map((note) => cliStyles.muted(note))].join("\n"));
+    // The closing line counts the stale rows; the line under it names them.
+    if (stale.length > 0) {
+      staleNote = `Stale: ${namedList(stale.map(({ ticker, lastTrade }) => `${listingLabel(ticker)}${lastTrade ? ` (last trade ${lastTrade})` : ""}`))}.`;
+    }
   }
-  if (freshness) console.log(`\n${cliFreshnessFooter(freshness)}`);
+  if (freshness) console.log(`\n${cliFreshnessFooter(freshness)}${staleNote ? `\n${cliStyles.muted(staleNote)}` : ""}`);
   if (explain) console.log(`\n${renderReportGlossary(EXPLAINED_REPORT, explained)}`);
 }
 
@@ -843,6 +1157,10 @@ interface WatchlistRowValue {
   marketCap: number | null;
   /** A perpetual market's funding per eight hours, as a fraction; null when its market cannot be read, undefined for any other row. */
   funding: number | null | undefined;
+  /** Whether the quote is stale, as the closing line counts it. */
+  stale: boolean;
+  /** The exchange-local date of the quote's last trade. */
+  lastTrade: string | null;
   row: Record<string, unknown>;
 }
 
@@ -933,8 +1251,10 @@ async function valueWatchlistRows({
     const kind = resolveTickerInstrumentKind(ticker, { quote: quote ?? snapshot?.quote });
     const venue = exchangeShortName(quote?.tradingExchangeName || quote?.exchangeName, quote?.fullExchangeName) || ticker.metadata.exchange || null;
     const funding = perpetualFunding.get(symbol);
+    const stale = quoteFreshnessFields(quote).stale === true;
+    const lastTrade = quote ? lastTradeDate(quote) : null;
     values.push({
-      ticker, quote, headline, extended, kind, venue, marketCap, funding,
+      ticker, quote, headline, extended, kind, venue, marketCap, funding, stale, lastTrade,
       row: {
         symbol,
         ...listingColumns(ticker, quote),
@@ -951,6 +1271,9 @@ async function valueWatchlistRows({
         marketCapCurrency: currency,
         // When the price shown was observed, as `quote` dates it.
         quoteAsOf: quote ? known(quoteHeadlineTime(quote)) : null,
+        // A stale quote (as the source line counts it) and the exchange-local date it last traded.
+        stale,
+        lastTradeDate: lastTrade,
       },
     });
   }