gloomberb 0.16.2 → 0.16.4

package/src/cli/history-rows.ts

@@ -1,19 +1,52 @@
 import type { PricePoint } from "../types/financials";
 import { marketPriceFractionDigitCeiling, resolveAssetDisplayKind } from "../market-data/market/format";
-import { isIntradayResolution, type ManualChartResolution } from "../time-series/resolution";
+import { TIME_RANGES, type TimeRange } from "../time-series/range";
+import { subtractTimeRange } from "../time-series/date-window";
+import {
+  CHART_RESOLUTION_STEP_MS,
+  isIntradayResolution,
+  RANGE_HISTORY_RESOLUTION,
+  type ManualChartResolution,
+} from "../time-series/resolution";
+import { currencyUnitLabel } from "../utils/currency-units";
 import { getPricePointTimestamp } from "../utils/price-history";
+import { pricePointIntegrityFlags, pricePointValues } from "../utils/price-history-integrity";
+import { formatUtcTime } from "../utils/utc-time";
 
 const PRICE_KEYS = ["open", "high", "low", "close"] as const;
+const DAY_MS = 24 * 60 * 60 * 1000;
 /** Daily bars are a day apart even when stamped at the session open. */
 const INTRADAY_MAX_GAP_MS = 20 * 60 * 60 * 1000;
+const INTRADAY_RESOLUTIONS = ["1m", "5m", "15m", "30m", "45m", "1h"] as const;
+/** A first bar later than this after the range's start is a late start, not a weekend or holiday. */
+const LATE_START_MIN_MS = 10 * DAY_MS;
+const LATE_START_MIN_BARS = 3;
 
