gloomberb 0.18.3 → 0.18.4

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

@@ -42,10 +42,11 @@ import type { ResolvedPaneFunction } from "./resolver";
 import { isRecord } from "../../utils/guards";
 import { splitSymbolWords } from "../symbol-args";
 import { formatUtcTime, localTimeSuffix } from "../../utils/utc-time";
-import { deriveHeadlessFreshness, formatFreshnessLine, staleRowsText, type ReportFreshness } from "./freshness";
+import { deriveHeadlessFreshness, formatFreshnessLine, staleRowsText, withSavedCopy, type ReportFreshness } from "./freshness";
 import { accessGateStatus, errorsAccessGate, isProLock, reportGateText } from "./access-gate";
 import { noArgumentMessage } from "./capabilities";
 import { lockedHeadlessReport } from "./lock-note";
+import { resumeStateKey } from "../../plugins/registry/plugin-state";
 
 interface SerializableHeadlessColumn {
   key: string;
@@ -69,7 +70,7 @@ function argumentName(definition: HeadlessPaneDefinition): string {
 }
 
 function requiredArgumentError(definition: HeadlessPaneDefinition, token: string): Error {
-  return new Error(`Usage: gloomberb fn ${token} <${argumentName(definition)}>`);
+  return new Error(`Usage: gloom fn ${token} <${argumentName(definition)}>`);
 }
 
 function normalizeSymbol(value: string): string {
@@ -187,7 +188,7 @@ async function loadHeadlessPaneModel(
   return result;
 }
 
-type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh" | "resolveBroker"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities">> & {
+type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh" | "resolveBroker"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities" | "findCatalogSeries">> & {
   dataProvider: HeadlessPaneContext["marketData"];
 };
 
@@ -205,6 +206,8 @@ export function createHeadlessPaneContext(
     ...(context.refresh ? { refresh: true } : {}),
     settings: resolved.instance.settings,
     capabilities: getSharedRegistry() ?? context.seriesCapabilities,
+    catalogSeriesName: (expression) => (getSharedRegistry()?.series.findByExpression(expression)?.definition
+      ?? context.findCatalogSeries?.(expression))?.name,
     resolveBroker: context.resolveBroker,
     async resolvePortfolio(id) {
       const portfolio = findNamedCollection(context.config.portfolios, id);
@@ -223,10 +226,12 @@ export function createHeadlessPaneContext(
         ?? (key !== parsed.symbol ? await context.store.loadTicker(parsed.symbol) : null);
       return { symbol: parsed.symbol, exchange: parsed.exchange ?? ticker?.metadata.exchange };
     },
+    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) => `gloomberb ${command} ${argumentWith(key)}`,
+        command, noun: "a quote", retry: (key) => `gloom ${command} ${argumentWith(key)}`,
       }, { refresh: !!context.refresh });
       if (!read) return null;
       return { symbol: read.symbol, ...read.exchange ? { exchange: read.exchange } : {}, ...read.name ? { name: read.name } : {} };
@@ -363,7 +368,8 @@ export function serializeHeadlessPaneResult(
     }
     case "series": {
       const series = result as HeadlessSeriesResult;
-      return { ...common, series: series.series, ...(series.stats ? { stats: series.stats } : {}) };
+      // `textDecimals` only shapes the text report; JSON keeps every digit and does not carry it.
+      return { ...common, series: series.series.map(({ textDecimals: _text, ...kept }) => kept), ...(series.stats ? { stats: series.stats } : {}) };
     }
     case "snapshot": {
       const snapshot = result as HeadlessSnapshotResult;
@@ -484,7 +490,8 @@ function seriesPointExportDate(series: HeadlessSeries, date: SeriesPointDate, da
 }
 
 /**
- * A latest value as the series report prints it: percentages, multiples and
+ * A latest value as the series report prints it: percentages and percentage
+ * points, multiples and
  * ratios (P/E, EV/EBITDA, one series over another, VIX 3M / VIX) to two
  * decimals, which a ratio under 0.1 trades for three significant digits so it
  * is not flattened to 0.03, and a 0 to 100 score to a tenth of a point. The
@@ -494,8 +501,9 @@ function seriesPointExportDate(series: HeadlessSeries, date: SeriesPointDate, da
 function seriesValue(series: HeadlessSeries, value: number | null): string {
   if (value == null) return "-";
   if (!Number.isFinite(value)) return displayNumber(value);
+  if (series.textDecimals != null) return value.toFixed(series.textDecimals);
   const unit = series.unit?.trim().toLowerCase();
-  if (unit === "%") return value.toFixed(2);
+  if (unit === "%" || unit === "pp") return value.toFixed(2);
   if (unit === "x" || unit === "ratio") return value !== 0 && Math.abs(value) < 0.1 ? value.toPrecision(3) : value.toFixed(2);
   if (unit === "score") return value.toFixed(1);
   return displayNumber(value);
@@ -525,6 +533,7 @@ function renderRows(
       minWidth: column.minWidth,
       stackPriority: column.stackPriority,
       stackRows: column.stackRows,
+      minTableWidth: column.minTableWidth,
     })),
     rows.map((row) => columns.map((column) => cell(row, column))),
     {
@@ -612,7 +621,7 @@ const SERIES_FIELDS = ["value", "open", "high", "low", "close", "volume"] as con
  * column names beside the bare `Value`, `Open`... headers.
  */
 function seriesTable(series: HeadlessSeries): CliReportTable {
-  const fields = SERIES_FIELDS.filter((field) => series.points.some((point) => point[field] != null));
+  const fields = SERIES_FIELDS.filter((field) => !(field === "value" && series.valueIsClose) && series.points.some((point) => point[field] != null));
   const days = observesDays(series);
   const dates = series.points.map((point) => seriesPointExportDate(series, point.date, days));
   const header = (field: (typeof SERIES_FIELDS)[number]) => `${field[0]!.toUpperCase()}${field.slice(1)}`;
@@ -754,7 +763,7 @@ export function headlessReportTables(
       const rowsResult = result as HeadlessRowsResult;
       const columns = displayedColumns(columnsFor(rowsResult.rows, rowsResult.columns, definition.columns));
       const rowIdentities = rowIdentitiesOf(rowsResult.rows, rowsResult);
-      const own = exportRowsTable(title, columns, rowsResult.rows, { status: true });
+      const own = exportRowsTable(title, columns, rowsResult.rows, { status: true, ...(rowsResult.rowUnitKey ? { rowUnitKey: rowsResult.rowUnitKey } : {}) });
       const interval = rowsResult.interval?.trim();
       tables = [{ ...own, ...(rowIdentities ? { rowIdentities } : {}), ...(interval ? { identity: { interval } } : {}) }, ...(rowsResult.exportTables ?? []).map((extra) => {
         const identity = {
@@ -775,7 +784,10 @@ export function headlessReportTables(
         };
         if (!("rows" in section && section.rows)) {
           const entries = exportEntriesTable(section.title, section.entries);
-          return Object.keys(named).length > 0 ? { ...entries, identity: named } : entries;
+          // A figure that declares its unit names it in the unit column of its own line too.
+          const rowIdentities = section.entries.some((entry) => entry.unit?.trim())
+            ? section.entries.map((entry) => entry.unit?.trim() ? { currencyOrUnit: entry.unit.trim() } : undefined) : undefined;
+          return { ...entries, ...(Object.keys(named).length > 0 ? { identity: named } : {}), ...(rowIdentities ? { rowIdentities } : {}) };
         }
         const table = exportRowsTable(section.title, displayedColumns(columnsFor(section.rows, section.columns, definition.columns)), section.rows, { status: true });
         const identity = {
@@ -967,7 +979,8 @@ export async function buildHeadlessFunctionReport(
   }
   const { complete, unavailableSymbols, rowCount, symbols } = reportCoverage(loaded);
   const serialized = serializeHeadlessPaneResult(loaded.definition, loaded.result);
-  const freshness = deriveHeadlessFreshness(loaded.definition, loaded.result);
+  // What the report shows from a saved copy, its refresh having failed, says so.
+  const freshness = withSavedCopy(deriveHeadlessFreshness(loaded.definition, loaded.result), loaded.result);
   return {
     data: {
       kind: loaded.definition.shape,

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

@@ -21,10 +21,12 @@ import {
   parsePaneFunctionArgs,
   type ParsedPaneFunctionArgs,
 } from "./options";
-import { applyListingArgument, findPaneFunction, resolvePaneFunction, UnknownPaneFunctionError, type ResolvedPaneFunction } from "./resolver";
+import { applyListingArgument, findPaneFunction, parsePaneFunctionArgsFor, resolvePaneFunction, UnknownPaneFunctionError, type ResolvedPaneFunction } from "./resolver";
 import { buildFunctionReport } from "./report";
 import { expandResolvedArgument } from "./headless";
-import { defaultScreenshotPath, renderDesktopShot, shotSizeWarnings, shotStatusIssues } from "./screenshot";
+import { defaultScreenshotPath, shotSizeWarnings } from "./screenshot-payload";
+import { renderDesktopShot } from "./screenshot-render";
+import { shotStatusIssues } from "./screenshot-assessment";
 import {
   buildPaneCatalogEntries,
 } from "./catalog";
@@ -67,7 +69,7 @@ async function withPaneRuntime<T>(
     const context: MarketContext = ctx.cliOptions.refresh ? { ...market, refresh: true } : market;
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {
-      let parsed = await applyListingArgument(registry, context, parsePaneFunctionArgs(args, ctx.cliOptions), settings.command);
+      let parsed = await applyListingArgument(registry, context, parsePaneFunctionArgsFor(registry, args, ctx.cliOptions), settings.command);
       let resolved = await resolvePaneFunction(registry, context, parsed, settings);
       // A function that widens its argument (RV's --peers) runs, reports and captures the widened one.
       const expansion = await withPersistedCloudSession(context, () => expandResolvedArgument(resolved, context, parsed.arg));
@@ -100,8 +102,8 @@ function commandWord(argument: string): string {
 }
 
 /**
- * What to run when a command name is a function's code (`gloomberb OVDV KO`,
- * `gloomberb help OVDV`): `fn` with the reader's own arguments, or the
+ * What to run when a command name is a function's code (`gloom OVDV KO`,
+ * `gloom help OVDV`): `fn` with the reader's own arguments, or the
  * function's argument hint when they gave none. Null when the word is no
  * function code or the catalog cannot be read, and the command stays unknown.
  */
@@ -123,7 +125,7 @@ export async function functionCodeCommand(
     });
     if (!found) return null;
     const code = word.replace(/^\$/, "").toUpperCase();
-    return { code, command: ["gloomberb fn", code, args.length > 0 ? args.map(commandWord).join(" ") : found.argument].filter(Boolean).join(" ") };
+    return { code, command: ["gloom fn", code, args.length > 0 ? args.map(commandWord).join(" ") : found.argument].filter(Boolean).join(" ") };
   } catch (error) {
     logFailure("cli.pane-functions-index", "Resolve function code command failed")(error);
     return null;
@@ -131,7 +133,7 @@ export async function functionCodeCommand(
 }
 
 /**
- * The one function code a command name is a slip from (`gloomberb RCDF PLTR`
+ * The one function code a command name is a slip from (`gloom RCDF PLTR`
  * for RDCF), with the command that runs it on the reader's arguments, read
  * as a command word is (nearFunctionCodes), so a ticker is not taken for one.
  * Null when no code, or more than one, is that close, or the catalog cannot
@@ -155,7 +157,7 @@ export async function nearFunctionCodeCommand(
     });
     if (near.length !== 1) return null;
     const { code, label } = near[0]!;
-    return { code, label, command: ["gloomberb fn", code, ...args.map(commandWord)].join(" ") };
+    return { code, label, command: ["gloom fn", code, ...args.map(commandWord)].join(" ") };
   } catch (error) {
     logFailure("cli.pane-functions-index", "Find nearby function code command failed")(error);
     return null;
@@ -272,7 +274,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       )) {
         throw new Error(
           `${resolved.token} is not a verified bot-safe report capability. `
-          + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
+          + `Use "gloom catalog ${resolved.token}" to inspect readiness.`,
         );
       }
       const tabular = ctx.cliOptions.format === "csv" || ctx.cliOptions.format === "ndjson";
@@ -294,7 +296,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       const fate = listing && quoteAnswer && isTickerLinkPeer(resolved.instance, registry.panes)
         ? listingFateLoader(listing, context, quoteAnswer().then((answer) => answer.quote))
         : null;
-      const moved = { command: "fn", retry: (key: string) => `gloomberb fn ${resolved.token} ${key}` };
+      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.
       const report = await refuseMovedListing(fate, moved, () => withPersistedCloudSession(
         context,
@@ -307,7 +309,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
         ),
       ));
       // A company's name typed where its ticker goes (`fn RDCF Palantir`) found nothing: the answer is `quote`'s,
-      // "Not a ticker: PALANTIR. Try `gloomberb search Palantir`.", not an empty report.
+      // "Not a ticker: PALANTIR. Try `gloom search Palantir`.", not an empty report.
       if (quoteAnswer && (report.data.empty || report.data.unavailableSymbols.length > 0)) {
         const { quote, error } = await quoteAnswer();
         const message = error instanceof Error ? error.message : null;
@@ -367,8 +369,8 @@ export function emptySeriesExport(
     const ids = [...new Set(fred)];
     return {
       message: `${asked} has no data to export: ${ids.join(" and ")} ${ids.length === 1 ? "is a FRED series" : "are FRED series"}, not ${ids.length === 1 ? "a ticker" : "tickers"}.`,
-      details: `Chart it with the fred: prefix: gloomberb fn G ${ids.map((id) => `fred:${id}`).join(",")} ${formatFlag}`
-        + `${ids.length === 1 ? ` (or gloomberb fred ${ids[0]} ${formatFlag})` : ""}.`,
+      details: `Chart it with the fred: prefix: gloom fn G ${ids.map((id) => `fred:${id}`).join(",")} ${formatFlag}`
+        + `${ids.length === 1 ? ` (or gloom fred ${ids[0]} ${formatFlag})` : ""}.`,
     };
   }
   const missing = data.unavailableSymbols.length > 0 ? ` for ${data.unavailableSymbols.join(", ")}` : "";
@@ -377,7 +379,7 @@ export function emptySeriesExport(
     message: `${asked} has no data to export${missing}.`,
     details: [
       ...reasons,
-      `Check the symbol with gloomberb search, or run gloomberb ${asked} without ${formatFlag} to see the report.`,
+      `Check the symbol with gloom search, or run gloom ${asked} without ${formatFlag} to see the report.`,
     ].join("\n"),
   };
 }
@@ -405,7 +407,7 @@ async function capturePaneScreenshot(args: string[], ctx: CliCommandContext, onS
       )) {
         throw new Error(
           `${resolved.token} is not a verified bot-safe screenshot capability. `
-          + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
+          + `Use "gloom catalog ${resolved.token}" to inspect readiness.`,
         );
       }
       // An option the pane cannot draw fails here, before a capture of its default is saved as if it were the view asked for.
@@ -469,7 +471,7 @@ function runGlossary(term: string, ctx: CliCommandContext): void {
   const { exact, partial } = lookupGlossary(term);
   const entries = [...exact, ...partial];
   if (entries.length === 0) {
-    ctx.fail(`No glossary entry for "${term}".`, knownGapMessage(term) ?? "gloomberb catalog glossary lists every term.");
+    ctx.fail(`No glossary entry for "${term}".`, knownGapMessage(term) ?? "gloom catalog glossary lists every term.");
   }
   ctx.printResult({ data: entries.map(glossaryRecord) }, { text: () => renderGlossaryEntries(entries).join("\n") });
 }

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

@@ -106,7 +106,17 @@ export function parseArgumentsOption(value: string): Record<string, string> {
   return pairs;
 }
 
-export function parsePaneFunctionArgs(args: string[], globalOptions: { limit?: number; tail?: number } = {}): ParsedPaneFunctionArgs {
+/** How many words one value of an option takes, by its key as parsed (`fxShift`); one when it is not a pair. */
+export type OptionValueWords = (key: string) => number;
+
+/** Words in the last value of a list (`TRY -20, EUR 5` ends with two); a decimal comma (`TRY -2,5`) separates nothing. */
+const lastValueWords = (value: string) => value.split(/(?<!\d),|,(?!\d)/).at(-1)!.trim().split(/\s+/).filter(Boolean).length;
+
+export function parsePaneFunctionArgs(
+  args: string[],
+  globalOptions: { limit?: number; tail?: number } = {},
+  valueWords?: OptionValueWords,
+): ParsedPaneFunctionArgs {
   const positionals: string[] = [];
   const options: Record<string, string | true> = {};
   let outputPath: string | null = null;
@@ -153,8 +163,18 @@ export function parsePaneFunctionArgs(args: string[], globalOptions: { limit?: n
     }
     const next = args[index + 1];
     const nextValue = inlineValue === undefined && next && !next.startsWith("--") ? args[++index] : true;
-    const value: string | true = inlineValue ?? nextValue ?? true;
+    let value: string | true = inlineValue ?? nextValue ?? true;
     const normalizedKey = normalizeOptionKey(key);
+    // A value that is a pair (`--fx-shift TRY -20`) takes the words after it, and a list of them the words after a comma.
+    const words = value === true ? 1 : valueWords?.(normalizedKey) ?? 1;
+    if (words > 1 && value !== true) {
+      while (index + 1 < args.length && !args[index + 1]!.startsWith("--")
+        && (lastValueWords(value) < words || value.trimEnd().endsWith(","))) {
+        value = `${value} ${args[++index]!}`;
+      }
+      const earlier = options[normalizedKey];
+      if (typeof earlier === "string") value = `${earlier}, ${value}`;
+    }
     if (normalizedKey === "requireBotSafe" || normalizedKey === "botSafe") {
       requireBotSafe = value === true || String(value).toLowerCase() === "true";
     } else if (normalizedKey === "output" || normalizedKey === "out" || normalizedKey === "o") {

package/src/cli/pane-functions/report-notices.ts

@@ -66,24 +66,29 @@ function publishedSources(value: unknown): NonNullable<HeadlessPaneFreshness["so
   return sources.length ? sources : null;
 }
 
+function isStringList(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
 /**
  * How current a rendered pane says its data is, from the `report-freshness`
  * node it publishes: `{ asOf?, status?, delayMinutes?, source?, sources?,
- * maxAgeMinutes?, oldestAge?, note?, basis?, asOfLabel? }`; `basis` names what a pane
+ * maxAgeMinutes?, oldestAge?, ageOnly?, note?, noteVariants?, basis?, asOfLabel?, datesEachVenue? }`; `basis` names what a pane
  * that is not a feed lists, when one pane lists different things (NI's
  * stories, and its LTR code's letters). A capture keeps no footer status and
  * few cells carry a time, so a pane that knows its feed (OMON's chain) dates
  * the report here, as the plain command over the same data does, and a pane
- * over several venues (PERP) dates each one as its report does. A pane whose
+ * over several venues (PERP) dates each one as its report does, as does one
+ * whose quotes trade on several markets (RV's `datesEachVenue`). A pane whose
  * figures come from several dated quotes (FXC's pair rates) publishes them
  * instead, see `renderedReportObservations`.
  */
 export function renderedReportFreshness(
   semanticUi: readonly RemoteUiNodeSnapshot[],
-): Pick<HeadlessPaneFreshness, "asOf" | "status" | "delayMinutes" | "source" | "sources" | "maxAgeMinutes" | "oldestAge" | "note" | "basis" | "asOfLabel"> {
+): Pick<HeadlessPaneFreshness, "asOf" | "status" | "delayMinutes" | "source" | "sources" | "maxAgeMinutes" | "oldestAge" | "ageOnly" | "note" | "noteVariants" | "basis" | "asOfLabel" | "datesEachVenue"> {
   const metadata = semanticUi.find((node) => node.role === "report-freshness")?.metadata;
   if (!metadata) return {};
-  const { asOf, status, delayMinutes, source, maxAgeMinutes, oldestAge, note, basis, asOfLabel } = metadata as Record<string, unknown>;
+  const { asOf, status, delayMinutes, source, maxAgeMinutes, oldestAge, ageOnly, note, noteVariants, basis, asOfLabel, datesEachVenue } = metadata as Record<string, unknown>;
   const sources = publishedSources(metadata.sources);
   return {
     ...(typeof asOf === "string" || isFiniteNumber(asOf) ? { asOf } : {}),
@@ -93,9 +98,12 @@ export function renderedReportFreshness(
     ...(sources ? { sources } : {}),
     ...(isFiniteNumber(maxAgeMinutes) && maxAgeMinutes > 0 ? { maxAgeMinutes } : {}),
     ...(oldestAge === true ? { oldestAge } : {}),
+    ...(ageOnly === true ? { ageOnly } : {}),
     ...(typeof note === "string" && note.trim() ? { note } : {}),
+    ...(isStringList(noteVariants) && noteVariants.length > 0 ? { noteVariants } : {}),
     ...(typeof basis === "string" && basis.trim() ? { basis } : {}),
     ...(typeof asOfLabel === "string" && asOfLabel.trim() ? { asOfLabel } : {}),
+    ...(datesEachVenue === true ? { datesEachVenue } : {}),
   };
 }
 

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

@@ -51,10 +51,10 @@ export function resolvePaneFunctionReportSource(
   return resolved.capability.reportReadiness === "live-dom" ? "dom" : null;
 }
 
-/** `gloomberb shot CAT santander`, the argument quoted when it has spaces. */
+/** `gloom shot CAT santander`, the argument quoted when it has spaces. */
 function shotCommand(token: string, rawArg: string): string {
   const arg = rawArg.trim();
-  return ["gloomberb shot", token, arg && /\s/.test(arg) ? JSON.stringify(arg) : arg].filter(Boolean).join(" ");
+  return ["gloom shot", token, arg && /\s/.test(arg) ? JSON.stringify(arg) : arg].filter(Boolean).join(" ");
 }
 
 export async function buildFunctionReport(
@@ -67,7 +67,7 @@ export async function buildFunctionReport(
   if (!source) {
     // HELP is what a newcomer tries first: send them to the command guide and the function list.
     if (resolved.pane.id === "help") {
-      throw new Error("HELP is an in-app pane, so it has no report. For the commands run `gloomberb help`; for the functions run `gloomberb catalog`.");
+      throw new Error("HELP is an in-app pane, so it has no report. For the commands run `gloom help`; for the functions run `gloom catalog`.");
     }
     // A pane `shot` can draw is still one command away.
     const screenshot = resolved.capability.screenshotReadiness;
@@ -88,10 +88,10 @@ export async function buildFunctionReport(
   }
   if (source === "dom") {
     const view = domReportView(report.data);
-    report.text = appendDomReportFooter(report.text, elapsedMs, view, report.data.freshness);
+    report.text = appendDomReportFooter(report.text, view, report.data.freshness);
     report.tables = {
       ...report.tables,
-      footer: [...report.tables.footer, `note: ${domReportNote(elapsedMs, view)}`],
+      footer: [...report.tables.footer, `note: ${domReportNote(view)}`],
     };
   }
   return report;

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

@@ -36,16 +36,20 @@ import {
   cleanTickerInput,
   normalizeLookupToken,
   optionSettings,
+  parsePaneFunctionArgs,
   type ParsedPaneFunctionArgs,
 } from "./options";
 import { argumentSymbols, validateSymbolCount } from "./headless";
 import {
   capabilityHasOption,
   capabilityPaneSettings,
+  findCapabilityOption,
   getHeadlessPaneDefinition,
   getPaneFunctionCapability,
   noArgumentMessage,
   normalizeCapabilityOptions,
+  paneFunctionArgument,
+  takesNoArgument,
   type NormalizedPaneFunctionOptions,
   type PaneFunctionCapability,
 } from "./capabilities";
@@ -124,6 +128,24 @@ export function findPaneFunction(registry: PaneFunctionCatalog, target: string):
   return { template, pane: template ? registry.panes.get(template.paneId) : entry as PaneDef };
 }
 
+/**
+ * `fn` and `shot` arguments read with the function's own options: one whose
+ * value is a pair (MARS's `--fx-shift TRY -20`) takes the words after its
+ * flag, which a function that has none would read as its argument.
+ */
+export function parsePaneFunctionArgsFor(
+  registry: PaneFunctionCatalog,
+  args: string[],
+  globalOptions: { limit?: number; tail?: number } = {},
+): ParsedPaneFunctionArgs {
+  const parsed = parsePaneFunctionArgs(args, globalOptions);
+  const found = parsed.target ? findPaneFunction(registry, parsed.target) : null;
+  if (!found?.pane) return parsed;
+  const capability = getPaneFunctionCapability(found.template, found.pane);
+  if (!capability.options.some((option) => (option.valueWords ?? 1) > 1)) return parsed;
+  return parsePaneFunctionArgs(args, globalOptions, (key) => findCapabilityOption(capability, key)?.valueWords ?? 1);
+}
+
 /**
  * `fn ANR SAN --exchange EPA` is `fn ANR SAN:EPA`: a function that takes
  * tickers gets each listing as `quote` reads it (`resolveCliListing`), so
@@ -153,14 +175,24 @@ export async function applyListingArgument(
   }
   const exchange = typeof args.options.exchange === "string" ? args.options.exchange : undefined;
   const { exchange: _exchange, ...options } = args.options;
-  // A list entry with spaces is a company's name search finds, or the symbols it holds.
-  const typed = takesOneTicker ? [args.arg] : await readNameEntries(splitSymbolArgs([args.arg]), context.dataProvider);
+  // A list entry with spaces, or an argument of words, is a company's name search finds, or the symbols it holds.
+  const typed = takesOneTicker ? [args.arg] : await readNameEntries(splitSymbolArgs([args.arg], { phrases: true }), context.dataProvider);
   if (typed.length === 0) return args;
   // RY.TO is the listing its quote names, RY:TSX, as `quote` reads it: a function's data is read by venue.
   let listings = await Promise.all(typed.map((raw) => resolveCliListing(raw, exchange, context, { ownExchangeWins: typed.length > 1, venueSuffix: true })));
   // A separator stuck to the end of a pasted list (`UPST;`) is not part of a symbol; it is named.
   const notes: string[] = takesOneTicker ? [] : stripStrayEdges(args.arg).notes;
   const token = found.template?.shortcut?.prefix ?? args.target.toUpperCase();
+  // Words search finds no company for, and that are not symbols either, name nothing a function can read: tickers do.
+  const unnamed = takesList ? listings.filter((listing) => /\s/.test(listing.symbol)) : [];
+  if (unnamed.length > 0) {
+    const names = unnamed.map((listing) => typed[listings.indexOf(listing)]!.trim());
+    const answer = `No company found for ${names.map((name) => `"${name}"`).join(", ")}; type tickers`;
+    const details = `Such as gloom ${command} ${token} GME,AMC. Find a company's ticker with gloom search "${names[0]!.replace(/"/g, "")}".`;
+    listings = listings.filter((listing) => !unnamed.includes(listing));
+    if (listings.length === 0) throw new ListingArgError(`${answer}.`, details);
+    notes.push(`${answer}, such as GME,AMC.`);
+  }
   // A function with company data answers an index or an ETF with what it is and where its data is, before
   // any request: its source would only say "Unknown ticker" or come back empty. A list leaves it out.
   const covered = found.pane.instruments;
@@ -185,7 +217,7 @@ export async function applyListingArgument(
   const abroad = usOnly ? listings.filter((listing) => listingAbroadVenue(listing.key) != null) : [];
   if (usOnly && abroad.length > 0) {
     const answers = await Promise.all(abroad.map(async (listing) => {
-      const answer = await usListingsOnlyMessage(usOnly, listing, context, (key) => `gloomberb ${command} ${token} ${key}`);
+      const answer = await usListingsOnlyMessage(usOnly, listing, context, (key) => `gloom ${command} ${token} ${key}`);
       const hint = headless?.usListingsOnlyHint?.(listing.key);
       return hint ? { ...answer, details: `${answer.details}\n${hint}` } : answer;
     }));
@@ -264,11 +296,11 @@ async function unknownPaneFunctionError(
   const runs = suggested.length > 0 ? suggested : near.length === 1 ? near : [];
   return new UnknownPaneFunctionError(name, [
     // A function a word asks for, typed with no argument, shows the one it takes (`<ticker>`).
-    ...runs.map(({ code }, index) => [index === 0 ? "Run:" : "    ", "gloomberb", command, code,
+    ...runs.map(({ code }, index) => [index === 0 ? "Run:" : "    ", "gloom", command, code,
       argument.trim() || (suggested.length > 0 ? findFunctionCode(registry, code)?.argument : "")].filter(Boolean).join(" ")),
     ...closest.length > 0
-      ? ["Closest matches:", ...closest.map((entry) => `  ${entry.token.padEnd(tokenWidth)}  ${entry.label}`), `Search the catalog: gloomberb catalog ${word}`]
-      : near.length > 0 ? [] : [`No function code is close to ${word}. List every function: gloomberb catalog`],
+      ? ["Closest matches:", ...closest.map((entry) => `  ${entry.token.padEnd(tokenWidth)}  ${entry.label}`), `Search the catalog: gloom catalog ${word}`]
+      : near.length > 0 ? [] : [`No function code is close to ${word}. List every function: gloom catalog`],
   ].join("\n"), near.length > 0 ? nearCodesText(near) : null);
 }
 
@@ -280,7 +312,7 @@ export async function resolvePaneFunction(
 ): Promise<ResolvedPaneFunction> {
   let args = parsedArgs;
   if (!args.target) {
-    throw new Error("Usage: gloomberb fn <function-or-pane> [argument] [--key value]");
+    throw new Error("Usage: gloom fn <function-or-pane> [argument] [--key value]");
   }
 
   const found = findPaneFunction(registry, args.target);
@@ -302,16 +334,21 @@ export async function resolvePaneFunction(
   // What the user types for the function, which every error about it names.
   const token = template?.shortcut?.prefix ?? template?.id ?? pane.id;
   // A word after a function that takes none is most often one of its option values (`fn JODI gas`).
-  if (headless?.argument.kind === "none" && args.arg?.trim()) {
+  // Every function the catalog lists with no argument refuses one, a rendered view (HALT) as a report (CBR).
+  // The catalog lists templates and the panes no template opens (HELP); a pane opened by its id stands for its templates.
+  const listed = template !== undefined || ![...registry.paneTemplates.values()].some((entry) => entry.paneId === pane.id);
+  const refusesArgument = listed ? takesNoArgument(paneFunctionArgument(template, pane)) : headless?.argument.kind === "none";
+  if (refusesArgument && args.arg?.trim()) {
     throw new Error(noArgumentMessage(capability.options, token, args.arg, resolutionSettings.command ?? "fn"));
   }
   const normalizedOptions = normalizeCapabilityOptions(capability, args.options, {
-    strict: args.requireBotSafe || (!!headless && resolutionSettings.strictHeadlessOptions === true),
+    strict: args.requireBotSafe || capability.strictOptions === true || (!!headless && resolutionSettings.strictHeadlessOptions === true),
     code: token,
     argument: args.arg || null,
   });
   const settings = {
-    ...optionSettings(args.options),
+    // A view that takes only its declared options gets only their settings.
+    ...capability.strictOptions ? {} : optionSettings(args.options),
     ...capabilityPaneSettings(capability, normalizedOptions),
   };
   if (args.requireBotSafe) {