gloomberb 0.16.3 → 0.16.5

package/src/plugins/builtin/alerts/targets.ts

@@ -0,0 +1,92 @@
+import { useCallback } from "react";
+import type { PaneHint } from "../../../components";
+import type { PaneTemplateCreateOptions } from "../../../types/plugin";
+import { usePluginAppActions } from "../../runtime";
+import { RESEARCH_SEARCH_TEMPLATE_ID } from "../research-search/model";
+import { useOpenDescription } from "../shared/open-description";
+import { THIRTEENF_TEMPLATE_ID } from "../thirteenf/model";
+import type { EventAlertRule } from "./events";
+import type { AlertHistoryItem } from "./history";
+import { isResearchAlertKind, readResearchRule } from "./research-rules";
+import type { AlertRule } from "./types";
+
+/** What an alert follows, read the same way from a saved rule and from a delivered alert. */
+export interface AlertSubject {
+  kind: string;
+  symbol?: string;
+  exchange?: string;
+  marketId?: string;
+  /** A macro event rule's release: `cpi` or `fomc`. */
+  event?: string;
+  keyword?: string;
+  cik?: string;
+}
+
+/** A listing's DES, or a pane template and what it opens on. */
+export type AlertTarget =
+  | { kind: "description"; symbol: string; exchange?: string }
+  | { kind: "pane"; templateId: string; options?: PaneTemplateCreateOptions };
+
+const pane = (templateId: string, options?: PaneTemplateCreateOptions): AlertTarget =>
+  ({ kind: "pane", templateId, ...(options ? { options } : {}) });
+
+/**
+ * The one map from what an alert follows to what it opens, for every rule kind and every delivered alert:
+ * a perpetual opens PERP on its market; a dated event the pane its date comes from (ERN, CPI, WIRP); catalyst,
+ * Congress and 13F rules their calendar or list, on the company or fund they name; any other rule on a security
+ * that listing's DES. A rule on no security opens the pane it watches (SRCH for a news keyword, FLOW for flow
+ * on the user's lists, FIRST for breaking news). Null when there is nothing to open.
+ */
+export function alertTarget(subject: AlertSubject): AlertTarget | null {
+  const { kind, symbol } = subject;
+  switch (kind) {
+    case "perps_threshold": return subject.marketId ? pane("perps-pane", { arg: subject.marketId }) : null;
+    case "earnings_date":
+    case "earnings": return symbol ? pane("earnings-calendar-pane", { arg: symbol }) : null;
+    case "macro_event": return subject.event === "cpi" ? pane("cpi-pane") : subject.event === "fomc" ? pane("rate-path-pane") : null;
+    case "catalyst": return pane("catalysts-pane", symbol ? { symbol } : undefined);
+    case "congress_trade": return pane("congress-trades-pane");
+    case "thirteenf_filing": return pane(THIRTEENF_TEMPLATE_ID, subject.cik ? { arg: subject.cik } : undefined);
+    case "news_keyword": if (!symbol) return pane(RESEARCH_SEARCH_TEMPLATE_ID, subject.keyword ? { arg: subject.keyword } : undefined); break;
+    case "options_flow": if (!symbol) return pane("scanner-flow-pane"); break;
+    case "breaking_news": if (!symbol) return pane("news-breaking-pane"); break;
+  }
+  return symbol ? { kind: "description", symbol, ...(subject.exchange ? { exchange: subject.exchange } : {}) } : null;
+}
+
+/** A research rule's `US` is any US venue, which names no listing. */
+const venue = (exchange: string | undefined) => exchange && exchange !== "US" ? exchange : undefined;
+
+/** An Events rule: a ticker, a fund or a research rule's own fields. */
+export function eventRuleSubject(rule: EventAlertRule): AlertSubject {
+  if (isResearchAlertKind(rule.kind)) {
+    const config = readResearchRule(rule.kind, rule.value);
+    return { kind: rule.kind, symbol: config?.symbol, exchange: venue(config?.exchange), marketId: config?.marketId, event: config?.event, keyword: config?.keyword };
+  }
+  return { kind: rule.kind, ...(rule.target === "ticker" ? { symbol: rule.value } : rule.target === "fund" ? { cik: rule.value } : {}) };
+}
+
+export const priceRuleSubject = (alert: AlertRule): AlertSubject => ({ kind: "price", symbol: alert.symbol, exchange: alert.exchange });
+
+/** A delivered alert, from the fields its notification carries. */
+export function deliveredAlertSubject(item: AlertHistoryItem): AlertSubject {
+  const text = (key: string) => {
+    const value = item.data?.[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+  };
+  return { kind: item.kind, symbol: text("symbol"), exchange: venue(text("exchange")), marketId: text("marketId"), event: text("event"), keyword: text("keyword"), cik: text("cik") };
+}
+
+/** The `v` hint each alerts tab gives its selected row, when the row has something to open. */
+export const alertViewHints = (target: AlertTarget | null, open: (target: AlertTarget) => void): PaneHint[] =>
+  target ? [{ id: "view", key: "v", label: "iew", title: "View what it follows", onPress: () => open(target) }] : [];
+
+/** Opens an alert's target: a DES the way every pane's `d` does, any other pane from its template. */
+export function useOpenAlertTarget(): (target: AlertTarget) => void {
+  const openDescription = useOpenDescription();
+  const { createPaneFromTemplate } = usePluginAppActions();
+  return useCallback((target: AlertTarget) => {
+    if (target.kind === "description") openDescription(target.symbol, target.exchange);
+    else createPaneFromTemplate(target.templateId, target.options);
+  }, [createPaneFromTemplate, openDescription]);
+}

package/src/plugins/builtin/analytics/index.tsx

@@ -450,13 +450,15 @@ export const portfolioAnalyticsModule: PluginModule = {
       component: PortfolioAnalyticsPane,
       headless: portfolioRiskHeadless,
       tableExport: true,
-      settings: { fields: [
+      // The risk window reads as trailing until it is set.
+      settings: (context) => ({ values: { riskSince: context.settings.riskSince ?? "trailing" }, fields: [
         { key: "analyticsView", label: "View", type: "select", options: [{ value: "overview", label: "Overview" }, { value: "risk", label: "Risk depth" }] },
+        { key: "riskSince", label: "Risk window", type: "select", options: [{ value: "trailing", label: "Trailing 60 sessions" }, { value: "filed", label: "Since 13F filing" }] },
         { key: "riskEvidence", label: "Local evidence JSON", type: "text" },
         { key: "equityShift", label: "Index shift (%)", type: "text" },
         { key: "rateShift", label: "10Y shift (bp)", type: "text" },
         { key: "volShift", label: "VIX shift (points)", type: "text" },
-      ] },
+      ] }),
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 80, height: 30 },

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

@@ -11,8 +11,10 @@ import {
   riskCoverageShortfall,
   riskCoverageText,
   RISK_VIEWS,
+  riskEvidence,
   riskPercentile,
   riskValue,
+  sinceFallbackNote,
   type PortfolioRiskModel,
   type RiskCoverage,
   type RiskDisplayRow,
@@ -39,7 +41,8 @@ function displayRow(row: RiskDisplayRow) {
     value: riskValue(row),
     percentile: riskPercentile(row),
     asOf: row.asOf?.slice(0, 10) ?? null,
-    detail: row.detail,
+    detail: riskEvidence(row),
+    ...(row.amount != null ? { amount: row.amount, currency: row.amountCurrency ?? null } : {}),
   };
 }
 
@@ -130,9 +133,16 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       key: "view",
       type: "enum",
       settingKey: "riskView",
-      defaultValue: "risk",
+      // No default: left out, the report prints every view.
       values: RISK_VIEWS.map((value) => ({ value })),
-      description: "Portfolio risk view.",
+      description: "One portfolio risk view; every view when left out.",
+    },
+    {
+      key: "since",
+      type: "enum",
+      settingKey: "riskSince",
+      values: [{ value: "filed" }],
+      description: "Risk rows since the 13F filing date of a portfolio made with portfolio import --13f, instead of the trailing 60 sessions.",
     },
     {
       key: "evidence",
@@ -144,28 +154,25 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       key: "equity-shift",
       type: "integer",
       settingKey: "equityShift",
-      defaultValue: -10,
       minimum: -99,
       maximum: 100,
-      description: "Independent index shock in percent.",
+      description: "Independent index shock in percent (-10 when left out).",
     },
     {
       key: "rate-shift",
       type: "integer",
       settingKey: "rateShift",
-      defaultValue: 100,
       minimum: -500,
       maximum: 500,
-      description: "Independent 10Y yield shock in basis points.",
+      description: "Independent 10Y yield shock in basis points (100 when left out).",
     },
     {
       key: "vol-shift",
       type: "integer",
       settingKey: "volShift",
-      defaultValue: 10,
       minimum: -50,
       maximum: 100,
-      description: "Independent VIX shock in index points.",
+      description: "Independent VIX shock in index points (10 when left out).",
     },
   ],
   describe: (args) =>
