@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/cli/listing-arg.ts

@@ -15,9 +15,9 @@ import {
   type ListingVenue,
 } from "../tickers/listing-venues";
 import { findUsListingOfCompany, type UsListing } from "../tickers/us-listing";
-import { findListingOfCompanyName, isCompanyNameInput, readTerminalCodeArg, type CompanyNameListing } from "../tickers/company-name-listing";
+import { findListingOfCompanyName, isCompanyNameInput, marksAnotherListing, readTerminalCodeArg, type CompanyNameListing } from "../tickers/company-name-listing";
 import { movedAwayChange, startTickerChangeLookup, type MovedTickerChange } from "../tickers/ticker-changes";
-import { lineMayHaveMoved, loadListingFate, MovedSymbolError, type ListingFate } from "../tickers/listing-fate";
+import { lineMayHaveMoved, listingChangeLine, loadListingFate, MovedSymbolError, SUCCESSOR_CHANGE_WAIT_MS, 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";
@@ -25,6 +25,7 @@ import {
   canonicalExchange,
   exchangeCodeVenues,
   exchangeLabel,
+  exchangeName,
   isKnownExchangeCode,
   isSharedExchangeCode,
   isUsListingExchange,
@@ -36,7 +37,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, exchangeLineCoinListing, isSpotCommodityOrCurrencyPair, MAJOR_COIN_NAMES } from "../utils/crypto-pair";
+import { dashedCoinPair, exchangeLineCoinListing, isSpotCommodityOrCurrencyPair, MAJOR_COIN_NAMES, TOP_COIN_NAMES } from "../utils/crypto-pair";
 import { boardCoinFor, primeBoardCoins } from "./board-coins";
 import { knownGapMessage } from "./known-gaps";
 import { currencyPairSpelling } from "../utils/currency-pair";
@@ -60,7 +61,7 @@ import {
 import { listingAbroadVenue } from "../utils/sec";
 import { savedAbroadForBareSymbol, savedUsListingOf } from "../tickers/search/bare-symbol";
 import { listingSuffixCandidate, listingSuffixVenue, tickerHasListingSuffix } from "../sources/listing-symbols";
-import { notTheCoinNote } from "./commands/crypto-hints";
+import { coinElsewhereNote, notTheCoinNote } from "./commands/crypto-hints";
 
 /** The `--exchange` option of every command that takes a ticker. */
 export const EXCHANGE_OPTION = {
@@ -414,9 +415,15 @@ export function listingChoiceNote(
     .filter((exchange) => exchange !== chosen.exchange);
   if (others.length === 0) return null;
   const more = others.length - MAX_OTHER_LISTINGS;
-  const named = `${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloom search ${symbol}` : ""}`;
+  const named = `${others.slice(0, MAX_OTHER_LISTINGS).map(venueInProse).join(", ")}${more > 0 ? ` and ${more} more: gloom search ${symbol}` : ""}`;
   const which = others.length === 1 ? "a different company" : "different companies";
-  return `${symbol} = ${name ? `${shortCompanyName(name)}, ` : ""}${chosen.exchange} (${which} on ${named})`;
+  return `${symbol} = ${name ? `${shortCompanyName(name)}, ` : ""}${exchangeName(chosen.exchange)} (${which} on ${named})`;
+}
+
+/** A venue as a sentence names it, in full: "the Warsaw Stock Exchange", "Xetra", "NASDAQ" (a name that is its code). */
+function venueInProse(code: string): string {
+  const name = exchangeName(code);
+  return /\b(?:Exchange|Bourse|Market)$/.test(name) ? `the ${name}` : name;
 }
 
 // Quotes of these never name a company's listing, so they are never a choice between companies.
@@ -454,6 +461,19 @@ export function coinListingNotes(
   return note ? [note] : [];
 }
 
+/**
+ * `coinListingNotes` for each listing of a list (CORR RIOT,BTC), asked only
+ * of a bare top coin code, whose quote alone says whether it is the coin.
+ */
+export async function listCoinNotes(
+  listings: ReadonlyArray<Pick<CliListing, "symbol" | "exchange" | "request">>,
+  deps: Pick<ListingDeps, "dataProvider">,
+): Promise<string[]> {
+  const bare = listings.filter((listing) => !listing.exchange && TOP_COIN_NAMES.has(listing.symbol));
+  const quotes = await Promise.all(bare.map((listing) => loadListingQuote(deps.dataProvider, listing)));
+  return bare.flatMap((listing, index) => coinListingNotes(listing, quotes[index]));
+}
+
 /**
  * `listingChoiceNote` for a listing a command resolved, from the quote it was
  * read on: only a bare symbol went where the data service chose. A named
@@ -636,8 +656,12 @@ function describeOtherListings(
   // Every other listing was asked and had nothing: they are named as such, with nothing to try.
   const heading = choose ? "Listings" : lines.length === 0 ? `No ${request.noun} on its other listings either` : "Other listings";
   const named = lines.length === 0 ? without : offered;
-  const details = lines.length === 0 ? `${heading}: ${without.map((venue) => venueKey(listing.symbol, venue)).join(", ")}.`
+  const listed = lines.length === 0 ? `${heading}: ${without.map((venue) => venueKey(listing.symbol, venue)).join(", ")}.`
     : lines.length === 1 ? `${heading}: ${lines[0]}` : [`${heading}:`, ...lines.map((line) => `  ${line}`)].join("\n");
+  // A top coin's code (HYPE, SOL) none of the listings is: the coin may be what was meant.
+  const coin = coinElsewhereNote(listing.symbol, [...resolved ? [resolved] : [], ...others]
+    .map((venue) => ({ key: venueKey(listing.symbol, venue), name: venue.name })));
+  const details = coin ? `${listed}\n${coin}` : listed;
   return {
     // The symbol went to no venue, so none of them is said to lack the data.
     message: choose
@@ -786,6 +810,11 @@ export interface ReadListing {
   name: string | null;
   /** A bare coin ticker read as a listing that is not the coin (`coinListingNotes`); null otherwise. */
   coinNote: string | null;
+  /**
+   * What became of the company that had the symbol, as `quote` says it ("GOGL was Golden Ocean Group until
+   * 2025, now Cmb.Tech: CMBT"), when asked for (`successor`); null otherwise.
+   */
+  successorNote?: string | null;
 }
 
 /**
@@ -801,13 +830,19 @@ export async function readBareListing(
   symbol: string,
   deps: ListingDeps,
   request: ListingDataRequest,
-  { refresh = false }: { refresh?: boolean } = {},
+  /** `successor`: also say what became of the company that had the symbol, looked up beside its quote. */
+  { refresh = false, successor = false }: { refresh?: boolean; successor?: boolean } = {},
 ): Promise<ReadListing | null> {
   const listing = await resolveCliListing(symbol, null, deps);
   if (listing.exchange) return null;
+  const changes = successor ? startTickerChangeLookup(deps.dataProvider, listing.symbol, listing.exchange) : null;
   const answer = await loadListingQuoteAnswer(deps.dataProvider, listing);
   if (answer.quote) {
-    return { symbol: listing.symbol, exchange: listing.request.exchange, name: answer.quote.name?.trim() || null, coinNote: coinListingNotes(listing, answer.quote)[0] ?? null };
+    const successorNote = changes
+      ? listingChangeLine(await loadListingFate(listing, deps.dataProvider, { quote: answer.quote, changes, graceMs: SUCCESSOR_CHANGE_WAIT_MS }))
+      : null;
+    return { symbol: listing.symbol, exchange: listing.request.exchange, name: answer.quote.name?.trim() || null, coinNote: coinListingNotes(listing, answer.quote)[0] ?? null,
+      ...successorNote ? { successorNote } : {} };
   }
   if (!isNoProviderError(answer.error)) return null;
   const other = await quoteBareListing(listing, deps, request, { refresh });
@@ -861,10 +896,12 @@ export function listingFateLoader(
   listing: Pick<CliListing, "symbol" | "exchange" | "request">,
   deps: Pick<ListingDeps, "dataProvider">,
   quote: Promise<Quote | null>,
+  /** `successor`: the command says what became of the company too (GOGL's merger), so the lookup is waited for. */
+  { successor = false }: { successor?: boolean } = {},
 ): () => Promise<ListingFate> {
   const changes = startTickerChangeLookup(deps.dataProvider, listing.symbol, listing.exchange);
   let fate: Promise<ListingFate> | null = null;
-  return () => fate ??= loadListingFate(listing, deps.dataProvider, { quote, changes });
+  return () => fate ??= loadListingFate(listing, deps.dataProvider, { quote, changes, ...successor ? { graceMs: SUCCESSOR_CHANGE_WAIT_MS } : {} });
 }
 
 /**
@@ -1338,6 +1375,22 @@ export async function oneWordCompanyName(typed: string, deps: Pick<ListingDeps,
   return found ? companyListingArg(typed, found) : null;
 }
 
+/**
+ * A word the service marks as a company's name (`searchAliases`), read as
+ * that company's listing as `oneWordCompanyName` reads a word, for a bare
+ * symbol no source quotes, before it is read on the symbol's listings abroad:
+ * "siemens" is SIE on XETRA (Siemens AG), not SIEMENS on NSE (Siemens Ltd.).
+ * Null when the service marks no listing with the word, or marks the word's
+ * own symbol, and when search names no company or is too busy to say.
+ */
+export async function serviceNamedCompany(typed: string, deps: Pick<ListingDeps, "dataProvider">): Promise<ListingArg | null> {
+  // Most symbols are no company's name: one search says so before any listing is weighed or quoted.
+  if (!ONE_WORD_NAME.test(typed.trim()) || !await marksAnotherListing(deps.dataProvider, typed)) return null;
+  const found = await findOneWordCompany(typed, deps);
+  if (!found?.named || found.symbol.toUpperCase() === typed.trim().toUpperCase()) return null;
+  return companyListingArg(typed, found);
+}
+
 /** The company `oneWordCompanyName` reads a word as, before it is read as a listing. */
 async function findOneWordCompany(typed: string, deps: Pick<ListingDeps, "dataProvider">): Promise<CompanyNameListing | null> {
   const word = typed.trim();

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: [],
   },