gloomberb 0.19.0 → 0.19.2

package/src/cli/commands/ticker.ts

@@ -83,7 +83,7 @@ import { movedAwayChange } from "../../tickers/ticker-changes";
 import { companyMemberships, loadCompanyMemberships, type CompanyMemberships, type ListMembership } from "../issuer-membership";
 import { isNotATickerMessage } from "../not-a-ticker";
 import { sharesOutstandingInReceipts } from "../../utils/depositary-receipt";
-import { depositaryPairText, isReceiptSide, listingDepositaryPair } from "../../market-data/depositary-pair";
+import { cedearRatioText, depositaryPairText, isReceiptSide, listingCedearRatio, listingDepositaryPair } from "../../market-data/depositary-pair";
 import { cliFreshnessFooter } from "../result";
 import { providerMissReason } from "../../sources/provider-errors";
 import { exportEntriesTable, reportFooterLines, type CliReportTables } from "../report-tables";
@@ -100,6 +100,7 @@ import { bondFigures, NOT_SEC_YIELD } from "../../market-data/bond-funds";
 import { readFundFacts } from "../../market-data/fund-facts";
 import { taxEquivalentLines, type TaxEquivalentAnalysis } from "../../market-data/tax-equivalent";
 import { isRoundTheClockCoin } from "../../utils/crypto-pair";
+import { ipoDetailNotes, ipoMetricRows, loadTickerIpo, type TickerIpo } from "../../plugins/builtin/ipo-calendar/listing-ipo";
 import { coinNewsFallbackNotice } from "../../sources/gloomberb-cloud/news";
 
 const NEWS_ITEM_LIMIT = 5;
