gloomberb 0.19.2 → 0.19.3

package/src/cli/options.ts

@@ -14,7 +14,7 @@ export interface CliGlobalOptions {
   limit?: number;
   /** `--tail <n>`: the newest n rows of a dated series, in their printed order. Never set with `limit`. */
   tail?: number;
-  /** `--width <n>`: fit tables to n columns. Unset, a terminal's own width fits them and piped output is not fitted. */
+  /** `--width <n>`: fit tables to n columns. Unset, a terminal's own width fits them, and piped output fits `COLUMNS` when set, else is not fitted. */
   width?: number;
   refresh: boolean;
   dryRun: boolean;

package/src/cli/output-file.ts

@@ -1,6 +1,7 @@
-import { mkdir, stat, writeFile } from "fs/promises";
+import { lstat, mkdir } from "fs/promises";
 import { homedir } from "os";
 import { posix, win32 } from "path";
+import { NOT_A_PLAIN_FILE, writePrivateFile } from "../utils/private-files";
 
 interface OutputPathContext {
   cwd?: string;
@@ -40,29 +41,75 @@ function isFolder(path: string, paths: typeof posix): Error {
   return new Error(`Cannot write ${path}: it is a folder. Name a file in it, such as ${paths.join(path, "report.csv")}.`);
 }
 
-/** Fails when `path` names a folder: checked before a report loads, so it stops at once. */
+function isLink(path: string): Error {
+  return new Error(`Cannot write ${path}: it is a link. Name the file it points to, or a new file.`);
+}
+
+function isNotAFile(path: string): Error {
+  return new Error(`Cannot write ${path}: it is not a plain file. Name a new file, or a file to replace.`);
+}
+
+/**
+ * Fails when `path` names a folder, a link or anything else that is not a
+ * plain file (a device, a pipe): checked before a report loads, so it stops
+ * at once, and again as the file is opened.
+ */
 export async function checkOutputPath(path: string, platform: NodeJS.Platform = process.platform): Promise<void> {
-  const existing = await stat(path).catch(() => {
+  const existing = await lstat(path).catch(() => {
     // Intentional ignore: a path that does not exist yet is the usual case, and writing reports any real failure.
     return null;
   });
-  if (existing?.isDirectory()) throw isFolder(path, platform === "win32" ? win32 : posix);
+  if (!existing) return;
+  if (existing.isDirectory()) throw isFolder(path, platform === "win32" ? win32 : posix);
+  if (existing.isSymbolicLink()) throw isLink(path);
+  if (!existing.isFile()) throw isNotAFile(path);
+}
+
+/**
+ * Creates the folder `path` goes in and the folders above it, failing with
+ * that folder named when it cannot: `--output /nonexistent/x.png` cannot
+ * create /nonexistent, which says more than the `mkdir` error behind it.
+ */
+export async function createOutputFolder(path: string, platform: NodeJS.Platform = process.platform): Promise<void> {
+  const folder = (platform === "win32" ? win32 : posix).dirname(path);
+  try {
+    await mkdir(folder, { recursive: true });
+  } catch (error) {
+    const code = errorCode(error);
+    const lead = `Cannot create the folder ${folder}`;
+    if (code === "EACCES" || code === "EPERM") throw new Error(`${lead}: permission denied.`);
+    if (code === "EROFS") throw new Error(`${lead}: the disk is read-only.`);
+    if (code === "ENOTDIR" || code === "EEXIST") throw new Error(`${lead}: a file stands where one of its folders would be.`);
+    throw new Error(`${lead}: ${error instanceof Error ? error.message : String(error)}`);
+  }
 }
 
 /**
  * Writes a command's output to `path`, creating the folders it names as
- * `shot --output` does, and failing with what to do when it cannot.
+ * `shot --output` does, and failing with what to do when it cannot. The file
+ * is readable by the user alone, as one it replaces is made, and only a plain
+ * file is written: a link or a device in its place is refused, checked first
+ * and again as the file is opened.
  */
-export async function writeOutputFile(path: string, contents: string, platform: NodeJS.Platform = process.platform): Promise<void> {
+export async function writeOutputFile(path: string, contents: string | Uint8Array, platform: NodeJS.Platform = process.platform): Promise<void> {
   const paths = platform === "win32" ? win32 : posix;
+  await createOutputFolder(path, platform);
+  await checkOutputPath(path, platform);
   try {
-    await mkdir(paths.dirname(path), { recursive: true });
-    await writeFile(path, contents);
+    await writePrivateFile(path, contents);
   } catch (error) {
-    const code = errorCode(error);
-    if (code === "EISDIR") throw isFolder(path, paths);
-    if (code === "EACCES" || code === "EPERM") throw new Error(`Cannot write ${path}: permission denied.`);
-    if (code === "ENOTDIR" || code === "EEXIST") throw new Error(`Cannot write ${path}: a file stands where one of its folders would be.`);
-    throw new Error(`Cannot write ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    throw writeFailure(path, paths, error);
   }
 }
+
+function writeFailure(path: string, paths: typeof posix, error: unknown): Error {
+  const code = errorCode(error);
+  if (code === "EISDIR") return isFolder(path, paths);
+  // A link opened without following it: ELOOP on Linux and macOS, EMLINK on FreeBSD.
+  if (code === "ELOOP" || code === "EMLINK") return isLink(path);
+  // A device, or a pipe no one reads.
+  if (code === NOT_A_PLAIN_FILE || code === "ENXIO") return isNotAFile(path);
+  if (code === "EACCES" || code === "EPERM") return new Error(`Cannot write ${path}: permission denied.`);
+  if (code === "ENOTDIR" || code === "EEXIST") return new Error(`Cannot write ${path}: a file stands where one of its folders would be.`);
+  return new Error(`Cannot write ${path}: ${error instanceof Error ? error.message : String(error)}`);
+}

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

@@ -32,6 +32,17 @@ import {
 import { renderGlossaryEntries, type GlossaryLookup } from "../glossary";
 import { renderSeriesMatches, type SeriesMatch } from "../series-search";
 import { typoDistance } from "../../utils/typo-distance";
+import { quotedSearchCommand } from "../commands/news-search";
+
+/**
+ * The `news` search for words no function matches (`catalog hurricane`):
+ * one word quoted so `news` searches the stories rather than a ticker, several
+ * as typed in one pair of quotes.
+ */
+function catalogNewsCommand(query: string): string {
+  const words = query.trim().replace(/\s+/g, " ").replace(/["']/g, "");
+  return /\s/.test(words) ? `gloom news "${words}"` : quotedSearchCommand(words.toLowerCase());
+}
 
 export interface PaneFunctionCatalog {
   panes: ReadonlyMap<string, PaneDef>;
@@ -253,9 +264,9 @@ async function buildTemplateCatalogEntry(
   const sampleArg = sampleArgForTemplate(template);
   const createOptions: PaneTemplateCreateOptions | undefined = buildCreateOptions(template, sampleArg);
   const primarySymbol = createOptions?.symbol ?? createOptions?.symbols?.[0] ?? null;
-  let defaultSettings: Record<string, unknown> = {};
+  let defaultSettings: Record<string, unknown> = template.catalogSettings ?? {};
 
-  if (template.createInstance) {
+  if (template.catalogSettings === undefined && template.createInstance) {
     try {
       const spec = await template.createInstance(buildTemplateContext(context, primarySymbol), createOptions);
       defaultSettings = spec?.settings ?? {};
@@ -810,7 +821,7 @@ export function renderPaneCatalogReport(
     if (charted) return withGap([charted, terms].filter(Boolean).join("\n\n"));
     if (glossary.exact.length > 0 || gap || setting) return withGap(terms);
     return withTerms(note(args.query
-      ? `No functions match "${args.query}". Run gloom catalog to browse them all.`
+      ? `No functions match "${args.query}". For stories that mention it: ${catalogNewsCommand(args.query)}. Run gloom catalog to browse them all.`
       : "No functions are available."));
   }
 

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

@@ -238,7 +238,7 @@ export function collectShotSymbols(resolved: ResolvedPaneFunction, rawArg: strin
     }
   }
   // A text argument is a phrase, not a symbol, so it must never be looked up as one.
-  const argIsTicker = argumentNamesTicker(resolved.template, resolved.headless);
+  const argIsTicker = argumentNamesTicker(resolved.template, resolved.headless, resolved.pane);
   let symbols = resolved.createOptions?.symbols?.length
     ? resolved.createOptions.symbols
     : [

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

@@ -10,6 +10,7 @@ import { createHeadlessPaneContext } from "./headless";
 import type { HeadlessPaneContext } from "../../types/headless";
 import { lockNoteReason } from "../../plugins/builtin/shared/pro-lock-note";
 import { renderDesktopShot } from "./screenshot-render";
+import { resolvePersistedCloudSessionToken } from "./cloud-session";
 import type { PaneScreenshotResult } from "./screenshot-types";
 import { deriveRenderedFreshness, formatFreshnessLine, type ReportFreshness } from "./freshness";
 import { exportTextTable, reportFooterLines, type CliReportTables } from "../report-tables";
@@ -389,11 +390,55 @@ class RenderedReportFailure extends Error {
   }
 }
 
+/**
+ * The report of a pane the sign-in wall covers whole (`PaneDef.signInWall`)
+ * when there is no session: its lock note, as the rendered wall reports it,
+ * without waiting for the wall to render. Null with a session, or for any
+ * other pane.
+ */
+async function signedOutDomReport(
+  resolved: ResolvedPaneFunction,
+  context: MarketContext,
+  rawArg: string,
+): Promise<PaneFunctionReport | null> {
+  if (!resolved.pane.signInWall || !resolved.pane.reportLockNote || resolvePersistedCloudSessionToken(context)) return null;
+  const symbols = collectShotSymbols(resolved, rawArg);
+  const note = await resolved.pane.reportLockNote({
+    gate: "sign-in", symbol: symbols[0] ?? null, token: resolved.token,
+    context: createHeadlessPaneContext(resolved, context, new AbortController().signal),
+  });
+  const reason = lockNoteReason(note);
+  return {
+    data: {
+      kind: "rendered-view",
+      target: resolved.token,
+      capabilityId: resolved.capability.id,
+      symbols,
+      options: resolved.options,
+      rowCount: 0,
+      empty: true,
+      complete: false,
+      unavailableSymbols: [],
+      rows: [],
+      visibleText: "",
+      truncated: false,
+      truncationReasons: [],
+      limitation: DOM_LIMITATION,
+      reason,
+      locked: "sign-in",
+    },
+    text: [resolved.label, "", ...lockNoteLines(note)].join("\n").trimEnd(),
+    tables: domReportTables([], resolved.label, null, reason, []),
+  };
+}
+
 export async function buildDomFunctionReport(
   resolved: ResolvedPaneFunction,
   context: MarketContext,
   rawArg: string,
 ): Promise<PaneFunctionReport> {
+  const signedOut = await signedOutDomReport(resolved, context, rawArg);
+  if (signedOut) return signedOut;
   let result: PaneScreenshotResult;
   try {
     result = await renderDesktopShot({

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 newest observation is a bar of this many minutes opening at `asOf`: the line names its span (`last bar 15:00–16:00 UTC`). */
+  barMinutes?: number;
   /** 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`. */
@@ -572,6 +574,7 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
   const note = declared.note?.trim();
   const noteVariants = note ? (declared.noteVariants ?? []).map((variant) => variant.trim()).filter((variant) => variant && variant !== note) : [];
   const asOfLabel = asOf ? declared.asOfLabel?.trim() : undefined;
+  const barMinutes = asOf && !asOf.dateOnly && !declaredAsOf && declared.barMinutes != null && declared.barMinutes > 0 ? declared.barMinutes : undefined;
   const schedule = declared.schedule?.trim();
   const scheduleVariants = schedule ? (declared.scheduleVariants ?? []).map((variant) => variant.trim()).filter((variant) => variant && variant !== schedule) : [];
   const publisher = declared.publisher?.trim();
@@ -612,6 +615,7 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
     ...(oldestAgeMinutes != null ? { oldestAgeMinutes } : {}),
     ...(status === "unreported" && declared.ageOnly ? { ageOnly: true as const } : {}),
     ...(asOfLabel ? { asOfLabel } : {}),
+    ...(barMinutes ? { barMinutes } : {}),
     ...(asOf && declared.retrievedToo ? { retrievedToo: true as const } : {}),
     ...(note ? { note } : {}),
     ...(noteVariants.length > 0 ? { noteVariants } : {}),
@@ -619,10 +623,16 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
     ...(scheduleVariants.length > 0 ? { scheduleVariants } : {}),
     ...(publisher ? { publisher } : {}),
     ...(publishedAt ? { publishedAt: isoTime(publishedAt) } : {}),
-    retrievedAt: new Date(now).toISOString(),
+    retrievedAt: declaredRetrieval(declared.retrievedAt, now) ?? new Date(now).toISOString(),
   };
 }
 
+/** A declared retrieval (`retrievedAt`): when the source last read the data, not in the future. */
+function declaredRetrieval(value: string | undefined, now: number): string | null {
+  const time = value ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(time) && time <= now + FUTURE_TOLERANCE_MS ? new Date(time).toISOString() : null;
+}
+
 /**
  * Source, as-of and status for a headless report: what the loader declared
  * (the result's `freshness` over the definition's), the rest read from the
@@ -914,6 +924,8 @@ function asOfText(freshness: ReportFreshness, short: boolean, local: boolean, un
     : period ? `${periodText(freshness.asOf, period)} (${period})`
     : freshness.asOfClose
       ? `${tradingDayText(freshness.asOfClose, market)} close`
+      : freshness.barMinutes && time && !time.dateOnly
+        ? barSpanText(time.time, freshness.barMinutes, undated && onRetrievalDay(new Date(time.time).toISOString(), freshness.retrievedAt))
       : time?.dateOnly ? tradingDayText(freshness.asOf, market)
         : undated && time && onRetrievalDay(new Date(time.time).toISOString(), freshness.retrievedAt)
           ? `${new Date(time.time).toISOString().slice(11, 16)} UTC` : timeText(freshness.asOf, local);
@@ -924,6 +936,14 @@ function asOfText(freshness: ReportFreshness, short: boolean, local: boolean, un
   return oldest && !short && freshness.oldestAgeMinutes == null ? `${dated} (oldest ${oldest})` : dated;
 }
 
+/** `Fri 30 Oct 2026, last bar 15:00–16:00 UTC`: the newest bar's span; `undated` leaves the day off. */
+function barSpanText(open: number, minutes: number, undated: boolean): string {
+  const start = new Date(open).toISOString();
+  const end = new Date(open + minutes * 60_000).toISOString();
+  const span = `last bar ${start.slice(11, 16)}–${end.slice(11, 16)} UTC`;
+  return undated ? span : `${dayText(start)}, ${span}`;
+}
+
 /**
  * Each source's own as-of, the zone named once at the end:
  * `Sun 11 Oct 2026 · Binance 02:15 · Bybit 02:24 UTC`. The day leads, the newest source's,
@@ -986,6 +1006,15 @@ function marketText(market: ReportMarket, now: number, short: boolean, local: bo
   }
 }
 
+/**
+ * Where one venue's market stands now and the status line's words for it (`markets closed until Mon`), for a pane with
+ * no dated rows to read that from, such as a scanner. Null when no calendar places the venue.
+ */
+export function venueMarketLine(exchange: string, now: number): { state: ReportMarket["state"]; text: string } | null {
+  const { market } = reportMarketSession([{ exchange, time: null }], now);
+  return market ? { state: market.state, text: marketText(market, now, false, false) } : null;
+}
+
 /** Whether every market of a mixed report reads the same (`markets closed until Mon`): one line then says it for all. */
 function sameMarketText(markets: readonly VenueMarket[], now: number): boolean {
   return new Set(markets.map((market) => marketText(market, now, false, false))).size === 1;
@@ -1092,8 +1121,10 @@ function observedDayText(date: string, retrievedAt: string): string {
 }
 
 interface DatasetLineDetail {
-  /** Leave out the source. */
-  source?: "none";
+  /** The source without its `Source:` label, or left out. */
+  source?: "bare" | "none";
+  /** Leave out how many days the data lags, which a narrow line gives up before its source and date. */
+  lag?: "none";
   /** Leave out the oldest observation. */
   oldest?: "none";
   /** Count stale rows without their total. */
@@ -1113,11 +1144,12 @@ function lagText(days: number): string {
  * `Source: DTCC · last trade 2026-10-09 · lag 2 days`.
  */
 function datasetLineParts(freshness: ReportFreshness, asOf: string, lagDays: number, detail: DatasetLineDetail = {}): string[] {
+  const source = detail.source === "none" ? [] : [detail.source === "bare" ? freshness.source : `Source: ${freshness.source}`];
   if (freshness.observation) {
     return [
-      ...(detail.source === "none" ? [] : [`Source: ${freshness.source}`]),
+      ...source,
       `${freshness.observation} ${asOf.slice(0, 10)}`,
-      lagText(lagDays),
+      ...(detail.lag === "none" ? [] : [lagText(lagDays)]),
       ...(freshness.savedAt ? [savedCopyText(freshness.savedAt, freshness.retrievedAt, false)]
         : freshness.status === "stale" ? ["stale"] : []),
     ];
@@ -1127,9 +1159,9 @@ function datasetLineParts(freshness: ReportFreshness, asOf: string, lagDays: num
   const oldest = freshness.oldest && detail.oldest !== "none" ? ` (oldest ${dated(freshness.oldest)})` : "";
   const stale = freshness.status !== "stale" ? null : staleRowsText(freshness, detail.status === "short") ?? "stale";
   return [
-    ...(detail.source === "none" ? [] : [`Source: ${freshness.source}`]),
+    ...source,
     `observed ${dated(asOf)}${period ? ` (${period})` : ""}${oldest}`,
-    `lag ${lagDays}d`,
+    ...(detail.lag === "none" ? [] : [`lag ${lagDays}d`]),
     ...(freshness.savedAt ? [savedCopyText(freshness.savedAt, freshness.retrievedAt, false)] : stale ? [stale] : []),
   ];
 }
@@ -1190,16 +1222,21 @@ export function paneStatusLineVariants(freshness: ReportFreshness): string[] {
  * `Source: CFTC · Tue 6 Oct 2026 · not a live feed (weekly report)`, shortens
  * the same way and gives up its source last. A dataset reads
  * `Source: Gloom Cloud · observed Sun 4 Oct · lag 6d` and gives up its oldest
- * observation, the stale total, then its source.
+ * observation, the stale total, then its lag; its source loses its label
+ * (`Gloom Cloud · observed Sun 4 Oct`), and the narrowest line is the date
+ * alone (`Observed Sun 4 Oct`): the source goes before the date.
  */
 export function statusLineVariants(freshness: ReportFreshness, { source = false }: { source?: boolean } = {}): string[] {
   if (datesObservation(freshness)) {
     const { asOf, lagDays } = freshness;
+    // The lag, relative to the reading, goes before the source and the date; the source before the date.
     const datasetDetails: DatasetLineDetail[] = [
       {},
       { oldest: "none" },
       { oldest: "none", status: "short" },
-      { source: "none", oldest: "none", status: "short" },
+      { oldest: "none", status: "short", lag: "none" },
+      { oldest: "none", status: "short", lag: "none", source: "bare" },
+      { oldest: "none", status: "short", lag: "none", source: "none" },
     ];
     return [...new Set(datasetDetails.map((detail) => capitalize(datasetLineParts(freshness, asOf, lagDays, detail).join(" · "))))];
   }

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

@@ -234,10 +234,11 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     bloomberg: ["RV"],
   },
   EQS: {
-    summary: "Screen covered stocks on valuation, growth, margins, liquidity, volatility, technicals, float and ownership, short interest, insider activity and 13F holders, then rank the matches by any metric. "
+    summary: "Screen covered stocks on valuation, growth, margins, returns on capital, leverage, liquidity, volatility, technicals, float and ownership, short interest, insider activity and 13F holders, then rank the matches by any metric. "
       + "ATR% is the 14-session average true range as a percent of the last close. IV rank is a rank, not an IV percentile: 0 is the lowest 30-day implied volatility of the past 52 weeks and 100 the highest. IV percentile, IV30 change in vol points, HV20 and HV rank screen premium to sell. "
-      + "Technical fields read the last completed session: RSI 14, price vs SMA 20, 50 and 200, trading days since a MACD or golden cross and since a new 20-day or 52-week high or low, and Bollinger width percentile (0 is a six-month squeeze). Ideas holds ready technical screens.",
-    usage: ["EQS", "gloom fn EQS --preset golden-cross"],
+      + "Technical fields read the last completed session: RSI 14, price vs SMA 20, 50 and 200, trading days since a MACD or golden cross and since a new 20-day or 52-week high or low, and Bollinger width percentile (0 is a six-month squeeze). "
+      + "ROIC, FCF yield, net debt / EBITDA, debt / equity and the revenue and EPS CAGRs read FA's bases, and forward growth EE's consensus; N/M where FA prints it. Ideas holds ready technical screens and Value, Quality and GARP.",
+    usage: ["EQS", "gloom fn EQS --preset golden-cross", "gloom fn EQS --preset quality"],
     keys: [key("a", "dd criterion"), key("m", "etric"), key("t", "check ticker"), key("s", "ave screen"), key("o", "pen research")],
     data: same("Daily snapshot, statements as filed"),
     bloomberg: ["EQS"],
@@ -533,7 +534,7 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     bloomberg: ["CAST", "DDIS"],
   },
   ATTN: {
-    summary: "See which tickers opted-in Gloom users are researching, with delayed privacy-qualified hourly counts, abnormal attention, sectors, countries and market context. Suppressed activity is unavailable, never zero.",
+    summary: "See which tickers Gloom users are researching, with delayed privacy-qualified hourly counts, abnormal attention, sectors, countries and market context. Suppressed activity is unavailable, never zero.",
     usage: ["ATTN", "ATTN 6758:JPX"],
     keys: [OPEN, key("e", "vidence"), key("d", "es"), key("g", "raph"), key("n", "ews")],
     data: { free: "Three published rows per section and the latest history point", pro: "All published rows and hourly history; minimum one-hour publication lag" },
@@ -1252,10 +1253,17 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     bloomberg: [],
   },
   TBO: {
-    summary: "Data center and semiconductor supply chain intelligence: company lists, sites and intel, with limited free data and full access with a TheBuildout subscription.",
+    summary: "Data center and semiconductor supply chain intelligence: a board of AI buildout themes sized by market cap and coloured by median 1Y return, each theme's companies, sites and intel, with limited free data and full access with Buildout.",
     usage: ["TBO"],
-    keys: [TABS, OPEN, key("s", "tar")],
-    data: same("Intel 72 hours delayed without a TheBuildout plan"),
+    keys: [TABS, key("←/→", " theme"), OPEN, key("s", "tar")],
+    data: same("Intel 72 hours delayed without Buildout"),
+    bloomberg: [],
+  },
+  TBOC: {
+    summary: "One company in TheBuildout: its power and hosting deals, suppliers and customers as a flow, its sites, hiring by site and the signals that name it. Linked to TBO, it follows the company under the cursor.",
+    usage: ["TBOC MSFT", "TBOC MSFT --tab signals"],
+    keys: [TABS, OPEN],
+    data: same("Signals 72 hours delayed and no hiring by site without Buildout"),
     bloomberg: [],
   },
   ACM: {
@@ -1427,9 +1435,9 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     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.",
+    summary: "What is being built, what is planned and what shipped, with each item's votes, and the Changelog in a second tab. 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")],
+    keys: [TABS, OPEN, key("v", "ote")],
     data: null,
     bloomberg: [],
   },

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

@@ -1,9 +1,10 @@
 import { getSharedRegistry } from "../../plugins/registry";
+import { seriesExpression, seriesNamedBy } from "../../series/registry";
 import { findCachedPortfolioAccount } from "../../plugins/builtin/portfolio-list/cached-account";
-import { parsePublicTickerKey } from "../../utils/exchanges";
 import { findNamedCollection } from "../../portfolio/collection-name";
 import { readBareListing } from "../listing-arg";
 import { apiClient } from "../../api-client";
+import { resolveSavedInstrument } from "../../tickers/saved-instrument";
 import type { MarketContext } from "../types";
 import type {
   HeadlessArgumentExpansion,
@@ -190,7 +191,7 @@ async function loadHeadlessPaneModel(
   return result;
 }
 
-type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh" | "resolveBroker"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities" | "findCatalogSeries">> & {
+type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh" | "resolveBroker"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities" | "findCatalogSeries" | "findCatalogSeriesNamed">> & {
   dataProvider: HeadlessPaneContext["marketData"];
 };
 
@@ -210,6 +211,11 @@ export function createHeadlessPaneContext(
     capabilities: getSharedRegistry() ?? context.seriesCapabilities,
     catalogSeriesName: (expression) => (getSharedRegistry()?.series.findByExpression(expression)?.definition
       ?? context.findCatalogSeries?.(expression))?.name,
+    catalogSeriesNamed: (word) => {
+      const registered = getSharedRegistry()?.series?.list().map(({ definition }) => definition) ?? [];
+      const definition = seriesNamedBy(registered, word) ?? context.findCatalogSeriesNamed?.(word);
+      return definition ? { expression: seriesExpression(definition), name: definition.name } : undefined;
+    },
     resolveBroker: context.resolveBroker,
     async resolvePortfolio(id) {
       const portfolio = findNamedCollection(context.config.portfolios, id);
@@ -222,25 +228,21 @@ export function createHeadlessPaneContext(
       if (!watchlist) return null;
       return (await context.store.loadAllTickers()).filter(row => row.metadata.watchlists.includes(watchlist.id));
     },
-    async resolveInstrument(key) {
-      const parsed = parsePublicTickerKey(key);
-      const ticker = await context.store.loadTicker(key)
-        ?? (key !== parsed.symbol ? await context.store.loadTicker(parsed.symbol) : null);
-      return { symbol: parsed.symbol, exchange: parsed.exchange ?? ticker?.metadata.exchange };
-    },
+    resolveInstrument: (key) => resolveSavedInstrument(key, (saved) => context.store.loadTicker(saved)),
     readDeviceState: <T,>(pluginId: string, key: string) =>
       context.persistence?.pluginState.get<T>(pluginId, resumeStateKey(key))?.value ?? null,
     async resolveListing(symbol, argumentWith) {
       const command = `fn ${resolved.token}`;
       const read = await readBareListing(symbol, context, {
         command, noun: "a quote", retry: (key) => `gloom ${command} ${argumentWith(key)}`,
-      }, { refresh: !!context.refresh });
+      }, { refresh: !!context.refresh, successor: true });
       if (!read) return null;
       return {
         symbol: read.symbol,
         ...read.exchange ? { exchange: read.exchange } : {},
         ...read.name ? { name: read.name } : {},
         ...read.coinNote ? { coinNote: read.coinNote } : {},
+        ...read.successorNote ? { successorNote: read.successorNote } : {},
       };
     },
   };
@@ -544,12 +546,17 @@ function renderRows(
       stackPriority: column.stackPriority,
       stackRows: column.stackRows,
       minTableWidth: column.minTableWidth,
+      optional: column.optional,
+      dropPriority: column.dropPriority,
     })),
     rows.map((row) => columns.map((column) => cell(row, column))),
     {
-      below: under.length === 0 ? undefined : rows.map((row) => under.flatMap((column) => (
-        row[column.key] == null || row[column.key] === "" ? [] : cell(row, column).split("\n")
-      ))),
+      // A value the text leaves out (a summary that only repeats the headline) takes no line.
+      below: under.length === 0 ? undefined : rows.map((row) => under.flatMap((column) => {
+        const text = row[column.key] == null || row[column.key] === "" ? "" : cell(row, column);
+        return text === "" ? [] : text.split("\n");
+      })),
+      ...(under.length > 0 && under.every((column) => column.underRow === "line") ? { cutBelow: true } : {}),
     },
   );
 }
@@ -571,7 +578,7 @@ function renderBundle(
   return result.sections.filter((section) => !isLockedSection(section)).flatMap((section, index) => [
     ...(index > 0 ? [""] : []),
     // A section with no title is its rows, or its empty message, alone.
-    ...(section.title ? [renderSection(section.title)] : []),
+    ...(section.title ? [renderSection(section.textTitle ?? section.title)] : []),
     "rows" in section && section.rows
       ? renderRows(section.textRows ?? section.rows, section.textColumns ?? section.columns, definition.columns, section.empty)
       : renderEntries(section.textEntries ?? section.entries),
@@ -898,7 +905,8 @@ export function renderHeadlessPaneText(
 ): string {
   // A long title wraps to a narrow --width like the text under a table; each line stays bold.
   const lines = [...wrapToTerminal(reportTitle(definition, args, result, fallbackTitle)).split("\n").map(cliStyles.bold), ""];
-  const notices = textNotices(result);
+  // A notice wraps to a narrow --width, as the notes and errors under the tables do.
+  const notices = textNotices(result).map((notice) => wrapToTerminal(notice));
   if (notices.length) lines.push(...notices, "");
   const gate = reportGate(definition, result);
   const reason = emptyReportReason(definition, result, args, token, gate);

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

@@ -46,6 +46,7 @@ import { checkOutputPath, resolveOutputPath, writeOutputFile } from "../output-f
 import type { CatalogCommandHit } from "../unknown-command";
 import { CLI_EXIT_CODES } from "../exit-codes";
 import { shotOptionRefusal } from "./shot-options";
+import { listingChangeLine } from "../../tickers/listing-fate";
 import {
   GLOSSARY,
   glossaryRecord,
@@ -312,7 +313,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       let quoted: ReturnType<typeof loadListingQuoteAnswer> | null = null;
       const quoteAnswer = listing ? () => quoted ??= loadListingQuoteAnswer(context.dataProvider, listing) : null;
       const fate = listing && quoteAnswer && isTickerLinkPeer(resolved.instance, registry.panes)
-        ? listingFateLoader(listing, context, quoteAnswer().then((answer) => answer.quote))
+        ? listingFateLoader(listing, context, quoteAnswer().then((answer) => answer.quote), { successor: true })
         : null;
       const moved = { command: "fn", retry: (key: string) => `gloom fn ${resolved.token} ${key}` };
       // A report that fails or comes back empty for an exchange the symbol is not listed on says so.
@@ -356,7 +357,10 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       const data = glossary
         ? { ...report.data, glossary: glossary.map(({ term, short, definition }) => ({ term, ...(short ? { short } : {}), definition })) }
         : report.data;
-      const warnings = [...parsed.listingNotes ?? [], ...await choice ?? [], ...report.data.warnings ?? []];
+      // What became of the company that had the symbol (GOGL), as `quote` says it, leads.
+      const successor = fate ? listingChangeLine(await fate()) : null;
+      // A note the listing and the report both make (a coin's code charted as a fund) is said once.
+      const warnings = [...new Set([...successor ? [successor] : [], ...parsed.listingNotes ?? [], ...await choice ?? [], ...report.data.warnings ?? []])];
       // A report with no data is printed as it is, and fails: exit 1, and `ok: false` in JSON with the reason.
       const failure = reportFailure(report.data, ["fn", resolved.token, parsed.arg.trim()].filter(Boolean).join(" "), {
         failsWithoutData: resolved.headless?.failsWithoutData, tables: report.tables });

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

@@ -1,4 +1,4 @@
-import type { HeadlessPaneDefinition, PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
+import type { HeadlessPaneDefinition, PaneDef, PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
 import { parseTickerListInput } from "../../tickers/list";
 import { normalizeTickerInput } from "../../tickers/search";
 import { resolveFinancialPeriodOption } from "../../plugins/builtin/ticker-detail/financials/model";
@@ -85,12 +85,16 @@ export function cleanTickerInput(value: string): string {
 /**
  * Whether a function's argument names the ticker its pane shows. Its report
  * says first: AUCT's `10Y` and IPO's `pending` are free text its own resolver
- * reads, never a symbol to look up. Without a report, the shortcut says.
+ * reads, never a symbol to look up. Without a report, a rendered pane whose
+ * argument is an id it opens (the story pane's story id) says so, then the
+ * shortcut.
  */
 export function argumentNamesTicker(
   template: Pick<PaneTemplateDef, "shortcut"> | undefined,
   headless: Pick<HeadlessPaneDefinition, "argument"> | undefined,
+  pane?: Pick<PaneDef, "reportArgument">,
 ): boolean {
+  if (!headless && pane?.reportArgument?.identifier) return false;
   const kind = headless?.argument.kind;
   if (kind === "free-text" || kind === "none") return false;
   return kind === "tickers" || kind === "symbol-list" || template?.shortcut?.argKind !== "text";