@@ -191,7 +198,8 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       throw new Error(
         "Imported evidence belongs to a different portfolio or currency",
       );
-    const view = String(args.options.view ?? "risk");
+    const requestedView = isRiskView(args.options.view) ? args.options.view : null;
+    const view: string = requestedView ?? "risk";
     const localOnly =
       ["performance", "attribution", "greeks"].includes(view) &&
       evidence != null;
@@ -226,7 +234,17 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
         rates: Number(args.options["rate-shift"] ?? 100),
         volatility: Number(args.options["vol-shift"] ?? 10),
       },
+      args.options.since === "filed" ? { since: "filed" } : {},
     );
+    // 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 notices = [
+      ...(model.window.kind === "since-filed" ? [`Risk rows since the 13F filing on ${model.window.filed}, against ${model.benchmark}`] : []),
+      ...(args.options.since === "filed" && model.window.kind !== "since-filed" ? [fallback] : []),
+      ...(requestedView && requestedView !== "stress" && shifted.length ? [`${shifted.map((key) => `--${key}`).join(", ")} change${shifted.length === 1 ? "s" : ""} the stress view only, not --view ${requestedView}`] : []),
+      ...(requestedView && args.options.since != null && requestedView !== "risk" ? [`--since changes the risk view only, not --view ${requestedView}`] : []),
+    ];
     // A basket view is complete only when the basket covers every holding.
     const covered = model.coverage.leftOut.length === 0;
     const complete =
