gloomberb 0.18.3 → 0.18.4

package/src/plugins/builtin/analytics/risk-book.ts

@@ -0,0 +1,215 @@
+import type { Portfolio } from "../../../types/ticker";
+import type { BrokerAccount } from "../../../types/trading";
+import { resolvePortfolioCash } from "../../../portfolio/allocation";
+import { resolveCurrencyUnit } from "../../../utils/currency-units";
+import { canonicalExchange, normalizeSymbol } from "../../../utils/exchanges";
+
+/**
+ * The whole book beside the equity basket: the cash it holds by currency, and
+ * the stress shocks that reprice every line of it (holdings and cash) through
+ * its currency or its own price, rather than through a basket regression.
+ */
+
+/** One currency of the cash a portfolio holds beside its positions. */
+export interface RiskCashLine {
+  currency: string;
+  /** In `currency`; negative for a balance owed. */
+  amount: number;
+}
+
+const ISO_CURRENCY = /^[A-Z]{3}$/;
+
+/**
+ * The portfolio's cash by currency: the broker account's own balances when it
+ * reports them per currency, else its total cash (in the portfolio's currency
+ * when the account names none), else the amount entered with `portfolio cash set`.
+ */
+export function riskCashLines(
+  portfolio: Pick<Portfolio, "cash" | "currency">,
+  account: Pick<BrokerAccount, "cashBalances" | "totalCashValue" | "currency"> | null | undefined,
+): RiskCashLine[] {
+  const byCurrency = new Map<string, number>();
+  for (const balance of account?.cashBalances ?? []) {
+    const currency = balance.currency?.trim().toUpperCase() ?? "";
+    // A broker's summary row (IBKR's BASE) is no currency of its own.
+    if (!ISO_CURRENCY.test(currency) || !Number.isFinite(balance.quantity) || Math.abs(balance.quantity) < 1e-9) continue;
+    byCurrency.set(currency, (byCurrency.get(currency) ?? 0) + balance.quantity);
+  }
+  if (byCurrency.size) return [...byCurrency].map(([currency, amount]) => ({ currency, amount }));
+  const line = resolvePortfolioCash(portfolio, account);
+  const currency = (line?.currency.trim() || portfolio.currency || "").toUpperCase();
+  return line && ISO_CURRENCY.test(currency) && Number.isFinite(line.amount) && line.amount !== 0
+    ? [{ currency, amount: line.amount }]
+    : [];
+}
+
+/** A currency's move against USD, in percent of its USD value: TRY -20 is the lira 20% weaker. */
+export interface RiskFxShift {
+  currency: string;
+  percent: number;
+}
+/** A holding's own price move, in percent, in its listing currency. */
+export interface RiskAssetShift {
+  symbol: string;
+  exchange?: string;
+  percent: number;
+}
+
+/** The moves a shock takes, in percent: a fall to nothing is no scenario, a rise past six times is no stress. */
+export const RISK_SHOCK_LIMITS = { minimum: -99, maximum: 500 } as const;
+
+/** `-20%` and `+10%` as a shock names its move. */
+const signedPercent = (percent: number) => `${percent > 0 ? "+" : ""}${percent}%`;
+
+/** The commas that separate shocks: not a decimal comma between two digits (`TRY -2,5`). */
+const SHOCK_SEPARATOR = /(?<!\d),|,(?!\d)/;
+
+/** `TRY -20, EUR 5`: each item a name and a percent, or why one is not. */
+function shockItems(text: string, flag: string, what: string, example: string): Array<{ name: string; percent: number }> {
+  const items = text.split(SHOCK_SEPARATOR).map((item) => item.trim()).filter(Boolean);
+  if (!items.length) throw new Error(`${flag} takes ${what} and a percent, such as ${example}.`);
+  return items.map((item) => {
+    const match = /^(\S+)\s+([-+]?\d+(?:[.,]\d+)?)\s*%?$/.exec(item);
+    if (!match) throw new Error(`${flag} takes ${what} and a percent, such as ${example}; got "${item}".`);
+    const percent = Number(match[2]!.replace(",", "."));
+    if (percent < RISK_SHOCK_LIMITS.minimum || percent > RISK_SHOCK_LIMITS.maximum)
+      throw new Error(`${flag} moves by ${RISK_SHOCK_LIMITS.minimum}% to +${RISK_SHOCK_LIMITS.maximum}%; got ${match[2]} for ${match[1]}.`);
+    return { name: match[1]!, percent };
+  });
+}
+
+/** `--fx-shift TRY -20, EUR 5`, read; throws naming what is wrong. */
+export function parseFxShifts(text: string, flag = "--fx-shift"): RiskFxShift[] {
+  const shifts = shockItems(text, flag, "a currency", "TRY -20").map(({ name, percent }) => {
+    const currency = name.toUpperCase();
+    if (!ISO_CURRENCY.test(currency)) throw new Error(`${flag} takes a three-letter currency code such as TRY or EUR; got "${name}".`);
+    if (currency === "USD")
+      throw new Error(`${flag} moves a currency against USD, so USD itself does not shift: a stronger dollar is the other currency falling (TRY -20).`);
+    return { currency, percent };
+  });
+  const twice = shifts.find((shift, index) => shifts.findIndex((other) => other.currency === shift.currency) !== index);
+  if (twice) throw new Error(`${flag} names ${twice.currency} twice.`);
+  return shifts;
+}
+
+/** `--asset-shift GLD 10, BTC-USD -30`, read; throws naming what is wrong. */
+export function parseAssetShifts(text: string, flag = "--asset-shift"): RiskAssetShift[] {
+  const shifts = shockItems(text, flag, "a holding", "GLD 10").map(({ name, percent }) => {
+    if (!/^[A-Za-z0-9^][A-Za-z0-9.=^&/-]{0,23}(?::[A-Za-z0-9.]{1,12})?$/.test(name))
+      throw new Error(`${flag} takes a holding's symbol, such as GLD or BTC-USD; got "${name}".`);
+    const [symbol, exchange] = name.toUpperCase().split(":");
+    return { symbol: symbol!, ...(exchange ? { exchange } : {}), percent };
+  });
+  const key = (shift: RiskAssetShift) => `${shift.symbol}:${shift.exchange ?? ""}`;
+  const twice = shifts.find((shift, index) => shifts.findIndex((other) => key(other) === key(shift)) !== index);
+  if (twice) throw new Error(`${flag} names ${twice.symbol} twice.`);
+  return shifts;
+}
+
+/** The canonical text of shocks, as an option keeps it (`TRY -20, EUR 5`). */
+export function formatShocks(shifts: readonly (RiskFxShift | RiskAssetShift)[]): string {
+  return shifts.map((shift) => {
+    const name = "currency" in shift ? shift.currency : `${shift.symbol}${shift.exchange ? `:${shift.exchange}` : ""}`;
+    return `${name} ${shift.percent}`;
+  }).join(", ");
+}
+
+/** One line of the book to reprice: a holding or a currency's cash. */
+export interface RiskBookLine {
+  id: string;
+  label: string;
+  /** The currency its value moves with against USD: a listing's own (GBP for pence), or the cash's. */
+  currency: string;
+  /** Signed value in the account currency; null when nothing values it. */
+  value: number | null;
+  /** The listing an asset shift names; null for cash. */
+  listing: { symbol: string; exchange: string } | null;
+}
+interface RiskRepricedLine {
+  id: string;
+  label: string;
+  /** The shocks that move it, as named: "TRY -20% vs USD", "BTC-USD -30%". */
+  shocks: string[];
+  before: number | null;
+  after: number | null;
+  change: number | null;
+  /** Change in percent of the line's own gross value. */
+  percent: number | null;
+}
+/** Every given shock applied at once, each line of the book repriced at its own currency and price. */
+export interface RiskRepricing {
+  /** "TRY -20% vs USD, BTC-USD -30%". */
+  scenario: string;
+  /** Lines a shock moves, largest change first; lines without a value last. */
+  lines: RiskRepricedLine[];
+  /** The book's net value before the shocks, cash included, in the account currency. */
+  bookValue: number;
+  change: number;
+  /** Change in percent of `bookValue`; null when the book is worth nothing net. */
+  percent: number | null;
+  /** Lines a shock moves that have no value, so are not in the change. */
+  unvalued: string[];
+  /** Shocks nothing in the book moves with: a currency it holds nothing in, a holding it does not hold. */
+  unmatched: Array<{ kind: "currency" | "holding"; name: string }>;
+}
+
+const fxName = (shift: RiskFxShift) => `${shift.currency} ${signedPercent(shift.percent)} vs USD`;
+const assetName = (shift: RiskAssetShift) => `${shift.symbol}${shift.exchange ? `:${shift.exchange}` : ""} ${signedPercent(shift.percent)}`;
+
+/**
+ * Reprices every line of the book under the shocks at once. A line's value in
+ * the account currency is its USD value over the USD price of one account
+ * unit, so a currency's move changes it by (1 + its currency's move) and (for
+ * a listing a shock names) (1 + its own move), over (1 + the account
+ * currency's move): TRY -20 takes a fifth off lira cash in a USD account, and
+ * adds a quarter to a USD holding in a lira account. Null without a shock.
+ */
+export function repriceBook(
+  lines: readonly RiskBookLine[],
+  accountCurrency: string,
+  fx: readonly RiskFxShift[] = [],
+  assets: readonly RiskAssetShift[] = [],
+): RiskRepricing | null {
+  if (!fx.length && !assets.length) return null;
+  const currencyOf = (currency: string) => resolveCurrencyUnit(currency).currency || "USD";
+  const account = currencyOf(accountCurrency);
+  const fxShift = new Map(fx.map((shift) => [shift.currency, shift]));
+  const matches = (shift: RiskAssetShift, line: RiskBookLine) =>
+    !!line.listing && normalizeSymbol(line.listing.symbol) === normalizeSymbol(shift.symbol)
+    && (!shift.exchange || canonicalExchange(line.listing.exchange) === canonicalExchange(shift.exchange));
+  const moved = new Set<string>();
+  const repriced = lines.flatMap((line): RiskRepricedLine[] => {
+    const own = currencyOf(line.currency);
+    const ownShift = own === account ? undefined : fxShift.get(own);
+    const accountShift = own === account ? undefined : fxShift.get(account);
+    const asset = assets.find((shift) => matches(shift, line));
+    const factor = (1 + (ownShift?.percent ?? 0) / 100) * (1 + (asset?.percent ?? 0) / 100) / (1 + (accountShift?.percent ?? 0) / 100);
+    if (Math.abs(factor - 1) < 1e-12) return [];
+    for (const shift of [ownShift, accountShift]) if (shift) moved.add(shift.currency);
+    if (asset) moved.add(assetName(asset));
+    const shocks = [...(ownShift ? [fxName(ownShift)] : []), ...(accountShift ? [fxName(accountShift)] : []), ...(asset ? [assetName(asset)] : [])];
+    if (line.value == null)
+      return [{ id: line.id, label: line.label, shocks, before: null, after: null, change: null, percent: null }];
+    const after = line.value * factor;
+    return [{
+      id: line.id, label: line.label, shocks, before: line.value, after, change: after - line.value,
+      percent: line.value === 0 ? 0 : ((after - line.value) / Math.abs(line.value)) * 100,
+    }];
+  }).sort((left, right) => (left.change == null ? 1 : 0) - (right.change == null ? 1 : 0)
+    || Math.abs(right.change ?? 0) - Math.abs(left.change ?? 0));
+  const bookValue = lines.reduce((sum, line) => sum + (line.value ?? 0), 0);
+  const change = repriced.reduce((sum, line) => sum + (line.change ?? 0), 0);
+  return {
+    scenario: [...fx.map(fxName), ...assets.map(assetName)].join(", "),
+    lines: repriced,
+    bookValue,
+    change,
+    percent: bookValue > 0 ? (change / bookValue) * 100 : null,
+    unvalued: repriced.filter((line) => line.change == null).map((line) => line.label),
+    unmatched: [
+      ...fx.filter((shift) => !moved.has(shift.currency)).map((shift) => ({ kind: "currency" as const, name: shift.currency })),
+      ...assets.filter((shift) => !moved.has(assetName(shift)))
+        .map((shift) => ({ kind: "holding" as const, name: `${shift.symbol}${shift.exchange ? `:${shift.exchange}` : ""}` })),
+    ],
+  };
+}