-interface HistoryRow {
+const BAR_INTERVAL_LABELS: Record<ManualChartResolution, string> = {
+  "1m": "1-minute",
+  "5m": "5-minute",
+  "15m": "15-minute",
+  "30m": "30-minute",
+  "45m": "45-minute",
+  "1h": "hourly",
+  "1d": "daily",
+  "1wk": "weekly",
+  "1mo": "monthly",
+};
+
+export interface HistoryRow {
   date: string;
   open: number | null;
   high: number | null;
   low: number | null;
-  close: number;
+  close: number | null;
   volume: number | null;
+  /** Currency code of the prices; null for index points or when no source says. */
+  currency: string | null;
+  /** Bar size, in the codes of `resolution`: 5m, 1h, 1d, 1wk, 1mo. */
+  interval: ManualChartResolution | null;
+  /** Each way the bar's prices contradict each other, such as `high<open`; null when they agree. */
+  flag: string | null;
 }
 
 function decimalPlaces(value: number): number {
@@ -43,29 +76,63 @@ function isUtcMidnight(time: number): boolean {
   return new Date(time).toISOString().endsWith("T00:00:00.000Z");
 }
 
+function medianGap(times: readonly number[]): number | null {
+  const finite = times.filter(Number.isFinite).sort((left, right) => left - right);
+  const gaps = finite.slice(1).map((time, index) => time - finite[index]!).filter((gap) => gap > 0).sort((left, right) => left - right);
+  return gaps.length > 0 ? gaps[Math.floor((gaps.length - 1) / 2)]! : null;
+}
+
 /** Without a declared cadence, bar spacing decides: daily bars may be stamped at the session open. */
 function looksIntraday(times: readonly number[]): boolean {
-  const finite = times.filter(Number.isFinite).sort((left, right) => left - right);
+  const finite = times.filter(Number.isFinite);
   if (finite.length < 2) return finite.some((time) => !isUtcMidnight(time));
-  const gaps = finite.slice(1).map((time, index) => time - finite[index]!).filter((gap) => gap > 0).sort((left, right) => left - right);
-  return gaps.length > 0 && gaps[Math.floor((gaps.length - 1) / 2)]! < INTRADAY_MAX_GAP_MS;
+  const gap = medianGap(finite);
+  return gap != null && gap < INTRADAY_MAX_GAP_MS;
+}
+
+/** The bar size served: as the source declared it, otherwise read from the typical spacing of the bars. */
+function historyInterval(times: readonly number[], resolution: ManualChartResolution | null): ManualChartResolution | null {
+  if (resolution) return resolution;
+  const gap = medianGap(times);
+  if (gap == null) return null;
+  if (gap < INTRADAY_MAX_GAP_MS) {
+    return INTRADAY_RESOLUTIONS.reduce((best, candidate) => (
+      Math.abs(CHART_RESOLUTION_STEP_MS[candidate] - gap) < Math.abs(CHART_RESOLUTION_STEP_MS[best] - gap) ? candidate : best
+    ));
+  }
+  const days = gap / DAY_MS;
+  return days >= 25 ? "1mo" : days >= 6 ? "1wk" : "1d";
 }
 
-/** Intraday bars keep their UTC time; daily and longer bars are trading dates. */
-export function historyRows(points: readonly PricePoint[], resolution: ManualChartResolution | null): HistoryRow[] {
+/**
+ * Intraday bars keep their UTC time; daily and longer bars are trading dates.
+ * A bar whose prices contradict each other is blanked exactly as HP blanks it,
+ * and says why in `flag`.
+ */
+export function historyRows(
+  points: readonly PricePoint[],
+  resolution: ManualChartResolution | null,
+  currency: string | null = null,
+): HistoryRow[] {
   const times = points.map(getPricePointTimestamp);
   const intraday = resolution ? isIntradayResolution(resolution) : looksIntraday(times);
+  const interval = historyInterval(times, resolution);
   return points.map((point, index) => {
     const time = times[index]!;
     const iso = Number.isFinite(time) ? new Date(time).toISOString() : "";
-    const price = (value: number | undefined) => value == null ? null : cleanFloat32Price(value);
+    const values = pricePointValues(point);
+    const flags = pricePointIntegrityFlags(point);
+    const price = (value: number | null) => value == null ? null : cleanFloat32Price(value);
     return {
       date: intraday ? iso.replace(".000Z", "Z") : iso.slice(0, 10),
-      open: price(point.open),
-      high: price(point.high),
-      low: price(point.low),
-      close: cleanFloat32Price(point.close),
-      volume: point.volume ?? null,
+      open: price(values.open),
+      high: price(values.high),
+      low: price(values.low),
+      close: price(values.close),
+      volume: values.volume,
+      currency,
+      interval,
+      flag: flags.length > 0 ? flags.join(",") : null,
     };
   });
 }
@@ -84,7 +151,7 @@ function neededDecimals(value: number, cap: number): number {
  * one, the largest price sets a seven significant digit ceiling (BTC keeps
  * cents, FX keeps pips, sub-cent coins keep their digits). Cents at least above 1.
  */
-export function historyPriceDecimals(rows: readonly HistoryRow[], assetCategory?: string): number {
+export function historyPriceDecimals(rows: readonly Pick<HistoryRow, typeof PRICE_KEYS[number]>[], assetCategory?: string): number {
   const values = rows.flatMap((row) => PRICE_KEYS.flatMap((key) => {
     const value = row[key];
     return value != null && Number.isFinite(value) && value !== 0 ? [Math.abs(value)] : [];
@@ -100,3 +167,108 @@ export function historyPriceDecimals(rows: readonly HistoryRow[], assetCategory?
   const decimals = needed[Math.floor(0.9 * (needed.length - 1))]!;
   return largest >= 1 ? Math.max(2, decimals) : decimals;
 }
+
+/** How far back ALL reaches, in whole years, from the window a history request for it asks for. */
+export function historyAllRangeYears(now = new Date()): number {
+  return Math.round((now.getTime() - subtractTimeRange(now, "ALL").getTime()) / (365.25 * DAY_MS));
+}
+
+/** "1D 5-minute, 1W hourly, 1M to 1Y daily, 5Y weekly, ALL monthly", from the table history requests use. */
+export function historyIntervalsByRange(): string {
+  const groups: Array<{ ranges: TimeRange[]; resolution: ManualChartResolution }> = [];
+  for (const range of TIME_RANGES) {
+    const resolution = RANGE_HISTORY_RESOLUTION[range];
+    const last = groups.at(-1);
+    if (last?.resolution === resolution) last.ranges.push(range);
+    else groups.push({ ranges: [range], resolution });
+  }
+  return groups.map(({ ranges, resolution }) => (
+    `${ranges.length > 1 ? `${ranges[0]} to ${ranges.at(-1)}` : ranges[0]} ${BAR_INTERVAL_LABELS[resolution]}`
+  )).join(", ");
+}
+
+export interface HistoryUnit {
+  kind: "currency" | "pair" | "points" | "unknown";
+  /** Currency code of the prices; null for index points or when no source says. */
+  currency: string | null;
+  /** What one price is: "USD", "ILA (agorot, 1/100 ILS)", "ZAR per USD", "index points"; null when unknown. */
+  unit: string | null;
+}
+
+/**
+ * What the prices are in. An FX pair is named by its symbol (ZAR=X is ZAR per
+ * USD, EURUSD=X is USD per EUR), an index is in points, and anything else is
+ * in the currency its quote states, a sub-unit named as such. Without one the
+ * unit is unknown rather than guessed from the exchange.
+ */
+export function historyUnit(symbol: string, quote: { currency?: string; instrumentType?: string } | null | undefined): HistoryUnit {
+  const pair = /^([A-Z]{3})([A-Z]{3})?=X$/.exec(symbol.trim().toUpperCase());
+  if (pair) {
+    const [base, counter] = pair[2] ? [pair[1]!, pair[2]] : ["USD", pair[1]!];
+    return { kind: "pair", currency: counter, unit: `${counter} per ${base}` };
+  }
+  if (quote?.instrumentType?.trim().toUpperCase() === "INDEX") return { kind: "points", currency: null, unit: "index points" };
+  const code = quote?.currency?.trim();
+  return code
+    ? { kind: "currency", currency: code, unit: currencyUnitLabel(code, { ofMajor: true }) }
+    : { kind: "unknown", currency: null, unit: null };
+}
+
+function historyDate(value: string): string {
+  return value.length > 10 ? formatUtcTime(value) : value;
+}
+
+/** The facts line under a history heading: "Currency USD", "daily bars", "2025-10-09 to 2026-10-08", "251 bars". */
+export function historyFacts(unit: HistoryUnit, rows: readonly Pick<HistoryRow, "date" | "interval">[]): string[] {
+  const first = rows[0]?.date;
+  const last = rows.at(-1)?.date;
+  const interval = rows[0]?.interval;
+  return [
+    unit.kind === "pair" ? unit.unit! : unit.kind === "points" ? "Index points" : `Currency ${unit.unit ?? "unknown"}`,
+    interval ? `${BAR_INTERVAL_LABELS[interval]} bars` : "",
+    first && last ? (first === last ? historyDate(first) : `${historyDate(first)} to ${historyDate(last)}`) : "",
+    `${rows.length} ${rows.length === 1 ? "bar" : "bars"}`,
+  ].filter(Boolean);
+}
+
+/**
+ * What an export should know that its rows do not show: bars coarser than the
+ * range is served in, or a first bar well after the start asked for, as for a
+ * listing younger than the range. Weekends and holidays are within tolerance.
+ */
+export function historyNotes(
+  range: TimeRange,
+  interval: ManualChartResolution | null,
+  firstDate: string | undefined,
+  now = Date.now(),
+): string[] {
+  if (!firstDate) return [];
+  const notes: string[] = [];
+  const expected = RANGE_HISTORY_RESOLUTION[range];
+  if (interval && CHART_RESOLUTION_STEP_MS[interval] > CHART_RESOLUTION_STEP_MS[expected]) {
+    const from = interval === "1mo" ? firstDate.slice(0, 7) : firstDate.slice(0, 10);
+    notes.push(`Asked ${range}, got ${BAR_INTERVAL_LABELS[interval]} bars from ${from}`);
+  }
+  const first = Date.parse(firstDate);
+  if (range !== "ALL" && Number.isFinite(first)) {
+    const tolerance = Math.max(LATE_START_MIN_MS, LATE_START_MIN_BARS * CHART_RESOLUTION_STEP_MS[interval ?? expected]);
+    if (first - subtractTimeRange(new Date(now), range).getTime() > tolerance) {
+      notes.push(`Asked ${range}, data starts ${firstDate.slice(0, 10)} (first available bar)`);
+    }
+  }
+  return notes;
+}
+
+/** "37 of 251 bars have high below open or close in the source data; ...", or null when every bar agrees. */
+export function historyFlagNote(rows: readonly Pick<HistoryRow, "flag">[]): string | null {
+  const flagged = rows.filter((row) => row.flag);
+  if (flagged.length === 0) return null;
+  const codes = new Set(flagged.flatMap((row) => row.flag!.split(",")));
+  const kinds = [
+    codes.has("high<open") || codes.has("high<close") ? "high below open or close" : "",
+    codes.has("low>open") || codes.has("low>close") ? "low above open or close" : "",
+    codes.has("low>high") ? "low above high" : "",
+  ].filter(Boolean);
+  const count = `${flagged.length} of ${rows.length} ${flagged.length === 1 && rows.length === 1 ? "bar" : "bars"}`;
+  return `${count} ${flagged.length === 1 ? "has" : "have"} ${kinds.join(", or ")} in the source data; their prices are left blank`;
+}

package/src/cli/index-roots.ts

@@ -0,0 +1,51 @@
+/**
+ * Well-known index roots that people type bare. As a bare symbol each one is
+ * another instrument (MOVE is Corvex, MID a fund) or nothing at all (VIX); the
+ * index itself is quoted as ^ROOT. Every entry is offered as a command to run,
+ * so only roots whose ^ symbol returns a quote belong here.
+ */
+const INDEX_ROOTS = new Map([
+  ["VIX", "Cboe Volatility Index"],
+  ["VVIX", "Cboe VIX of VIX Index"],
+  ["VIX9D", "Cboe S&P 500 9-Day Volatility Index"],
+  ["VIX3M", "Cboe S&P 500 3-Month Volatility Index"],
+  ["VXN", "Cboe Nasdaq-100 Volatility Index"],
+  ["OVX", "Cboe Crude Oil ETF Volatility Index"],
+  ["GVZ", "Cboe Gold ETF Volatility Index"],
+  ["SKEW", "Cboe SKEW Index"],
+  ["TNX", "Cboe 10-Year Treasury Yield Index"],
+  ["SPX", "S&P 500 Index"],
+  ["OEX", "S&P 100 Index"],
+  ["MID", "S&P MidCap 400 Index"],
+  ["DJI", "Dow Jones Industrial Average"],
+  ["NDX", "Nasdaq-100 Index"],
+  ["SOX", "PHLX Semiconductor Index"],
+  ["RUT", "Russell 2000 Index"],
+  ["RUI", "Russell 1000 Index"],
+  ["RUA", "Russell 3000 Index"],
+  ["MOVE", "ICE BofA MOVE Index"],
+  ["NYA", "NYSE Composite Index"],
+]);
+
+export interface IndexRoot {
+  /** The index's own symbol: ^VIX. */
+  symbol: string;
+  name: string;
+}
+
+/** The index a bare root names (VIX is ^VIX); null for any other symbol, ^VIX included. */
+export function indexRootFor(symbol: string): IndexRoot | null {
+  const root = symbol.trim().toUpperCase();
+  const name = INDEX_ROOTS.get(root);
+  return name ? { symbol: `^${root}`, name } : null;
+}
+
+/** "^VIX  Cboe Volatility Index (try: gloomberb quote ^VIX)", under a bare root that found nothing. */
+export function indexRootTryLine(root: IndexRoot, command = "quote"): string {
+  return `${root.symbol}  ${root.name} (try: gloomberb ${command} ${root.symbol})`;
+}
+
+/** "also ^MOVE ICE BofA MOVE Index (gloomberb quote ^MOVE)", under a bare root that quoted another instrument. */
+export function indexRootAlsoLine(root: IndexRoot, command = "quote"): string {
+  return `also ${root.symbol} ${root.name} (gloomberb ${command} ${root.symbol})`;
+}

package/src/cli/index.ts

@@ -16,14 +16,16 @@ import {
   renderCliHelp,
   renderCommandHelp,
   suggestCliCommand,
+  TABLE_SECTION_OPTION,
   type CliHelpEntry,
 } from "./help";
 import { parsePaneFunctionArgs } from "./pane-functions/options";
-import { fail, inferCliErrorOptions, printCliError } from "./errors";
-import { setCliColorEnabledOverride } from "../utils/cli-output";
+import { checkCliCommandOptions } from "./command-options";
+import { asUsageError, fail, inferCliErrorOptions, printCliError } from "./errors";
+import { setCliColorEnabledOverride, setCliWidthOverride } from "../utils/cli-output";
 import { search, searchCandidatesForCli, buildSearchReport } from "./commands/search";
 import { ticker } from "./commands/ticker";
-import { takeOption } from "./commands/command-utils";
+import { requireOneArg, takeOption } from "./commands/command-utils";
 import { EXCHANGE_OPTION } from "./listing-arg";
 import { apiCliCommand } from "./commands/api";
 import { marketDataCliCommands } from "./commands/market";
@@ -107,11 +109,8 @@ function createCoreCliCommands(
       execute: async (rawArgs, ctx) => {
         const args = [...rawArgs];
         const exchange = takeOption(args, "--exchange");
-        const symbol = args[0];
-        if (!symbol) {
-          ctx.fail("Usage: gloomberb ticker <symbol>");
-        }
-        await ticker(symbol!, {
+        const symbol = requireOneArg(args, "ticker <symbol>", "symbol", ctx);
+        await ticker(symbol, {
           exchange,
           initMarketData: ctx.initMarketData,
           fail: ctx.fail,
@@ -128,7 +127,7 @@ function createCoreCliCommands(
         usage: ["catalog [query] [--all] [--bot-safe]"],
         options: [
           { flags: "--all", description: "List every match instead of the first 25" },
-          { flags: "--bot-safe", description: "Only functions with a verified unattended report" },
+          { flags: "--bot-safe, --botsafe", description: "Only functions with a verified unattended report" },
         ],
         examples: ["catalog", "catalog options", "catalog HP"],
       },
@@ -146,12 +145,17 @@ function createCoreCliCommands(
         options: [
           { flags: "--<option> <value>", description: "A function setting; gloomberb catalog <function> lists them" },
           { flags: "--require-bot-safe", description: "Fail unless the function has a verified, complete report" },
+          {
+            ...TABLE_SECTION_OPTION,
+            description: `${TABLE_SECTION_OPTION.description} (CALLS keeps --section for the transcript part)`,
+          },
           EXCHANGE_OPTION,
         ],
         examples: [
           "fn HP AAPL",
           "fn ANR SAN:EPA",
           "fn CBR --json",
+          "fn WEI --csv --section europe > europe.csv",
           "fn 13F AAPL --view=ticker-holdings",
           "fn OVME --spot 100 --strike 100 --days 30 --volatility 25",
         ],
@@ -172,9 +176,10 @@ function createCoreCliCommands(
           { flags: "--output <path>", description: "PNG to write; defaults to gloomberb-<function>-<argument>.png in this folder" },
           { flags: "--width <px>", description: "Image width, 720 to 2400 (default 1280)" },
           { flags: "--height <px>", description: "Image height, 360 to 1800 (default 720)" },
-          { flags: "--theme <id>", description: "Render with another theme, such as amber or green" },
+          { flags: "--theme <id>", description: "Render with another theme, such as amber or colorblind; gloomberb config themes lists them" },
           { flags: "--scale <n>", description: "Text scale from 0.5 to 4 (default 1)" },
           { flags: "--watermark <label>", description: "Label drawn in the pane title bar" },
+          { flags: "--no-status", description: "Leave out the dated status line (as-of, delay, market hours) drawn in the pane footer" },
           { flags: "--<option> <value>", description: "A function setting; gloomberb catalog <function> lists them" },
           EXCHANGE_OPTION,
         ],
@@ -183,6 +188,7 @@ function createCoreCliCommands(
           "shot HP BHP:ASX",
           "shot DDIS MSFT --tab history",
           "shot HP NVDA --width 1600 --theme green",
+          "shot QQ AAPL,MSFT --no-status",
         ],
       },
       execute: async (args, ctx) => {
@@ -332,11 +338,12 @@ export async function dispatchCli(args: string[], options: DispatchCliOptions =
   try {
     parsed = parseCliGlobalArgs(args);
   } catch (error) {
-    printCliError(error, inferCliErrorOptions(args));
+    printCliError(asUsageError(error), inferCliErrorOptions(args));
     process.exitCode = 1;
     return { kind: "handled" };
   }
   setCliColorEnabledOverride(parsed.options.color);
+  setCliWidthOverride(parsed.options.width ?? null);
   const command = parsed.args[0] ?? (parsed.help ? "help" : undefined);
   if (!command) {
     return { kind: "unhandled" };
@@ -354,13 +361,14 @@ export async function dispatchCli(args: string[], options: DispatchCliOptions =
   const target = helpOnly ? registry.lookup.get("help")! : resolved;
   const commandArgs = helpOnly ? [resolved.command.name] : parsed.args.slice(1);
   try {
+    if (!helpOnly && resolved.builtin) checkCliCommandOptions(resolved.command, commandArgs, parsed.literalStart - 1);
     const result = await target.command.execute(
       commandArgs,
-      createCliCommandContext(target.ownerId, registry, parsed.options),
+      createCliCommandContext(target.ownerId, registry, parsed.options, commandArgs),
     );
     return normalizeCliDispatchResult(result);
   } catch (error) {
-    printCliError(error, parsed.options, { command: resolved.command.name });
+    printCliError(error, parsed.options, { command: resolved.command.name, args: commandArgs });
     process.exitCode = 1;
     return { kind: "handled" };
   }

package/src/cli/listing-arg.ts

@@ -8,10 +8,13 @@ import {
   canonicalExchange,
   exchangeLabel,
   isKnownExchangeCode,
+  isUsListingExchange,
   parsePublicTickerKey,
   publicTickerKey,
+  resolveExchangeTimeZone,
 } from "../utils/exchanges";
 import { withMarketData } from "./scoped-context";
+import { isNoProviderMessage } from "../sources/provider-errors";
 
 /** The `--exchange` option of every command that takes a ticker. */
 export const EXCHANGE_OPTION = {
@@ -156,32 +159,237 @@ export async function failIfNotTraded(
   if (message) ctx.fail(message);
 }
 
+/** What a command asked a listing for, to name it when the listing has none: `history` asks for "history". */
+export interface ListingDataRequest {
+  /** The command a retry runs, with any options to repeat: `history`, `history --range 5Y`. */
+  command: string;
+  /** What the listing has none of: "history", "a quote". */
+  noun: string;
+}
+
+/**
+ * The router's answer when no source serves a symbol: "No history provider available for 2222",
+ * or "Not a ticker: 2222." when the service found no listing for it.
+ */
+export function isNoProviderError(error: unknown): boolean {
+  return isNoProviderMessage(error instanceof Error ? error.message : String(error ?? ""));
+}
+
+const MAX_OTHER_LISTINGS = 5;
+
+type BareListing = Pick<CliListing, "symbol" | "exchange"> & Partial<Pick<CliListing, "saved">>;
+
+/** Where a bare symbol went and where else it trades, in the order they are tried and named. */
+interface BareListingVenues {
+  /** Canonical code of the venue the symbol went to. */
+  exchange: string;
+  /** That venue as search lists it; null for a saved venue search no longer lists. */
+  resolved: ListingVenue | null;
+  /** The symbol's other venues, in search order. */
+  others: ListingVenue[];
+}
+
+/** A bare symbol goes to its saved listing, else to the one search lists first. Null when it named its exchange. */
+async function bareListingVenues(listing: BareListing, deps: ListingDeps): Promise<BareListingVenues | null> {
+  if (listing.exchange) return null;
+  const venues = await listingVenues(listing.symbol, deps).catch(() => []);
+  const savedExchange = canonicalExchange(listing.saved?.metadata.exchange);
+  const resolved = venues.find((venue) => venue.exchange === savedExchange) ?? (savedExchange ? null : venues[0] ?? null);
+  const exchange = resolved?.exchange ?? savedExchange;
+  if (!exchange) return null;
+  return { exchange, resolved, others: venues.filter((venue) => venue !== resolved && venue.exchange !== savedExchange) };
+}
+
+interface OtherListingsMessage {
+  message: string;
+  details: string;
+  /** SAN:EPA, for each other listing. */
+  others: string[];
+}
+
+function describeOtherListings(
+  listing: BareListing,
+  { exchange, resolved, others }: BareListingVenues,
+  request: ListingDataRequest,
+): OtherListingsMessage | null {
+  if (others.length === 0) return null;
+  const name = resolved?.name || listing.saved?.metadata.name?.trim() || "";
+  const [command, ...options] = request.command.split(" ");
+  const retry = (key: string) => ["gloomberb", command, key, ...options].join(" ");
+  const lines = others.slice(0, MAX_OTHER_LISTINGS).map((venue) => {
+    const key = `${listing.symbol}:${venue.exchange}`;
+    return `${key}${venue.name ? ` ${venue.name}` : ""} (try: ${retry(key)})`;
+  });
+  if (others.length > MAX_OTHER_LISTINGS) lines.push(`and ${others.length - MAX_OTHER_LISTINGS} more: gloomberb search ${listing.symbol}`);
+  return {
+    message: `${listing.symbol} resolved to ${name ? `${name} (${exchange})` : exchange}, which has no ${request.noun}.`,
+    details: lines.length === 1 ? `Other listings: ${lines[0]}` : ["Other listings:", ...lines.map((line) => `  ${line}`)].join("\n"),
+    others: others.map((venue) => `${listing.symbol}:${venue.exchange}`),
+  };
+}
+
+/**
+ * For a bare symbol whose request found no source: the listing it went to and
+ * the symbol's other listings, each with the command that asks for it, such
+ * as "2222 resolved to Kotobuki Spirits Co., Ltd. (JPX), which has no
+ * history." and "2222:TADAWUL Saudi Arabian Oil Co. (try: gloomberb history
+ * 2222:TADAWUL)". Null when the symbol named its exchange or has no other
+ * listing. It searches, so ask only after a request failed.
+ */
+async function otherListingsMessage(
+  listing: BareListing,
+  deps: ListingDeps,
+  request: ListingDataRequest,
+): Promise<OtherListingsMessage | null> {
+  const venues = await bareListingVenues(listing, deps);
+  return venues && describeOtherListings(listing, venues, request);
+}
+
+/** The listing on one venue, as `SYM:EXCH` names it. */
+function namedListing(listing: CliListing, exchange: string): CliListing {
+  const key = `${listing.symbol}:${exchange}`;
+  const saved = canonicalExchange(listing.saved?.metadata.exchange) === exchange ? listing.saved : null;
+  return { symbol: listing.symbol, exchange, key, saved, request: { symbol: key, exchange } };
+}
+
+async function quoteListings(
+  dataProvider: DataProvider,
+  listings: readonly CliListing[],
+  refresh: boolean,
+): Promise<Array<Quote | null>> {
+  if (listings.length === 0) return [];
+  const targets = listings.map((listing) => listing.request);
+  if (dataProvider.getQuotesBatch) {
+    const results = await dataProvider.getQuotesBatch(targets, { forceRefresh: refresh }).catch(() => []);
+    return targets.map((target, index) => (results.find((result) => result.target === target) ?? results[index])?.quote ?? null);
+  }
+  return Promise.all(targets.map((target) => dataProvider.getQuote(target.symbol, target.exchange, {
+    cacheMode: refresh ? "refresh" : "default",
+  }).catch(() => null)));
+}
+
+export type BareListingQuote =
+  | {
+    kind: "quoted";
+    /** The listing that has a quote: SXR8:XETRA. */
+    listing: CliListing;
+    quote: Quote;
+    /** "SXR8 -> XETRA (other listings: BUD, MUNICH)". */
+    note: string;
+  }
+  | ({ kind: "missing" } & OtherListingsMessage);
+
+/**
+ * The quote for a bare symbol no source quoted. The data service reads a
+ * symbol with no US listing on its home listing abroad (`bareListingNote`),
+ * so this is left for one it reads on none, as a code several companies list
+ * (2222 is Kotobuki Spirits in Tokyo and Saudi Aramco in Riyadh), and for a
+ * home listing with no quote. Search knows where the symbol trades: each
+ * listing is asked again by its own key (2222:JPX), as a named one is. The
+ * listing the symbol resolved to goes first, then the others together, and
+ * the first in search order with a quote is the answer. When none has one,
+ * the `otherListingsMessage` failure. Null when the symbol named its exchange
+ * (a named venue never switches) or search knows no listing of it. It
+ * searches, so ask only after a request failed.
+ */
+export async function quoteBareListing(
+  listing: CliListing,
+  deps: ListingDeps,
+  request: ListingDataRequest,
+  { refresh = false }: { refresh?: boolean } = {},
+): Promise<BareListingQuote | null> {
+  const venues = await bareListingVenues(listing, deps);
+  if (!venues) return null;
+  const first = [namedListing(listing, venues.exchange)];
+  const rest = venues.others.map((venue) => namedListing(listing, venue.exchange));
+  let tried = first;
+  let quotes = await quoteListings(deps.dataProvider, first, refresh);
+  if (!quotes[0] && rest.length > 0) {
+    tried = [...first, ...rest];
+    quotes = [...quotes, ...await quoteListings(deps.dataProvider, rest, refresh)];
+  }
+  const found = quotes.findIndex(Boolean);
+  if (found < 0) {
+    const other = describeOtherListings(listing, venues, request);
+    return other && { kind: "missing", ...other };
+  }
+  const answer = tried[found]!;
+  const without = tried.slice(0, found).map((entry) => entry.exchange);
+  // Listings not asked, or asked and quoted, are still there to name.
+  const others = [...first, ...rest]
+    .filter((entry, index) => entry !== answer && (index >= tried.length || quotes[index]))
+    .map((entry) => entry.exchange);
+  const more = others.length - MAX_OTHER_LISTINGS;
+  const aside = [
+    without.length > 0 ? `no quote on ${without.join(", ")}` : "",
+    others.length > 0
+      ? `other listings: ${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloomberb search ${listing.symbol}` : ""}`
+      : "",
+  ].filter(Boolean).join("; ");
+  return {
+    kind: "quoted",
+    listing: answer,
+    quote: quotes[found]!,
+    note: `${listing.symbol} -> ${answer.exchange}${aside ? ` (${aside})` : ""}`,
+  };
+}
+
+// The zones of the US exchanges; a venue in another is abroad.
+const US_TIME_ZONES = new Set(["America/New_York", "America/Chicago"]);
+
+/**
+ * "SXR8 -> XETRA" for a bare symbol the data service read on its home listing
+ * abroad, as it reads a symbol with no US listing whose listings belong to one
+ * company or fund: a row that shows the symbol as typed says which listing it
+ * is. Null for a named or saved venue, and for a venue the app does not place
+ * outside the US (a US exchange, OTC, a futures exchange).
+ */
+export function bareListingNote(
+  listing: Pick<CliListing, "symbol" | "request">,
+  quote: Pick<Quote, "listingExchangeName" | "exchangeName"> | null | undefined,
+): string | null {
+  if (listing.request.exchange || !quote || !/^[A-Z0-9]{1,10}$/.test(listing.symbol)) return null;
+  const venue = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+  const zone = resolveExchangeTimeZone(venue);
+  return zone && !US_TIME_ZONES.has(zone) && !isUsListingExchange(venue) ? `${listing.symbol} -> ${venue}` : null;
+}
+
 /**
  * A data request for the listings a command named. When it throws, or `isMiss`
  * calls what it returned empty, and a listing's exchange is one its symbol does
  * not trade on, the command ends in that message instead of the request's own
- * "unavailable". A request that succeeds costs no extra lookup.
+ * "unavailable". With `request`, a bare symbol no source serves ends naming
+ * its other listings (`otherListingsMessage`). A request that succeeds costs no
+ * extra lookup.
  */
 export async function loadForListing<T>(
-  listings: Pick<ListingArg, "symbol" | "exchange"> | readonly Pick<ListingArg, "symbol" | "exchange">[],
+  listings: ListingForLoad | readonly ListingForLoad[],
   deps: ListingDeps,
   ctx: Pick<CliCommandContext, "fail">,
   load: () => Promise<T>,
   isMiss?: (value: T) => boolean,
+  request?: ListingDataRequest,
 ): Promise<T> {
-  const named = ("symbol" in listings ? [listings] : listings).filter((listing) => listing.exchange);
+  const all = "symbol" in listings ? [listings] : listings;
+  const named = all.filter((listing) => listing.exchange);
   const checkVenues = () => Promise.all(named.map((listing) => failIfNotTraded(listing, deps, ctx)));
   let value: T;
   try {
     value = await load();
   } catch (error) {
     await checkVenues();
+    if (request && all.length === 1 && isNoProviderError(error)) {
+      const other = await otherListingsMessage(all[0]!, deps, request);
+      if (other) ctx.fail(other.message, other.details);
+    }
     throw error;
   }
   if (isMiss?.(value)) await checkVenues();
   return value;
 }
 
+type ListingForLoad = Pick<ListingArg, "symbol" | "exchange"> & Partial<Pick<CliListing, "saved">>;
+
 /** The saved ticker for a listing: under its own key, or a saved symbol whose venue it is. */
 export async function loadSavedListing(store: ListingStore, listing: ListingArg): Promise<TickerRecord | null> {
   if (!listing.exchange) return store.loadTicker(listing.symbol);