@gloom-sh/terminal 0.19.0 → 0.19.1

package/src/cli/commands/overview.ts

@@ -1,8 +1,8 @@
 import { logFailure } from "../../utils/log-failure";
 import { apiClient } from "../../api-client";
-import { ApiRequestError } from "../../api-client/errors";
+import { ApiRequestError, isPermanentClientError } from "../../api-client/errors";
 import type { CliCommandDef } from "../../types/plugin";
-import { withCliServices, withMarketData } from "../context";
+import { withCliServices, withConfigData, withMarketData } from "../context";
 import { CLI_ERROR_CODE, failWithFields } from "../errors";
 import type { CliResultColumn } from "../result";
 import { formatCompact } from "../../utils/format";
@@ -25,17 +25,27 @@ import {
 import { MOVER_CANDIDATES } from "../../plugins/builtin/market-movers/client";
 import { hasPartialFloat, meetsMinFloat, minFloatShares, normalizeMinFloat, PARTIAL_FLOAT_NOTE } from "../../plugins/builtin/market-movers/min-float";
 import { fetchEconCalendarFrom } from "../../plugins/builtin/econ/calendar-source";
-import { computedFredSeriesNote, seriesNotOnFred } from "../../sources/gloomberb-cloud/fred-series";
+import {
+  attachFredSeriesPersistence, computedFredSeriesNote, loadCachedFredSeries, resetFredSeriesPersistence, seriesNotOnFred,
+} from "../../sources/gloomberb-cloud/fred-series";
+import type { CloudFredSeriesPayload } from "../../api-client";
+import { savedCopyMark } from "../../data/saved-copies";
+import { ratesMacroPluginMeta } from "../../plugins/builtin/builtin-plugin-meta";
+import { createCommandPluginPersistence } from "../saved-copy-persistence";
 import { EXTENDED_SESSION_LABELS, getQuoteSessionFields, type ExtendedSession } from "../../market-data/market/status";
 import {
   COUNTRY_CYCLE,
   COUNTRY_FILTER_HINT,
+  awaitsConsensus,
   countriesWithoutEvents,
+  econEventName,
   FILTER_CYCLE,
   loadCalendar,
   eventCountry,
   matchesCountry,
+  matchesEventSearch,
   matchesImpact,
+  NO_CONSENSUS_NOTE,
   noScheduledReleasesMessage,
   parseCountryFilter,
   shortCalendarEnd,
@@ -303,7 +313,7 @@ function utcDateTimePart(value: unknown, part: "date" | "time", readerClock = tr
   return part === "date" ? iso.slice(0, 10) : `${iso.slice(11, 16)} UTC${readerClock ? localTimeSuffix(date.getTime()) : ""}`;
 }
 
-const ECON_USAGE = "econ [--country <regions or countries>] [--impact <level>] [--from <date>] [--tz <zone>]";
+const ECON_USAGE = "econ [--country <regions or countries>] [--impact <level>] [--search <words>] [--from <date>] [--tz <zone>]";
 const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
 /** "Sat" for 2026-10-31. */
 const weekdayOf = (date: string) => WEEKDAYS[new Date(`${date}T00:00:00Z`).getUTCDay()]!;
@@ -470,13 +480,15 @@ async function runEcon(args: string[], ctx: Parameters<CliCommandDef["execute"]>
   const rawArgs = [...args];
   const country = parseCountry(takeOption(rawArgs, "--country"), ctx);
   const impact: ImpactFilter = parseFilter(takeOption(rawArgs, "--impact"), FILTER_CYCLE, "impact", ctx);
+  const search = takeOption(rawArgs, "--search")?.trim() ?? null;
+  if (search === "") ctx.fail("--search needs the words of an event's name.", "Such as econ --search nonfarm.");
   const fromOption = parseDateOption(takeOption(rawArgs, "--from"), "--from", ctx);
   const tzOption = takeOption(rawArgs, "--tz");
   const viewerZone = tzOption == null ? null : canonicalTimeZone(tzOption);
   if (tzOption != null && !viewerZone) {
     ctx.fail(`Unknown time zone "${tzOption}".`, "Use an IANA zone name, such as America/New_York, Europe/London or Asia/Tokyo.");
   }
-  rejectArgs(rawArgs, ECON_USAGE, ctx, "Filter with --country and --impact.");
+  rejectArgs(rawArgs, ECON_USAGE, ctx, "Filter with --country, --impact and --search.");
   await withCliServices(ctx, async () => {
     const now = Date.now();
     const todayStart = Math.floor(now / DAY_MS) * DAY_MS;
@@ -487,7 +499,9 @@ async function runEcon(args: string[], ctx: Parameters<CliCommandDef["execute"]>
       : null;
     const past = stored?.events ? stored : null;
     const unread = stored && !stored.events && stored.failure ? `The stored calendar could not be read (${stored.failure}); listing the current calendar` : null;
-    const { data: events, fetchedAt, stale } = past ? { data: past.events, fetchedAt: Date.now(), stale: false } : await loadCalendar(ctx.cliOptions.refresh);
+    const { data: events, fetchedAt, stale, source } = past
+      ? { data: past.events, fetchedAt: Date.now(), stale: false, source: "network" as const }
+      : await loadCalendar(ctx.cliOptions.refresh);
     // The calendar lists from today (UTC). --from moves the first day; --tail
     // alone keeps the newest events of the whole calendar, the past week's too.
     const from = fromOption ?? (ctx.cliOptions.tail != null ? null : new Date(todayStart).toISOString().slice(0, 10));
@@ -506,9 +520,10 @@ async function runEcon(args: string[], ctx: Parameters<CliCommandDef["execute"]>
     // Countries asked for that nothing in the window is for: a quiet week there, not an unknown country.
     const inWindow = events.filter((event) => event.date.getTime() >= fromTime);
     const unscheduled = countriesWithoutEvents(country, inWindow);
-    const rows = inWindow
-      .filter((event) => matchesCountry(event, country) && matchesImpact(event, impact))
-      .sort((left, right) => left.date.getTime() - right.date.getTime())
+    const listed = inWindow
+      .filter((event) => matchesCountry(event, country) && matchesImpact(event, impact) && (search == null || matchesEventSearch(event, search)))
+      .sort((left, right) => left.date.getTime() - right.date.getTime());
+    const rows = listed
       .map((event) => {
         // The viewer's clock (--tz) for a row with a time: its date and time there.
         const clock = viewerZone && !hasNoReleaseTime(event) ? zonedClock(event.date.getTime(), viewerZone) : null;
@@ -522,7 +537,8 @@ async function runEcon(args: string[], ctx: Parameters<CliCommandDef["execute"]>
           ...(viewerZone ? { viewerDate: clock?.date ?? null, viewerTime: clock?.time ?? null } : {}),
           country: eventCountry(event),
           impact: event.impact,
-          event: event.event,
+          // As the calendar names it: the Fed's decision is the upper bound of its range.
+          event: econEventName(event),
           actual: figures.actual,
           forecast: figures.forecast,
           prior: figures.prior,
@@ -553,15 +569,20 @@ async function runEcon(args: string[], ctx: Parameters<CliCommandDef["execute"]>
     // A filter of countries only, none of which has anything in the window, says so as its empty list.
     const allUnscheduled = unscheduled.length > 0 && unscheduled.length === country.split(",").length;
     const notes = [listedBefore, listedAfter, ...(rows.length > 0 ? blankTimeNotes(rows) : []),
-      rows.length > 0 && unscheduled.length > 0 ? noScheduledReleasesMessage(unscheduled) : null]
+      rows.length > 0 && unscheduled.length > 0 ? noScheduledReleasesMessage(unscheduled) : null,
+      // A dash under Forecast on a release still to come is a consensus not in yet, not a missing figure.
+      listed.some(awaitsConsensus) ? NO_CONSENSUS_NOTE : null]
       .filter((note): note is string => !!note);
     const footnote = notes.join("\n");
+    // The calendar as read, not its rows: those are scheduled, mostly ahead. One that could not be
+    // refreshed is the copy an earlier read saved, and says when that was.
+    const read = rowsFreshness([], { status: "not-a-feed", basis: "calendar", asOf: fetchedAt }, { stale });
+    const calendarFreshness = read && source === "stale-fallback" ? { ...read, savedAt: new Date(fetchedAt).toISOString() } : read;
     ctx.printResult({
       data: rows,
       ...(unread ? { warnings: [unread] } : {}),
-      metadata: { country, impact, from, listedThrough, storedFrom: past?.storedFrom ?? null, ...(viewerZone ? { timeZone: viewerZone } : {}) },
-      // The calendar as read, not its rows: those are scheduled, mostly ahead.
-      freshness: rowsFreshness([], { status: "not-a-feed", basis: "calendar", asOf: fetchedAt }, { stale }),
+      metadata: { country, impact, ...(search != null ? { search } : {}), from, listedThrough, storedFrom: past?.storedFrom ?? null, ...(viewerZone ? { timeZone: viewerZone } : {}) },
+      freshness: calendarFreshness,
     }, {
       dateKey: "date",
       defaultLimit: 50,
@@ -607,6 +628,36 @@ function isUnsupportedSeries(error: unknown): boolean {
   return error.details?.code === "unsupported_series" || /^Unsupported FRED series\b/i.test(message);
 }
 
+/**
+ * Runs `run` with the FRED series cache saving what it fetches in the profile,
+ * where the app's rates and macro panes keep it: a refresh that fails then
+ * answers from the copy an earlier read saved, and the report says so.
+ */
+function withSavedFredSeries<T>(ctx: Parameters<CliCommandDef["execute"]>[1], run: () => Promise<T>): Promise<T> {
+  return withConfigData(ctx, async ({ persistence }) => {
+    attachFredSeriesPersistence(createCommandPluginPersistence(persistence.resources, `plugin:${ratesMacroPluginMeta.stateId}`));
+    try {
+      return await run();
+    } finally {
+      resetFredSeriesPersistence();
+    }
+  });
+}
+
+/**
+ * A FRED series from Gloom Cloud, or the copy an earlier read saved when it
+ * cannot be refreshed (marked as such). A refusal asking again will not change
+ * (a series Gloom Cloud no longer serves, access denied) is said, not covered.
+ */
+async function loadFredSeries(
+  seriesId: string,
+  params: { startDate?: string; limit?: number; sortOrder: "asc" | "desc" },
+): Promise<CloudFredSeriesPayload> {
+  const result = await loadCachedFredSeries({ seriesId, ...params }, () => apiClient.getCloudFredSeries(seriesId, params));
+  if (result.source === "stale-fallback" && isPermanentClientError(result.error)) throw result.error;
+  return result.data;
+}
+
 async function runFredList(filter: string, ctx: Parameters<CliCommandDef["execute"]>[1]) {
   let catalog;
   try {
@@ -652,9 +703,19 @@ async function runFred(rawArgs: string[], ctx: Parameters<CliCommandDef["execute
     ctx.fail(change ? `Unknown change "${change}".` : "--change needs 1D or 1W.", "Use 1D (from the previous observation) or 1W (from a week before).");
   }
   const seriesId = requireOneArg(args, FRED_USAGE, "series", ctx).toUpperCase();
+  await withSavedFredSeries(ctx, () => printFredSeries(ctx, { seriesId, start, startDate, sortOrder, horizon }));
+}
+
+async function printFredSeries(ctx: Parameters<CliCommandDef["execute"]>[1], { seriesId, start, startDate, sortOrder, horizon }: {
+  seriesId: string;
+  start: string | undefined;
+  startDate: string;
+  sortOrder: "asc" | "desc";
+  horizon: ReturnType<typeof parseFredChange>;
+}) {
   // A change needs the observation it is measured from: the fetch reaches back before the first row shown.
   const fetchStart = horizon ? fredChangeFetchStart(startDate) : startDate;
-  const data = await apiClient.getCloudFredSeries(seriesId, { startDate: fetchStart, sortOrder }).catch((error: unknown) => {
+  const data = await loadFredSeries(seriesId, { startDate: fetchStart, sortOrder }).catch((error: unknown) => {
     if (isUnsupportedSeries(error)) ctx.fail(`Unsupported FRED series ${seriesId}. List supported series with: gloom fred --list`);
     throw error;
   });
@@ -668,7 +729,9 @@ async function runFred(rawArgs: string[], ctx: Parameters<CliCommandDef["execute
   const releasedOf = (observation: { publisher?: string; publishedAt?: string; releasedOn?: string }) =>
     observation.releasedOn ?? (observation.publisher?.trim() ? observation.publishedAt : undefined);
   // A value FRED does not list yet carries its publisher and when it published, in every export.
+  // A row from the copy an earlier read saved, the refresh having failed, carries its mark: the source line says so.
   const exportRow = (observation: { date: string; value: number | null; publisher?: string; publishedAt?: string; releasedOn?: string }) => ({
+    ...savedCopyMark(data),
     date: observation.date,
     value: fredExportValue(seriesId, observation.value),
     ...(changes ? { change: changes.get(observation.date)?.change ?? null, changeFrom: changes.get(observation.date)?.changeFrom ?? null } : {}),
@@ -687,7 +750,7 @@ async function runFred(rawArgs: string[], ctx: Parameters<CliCommandDef["execute
     computedFredSeriesNote(seriesId),
   ].filter((note): note is string => note != null);
   // Nothing on or after the start: name where the series ends, so an empty answer is not a dead end.
-  const latest = rows.length > 0 ? null : await apiClient.getCloudFredSeries(seriesId, { limit: 1, sortOrder: "desc" })
+  const latest = rows.length > 0 ? null : await loadFredSeries(seriesId, { limit: 1, sortOrder: "desc" })
     .then((payload) => payload.observations[0] ?? null).catch(logFailure("cli.commands-overview", "Read latest economic series observation failed", null));
   // CSV and NDJSON are rows alone: an empty one would read as a series with no data, so it fails and says where the series ends.
   if (rows.length === 0 && (ctx.cliOptions.format === "csv" || ctx.cliOptions.format === "ndjson")) {
@@ -759,10 +822,12 @@ async function runYieldCurve(rawArgs: string[], ctx: Parameters<CliCommandDef["e
   const startDate = parseStartDate(takeOption(args, "--start"), ctx);
   rejectArgs(args, "yield-curve [--start <date>]", ctx);
   const series = Object.keys(YIELD_TENORS);
-  const results = await Promise.all(series.map(async (seriesId) => {
-    const data = await apiClient.getCloudFredSeries(seriesId, { startDate, sortOrder: "desc" });
+  const results = await withSavedFredSeries(ctx, () => Promise.all(series.map(async (seriesId) => {
+    const data = await loadFredSeries(seriesId, { startDate, sortOrder: "desc" });
     const [latest, previous] = data.observations;
     return {
+      // A tenor from the copy an earlier read saved, the refresh having failed, says so in the source line.
+      ...savedCopyMark(data),
       seriesId,
       date: latest?.date ?? "",
       // Yields in percent, which the exports' `currency_or_unit` column says (`pct`), as `fred` does.
@@ -775,7 +840,7 @@ async function runYieldCurve(rawArgs: string[], ctx: Parameters<CliCommandDef["e
       latest,
       publishedAt: latest?.publisher ? null : fredPublicationTime(data.info, latest?.date),
     };
-  }));
+  })));
   // Tenors whose latest yield FRED does not list yet name the Treasury and when it published them.
   const ahead = fredProvenance(results.flatMap((row) => row.latest ? [row.latest] : []));
   // The curve shown was published with its last tenor: the newest of their FRED updates, when each has one.
@@ -907,10 +972,11 @@ export const overviewCliCommands: CliCommandDef[] = [
       options: [
         { flags: "--country <regions or countries>", description: "US, G7, EU, all (default), or countries by their two-letter codes, comma separated, such as MX or MX,BR,ZA" },
         { flags: "--impact <level>", description: "high, medium, low, or all (default all)" },
+        { flags: "--search <words>", description: "Events whose name has these words, case, spaces and hyphens aside, such as nonfarm or fed funds" },
         { flags: "--from <date>", description: `First day listed, as ${DATE_OPTION_EXAMPLES} (default today, UTC); an earlier day lists past events from the stored calendar and says where it starts` },
         { flags: "--tz <zone>", description: "Add a column with each release's time on that clock, an IANA zone such as America/New_York; with the weekday when it falls on another day than the UTC date" },
       ],
-      examples: ["econ", "econ --country US --impact high", "econ --country MX,BR,ZA,IN,KR", "econ --from 2026-10-12 --country US",
+      examples: ["econ", "econ --country US --impact high", "econ --search nonfarm", "econ --country MX,BR,ZA,IN,KR", "econ --from 2026-10-12 --country US",
         "econ --country BR --tz America/New_York", "econ --tail 20"],
     },
     execute: runEcon,

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/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

@@ -437,6 +437,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/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/listing-arg.ts

@@ -17,7 +17,7 @@ import {
 import { findUsListingOfCompany, type UsListing } from "../tickers/us-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 { 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);
@@ -1346,7 +1359,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 +1397,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 +1424,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) {