@@ -126,6 +127,8 @@ const METADATA_SEPARATOR = "  ·  ";
 interface TickerCommandDependencies {
   /** `--exchange`: the listing, for a symbol that trades in several places. */
   exchange?: string;
+  /** A stock's IPO of the last year with its lock-up news; a failure leaves the IPO section out. */
+  listingIpo?: (listing: { symbol: string; exchange?: string | null }) => Promise<TickerIpo | null>;
   initMarketData?: () => Promise<MarketContext>;
   fail?: (message: string, details?: string) => never;
   printResult?: CliCommandContext["printResult"];
@@ -1081,8 +1084,11 @@ export async function buildTickerReport({
   fundFacts = null,
   memberships,
   offerings = [],
+  ipo = null,
 }: {
   symbol: string;
+  /** A stock's IPO of the last year, with its lock-up estimate and news (loadTickerIpo). */
+  ipo?: TickerIpo | null;
   /** The lists holding the company, by any of its listings (loadCompanyMemberships); the saved listing's own lists when absent. */
   memberships?: CompanyMemberships;
   /** The filings behind the latest statements, and a newer quarter's results release. */
@@ -1165,6 +1171,9 @@ export async function buildTickerReport({
   if (depositaryPair) {
     lines.push(cliStyles.muted(`ADR ratio ${depositaryPairText(depositaryPair, isReceiptSide(financials))}. Implied FX and premium: gloom fn ADR ${quote?.symbol ?? symbol}`));
   }
+  // A CEDEAR states its ratio in its company's shares, as a receipt does.
+  const cedearRatio = listingCedearRatio(financials);
+  if (cedearRatio) lines.push(cliStyles.muted(`CEDEAR ratio ${cedearRatioText(cedearRatio)}.`));
 
   // A list that holds the company as another of its listings says which: "Watchlists R (as RCI.B:TSX)".
   const lists = memberships ?? companyMemberships(config, tickerFile, [], null);
@@ -1250,7 +1259,15 @@ export async function buildTickerReport({
     ]);
   }
 
-  const metrics = fundamentalsMetrics(quote, priced.fundamentals, profile, { text: marketCapText }, priceReturns, fundamentalsCurrency(financials),
+  // A stock that listed in the last year: its IPO, the move since, and when its lock-up is estimated to end.
+  if (ipo) {
+    appendMetricSection(lines, "IPO", ipoMetricRows(ipo.deal, quote ? getRegularSessionDisplay(quote)?.price : null));
+    for (const note of ipoDetailNotes(ipo.deal, ipo.news)) lines.push(cliStyles.muted(note));
+  }
+
+  // A listing of the last year may have no statements yet: its IPO says how recent it is.
+  const listing = { listedSince: ipo ? ipo.deal.listingDate ?? ipo.deal.firstDay?.session ?? null : null };
+  const metrics = fundamentalsMetrics(quote, priced.fundamentals, profile, { text: marketCapText }, priceReturns, fundamentalsCurrency(financials, listing),
     { text: enterpriseValueText }, distributions, bondFund, codes);
   const reportedCurrency = financials.financialCurrency?.trim();
   const statements = [...financials.annualStatements, ...financials.quarterlyStatements];
@@ -1349,9 +1366,11 @@ function buildTickerStructuredData({
   bondFund = null,
   memberships,
   offerings = [],
+  ipo = null,
 }: {
   symbol: string;
   listing: CliListing;
+  ipo?: TickerIpo | null;
   memberships: CompanyMemberships;
   statementFilings: StatementFilingsReport | null;
   offerings?: readonly OfferingFiling[];
@@ -1434,6 +1453,8 @@ function buildTickerStructuredData({
     // and the offering prospectuses filed since that the cash does not include.
     cashRunway: runway,
     offeringsAfterBalanceSheet: runway ? offeringsAfter(offerings, runway.periodEnd) : [],
+    // A stock that listed in the last year: its IPO deal (offer price, first day, lock-up estimate) and lock-up news.
+    ...ipo ? { ipo: { ...ipo.deal, lockupNews: ipo.news } } : {},
     // The form and filed date of the latest periods' filings, and a newer quarter's results released before its statements.
     statementFilings,
     notes,
@@ -1462,6 +1483,8 @@ function buildTickerStructuredData({
 }
 
 function depositaryPairJson(financials: TickerFinancials) {
+  const cedear = listingCedearRatio(financials);
+  if (cedear) return { cedearRatio: { ...cedear, text: cedearRatioText(cedear) } };
   const pair = listingDepositaryPair(financials);
   if (!pair) return {};
   const receipt = isReceiptSide(financials);
@@ -1573,6 +1596,11 @@ export async function ticker(symbol: string, dependencies: TickerCommandDependen
     });
     // An offering since the latest balance sheet, read only when the report has a runway to flag.
     const offerings = loadOfferingFilings(statementSources, { symbol: requestSymbol, exchange }, cashRunway(resolvedFinancials) != null);
+    // A stock's IPO of the last year, read beside the rest; it never fails the report.
+    const ipoLoad = quote && resolveTickerInstrumentKind(tickerFile, resolvedFinancials) === "equity"
+      ? (dependencies.listingIpo ?? loadTickerIpo)({ symbol: requestSymbol, exchange: exchange || quote.listingExchangeName || quote.exchangeName })
+        .catch(logFailure("cli.commands-ticker", "Read a listing's IPO failed", null))
+      : Promise.resolve(null);
     const [notesResult, newsResult, secFilingsResult] = await Promise.allSettled([
       notesFiles.load(tickerFile?.metadata.ticker ?? normalized),
       dataProvider.getNews({
@@ -1640,6 +1668,7 @@ export async function ticker(symbol: string, dependencies: TickerCommandDependen
           bondFund: await bondFund,
           memberships,
           offerings: await offerings,
+          ipo: await ipoLoad,
         }),
       });
       return;
@@ -1666,6 +1695,7 @@ export async function ticker(symbol: string, dependencies: TickerCommandDependen
         fundFacts: await fundFacts,
         memberships,
         offerings: await offerings,
+        ipo: await ipoLoad,
     }));
     if (freshness) console.log(`\n${cliFreshnessFooter(freshness, quote ?? resolvedFinancials)}`);
   });

package/src/cli/context.ts

@@ -141,6 +141,7 @@ export async function initCliServices(options: CliServicesOptions = {}) {
     config,
     plugins: getLoadablePlugins(options.externalPlugins ?? []),
     externalPlugins: options.externalPlugins ?? [],
+    interactive: false,
   });
   services.providerRouter.setConfigAccessor(() => config);
   services.providerRouter.setBackgroundRevalidation(false);

package/src/cli/errors.ts

@@ -13,7 +13,7 @@ export const CLI_ERROR_CODE = "cli_error";
 /** The code of a command that ran, and the data service has nothing for what it asked. */
 export const NO_DATA_CODE = "no_data";
 /** The code of a command whose requests never reached the data service. */
-export const SERVICE_UNREACHABLE_CODE = "service_unreachable";
+const SERVICE_UNREACHABLE_CODE = "service_unreachable";
 
 /** What to check when nothing answered: the connection, and the proxy when one is set. */
 function unreachableHint(): string {
@@ -74,6 +74,21 @@ export function failRetryable(message: string, code: string): never {
   throw new CliFailure(message, undefined, code, true);
 }
 
+/**
+ * What a command says when its requests never reached the data service:
+ * `message` names what it could not get (by default only that), and the
+ * details what to check. `--json` marks it retryable.
+ */
+export function unreachableError(message = DATA_SERVICE_UNREACHABLE_MESSAGE): CliErrorObject {
+  return { code: SERVICE_UNREACHABLE_CODE, message, details: unreachableHint(), retryable: true };
+}
+
+/** Fails as a command whose requests never reached the data service (`unreachableError`). */
+export function failUnreachable(message?: string): never {
+  const error = unreachableError(message);
+  throw new CliFailure(error.message, error.details, error.code, error.retryable);
+}
+
 export function closeAndFail(persistence: AppPersistence, message: string, details?: string): never {
   persistence.close();
   fail(message, details);
@@ -104,7 +119,7 @@ function cliErrorObject(error: unknown): CliErrorObject {
   }
   // No answer came back at all: in Gloom's words, whichever fetch failed (Bun's "Unable to connect", a refused proxy).
   if (isNetworkFailure(error)) {
-    return { code: SERVICE_UNREACHABLE_CODE, message: DATA_SERVICE_UNREACHABLE_MESSAGE, details: unreachableHint(), retryable: true };
+    return unreachableError();
   }
   // Gloom Cloud refused what was asked (an unknown series, a bad date): the input was wrong, not the program.
   if (error instanceof ApiRequestError && error.status === 400) {

package/src/cli/glossary.ts

@@ -404,7 +404,8 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
   },
   {
     term: "Net debt", aliases: ["net debt/ebitda", "net debt to ebitda", "net leverage"], functions: ["FA"], shown: ["Net Debt"],
-    definition: "Total debt less cash and short-term investments. Negative means more cash than debt. "
+    definition: "Total debt less cash and short-term investments, with the balance sheet's lease liabilities under IFRS (\"incl. leases\"); "
+      + "a company reporting under US GAAP (a 10-K, or a 20-F such as Alibaba's) keeps its operating leases out (\"excl. op. leases\"). Negative means more cash than debt. "
       + "Net debt / EBITDA is how many years of EBITDA would repay it; FA divides by a year of EBITDA, the trailing four quarters in a quarterly column.",
   },
   {
@@ -437,6 +438,12 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
     definition: "How many ordinary shares one depositary receipt holds: 1 ADR = 10 ordinary shares means one GGAL in New York is ten GGAL.BA shares in Buenos Aires. "
       + "A receipt's price compares with its home price only once the home price is multiplied by the ratio.",
   },
+  {
+    term: "CEDEAR ratio", aliases: ["cedear", "cedears", "certificado de deposito argentino"],
+    functions: ["DES"], shown: ["CEDEAR ratio", "CEDEAR Ratio"],
+    definition: "How many Buenos Aires CEDEARs make the company's shares they stand for, from BYMA's published list: 20 AAPL:BYMA = 1 Apple Inc. share. "
+      + "A CEDEAR's market cap is its company's, in the currency of the listing it stands for (Apple's in dollars), not the certificate's peso price times a share count.",
+  },
   {
     term: "ADR premium", aliases: ["adr discount", "adr vs home", "receipt premium", "adr premium/discount"],
     functions: ["ADR"], shown: ["ADR vs home", "premium", "discount"],

package/src/cli/history-rows.ts

@@ -14,7 +14,9 @@ import { isRoundTheClockCoin } from "../utils/crypto-pair";
 import { currencyPairCode } from "../utils/currency-pair";
 import { currencyUnitLabel, resolveCurrencyUnit } from "../utils/currency-units";
 import { getPricePointTimestamp } from "../utils/price-history";
-import { latestTradeIndex, missingVolumeNotice, pricePointIntegrityFlags, pricePointValues } from "../utils/price-history-integrity";
+import {
+  isWickFlag, latestTradeIndex, missingVolumeNotice, pricePointIntegrityFlags, pricePointValues, pricePointWickFlags,
+} from "../utils/price-history-integrity";
 import { formatUtcTime } from "../utils/utc-time";
 import { historyCoverageNotice } from "../sources/history-coverage";
 import { barLastSession, barPeriodToDate, type BarPeriodToDate } from "../market-data/market/bar-period";
@@ -253,10 +255,17 @@ function flagCodes(row: Pick<HistoryRow, "flag">): string[] {
   return row.flag ? row.flag.split(",") : [];
 }
 
+/** The codes of a bar left blank for prices that contradict each other: not a break before it, nor a withheld wick. */
+function blankingCodes(row: Pick<HistoryRow, "flag">): string[] {
+  return flagCodes(row).filter((code) => !BREAK_FLAGS.has(code) && !isWickFlag(code));
+}
+
 /**
  * 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`. A bar after a gap or a jump in the series keeps its
+ * and says why in `flag`. A low or high too far from the open and close to
+ * have traded is left blank, the rest of the bar kept, flagged `low<close/2`
+ * or `high>2*open`. A bar after a gap or a jump in the series keeps its
  * prices and is flagged `gap` or `jump`.
  */
 export function historyRows(
@@ -277,7 +286,7 @@ export function historyRows(
     const time = times[index]!;
     const iso = Number.isFinite(time) ? new Date(time).toISOString() : "";
     const values = pricePointValues(point);
-    const flags = pricePointIntegrityFlags(point);
+    const flags = [...pricePointIntegrityFlags(point), ...pricePointWickFlags(point)];
     const price = (value: number | null) => value == null ? null : cleanBarPrice(value, priceDivisor);
     return {
       date: intraday ? iso.replace(".000Z", "Z") : iso.slice(0, 10),
@@ -448,7 +457,7 @@ export function historyMissingVolumeNote(
   if (!historyReportsVolume(rows)) return null;
   const latestTrade = latestTradeIndex(rows.map((row) => Date.parse(row.date)));
   const missing = rows.filter((row, index) => row.volume == null && row.venueVolume == null && !row.partial && !row.filled
-    && !flagCodes(row).some((code) => !BREAK_FLAGS.has(code)) && index !== latestTrade).length;
+    && blankingCodes(row).length === 0 && index !== latestTrade).length;
   return missingVolumeNotice(missing, rows.length) ?? null;
 }
 
@@ -833,10 +842,9 @@ export function historyGapNote(
  * keep their prices and are not counted.
  */
 export function historyFlagNote(rows: readonly Pick<HistoryRow, "flag">[]): string | null {
-  const contradictions = (row: Pick<HistoryRow, "flag">) => flagCodes(row).filter((code) => !BREAK_FLAGS.has(code));
-  const flagged = rows.filter((row) => contradictions(row).length > 0);
+  const flagged = rows.filter((row) => blankingCodes(row).length > 0);
   if (flagged.length === 0) return null;
-  const codes = new Set(flagged.flatMap(contradictions));
+  const codes = new Set(flagged.flatMap(blankingCodes));
   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" : "",
@@ -845,3 +853,23 @@ export function historyFlagNote(rows: readonly Pick<HistoryRow, "flag">[]): stri
   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`;
 }
+
+/**
+ * "The low of 2021-11-29 is under half its open and close, too far to have
+ * traded; left blank and out of ranges", or null when no bar has such a wick
+ * (pricePointWickFlags). Three or more bars are counted.
+ */
+export function historyWickNote(rows: readonly Pick<HistoryRow, "date" | "flag">[]): string | null {
+  const flagged = rows.filter((row) => flagCodes(row).some(isWickFlag));
+  if (flagged.length === 0) return null;
+  const sides = new Set(flagged.flatMap((row) => flagCodes(row).filter(isWickFlag).map((code) => code.slice(0, code.indexOf(code.startsWith("low") ? "<" : ">")))));
+  const reason = "too far to have traded; left blank and out of ranges";
+  const only = flagged[0]!;
+  if (flagged.length === 1 && sides.size === 1) {
+    return sides.has("low") ? `The low of ${only.date} is under half its open and close, ${reason}`
+      : `The high of ${only.date} is over twice its open and close, ${reason}`;
+  }
+  const kinds = [sides.has("low") ? "a low under half" : "", sides.has("high") ? "a high over twice" : ""].filter(Boolean).join(" or ");
+  const dates = flagged.length <= LISTED_GAPS ? ` (${listItems(flagged.map((row) => row.date))})` : "";
+  return `${flagged.length} of ${rows.length} bars have ${kinds} their open and close${dates}, ${reason}`;
+}

package/src/cli/index-roots.ts

@@ -35,10 +35,3 @@ export function indexRootTryLine(root: IndexRoot, command = "quote"): string {
 export function indexRootAlsoLine(root: IndexRoot, command = "quote"): string {
   return `also ${root.symbol} ${root.name} (gloom ${command} ${root.symbol})`;
 }
-
-/** Cboe's Treasury yield indices: 13-week bill, 5-, 10- and 30-year notes. Each level is a yield in percent. */
-const YIELD_INDEX_SYMBOLS: ReadonlySet<string> = new Set(["^IRX", "^FVX", "^TNX", "^TYX"]);
-
-export function isYieldIndexSymbol(symbol: string): boolean {
-  return YIELD_INDEX_SYMBOLS.has(symbol.trim().toUpperCase());
-}

package/src/cli/known-gaps.ts

@@ -222,6 +222,17 @@ const TOPIC_POINTERS: ReadonlyArray<{
     closestLabel: "COMEX curves",
     closest: [["CTM", "gloom fn CTM HG for copper, gloom fn CTM ALI for aluminium"]],
   },
+  {
+    // No source serves a jet fuel (kerosene) price. Heating oil, NY Harbor ULSD, is what airlines hedge it with and
+    // analysts read it by; the EIA's weekly US stocks are a catalog series (checked 2026-10-29: quote HO=F,
+    // fn COT HO and fn G CAP:doe:jet all answer).
+    topic: "Jet fuel (kerosene)",
+    availability: "no price series; heating oil (NY Harbor ULSD) is the usual proxy, its price: gloom quote HO=F. "
+      + "US jet fuel stocks (EIA, weekly): gloom fn G CAP:doe:jet",
+    phrases: ["jet fuel", "jet fuels", "kerosene", "kerosine", "jet kerosene", "aviation fuel", "aviation fuels", "avtur"],
+    closestLabel: "positioning",
+    closest: [["COT", "heating oil, the usual jet fuel proxy: gloom fn COT HO"]],
+  },
   {
     // "exchange reserves" alone reads as crypto's; "foreign exchange reserves" is a central bank's, so only whole.
     topic: "Crypto exchange reserves and exchange flows",

package/src/cli/listing-arg.ts

@@ -15,9 +15,9 @@ import {
   type ListingVenue,
 } from "../tickers/listing-venues";
 import { findUsListingOfCompany, type UsListing } from "../tickers/us-listing";
-import { findListingOfCompanyName, isCompanyNameInput, readTerminalCodeArg, type CompanyNameListing } from "../tickers/company-name-listing";
+import { findListingOfCompanyName, isCompanyNameInput, marksAnotherListing, 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 { lineMayHaveMoved, loadListingFate, MovedSymbolError, type ListingFate } from "../tickers/listing-fate";
 import { quotedListingName } from "../tickers/listing-name";
 import { cliStyles } from "../utils/cli-output";
 import { groupByCompany, namesDepositaryReceipt, sameCompany, sameListedName, shortCompanyName } from "../tickers/company-name";
@@ -36,7 +36,7 @@ import { withMarketData } from "./scoped-context";
 import { failWithFields } from "./errors";
 import { stripStrayEdges } from "./symbol-args";
 import { isNoProviderMessage, isNoSourceAnswer, isProviderBusy } from "../sources/provider-errors";
-import { dashedCoinPair, MAJOR_COIN_NAMES } from "../utils/crypto-pair";
+import { dashedCoinPair, exchangeLineCoinListing, isSpotCommodityOrCurrencyPair, MAJOR_COIN_NAMES } from "../utils/crypto-pair";
 import { boardCoinFor, primeBoardCoins } from "./board-coins";
 import { knownGapMessage } from "./known-gaps";
 import { currencyPairSpelling } from "../utils/currency-pair";
@@ -107,6 +107,12 @@ export interface ListingArg {
    * `readAs` asks about it, and a command the listing fails asks too.
    */
   meant?: { symbol: string; name: string };
+  /**
+   * A bare symbol a company's name was read as still says what it was read
+   * as (`listingChoiceNotes`): GETYQ for "getty images", whose NYSE line
+   * became GETYQ. Other bare symbols say where the data service chose instead.
+   */
+  readFromName?: true;
 }
 
 /** "Did you mean JPM (JPMorgan Chase & Co.)?", for a name read as a fund or an index; empty for any other listing. */
@@ -176,8 +182,13 @@ function parseCleanListingArg(
   // `SAN:` asks which listing; with --exchange it has its answer.
   if (option && typed.endsWith(":")) typed = typed.slice(0, -1);
   const venueKey = parsePublicTickerKey(typed);
-  // BTC/USD, as crypto venues write a pair, is the coin's own BTC-USD.
-  const parsed = { ...venueKey, symbol: dashedCoinPair(venueKey.symbol) ?? venueKey.symbol };
+  // A crypto exchange's line of a pair (BTC/GBP:COINBASE PRO, as search offered it) is the crypto venue's BTC-GBP:CCC.
+  const line = venueKey.exchange || optionCode ? exchangeLineCoinListing(venueKey.symbol, venueKey.exchange ?? optionCode) : null;
+  if (line) return { symbol: line.symbol, exchange: line.exchange, key: `${line.symbol}:${line.exchange}` };
+  // BTC/USD, as crypto venues write a pair, is the coin's own BTC-USD; spot crude (WTI/USD) and gold by the gram
+  // (GAU/USD:COMMODITY) are not coins, though tokens share their letters.
+  const coinPair = isSpotCommodityOrCurrencyPair(venueKey.symbol, venueKey.exchange ?? optionCode) ? null : dashedCoinPair(venueKey.symbol);
+  const parsed = { ...venueKey, symbol: coinPair ?? venueKey.symbol };
   const ownCode = parsed.exchange ? typedExchangeCode(typed) : "";
   let exchange = parsed.exchange ?? option;
   let code = ownCode || optionCode;
@@ -452,7 +463,7 @@ export function coinListingNotes(
  * its warnings.
  */
 export async function listingChoiceNotes(
-  listing: Pick<CliListing, "symbol" | "exchange" | "saved" | "readAs">,
+  listing: Pick<CliListing, "symbol" | "exchange" | "saved" | "readAs" | "readFromName">,
   deps: ListingDeps,
   quote: Pick<Quote, "name" | "listingExchangeName" | "exchangeName" | "instrumentType" | "stale" | "delisting"> | null | undefined,
   /** The venues `loadBareVenues` already started; looked up here when not given. */
@@ -460,6 +471,8 @@ export async function listingChoiceNotes(
 ): Promise<string[]> {
   const coin = coinListingNotes(listing, quote);
   if (!isBareListing(listing)) return [...listingReadNotes(listing), ...coin];
+  // A bare symbol a name was read as says so: "Read "getty images" as GETYQ (...). GETY became GETYQ on 2026-10-22."
+  if (listing.readFromName) 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 coin;
@@ -475,7 +488,7 @@ export async function listingChoiceNotes(
  * 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">,
+  listing: Pick<CliListing, "symbol" | "exchange" | "saved" | "request" | "readAs" | "readFromName">,
   deps: ListingDeps,
 ): Promise<string[]> {
   const venues = loadBareVenues(listing, deps);
@@ -1325,6 +1338,22 @@ export async function oneWordCompanyName(typed: string, deps: Pick<ListingDeps,
   return found ? companyListingArg(typed, found) : null;
 }
 
+/**
+ * A word the service marks as a company's name (`searchAliases`), read as
+ * that company's listing as `oneWordCompanyName` reads a word, for a bare
+ * symbol no source quotes, before it is read on the symbol's listings abroad:
+ * "siemens" is SIE on XETRA (Siemens AG), not SIEMENS on NSE (Siemens Ltd.).
+ * Null when the service marks no listing with the word, or marks the word's
+ * own symbol, and when search names no company or is too busy to say.
+ */
+export async function serviceNamedCompany(typed: string, deps: Pick<ListingDeps, "dataProvider">): Promise<ListingArg | null> {
+  // Most symbols are no company's name: one search says so before any listing is weighed or quoted.
+  if (!ONE_WORD_NAME.test(typed.trim()) || !await marksAnotherListing(deps.dataProvider, typed)) return null;
+  const found = await findOneWordCompany(typed, deps);
+  if (!found?.named || found.symbol.toUpperCase() === typed.trim().toUpperCase()) return null;
+  return companyListingArg(typed, found);
+}
+
 /** 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();
@@ -1346,7 +1375,36 @@ function isMajorCoinName(word: string): boolean {
 }
 
 function findCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvider">, options: { oneWord?: boolean } = {}): Promise<CompanyNameListing | null> {
-  return findListingOfCompanyName(deps.dataProvider, typed, { meant: true, quoted: true, ...options });
+  return findListingOfCompanyName(deps.dataProvider, typed, { meant: true, quoted: true, movedLine: (listing) => movedLineOf(listing, deps), ...options });
+}
+
+/**
+ * Where the company of a US line that stopped trading, or has no quote, trades
+ * now when it moved off the symbol (`loadListingFate`): GETY became GETYQ on
+ * 2026-10-22, so "getty images" is GETYQ rather than its delisted NYSE line or
+ * the Munich line still quoting the old shares. A line that trades is not
+ * looked up.
+ */
+async function movedLineOf(
+  listing: { symbol: string; exchange: string; quote: Quote | null; name: string | null },
+  deps: Pick<ListingDeps, "dataProvider">,
+): Promise<{ symbol: string; note: string } | null> {
+  const { quote, name, ...line } = listing;
+  if (quote && !lineMayHaveMoved(quote)) return null;
+  const fate = await loadListingFate(line, deps.dataProvider, { quote });
+  const moved = fate.moved ?? (quote ? null : movedWithoutQuote(fate.change, name));
+  return moved ? { symbol: moved.tradesAs, note: moved.note } : null;
+}
+
+/**
+ * The move of a line with no quote, when it is the move of the company search
+ * names on the line. With no quote nothing tells the company's change from an
+ * older one's: a reused symbol's change data is the company that held it
+ * before, so it is followed only when that company is this one.
+ */
+function movedWithoutQuote(change: ListingFate["change"], name: string | null): MovedTickerChange | null {
+  const moved = movedAwayChange(change);
+  return moved && sameCompany(name, moved.issuer) ? moved : null;
 }
 
 async function readCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvider">, options: { oneWord?: boolean } = {}): Promise<ListingArg | null> {
@@ -1355,11 +1413,16 @@ async function readCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvi
 }
 
 function companyListingArg(typed: string, found: CompanyNameListing): ListingArg {
-  const key = `${found.symbol}:${found.exchange}`;
+  const key = found.exchange ? `${found.symbol}:${found.exchange}` : found.symbol;
   // 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;
   const question = meant ? ` ${meantQuestion({ meant })}` : "";
-  return { ...parseListingArg(key), readAs: `Read "${typed.trim()}" as ${key} (${found.name}).${question}`, ...meant ? { meant } : {} };
+  // A company that moved off the line search lists says so: "GETY became GETYQ on 2026-10-22."
+  const moved = found.moved ? ` ${found.moved}.` : "";
+  return {
+    ...parseListingArg(key), readAs: `Read "${typed.trim()}" as ${key} (${found.name}).${moved}${question}`,
+    ...meant ? { meant } : {}, ...found.exchange ? {} : { readFromName: true as const },
+  };
 }
 
 /**
@@ -1377,7 +1440,7 @@ export async function companyNameSuggestion(typed: string, deps: Pick<ListingDep
     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 };
+    return { symbol: !listing.exchange || 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;

package/src/cli/pane-functions/capabilities.ts

@@ -48,6 +48,7 @@ const NON_DATA_PANE_IDS = new Set([
   "local-agent-workspace",
   "macro-tv",
   "plugin-marketplace",
+  "roadmap",
   "world-venue-map",
 ]);
 

package/src/cli/pane-functions/discovery.ts

@@ -12,7 +12,9 @@ import type {
   PluginPersistence,
 } from "../../types/plugin";
 import { createPluginTeamState } from "../../plugins/team-state";
+import { bindPluginContextNamespaces } from "../../plugins/registry/plugin-state";
 import type { MarketContext } from "../types";
+import { createCommandPluginPersistence } from "../saved-copy-persistence";
 import type { PaneFunctionCatalog } from "./catalog";
 
 export interface PaneDiscoveryOptions {
@@ -173,23 +175,41 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
     brokers,
   });
 
+  // Each plugin's caches save what a command fetches where the app keeps them, so a failed refresh answers from them.
+  const resources = context.persistence?.resources;
+  const persistences: Array<ReturnType<typeof createCommandPluginPersistence>> = [];
+  const commandPersistence = (stateId: string) => {
+    const persistence = createCommandPluginPersistence(resources, `plugin:${stateId}`);
+    persistences.push(persistence);
+    return persistence;
+  };
+
   const destroy = () => {
     let failure: unknown;
     for (const plugin of setupPlugins.splice(0).reverse()) {
       try { plugin.dispose?.(); } catch (error) { failure ??= error; }
     }
+    // A plugin that keeps its persistence past dispose must not reach a store the command closes.
+    for (const persistence of persistences.splice(0)) persistence.release();
     brokers.clear();
     if (context.resolveBroker === resolveBroker) context.resolveBroker = previousResolver;
     if (failure) throw failure;
   };
 
+  const namespaced = (stateId: string) => ({
+    persistence: commandPersistence(stateId),
+    resume: discoveryContext.resume,
+    configState: discoveryContext.configState,
+    teamState: discoveryContext.teamState,
+  });
   try {
     for (const plugin of plugins) {
       for (const pane of plugin.panes ?? []) panes.set(pane.id, pane);
       for (const template of plugin.paneTemplates ?? []) paneTemplates.set(template.id, template);
       if (plugin.setup) {
         setupPlugins.push(plugin);
-        await plugin.setup(discoveryContext);
+        const stateId = plugin.stateId ?? plugin.id;
+        await plugin.setup(bindPluginContextNamespaces({ ...discoveryContext, ...namespaced(stateId) }, namespaced));
       }
     }
   } catch (error) {

package/src/cli/pane-functions/freshness.ts

@@ -123,6 +123,8 @@ export interface ReportFreshness {
   ageOnly?: true;
   /** What the newest observation is, said before its time: `newest story Tue 29 Sep 2026 20:17 UTC`. */
   asOfLabel?: string;
+  /** The line says when the report was retrieved after the newest observation's date (`retrieved Wed 28 Oct 2026 19:07 UTC`). */
+  retrievedToo?: true;
   /** What the figures are, said after the status: `funding = current estimate, pays 08:00 UTC`. */
   note?: string;
   /** Shorter forms of `note`, in the order a capture's line too long for it tries them. */
@@ -610,6 +612,7 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
     ...(oldestAgeMinutes != null ? { oldestAgeMinutes } : {}),
     ...(status === "unreported" && declared.ageOnly ? { ageOnly: true as const } : {}),
     ...(asOfLabel ? { asOfLabel } : {}),
+    ...(asOf && declared.retrievedToo ? { retrievedToo: true as const } : {}),
     ...(note ? { note } : {}),
     ...(noteVariants.length > 0 ? { noteVariants } : {}),
     ...(schedule ? { schedule } : {}),
@@ -1061,8 +1064,11 @@ function statusLineParts(freshness: ReportFreshness, detail: StatusLineDetail =
   const undated = detail.date === "none";
   return [
     ...(freshness.sources?.length ? sourcesAsOfParts(freshness, freshness.sources, undated)
-      : freshness.unreached && !freshness.asOf ? []
+      // Undated, a saved copy is not "retrieved" now: its own part says when it was saved.
+      : (freshness.unreached || freshness.savedAt) && !freshness.asOf ? []
       : [asOfText(freshness, detail.asOf === "short", local, undated)]),
+    // A list dated by its newest filing says when it was read as well.
+    ...(freshness.retrievedToo && freshness.asOf && !freshness.savedAt ? [`retrieved ${timeText(freshness.retrievedAt, local)}`] : []),
     ...(freshness.schedule && detail.schedule !== "none"
       ? [typeof detail.schedule === "number" ? freshness.scheduleVariants?.[detail.schedule] ?? freshness.schedule : freshness.schedule] : []),
     ...(freshness.oldestAgeMinutes != null ? [`oldest ${ageText(freshness.oldestAgeMinutes)}`] : []),

package/src/cli/pane-functions/function-help.ts

@@ -1426,6 +1426,13 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     data: null,
     bloomberg: [],
   },
+  ROADMAP: {
+    summary: "What is being built, what is planned and what shipped, with each item's votes. Pro members vote on what is building or planned, once per item, and can take the vote back.",
+    usage: ["ROADMAP"],
+    keys: [OPEN, key("v", "ote")],
+    data: null,
+    bloomberg: [],
+  },
   HELP: {
     summary: "Help and the function reference. HELP with a function opens its card, F1 opens the focused pane's, and HELP HELP reaches support.",
     usage: ["HELP", "HELP OMON", "HELP HELP"],

package/src/cli/pane-functions/index.ts

@@ -36,8 +36,8 @@ import {
   ListingArgError, listingFateLoader, listingReadNotes, loadForListing, loadListingQuoteAnswer, quotedListingChoiceNotes, refuseMovedListing,
 } from "../listing-arg";
 import { notATickerStop } from "../company-name-hint";
-import { CLI_ERROR_CODE, failWithError, isCliFailure, SERVICE_UNREACHABLE_CODE } from "../errors";
-import { DATA_SERVICE_UNREACHABLE_MESSAGE } from "../../utils/network-failure";
+import { CLI_ERROR_CODE, failUnreachable, failWithError, isCliFailure, unreachableError } from "../errors";
+import { DATA_SERVICE_UNREACHABLE_MESSAGE, isNetworkFailure } from "../../utils/network-failure";
 import { isTickerLinkPeer } from "../../layout/ticker-navigation";
 import { knownGapMessage, commandPointer, commandPointerLeads, topicPointer } from "../known-gaps";
 import { selectReportTables, type CliReportTables } from "../report-tables";
@@ -264,7 +264,7 @@ export function reportFailure(
   const reasons = [...data.errors ?? [], ...typeof data.reason === "string" ? [data.reason] : []];
   const unreached = reasons.filter((reason) => reason.includes(DATA_SERVICE_UNREACHABLE_MESSAGE));
   if (unreached.length > 0 && (data.empty || data.unavailableSymbols.length > 0)) {
-    return { code: SERVICE_UNREACHABLE_CODE, message: `${asked}: ${unreached.join("; ")}.`.replace(/\.\.$/, "."), retryable: true };
+    return unreachableError(`${asked}: ${unreached.join("; ")}.`.replace(/\.\.$/, "."));
   }
   if (!data.empty && !(noListing && noValues) && !(failsWithoutData && foundNothing(data))) return null;
   const unavailable = data.unavailableSymbols.length > 0 ? `no data for ${data.unavailableSymbols.join(", ")}` : "no data";
@@ -618,6 +618,9 @@ async function runPaneCliCommand(ctx: CliCommandContext, run: () => Promise<void
     // A listing it cannot use says what to type instead; a name that opens nothing, what is close to it.
     if (error instanceof ListingArgError || error instanceof UnknownPaneFunctionError) ctx.fail(error.message, error.details || undefined);
     const message = error instanceof Error ? error.message : String(error);
+    // Nothing answered: said as every command says it, with what to check.
+    if (message.includes(DATA_SERVICE_UNREACHABLE_MESSAGE)) failUnreachable(message);
+    if (isNetworkFailure(error)) failUnreachable();
     // A failure the command already worded keeps its advice line.
     const stated = error instanceof Error ? (error as Error & { details?: unknown }).details : undefined;
     const details = typeof stated === "string" ? stated : undefined;