gloomberb 0.16.1 → 0.16.3

package/src/cli/freshness.ts

@@ -0,0 +1,61 @@
+import type { FinancialStatement, Quote, TickerFinancials } from "../types/financials";
+import type { HeadlessPaneFreshness, HeadlessPaneRow } from "../types/headless";
+import { deriveHeadlessFreshness, type ReportFreshness } from "./pane-functions/freshness";
+import { quoteFreshnessFields, REPORTED_DATA } from "../plugins/builtin/shared/report-freshness";
+import { latestFinancialPeriod } from "../utils/latest-financial-period";
+
+/**
+ * The source, as-of and status line of a plain CLI command, derived exactly as
+ * an `fn` report derives it: rows read like a headless report's rows (quote
+ * `dataSource`, `delayMinutes`, `stale` flags, observation times, worst of
+ * across rows) under what the command declares about them. Nothing to cite, no line.
+ */
+export function rowsFreshness(
+  rows: readonly object[],
+  declared?: HeadlessPaneFreshness,
+  metadata?: Record<string, unknown>,
+  now = Date.now(),
+): ReportFreshness | undefined {
+  if (rows.length === 0 && !metadata && !declared) return undefined;
+  return deriveHeadlessFreshness(
+    { shape: "rows", freshness: declared },
+    { rows: rows as HeadlessPaneRow[], ...(metadata ? { metadata } : {}) },
+    now,
+  );
+}
+
+/** One row per quote shown, as `fn` quote reports carry them: live, delayed or stale for its session. */
+function quoteFreshnessRow(quote: Quote): HeadlessPaneRow {
+  return { ...quoteFreshnessFields(quote), updatedAt: quote.lastUpdated };
+}
+
+/** Worst of across the quotes shown, dated by the newest. Quotes that failed to load say nothing. */
+export function quotesFreshness(
+  quotes: Iterable<Quote | null | undefined>,
+  declared?: HeadlessPaneFreshness,
+  now = Date.now(),
+): ReportFreshness | undefined {
+  const rows = [...quotes].filter((quote): quote is Quote => quote != null).map(quoteFreshnessRow);
+  return rows.length > 0 ? rowsFreshness(rows, declared, undefined, now) : undefined;
+}
+
+/** The newest reported period end in the statements, the period the trailing figures run through. */
+function latestReportedPeriod(financials: Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">): string | null {
+  const rows: FinancialStatement[] = [...financials.annualStatements, ...financials.quarterlyStatements];
+  return latestFinancialPeriod(rows, (row) => row.date)?.date ?? null;
+}
+
+/**
+ * Fundamentals and valuation: reported figures, not a feed. Dated by when the
+ * statistics block was observed, with the newest statement period they run
+ * through named in the status; stale only when the block says so.
+ */
+export function fundamentalsFreshness(financials: TickerFinancials, now = Date.now()): ReportFreshness {
+  const fundamentals = financials.fundamentals;
+  const period = latestReportedPeriod(financials);
+  return rowsFreshness([], {
+    ...REPORTED_DATA,
+    basis: period ? `reported through ${period}` : REPORTED_DATA.basis,
+    asOf: fundamentals?.fetchedAt ?? null,
+  }, { stale: fundamentals?.stale === true }, now)!;
+}

package/src/cli/help.ts

@@ -10,6 +10,12 @@ import {
   wrapText,
 } from "../utils/cli-output";
 
+/** `--section` of a command whose report has several tables. */
+export const TABLE_SECTION_OPTION = {
+  flags: "--section <title|n>",
+  description: "With --csv or --ndjson, write only that table, by its title or number",
+};
+
 /** Headings of `gloomberb help`, in display order. */
 export const CLI_COMMAND_GROUPS = {
   research: "Research",
@@ -29,7 +35,9 @@ const MAX_HELP_WIDTH = 100;
 const PIPED_HELP_WIDTH = 80;
 
 const GLOBAL_OPTIONS: Array<[string, string]> = [
-  ["--json, --csv, --ndjson", "Print machine-readable output instead of text"],
+  ["--json", "Print the full result as JSON"],
+  ["--csv", "Print rows as CSV under the columns the text shows; fn reports and fundamentals put each table under # section: and end with # source lines"],
+  ["--ndjson", "Print one JSON object per table row"],
   ["--limit <n>", "Show at most n rows"],
   ["--refresh", "Fetch fresh data instead of reading the cache"],
   ["--dry-run", "Preview config, cache, notes, alerts, plugin on/off, and remote changes without saving"],
@@ -95,6 +103,7 @@ export function renderCliHelp(entries: CliHelpEntry[], version: string, descript
       ["gloomberb", "Open the terminal UI"],
       ["gloomberb <command> [args]", "Run a command and print the result"],
       ["gloomberb help <command>", "Show a command's usage, options, and examples"],
+      ["gloomberb ticker SAN:EPA", "Name the listing of a symbol that trades in several places (or --exchange EPA)"],
     ], { width }),
   ];
 