package/src/plugins/builtin/analytics/risk-client.ts

@@ -68,7 +68,7 @@ export interface RiskMarketSnapshot {
   fetchedAt: string;
   warnings: string[];
   brokerOptions?: import("./risk-options").PortfolioOptionBook;
-  /** USD per unit of the account currency and of each listing or position currency of the holdings, at load time. */
+  /** USD per unit of the account currency, of each listing or position currency of the holdings and of each currency of cash, at load time. */
   fxRates?: Record<string, number>;
   /** For an account not in USD: the daily closes its returns convert at, or why they cannot. */
   accountFx?: AccountFx;
@@ -321,7 +321,8 @@ const largestFirst = (
  * USD. Holdings with no FX pair, positions the caller marks unsupported and
  * holdings past the limit get no history request; their entry says why. An
  * account in another currency than USD also loads that currency's current
- * rate and daily FX history, which the model converts every return with. The
+ * rate and daily FX history, which the model converts every return with, and
+ * each currency of the book's cash its current rate, which values it. The
  * signal stops the fetch: no request starts once it
  * aborts, the ones in flight are cancelled, and the call rejects instead of
  * returning a partial snapshot nobody is waiting for.
@@ -332,6 +333,7 @@ export async function fetchPortfolioRiskMarket(
   now = new Date(),
   signal?: AbortSignal,
   accountCurrency = "USD",
+  cashCurrencies: readonly string[] = [],
 ): Promise<RiskMarketSnapshot> {
   signal?.throwIfAborted();
   const normalized = (row: RiskInstrument): RiskInstrument => ({
@@ -435,6 +437,9 @@ export async function fetchPortfolioRiskMarket(
           listings.get(row.id)?.currency ?? (quotes.has(row.id) ? null : row.request.currency),
         ).currency;
         return currency && currency !== "USD" ? [currency] : [];
+      }), ...cashCurrencies.flatMap((code) => {
+        const currency = resolveCurrencyUnit(code).currency;
+        return currency && currency !== "USD" ? [currency] : [];
       })],
     ),
   ].slice(0, MAX_FX_CURRENCIES);