@@ -246,13 +264,13 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
     return {
       complete,
       errors: [...(shortfall ? [shortfall] : []), ...model.warnings],
-      notes: [...riskCoverageNotices(model.coverage), ...model.notes],
-      sections: RISK_VIEWS.map((view) => ({
+      notes: [...riskCoverageNotices(model.coverage), ...model.notes.filter((note) => note !== fallback)],
+      sections: (requestedView ? [requestedView] : RISK_VIEWS).map((view) => ({
         title: view,
         columns: RISK_COLUMNS,
         rows: model.rows[view].map(displayRow),
       })),
-      metadata: { coverage: coverageSummary(model.coverage), model },
+      metadata: { coverage: coverageSummary(model.coverage), model, benchmark: model.benchmark, window: model.window, notices },
     };
   },
   compact(result, args) {
@@ -278,6 +296,8 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
           currency: model.portfolio.currency,
         },
         view,
+        benchmark: model.benchmark,
+        window: model.window,
         ...(basketView && model.coverage
           ? { coverage: coverageSummary(model.coverage, COMPACT_LEFT_OUT_LIMIT) }
           : {}),

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

@@ -186,28 +186,24 @@ const percentile = (
   };
 };
 
-export function rollingBasketRisk(
-  sample: readonly RiskSamplePoint[],
-  window = RISK_WINDOW,
-): RiskStatistic[] {
-  if (!Number.isInteger(window) || window < 60)
-    throw new Error("Risk window must contain at least 60 daily sessions");
-  const definitions = [
+/** The return and risk statistics of a basket against its benchmark, over one window of paired sessions. */
+function basketRiskDefinitions(benchmark: string) {
+  return [
     {
       id: "return",
-      label: `${window}D basket return`,
+      name: "basket return",
       value: (rows: RiskSamplePoint[]) =>
         100 * compoundReturns(rows.map((row) => row.value)),
     },
     {
       id: "benchmark",
-      label: `${window}D benchmark return`,
+      name: `benchmark return (${benchmark})`,
       value: (rows: RiskSamplePoint[]) =>
         100 * compoundReturns(rows.map((row) => row.benchmark)),
     },
     {
       id: "active",
-      label: `${window}D active return`,
+      name: "active return",
       value: (rows: RiskSamplePoint[]) =>
         100 *
         (compoundReturns(rows.map((row) => row.value)) -
@@ -215,36 +211,56 @@ export function rollingBasketRisk(
     },
     {
       id: "volatility",
-      label: `${window}D annualized volatility`,
-      value: (rows: RiskSamplePoint[]) =>
-        100 * sampleVolatility(rows.map((row) => row.value))!,
+      name: "annualized volatility",
+      value: (rows: RiskSamplePoint[]) => {
+        const volatility = sampleVolatility(rows.map((row) => row.value));
+        return volatility == null ? null : 100 * volatility;
+      },
     },
     {
       id: "drawdown",
-      label: `${window}D max drawdown`,
+      name: "max drawdown",
       value: (rows: RiskSamplePoint[]) =>
         100 * Math.min(0, ...drawdownPath(rows.map((row) => row.value))),
     },
     {
       id: "var",
-      label: `1D VaR 95% (${window}D)`,
-      value: (rows: RiskSamplePoint[]) =>
-        100 * historicalTail(rows.map((row) => row.value))!.var,
+      name: "1D VaR 95%",
+      value: (rows: RiskSamplePoint[]) => {
+        const tail = historicalTail(rows.map((row) => row.value));
+        return tail == null ? null : 100 * tail.var;
+      },
     },
     {
       id: "es",
-      label: `1D expected shortfall (${window}D)`,
-      value: (rows: RiskSamplePoint[]) =>
-        100 * historicalTail(rows.map((row) => row.value))!.expectedShortfall,
+      name: "1D expected shortfall",
+      value: (rows: RiskSamplePoint[]) => {
+        const tail = historicalTail(rows.map((row) => row.value));
+        return tail == null ? null : 100 * tail.expectedShortfall;
+      },
     },
     {
       id: "tracking",
-      label: `${window}D tracking error`,
-      value: (rows: RiskSamplePoint[]) =>
-        100 * sampleVolatility(rows.map((row) => row.value - row.benchmark))!,
+      name: "tracking error",
+      value: (rows: RiskSamplePoint[]) => {
+        const volatility = sampleVolatility(rows.map((row) => row.value - row.benchmark));
+        return volatility == null ? null : 100 * volatility;
+      },
     },
   ];
-  return definitions.map((definition) => {
+}
+const TAIL_IDS = new Set(["var", "es"]);
+const finiteOrNull = (value: number | null) =>
+  value != null && Number.isFinite(value) ? value : null;
+
+export function rollingBasketRisk(
+  sample: readonly RiskSamplePoint[],
+  window = RISK_WINDOW,
+  benchmark = "SPY",
+): RiskStatistic[] {
+  if (!Number.isInteger(window) || window < 60)
+    throw new Error("Risk window must contain at least 60 daily sessions");
+  return basketRiskDefinitions(benchmark).map((definition) => {
     const history = sample.map((point, index) => {
       const rows = sample.slice(index - window + 1, index + 1);
       const contiguous =
@@ -252,10 +268,9 @@ export function rollingBasketRisk(
         rows.every(
           (row, i) => i === 0 || row.startDateKey === rows[i - 1]!.dateKey,
         );
-      const value = contiguous ? definition.value(rows) : null;
       return {
         date: point.dateKey,
-        value: value != null && Number.isFinite(value) ? value : null,
+        value: contiguous ? finiteOrNull(definition.value(rows)) : null,
       };
     });
     const latest = history.at(-1),
@@ -263,7 +278,9 @@ export function rollingBasketRisk(
       asOf = latest?.date ?? null;
     return {
       id: definition.id,
-      label: definition.label,
+      label: TAIL_IDS.has(definition.id)
+        ? `${definition.name} (${window}D)`
+        : `${window}D ${definition.name}`,
       value,
       unit: "%" as const,
       asOf,
@@ -276,6 +293,53 @@ export function rollingBasketRisk(
   });
 }
 
+/**
+ * The same statistics over every paired session since `since` (a 13F filing
+ * date), measured from the last close on or before it: the trailing
+ * contiguous run of sessions that end after that day. Each row's history is
+ * the statistic as of each session in the run; there is no rolling sample to
+ * rank it against, so it has no percentile. VaR and expected shortfall need
+ * 60 sessions.
+ */
+export function sinceBasketRisk(
+  sample: readonly RiskSamplePoint[],
+  since: string,
+  benchmark = "SPY",
+): RiskStatistic[] {
+  let first = sample.length;
+  while (
+    first > 0 &&
+    sample[first - 1]!.dateKey > since &&
+    (first === sample.length || sample[first]!.startDateKey === sample[first - 1]!.dateKey)
+  )
+    first -= 1;
+  const rows = sample.slice(first);
+  const start = rows[0]?.startDateKey ?? since;
+  const capitalized = (text: string) => `${text[0]!.toUpperCase()}${text.slice(1)}`;
+  return basketRiskDefinitions(benchmark).map((definition) => {
+    const history = rows.map((point, index) => ({
+      date: point.dateKey,
+      value: finiteOrNull(definition.value(rows.slice(0, index + 1))),
+    }));
+    const value = history.at(-1)?.value ?? null,
+      asOf = rows.at(-1)?.dateKey ?? null;
+    return {
+      id: definition.id,
+      label: TAIL_IDS.has(definition.id)
+        ? `${definition.name} (since ${start})`
+        : `${capitalized(definition.name)} since ${start}`,
+      value,
+      unit: "%" as const,
+      asOf,
+      startDate: rows.length ? start : null,
+      // The sessions in the window, also when too few for a value (a tail estimate needs 60).
+      samples: rows.length,
+      rank: { ...historyStatistics([], value, { asOf: asOf ?? since }), percentile: null, rank: null },
+      history,
+    };
+  });
+}
+
 export function rollingBeta(
   asset: readonly DatedReturn[],
   factor: readonly DatedReturn[],

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

@@ -1,11 +1,11 @@
 import { portfolioOptionGreeks } from "./risk-options";
 import type { Portfolio, TickerRecord } from "../../../types/ticker";
-import { formatNumber } from "../../../utils/format";
+import { formatCurrency, formatNumber } from "../../../utils/format";
 import { resolveCurrencyUnit } from "../../../utils/currency-units";
 import {
   getPortfolioPositionMetrics,
   resolvePortfolioMarketValue,
-} from "../portfolio-list/position-metrics";
+} from "../../../portfolio/position-metrics";
 import type { DatedReturn } from "./metrics";
 import {
   computeWeightedPortfolioReturns,
@@ -17,6 +17,7 @@ import {
   regressReturns,
   rollingBasketRisk,
   rollingBeta,
+  sinceBasketRisk,
   subtractReturns,
 } from "./risk-math";
 import {
@@ -97,7 +98,13 @@ export interface RiskDisplayRow {
   interaction?: number;
   /** Holdings rows only: why the holding is outside the covered basket. */
   leftOut?: string;
+  /** VaR and expected shortfall only: the loss `value` is on the covered basket's current value (`amountBase`), in `amountCurrency`. */
+  amount?: number;
+  amountCurrency?: string;
+  amountBase?: number;
 }
+/** The tail-loss rows, which also read in money on the covered basket. */
+const TAIL_ROW_IDS: ReadonlySet<string> = new Set(["var", "es"]);
 /**
  * Below half of market value the qualifying holdings are not most of the
  * account, so a basket estimate would mostly describe something other than it;
@@ -124,6 +131,22 @@ export interface RiskShifts {
   rates: number;
   volatility: number;
 }
+/** The benchmark the basket's returns, active return and tracking error are measured against. */
+const RISK_BENCHMARK = "SPY";
+
+/**
+ * The window the risk rows cover: the trailing 60 sessions, or, with `since:
+ * "filed"`, every session since the filing date of a portfolio imported from
+ * a 13F.
+ */
+export interface RiskWindowRequest {
+  since?: "filed";
+}
+
+/** Why a portfolio asked for risk since its filing shows the trailing window instead. */
+export const sinceFallbackNote = (portfolio: Pick<Portfolio, "name">) =>
+  `"${portfolio.name}" was not imported from a 13F, so it has no filing date; the risk rows cover the trailing 60 sessions.`;
+
 const DEFAULT_RISK_SHIFTS: RiskShifts = {
   equity: -10,
   rates: 100,
@@ -287,6 +310,7 @@ export function buildPortfolioRisk(
   market: RiskMarketSnapshot,
   evidence: PortfolioRiskEvidence | null = null,
   shifts: RiskShifts = DEFAULT_RISK_SHIFTS,
+  window: RiskWindowRequest = {},
 ) {
   if (
     ![shifts.equity, shifts.rates, shifts.volatility].every(Number.isFinite) ||
@@ -469,9 +493,15 @@ export function buildPortfolioRisk(
     );
     return (instrument && byId.get(riskInstrumentId(instrument))?.returns) || [];
   };
-  const benchmark = proxy("SPY"),
+  const benchmark = proxy(RISK_BENCHMARK),
     sample = pairedReturns(basket, benchmark);
-  const metrics = rollingBasketRisk(sample);
+  // Since the filing only for a portfolio that has one; any other keeps the trailing window and says why.
+  const filed = window.since === "filed" ? portfolio.importedFrom?.filed ?? null : null;
+  if (window.since === "filed" && !filed)
+    notes.push(sinceFallbackNote(portfolio));
+  const metrics = filed
+    ? sinceBasketRisk(sample, filed, RISK_BENCHMARK)
+    : rollingBasketRisk(sample, undefined, RISK_BENCHMARK);
   const factors = [
     { id: "market", label: "Market (SPY)", series: benchmark },
     {
@@ -546,7 +576,9 @@ export function buildPortfolioRisk(
       if (factor.samples === 0)
         warnings.push(`${factor.label}: no matched factor history`);
   if (sufficient && metrics.every((row) => row.value == null))
-    warnings.push("Fewer than 60 consecutive matched completed daily returns.");
+    warnings.push(filed
+      ? `No completed session since the 13F filing on ${filed} yet.`
+      : "Fewer than 60 consecutive matched completed daily returns.");
   const performance = evidence?.performance
     ? calculateAccountPerformance(evidence.performance)
     : null;
@@ -565,12 +597,19 @@ export function buildPortfolioRisk(
     : null;
   warnings.push(...(greeks?.warnings ?? []));
   const rows: Record<RiskView, RiskDisplayRow[]> = {
-    risk: metrics.map((row) => ({
-      ...row,
-      percentile: row.rank.percentile,
-      // The method (price returns at fixed current weights) is in docs; the footer keeps room for coverage.
-      detail: `${row.samples} sessions`,
-    })),
+    risk: metrics.map((row) => {
+      // VaR and expected shortfall are a one-day loss on the covered basket's current value, in the portfolio currency.
+      const tail = TAIL_ROW_IDS.has(row.id) && row.value != null && coverage.coveredValue > 0;
+      return {
+        ...row,
+        percentile: row.rank.percentile,
+        // The method (price returns at fixed current weights) is in docs; the footer keeps room for coverage.
+        detail: filed && row.value == null && TAIL_ROW_IDS.has(row.id) ? `${row.samples} sessions; needs 60` : `${row.samples} sessions`,
+        ...(tail
+          ? { amount: (row.value! / 100) * coverage.coveredValue, amountCurrency: coverage.currency, amountBase: coverage.coveredValue }
+          : {}),
+      };
+    }),
     factors: factors.map((row) => ({
       ...row,
       percentile: row.rank.percentile,
@@ -762,6 +801,10 @@ export function buildPortfolioRisk(
     warnings: [...new Set(warnings)],
     notes,
     fetchedAt: market.fetchedAt,
+    benchmark: RISK_BENCHMARK,
+    window: filed
+      ? { kind: "since-filed" as const, filed, start: metrics[0]?.startDate ?? null, sessions: metrics[0]?.samples ?? 0 }
+      : { kind: "trailing" as const, sessions: 60 },
   };
 }
 export type PortfolioRiskModel = ReturnType<typeof buildPortfolioRisk>;
@@ -770,6 +813,22 @@ export const riskValue = (row: RiskDisplayRow) =>
     ? "left out"
     : row.value == null
     ? "--"
-    : `${row.value.toFixed(2)}${row.unit === "%" ? "%" : ` ${row.unit}`}`;
+    : `${row.value.toFixed(2)}${row.unit === "%" ? "%" : ` ${row.unit}`}${riskAmount(row)}`;
+/** "220,476 USD basket": the value a tail loss in money is taken on, or null for a row without one. */
+export function riskAmountBase(row: Pick<RiskDisplayRow, "amountBase" | "amountCurrency">): string | null {
+  return row.amountBase != null && Number.isFinite(row.amountBase) && row.amountCurrency
+    ? `${formatNumber(row.amountBase, 0)} ${row.amountCurrency} basket`
+    : null;
+}
+/** A row's evidence with the basket a tail loss in money is taken on. */
+export function riskEvidence(row: RiskDisplayRow): string {
+  const base = riskAmountBase(row);
+  return base ? `${row.detail}; of ${base}` : row.detail;
+}
+/** " ($5,735)": a tail loss in money beside its percent. */
+function riskAmount(row: RiskDisplayRow): string {
+  if (row.amount == null || !Number.isFinite(row.amount) || !row.amountCurrency) return "";
+  return ` (${formatCurrency(row.amount, row.amountCurrency, 0)})`;
+}
 export const riskPercentile = (row: RiskDisplayRow) =>
   row.percentile == null ? "--" : String(Math.round(row.percentile));