@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/cli/history-rows.ts

@@ -12,7 +12,7 @@ import {
 import { classifyInstrumentType } from "../tickers/instrument-kind";
 import { isRoundTheClockCoin } from "../utils/crypto-pair";
 import { currencyPairCode } from "../utils/currency-pair";
-import { currencyUnitLabel } from "../utils/currency-units";
+import { currencyUnitLabel, resolveCurrencyUnit } from "../utils/currency-units";
 import { getPricePointTimestamp } from "../utils/price-history";
 import { latestTradeIndex, missingVolumeNotice, pricePointIntegrityFlags, pricePointValues } from "../utils/price-history-integrity";
 import { formatUtcTime } from "../utils/utc-time";
@@ -109,6 +109,42 @@ export function cleanFloat32Price(value: number): number {
   return value;
 }
 
+/**
+ * The finest step a venue that quotes in a sub-unit prices in, in decimals of
+ * that unit: a ten-thousandth of a penny, the smallest tick London's tick
+ * tables use (for its lowest-priced shares).
+ */
+const SUB_UNIT_TICK_DECIMALS = 4;
+/** The decimals of that sub-unit a table of bars shows: a tenth of a penny, 638.5p as 6.385. */
+const SUB_UNIT_SHOWN_DECIMALS = 1;
+
+/**
+ * A bar's price as the decimal it is (`cleanFloat32Price`). A price served in
+ * a sub-unit and divided into its currency (`divisor` 100: a London line's
+ * pence, as pounds) carries the float32 noise of the pence it was quoted in
+ * (623.59998p is 6.2359998), so it is cleaned in pence, kept to the venue's
+ * finest tick there, then divided: 6.236.
+ */
+export function cleanBarPrice(value: number, divisor = 1): number {
+  if (!(divisor > 1) || !Number.isFinite(divisor) || !Number.isFinite(value) || value === 0) return cleanFloat32Price(value);
+  const subUnit = cleanFloat32Price(value * divisor);
+  const places = Math.min(SUB_UNIT_TICK_DECIMALS, decimalPlaces(subUnit));
+  const unitPlaces = Math.round(Math.log10(divisor));
+  return Number((Number(subUnit.toFixed(places)) / divisor).toFixed(places + unitPlaces));
+}
+
+/**
+ * How many of the unit a quote's prices were served in make one of the
+ * currency it shows them in: 100 for a London line priced in pence and shown
+ * in pounds, 1 for any other. A quote in a sub-unit itself (`GBp`) shows the
+ * prices as served: they are cleaned as they are.
+ */
+export function quotedPriceDivisor(quote: { currency?: string; providerPriceDivisor?: number } | null | undefined): number {
+  const divisor = quote?.providerPriceDivisor;
+  if (resolveCurrencyUnit(quote?.currency).divisor > 1) return 1;
+  return divisor != null && Number.isFinite(divisor) && divisor > 1 ? divisor : 1;
+}
+
 function isUtcMidnight(time: number): boolean {
   return new Date(time).toISOString().endsWith("T00:00:00.000Z");
 }
@@ -229,6 +265,8 @@ export function historyRows(
   currency: string | null = null,
   unit: string | null = null,
   volume: HistoryVolume | null = null,
+  /** The listing's `quotedPriceDivisor`: prices served in pence are cleaned in pence. */
+  priceDivisor = 1,
 ): HistoryRow[] {
   const times = points.map(getPricePointTimestamp);
   const intraday = resolution ? isIntradayResolution(resolution) : looksIntraday(times);
@@ -240,7 +278,7 @@ export function historyRows(
     const iso = Number.isFinite(time) ? new Date(time).toISOString() : "";
     const values = pricePointValues(point);
     const flags = pricePointIntegrityFlags(point);
-    const price = (value: number | null) => value == null ? null : cleanFloat32Price(value);
+    const price = (value: number | null) => value == null ? null : cleanBarPrice(value, priceDivisor);
     return {
       date: intraday ? iso.replace(".000Z", "Z") : iso.slice(0, 10),
       open: price(values.open),
@@ -440,8 +478,14 @@ function neededDecimals(value: number, cap: number): number {
  * row. A known asset kind caps it with the app's price display rules; without
  * 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.
+ * Prices served in a sub-unit (`priceDivisor` 100, a London line's pence) may
+ * keep a tenth of it too: 6.385 for 638.5p. Finer ticks stay in the export.
  */
-export function historyPriceDecimals(rows: readonly Pick<HistoryRow, typeof PRICE_KEYS[number]>[], assetCategory?: string): number {
+export function historyPriceDecimals(
+  rows: readonly Pick<HistoryRow, typeof PRICE_KEYS[number]>[],
+  assetCategory?: string,
+  priceDivisor = 1,
+): 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)] : [];
@@ -450,9 +494,12 @@ export function historyPriceDecimals(rows: readonly Pick<HistoryRow, typeof PRIC
   const largest = values.reduce((max, value) => Math.max(max, value), 0);
   const magnitude = Math.floor(Math.log10(largest));
   const significantCap = largest >= 1 ? Math.max(2, 6 - magnitude) : 6 - magnitude;
-  const cap = resolveAssetDisplayKind({ assetCategory }) === "other"
+  // A line priced in pence is a share or a fund on its exchange, whatever kind its row was saved as.
+  const subUnit = priceDivisor > 1;
+  const kind = subUnit && resolveAssetDisplayKind({ assetCategory }) === "other" ? "EQUITY" : assetCategory;
+  const cap = resolveAssetDisplayKind({ assetCategory: kind }) === "other"
     ? significantCap
-    : Math.min(significantCap, marketPriceFractionDigitCeiling(largest, { assetCategory }));
+    : Math.min(significantCap, marketPriceFractionDigitCeiling(largest, { assetCategory: kind }) + (subUnit ? SUB_UNIT_SHOWN_DECIMALS : 0));
   const needed = values.map((value) => neededDecimals(value, cap)).sort((left, right) => left - right);
   const decimals = needed[Math.floor(0.9 * (needed.length - 1))]!;
   return largest >= 1 ? Math.max(2, decimals) : decimals;
@@ -470,13 +517,14 @@ interface BarPrices {
  * The decimals one table of bars prints its prices with (`history`, HP's pane
  * and `fn HP`): historyPriceDecimals over the float32-cleaned prices, so a
  * feed's 4013.39990234 reads as the 4013.4 it is and the count follows the
- * asset's display rules (two for gold, three for silver, cents for a US equity).
+ * asset's display rules (two for gold, three for silver, cents for a US equity,
+ * and a London line's pence: 6.385 for 638.5p, with `priceDivisor` 100).
  */
-export function barPriceDecimals(bars: readonly BarPrices[], assetCategory?: string): number {
-  const clean = (value: number | null | undefined) => value == null ? null : cleanFloat32Price(value);
+export function barPriceDecimals(bars: readonly BarPrices[], assetCategory?: string, priceDivisor = 1): number {
+  const clean = (value: number | null | undefined) => value == null ? null : cleanBarPrice(value, priceDivisor);
   return historyPriceDecimals(bars.flatMap((bar) => bar.close == null ? [] : [{
     date: "", open: clean(bar.open), high: clean(bar.high), low: clean(bar.low), close: clean(bar.close)!, volume: null,
-  }]), assetCategory);
+  }]), assetCategory, priceDivisor);
 }
 
 /** A price at the table's decimal count (barPriceDecimals), within `maxWidth` when the pane gives one. */

package/src/cli/index.ts

@@ -179,6 +179,7 @@ export function createCoreCliCommands(
           { flags: "--<option> <value>", description: "A function setting; gloom catalog <function> lists them" },
           { flags: "--require-bot-safe", description: "Fail unless the function has a verified, complete report" },
           { flags: "--explain", description: "Follow the report with what its terms mean (text and JSON; CSV keeps the rows)" },
+          { flags: "--output <path>, --out <path>", description: "Write the report to this file, in the format asked for, and print where it went" },
           {
             ...TABLE_SECTION_OPTION,
             description: `${TABLE_SECTION_OPTION.description} (CALLS keeps --section for the transcript part)`,
@@ -190,6 +191,7 @@ export function createCoreCliCommands(
           "fn ANR SAN:EPA",
           "fn CBR --json",
           "fn WEI --csv --section europe > europe.csv",
+          "fn RV NEE,FSLR --csv --output rv.csv",
           "fn 13F AAPL --view=ticker-holdings",
           "fn OVME --spot 100 --strike 100 --days 30 --volatility 25",
           "fn HIVG SPY --event fomc --offset -6 --lookback ALL --csv",

package/src/cli/listing-arg.ts

@@ -15,12 +15,12 @@ import {
   type ListingVenue,
 } from "../tickers/listing-venues";
 import { findUsListingOfCompany, type UsListing } from "../tickers/us-listing";
-import { findListingOfCompanyName, isCompanyNameInput, readTerminalCodeArg } from "../tickers/company-name-listing";
+import { findListingOfCompanyName, isCompanyNameInput, readTerminalCodeArg, type CompanyNameListing } from "../tickers/company-name-listing";
 import { movedAwayChange, startTickerChangeLookup, type MovedTickerChange } from "../tickers/ticker-changes";
 import { loadListingFate, MovedSymbolError, type ListingFate } from "../tickers/listing-fate";
 import { quotedListingName } from "../tickers/listing-name";
 import { cliStyles } from "../utils/cli-output";
-import { groupByCompany, sameCompany, shortCompanyName } from "../tickers/company-name";
+import { groupByCompany, namesDepositaryReceipt, sameCompany, sameListedName, shortCompanyName } from "../tickers/company-name";
 import {
   canonicalExchange,
   exchangeCodeVenues,
@@ -35,7 +35,7 @@ import {
 import { withMarketData } from "./scoped-context";
 import { failWithFields } from "./errors";
 import { stripStrayEdges } from "./symbol-args";
-import { isNoProviderMessage, isProviderBusy } from "../sources/provider-errors";
+import { isNoProviderMessage, isNoSourceAnswer, isProviderBusy } from "../sources/provider-errors";
 import { dashedCoinPair, MAJOR_COIN_NAMES } from "../utils/crypto-pair";
 import { boardCoinFor, primeBoardCoins } from "./board-coins";
 import { knownGapMessage } from "./known-gaps";
@@ -49,10 +49,12 @@ import {
   bloombergMarketHint,
   endsInLegalForm,
   isSearchOnlyVenue,
+  readLondonDottedSymbol,
   readNearMissListing,
   readTerminalListingCode,
   terminalCodeReadAs,
   unknownBloombergMarket,
+  type NearMissListing,
   type TerminalListingCode,
 } from "../tickers/terminal-codes";
 import { listingAbroadVenue } from "../utils/sec";
@@ -338,6 +340,15 @@ export function isNoProviderError(error: unknown): boolean {
   return isNoProviderMessage(error instanceof Error ? error.message : String(error ?? ""));
 }
 
+/**
+ * The router's answer that no source served a request because one failed (a
+ * timeout, a rate limit, a refused session) rather than missed: it says
+ * nothing about whether the symbol exists, unlike "Not a ticker".
+ */
+export function isUnsettledNoProvider(error: unknown): boolean {
+  return isNoProviderError(error) && !isNoSourceAnswer(error);
+}
+
 const MAX_OTHER_LISTINGS = 5;
 
 type BareListing = Pick<CliListing, "symbol" | "exchange"> & Partial<Pick<CliListing, "saved">>;
@@ -359,33 +370,42 @@ function listsSeveralCompanies(venues: readonly ListingVenue[]): boolean {
   return groupByCompany(venues, (venue) => venue.name).length > 1;
 }
 
-/** Every other company that lists the symbol once, at its first venue in search order. */
+/**
+ * Every other company or fund that lists the symbol, once, at its first venue
+ * in search order. A venue is another's only when its name says so: one with
+ * no name, or a depositary receipt named unlike the company (a CEDEAR's short
+ * form of its fund's name), is left out rather than guessed at, and one
+ * fund's venues are one fund however each words it (`sameListedName`).
+ */
 function otherCompanies(venues: readonly ListingVenue[], company: string): ListingVenue[] {
-  return groupByCompany(venues, (venue) => venue.name)
-    .filter((group) => !group.some((venue) => sameCompany(venue.name, company)))
+  if (!company.trim()) return [];
+  const known = venues.filter((venue) => !namesDepositaryReceipt(venue.name) || sameListedName(venue.name, company));
+  return groupByCompany(known, (venue) => venue.name, sameListedName)
+    .filter((group) => !group.some((venue) => sameListedName(venue.name, company)))
     .map((group) => group[0]!);
 }
 
 /**
- * "CAR = Avis Budget Group, NASDAQ (also XETRA, ASX)": the listing a bare
- * symbol several companies list was read on, and where the others list it.
- * Null when one company lists it, so a symbol that means one thing says
- * nothing.
+ * "CAR = Avis Budget Group, NASDAQ (different companies on XETRA, ASX)": the
+ * listing a bare symbol several companies list was read on, and where the
+ * others list it. Null when no other company is known to list it, so a symbol
+ * that means one thing (XLK, and its receipt in Buenos Aires) says nothing.
  */
 export function listingChoiceNote(
   symbol: string,
   chosen: { exchange: string; name?: string | null },
   venues: readonly ListingVenue[],
 ): string | null {
-  if (!chosen.exchange || !listsSeveralCompanies(venues)) return null;
+  if (!chosen.exchange) return null;
   const chosenVenue = venues.find((venue) => venue.exchange === chosen.exchange);
   const name = chosen.name?.trim() || chosenVenue?.name || "";
   const others = otherCompanies(venues, chosenVenue?.name || name).map((venue) => venue.exchange)
     .filter((exchange) => exchange !== chosen.exchange);
   if (others.length === 0) return null;
   const more = others.length - MAX_OTHER_LISTINGS;
-  const also = `${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloom search ${symbol}` : ""}`;
-  return `${symbol} = ${name ? `${shortCompanyName(name)}, ` : ""}${chosen.exchange} (also ${also})`;
+  const named = `${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloom search ${symbol}` : ""}`;
+  const which = others.length === 1 ? "a different company" : "different companies";
+  return `${symbol} = ${name ? `${shortCompanyName(name)}, ` : ""}${chosen.exchange} (${which} on ${named})`;
 }
 
 // Quotes of these never name a company's listing, so they are never a choice between companies.
@@ -409,34 +429,50 @@ export function listingReadNotes(listing: Pick<ListingArg, "readAs">): string[]
   return listing.readAs ? [listing.readAs] : [];
 }
 
+/**
+ * The coin line for a bare coin ticker (SOL, ETH) a command read as a listing that is
+ * not the coin, from the quote it was read on (`notTheCoinNote`). A list, so a command can
+ * spread it into its warnings. A named listing (`ETH:ARCA`, `--exchange`) asked for that
+ * listing on purpose and gets none.
+ */
+export function coinListingNotes(
+  listing: Pick<CliListing, "symbol" | "exchange">,
+  quote: Pick<Quote, "name" | "instrumentType" | "stale" | "delisting"> | null | undefined,
+): string[] {
+  const note = listing.exchange ? null : notTheCoinNote(listing.symbol, quote);
+  return note ? [note] : [];
+}
+
 /**
  * `listingChoiceNote` for a listing a command resolved, from the quote it was
  * read on: only a bare symbol went where the data service chose. A named
  * listing whose code names several venues says which it was read as
- * (`listingReadNotes`). A list, so a command can spread it into its warnings.
+ * (`listingReadNotes`). A bare coin ticker read as another listing ends with
+ * the coin's pair (`coinListingNotes`). A list, so a command can spread it into
+ * its warnings.
  */
 export async function listingChoiceNotes(
   listing: Pick<CliListing, "symbol" | "exchange" | "saved" | "readAs">,
   deps: ListingDeps,
-  quote: Pick<Quote, "name" | "listingExchangeName" | "exchangeName" | "instrumentType"> | null | undefined,
+  quote: Pick<Quote, "name" | "listingExchangeName" | "exchangeName" | "instrumentType" | "stale" | "delisting"> | null | undefined,
   /** The venues `loadBareVenues` already started; looked up here when not given. */
   venues?: Promise<ListingVenue[]> | null,
 ): Promise<string[]> {
-  if (!isBareListing(listing)) return listingReadNotes(listing);
-  if (!quote || UNLISTED_TYPES.has(quote.instrumentType?.trim().toUpperCase() ?? "")) return [];
+  const coin = coinListingNotes(listing, quote);
+  if (!isBareListing(listing)) return [...listingReadNotes(listing), ...coin];
+  if (!quote || UNLISTED_TYPES.has(quote.instrumentType?.trim().toUpperCase() ?? "")) return coin;
   const exchange = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
-  if (!exchange) return [];
+  if (!exchange) return coin;
   const listed = await (venues ?? loadBareVenues(listing, deps) ?? []);
   const note = listingChoiceNote(listing.symbol, { exchange, name: quote.name }, listed);
-  return note ? [note] : [];
+  return [...note ? [note] : [], ...coin];
 }
 
 /**
  * `listingChoiceNotes` for a command with no quote of its own to read the
  * listing from (`fn`): it loads the listing's quote, and only for a bare
  * symbol, so a named or saved listing costs nothing. A bare coin ticker read
- * as a fund (BTC, the Grayscale trust) ends with `quote`'s note naming the
- * coin's pair.
+ * as another listing (BTC, the Grayscale trust) ends with the coin's pair.
  */
 export async function quotedListingChoiceNotes(
   listing: Pick<CliListing, "symbol" | "exchange" | "saved" | "request" | "readAs">,
@@ -444,9 +480,7 @@ export async function quotedListingChoiceNotes(
 ): Promise<string[]> {
   const venues = loadBareVenues(listing, deps);
   if (!venues) return listingReadNotes(listing);
-  const quote = await loadListingQuote(deps.dataProvider, listing);
-  const coin = notTheCoinNote(listing.symbol, quote);
-  return [...await listingChoiceNotes(listing, deps, quote, venues), ...coin ? [coin] : []];
+  return listingChoiceNotes(listing, deps, await loadListingQuote(deps.dataProvider, listing), venues);
 }
 
 /**
@@ -563,31 +597,43 @@ export function futuresTryLine(symbol: string, request: ListingDataRequest): str
   return `${future.symbol} ${future.name} future${retry ? ` (try: ${retry})` : ""}`;
 }
 
+/** A venue's listing as its key names it: under its own symbol there (BP:LSE for `BP.`), else the one asked for. */
+function venueKey(symbol: string, venue: Pick<ListingVenue, "exchange" | "symbol">): string {
+  return `${venue.symbol ?? symbol}:${venue.exchange}`;
+}
+
 function describeOtherListings(
   listing: BareListing,
   { exchange, resolved, others, choose }: BareListingVenues,
   request: ListingDataRequest,
+  /** Listings just asked that had none: named as having none, never offered to try. */
+  without: readonly ListingVenue[] = [],
 ): OtherListingsMessage | null {
   const future = futuresTryLine(listing.symbol, request);
-  if (others.length === 0 && !future) return null;
+  const offered = others.filter((venue) => !without.includes(venue));
+  if (offered.length === 0 && !future && without.length === 0) return null;
   const name = resolved?.name || listing.saved?.metadata.name?.trim() || "";
-  const lines = others.slice(0, MAX_OTHER_LISTINGS).map((venue) => {
-    const key = `${listing.symbol}:${venue.exchange}`;
+  const lines = offered.slice(0, MAX_OTHER_LISTINGS).map((venue) => {
+    const key = venueKey(listing.symbol, venue);
     const retry = retryCommand(request, key);
     return `${key}${venue.name ? ` ${venue.name}` : ""}${retry ? ` (try: ${retry})` : ""}`;
   });
-  if (others.length > MAX_OTHER_LISTINGS) lines.push(`and ${others.length - MAX_OTHER_LISTINGS} more: gloom search ${listing.symbol}`);
+  if (offered.length > MAX_OTHER_LISTINGS) lines.push(`and ${offered.length - MAX_OTHER_LISTINGS} more: gloom search ${listing.symbol}`);
   if (future) lines.push(future);
-  const heading = choose ? "Listings" : "Other listings";
+  // Every other listing was asked and had nothing: they are named as such, with nothing to try.
+  const heading = choose ? "Listings" : lines.length === 0 ? `No ${request.noun} on its other listings either` : "Other listings";
+  const named = lines.length === 0 ? without : offered;
+  const details = lines.length === 0 ? `${heading}: ${without.map((venue) => venueKey(listing.symbol, venue)).join(", ")}.`
+    : lines.length === 1 ? `${heading}: ${lines[0]}` : [`${heading}:`, ...lines.map((line) => `  ${line}`)].join("\n");
   return {
     // The symbol went to no venue, so none of them is said to lack the data.
     message: choose
       ? `Choose an exchange for ${listing.symbol}.`
       : `${listing.symbol} resolved to ${name ? `${name} (${exchange})` : exchange}, which has no ${request.noun}.`,
-    details: lines.length === 1 ? `${heading}: ${lines[0]}` : [`${heading}:`, ...lines.map((line) => `  ${line}`)].join("\n"),
+    details,
     heading,
-    listings: [...others.map((venue) => `${listing.symbol}:${venue.exchange}`), ...future ? [futuresContractByCode(listing.symbol)!.symbol] : []],
-    choices: others.slice(0, MAX_OTHER_LISTINGS).map((venue) => ({ key: `${listing.symbol}:${venue.exchange}`, name: venue.name || null })),
+    listings: [...named.map((venue) => venueKey(listing.symbol, venue)), ...future ? [futuresContractByCode(listing.symbol)!.symbol] : []],
+    choices: offered.slice(0, MAX_OTHER_LISTINGS).map((venue) => ({ key: venueKey(listing.symbol, venue), name: venue.name || null })),
     choose,
   };
 }
@@ -612,30 +658,44 @@ async function otherListingsMessage(
   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}`;
+/** The listing on one venue, as `SYM:EXCH` names it, under the venue's own symbol when search lists one. */
+function namedListing(listing: CliListing, venue: Pick<ListingVenue, "exchange" | "symbol">): CliListing {
+  const { exchange } = venue;
+  const symbol = venue.symbol ?? listing.symbol;
+  const key = `${symbol}:${exchange}`;
   const saved = canonicalExchange(listing.saved?.metadata.exchange) === exchange ? listing.saved : null;
-  return { symbol: listing.symbol, exchange, key, saved, request: { symbol: key, exchange } };
+  return { symbol, exchange, key, saved, request: { symbol: key, exchange } };
 }
 
+/**
+ * Each listing's quote, null where it has none; `undefined` where the request
+ * itself failed, which says nothing of whether it has one.
+ */
 async function quoteListings(
   dataProvider: DataProvider,
   listings: readonly CliListing[],
   refresh: boolean,
   datesChangeBasis = false,
-): Promise<Array<Quote | null>> {
+): Promise<Array<Quote | null | undefined>> {
   if (listings.length === 0) return [];
   const targets = listings.map((listing) => listing.request);
   if (dataProvider.getQuotesBatch) {
     const results = await dataProvider.getQuotesBatch(targets, { forceRefresh: refresh, ...(datesChangeBasis ? { datesChangeBasis } : {}) })
-      .catch(logFailure("cli.listing-arg", "Read listing quote batch failed", []));
-    return targets.map((target, index) => (results.find((result) => result.target === target) ?? results[index])?.quote ?? null);
+      .catch(logFailure("cli.listing-arg", "Read listing quote batch failed", null));
+    if (!results) return targets.map(() => undefined);
+    return targets.map((target, index) => {
+      const result = results.find((entry) => entry.target === target) ?? results[index];
+      // No source quotes it, which is an answer; any other failure is none.
+      return result?.quote ?? (result && (result.error == null || isNoProviderError(result.error)) ? null : undefined);
+    });
   }
   return Promise.all(targets.map((target) => dataProvider.getQuote(target.symbol, target.exchange, {
     cacheMode: refresh ? "refresh" : "default",
     ...(datesChangeBasis ? { datesChangeBasis } : {}),
-  }).catch(logFailure("cli.listing-arg", "Read listing quote failed", null))));
+  }).catch((error: unknown) => {
+    logFailure("cli.listing-arg", "Read listing quote failed")(error);
+    return isNoProviderError(error) ? null : undefined;
+  })));
 }
 
 export type BareListingQuote =
@@ -674,8 +734,8 @@ export async function quoteBareListing(
     const other = describeOtherListings(listing, venues, request);
     return other && { kind: "missing", ...other };
   }
-  const first = [namedListing(listing, venues.exchange)];
-  const rest = venues.others.map((venue) => namedListing(listing, venue.exchange));
+  const first = [namedListing(listing, venues.resolved ?? { exchange: venues.exchange })];
+  const rest = venues.others.map((venue) => namedListing(listing, venue));
   let tried = first;
   let quotes = await quoteListings(deps.dataProvider, first, refresh, datesChangeBasis);
   if (!quotes[0] && rest.length > 0) {
@@ -684,7 +744,9 @@ export async function quoteBareListing(
   }
   const found = quotes.findIndex(Boolean);
   if (found < 0) {
-    const other = describeOtherListings(listing, venues, request);
+    // A listing just asked that had no quote is no listing to try.
+    const without = venues.others.filter((_venue, index) => quotes[index + 1] === null);
+    const other = describeOtherListings(listing, venues, request, without);
     return other && { kind: "missing", ...other };
   }
   const answer = tried[found]!;
@@ -697,7 +759,8 @@ export async function quoteBareListing(
     kind: "quoted",
     listing: answer,
     quote: quotes[found]!,
-    note: chosenListingNote(listing.symbol, answer.exchange, others, without),
+    // Under the venue's own symbol (BP:LSE for `BP.`), the note names the listing, not only its venue.
+    note: chosenListingNote(listing.symbol, answer.symbol === listing.symbol ? answer.exchange : answer.key, others, without),
   };
 }
 
@@ -708,6 +771,8 @@ export interface ReadListing {
   exchange: string;
   /** The listing's company, from its quote. */
   name: string | null;
+  /** A bare coin ticker read as a listing that is not the coin (`coinListingNotes`); null otherwise. */
+  coinNote: string | null;
 }
 
 /**
@@ -728,10 +793,14 @@ export async function readBareListing(
   const listing = await resolveCliListing(symbol, null, deps);
   if (listing.exchange) return null;
   const answer = await loadListingQuoteAnswer(deps.dataProvider, listing);
-  if (answer.quote) return { symbol: listing.symbol, exchange: listing.request.exchange, name: answer.quote.name?.trim() || null };
+  if (answer.quote) {
+    return { symbol: listing.symbol, exchange: listing.request.exchange, name: answer.quote.name?.trim() || null, coinNote: coinListingNotes(listing, answer.quote)[0] ?? null };
+  }
   if (!isNoProviderError(answer.error)) return null;
   const other = await quoteBareListing(listing, deps, request, { refresh });
-  if (other?.kind === "quoted") return { symbol: listing.symbol, exchange: other.listing.exchange, name: other.quote.name?.trim() || null };
+  if (other?.kind === "quoted") {
+    return { symbol: listing.symbol, exchange: other.listing.exchange, name: other.quote.name?.trim() || null, coinNote: coinListingNotes(listing, other.quote)[0] ?? null };
+  }
   if (other?.choose) throw new ListingArgError(other.message, other.details, other.choices);
   return null;
 }
@@ -1096,7 +1165,9 @@ export async function resolveCliListing(
   const terminal = named ? null : read;
   // "AAPL GP" is written as a code, with a market code no venue answers to and no company's name: one entry, never AAPL and GP.
   if (!terminal && !named) await refuseUnknownMarketCode(typed, deps);
-  let parsed = named ?? parseListingArg(raw, exchangeOption, { ...options, terminalCode: terminal });
+  // `BP.` is London's code for BP: its London line where London lists it, and `GE.` a US ticker with a stray dot.
+  const dotted = terminal || named || exchangeOption?.trim() ? null : readLondonDottedSymbol(typed);
+  let parsed = named ?? (dotted ? await londonDottedListing(dotted, deps) : parseListingArg(raw, exchangeOption, { ...options, terminalCode: terminal }));
   if (!parsed.symbol) throw new ListingArgError("Ticker symbol is required.");
   // $VIX is Schwab's code for ^VIX, unless a security trades as VIX: $AAPL is a cashtag.
   const index = named || parsed.exchange ? null : await readDollarIndexCode(raw, deps);
@@ -1140,6 +1211,21 @@ export async function resolveCliListing(
   };
 }
 
+/**
+ * A two-letter symbol written with London's trailing dot (`BP.`, `RR.`) as its
+ * London line, said as "Read BP. as BP:LSE.", where search lists it on LSE or
+ * its quote there says it trades. Elsewhere the dot was a slip after the
+ * ticker, dropped as a stray edge is (`GE.` is GE).
+ */
+async function londonDottedListing(dotted: NearMissListing, deps: ListingDeps): Promise<ListingArg> {
+  const london = { symbol: dotted.symbol, exchange: "LSE" };
+  const venues = await listingVenues(dotted.symbol, deps).catch(logFailure("cli.listing-arg", "Read listing venues failed", []));
+  const listed = venues.some((venue) => venue.exchange === london.exchange) || await quotedOnVenue(london, deps);
+  if (!listed) return parseListingArg(dotted.symbol);
+  const key = `${london.symbol}:${london.exchange}`;
+  return { ...parseListingArg(key), readAs: `Read ${dotted.typed} as ${key}.` };
+}
+
 /**
  * Fails a line written as a Bloomberg code whose market code no venue answers
  * to (`AAPL GP`), suggesting the code of the symbol's own listing (`AAPL
@@ -1235,17 +1321,23 @@ const ONE_WORD_NAME = /^\p{L}[\p{L}\p{N}&'’.-]*$/u;
  * for anything else, and when search names no company or is too busy to say.
  */
 export async function oneWordCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvider">): Promise<ListingArg | null> {
+  const found = await findOneWordCompany(typed, deps);
+  return found ? companyListingArg(typed, found) : null;
+}
+
+/** The company `oneWordCompanyName` reads a word as, before it is read as a listing. */
+async function findOneWordCompany(typed: string, deps: Pick<ListingDeps, "dataProvider">): Promise<CompanyNameListing | null> {
   const word = typed.trim();
   if (!ONE_WORD_NAME.test(word) || knownGapMessage(word) || isMajorCoinName(word)) return null;
-  const named = await readCompanyName(word, deps, { oneWord: true }).catch((error: unknown) => {
+  const found = await findCompanyName(word, deps, { oneWord: true }).catch((error: unknown) => {
     if (!isProviderBusy(error)) throw error;
     // Intentional ignore: a busy search says nothing about the name, so the word keeps its own "Not a ticker".
     return null;
   });
-  if (!named) return null;
+  if (!found) return null;
   // The board is read only for a word that names a company, and once for the run (`primeBoardCoins`).
   if (/^[A-Za-z0-9]+$/.test(word)) await primeBoardCoins([`Not a ticker: ${word.toUpperCase()}.`]);
-  return boardCoinFor(word) ? null : named;
+  return boardCoinFor(word) ? null : found;
 }
 
 function isMajorCoinName(word: string): boolean {
@@ -1253,9 +1345,16 @@ function isMajorCoinName(word: string): boolean {
   return [...MAJOR_COIN_NAMES.values()].some((name) => name.toLowerCase() === wanted);
 }
 
+function findCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvider">, options: { oneWord?: boolean } = {}): Promise<CompanyNameListing | null> {
+  return findListingOfCompanyName(deps.dataProvider, typed, { meant: true, quoted: true, ...options });
+}
+
 async function readCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvider">, options: { oneWord?: boolean } = {}): Promise<ListingArg | null> {
-  const found = await findListingOfCompanyName(deps.dataProvider, typed, { meant: true, quoted: true, ...options });
-  if (!found) return null;
+  const found = await findCompanyName(typed, deps, options);
+  return found ? companyListingArg(typed, found) : null;
+}
+
+function companyListingArg(typed: string, found: CompanyNameListing): ListingArg {
   const key = `${found.symbol}:${found.exchange}`;
   // A fund or an index carrying the name asks about the company's stock: "Did you mean JPM (JPMorgan Chase & Co.)?".
   const meant = found.meant ? { symbol: found.meant.symbol, name: found.meant.name } : null;
@@ -1263,6 +1362,35 @@ async function readCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvi
   return { ...parseListingArg(key), readAs: `Read "${typed.trim()}" as ${key} (${found.name}).${question}`, ...meant ? { meant } : {} };
 }
 
+/**
+ * The listing search names for a company's name typed where a ticker goes,
+ * as a sentence offers it: `PLTR (Palantir Technologies Inc.)`, a listing
+ * abroad with its venue (`SIE:XETRA (Siemens AG)`), a fund or an index that
+ * carries the name as the company's stock it means. Null when the words name
+ * no company, search is busy, or the listing found is the word itself: a
+ * real ticker is never a company's name. Never throws.
+ */
+export async function companyNameSuggestion(typed: string, deps: Pick<ListingDeps, "dataProvider">): Promise<{ symbol: string; name: string } | null> {
+  const words = typed.trim().replace(/^\$/, "");
+  if (!words) return null;
+  try {
+    const found = isCompanyNameInput(words) ? await findCompanyName(words, deps).catch(busyAsMiss) : await findOneWordCompany(words, deps);
+    const listing = found?.meant ?? found;
+    if (!listing || listing.symbol.toUpperCase() === words.toUpperCase()) return null;
+    return { symbol: isUsListingExchange(listing.exchange) ? listing.symbol : `${listing.symbol}:${listing.exchange}`, name: listing.name };
+  } catch (error) {
+    logFailure("cli.listing-arg", "Search a company name for a suggestion failed")(error);
+    return null;
+  }
+}
+
+/** A search too busy to answer is no company, as a name that matches none. */
+function busyAsMiss(error: unknown): null {
+  if (!isProviderBusy(error)) throw error;
+  // Intentional ignore: a busy search says nothing about the name, so no company is suggested.
+  return null;
+}
+
 /** `resolveCliListing` for a command: a bad exchange fails the command with its message. */
 export async function requireCliListing(
   raw: string,