@@ -663,23 +668,25 @@ export async function fetchPortfolioRiskMarket(
  * What changes the requests: identity, size, whether a holding can enter the
  * basket, and an account currency other than USD (whose daily FX the load adds).
  */
-const cacheKey = (holdings: readonly RiskHoldingRequest[], accountCurrency: string) =>
+const cacheKey = (holdings: readonly RiskHoldingRequest[], accountCurrency: string, cashCurrencies: readonly string[]) =>
   [
     ...new Set(
       holdings.map(
         (row) => `${riskInstrumentId(row)}|${row.quantity ?? ""}|${row.currency ?? ""}|${row.unsupported ? 1 : 0}`,
       ),
     ),
-  ].sort().join(",") + (accountCurrency === "USD" ? "" : `@${accountCurrency}`);
+  ].sort().join(",") + (accountCurrency === "USD" ? "" : `@${accountCurrency}`)
+  + (cashCurrencies.length ? `+${[...new Set(cashCurrencies)].sort().join(",")}` : "");
 export async function loadPortfolioRiskMarket(
   holdings: readonly RiskHoldingRequest[],
   force = false,
   accountCurrency = "USD",
+  cashCurrencies: readonly string[] = [],
 ) {
   const { payload, stale, refreshError } = await loadCloudResource(
     portfolioRiskCache,
-    cacheKey(holdings, accountCurrency),
-    () => fetchPortfolioRiskMarket(holdings, undefined, undefined, undefined, accountCurrency),
+    cacheKey(holdings, accountCurrency, cashCurrencies),
+    () => fetchPortfolioRiskMarket(holdings, undefined, undefined, undefined, accountCurrency, cashCurrencies),
     { force },
   );
   return {

package/src/plugins/builtin/analytics/risk-headless.ts

@@ -3,15 +3,17 @@ import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchPortfolioRiskMarket, RISK_HISTORY_LIMIT } from "./risk-client";
 import { parsePortfolioRiskEvidence } from "./risk-evidence";
 import { describeCollections } from "../../../portfolio/collection-name";
+import { formatShocks, parseAssetShifts, parseFxShifts, riskCashLines } from "./risk-book";
 import {
   BASKET_VIEWS,
+  BOOK_TOTAL_ROW_ID,
   buildPortfolioRisk,
   portfolioRiskRequests,
   portfolioRiskTickers,
+  riskCoverageLine,
   riskCoverageNotices,
   riskCoverageShortfall,
-  riskCoverageText,
-  riskExclusionText,
+  riskHoldingsLeftOut,
   RISK_VIEWS,
   riskEvidence,
   riskPercentile,
@@ -53,16 +55,17 @@ const COMPACT_PAIR_LIMIT = 25;
 
 /**
  * Formatted like the pane; metadata.model keeps full precision. A tail loss in
- * money is of the covered basket, so its evidence names what the basket leaves
- * out, as the pane's footer does beside the same figure.
+ * money is of the covered basket, so its evidence names how it is estimated,
+ * the basket's share of the book and what it leaves out, as the pane's footer
+ * does beside the same figure.
  */
-function displayRow(row: RiskDisplayRow, exclusion: string | null) {
+function displayRow(row: RiskDisplayRow) {
   return {
     label: row.label,
     value: riskValue(row),
     percentile: riskPercentile(row),
     asOf: row.asOf?.slice(0, 10) ?? null,
-    detail: exclusion && row.amount != null ? `${riskEvidence(row)}; ${exclusion}` : riskEvidence(row),
+    detail: riskEvidence(row),
     ...(row.amount != null ? { amount: row.amount, currency: row.amountCurrency ?? null } : {}),
   };
 }
@@ -77,19 +80,22 @@ const COMPACT_LEFT_OUT_LIMIT = 40;
 /** What the basket views cover, so a report never reads as the whole account when it is not. */
 function coverageSummary(coverage: RiskCoverage, limit = Infinity) {
   return {
+    // Of the book, cash included; the minimum is of the holdings' value.
     share: coverage.share,
     shareIsUpperBound: coverage.unvalued > 0,
+    holdingsShare: coverage.holdingsShare ?? coverage.share,
     minimumShare: coverage.minimumShare,
     estimated: coverage.sufficient,
     currency: coverage.currency,
     marketValue: coverage.marketValue,
+    cashValue: coverage.cashValue ?? 0,
     coveredValue: coverage.coveredValue,
     holdings: coverage.holdings,
     covered: coverage.covered,
     convertedFromLocalCurrency: coverage.converted,
     leftOut: coverage.leftOut
       .slice(0, limit)
-      .map((row) => ({ symbol: row.symbol, reason: row.reason, share: row.share })),
+      .map((row) => ({ symbol: row.symbol, reason: row.reason, share: row.share, ...(row.cash ? { cash: true } : {}) })),
     ...(coverage.leftOut.length > limit ? { moreLeftOut: coverage.leftOut.length - limit } : {}),
   };
 }
@@ -99,9 +105,8 @@ function coverageLine(coverage: RiskCoverage | undefined): { error?: string; not
   const shortfall = riskCoverageShortfall(coverage);
   // No estimate at all is a failure; an estimate that leaves holdings out is a caveat.
   if (shortfall) return { error: `Basket estimates unavailable: ${shortfall.title} ${shortfall.message}`.trim() };
-  return coverage?.leftOut.length
-    ? { note: `Basket ${riskCoverageText(coverage)}; metadata.coverage lists each with its reason.` }
-    : {};
+  const line = coverage?.leftOut.length ? riskCoverageLine(coverage) : null;
+  return line ? { note: `${line[0]!.toUpperCase()}${line.slice(1)}; metadata.coverage lists each with its reason.` } : {};
 }
 
 /** One view, its strongest or first rows, and the portfolio's totals instead of the model. */
@@ -120,15 +125,18 @@ function compactRiskRows(model: PortfolioRiskModel, view: RiskView): { rows: Ris
     };
   }
   if (all.length <= COMPACT_ROW_LIMIT) return { rows: all, notices: [] };
+  // The book's total of the shocks is what they come to: the lines go before it does.
+  const total = all.filter((row) => row.id === BOOK_TOTAL_ROW_ID);
+  const rows = [...all.filter((row) => row.id !== BOOK_TOTAL_ROW_ID).slice(0, COMPACT_ROW_LIMIT - total.length), ...total];
   return {
-    rows: all.slice(0, COMPACT_ROW_LIMIT),
-    notices: [`${all.length - COMPACT_ROW_LIMIT} more ${view} rows not shown.`],
+    rows,
+    notices: [`${all.length - rows.length} more ${view} rows not shown.`],
   };
 }
 
 export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
-  freshness: { source: "Local portfolio and Gloom Cloud", status: "not-a-feed", basis: "risk model on daily closes" },
+  freshness: { source: "Local portfolio and Gloom Cloud", status: "not-a-feed", basis: "daily closes" },
   argument: {
     kind: "free-text",
     optional: true,
@@ -143,8 +151,9 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       "Explicit local evidence for account returns and attribution",
     ],
     limitations: [
-      `Fixed-current-weight equity basket over the holdings that qualify, largest ${RISK_HISTORY_LIMIT} by value, in the account's currency; foreign listings convert to USD at daily FX closes, and a non-USD account's returns then convert into its currency at its own daily FX closes; metadata.coverage states the covered share of market value and each holding left out.`,
+      `Fixed-current-weight equity basket over the holdings that qualify, largest ${RISK_HISTORY_LIMIT} by value, in the account's currency; foreign listings convert to USD at daily FX closes, and a non-USD account's returns then convert into its currency at its own daily FX closes; metadata.coverage states the covered share of the book (cash included) and each holding and currency's cash left out.`,
       "--since filed buys the 13F's own weights at the filing-date close and holds them (--weights current holds today's weights fixed instead).",
+      "--fx-shift and --asset-shift reprice every holding and the cash at once; the index, 10Y and VIX shifts are separate basket regressions.",
       "No account performance inferred.",
       "ETF price-return factor proxies.",
       "Historical percentiles need 20 rolling samples.",
@@ -204,6 +213,27 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       maximum: 100,
       description: "Independent VIX shock in index points (10 when left out).",
     },
+    {
+      key: "fx-shift",
+      type: "string",
+      settingKey: "fxShift",
+      valueWords: 2,
+      placeholder: "CCY pct",
+      example: "--fx-shift TRY -20",
+      // "TRY -20" read as the lira's move against USD, not USD's against the lira.
+      description: "A currency's move against USD in percent: TRY -20 is the lira 20% weaker. Reprices every holding and the cash in that currency, and in a lira account every other line against it. Several separated by commas: TRY -20, EUR 5.",
+      normalize: (value) => formatShocks(parseFxShifts(value)),
+    },
+    {
+      key: "asset-shift",
+      type: "string",
+      settingKey: "assetShift",
+      valueWords: 2,
+      placeholder: "SYMBOL pct",
+      example: "--asset-shift BTC-USD -30",
+      description: "A holding's own price move in percent, in its listing currency: GLD 10, BTC-USD -30. Applied with --fx-shift as one scenario. Several separated by commas.",
+      normalize: (value) => formatShocks(parseAssetShifts(value)),
+    },
   ],
   // The portfolio as configured, so `Family`, `family` and `FAMILY` head the report alike.
   describe: (args, result) =>
