gloomberb 0.18.2 → 0.18.4

package/src/cli/symbol-rows.ts

@@ -1,12 +1,14 @@
 import type { DataProvider } from "../types/data-provider";
 import type { TickerRecord } from "../types/ticker";
-import { listingFields, savedListingName, type ListingChoice } from "./listing-arg";
+import { listingFields, listingVenues, savedListingName, type ListingChoice } from "./listing-arg";
 import { StagedTickerRepository, type TickerSource } from "./staged-tickers";
 import { symbolInputKey } from "./symbol-args";
-import { describeSuggestion, isPlainNoMatch, suggestListings } from "./listing-suggestion";
+import { describeSuggestion, isPlainNoMatch, suggestListings, suggestUsTicker } from "./listing-suggestion";
+import { NotASymbolError } from "./symbol-cells";
 import {
   CoinListingError,
   ListingChoiceError,
+  LookupUnansweredError,
   resolveCliTicker,
   resolveTickersForCli,
   TickerNotFoundError,
@@ -18,16 +20,21 @@ import { isUsSymbolVenue, LOOKUP_TIMEOUT_MS, tickerChangeLine, tickerChangeSymbo
 import { isVenueAbroad } from "../tickers/listing-fate";
 import { sameCompany } from "../tickers/company-name";
 import { tickerHasListingSuffix } from "../sources/listing-symbols";
-import { canonicalExchange, resolveExchangeTimeZone } from "../utils/exchanges";
+import { canonicalExchange, exchangeLabel, resolveExchangeTimeZone } from "../utils/exchanges";
 import { isCurrencyPairListing } from "../utils/fx-market-hours";
+import { isCurrencyCode } from "../utils/currency-pair";
+import { logFailure } from "../utils/log-failure";
 
 /**
  * What became of one symbol of an add or remove. `needs_choice`: a symbol of
  * an add whose company moved or merged away, whose listing stopped trading, or
  * that matched only a listing abroad; it is not added, and the row offers what
- * to add instead.
+ * to add instead. `not_a_symbol`: an entry refused before any lookup (`N/A`,
+ * `$$$`, a price). `not_looked_up`: Gloom Cloud kept refusing its lookup, so
+ * it is neither found nor missing, and is worth adding again.
  */
-export type SymbolStatus = "added" | "already_listed" | "removed" | "not_listed" | "not_found" | "needs_choice" | "failed";
+export type SymbolStatus =
+  | "added" | "already_listed" | "removed" | "not_listed" | "not_found" | "needs_choice" | "failed" | "not_a_symbol" | "not_looked_up";
 
 /** One symbol's line: the `--json` and `--csv` row, and a line of text. */
 export interface SymbolRow extends Record<string, unknown> {
@@ -65,6 +72,8 @@ export interface SymbolRow extends Record<string, unknown> {
   tradesAs?: string | null;
   /** An added row's line saying that company moved or merged away, so the listing stored is another's. */
   changeNote?: string;
+  /** A bare symbol added on its only listing, abroad: "GARAN has no US listing; it trades on BIST, in TRY." */
+  abroad?: string;
 }
 
 export type Verb = "add" | "remove";
@@ -91,7 +100,15 @@ export function listingRow(
     ...readAs ? { readAs } : {}, ...extra };
 }
 
-export function failedRow(input: string, error: Error, status: SymbolStatus = error instanceof TickerNotFoundError ? "not_found" : "failed"): SymbolRow {
+/** The status a failure gives its row: not found, not a symbol, not looked up, or failed for its own reason. */
+function failureStatus(error: Error): SymbolStatus {
+  if (error instanceof TickerNotFoundError) return "not_found";
+  if (error instanceof NotASymbolError) return "not_a_symbol";
+  if (error instanceof LookupUnansweredError) return "not_looked_up";
+  return "failed";
+}
+
+export function failedRow(input: string, error: Error, status: SymbolStatus = failureStatus(error)): SymbolRow {
   const hint = error instanceof CoinListingError ? error.hint : null;
   const choice = error instanceof ListingChoiceError
     ? { choices: error.choices, listingCount: error.listingCount, ...error.successor ? { successor: error.successor } : {} }
@@ -156,6 +173,77 @@ function isListedAbroad(ticker: TickerRecord): boolean {
   return !isUsSymbolVenue(venue) && !!currency && currency !== "USD";
 }
 
+/** A bare US-shaped symbol (JPM, BRK.B), not 7203 or RY.TO, which name a venue of their own. */
+function bareUsShapedSymbol(resolution: Pick<CliTicker, "bareSymbol">): string | null {
+  const symbol = resolution.bareSymbol;
+  return symbol && tickerChangeSymbol(symbol) && !tickerHasListingSuffix(symbol) ? symbol : null;
+}
+
+type SymbolDeps = { store: TickerSource; dataProvider: DataProvider };
+
+const NO_SAVED_ROWS = { loadTicker: async () => null, loadAllTickers: async () => [] };
+
+/**
+ * Whether a bare symbol also names a US listing: a US company had or has it
+ * (its change history: DFS was Discover Financial Services), or it lists on
+ * a US venue, by the venues the lookup saw or, when it asked none (a saved
+ * row, read with no search), by search now, else by the symbol's own quote,
+ * which names its US line first. When neither answers it counts as naming
+ * one, so the match stays a choice.
+ */
+async function namesUsListing(resolution: CliTicker, deps: SymbolDeps): Promise<boolean> {
+  if (resolution.change || resolution.formerIssuer) return true;
+  if (resolution.otherVenues) return resolution.otherVenues.some((venue) => isUsSymbolVenue(venue));
+  const symbol = resolution.bareSymbol!;
+  // Search's listings, not the saved row it would answer with; none found (or search failed) says nothing.
+  const venues = await listingVenues(symbol, { store: NO_SAVED_ROWS, dataProvider: deps.dataProvider })
+    .catch(logFailure("cli.symbol-rows", "Read listing venues failed", []));
+  if (venues.length > 0) return venues.some((venue) => isUsSymbolVenue(venue.exchange));
+  const quote = await deps.dataProvider.getQuote(symbol, "").catch(logFailure("cli.symbol-rows", "Quote bare symbol failed", null));
+  const venue = canonicalExchange(quote?.listingExchangeName || quote?.exchangeName);
+  return !venue || isUsSymbolVenue(venue);
+}
+
+/**
+ * Whether a bare symbol is stored on its listing abroad, still trading, and
+ * that is all it names (`namesUsListing`): GARAN is added on BIST, saying so.
+ */
+async function listedOnlyAbroad(resolution: CliTicker, deps: SymbolDeps): Promise<boolean> {
+  if (!bareUsShapedSymbol(resolution) || resolution.ended || !isListedAbroad(resolution.ticker)) return false;
+  return !await namesUsListing(resolution, deps);
+}
+
+/** "GARAN has no US listing; it trades on BIST, in TRY.": the line an add says beside a symbol `listedOnlyAbroad`. */
+function abroadOnlyNote(resolution: CliTicker): string {
+  const { exchange, currency } = resolution.ticker.metadata;
+  const unit = currency?.trim();
+  return `${resolution.bareSymbol} has no US listing; it trades on ${exchangeLabel(exchange)}${unit ? `, in ${unit}` : ""}.`;
+}
+
+/**
+ * What a bare symbol listed only abroad was more likely typed for: a
+ * currency (MXN, mixi Inc in Stuttgart) or a US ticker one slip away (APPL,
+ * Aptus Pharma in Mumbai, for AAPL). "APPL is one slip from AAPL (Apple
+ * Inc.)" or "MXN is also a currency"; null when the symbol is likely meant as typed.
+ */
+async function meantInstead(symbol: string, deps: SymbolDeps): Promise<string | null> {
+  if (symbol !== "USD" && /^[A-Z]{3}$/.test(symbol) && isCurrencyCode(symbol)) return `${symbol} is also a currency`;
+  const suggestion = await suggestUsTicker(symbol, deps).catch(logFailure("cli.symbol-rows", "Suggest a US ticker failed", null));
+  return suggestion ? `${symbol} is one slip from ${describeSuggestion(suggestion)}` : null;
+}
+
+/**
+ * How a bare symbol matched abroad is settled: `abroad` when it is added
+ * there, with its line, or `meant` when it is left for a choice as more
+ * likely typed for something else. Both null for anything else, which
+ * `choiceNeeded` decides.
+ */
+async function settleAbroad(resolution: CliTicker, deps: SymbolDeps): Promise<{ abroad: string | null; meant: string | null; onlyAbroad: boolean }> {
+  if (!await listedOnlyAbroad(resolution, deps)) return { abroad: null, meant: null, onlyAbroad: false };
+  const meant = await meantInstead(resolution.bareSymbol!, deps);
+  return { abroad: meant ? null : abroadOnlyNote(resolution), meant, onlyAbroad: true };
+}
+
 /** Whether a YYYY-MM-DD day is within `ms` before `now`. */
 function within(day: string | null, ms: number, now: number): boolean {
   const at = day ? Date.parse(day.slice(0, 10)) : Number.NaN;
@@ -164,27 +252,34 @@ function within(day: string | null, ms: number, now: number): boolean {
 
 /**
  * Why a symbol of an add that named no exchange is not stored as it matched:
- * the listing found stopped trading (NYCB:NYSE), it is a listing abroad (DFS
- * Furniture's DFS:LSE for DFS), or the company that had the symbol left it in
+ * the listing found stopped trading (NYCB:NYSE), it is a listing abroad while
+ * the symbol also names a US one (DFS Furniture's DFS:LSE for DFS, Discover's
+ * old symbol) or was likely typed for something else (`meantInstead`: APPL
+ * for AAPL), or the company that had the symbol left it in
  * the last two years (BRKL, Brookline Bancorp's until 2025, now a fund's). The message
  * leads with what became of the company that held the symbol, when the
  * symbol's history says ("DFS was Discover Financial Services until 2025, now
  * Capital One Financial: COF"), whose symbol now is the successor offered; the
  * match is offered too. Null for a match stored as it is: a trading US
  * listing whose symbol changed hands longer ago (its row says so) or never,
- * or one whose input named its exchange; coins, perpetual markets and
- * currency pairs, which trade in no one country, too.
+ * a listing abroad that is all the symbol names (GARAN:BIST for GARAN, said
+ * with `abroadOnlyNote`), or one whose input named its exchange; coins,
+ * perpetual markets and currency pairs, which trade in no one country, too.
  */
-function choiceNeeded(resolution: CliTicker, now = Date.now()): { message: string; successor: string | null } | null {
-  const symbol = resolution.bareSymbol;
-  // A US-shaped symbol (JPM, BRK.B), not 7203 or RY.TO, which name a venue of their own.
-  if (!symbol || !tickerChangeSymbol(symbol) || tickerHasListingSuffix(symbol)) return null;
+function choiceNeeded(
+  resolution: CliTicker,
+  { onlyAbroad, meant }: { onlyAbroad: boolean; meant: string | null },
+  now = Date.now(),
+): { message: string; successor: string | null } | null {
+  const symbol = bareUsShapedSymbol(resolution);
+  if (!symbol) return null;
   const history = successorOf(resolution);
   const label = savedListingName(resolution.ticker).label;
   // A company that left lately: the match is another's, or that company's own line, still quoted.
   const recent = !!history?.successor && within(history.left, RECENT_REUSE_MS, now);
   const found = resolution.ended
-    ?? (isListedAbroad(resolution.ticker) ? `${symbol} matched ${label}, a listing abroad`
+    ?? (isListedAbroad(resolution.ticker) && (!onlyAbroad || meant)
+      ? `${symbol} matched ${label}, a listing abroad${meant ? `; ${meant}` : ""}`
       : recent ? `${symbol} matched ${label}, ${sameCompany(resolution.ticker.metadata.name, history?.company) ? "that company's old line" : "another company's listing"}`
         : null);
   if (!found) return null;
@@ -201,7 +296,9 @@ export const NO_MATCH = /^No ticker match found for /;
  * went nowhere are named so the list can be fixed.
  */
 export function summarizeSymbolRows(rows: readonly SymbolRow[], verb: Verb, repeated: number): string {
-  const inputs = (status: SymbolStatus) => rows.filter((row) => row.status === status).map((row) => symbolInputKey(row.input));
+  // An entry that is no symbol, or was not looked up, is named as it was written: `$$$`, `philip morris intl`.
+  const inputs = (status: SymbolStatus) => rows.filter((row) => row.status === status)
+    .map((row) => status === "not_a_symbol" || status === "not_looked_up" ? row.input.trim() : symbolInputKey(row.input));
   const counts = SETTLED[verb]
     .map(([status, word], index) => ({ count: inputs(status).length, word, index }))
     .filter(({ count, index }) => index === 0 || count > 0)
@@ -213,6 +310,12 @@ export function summarizeSymbolRows(rows: readonly SymbolRow[], verb: Verb, repe
   if (choices.length > 0) groups.push(`${choices.length} need${choices.length === 1 ? "s" : ""} a choice: ${choices.join(", ")}`);
   const failed = inputs("failed");
   if (failed.length > 0) groups.push(`${failed.length} not ${verb === "add" ? "added" : "removed"}: ${failed.join(", ")}`);
+  const unanswered = inputs("not_looked_up");
+  if (unanswered.length > 0) groups.push(`${unanswered.length} not looked up: ${unanswered.join(", ")}`);
+  const junk = inputs("not_a_symbol");
+  if (junk.length > 0) {
+    groups.push(`${junk.length} not ${junk.length === 1 ? "a symbol" : "symbols"}: ${junk.join(junk.some((input) => input.includes(",")) ? "; " : ", ")}`);
+  }
   if (repeated > 0) groups.push(`${repeated} repeat${repeated === 1 ? "" : "s"} skipped`);
   return `${groups.join("; ")}.`;
 }
@@ -248,6 +351,7 @@ async function settleAdd(
   input: string,
   lookup: CliTickerResolution,
   staged: StagedTickerRepository,
+  dataProvider: DataProvider,
   add: AddTicker,
   added: Set<string>,
 ): Promise<AddOutcome> {
@@ -258,7 +362,8 @@ async function settleAdd(
       ? { row: { ...failedRow(input, error, "needs_choice"), tradesAs: error.successor }, error }
       : { row: failedRow(input, error), error };
   }
-  const choice = choiceNeeded(lookup);
+  const abroad = await settleAbroad(lookup, { store: staged, dataProvider });
+  const choice = choiceNeeded(lookup, abroad);
   if (choice) {
     // The lookup saved the listing it matched; one that is in no list of this run is not kept.
     if (!added.has(lookup.ticker.metadata.ticker)) staged.discard(lookup.ticker.metadata.ticker);
@@ -281,7 +386,7 @@ async function settleAdd(
   const history = successorOf(lookup);
   return { row: listingRow(input, result.changed ? "added" : "already_listed", result.ticker, {
     notes: lookup.notes, ended: lookup.ended, hint: lookup.coinNote, readAs: lookup.readAs,
-    extra: history ? { changeNote: history.note, tradesAs: history.successor } : {},
+    extra: { ...history ? { changeNote: history.note, tradesAs: history.successor } : {}, ...abroad.abroad ? { abroad: abroad.abroad } : {} },
   }), error: null };
 }
 
@@ -337,7 +442,7 @@ export async function addSymbols({
       rows.push(failedRow(input, refusal ?? new Error("Not looked up.")));
       continue;
     }
-    const { row } = await settleAdd(input, resolution, staged, add, added);
+    const { row } = await settleAdd(input, resolution, staged, dataProvider, add, added);
     rows.push(resolution.error && row.status !== "needs_choice" && failure ? failedRow(input, failure(resolution.error)) : row);
   }
   if (!dryRun) await staged.commit();
@@ -374,15 +479,16 @@ export async function addSymbol(
   } catch (caught) {
     lookup = { input, error: caught instanceof Error ? caught : new Error(String(caught)) };
   }
-  const outcome = await settleAdd(input, lookup, staged, add, new Set());
+  const outcome = await settleAdd(input, lookup, staged, dataProvider, add, new Set());
   if (!dryRun) await staged.commit();
   return { ...outcome, lookup: lookup.error ? null : lookup };
 }
 
 /**
- * Why a typed symbol the command bar adds on its own would not be stored as
- * it matched (`settleAdd`), as a pasted list would leave it: its needs-choice
- * row, else null, for the single add to go on as it does. Nothing is saved.
+ * How a typed symbol the command bar adds on its own is decided, as a symbol
+ * of a pasted list is (`settleAdd`): a needs-choice row when it would not be
+ * stored as it matched, else the row it would add, which says when it is
+ * listed only abroad; null when nothing was looked up. Nothing is saved.
  */
 export async function typedSymbolChoice(input: string, store: TickerSource, dataProvider: DataProvider): Promise<SymbolRow | null> {
   const symbol = input.trim().toUpperCase();
@@ -395,8 +501,8 @@ export async function typedSymbolChoice(input: string, store: TickerSource, data
   } catch (caught) {
     lookup = { input: symbol, error: caught instanceof Error ? caught : new Error(String(caught)) };
   }
-  const { row } = await settleAdd(symbol, lookup, staged, (ticker) => ({ changed: false, ticker }), new Set());
-  return row.status === "needs_choice" ? row : null;
+  const { row } = await settleAdd(symbol, lookup, staged, dataProvider, (ticker) => ({ changed: false, ticker }), new Set());
+  return row;
 }
 
 /** The rows, each symbol search found no listing for with the nearest listing it did find, when that is a near match. */

package/src/cli/ticker-resolution.ts

@@ -1,6 +1,7 @@
 import { logFailure } from "../utils/log-failure";
 import type { DataProvider } from "../types/data-provider";
 import type { Quote } from "../types/financials";
+import type { InstrumentSearchResult } from "../types/instrument";
 import type { TickerRecord } from "../types/ticker";
 import type { AppTickerRepositoryPort } from "../core/app-service-ports";
 import { connectionHealth, GLOOM_CLOUD_HTTP_CONNECTION_ID } from "../core/connection-health";
@@ -15,6 +16,7 @@ import {
 import { canonicalExchange, parsePublicTickerKey } from "../utils/exchanges";
 import {
   chosenListingNote,
+  isNoProviderError,
   ListingArgError,
   listingChoiceNote,
   listingReadNotes,
@@ -25,6 +27,7 @@ import {
   quoteBareListing,
   resolveCliListing,
   savedListingName,
+  UNLISTED_TYPES,
   type CliListing,
   type ListingChoice,
   type ListingDeps,
@@ -33,6 +36,7 @@ import { listingChangeLine, loadListingFate, noLongerTradingNote, tradingListing
 import {
   describeFormerIssuer,
   describeTickerChange,
+  isUsSymbolVenue,
   movedAwayChange,
   LOOKUP_TIMEOUT_MS,
   startTickerChangeLookup,
@@ -46,6 +50,9 @@ import {
 import { batchedListLookups, type ListLookupPlan } from "../tickers/batched-lookups";
 import { providerSearchQueries } from "../tickers/search";
 import { coinElsewhereNote, savedListingCoinNote } from "./commands/crypto-hints";
+import { NotASymbolError, notASymbolError } from "./symbol-cells";
+import { kindFromListingSyntax } from "../tickers/instrument-kind";
+import { normalizeTickerSymbol } from "../tickers/search/ranking";
 
 /** The saved ticker for a symbol (`SAN:EPA`, or `SAN` with `--exchange EPA`), saving it from search first if needed. */
 export async function resolveTickerForCli(
@@ -87,10 +94,18 @@ export interface CliTicker {
    * the input named its listing, or a company's name was read as one.
    */
   bareSymbol: string | null;
+  /**
+   * The venues other than the stored one the symbol lists on, as far as the
+   * lookup saw them: search's, or none when the symbol's own quote named the
+   * listing and search was busy. Null when the lookup asked neither (a saved
+   * row), so whether a bare symbol matched abroad also names a US listing is
+   * still to be asked.
+   */
+  otherVenues: string[] | null;
 }
 
 export interface CliTickerOptions {
-  /** The command that takes one listing, for the choices a failure names: `gloomberb watchlist add Growth 2222:JPX`. */
+  /** The command that takes one listing, for the choices a failure names: `gloom watchlist add Growth 2222:JPX`. */
   retry?: (key: string) => string;
   /** `--exchange` only fills in the symbols that name no exchange of their own, as for a list of symbols. */
   ownExchangeWins?: boolean;
@@ -159,6 +174,17 @@ export class TickerNotFoundError extends ListingArgError {
   }
 }
 
+/**
+ * A list's symbol Gloom Cloud kept refusing to look up, through every wait:
+ * the lookup did not happen, so the symbol is neither found nor missing.
+ */
+export class LookupUnansweredError extends Error {
+  constructor(readonly input: string) {
+    super(`Could not look up ${input}: Gloom Cloud did not answer. Try again in a minute.`);
+    this.name = "LookupUnansweredError";
+  }
+}
+
 /**
  * `resolveTickerForCli`, saying which listing a bare symbol went to. A bare
  * symbol goes where `quote` reads it: the listing its own quote is on, else,
@@ -166,7 +192,9 @@ export class TickerNotFoundError extends ListingArgError {
  * (`quoteBareListing`); a code several companies list asks which. A symbol
  * search no longer lists, whose quote stopped long ago, is no longer trading,
  * and a named exchange the symbol is not on says where it is. Those failures
- * are `ListingArgError`s, with any choices in `details`.
+ * are `ListingArgError`s, with any choices in `details`. What cannot be a
+ * symbol (`N/A`, `$$$`, a price such as `2.582,52`) fails with
+ * `NotASymbolError` before anything is asked.
  */
 export async function resolveCliTicker(
   symbol: string,
@@ -178,8 +206,11 @@ export async function resolveCliTicker(
   if (!symbol.trim()) {
     throw new Error("Ticker symbol is required.");
   }
+  const notSymbol = notASymbolError(symbol);
+  if (notSymbol) throw notSymbol;
   const deps: ListingDeps = { store, dataProvider };
-  const listing = await resolveCliListing(symbol, exchange, deps, { ownExchangeWins: options.ownExchangeWins });
+  // A vendor's suffix is the venue it names (GARAN.IS is GARAN:BIST), so the listing is saved under one key.
+  const listing = await resolveCliListing(symbol, exchange, deps, { ownExchangeWins: options.ownExchangeWins, listingSuffix: true });
   const read = listingReadNotes(listing);
   // Looked up beside the search, so saying FB is now META costs no wait.
   const changes = options.changes === false ? null : startTickerChangeLookup(dataProvider, listing.symbol, listing.exchange);
@@ -195,6 +226,20 @@ export async function resolveCliTicker(
     const saved = options.refreshName === false ? { ticker: listing.saved, quote: null } : await nameFromListingQuote(listing.saved, store, dataProvider, null);
     return withChange(withEnded(saved, read), { name: saved.ticker.metadata.name });
   }
+  // A listing its own quote names is found as `quote` finds it, the quote cache first, so a busy search never
+  // blocks a listing the quote knows. Search is asked after, for the venues a note names, and may fail.
+  const known = await listingOfOwnQuote(listing, dataProvider);
+  if (known) {
+    const { ticker, created } = await upsertTickerFromSearchResult(store, known.result);
+    const named = created ? await nameFromListingQuote(ticker, store, dataProvider, known.quote) : { ticker, quote: known.quote };
+    const saved = savedListingName(named.ticker);
+    const venues = listing.exchange ? [] : await listingVenues(listing.symbol, deps).catch(logFailure("cli.ticker-resolution", "Read quoted listing venues failed", []));
+    const others = venues.map((venue) => venue.exchange).filter((venue) => venue !== saved.exchange);
+    const venueNote = others.length > 0 && saved.exchange
+      ? listingChoiceNote(listing.symbol, saved, venues) ?? chosenListingNote(listing.symbol, saved.exchange, others)
+      : null;
+    return withChange({ ticker: named.ticker, notes: [...read, ...venueNote ? [venueNote] : []], ended: null, otherVenues: others }, tradingListing(known.quote));
+  }
 
   const localTickers = new Map(
     (await store.loadAllTickers()).map((ticker) => [ticker.metadata.ticker.toUpperCase(), ticker] as const),
@@ -203,6 +248,7 @@ export async function resolveCliTicker(
   let resolved: ResolvedTickerSearch | null;
   let bareNote: string | null = null;
   let bareQuote: Quote | null = null;
+  let bareVenues: string[] = [];
   try {
     resolved = await search(listing.key);
   } catch (error) {
@@ -224,6 +270,7 @@ export async function resolveCliTicker(
     resolved = await search(bare.listing.key);
     bareNote = bare.note;
     bareQuote = bare.quote;
+    bareVenues = error.listings.flatMap((key) => parsePublicTickerKey(key).exchange ?? []).filter((venue) => venue !== bare.listing.exchange);
   }
 
   if (!resolved) {
@@ -238,7 +285,7 @@ export async function resolveCliTicker(
   }
   if (resolved.kind === "local") {
     const local = options.refreshName === false ? { ticker: resolved.ticker, quote: null } : await nameFromListingQuote(resolved.ticker, store, dataProvider, bareQuote);
-    return withChange(withEnded(local, [...read, ...bareNote ? [bareNote] : []]), { name: local.ticker.metadata.name });
+    return withChange({ ...withEnded(local, [...read, ...bareNote ? [bareNote] : []]), otherVenues: bareNote ? bareVenues : null }, { name: local.ticker.metadata.name });
   }
 
   const { ticker, created } = await upsertTickerFromSearchResult(store, resolved.result);
@@ -257,10 +304,50 @@ export async function resolveCliTicker(
     ticker: named.ticker,
     notes: [...read, venueNote, ended].filter((note): note is string => !!note),
     ended,
+    otherVenues: bareNote ? bareVenues : others,
   }, current);
 }
 
-type ResolvedListing = Omit<CliTicker, "change" | "formerIssuer" | "coinNote" | "readAs" | "bareSymbol">;
+/**
+ * The listing a symbol's own quote names, asked as `quote` asks it (the quote
+ * cache first): a priced quote answering for that symbol, on the venue named
+ * when one was, that still trades. Null when there is none, and for a pair, a
+ * future, an index or a coin, which search types; search then looks it up. So
+ * is a named US venue: the US exchanges share one symbol, and a quote asked
+ * for on any of them answers as that venue (AAPL:NYSE), where search says
+ * AAPL trades on NASDAQ.
+ */
+async function listingOfOwnQuote(listing: CliListing, dataProvider: DataProvider): Promise<{ result: InstrumentSearchResult; quote: Quote } | null> {
+  if (listing.sharedCode || kindFromListingSyntax(listing.key, listing.exchange) || (listing.exchange && isUsSymbolVenue(listing.exchange))) return null;
+  let quote: Quote;
+  try {
+    quote = await dataProvider.getQuote(listing.request.symbol, listing.request.exchange);
+  } catch (error) {
+    // Search then says what is wrong with the symbol.
+    if (!isNoProviderError(error)) logFailure("cli.ticker-resolution", "Quote listing before search failed")(error);
+    return null;
+  }
+  const exchange = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+  const answered = normalizeTickerSymbol(quote.symbol ?? "");
+  if (!exchange || (answered !== listing.symbol && answered !== listing.key)) return null;
+  if (listing.exchange && exchange !== listing.exchange) return null;
+  if (!Number.isFinite(quote.price) || quote.price === 0 || !(quote.lastUpdated > 0)) return null;
+  if (quote.delisting || noLongerTradingNote(listing.key, quote)) return null;
+  if (UNLISTED_TYPES.has(quote.instrumentType?.trim().toUpperCase() ?? "")) return null;
+  return {
+    quote,
+    result: {
+      providerId: dataProvider.id,
+      symbol: listing.symbol,
+      name: quote.name?.trim() || listing.symbol,
+      exchange,
+      ...quote.currency ? { currency: quote.currency } : {},
+      type: quote.instrumentType || "",
+    },
+  };
+}
+
+type ResolvedListing = Omit<CliTicker, "change" | "formerIssuer" | "coinNote" | "readAs" | "bareSymbol" | "otherVenues"> & { otherVenues?: string[] | null };
 
 /**
  * The resolution with the symbol's change, when it has one, and the coin note
@@ -282,7 +369,7 @@ async function describeResolution(
   const line = tickerChangeLine(change) ?? formerIssuer?.note;
   const coinNote = listing.exchange ? null : savedListingCoinNote(listing.symbol, resolved.ticker);
   return { ...resolved, notes: [...line ? [line] : [], ...resolved.notes, ...coinNote ? [coinNote] : []], change, formerIssuer, coinNote,
-    readAs: listing.readAs ?? null, bareSymbol: listing.exchange ? null : listing.symbol };
+    readAs: listing.readAs ?? null, bareSymbol: listing.exchange ? null : listing.symbol, otherVenues: resolved.otherVenues ?? null };
 }
 
 /**
@@ -368,6 +455,11 @@ function watchFailedRequests(): { count: () => number; stop: () => void } {
   return { count: () => failures.size, stop: () => { unsubscribe(); dispose?.(); } };
 }
 
+/** Whether a lookup's failure may be the service refusing it, so a new look could answer: not one refused before any request. */
+function mayBeRefusal(error: Error): boolean {
+  return !(error instanceof NotASymbolError);
+}
+
 function lookUpTickers(
   symbols: readonly string[],
   concurrency: number,
@@ -389,8 +481,11 @@ function lookUpTickers(
  * is searched as it always is.
  */
 function listLookupPlan(input: string, exchange: string | undefined): ListLookupPlan {
+  // What cannot be a symbol is refused without a request.
+  if (notASymbolError(input)) return { searches: [], changes: null };
   try {
-    const listing = parseListingArg(input, exchange, { ownExchangeWins: true });
+    // GARAN.IS names its venue, as GARAN:BIST does: it is looked up as a named listing is.
+    const listing = parseListingArg(input, exchange, { ownExchangeWins: true, listingSuffix: true });
     const searchable = !listing.exchange && /^[A-Z0-9][A-Z0-9.-]{0,11}$/.test(listing.symbol);
     return {
       searches: searchable ? providerSearchQueries(listing.symbol) : [],
@@ -410,7 +505,9 @@ function listLookupPlan(input: string, exchange: string | undefined): ListLookup
  * few batched requests first (`batchedListLookups`). "Not found" means search
  * found no listing: while the service refuses requests, the symbols that
  * failed are looked up again after a pause, and any it still did not answer
- * for say so.
+ * for fail with `LookupUnansweredError`. One that cannot be a symbol fails
+ * with `NotASymbolError` at once: it is never asked for, looked up again or
+ * waited for.
  */
 export async function resolveTickersForCli(
   symbols: readonly string[],
@@ -448,7 +545,7 @@ export async function resolveTickersForCli(
     let lookups = symbols.map((input) => looked.get(input)!);
     let failing = failedRequests.count() > 0;
     for (const waitMs of retryWaitsMs) {
-      const failed = lookups.filter((entry) => entry.error).map((entry) => entry.input);
+      const failed = lookups.filter((entry) => entry.error && mayBeRefusal(entry.error)).map((entry) => entry.input);
       if (!failing || failed.length === 0) break;
       onRetry?.(failed.length, waitMs);
       await new Promise((resolveWait) => setTimeout(resolveWait, waitMs));
@@ -459,8 +556,8 @@ export async function resolveTickersForCli(
     }
     if (!failing) return lookups;
     // Still refused after the last wait: a failure may only be the refusal, so none is called not found.
-    return lookups.map((entry) => entry.error
-      ? { input: entry.input, error: new Error(`Could not look up ${entry.input}: Gloom Cloud did not answer. Try again in a minute.`) }
+    return lookups.map((entry) => entry.error && mayBeRefusal(entry.error)
+      ? { input: entry.input, error: new LookupUnansweredError(entry.input) }
       : entry);
   } finally {
     failedRequests.stop();

package/src/cli/treasury-yields.ts

@@ -68,18 +68,18 @@ export function treasuryYieldTenor(text: string): TreasuryYieldTenor | null {
 /** The commands with the yield: its Cboe index when there is one, its FRED series, the curve. */
 function yieldCommands(tenor: TreasuryYieldTenor): Array<readonly [command: string, gives: string]> {
   return [
-    ...tenor.index ? [[`gloomberb quote ${tenor.index}`, "Cboe index"] as const] : [],
-    [`gloomberb fred ${tenor.fred}`, "daily"],
-    ["gloomberb yield-curve", "every tenor"],
+    ...tenor.index ? [[`gloom quote ${tenor.index}`, "Cboe index"] as const] : [],
+    [`gloom fred ${tenor.fred}`, "daily"],
+    ["gloom yield-curve", "every tenor"],
   ];
 }
 
-/** "US 10-year Treasury yield: gloomberb quote ^TNX (Cboe index), ...", for `search`, `catalog` and a bare root. */
+/** "US 10-year Treasury yield: gloom quote ^TNX (Cboe index), ...", for `search`, `catalog` and a bare root. */
 export function treasuryYieldLine(tenor: TreasuryYieldTenor): string {
   return `US ${tenor.label} Treasury yield: ${yieldCommands(tenor).map(([command, gives]) => `${command} (${gives})`).join(", ")}.`;
 }
 
-/** "Try `gloomberb quote ^TNX`, ... for the US 10-year Treasury yield.", after "Not a ticker: US10Y." */
+/** "Try `gloom quote ^TNX`, ... for the US 10-year Treasury yield.", after "Not a ticker: US10Y." */
 export function treasuryYieldHint(tenor: TreasuryYieldTenor): string {
   const commands = yieldCommands(tenor).map(([command]) => `\`${command}\``);
   return `Try ${commands.slice(0, -1).join(", ")} or ${commands.at(-1)} for the US ${tenor.label} Treasury yield.`;

package/src/cli/types.ts

@@ -19,6 +19,8 @@ export type MarketContext = ConfigContext & {
   resolveBroker?: (brokerType: string) => import("../types/broker").BrokerAdapter | null;
   /** Charts catalog series in a report run without the plugin runtime. */
   seriesCapabilities?: CapabilityInvoker;
+  /** The catalog series charted as an expression (`FRED:DFII10`), in a report run without the plugin runtime. */
+  findCatalogSeries?: (expression: string) => import("../series/types").SeriesDefinition | undefined;
   /** `--refresh`: prefetched data bypasses the local cache. */
   refresh?: boolean;
   /** Filings behind the statements and a bank's figures, read from Gloom Cloud; absent where the data service is a stand-in. */

package/src/cli/uncovered-instrument.ts

@@ -14,7 +14,7 @@ const VIX_FUNCTION_INDICES: ReadonlySet<string> = new Set(VOLATILITY_INDICES.map
 export function uncoveredInstrumentCommand(instrument: InstrumentOfKind): string {
   const symbol = instrument.symbol;
   const bare = parsePublicTickerKey(symbol).symbol.toUpperCase();
-  if (instrument.kind === "index" && VIX_FUNCTION_INDICES.has(bare)) return "gloomberb fn VIX";
-  if (instrument.kind === "fund") return `gloomberb fundamentals ${symbol}`;
-  return `gloomberb ticker ${symbol}`;
+  if (instrument.kind === "index" && VIX_FUNCTION_INDICES.has(bare)) return "gloom fn VIX";
+  if (instrument.kind === "fund") return `gloom fundamentals ${symbol}`;
+  return `gloom ticker ${symbol}`;
 }

package/src/cli/unknown-command.ts

@@ -22,13 +22,13 @@ function shellWord(arg: string): string {
 
 /**
  * The command that runs `hit` with what the reader typed after the unknown
- * word: their tickers (`gloomberb fn RV DUOL --peers`, the switch added when
+ * word: their tickers (`gloom fn RV DUOL --peers`, the switch added when
  * one symbol meets a function that picks its peers), or the function's
  * placeholder and a search when they typed a company's name.
  */
 function catalogHitCommand(hit: CatalogCommandHit, args: readonly string[]): { command: string; search: string | null } {
   const typed = args.filter((arg) => arg.trim() && !arg.startsWith("-"));
-  const base = `gloomberb fn ${hit.code}`;
+  const base = `gloom fn ${hit.code}`;
   if (hit.argKind === "none") return { command: base, search: null };
   const placeholder = hit.argPlaceholder ?? hit.argKind;
   if (!hit.argKind || !TICKER_ARGUMENTS.has(hit.argKind)) {
@@ -39,7 +39,7 @@ function catalogHitCommand(hit: CatalogCommandHit, args: readonly string[]): { c
   const single = typed.length === 1;
   const peers = hit.peers && single ? " --peers" : "";
   if (names.length > 0) {
-    return { command: `${base} <${single ? "ticker" : placeholder ?? "tickers"}>${peers}`, search: `gloomberb search ${names.map(shellWord).join(" ")}` };
+    return { command: `${base} <${single ? "ticker" : placeholder ?? "tickers"}>${peers}`, search: `gloom search ${names.map(shellWord).join(" ")}` };
   }
   return { command: `${base} ${typed.length > 0 ? typed.map(shellWord).join(" ") : `<${placeholder ?? "ticker"}>`}${peers}`, search: null };
 }
@@ -52,14 +52,14 @@ function catalogHitCommand(hit: CatalogCommandHit, args: readonly string[]): { c
 const TICKER_SHAPED = /^\^?[A-Z0-9][A-Z0-9.=-]{0,11}(?::[A-Z0-9]{1,8})?$/;
 
 /**
- * What a ticker typed as a command (`gloomberb PLTR`) is answered with: the
+ * What a ticker typed as a command (`gloom PLTR`) is answered with: the
  * command that quotes it and the search that finds it. Null for a word not
  * written as a ticker.
  */
 export function tickerPointer(token: string): string | null {
   const word = token.trim();
   if (!TICKER_SHAPED.test(word) || !/[A-Z]/.test(word)) return null;
-  return [`To quote it: gloomberb quote ${word}`, `Find the ticker: gloomberb search ${word}`].join("\n");
+  return [`To quote it: gloom quote ${word}`, `Find the ticker: gloom search ${word}`].join("\n");
 }
 
 /**
@@ -71,7 +71,7 @@ export function tickerPointer(token: string): string | null {
 export function catalogPointer(token: string, hits: readonly CatalogCommandHit[], args: readonly string[]): string | null {
   if (hits.length === 0) return null;
   const word = /^[\w.:-]+$/.test(token) ? token : JSON.stringify(token);
-  const more = `gloomberb catalog ${word}`;
+  const more = `gloom catalog ${word}`;
   if (hits.length === 1) {
     const { command, search } = catalogHitCommand(hits[0]!, args);
     return `Try \`${command}\` (${hits[0]!.label})${search ? `; \`${search}\` finds the ticker` : ""}. \`${more}\` lists more.`;