gloomberb 0.16.3 → 0.16.4

package/src/plugins/builtin/plugin-module.ts

@@ -3,6 +3,8 @@ import type {
   GloomPlugin,
   GloomPluginContext,
 } from "../../types/plugin";
+import { pluginContextInNamespace } from "../registry/plugin-state";
+import { withPluginStateNamespace } from "../runtime/context";
 
 type PluginMetadataKey =
   | "id"
@@ -21,6 +23,22 @@ type PluginMetadata = Pick<GloomPlugin, PluginMetadataKey>;
 // Brokers and declared hosts belong to external plugins; no built-in module contributes them.
 export type PluginModule = Omit<GloomPlugin, PluginMetadataKey | "broker" | "hosts">;
 
+/** A module with a say in how it is composed. A bare module takes the defaults. */
+interface PluginModuleEntry {
+  module: PluginModule;
+  /**
+   * The state namespace the module keeps when it sits in a plugin whose own
+   * namespace is different: its panes, tabs and slots read pane, plugin and
+   * config state there, and its setup gets persistence and caches there. Set
+   * it when a module moves to another plugin so its users keep their state.
+   */
+  stateId?: string;
+  /** Left out of the plugin the desktop backend process runs. */
+  rendererOnly?: boolean;
+}
+
+type PluginModuleInput = PluginModule | PluginModuleEntry;
+
 const HANDLED_MODULE_KEYS = [
   "cliCommands",
   "setup",
@@ -36,7 +54,43 @@ const ALL_MODULE_KEYS_HANDLED: MissingModuleKey extends never ? true : never = t
 void ALL_MODULE_KEYS_HANDLED;
 
 interface CompositePluginOptions extends PluginMetadata {
-  modules: readonly PluginModule[];
+  modules: readonly PluginModuleInput[];
+}
+
+function moduleEntry(input: PluginModuleInput): PluginModuleEntry {
+  return "module" in input ? input : { module: input };
+}
+
+/**
+ * The module as it runs under a namespace other than its plugin's: every
+ * surface it renders and the context its setup receives are moved there,
+ * while what it contributes still belongs to the plugin.
+ */
+function moduleInNamespace(module: PluginModule, stateId: string): PluginModule {
+  const slots = module.slots && Object.fromEntries(Object.entries(module.slots).map(([slotName, renderer]) => [
+    slotName,
+    renderer && withPluginStateNamespace(stateId, renderer as (props: unknown) => ReactNode),
+  ])) as PluginModule["slots"];
+  return {
+    ...module,
+    ...(module.panes ? {
+      panes: module.panes.map((pane) => ({ ...pane, component: withPluginStateNamespace(stateId, pane.component) })),
+    } : {}),
+    ...(slots ? { slots } : {}),
+    ...(module.setup ? {
+      setup: (ctx: GloomPluginContext) => {
+        const scoped = pluginContextInNamespace(ctx, stateId);
+        return module.setup!({
+          ...scoped,
+          registerPane: (pane) => ctx.registerPane({ ...pane, component: withPluginStateNamespace(stateId, pane.component) }),
+          registerTickerResearchTab: (tab) => ctx.registerTickerResearchTab({
+            ...tab,
+            component: withPluginStateNamespace(stateId, tab.component),
+          }),
+        });
+      },
+    } : {}),
+  };
 }
 
 function composeSlots(modules: readonly PluginModule[]): GloomPlugin["slots"] {
@@ -65,14 +119,23 @@ function composeSlots(modules: readonly PluginModule[]): GloomPlugin["slots"] {
   return slots as GloomPlugin["slots"];
 }
 
+const compositions = new WeakMap<GloomPlugin, CompositePluginOptions>();
+const backendVariants = new WeakMap<GloomPlugin, GloomPlugin>();
+
 /**
  * Combines implementation modules under one real plugin identity.
  *
  * Modules deliberately have no identity or toggle metadata. Every contribution
- * is owned, persisted, enabled, and disposed through the returned parent plugin.
+ * is owned, enabled, and disposed through the returned parent plugin, and
+ * persisted under its namespace unless the module's entry keeps another.
  */
 export function composeBuiltinPlugin(options: CompositePluginOptions): GloomPlugin {
-  const { modules, ...metadata } = options;
+  const { modules: inputs, ...metadata } = options;
+  const pluginStateId = metadata.stateId ?? metadata.id;
+  const modules = inputs.map((input) => {
+    const { module, stateId } = moduleEntry(input);
+    return stateId && stateId !== pluginStateId ? moduleInNamespace(module, stateId) : module;
+  });
   const cliCommands = modules.flatMap((module) => module.cliCommands ?? []);
   const panes = modules.flatMap((module) => module.panes ?? []);
   const paneTemplates = modules.flatMap((module) => module.paneTemplates ?? []);
@@ -80,7 +143,7 @@ export function composeBuiltinPlugin(options: CompositePluginOptions): GloomPlug
   const slots = composeSlots(modules);
   let startedModules: PluginModule[] = [];
 
-  return {
+  const plugin: GloomPlugin = {
     ...metadata,
     ...(cliCommands.length > 0 ? { cliCommands } : {}),
     ...(panes.length > 0 ? { panes } : {}),
@@ -114,4 +177,24 @@ export function composeBuiltinPlugin(options: CompositePluginOptions): GloomPlug
       if (firstError) throw firstError;
     },
   };
+  compositions.set(plugin, options);
+  return plugin;
+}
+
+/**
+ * The plugin as the desktop backend process runs it: the same identity
+ * without its renderer-only modules. Anything else comes back unchanged.
+ */
+export function withoutRendererOnlyModules(plugin: GloomPlugin): GloomPlugin {
+  const options = compositions.get(plugin);
+  if (!options?.modules.some((input) => moduleEntry(input).rendererOnly)) return plugin;
+  let variant = backendVariants.get(plugin);
+  if (!variant) {
+    variant = composeBuiltinPlugin({
+      ...options,
+      modules: options.modules.filter((input) => !moduleEntry(input).rendererOnly),
+    });
+    backendVariants.set(plugin, variant);
+  }
+  return variant;
 }

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

@@ -11,7 +11,7 @@ import type { AppConfig } from "../../../../types/config";
 import type { CliCommandContext, CliCommandDef } from "../../../../types/plugin";
 import type { Portfolio, TickerRecord } from "../../../../types/ticker";
 import type { TickerRepository } from "../../../../data/ticker-repository";
-import { canonicalExchange, parsePublicTickerKey } from "../../../../utils/exchanges";
+import { canonicalTickerKey, parsePublicTickerKey } from "../../../../utils/exchanges";
 import {
   addTickerToPortfolio,
   adoptFirstPositionCurrency,
@@ -38,7 +38,6 @@ import {
 } from "../allocation";
 import { findCachedPortfolioAccount } from "../cached-account";
 import {
-  describeTicker,
   failPortfolioCommand,
   isCashArgument,
   listingFields,
@@ -204,12 +203,19 @@ async function setPositionCommand(
       await store.saveTicker(result.ticker);
       const adopted = firstPosition ? adoptFirstPositionCurrency(config, portfolio.id, currency) : null;
       if (adopted) await saveConfig(adopted);
-      console.log(cliStyles.success(`Set position for ${describeTicker(result.ticker)} in "${portfolio.name}".`));
-      console.log(renderStats([
-        ["Shares", formatMarketQuantity(shares, { assetCategory: result.ticker.metadata.assetCategory })],
-        ["Average Cost", formatMarketCostWithCurrency(avgCost, currency, { assetCategory: result.ticker.metadata.assetCategory })],
-        ["Currency", currency],
-      ]));
+      const saved = savedListingName(result.ticker);
+      ctx.printResult({
+        data: { changed: true, ...listingFields(saved), portfolio: portfolio.name, shares, avgCost, currency },
+      }, {
+        text: () => [
+          cliStyles.success(`Set position for ${saved.label} in "${portfolio.name}".`),
+          renderStats([
+            ["Shares", formatMarketQuantity(shares, { assetCategory: result.ticker.metadata.assetCategory })],
+            ["Average Cost", formatMarketCostWithCurrency(avgCost, currency, { assetCategory: result.ticker.metadata.assetCategory })],
+            ["Currency", currency],
+          ]),
+        ].join("\n"),
+      });
     } catch (error) {
       failPortfolioCommand(ctx, error, `Failed to set position for ${symbol} in "${portfolioName}".`);
     }
@@ -275,7 +281,8 @@ async function clearCashCommand(name: string, ctx: CliCommandContext) {
   });
 }
 
-function printTargetSumNote(config: AppConfig, portfolioId: string, tickers: readonly TickerRecord[]) {
+/** The note under a target change when the targets do not add up to the whole portfolio, else null. */
+function targetSumNote(config: AppConfig, portfolioId: string, tickers: readonly TickerRecord[]): string | null {
   const portfolio = config.portfolios.find((entry) => entry.id === portfolioId);
   const listed = new Set([CASH_SYMBOL, ...tickers.filter((ticker) => ticker.metadata.portfolios.includes(portfolioId)).map((ticker) => ticker.metadata.ticker)]);
   let sum: number | null = null;
@@ -283,24 +290,32 @@ function printTargetSumNote(config: AppConfig, portfolioId: string, tickers: rea
     if (listed.has(symbol)) sum = (sum ?? 0) + weight;
   }
   const note = describeTargetSum(sum);
-  if (note) console.log(cliStyles.muted(note));
+  return note ? cliStyles.muted(note) : null;
 }
 
-/** The portfolio's own ticker for a symbol, without a search when it is already listed. */
+/**
+ * The portfolio's own row for a listing, without a search when it is already
+ * listed. A named exchange (SAN:EPA, or SAN --exchange EPA) matches only a row
+ * on that venue, whatever key the row is saved under: a bare SAN row is one
+ * listing, Paris or New York, never both. A bare SAN takes the row saved under
+ * that key, else any row of the symbol.
+ */
 async function findListedTicker(store: TickerRepository, portfolio: Portfolio, symbol: string, exchange?: string): Promise<TickerRecord | null> {
   const listing = parseListingArg(symbol, exchange);
-  const typed = symbol.trim().toUpperCase();
   const listed = (await store.loadAllTickers()).filter((ticker) => ticker.metadata.portfolios.includes(portfolio.id));
+  const savedAs = (ticker: TickerRecord, key: string) => ticker.metadata.ticker.toUpperCase() === key;
+  if (!listing.exchange) {
+    const sameSymbol = listed.filter((ticker) => parsePublicTickerKey(ticker.metadata.ticker).symbol === listing.symbol);
+    return sameSymbol.find((ticker) => savedAs(ticker, listing.symbol)) ?? sameSymbol[0] ?? null;
+  }
+  const onVenue = listed.filter((ticker) => canonicalTickerKey(ticker.metadata.ticker, ticker.metadata.exchange) === listing.key);
   // The key as saved (VTI:XMEX), else the same listing under another spelling of its venue (VTI:BMV).
-  return listed.find((ticker) => [typed, listing.key].includes(ticker.metadata.ticker.toUpperCase()))
-    ?? listed.find((ticker) => {
-      const saved = parsePublicTickerKey(ticker.metadata.ticker);
-      return saved.symbol === listing.symbol
-        && (!listing.exchange || canonicalExchange(saved.exchange ?? ticker.metadata.exchange) === listing.exchange);
-    })
-    ?? null;
+  return onVenue.find((ticker) => savedAs(ticker, listing.key)) ?? onVenue[0] ?? null;
 }
 
+/** What a target command reports for the cash line, in the fields a listing has. */
+const CASH_LISTING = { key: CASH_SYMBOL, symbol: CASH_SYMBOL, exchange: "", name: null };
+
 async function setTargetCommand(rest: string[], exchange: string | undefined, ctx: CliCommandContext) {
   const rawWeight = rest.at(-1);
   const symbol = rest.at(-2);
@@ -313,8 +328,12 @@ async function setTargetCommand(rest: string[], exchange: string | undefined, ct
       if (isCashArgument(symbol, exchange)) {
         const next = setPortfolioTargetWeight(config, portfolio.id, CASH_SYMBOL, weight);
         await saveConfig(next);
-        console.log(cliStyles.success(`Set the cash target in "${portfolio.name}" to ${formatAllocationWeight(weight)}.`));
-        printTargetSumNote(next, portfolio.id, await store.loadAllTickers());
+        const note = targetSumNote(next, portfolio.id, await store.loadAllTickers());
+        ctx.printResult({
+          data: { changed: true, ...listingFields(CASH_LISTING), portfolio: portfolio.name, targetWeight: weight },
+        }, {
+          text: () => [cliStyles.success(`Set the cash target in "${portfolio.name}" to ${formatAllocationWeight(weight)}.`), note].filter(Boolean).join("\n"),
+        });
         return;
       }
       let ticker = await findListedTicker(store, portfolio, symbol, exchange);
@@ -324,7 +343,7 @@ async function setTargetCommand(rest: string[], exchange: string | undefined, ct
         if (!resolved.metadata.portfolios.includes(portfolio.id)) {
           if (!isManualPortfolio(portfolio)) {
             throw new PortfolioCliError(
-              `${describeTicker(resolved)} is not in "${portfolio.name}".`,
+              `${savedListingName(resolved).label} is not in "${portfolio.name}".`,
               "A broker portfolio lists what the broker holds; set targets on its holdings.",
             );
           }
@@ -338,9 +357,17 @@ async function setTargetCommand(rest: string[], exchange: string | undefined, ct
       }
       const next = setPortfolioTargetWeight(config, portfolio.id, ticker.metadata.ticker, weight);
       await saveConfig(next);
-      if (added) console.log(cliStyles.success(`Added ${describeTicker(ticker)} to "${portfolio.name}".`));
-      console.log(cliStyles.success(`Set the target for ${describeTicker(ticker)} in "${portfolio.name}" to ${formatAllocationWeight(weight)}.`));
-      printTargetSumNote(next, portfolio.id, await store.loadAllTickers());
+      const saved = savedListingName(ticker);
+      const note = targetSumNote(next, portfolio.id, await store.loadAllTickers());
+      ctx.printResult({
+        data: { changed: true, ...listingFields(saved), portfolio: portfolio.name, targetWeight: weight, added },
+      }, {
+        text: () => [
+          added ? cliStyles.success(`Added ${saved.label} to "${portfolio.name}".`) : null,
+          cliStyles.success(`Set the target for ${saved.label} in "${portfolio.name}" to ${formatAllocationWeight(weight)}.`),
+          note,
+        ].filter(Boolean).join("\n"),
+      });
     } catch (error) {
       failPortfolioCommand(ctx, error, `Failed to set the target for ${symbol} in "${name}".`);
     }
@@ -355,21 +382,28 @@ async function clearTargetCommand(rest: string[], exchange: string | undefined,
       const whole = config.portfolios.some((entry) => [entry.id, entry.name].some((value) => value.toLowerCase() === rest.join(" ").trim().toLowerCase()));
       const portfolio = requirePortfolio(config, whole ? rest.join(" ") : rest.slice(0, -1).join(" "));
       const rawSymbol = whole ? undefined : rest.at(-1);
-      const symbol = rawSymbol == null ? undefined
-        : isCashArgument(rawSymbol, exchange) ? CASH_SYMBOL
-          : (await findListedTicker(store, portfolio, rawSymbol, exchange))?.metadata.ticker ?? parseListingArg(rawSymbol, exchange).key;
+      const cash = rawSymbol != null && isCashArgument(rawSymbol, exchange);
+      const listing = rawSymbol == null || cash ? null : parseListingArg(rawSymbol, exchange);
+      // The row the listing is: the portfolio's own, else any saved one; a target is kept under that row's key.
+      const ticker = listing ? await findListedTicker(store, portfolio, rawSymbol!, exchange) ?? await loadSavedListing(store, listing) : null;
+      const saved = ticker ? savedListingName(ticker) : null;
+      const symbol = cash ? CASH_SYMBOL : ticker?.metadata.ticker ?? listing?.key;
       const { config: next, removed } = clearPortfolioTargetWeights(config, portfolio.id, symbol);
+      const fields = cash ? listingFields(CASH_LISTING) : saved ? listingFields(saved) : listing ? listingFields({ ...listing, name: null }) : {};
+      const named = saved?.label ?? listing?.key ?? CASH_SYMBOL;
+      const data = { changed: removed.length > 0, ...fields, portfolio: portfolio.name, removedTargets: removed.length };
       if (removed.length === 0) {
-        console.log(cliStyles.warning(symbol ? `"${portfolio.name}" has no target for ${symbol}.` : `"${portfolio.name}" has no targets.`));
+        ctx.printResult({ data }, { text: () => cliStyles.warning(symbol ? `"${portfolio.name}" has no target for ${named}.` : `"${portfolio.name}" has no targets.`) });
         return;
       }
       await saveConfig(next);
-      if (symbol) {
-        const ticker = symbol === CASH_SYMBOL ? null : await store.loadTicker(symbol);
-        console.log(cliStyles.success(`Cleared the ${symbol === CASH_SYMBOL ? "cash target" : `target for ${ticker ? describeTicker(ticker) : symbol}`} in "${portfolio.name}".`));
-      } else {
-        console.log(cliStyles.success(`Cleared ${removed.length} target${removed.length === 1 ? "" : "s"} in "${portfolio.name}".`));
-      }
+      ctx.printResult({ data }, {
+        text: () => cliStyles.success(
+          symbol
+            ? `Cleared the ${cash ? "cash target" : `target for ${named}`} in "${portfolio.name}".`
+            : `Cleared ${removed.length} target${removed.length === 1 ? "" : "s"} in "${portfolio.name}".`,
+        ),
+      });
     } catch (error) {
       failPortfolioCommand(ctx, error, `Failed to clear targets in "${rest.join(" ")}".`);
     }
@@ -407,7 +441,8 @@ async function showTargetsCommand(name: string, ctx: CliCommandContext) {
         [{ header: "Ticker" }, { header: "Name" }, { header: "Target", align: "right" }],
         rows.map((row) => [row.symbol, row.listed ? row.name ?? "" : cliStyles.muted("not in this portfolio"), formatAllocationWeight(row.targetWeight)]),
       ));
-      printTargetSumNote(config, portfolio.id, tickers);
+      const note = targetSumNote(config, portfolio.id, tickers);
+      if (note) console.log(note);
     } catch (error) {
       failPortfolioCommand(ctx, error, `Failed to show targets for "${name}".`);
     }

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

@@ -12,7 +12,16 @@ import { currencyMinorDigits, formatMarketCostWithCurrency, formatMarketPriceWit
 import { resolvePriceBasis } from "../../../../market-data/market/price-basis";
 import { getPortfolioPositionMetrics, getPortfolioQuoteDisplay, resolvePortfolioMarketValue, resolvePortfolioPositionPnl } from "../position-metrics";
 import { resolvePortfolioTotalsCurrency } from "../summary/totals";
-import { exchangeShortName, getActiveQuoteDisplay } from "../../../../market-data/market/status";
+import {
+  EXTENDED_SESSION_LABELS,
+  exchangeShortName,
+  getActiveQuoteDisplay,
+  getExtendedSessionDisplay,
+  type ActiveQuoteDisplay,
+  type ExtendedSession,
+  type ExtendedSessionDisplay,
+} from "../../../../market-data/market/status";
+import { headlineQuoteDisplay } from "../column-values";
 import type { AppConfig } from "../../../../types/config";
 import type { DataProvider } from "../../../../types/data-provider";
 import type { CliCommandContext } from "../../../../types/plugin";
@@ -47,6 +56,38 @@ function priceFormatOptions(quote: Parameters<typeof quoteFormatOptions>[0] & {
     : options;
 }
 
+/**
+ * What a collection's Last and Chg show, as the PF and watchlist panes do: the
+ * traded price until the regular close, then that close and its move, with a
+ * pre-market or after-hours print beside them, measured from that close.
+ * Market value and P&L keep the live price.
+ */
+export function collectionQuoteHeadline(quote: CollectionQuote | undefined): {
+  headline: ActiveQuoteDisplay | null;
+  extended: ExtendedSessionDisplay | null;
+} {
+  const traded = getActiveQuoteDisplay(quote);
+  const headline = traded && Number.isFinite(traded.price) ? headlineQuoteDisplay(traded, quote) : null;
+  const extended = headline ? getExtendedSessionDisplay(quote) : null;
+  return { headline, extended: extended && Number.isFinite(extended.price) ? extended : null };
+}
+
+/** The extended print as export fields: all null without one. */
+export function extendedQuoteFields(extended: ExtendedSessionDisplay | null) {
+  return {
+    extendedSession: extended?.session ?? null,
+    extendedPrice: extended?.price ?? null,
+    extendedChange: extended?.change ?? null,
+    extendedChangePercent: extended?.changePercent ?? null,
+  };
+}
+
+/** The extended sessions among the rows' prints, in the order their columns go. */
+export function extendedSessionsOf(sessions: Iterable<ExtendedSession | null | undefined>): ExtendedSession[] {
+  const present = new Set(sessions);
+  return (["PRE", "POST"] as const).filter((session) => present.has(session));
+}
+
 export function renderCollectionOverview(config: AppConfig, tickers: TickerRecord[]): string {
   const blocks: string[] = [];
 
@@ -143,7 +184,12 @@ export async function loadCollectionQuotes(
 interface PortfolioPositionValue {
   ticker: TickerRecord;
   quote: CollectionQuote | undefined;
+  /** The live print, which values the position. */
   activeQuote: ReturnType<typeof getActiveQuoteDisplay> | null;
+  /** Last and Chg as shown: the regular session's (collectionQuoteHeadline). */
+  headline: ActiveQuoteDisplay | null;
+  /** A pre-market or after-hours print, from the close in `headline`. */
+  extended: ExtendedSessionDisplay | null;
   /** Null for a ticker kept in the portfolio without an open position. */
   position: TickerPosition | null;
   metrics: ReturnType<typeof getPortfolioPositionMetrics> | null;
@@ -199,14 +245,15 @@ export async function valuePortfolioPositions({
     const positions = ticker.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);
 
     if (positions.length === 0) {
       const quoteCurrency = quote?.currency || ticker.metadata.currency || baseCurrency;
       const unitPrice = activeQuote ? known(await toBase(activeQuote.price, quoteCurrency)) : null;
       holdings.push({ symbol: ticker.metadata.ticker, held: false, marketValue: 0, units: 0, unitPrice });
-      values.push({ ticker, quote, activeQuote, position: null, metrics: null, pnl: null,
+      values.push({ ticker, quote, activeQuote, headline, extended, position: null, metrics: null, pnl: null,
         row: { symbol: ticker.metadata.ticker, exchange: ticker.metadata.exchange, shares: null, avgCost: null,
-          positionCurrency: null, quotePrice: known(activeQuote?.price), quoteCurrency: quote?.currency ?? null,
+          positionCurrency: null, quotePrice: known(headline?.price), ...extendedQuoteFields(extended), quoteCurrency: quote?.currency ?? null,
           costBasis: null, marketValue: null, unrealizedPnl: null, baseCurrency: currency } });
       continue;
     }
@@ -238,11 +285,12 @@ export async function valuePortfolioPositions({
       holding.marketValue = holding.marketValue == null || marketValue == null ? null : holding.marketValue + marketValue;
       holding.units += metrics.totalShares;
       holding.unitPrice ??= valuationQuote ? known(await toBase(valuationQuote.price, quoteCurrency)) : null;
-      values.push({ ticker, quote, activeQuote, position, metrics, pnl,
+      values.push({ ticker, quote, activeQuote, headline, extended, position, metrics, pnl,
         row: { symbol: ticker.metadata.ticker, 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,
-          quotePrice: known(activeQuote?.price), quoteCurrency, quoteAsOf: quote?.lastUpdated ?? null,
+          // Last as shown, the regular close after it; market value and P&L are at the live price.
+          quotePrice: known(headline?.price), ...extendedQuoteFields(extended), quoteCurrency, quoteAsOf: quote?.lastUpdated ?? null,
           costBasis: known(direction * costBasisBase), marketValue,
           unrealizedPnl: known(pnl), baseCurrency: currency, dateAcquired: position.dateAcquired ?? null,
           pnlBasis: selectedPnl.basis, brokerUnrealizedPnl: known(position.unrealizedPnl), brokerPnlCurrency: positionCurrency, brokerPnlAsOf: null } });
@@ -296,6 +344,18 @@ function signed(text: string, value: number | null | undefined): string {
 
 const NOT_AVAILABLE = "n/a";
 
+/** One cell per extended column: the print and its move from the close, as `quote` prints it, or blank. */
+function extendedCells(
+  sessions: readonly ExtendedSession[],
+  extended: ExtendedSessionDisplay | null,
+  quote: CollectionQuote | undefined,
+  assetCategory: string | undefined,
+): string[] {
+  return sessions.map((session) => extended?.session === session && quote
+    ? `${formatMarketPriceWithCurrency(extended.price, quote.currency, priceFormatOptions(quote, assetCategory))} ${colorBySign(formatPercentRaw(extended.changePercent), extended.change)}`
+    : "");
+}
+
 async function showCollectionWithMarketData(
   name: string,
   ctx: CliCommandContext,
@@ -436,18 +496,20 @@ async function showCollectionWithMarketData(
       return [weight, target, drift, trade, tradeValue];
     };
 
-    const rows: string[][] = valued.map(({ ticker, quote, activeQuote, position, metrics, pnl, row }, index) => {
-      const priceText = quote && activeQuote
-        ? colorBySign(formatMarketPriceWithCurrency(activeQuote.price, quote.currency, priceFormatOptions(quote, ticker.metadata.assetCategory)), activeQuote.change)
+    const extendedSessions = extendedSessionsOf(valued.map(({ extended }) => extended?.session));
+    const rows: string[][] = valued.map(({ ticker, quote, headline, extended, position, metrics, pnl, row }, index) => {
+      const priceText = quote && headline
+        ? colorBySign(formatMarketPriceWithCurrency(headline.price, quote.currency, priceFormatOptions(quote, ticker.metadata.assetCategory)), headline.change)
         : "—";
-      const changeText = activeQuote ? colorBySign(formatPercentRaw(activeQuote.changePercent), activeQuote.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;
       if (!position || !metrics) {
-        return [ticker.metadata.ticker, priceText, changeText, "—", "—", "—",
+        return [ticker.metadata.ticker, ...quoteCells, "—", "—", "—",
           ...allocationCells(figures, { unpriced: false, units: symbolUnits, assetCategory: ticker.metadata.assetCategory }), "—"];
       }
       const positionCurrency = metrics.positionCurrency;
@@ -455,8 +517,7 @@ async function showCollectionWithMarketData(
       const unpriced = marketValue == null;
       return [
         ticker.metadata.ticker,
-        priceText,
-        changeText,
+        ...quoteCells,
         formatMarketQuantity(metrics.totalShares, { assetCategory: ticker.metadata.assetCategory, multiplier: position.multiplier, priceBasis: metrics.priceBasis, quantityCurrency: positionCurrency }),
         formatMarketCostWithCurrency(position.avgCost, positionCurrency, { assetCategory: ticker.metadata.assetCategory, multiplier: position.multiplier, priceBasis: metrics.priceBasis }),
         unpriced ? NOT_AVAILABLE : wholeMoney(marketValue),
@@ -466,12 +527,12 @@ async function showCollectionWithMarketData(
     });
     if (cashExport) {
       const label = cashExport.currency && cashExport.currency !== currency ? `${CASH_SYMBOL} ${cashExport.currency}` : CASH_SYMBOL;
-      rows.push([label, "", "", "", "", cashExport.value == null ? NOT_AVAILABLE : wholeMoney(cashExport.value),
+      rows.push([label, "", "", ...extendedSessions.map(() => ""), "", "", cashExport.value == null ? NOT_AVAILABLE : wholeMoney(cashExport.value),
         ...allocationCells(cashExport, { unpriced: cashExport.value == null }), ""]);
     }
     const total = allocation.total;
     rows.push([
-      cliStyles.bold("TOTAL"), "", "", "", "",
+      cliStyles.bold("TOTAL"), "", "", ...extendedSessions.map(() => ""), "", "",
       cliStyles.bold(wholeMoney(total)),
       total != null && total > 0 ? formatAllocationWeight(100) : "—",
       ...(showTargets ? [formatAllocationWeight(allocation.targetSum), "", "", ""] : []),
@@ -485,6 +546,8 @@ async function showCollectionWithMarketData(
         { header: "Ticker" },
         { header: "Last", align: "right", optional: true, dropPriority: 1 },
         { header: "Chg", align: "right", optional: true, dropPriority: 2 },
+        // Before Chg, after Avg Cost, which is right of it at the same priority.
+        ...extendedSessions.map((session) => ({ header: EXTENDED_SESSION_LABELS[session], align: "right" as const, optional: true, dropPriority: 3 })),
         { header: quantityHeader, align: "right" },
         { header: "Avg Cost", align: "right", optional: true, dropPriority: 3 },
         { header: "Value", align: "right" },
@@ -522,12 +585,15 @@ async function showCollectionWithMarketData(
     for (const note of notes) console.log(note);
   } else {
     const rows: string[][] = [];
+    const shown = new Map(filtered.map((ticker) => [ticker, collectionQuoteHeadline(quotes.get(ticker.metadata.ticker))]));
+    const extendedSessions = extendedSessionsOf([...shown.values()].map(({ extended }) => extended?.session));
     for (const ticker of filtered) {
       const quote = quotes.get(ticker.metadata.ticker);
-      const priceText = quote
-        ? colorBySign(formatMarketPriceWithCurrency(quote.price, quote.currency, priceFormatOptions(quote, ticker.metadata.assetCategory)), quote.change)
+      const { headline, extended } = shown.get(ticker)!;
+      const priceText = quote && headline
+        ? colorBySign(formatMarketPriceWithCurrency(headline.price, quote.currency, priceFormatOptions(quote, ticker.metadata.assetCategory)), headline.change)
         : "—";
-      const changeText = quote ? colorBySign(formatPercentRaw(quote.changePercent), quote.change) : "—";
+      const changeText = headline ? colorBySign(formatPercentRaw(headline.changePercent), headline.change) : "—";
       const marketCapText = quote?.marketCap != null
         ? `${formatCompact(await toBase(quote.marketCap, quote.currency || ticker.metadata.currency || currency))} ${currency}`
         : "—";
@@ -537,6 +603,7 @@ async function showCollectionWithMarketData(
         exchangeShortName(quote?.exchangeName, quote?.fullExchangeName) || ticker.metadata.exchange || "—",
         priceText,
         changeText,
+        ...extendedCells(extendedSessions, extended, quote, ticker.metadata.assetCategory),
         marketCapText,
       ]);
     }
@@ -547,7 +614,9 @@ async function showCollectionWithMarketData(
         { header: "Exchange" },
         { header: "Last", align: "right" },
         { header: "Chg", align: "right" },
-        { header: "Mkt Cap", align: "right" },
+        ...extendedSessions.map((session) => ({ header: EXTENDED_SESSION_LABELS[session], align: "right" as const, optional: true, dropPriority: 1 })),
+        // A narrow terminal drops these first.
+        { header: "Mkt Cap", align: "right", optional: true, dropPriority: 2 },
       ],
       rows,
     ));

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

@@ -1,8 +1,6 @@
 import type { AppConfig } from "../../../../types/config";
 import type { CliCommandContext } from "../../../../types/plugin";
-import type { TickerRecord } from "../../../../types/ticker";
 import { parseListingArg, type SavedListingName } from "../../../../cli/listing-arg";
-import { isUsListingExchange } from "../../../../utils/exchanges";
 import { findPortfolio, isManualPortfolio } from "../mutations";
 import { CASH_SYMBOL } from "../allocation";
 
@@ -23,8 +21,8 @@ export function failPortfolioCommand(ctx: CliCommandContext, error: unknown, fal
   return ctx.fail(fallback);
 }
 
-/** What add and remove report about the listing they changed, as JSON and as the sentence's subject. */
-export function listingFields(saved: SavedListingName) {
+/** What every collection command reports about the listing it changed, as JSON and as the sentence's subject. */
+export function listingFields(saved: Pick<SavedListingName, "key" | "symbol" | "exchange" | "name">) {
   return { listing: saved.key, symbol: saved.symbol, exchange: saved.exchange || null, name: saved.name };
 }
 
@@ -72,15 +70,3 @@ export function rejectCashSymbol(symbol: string, exchange: string | undefined, p
     `Record cash with: gloomberb portfolio cash set "${portfolioName}" <amount> [currency]. For the stock that trades as CASH, name its exchange: CASH:NASDAQ.`,
   );
 }
-
-/** `VTI (Vanguard Total Stock Market ETF)`, with the venue and currency for a listing outside the US. */
-export function describeTicker(ticker: TickerRecord): string {
-  const { ticker: symbol, name, exchange, currency } = ticker.metadata;
-  const foreign = !!exchange && !isUsListingExchange(exchange);
-  const details = [
-    name?.trim(),
-    foreign ? exchange : undefined,
-    foreign && currency && currency.toUpperCase() !== "USD" ? currency.toUpperCase() : undefined,
-  ].filter((part): part is string => !!part);
-  return details.length > 0 ? `${symbol} (${details.join(", ")})` : symbol;
-}