@@ -217,6 +247,8 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
     if (!local) throw new Error(unknownPortfolio(requested, ctx.config.portfolios));
     const id = local.portfolio.id;
     const tickers = portfolioRiskTickers(local.tickers, id);
+    // The cash beside the holdings: the broker account's by currency, else the portfolio's own.
+    const cash = riskCashLines(local.portfolio, local.account);
     const evidence = parsePortfolioRiskEvidence(
       String(args.options.evidence ?? ctx.settings?.riskEvidence ?? ""),
     );
@@ -248,6 +280,7 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
             new Date(),
             ctx.signal,
             local.portfolio.currency,
+            cash.map((line) => line.currency),
           ),
       localOnly
         ? Promise.resolve(undefined)
@@ -264,14 +297,17 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
         equity: Number(args.options["equity-shift"] ?? -10),
         rates: Number(args.options["rate-shift"] ?? 100),
         volatility: Number(args.options["vol-shift"] ?? 10),
+        fx: args.options["fx-shift"] ? parseFxShifts(String(args.options["fx-shift"])) : [],
+        assets: args.options["asset-shift"] ? parseAssetShifts(String(args.options["asset-shift"])) : [],
       },
       args.options.since === "filed"
         ? { since: "filed", weights: args.options.weights === "current" ? "current" : "13f" }
         : {},