@@ -177,14 +186,10 @@ function editDistance(left: string, right: string): number {
   return previous[right.length]!;
 }
 
-/** The closest command token to a mistyped one, or null when nothing is plausibly meant. */
-export function suggestCliCommand(token: string, candidates: Iterable<string>): string | null {
-  const needle = token.trim().toLowerCase();
-  if (!needle || needle.startsWith("-")) return null;
+function closestName(needle: string, candidates: Iterable<string>): string | null {
   const allowed = needle.length <= 4 ? 1 : 2;
   let best: { name: string; score: number } | null = null;
   for (const candidate of candidates) {
-    if (candidate.startsWith("-")) continue;
     // A clear prefix ("tick" for "ticker") beats an edit of the same size.
     const score = needle.length >= 3 && candidate.startsWith(needle)
       ? 0.5
@@ -194,3 +199,19 @@ export function suggestCliCommand(token: string, candidates: Iterable<string>):
   }
   return best?.name ?? null;
 }
+
+/** The closest command token to a mistyped one, or null when nothing is plausibly meant. */
+export function suggestCliCommand(token: string, candidates: Iterable<string>): string | null {
+  const needle = token.trim().toLowerCase();
+  if (!needle || needle.startsWith("-")) return null;
+  return closestName(needle, [...candidates].filter((candidate) => !candidate.startsWith("-")));
+}
+
+/** The closest of a command's options to a mistyped one (`--rnage` for `--range`), or null. */
+export function suggestCliOption(flag: string, options: Iterable<string>): string | null {
+  const needle = flag.trim().toLowerCase().replace(/^-+/, "");
+  if (!needle) return null;
+  const byName = new Map([...options].map((option) => [option.replace(/^-+/, ""), option] as const));
+  const name = closestName(needle, byName.keys());
+  return name == null ? null : byName.get(name)!;
+}

package/src/cli/helpers.ts

@@ -9,6 +9,7 @@ import { cliStyles, colorBySign } from "../utils/cli-output";
 import type { AppConfig } from "../types/config";
 import type { Watchlist, TickerRecord } from "../types/ticker";
 import { isFiniteNumber } from "../utils/guards";
+import { formatUtcTime } from "../utils/utc-time";
 
 export function formatSignedCurrency(value: number, currency: string): string {
   return value > 0 ? `+${formatCurrency(value, currency)}` : formatCurrency(value, currency);
@@ -87,15 +88,10 @@ export function formatPriceRange(
   return `${format(low, { fixedFractionDigits: digits })}${separator}${format(high, { fixedFractionDigits: digits })}`;
 }
 
+/** A timestamp in CLI text: UTC with the zone named, the same on every machine. */
 export function formatTimestamp(timestamp: number | undefined): string {
-  if (!timestamp) return "—";
-  return new Date(timestamp).toLocaleString("en-US", {
-    month: "short",
-    day: "numeric",
-    year: "numeric",
-    hour: "numeric",
-    minute: "2-digit",
-  });
+  if (!timestamp || !Number.isFinite(timestamp)) return "—";
+  return formatUtcTime(new Date(timestamp)) || "—";
 }
 
 export function formatBidAsk(

package/src/cli/history-rows.ts

@@ -1,19 +1,52 @@
 import type { PricePoint } from "../types/financials";
 import { marketPriceFractionDigitCeiling, resolveAssetDisplayKind } from "../market-data/market/format";
-import { isIntradayResolution, type ManualChartResolution } from "../time-series/resolution";
+import { TIME_RANGES, type TimeRange } from "../time-series/range";
+import { subtractTimeRange } from "../time-series/date-window";
+import {
+  CHART_RESOLUTION_STEP_MS,
+  isIntradayResolution,
+  RANGE_HISTORY_RESOLUTION,
+  type ManualChartResolution,
+} from "../time-series/resolution";
+import { currencyUnitLabel } from "../utils/currency-units";
 import { getPricePointTimestamp } from "../utils/price-history";
+import { pricePointIntegrityFlags, pricePointValues } from "../utils/price-history-integrity";
+import { formatUtcTime } from "../utils/utc-time";
 
 const PRICE_KEYS = ["open", "high", "low", "close"] as const;
+const DAY_MS = 24 * 60 * 60 * 1000;
 /** Daily bars are a day apart even when stamped at the session open. */
 const INTRADAY_MAX_GAP_MS = 20 * 60 * 60 * 1000;
+const INTRADAY_RESOLUTIONS = ["1m", "5m", "15m", "30m", "45m", "1h"] as const;
+/** A first bar later than this after the range's start is a late start, not a weekend or holiday. */
+const LATE_START_MIN_MS = 10 * DAY_MS;
+const LATE_START_MIN_BARS = 3;
 
-interface HistoryRow {
+const BAR_INTERVAL_LABELS: Record<ManualChartResolution, string> = {
+  "1m": "1-minute",
+  "5m": "5-minute",
+  "15m": "15-minute",
+  "30m": "30-minute",
+  "45m": "45-minute",
+  "1h": "hourly",
+  "1d": "daily",
+  "1wk": "weekly",
+  "1mo": "monthly",
+};
+
+export interface HistoryRow {
   date: string;
   open: number | null;
   high: number | null;
   low: number | null;
-  close: number;
+  close: number | null;
   volume: number | null;
+  /** Currency code of the prices; null for index points or when no source says. */
+  currency: string | null;
+  /** Bar size, in the codes of `resolution`: 5m, 1h, 1d, 1wk, 1mo. */
+  interval: ManualChartResolution | null;
+  /** Each way the bar's prices contradict each other, such as `high<open`; null when they agree. */
+  flag: string | null;
 }
 
 function decimalPlaces(value: number): number {
@@ -43,29 +76,63 @@ function isUtcMidnight(time: number): boolean {
   return new Date(time).toISOString().endsWith("T00:00:00.000Z");
 }
 
+function medianGap(times: readonly number[]): number | null {
+  const finite = times.filter(Number.isFinite).sort((left, right) => left - right);
+  const gaps = finite.slice(1).map((time, index) => time - finite[index]!).filter((gap) => gap > 0).sort((left, right) => left - right);
+  return gaps.length > 0 ? gaps[Math.floor((gaps.length - 1) / 2)]! : null;
+}
+
 /** Without a declared cadence, bar spacing decides: daily bars may be stamped at the session open. */
 function looksIntraday(times: readonly number[]): boolean {
-  const finite = times.filter(Number.isFinite).sort((left, right) => left - right);
+  const finite = times.filter(Number.isFinite);
   if (finite.length < 2) return finite.some((time) => !isUtcMidnight(time));
-  const gaps = finite.slice(1).map((time, index) => time - finite[index]!).filter((gap) => gap > 0).sort((left, right) => left - right);
-  return gaps.length > 0 && gaps[Math.floor((gaps.length - 1) / 2)]! < INTRADAY_MAX_GAP_MS;
+  const gap = medianGap(finite);
+  return gap != null && gap < INTRADAY_MAX_GAP_MS;
+}
+
+/** The bar size served: as the source declared it, otherwise read from the typical spacing of the bars. */
+function historyInterval(times: readonly number[], resolution: ManualChartResolution | null): ManualChartResolution | null {
+  if (resolution) return resolution;
+  const gap = medianGap(times);
+  if (gap == null) return null;
+  if (gap < INTRADAY_MAX_GAP_MS) {
+    return INTRADAY_RESOLUTIONS.reduce((best, candidate) => (
+      Math.abs(CHART_RESOLUTION_STEP_MS[candidate] - gap) < Math.abs(CHART_RESOLUTION_STEP_MS[best] - gap) ? candidate : best
+    ));
+  }
+  const days = gap / DAY_MS;
+  return days >= 25 ? "1mo" : days >= 6 ? "1wk" : "1d";
 }
 
-/** Intraday bars keep their UTC time; daily and longer bars are trading dates. */
-export function historyRows(points: readonly PricePoint[], resolution: ManualChartResolution | null): HistoryRow[] {
+/**
+ * Intraday bars keep their UTC time; daily and longer bars are trading dates.
+ * A bar whose prices contradict each other is blanked exactly as HP blanks it,
+ * and says why in `flag`.
+ */
+export function historyRows(
+  points: readonly PricePoint[],
+  resolution: ManualChartResolution | null,
+  currency: string | null = null,
+): HistoryRow[] {
   const times = points.map(getPricePointTimestamp);
   const intraday = resolution ? isIntradayResolution(resolution) : looksIntraday(times);
+  const interval = historyInterval(times, resolution);
   return points.map((point, index) => {
     const time = times[index]!;
     const iso = Number.isFinite(time) ? new Date(time).toISOString() : "";
-    const price = (value: number | undefined) => value == null ? null : cleanFloat32Price(value);
+    const values = pricePointValues(point);
+    const flags = pricePointIntegrityFlags(point);
+    const price = (value: number | null) => value == null ? null : cleanFloat32Price(value);
     return {
       date: intraday ? iso.replace(".000Z", "Z") : iso.slice(0, 10),
-      open: price(point.open),
-      high: price(point.high),
-      low: price(point.low),
-      close: cleanFloat32Price(point.close),
-      volume: point.volume ?? null,
+      open: price(values.open),
+      high: price(values.high),
+      low: price(values.low),
+      close: price(values.close),
+      volume: values.volume,
+      currency,
+      interval,
+      flag: flags.length > 0 ? flags.join(",") : null,
     };
   });
 }
@@ -84,7 +151,7 @@ function neededDecimals(value: number, cap: number): number {
  * one, the largest price sets a seven significant digit ceiling (BTC keeps
  * cents, FX keeps pips, sub-cent coins keep their digits). Cents at least above 1.
  */
-export function historyPriceDecimals(rows: readonly HistoryRow[], assetCategory?: string): number {
+export function historyPriceDecimals(rows: readonly Pick<HistoryRow, typeof PRICE_KEYS[number]>[], assetCategory?: string): number {
   const values = rows.flatMap((row) => PRICE_KEYS.flatMap((key) => {
     const value = row[key];
     return value != null && Number.isFinite(value) && value !== 0 ? [Math.abs(value)] : [];
@@ -100,3 +167,108 @@ export function historyPriceDecimals(rows: readonly HistoryRow[], assetCategory?
   const decimals = needed[Math.floor(0.9 * (needed.length - 1))]!;
   return largest >= 1 ? Math.max(2, decimals) : decimals;
 }
+
+/** How far back ALL reaches, in whole years, from the window a history request for it asks for. */
+export function historyAllRangeYears(now = new Date()): number {
+  return Math.round((now.getTime() - subtractTimeRange(now, "ALL").getTime()) / (365.25 * DAY_MS));
+}
+
+/** "1D 5-minute, 1W hourly, 1M to 1Y daily, 5Y weekly, ALL monthly", from the table history requests use. */
+export function historyIntervalsByRange(): string {
+  const groups: Array<{ ranges: TimeRange[]; resolution: ManualChartResolution }> = [];
+  for (const range of TIME_RANGES) {
+    const resolution = RANGE_HISTORY_RESOLUTION[range];
+    const last = groups.at(-1);
+    if (last?.resolution === resolution) last.ranges.push(range);
+    else groups.push({ ranges: [range], resolution });
+  }
+  return groups.map(({ ranges, resolution }) => (
+    `${ranges.length > 1 ? `${ranges[0]} to ${ranges.at(-1)}` : ranges[0]} ${BAR_INTERVAL_LABELS[resolution]}`
+  )).join(", ");
+}
+
+export interface HistoryUnit {
+  kind: "currency" | "pair" | "points" | "unknown";
+  /** Currency code of the prices; null for index points or when no source says. */
+  currency: string | null;
+  /** What one price is: "USD", "ILA (agorot, 1/100 ILS)", "ZAR per USD", "index points"; null when unknown. */
+  unit: string | null;
+}
+
+/**
+ * What the prices are in. An FX pair is named by its symbol (ZAR=X is ZAR per
+ * USD, EURUSD=X is USD per EUR), an index is in points, and anything else is
+ * in the currency its quote states, a sub-unit named as such. Without one the
+ * unit is unknown rather than guessed from the exchange.
+ */
+export function historyUnit(symbol: string, quote: { currency?: string; instrumentType?: string } | null | undefined): HistoryUnit {
+  const pair = /^([A-Z]{3})([A-Z]{3})?=X$/.exec(symbol.trim().toUpperCase());
+  if (pair) {
+    const [base, counter] = pair[2] ? [pair[1]!, pair[2]] : ["USD", pair[1]!];
+    return { kind: "pair", currency: counter, unit: `${counter} per ${base}` };
+  }
+  if (quote?.instrumentType?.trim().toUpperCase() === "INDEX") return { kind: "points", currency: null, unit: "index points" };
+  const code = quote?.currency?.trim();
+  return code
+    ? { kind: "currency", currency: code, unit: currencyUnitLabel(code, { ofMajor: true }) }
+    : { kind: "unknown", currency: null, unit: null };
+}
+
+function historyDate(value: string): string {
+  return value.length > 10 ? formatUtcTime(value) : value;
+}
+
+/** The facts line under a history heading: "Currency USD", "daily bars", "2025-10-09 to 2026-10-08", "251 bars". */
+export function historyFacts(unit: HistoryUnit, rows: readonly Pick<HistoryRow, "date" | "interval">[]): string[] {
+  const first = rows[0]?.date;
+  const last = rows.at(-1)?.date;
+  const interval = rows[0]?.interval;
+  return [
+    unit.kind === "pair" ? unit.unit! : unit.kind === "points" ? "Index points" : `Currency ${unit.unit ?? "unknown"}`,
+    interval ? `${BAR_INTERVAL_LABELS[interval]} bars` : "",
+    first && last ? (first === last ? historyDate(first) : `${historyDate(first)} to ${historyDate(last)}`) : "",
+    `${rows.length} ${rows.length === 1 ? "bar" : "bars"}`,
+  ].filter(Boolean);
+}
+
+/**
+ * What an export should know that its rows do not show: bars coarser than the
+ * range is served in, or a first bar well after the start asked for, as for a
+ * listing younger than the range. Weekends and holidays are within tolerance.
+ */
+export function historyNotes(
+  range: TimeRange,
+  interval: ManualChartResolution | null,
+  firstDate: string | undefined,
+  now = Date.now(),
+): string[] {
+  if (!firstDate) return [];
+  const notes: string[] = [];
+  const expected = RANGE_HISTORY_RESOLUTION[range];
+  if (interval && CHART_RESOLUTION_STEP_MS[interval] > CHART_RESOLUTION_STEP_MS[expected]) {
+    const from = interval === "1mo" ? firstDate.slice(0, 7) : firstDate.slice(0, 10);
+    notes.push(`Asked ${range}, got ${BAR_INTERVAL_LABELS[interval]} bars from ${from}`);
+  }
+  const first = Date.parse(firstDate);
+  if (range !== "ALL" && Number.isFinite(first)) {
+    const tolerance = Math.max(LATE_START_MIN_MS, LATE_START_MIN_BARS * CHART_RESOLUTION_STEP_MS[interval ?? expected]);
+    if (first - subtractTimeRange(new Date(now), range).getTime() > tolerance) {
+      notes.push(`Asked ${range}, data starts ${firstDate.slice(0, 10)} (first available bar)`);
+    }
+  }
+  return notes;
+}
+
+/** "37 of 251 bars have high below open or close in the source data; ...", or null when every bar agrees. */
+export function historyFlagNote(rows: readonly Pick<HistoryRow, "flag">[]): string | null {
+  const flagged = rows.filter((row) => row.flag);
+  if (flagged.length === 0) return null;
+  const codes = new Set(flagged.flatMap((row) => row.flag!.split(",")));
+  const kinds = [
+    codes.has("high<open") || codes.has("high<close") ? "high below open or close" : "",
+    codes.has("low>open") || codes.has("low>close") ? "low above open or close" : "",
+    codes.has("low>high") ? "low above high" : "",
+  ].filter(Boolean);
+  const count = `${flagged.length} of ${rows.length} ${flagged.length === 1 && rows.length === 1 ? "bar" : "bars"}`;
+  return `${count} ${flagged.length === 1 ? "has" : "have"} ${kinds.join(", or ")} in the source data; their prices are left blank`;
+}

package/src/cli/index.ts

@@ -16,13 +16,17 @@ import {
   renderCliHelp,
   renderCommandHelp,
   suggestCliCommand,
+  TABLE_SECTION_OPTION,
   type CliHelpEntry,
 } from "./help";
 import { parsePaneFunctionArgs } from "./pane-functions/options";
+import { checkCliCommandOptions } from "./command-options";
 import { fail, inferCliErrorOptions, printCliError } from "./errors";
 import { setCliColorEnabledOverride } from "../utils/cli-output";
 import { search, searchCandidatesForCli, buildSearchReport } from "./commands/search";
 import { ticker } from "./commands/ticker";
+import { requireOneArg, takeOption } from "./commands/command-utils";
+import { EXCHANGE_OPTION } from "./listing-arg";
 import { apiCliCommand } from "./commands/api";
 import { marketDataCliCommands } from "./commands/market";
 import { overviewCliCommands } from "./commands/overview";
@@ -99,14 +103,15 @@ function createCoreCliCommands(
       help: {
         group: CLI_COMMAND_GROUPS.research,
         usage: ["ticker <symbol>"],
-        examples: ["ticker AAPL", "ticker 7203.T", "ticker AAPL --json"],
+        options: [EXCHANGE_OPTION],
+        examples: ["ticker AAPL", "ticker SAN:EPA", "ticker 7203.T", "ticker AAPL --json"],
       },
-      execute: async (args, ctx) => {
-        const symbol = args[0];
-        if (!symbol) {
-          ctx.fail("Usage: gloomberb ticker <symbol>");
-        }
-        await ticker(symbol!, {
+      execute: async (rawArgs, ctx) => {
+        const args = [...rawArgs];
+        const exchange = takeOption(args, "--exchange");
+        const symbol = requireOneArg(args, "ticker <symbol>", "symbol", ctx);
+        await ticker(symbol, {
+          exchange,
           initMarketData: ctx.initMarketData,
           fail: ctx.fail,
           ...(ctx.cliOptions.format === "text" ? {} : { printResult: ctx.printResult }),
@@ -122,7 +127,7 @@ function createCoreCliCommands(
         usage: ["catalog [query] [--all] [--bot-safe]"],
         options: [
           { flags: "--all", description: "List every match instead of the first 25" },
-          { flags: "--bot-safe", description: "Only functions with a verified unattended report" },
+          { flags: "--bot-safe, --botsafe", description: "Only functions with a verified unattended report" },
         ],
         examples: ["catalog", "catalog options", "catalog HP"],
       },
@@ -140,10 +145,17 @@ function createCoreCliCommands(
         options: [
           { flags: "--<option> <value>", description: "A function setting; gloomberb catalog <function> lists them" },
           { flags: "--require-bot-safe", description: "Fail unless the function has a verified, complete report" },
+          {
+            ...TABLE_SECTION_OPTION,
+            description: `${TABLE_SECTION_OPTION.description} (CALLS keeps --section for the transcript part)`,
+          },
+          EXCHANGE_OPTION,
         ],
         examples: [
           "fn HP AAPL",
+          "fn ANR SAN:EPA",
           "fn CBR --json",
+          "fn WEI --csv --section europe > europe.csv",
           "fn 13F AAPL --view=ticker-holdings",
           "fn OVME --spot 100 --strike 100 --days 30 --volatility 25",
         ],
@@ -168,9 +180,11 @@ function createCoreCliCommands(
           { flags: "--scale <n>", description: "Text scale from 0.5 to 4 (default 1)" },
           { flags: "--watermark <label>", description: "Label drawn in the pane title bar" },
           { flags: "--<option> <value>", description: "A function setting; gloomberb catalog <function> lists them" },
+          EXCHANGE_OPTION,
         ],
         examples: [
           "shot TAS AAPL --output tape.png",
+          "shot HP BHP:ASX",
           "shot DDIS MSFT --tab history",
           "shot HP NVDA --width 1600 --theme green",
         ],
@@ -344,6 +358,7 @@ export async function dispatchCli(args: string[], options: DispatchCliOptions =
   const target = helpOnly ? registry.lookup.get("help")! : resolved;
   const commandArgs = helpOnly ? [resolved.command.name] : parsed.args.slice(1);
   try {
+    if (!helpOnly && resolved.builtin) checkCliCommandOptions(resolved.command, commandArgs, parsed.literalStart - 1);
     const result = await target.command.execute(
       commandArgs,
       createCliCommandContext(target.ownerId, registry, parsed.options),