gloomberb 0.18.0 → 0.18.2

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

@@ -93,7 +93,7 @@ const POP_OUT = key("p", "op out");
 const STEP = key("←/→", " step");
 /** THEM and MEMB members: open them in RRG, CORR, SIW or RIPL, or save them as a watchlist. */
 const MEMBERS_MENU = key(".", " open members in, save as watchlist");
-const CHART_KEYS = [key("s", "eries"), key("i", "ndicators"), key("t", "imeframe"), key("f", "ormulas")];
+const CHART_KEYS = [key("s", "eries"), key("i", "ndicators"), key("b", "ars"), key("f", "ormulas")];
 
 export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
   // Research companies
@@ -445,8 +445,8 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     summary: "Named executive officers and what they were paid, read from the proxy statement and checked against the filing.",
     usage: ["EXEC NVDA"],
     keys: [key("y", "ear"), key("o", "pen filing")],
-    data: pro(AS_FILED.pro),
-    access: "pro",
+    data: { free: "As filed; each executive's total pay from the latest proxy", pro: "As filed; the pay breakdown and every year" },
+    access: "preview",
     bloomberg: ["MGMT"],
   },
   EK: {
@@ -681,10 +681,10 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
 
   // Watch markets
   MOST: {
-    summary: "Today's top gainers, losers, most active and trending tickers with price, change, volume against average and market cap. On Pro, pre-market and after-hours movers and the gaps at the open.",
+    summary: "Today's top gainers, losers, most active and trending tickers with price, change, volume against average and market cap, and the pre-market and after-hours movers. On Pro, the gaps at the open.",
     usage: ["MOST"],
     keys: [TABS, OPEN],
-    data: { free: DELAYED, pro: "Real-time, pre-market and after-hours" },
+    data: { free: DELAYED, pro: REAL_TIME },
     bloomberg: ["MOST"],
   },
   WEI: {
@@ -971,7 +971,7 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     bloomberg: [],
   },
   PDLR: {
-    summary: "Weekly primary dealer net positions and settlement fails across Treasuries and mortgage-backed securities.",
+    summary: "Weekly primary dealer net positions with history, by sector and Treasury tenor (bills, coupons, TIPS, FRN), and settlement fails.",
     usage: ["PDLR"],
     keys: [TABS],
     data: same("Weekly, as published"),
@@ -1110,7 +1110,7 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     docs: "PORT",
   },
   ALRT: {
-    summary: "Your price alerts with current price, distance to target and trigger state, plus alerts days before earnings, CPI or FOMC and market and filing event alerts.",
+    summary: "Your price alerts with current price, distance to target and trigger state, plus alerts on earnings, CPI and FOMC dates, filings and 13F, news keywords, analyst changes, 52-week highs and lows, unusual volume, short interest, insider and congress trades, catalysts, IV spikes, options flow and perps.",
     usage: ["ALRT"],
     keys: [key("a", "dd alert"), key("e", "dit"), key("d", "elete"), key("m", "re-arm")],
     data: QUOTES,
@@ -1238,6 +1238,30 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     data: null,
     bloomberg: [],
   },
+  BUY: {
+    summary: "Open the shared Trade ticket with a buy quantity and optional limit price. Focus starts on Review; choose an account and review the broker preview before confirming.",
+    usage: ["BUY AAPL 10", "BUY AAPL 10 150.25"],
+    keys: [key("r", "eview"), key("o", "rders")],
+    data: same("Broker account and quote"),
+    bloomberg: [],
+    docs: "BR",
+  },
+  SELL: {
+    summary: "Open the shared Trade ticket with a sell quantity and optional limit price. Focus starts on Review; holdings and broker capabilities are checked before confirmation.",
+    usage: ["SELL AAPL 10", "SELL AAPL 10 350.25"],
+    keys: [key("r", "eview"), key("o", "rders")],
+    data: same("Broker account and quote"),
+    bloomberg: [],
+    docs: "BR",
+  },
+  ORD: {
+    summary: "Open orders and recent activity for a selected broker profile and account. Review a modification or confirm cancellation from an open order; uncertain outcomes require reconciliation before another action.",
+    usage: ["ORD"],
+    keys: [key("m", "odify"), key("c", "ancel")],
+    data: same("Broker account snapshot"),
+    bloomberg: [],
+    docs: "BR",
+  },
 
   // Layouts and settings
   GL: {

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

@@ -168,12 +168,12 @@ async function loadHeadlessPaneModel(
   return result;
 }
 
-type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities">> & {
+type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh" | "resolveBroker"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities">> & {
   dataProvider: HeadlessPaneContext["marketData"];
 };
 
 /** What a headless loader reads the market, the account and the saved collections through. */
-function createHeadlessPaneContext(
+export function createHeadlessPaneContext(
   resolved: ResolvedPaneFunction,
   context: HeadlessMarketContext,
   signal: AbortSignal,
@@ -186,6 +186,7 @@ function createHeadlessPaneContext(
     ...(context.refresh ? { refresh: true } : {}),
     settings: resolved.instance.settings,
     capabilities: getSharedRegistry() ?? context.seriesCapabilities,
+    resolveBroker: context.resolveBroker,
     async resolvePortfolio(id) {
       const portfolio = findNamedCollection(context.config.portfolios, id);
       if (!portfolio) return null;
@@ -498,7 +499,7 @@ function renderRows(
   };
   return renderTable(
     columns.map((column) => ({
-      header: displayedHeader(column),
+      header: column.textHeader ?? displayedHeader(column),
       align: column.align,
       width: column.width,
       shrink: column.shrink,
@@ -939,9 +940,9 @@ export async function buildHeadlessFunctionReport(
     loaded = await loadResolvedHeadlessPaneModel(resolved, context, rawArgument);
   } catch (error) {
     // A Pro pane the server refused reports what its wall covers, as its rendered view does.
-    const locked = lockedHeadlessReport(resolved, error, () => (
+    const locked = await lockedHeadlessReport(resolved, error, () => (
       buildHeadlessPaneLoadArgs(resolved.headless!, resolved.token, rawArgument, resolved.options).symbols
-    ));
+    ), createHeadlessPaneContext(resolved, context, new AbortController().signal));
     if (locked) return locked;
     throw error;
   }

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

@@ -36,7 +36,7 @@ import {
 import { isNotATickerMessage } from "../not-a-ticker";
 import { isCliFailure } from "../errors";
 import { isTickerLinkPeer } from "../../layout/ticker-navigation";
-import { knownGapMessage, commandPointer, topicPointer } from "../known-gaps";
+import { knownGapMessage, commandPointer, commandPointerLeads, topicPointer } from "../known-gaps";
 import { selectReportTables } from "../report-tables";
 import { cliOutputWritten } from "../result";
 import type { CatalogCommandHit } from "../unknown-command";
@@ -486,6 +486,7 @@ export async function runPaneCatalog(args: string[], ctx: CliCommandContext) {
         // A setting or a report can be a command, not a function: "light theme" names `config themes` beside THEM,
         // "drip" names `portfolio show --drip` beside DVD.
         const setting = commandPointer(parsed.query);
+        const settingLeads = commandPointerLeads(parsed.query);
         // The data catalog series the query names, which `fn G` charts.
         const series = findCatalogSeries(ctx.plugins, parsed.query);
         const listed = pointer
@@ -496,7 +497,7 @@ export async function runPaneCatalog(args: string[], ctx: CliCommandContext) {
           ...series.length ? { metadata: { series } } : {},
           ...(gap || setting) && ctx.cliOptions.format !== "text" ? { warnings: [gap, setting].filter((note): note is string => !!note) } : {},
         }, {
-          text: () => renderPaneCatalogReport(filtered, effectiveParsed, glossary, gap, series, setting),
+          text: () => renderPaneCatalogReport(filtered, effectiveParsed, glossary, gap, series, setting, settingLeads),
         });
       } finally {
         registry.destroy();

package/src/cli/pane-functions/lock-note.ts

@@ -2,6 +2,7 @@ import { refusedLock } from "../../plugins/builtin/shared/cloud-denied";
 import { lockNoteReason } from "../../plugins/builtin/shared/pro-lock-note";
 import { cliTerminalWidth, wrapText } from "../../utils/cli-output";
 import { reportFooterLines } from "../report-tables";
+import type { HeadlessPaneContext } from "../../types/headless";
 import type { PaneFunctionReport } from "./report";
 import type { ResolvedPaneFunction } from "./resolver";
 
@@ -22,19 +23,21 @@ export function lockNoteLines(note: string): string[] {
  * `reportLockNote`, no source line and `locked` in JSON. The refusal may be
  * the error itself or the cause of the one a headless read wrote for it
  * (`explainRefusal`). Null when the error is no such refusal or the pane has
- * no note, and the error stands.
+ * no note, and the error stands. The context lets the note check the free
+ * route it names.
  */
-export function lockedHeadlessReport(
+export async function lockedHeadlessReport(
   resolved: ResolvedPaneFunction,
   error: unknown,
   /** The symbols the report was asked for, read once the error is known to be a refusal. */
   symbolsOf: () => string[],
-): PaneFunctionReport | null {
+  context?: HeadlessPaneContext,
+): Promise<PaneFunctionReport | null> {
   const refused = refusedLock(error);
   if (!refused || !resolved.pane.reportLockNote) return null;
   const gate = refused.gate;
   const symbols = symbolsOf();
-  const note = resolved.pane.reportLockNote({ ...refused, symbol: symbols[0] ?? null, token: resolved.token });
+  const note = await resolved.pane.reportLockNote({ ...refused, symbol: symbols[0] ?? null, token: resolved.token, ...context ? { context } : {} });
   const reason = lockNoteReason(note);
   return {
     data: {

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

@@ -148,7 +148,8 @@ export async function applyListingArgument(
   // 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);
   if (typed.length === 0) return args;
-  let listings = await Promise.all(typed.map((raw) => resolveCliListing(raw, exchange, context, { ownExchangeWins: typed.length > 1 })));
+  // 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();

package/src/cli/quote-answer.ts

@@ -0,0 +1,179 @@
+import type { QuoteBatchResult } from "../types/data-provider";
+import type { Quote } from "../types/financials";
+import { bareListingNote } from "../tickers/listing-fate";
+import { notATickerSymbol } from "../sources/provider-errors";
+import { looksLikeCurrencyPair } from "../utils/currency-pair";
+import { canonicalExchange } from "../utils/exchanges";
+import type { CliCommandDef } from "../types/plugin";
+import { currencyCodeNote } from "./currency-hints";
+import { describeSuggestion, suggestListing, suggestUsTicker, type ListingSuggestion } from "./listing-suggestion";
+import { indexRootAlsoLine, indexRootFor, indexRootTryLine } from "./index-roots";
+import { treasuryYieldLine, treasuryYieldTenor } from "./treasury-yields";
+import { knownGapForTicker } from "./known-gaps";
+import {
+  futuresTryLine,
+  isNoProviderError,
+  listingChoiceNotes,
+  listingReadNotes,
+  loadBareVenues,
+  notTradedMessage,
+  quoteBareListing,
+  requireCliListing,
+  tradingBoardNote,
+  type CliListing,
+  type ListingDataRequest,
+  type ListingVenue,
+} from "./listing-arg";
+import { withListingSuggestion } from "./not-a-ticker";
+import type { MarketContext } from "./types";
+
+/** The text of an error, or null for none. */
+export function errorMessage(error: unknown): string | null {
+  if (error == null) return null;
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * "APPL is not a US ticker: it is Aptus Pharma Limited on BSE (INR). Did you
+ * mean AAPL (Apple Inc.)?", for a symbol read on a listing abroad that is one
+ * slip from a US ticker, worded as the not-a-ticker answers word it.
+ */
+export function notUsTickerSentence({ target, quote, listing, usSuggestion }: { target: { symbol: string }; quote: Quote | null; listing?: { name: string | null }; usSuggestion?: ListingSuggestion }): string | null {
+  if (!quote || !usSuggestion) return null;
+  const venue = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+  const name = quote.name || listing?.name;
+  const what = `${name ? `${name} on ` : ""}${venue}${quote.currency ? ` (${quote.currency})` : ""}`;
+  return `${target.symbol} is not a US ticker: it is ${what}. Did you mean ${describeSuggestion(usSuggestion)}?`;
+}
+
+export interface QuoteAnswer {
+  result: QuoteBatchResult;
+  /** The listing the row is: the one asked for, or the venue a bare symbol was quoted on. */
+  listing: CliListing;
+  /** Why there is no quote, when there is more to say than the source's own error. */
+  failure?: { message: string; details?: string; oneLine: string };
+  notes: string[];
+}
+
+/**
+ * One symbol's row of `quote` and `compare`. A listing on an exchange its symbol
+ * is not listed on says so. A bare symbol the data service read on its home
+ * listing abroad names that venue (SXR8 -> XETRA). One no source quotes is
+ * quoted on its listings (`quoteBareListing`), else names them, or asks for an
+ * exchange when several companies list it (2222); a bare index root (VIX) also
+ * names its index (^VIX), and a futures board code a security keeps (GC) its
+ * future (GC=F). Venues are only looked up for a
+ * symbol with no quote, so a request that succeeds costs no search.
+ */
+export async function answerQuote(
+  result: QuoteBatchResult,
+  listing: CliListing,
+  market: MarketContext,
+  request: ListingDataRequest,
+  refresh: boolean,
+  venues: Promise<ListingVenue[]> | null,
+): Promise<QuoteAnswer> {
+  const root = listing.exchange ? null : indexRootFor(listing.symbol);
+  // A bare root that quoted something else, such as MOVE (Corvex), points at the index too.
+  const also = (quote: Quote) => root && quote.instrumentType?.trim().toUpperCase() !== "INDEX"
+    ? [indexRootAlsoLine(root, request.command)] : [];
+  if (result.quote) {
+    // "CAR = Avis Budget Group, NASDAQ (also XETRA, ASX)" names the venue too, so it replaces "SXR8 -> XETRA".
+    const choice = venues ? await listingChoiceNotes(listing, market, result.quote, venues) : listingReadNotes(listing);
+    const venue = choice.length > 0 ? null : bareListingNote(listing, result.quote);
+    // A row saved as 247540:KRX is quoted from KOSDAQ, the board it trades on.
+    const board = tradingBoardNote(listing, result.quote);
+    return { result, listing, notes: [...choice, venue ?? [], board ?? [], also(result.quote), currencyCodeNote(listing, result.quote) ?? []].flat() };
+  }
+  const notTraded = await notTradedMessage(listing, market);
+  if (notTraded) return { result, listing, failure: { message: notTraded, oneLine: notTraded }, notes: [] };
+  if (!isNoProviderError(result.error)) return { result, listing, notes: [] };
+  const other = await quoteBareListing(listing, market, request, { refresh });
+  if (other?.kind === "quoted") {
+    return {
+      result: { target: other.listing.request, quote: other.quote },
+      listing: other.listing,
+      notes: [other.note, ...also(other.quote), currencyCodeNote(listing, other.quote) ?? []].flat(),
+    };
+  }
+  // Other listings already name a futures board code's future (GC=F); with none, it is named here.
+  // A Treasury yield's root (TNX) names its FRED series and the curve beside its index.
+  const yieldTenor = root ? treasuryYieldTenor(listing.symbol) : null;
+  const tryLines = [
+    yieldTenor ? treasuryYieldLine(yieldTenor) : root ? indexRootTryLine(root, request.command) : null,
+    other || listing.exchange ? null : futuresTryLine(listing.symbol, request),
+    // BDI asks which exchange (Black Diamond Group) and says nowhere that the Baltic Dry Index is not here.
+    listing.exchange ? null : knownGapForTicker(listing.symbol),
+  ].filter((line): line is string => !!line);
+  if (!other && tryLines.length === 0) return { result: await withCurrencyPairHint(result, market), listing, notes: [] };
+  const message = other?.message ?? `${listing.symbol} has no ${request.noun}.`;
+  const details = [other?.details, ...tryLines].filter(Boolean).join("\n");
+  const oneLine = [
+    message,
+    other ? `${other.heading}: ${other.listings.join(", ")}.` : "",
+    ...tryLines,
+  ].filter(Boolean).join(" ");
+  return { result, listing, failure: { message, details, oneLine }, notes: [] };
+}
+
+/** A listing a command found a quote for, with what `quote` says beside it. */
+interface QuotedListing {
+  /** The listing the quote is of: the one typed, or the venue a bare symbol was quoted on. */
+  listing: CliListing;
+  quote: Quote;
+  /** The venue a bare symbol was read on, the currency it may have meant, the US ticker it is one slip from. */
+  notes: string[];
+}
+
+/**
+ * The listing a command that keeps a symbol (`alerts add`) was given, read as
+ * `quote` reads it: the same resolver and the same quote request, so what is
+ * kept is the listing `quote` prints (USDMXN and USD/MXN are USDMXN=X, MXN is
+ * MXN:FWB2) and `quote`'s own notes come back with it. A symbol nothing
+ * quotes fails the command with why, and the nearest listing search finds when
+ * it is near ("Not a ticker: ZZZQQ. Did you mean ZZZQ?"), so nothing is kept
+ * for it.
+ */
+export async function requireQuotedListing(
+  raw: string,
+  exchange: string | null | undefined,
+  market: MarketContext,
+  ctx: Pick<Parameters<CliCommandDef["execute"]>[1], "fail">,
+  command: string,
+): Promise<QuotedListing> {
+  const listing = await requireCliListing(raw, exchange, market, ctx);
+  const venues = loadBareVenues(listing, market);
+  const [result] = await market.dataProvider.getQuotesBatch([listing.request], { revalidate: true });
+  const answer = await answerQuote(result ?? { target: listing.request, quote: null }, listing, market, { command, noun: "quote" }, false, venues);
+  const quote = answer.result.quote;
+  if (!quote) {
+    if (answer.failure) ctx.fail(answer.failure.message, answer.failure.details);
+    const message = errorMessage(answer.result.error) ?? `No quote found for ${listing.key}.`;
+    // The listing search names, else the US ticker it is one slip from (AAPLL for AAPL), which search does not list for a typo.
+    const suggestion = notATickerSymbol(message) && !message.includes(" Did you mean ")
+      ? await suggestListing(listing.symbol, market) ?? await suggestUsTicker(listing.symbol, market)
+      : null;
+    ctx.fail(suggestion ? withListingSuggestion(message, describeSuggestion(suggestion)) : message);
+  }
+  // A bare symbol read on a listing abroad that is one slip from a US ticker says so, as `quote` does.
+  const venue = answer.listing.saved ? null : bareListingNote(answer.listing, quote);
+  const usSuggestion = venue && answer.notes.includes(venue) ? await suggestUsTicker(answer.listing.symbol, market) : null;
+  const notUs = notUsTickerSentence({ target: answer.result.target, quote, listing: { name: quote.name ?? null }, usSuggestion: usSuggestion ?? undefined });
+  return { listing: answer.listing, quote, notes: [...answer.notes, ...notUs ? [notUs] : []] };
+}
+
+/**
+ * A symbol written like a currency pair that is not a ticker (USD_NGN, as some
+ * FX feeds write a pair) names the listing `gloomberb search` finds nearest to
+ * it, as `watchlist add` does: "Did you mean USDNGN=X (US Dollar/Nigerian
+ * Naira)?". When search finds nothing near, the row keeps its own error and its
+ * search hint.
+ */
+async function withCurrencyPairHint(result: QuoteBatchResult, market: MarketContext): Promise<QuoteBatchResult> {
+  const message = errorMessage(result.error);
+  const symbol = message ? notATickerSymbol(message) : null;
+  if (!message || !symbol || !looksLikeCurrencyPair(symbol)) return result;
+  const suggestion = await suggestListing(symbol, market);
+  return suggestion ? { ...result, error: withListingSuggestion(message, describeSuggestion(suggestion)) } : result;
+}
+

package/src/cli/series-search.ts

@@ -1,6 +1,7 @@
 import { seriesExpression } from "../series/registry";
 import type { SeriesDefinition } from "../series/types";
 import { cliStyles, renderSection, renderTable, wrapText } from "../utils/cli-output";
+import { currencyCodeLabel } from "../utils/currency-units";
 
 /** A data catalog series a query names, as the CLI lists it. */
 export interface SeriesMatch {
@@ -108,7 +109,7 @@ export function renderSeriesMatches(
     renderTable(
       [{ header: "Series" }, { header: "Unit" }, { header: "Frequency", optional: true }, { header: "Publisher", optional: true },
         { header: "Chart", shrink: false }],
-      shown.map((match) => [match.name, match.unit, match.frequency, match.publisher ?? "", cliStyles.command(shellArgument(match.expression))]),
+      shown.map((match) => [match.name, currencyCodeLabel(match.unit), match.frequency, match.publisher ?? "", cliStyles.command(shellArgument(match.expression))]),
     ),
     "",
     ...wrapText(hint, width).map((line) => cliStyles.muted(line)),

package/src/cli/symbol-list.ts

@@ -74,28 +74,59 @@ function looksLikeSymbol(cell: string): boolean {
   return SYMBOL_TOKEN.test(cell) && !(NUMBER_CELL.test(cell) && /[.,%]/.test(cell));
 }
 
+/** How many cells a table's ignored-cells note names before it counts the rest. */
+const IGNORED_PREVIEW = 8;
+
+/** What a file or piped text holds: its symbols in order, and the cells of a table read by one column that were left out. */
+interface SymbolText {
+  symbols: string[];
+  /** Cells beside the symbol column of a table with no header, in reading order; empty for a list or a CSV with a header. */
+  ignored: string[];
+}
+
 /**
  * The symbols in a file or piped text, in order. A spreadsheet export reads
- * from the column its header names (Symbol, Ticker, Code), or else its first
- * column; a list split by commas, spaces or newlines gives every entry. A byte
- * order mark, Windows line ends, blank lines and lines starting with # or //
- * are ignored.
+ * from the column its header names (Symbol, Ticker, Code). Without a header,
+ * every cell is a symbol unless some column after the first holds a name, a
+ * price or a weight: that table is read by its first column, and the cells
+ * beside it are returned as `ignored` so the command can name them. A list
+ * split by commas, spaces or newlines gives every entry, even when a line of
+ * it is ragged or carries a stray separator (`"BIMAS ,"`). A byte order mark,
+ * Windows line ends, blank lines and lines starting with # or // are ignored.
  */
-export function parseSymbolText(text: string): string[] {
+export function parseSymbolText(text: string): SymbolText {
   const normalized = text.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
   const lines = normalized.split("\n");
   const delimiter = detectDelimiter(lines);
   const records = (delimiter ? parseDelimited(normalized, delimiter) : lines.map((line) => line.trim().split(/\s+/)))
     .filter((cells) => cells.some(Boolean) && !isComment(cells[0] ?? ""));
-  if (records.length === 0) return [];
+  if (records.length === 0) return { symbols: [], ignored: [] };
   const header = records[0]!.map(headerKey);
   const exact = header.findIndex((cell) => SYMBOL_HEADERS.has(cell));
   const column = exact >= 0 ? exact : header.findIndex((cell) => cell.includes("symbol") || cell.includes("ticker"));
-  if (column >= 0) return records.slice(1).map((cells) => cells[column] ?? "").filter(Boolean);
-  // Without a header, symbols laid out across columns are all symbols; a
-  // table with names, prices or weights beside them is read by its first column.
-  const grid = records.every((cells) => cells.every((cell, index) => !cell || (looksLikeSymbol(cell) && (index === 0 || !NUMBER_CELL.test(cell)))));
-  return grid ? records.flat().filter(Boolean) : records.map((cells) => cells[0] ?? "").filter(Boolean);
+  if (column >= 0) return { symbols: records.slice(1).map((cells) => cells[column] ?? "").filter(Boolean), ignored: [] };
+  // A separator or quote mark stuck to a cell is dropped (and named) when it is read, so it does not make the list a table.
+  const cleaned = records.map((cells) => cells.map((cell) => stripStrayEdges(cell).text));
+  const grid = cleaned.every((cells) => cells.every((cell, index) => !cell || (looksLikeSymbol(cell) && (index === 0 || !NUMBER_CELL.test(cell)))));
+  if (grid) return { symbols: records.flat().filter(Boolean), ignored: [] };
+  return {
+    symbols: records.map((cells) => cells[0] ?? "").filter(Boolean),
+    ignored: records.flatMap((cells) => cells.slice(1)).filter(Boolean),
+  };
+}
+
+/**
+ * The note a table read by its first column gets, naming what was left out:
+ * `Read the first column as symbols; ignored the 4 cells beside it: Apple
+ * Inc., 336.64, Microsoft, 535.07.` Long tables name the first few and count
+ * the rest. Null when nothing was ignored.
+ */
+function ignoredCellsNote(ignored: readonly string[]): string | null {
+  if (ignored.length === 0) return null;
+  const named = ignored.slice(0, IGNORED_PREVIEW).join(", ");
+  const more = ignored.length - IGNORED_PREVIEW;
+  const cells = ignored.length === 1 ? "the cell" : `the ${ignored.length} cells`;
+  return `Read the first column as symbols; ignored ${cells} beside it: ${named}${more > 0 ? ` and ${more} more` : ""}.`;
 }
 
 /** Whether standard input is a pipe or a file rather than a terminal, so a command may read its list from it. */
@@ -138,9 +169,10 @@ export class SymbolListError extends Error {
  * standard input when an argument is `-` or nothing else was given and input
  * is piped in. Repeats are dropped. A separator stuck to a symbol in a file, or
  * left on the end of what was typed (`UPST;`), is dropped with the quote marks
- * around it, and each is named in `strays` so the command can say so.
+ * around it, and the cells beside the symbols of a table read by its first
+ * column are left out; `notes` names each so the command can say so.
  */
-export async function readSymbolList(source: SymbolListSource): Promise<{ symbols: string[]; repeated: number; strays: string[] }> {
+export async function readSymbolList(source: SymbolListSource): Promise<{ symbols: string[]; repeated: number; notes: string[] }> {
   const readStdin = source.readStdin ?? (() => Bun.stdin.text());
   const wantsStdin = source.args.includes("-") || source.file === "-";
   const typedArgs = source.args.filter((arg) => arg !== "-");
@@ -148,12 +180,14 @@ export async function readSymbolList(source: SymbolListSource): Promise<{ symbol
   const collected = [...typed];
   // A separator left on the end of what was typed: `UPST;`, or a list that ends in a comma.
   const strays = new Set<string>(stripStrayEdges(typedArgs.join(" ")).notes);
-  const addCells = (cells: readonly string[]) => {
-    for (const cell of cells) {
+  const ignored: string[] = [];
+  const addCells = ({ symbols, ignored: beside }: SymbolText) => {
+    for (const cell of symbols) {
       const cleaned = stripStrayEdges(cell);
       cleaned.notes.forEach((note) => strays.add(note));
       collected.push(cleaned.text);
     }
+    ignored.push(...beside);
   };
   if (source.file != null && source.file !== "-") {
     if (!source.file.trim() || source.file.startsWith("--")) throw new SymbolListError("--file needs a path, such as --file symbols.csv.");
@@ -169,5 +203,6 @@ export async function readSymbolList(source: SymbolListSource): Promise<{ symbol
   if (wantsStdin || (typed.length === 0 && source.file == null && (source.stdinPiped ?? stdinIsPiped()))) {
     addCells(parseSymbolText(await readStdin()));
   }
-  return { ...uniqueSymbols(collected), strays: [...strays] };
+  const ignoredNote = ignoredCellsNote(ignored);
+  return { ...uniqueSymbols(collected), notes: [...strays, ...ignoredNote ? [ignoredNote] : []] };
 }

package/src/cli/types.ts

@@ -5,6 +5,7 @@ import { AssetDataRouter } from "../sources/provider-router";
 import type { AppServices } from "../core/app-services";
 import type { CapabilityInvoker } from "../capabilities/types";
 import type { StatementReportSources } from "./statement-filings";
+import type { FxHistoryClient } from "../market-data/fx-closes";
 
 export type ConfigContext = {
   config: AppConfig;
@@ -15,12 +16,15 @@ export type ConfigContext = {
 
 export type MarketContext = ConfigContext & {
   dataProvider: AssetDataRouter;
+  resolveBroker?: (brokerType: string) => import("../types/broker").BrokerAdapter | null;
   /** Charts catalog series in a report run without the plugin runtime. */
   seriesCapabilities?: CapabilityInvoker;
   /** `--refresh`: prefetched data bypasses the local cache. */
   refresh?: boolean;
   /** Filings behind the statements and a bank's figures, read from Gloom Cloud; absent where the data service is a stand-in. */
   statementSources?: StatementReportSources;
+  /** Daily FX closes (`fx --date`, converted INS values); Gloom Cloud unless a test stands in for it. */
+  fxHistory?: FxHistoryClient;
 };
 
 export type CliServicesContext = {

package/src/components/chart/composite/composite-chart.tsx

@@ -11,6 +11,7 @@ import { ChartToolbar, CHART_TOOLBAR_WIDTH } from "./toolbar";
 import { AsciiText, Box, ChartSurface, Text, useUiCapabilities, type BoxRenderable } from "../../../ui";
 import { useLiveStretch } from "../../../ui/live-stretch";
 import { useOptionalPaneInstanceId } from "../../../state/app/context";
+import { usePaneFocused } from "../../../state/app/activity";
 import { useTabCursorLink } from "../../../state/app/tab-cursor";
 import { useThemeColors, useThemeId } from "../../../theme/theme-context";
 import { themedSeriesColor, themeSeriesColors } from "../../../theme/series-colors";
@@ -155,6 +156,8 @@ function ThemedCompositeChart({
   const showTextFallback = useShowChartTextFallback();
   const [internalCursorDate, setInternalCursorDate] = useState<Date | null>(null);
   const [toolSpan, setToolSpan] = useState<ChartToolSpan | null>(null);
+  const [pointerDragging, setPointerDragging] = useState(false);
+  const paneFocused = usePaneFocused();
   const paneInstanceId = useOptionalPaneInstanceId();
   const [drawings, setDrawings] = useState<readonly ChartDrawing[]>(NO_DRAWINGS);
   const [selectedDrawingId, setSelectedDrawingId] = useState<string | null>(null);
@@ -186,7 +189,13 @@ function ThemedCompositeChart({
       (drawing) => drawing.id === selectedDrawingId ? { ...drawing, color } : drawing,
     ));
   }, [selectedDrawingId]);
-  const resolvedCursorDate = cursorDate === undefined ? internalCursorDate : cursorDate;
+  // A cursor the owner rests on without following its moves (a seasonal
+  // chart's latest week) is where the chart's own cursor goes back to: the
+  // pointer moves it as on any chart, and the pointer leaving returns it.
+  const restingCursor = cursorDate !== undefined && !onCursorDateChange;
+  const ownsCursor = cursorDate === undefined || restingCursor;
+  const resolvedCursorDate = cursorDate === undefined ? internalCursorDate
+    : restingCursor ? internalCursorDate ?? cursorDate : cursorDate;
   const totalWidth = Math.max(1, Math.floor(width));
   const totalHeight = Math.max(1, Math.floor(height));
   const seriesIdentityRef = useRef<ResolvedSeries[]>([]);
@@ -327,6 +336,7 @@ function ThemedCompositeChart({
     availableAxisWidth,
     Math.max(
       Math.min(MINIMUM_AXIS_LABEL_WIDTH, maximumAxisWidth),
+      ...(levels?.items ?? []).map((level) => level.axisLabel?.length ?? 0),
       ...(layoutPanels ?? []).flatMap((panel) => (["left", "right"] as const).map((side) => {
         const width = compositeAxisLabelWidth(panel.axes[side], formatAxisValue, includeCursorLabels);
         if (!includeSeriesTags || !width) return includeCursorLabels ? width : Math.min(width, maximumAxisWidth);
@@ -337,7 +347,7 @@ function ThemedCompositeChart({
         return (width + 1) * lanes;
       })),
     ),
-  ), [availableAxisWidth, formatAxisValue, includeCursorLabels, includeSeriesTags, layoutPanels, maximumAxisWidth]);
+  ), [availableAxisWidth, formatAxisValue, includeCursorLabels, includeSeriesTags, layoutPanels, maximumAxisWidth, levels?.items]);
   const leftAxisWidth = hasLeftAxis ? resolvedAxisWidth : 0;
   const rightAxisWidth = hasRightAxis ? resolvedAxisWidth : 0;
   const axisGap = resolvedAxisWidth > 0 ? 1 : 0;
@@ -417,18 +427,18 @@ function ThemedCompositeChart({
     const nextTimestamp = timestamp !== null && Number.isFinite(timestamp) ? timestamp : null;
     if (lastCursorTimestampRef.current === nextTimestamp) return;
     lastCursorTimestampRef.current = nextTimestamp;
-    if (cursorDate === undefined) setInternalCursorDate(date);
+    if (ownsCursor) setInternalCursorDate(date);
     onCursorDateChange?.(date);
     publishCursor?.(date && baseScene && nextTimestamp !== null ? compositeCursorAsOf(baseScene, date) : null);
-  }, [baseScene, cursorDate, onCursorDateChange, publishCursor]);
+  }, [baseScene, onCursorDateChange, ownsCursor, publishCursor]);
   // Another chart taking the cursor, or clearing it, takes it from this one,
   // so it does not come back here later. Read live: a move since the render
   // makes this chart's cursor the shared one again.
   useEffect(() => {
     void holdsSharedCursor;
-    if (!link || cursorDate !== undefined || lastCursorTimestampRef.current === null || link.held()) return;
+    if (!link || !ownsCursor || lastCursorTimestampRef.current === null || link.held()) return;
     updateCursor(null);
-  }, [cursorDate, holdsSharedCursor, link, updateCursor]);
+  }, [holdsSharedCursor, link, ownsCursor, updateCursor]);
   // Esc on a chart showing another chart's cursor clears it, as on that chart.
   // While the tab's cursor is pinned the arrows move the pin and Esc unpins it.
   const updateKeyboardCursor = useCallback((date: Date | null) => {
@@ -644,7 +654,11 @@ function ThemedCompositeChart({
     );
   }
 
-  const showToolbar = interactive && navigable && plotWidth > CHART_TOOLBAR_WIDTH + 4;
+  // The tools belong to the focused pane, and stay while one is in hand or a
+  // press drags the plot, so focus moving elsewhere never hides what is
+  // drawing. A chart outside a pane (a share page) keeps them.
+  const toolbarWanted = paneFocused !== false || armedTool !== null || pointerDragging || toolSpan !== null;
+  const showToolbar = interactive && navigable && toolbarWanted && plotWidth > CHART_TOOLBAR_WIDTH + 4;
   // Bars shorter than a day carry a time of day the cursor reads out.
   const intradayBars = scene.timeZone !== undefined || visibleSeries.some((entry) => (
     !!entry.historyResolution && isIntradayResolution(entry.historyResolution)
@@ -766,6 +780,7 @@ function ThemedCompositeChart({
           onZoomViewport={zoomViewport}
           onSetViewport={setViewportRange}
           onToolSpanChange={setToolSpan}
+          onDragActiveChange={setPointerDragging}
           keyboardToolDrag={keyboardToolDrag?.panelId === panel.id ? keyboardToolDrag : null}
           onPointerPress={cancelKeyboardPlacement}
           showTextFallback={showTextFallback}