+      cash,
     );
     // Options for views the report does not print are named, not dropped silently; the fallback from --since opens the report.
     const fallback = sinceFallbackNote(local.portfolio);
-    const shifted = ["equity-shift", "rate-shift", "vol-shift"].filter((key) => args.options[key] != null);
+    const shifted = ["equity-shift", "rate-shift", "vol-shift", "fx-shift", "asset-shift"].filter((key) => args.options[key] != null);
     // A non-USD account's returns were converted, and the basket views say into what.
     const returnsCurrency = riskReturnsCurrency(model);
     const notices = [
@@ -284,8 +320,8 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       ...(requestedView && args.options.since != null && requestedView !== "risk" ? [`--since changes the risk view only, not --view ${requestedView}`] : []),
       ...(args.options.weights != null && args.options.since !== "filed" ? ["--weights applies with --since filed only"] : []),
     ];
-    // A basket view is complete only when the basket covers every holding.
-    const covered = model.coverage.leftOut.length === 0;
+    // A basket view is complete only when the basket covers every holding; cash is never in it.
+    const covered = !riskHoldingsLeftOut(model.coverage);
     const complete =
       view === "performance"
         ? model.performance != null
@@ -300,7 +336,6 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
                 : model.complete;
     // A basket view with too little covered shows no estimate, and the report says why rather than leaving dashes.
     const shortfall = BASKET_VIEWS.has(view as RiskView) ? coverageLine(model.coverage).error : undefined;
-    const exclusion = riskExclusionText(model.coverage);
     return {
       complete,
       errors: [...(shortfall ? [shortfall] : []), ...model.warnings],
@@ -308,7 +343,7 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       sections: (requestedView ? [requestedView] : RISK_VIEWS).map((view) => ({
         title: view,
         columns: RISK_COLUMNS,
-        rows: model.rows[view].map((row) => displayRow(row, exclusion)),
+        rows: model.rows[view].map(displayRow),
       })),
       metadata: { coverage: coverageSummary(model.coverage), model, benchmark: model.benchmark, window: model.window, notices },
     };
@@ -321,7 +356,6 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
     // Each left-out holding is in metadata.coverage; the notes keep one line for all of them.
     const perHolding = new Set(riskCoverageNotices(model.coverage));
     const basketView = BASKET_VIEWS.has(view);
-    const exclusion = riskExclusionText(model.coverage);
     const coverage = basketView ? coverageLine(model.coverage) : {};
     const errors = [...new Set([...(coverage.error ? [coverage.error] : []), ...(result.errors ?? [])])];
     const notes = [...(coverage.note ? [coverage.note] : []), ...(result.notes ?? []).filter((note) => !perHolding.has(note))];
@@ -329,7 +363,7 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       complete: result.complete,
       ...(errors.length ? { errors } : {}),
       ...(notes.length ? { notes } : {}),
-      sections: [{ title: view, columns: RISK_COLUMNS, rows: rows.map((row) => displayRow(row, exclusion)) }],
+      sections: [{ title: view, columns: RISK_COLUMNS, rows: rows.map(displayRow) }],
       metadata: {
         portfolio: {
           id: model.portfolio.id,

package/src/plugins/builtin/analytics/risk-math.ts

@@ -46,13 +46,16 @@ function sampleVolatility(values: readonly number[]): number | null {
     ) * Math.sqrt(252)
   );
 }
+/** The confidence of the one-day VaR and expected shortfall, and the fewest daily returns they are read from. */
+export const RISK_TAIL_CONFIDENCE = 0.95;
+export const RISK_TAIL_MINIMUM = 60;
 /** Nearest-rank historical loss, without distribution or square-root horizon assumptions. */
 export function historicalTail(
   values: readonly number[],
-  confidence = 0.95,
+  confidence = RISK_TAIL_CONFIDENCE,
 ): { var: number; expectedShortfall: number } | null {
   if (
-    values.length < 60 ||
+    values.length < RISK_TAIL_MINIMUM ||
     confidence <= 0 ||
     confidence >= 1 ||
     values.some((value) => !Number.isFinite(value))
@@ -225,7 +228,7 @@ function basketRiskDefinitions(benchmark: string) {
     },
     {
       id: "var",
-      name: "1D VaR 95%",
+      name: `1D VaR ${Math.round(RISK_TAIL_CONFIDENCE * 100)}%`,
       value: (rows: RiskSamplePoint[]) => {
         const tail = historicalTail(rows.map((row) => row.value));
         return tail == null ? null : 100 * tail.var;