canli-quant-mcp 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## Unreleased
 
+## 0.1.2
+
+This cumulative npm candidate includes the statistical and input corrections recorded under
+0.1.1 below. The 0.1.1 source archive stays available; it will not be published separately to npm.
+
+- Non-finite computed results now return a tool error naming their fields and values before JSON
+  serialization or success receipt creation. Previously NaN and Infinity appeared as null with no
+  diagnostic. Both discovery and directly listed tools use the same result check. Ordinary finite
+  answers and legitimate null warm-up positions retain their existing representation.
+
+## 0.1.1 (signed source release; not published to npm)
+
+- Fix: an asset whose returns never change made `covariance_shrinkage`, `correlation_matrix` and
+  the portfolio optimizers (`max_sharpe_portfolio`, `min_variance_portfolio` and the others built
+  on the same estimates) answer with NaN. They now refuse and name the asset ("CASH has no
+  variance").
+- Fix: `put_call_parity` gave NaN for `implied_carry` when the quotes put the implied forward at or
+  below zero. It now gives null with a note to check the quotes for staleness. Both were found by
+  canli-mcp's `bench/robustness.mjs`.
+- Fix: `digits` also rounded whole numbers, so `digits: 4` turned 227,917,808 into 227,900,000.
+  It now trims fractions only; whole numbers and the integer part of large values stay exact.
+
+
+- `deflated_sharpe_ratio` and `probabilistic_sharpe_ratio` also take summary numbers (`sharpe_annual`,
+  `observations`, `skew`, `kurtosis`) and refuse fewer than 20 returns or zero variance, instead of
+  returning a probability from too little data. Found by watching a model call them in an agent
+  evaluation.
+- `sleeve_tournament`: Hansen's SPA and Romano-Wolf StepM are now re-studentized in every resample,
+  the default mean block length is round(n^(1/3)) instead of floor(sqrt(n)), and White's Reality
+  Check is reported alongside. The 0.1.0 version held one variance estimate fixed across resamples,
+  which the Null Zoo benchmark measured rejecting 13.5% of skill-less AR(1) searches at a nominal
+  5% with long blocks; on our planted-trend test data it kept 24 sleeves where the corrected test
+  keeps 4.
+
+- `sleeve_tournament` verdict: no longer calls the effective-trials deflation "the fairer one"; on
+  data with no edge it nearly passes a long-only winner. The verdict now says the raw count is the
+  conservative bound and that deflation (Sharpe above zero) and SPA/StepM (beats the benchmark)
+  answer different questions.
+
 ## 0.1.0
 
 First release: 235 tools in 18 toolsets (performance, options, exotics, rates, tvm, valuation,
@@ -23,7 +62,7 @@ sleeves, data_checks, labeling), reached through three discovery tools (`find_to
   meta, fixed-horizon and trend-scanning labels, sample weights, and purged, embargoed CV splits.
 - Privacy enforced by tests: no network, disk writes, logging, processes or workers; runs under
   Node's permission model.
-- 461 reference cases against QuantLib, statsmodels, arch, TA-Lib, numpy-financial, scikit-learn,
+- 465 reference cases against QuantLib, statsmodels, arch, TA-Lib, numpy-financial, scikit-learn,
   empyrical, scipy, pandas and dcor; planted-defect tests for the data checks; no-lookahead and warm-up
   checks on every sleeve.
 - Eleven workflow prompts, six resources, and opt-in calculation receipts.

package/README.md

@@ -1,12 +1,16 @@
 # canli-quant-mcp
 
+Computed NaN and Infinity values are refused with a tool error naming the affected fields.
+They do not become unexplained nulls or receive a success receipt. Check the input scale
+and the calculation's domain. Ordinary finite answers and null warm-up positions are preserved.
+
 235 quant finance tools in one MCP server: performance and risk, options and exotics, fixed income,
 portfolio construction, econometrics, technical indicators, execution, sizing, crypto and FX,
 valuation, strategy backtests, a library of 399 strategy sleeves, data checks, and data annotation
 and ML labeling. Every tool
 computes on the data you send, and every tool's results are checked in the test suite against an
 independent implementation (QuantLib, statsmodels, arch, TA-Lib, numpy-financial, scikit-learn,
-empyrical, scipy, pandas, dcor): 461 reference cases, plus planted-defect tests for the data checks.
+empyrical, scipy, pandas, dcor): 465 reference cases, plus planted-defect tests for the data checks.
 
 Local stdio, no key, no account, no network calls: your data never leaves your machine (see
 [Privacy](#privacy), enforced by tests).
@@ -80,7 +84,7 @@ Then ask, for example:
 | `sizing` | 7 | scipy and closed forms |
 | `crypto_fx` | 9 | closed forms and simulated pool reserves |
 | `strategies` | 20 | an independent pandas implementation of every recipe and of the costed engine |
-| `sleeves` | 8 | an independent numpy and pandas port of every recipe and the engine; arch's SPA and StepM on the same bootstrap draws; scipy average linkage; numpy CSCV; plus no-lookahead and warm-up checks on every sleeve |
+| `sleeves` | 8 | an independent numpy and pandas port of every recipe and the engine; arch's Reality Check and an independent re-studentized SPA and StepM on the same bootstrap draws; scipy average linkage; numpy CSCV; plus no-lookahead and warm-up checks on every sleeve |
 | `data_checks` | 10 | planted-defect tests: each check must find what was planted and stay quiet on clean data |
 | `labeling` | 7 | pandas ports of the snippets in Advances in Financial Machine Learning (ewm volatility, CUSUM filter, triple barrier, uniqueness, purged k-fold) and statsmodels OLS t-values |
 | `tvm` | 15 | numpy-financial and closed forms |
@@ -111,14 +115,14 @@ sleeves at once correct for it:
 
 | tool | what it answers |
 |---|---|
-| `sleeve_tournament` | Which sleeves lead on your prices, and does the best survive the deflated Sharpe ratio (counting all sleeves and the effective number of independent ones), Hansen's SPA test, Romano-Wolf StepM and the probability of backtest overfitting (CSCV)? |
+| `sleeve_tournament` | Which sleeves lead on your prices, and does the best survive the deflated Sharpe ratio (counting all sleeves and the effective number of independent ones), White's Reality Check, Hansen's SPA test and Romano-Wolf StepM (re-studentized in every resample) and the probability of backtest overfitting (CSCV)? |
 | `sleeve_walk_forward` | If you had kept picking the top sleeves by trailing Sharpe, what would you have earned out of sample, and how much of their in-sample Sharpe was luck? |
 | `sleeve_clusters` | How many genuinely different bets do the sleeves make on this data? |
 | `sleeve_regime_map` | Which sleeves held up in calm, turbulent, rising and falling markets? |
 | `combine_sleeves` | What does a book of chosen sleeves look like, and what asset weights does it want as of the latest close? |
 
 The tests check that no sleeve looks ahead (rewriting future prices never changes an earlier
-target), that none trades before its warm-up, and that the tournament's statistics match arch's SPA
+target), that none trades before its warm-up, and that the tournament's statistics match arch's Reality Check and an independent re-studentized SPA
 and StepM on the same bootstrap draws, scipy's clustering and an independent numpy CSCV.
 `run_sleeve` and `combine_sleeves` return `target_weights` by symbol, which a paper broker such as
 canli-paper-trading-mcp can rebalance to.
@@ -457,7 +461,7 @@ randomness is the sleeve bootstrap, drawn from a stated seed.
 | `list_sleeves` | Browse the library of 399 pre-defined strategy sleeves (18 families: trend, momentum, reversion, volatility, allocation, pairs). Each is a fixed rule with a spec hash; filter by family, data shape or words. |
 | `describe_sleeve` | One sleeve's exact rule, parameters, warm-up, rationale, published references, known risks and spec SHA-256. |
 | `run_sleeve` | Backtest one library sleeve on your prices with costs and no lookahead: CAGR, Sharpe, drawdown, turnover, cost drag, and the target weights as of the latest close (ready for a paper rebalance). |
-| `sleeve_tournament` | Run all library sleeves that fit your prices (up to 399) on a common window and rank them, then correct for the search: deflated Sharpe (raw and effective number of trials), Hansen SPA and Romano-Wolf StepM against a benchmark, and the probability of backtest overfitting (CSCV). |
+| `sleeve_tournament` | Run all library sleeves that fit your prices (up to 399) on a common window and rank them, then correct for the search: deflated Sharpe (raw and effective number of trials), White's Reality Check, re-studentized Hansen SPA and Romano-Wolf StepM against a benchmark, and the probability of backtest overfitting (CSCV). |
 | `sleeve_walk_forward` | Test the selection process itself: at each refit pick the top sleeves by trailing Sharpe, hold them for the next window, repeat. Compares the out-of-sample result with what the picks showed in sample, with holding every sleeve, and with the benchmark. |
 | `combine_sleeves` | Blend chosen sleeves (equal or trailing inverse-volatility weights, no lookahead) into one book: its statistics, each sleeve's, their correlations, the diversification ratio, and the book's combined asset target weights as of the latest close. |
 | `sleeve_clusters` | Group the sleeves that ran on your prices by return correlation (average linkage on sqrt((1 - rho) / 2)), to see how many genuinely different bets the library makes on this data and the best sleeve of each group. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canli-quant-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "235 quant finance tools and a library of 399 strategy sleeves as one MCP server: performance and risk, options and exotics, fixed income, portfolio construction, econometrics (regime switching, Johansen, CUSUM, HAR), indicators, execution, crypto and FX, valuation, backtests with multiple-testing corrections (deflated Sharpe, SPA, StepM, PBO), data annotation and ML labels (triple barrier, purged CV) and data checks, each checked against QuantLib, statsmodels, arch, TA-Lib or numpy. Keyless and local with no network, disk writes or logging; three tools in context by default.",
   "private": false,
   "type": "module",

package/src/math.mjs

@@ -221,19 +221,34 @@ export function olsSimple(x, y) {
 export function sig(x, digits = 10) {
   if (typeof x !== "number" || !Number.isFinite(x)) return x === undefined ? null : Number.isNaN(x) ? null : x;
   if (x === 0) return 0;
+  // Whole numbers (counts, observations, share amounts) are never changed, nor the integer part of
+  // a large value: digits trims fractions only.
+  if (Number.isInteger(x)) return x;
+  if (Math.abs(x) >= 10 ** digits) return Math.round(x);
   return Number(x.toPrecision(digits));
 }
 
 // Rounds every number in a plain result tree.
-export function compact(v, digits = 10) {
-  if (typeof v === "number") return sig(v, digits);
-  if (Array.isArray(v)) return v.map((x) => compact(x, digits));
-  if (v && typeof v === "object" && !(v instanceof Date)) {
-    const out = {};
-    for (const [k, x] of Object.entries(v)) if (x !== undefined) out[k] = compact(x, digits);
+export function compact(v, digits = 10, onNonFinite) {
+  const path = [];
+  const child = (key, value) => {
+    if (onNonFinite) path.push(key);
+    const out = visit(value);
+    if (onNonFinite) path.pop();
     return out;
+  };
+  const visit = (value) => {
+    if (typeof value === "number") {
+      if (onNonFinite && !Number.isFinite(value)) onNonFinite(value, path);
+      return sig(value, digits);
+    }
+    if (Array.isArray(value)) return value.map((x, i) => child(i, x));
+    if (value && typeof value === "object" && !(value instanceof Date)) {
+      return Object.fromEntries(Object.entries(value).filter(([, x]) => x !== undefined).map(([k, x]) => [k, child(k, x)]));
+    }
+    return value;
   }
-  return v;
+  return visit(v);
 }
 
 // ---------------------------------------------------------------------------------------------

package/src/registry.mjs

@@ -60,7 +60,19 @@ export function runTool(name, args, { digits = 10 } = {}) {
     const issues = parsed.error.issues.slice(0, 5).map((i) => `${i.path.join(".") || "arguments"}: ${i.message}`).join("; ");
     throw new Error(`${name}: ${issues}. describe_tool ${name} gives the exact input schema.`);
   }
-  return compact(tool.run(parsed.data), digits);
+  let nonFiniteCount = 0;
+  const examples = [];
+  const result = compact(tool.run(parsed.data), digits, (value, path) => {
+    nonFiniteCount++;
+    if (examples.length < 5) {
+      const pointer = path.map((key) => String(key).replace(/~/g, "~0").replace(/\//g, "~1")).join("/");
+      examples.push(`${pointer ? "/" + pointer.slice(0, 160) : "root"} (${String(value)})`);
+    }
+  });
+  if (nonFiniteCount) {
+    throw new Error(`${name}: calculation returned ${nonFiniteCount} non-finite value(s): ${examples.join(", ")}${nonFiniteCount > examples.length ? ", ..." : ""}. JSON cannot represent this numerical result. Check input scale and the tool's mathematical domain.`);
+  }
+  return result;
 }
 
 // Search: BM25 over each tool's name, title, keywords and description (field-weighted), with light

package/src/server.mjs

@@ -50,7 +50,7 @@ export const METHODS = Object.freeze({
   sizing: "scipy and closed forms",
   crypto_fx: "closed forms and simulated pool reserves",
   strategies: "an independent pandas implementation of every recipe and of the costed engine",
-  sleeves: "an independent numpy and pandas port of every recipe and the engine; arch's SPA and StepM on the same bootstrap draws; scipy average linkage; numpy CSCV; plus no-lookahead and warm-up checks on every sleeve",
+  sleeves: "an independent numpy and pandas port of every recipe and the engine; arch's Reality Check and an independent re-studentized SPA and StepM on the same bootstrap draws; scipy average linkage; numpy CSCV; plus no-lookahead and warm-up checks on every sleeve",
   data_checks: "planted-defect tests: each check must find what was planted and stay quiet on clean data",
   labeling: "pandas ports of the snippets in Advances in Financial Machine Learning (ewm volatility, CUSUM filter, triple barrier, uniqueness, purged k-fold) and statsmodels OLS t-values",
 });
@@ -130,7 +130,7 @@ export function registerAll(server, { toolsets = selectedToolsets() } = {}) {
       name: z.string().max(100).describe("Tool name from find_tool."),
       arguments: z.record(z.string(), z.unknown()).optional().describe("The tool's arguments, as describe_tool gives them."),
       receipt: z.boolean().optional().describe("Add a calculation receipt (input and output SHA-256) so the result can be independently recomputed and compared; default false."),
-      digits: z.number().int().min(3).max(10).optional().describe("Significant figures in the result; default 10. 4-6 cuts output tokens when full precision is not needed."),
+      digits: z.number().int().min(3).max(10).optional().describe("Significant figures for fractional numbers in the result; default 10. Whole numbers are never changed. 4-6 cuts output tokens when full precision is not needed."),
     }).strict(),
     outputSchema: open,
   }, guard(({ name, arguments: args, receipt, digits }) => {

package/src/tools/econometrics.mjs

@@ -222,9 +222,29 @@ function garchFit(r) {
 }
 
 function trialSharpeStats(r) {
-  const n = r.length, sr = mean(r) / std(r), m = moments(r);
+  if (r.length < 20) throw new Error(`Only ${r.length} returns: a Sharpe ratio's probability needs at least 20. With summary numbers instead, send sharpe_annual and observations (plus skew and kurtosis if known).`);
+  const sd = std(r);
+  if (!(sd > 0)) throw new Error("The returns have zero variance, so the Sharpe ratio is undefined.");
+  const n = r.length, sr = mean(r) / sd, m = moments(r);
   return { n, sr, skew: m.skew, kurt: m.excess_kurtosis + 3 };
 }
+
+// The same statistics from a series, or from summary numbers when no series is at hand.
+const summaryFields = {
+  sharpe_annual: z.number().min(-20).max(20).optional().describe("Observed annualized Sharpe ratio, instead of returns or prices."),
+  observations: z.number().int().min(20).max(1e8).optional().describe("Number of return observations behind sharpe_annual."),
+  skew: z.number().min(-50).max(50).optional().describe("Skewness of the returns with sharpe_annual; default 0."),
+  kurtosis: z.number().min(1).max(1000).optional().describe("Kurtosis (not excess; 3 if normal) with sharpe_annual; default 3."),
+};
+function sharpeStats(a, ppy) {
+  if (a.sharpe_annual === undefined) {
+    if (a.observations !== undefined || a.skew !== undefined || a.kurtosis !== undefined) throw new Error("observations, skew and kurtosis go with sharpe_annual.");
+    return trialSharpeStats(seriesFrom(a));
+  }
+  if (a.returns !== undefined || a.prices !== undefined) throw new Error("Send either sharpe_annual with observations, or returns/prices, not both.");
+  if (a.observations === undefined) throw new Error("sharpe_annual needs observations (the number of returns behind it).");
+  return { n: a.observations, sr: a.sharpe_annual / Math.sqrt(ppy), skew: a.skew ?? 0, kurt: a.kurtosis ?? 3 };
+}
 const psr = ({ n, sr, skew, kurt }, srStar) => normCdf((sr - srStar) * Math.sqrt(n - 1) / Math.sqrt(1 - skew * sr + (kurt - 1) / 4 * sr * sr));
 const EULER = 0.5772156649015329;
 
@@ -405,11 +425,11 @@ export const TOOLS = [
   {
     name: "probabilistic_sharpe_ratio",
     title: "Probabilistic Sharpe ratio",
-    description: "Compute the probability that the true Sharpe ratio exceeds a benchmark given the track record's length, skewness and kurtosis (Bailey and López de Prado), and the minimum track record length needed.",
-    keywords: "probabilistic sharpe ratio psr minimum track record length mintrl skewness kurtosis confidence",
-    input: z.object({ ...seriesFields, benchmark_sharpe: z.number().min(-10).max(10).optional().describe("Annual Sharpe to beat; default 0."), confidence: z.number().gt(0.5).lt(1).optional().describe("For the minimum track record; default 0.95.") }).strict(),
+    description: "Compute the probability that the true Sharpe ratio exceeds a benchmark given the track record's length, skewness and kurtosis (Bailey and López de Prado), and the minimum track record length needed. Takes returns or prices, or just the observed Sharpe and the number of observations.",
+    keywords: "probabilistic sharpe ratio psr probability sharpe real genuine skill significant minimum track record length mintrl skewness kurtosis confidence",
+    input: z.object({ ...seriesFields, ...summaryFields, benchmark_sharpe: z.number().min(-10).max(10).optional().describe("Annual Sharpe to beat; default 0."), confidence: z.number().gt(0.5).lt(1).optional().describe("For the minimum track record; default 0.95.") }).strict(),
     run(a) {
-      const r = seriesFrom(a), ppy = a.periods_per_year ?? 252, st = trialSharpeStats(r), bench = (a.benchmark_sharpe ?? 0) / Math.sqrt(ppy);
+      const ppy = a.periods_per_year ?? 252, st = sharpeStats(a, ppy), bench = (a.benchmark_sharpe ?? 0) / Math.sqrt(ppy);
       const zc = normInv(a.confidence ?? 0.95), varTerm = 1 - st.skew * st.sr + (st.kurt - 1) / 4 * st.sr * st.sr;
       const mtrl = st.sr > bench ? 1 + varTerm * (zc / (st.sr - bench)) ** 2 : null;
       return { psr: psr(st, bench), sharpe_annual: st.sr * Math.sqrt(ppy), periods: st.n, min_track_record_periods: mtrl, min_track_record_years: mtrl === null ? null : mtrl / ppy, skew: st.skew, kurtosis: st.kurt };
@@ -418,16 +438,16 @@ export const TOOLS = [
   {
     name: "deflated_sharpe_ratio",
     title: "Deflated Sharpe ratio",
-    description: "Deflate a backtest's Sharpe ratio for the number of strategies tried (Bailey and López de Prado 2014): the expected maximum Sharpe under the null and the probability the result beats it.",
+    description: "Deflate a backtest's Sharpe ratio for the number of strategies tried (Bailey and López de Prado 2014): the expected maximum Sharpe under the null and the probability the result beats it. Takes returns or prices, or just the observed Sharpe and the number of observations, with the trials' Sharpe variance or Sharpes.",
     keywords: "overfit overfitting variants trials tried multiple testing luck deflated sharpe ratio dsr multiple testing selection bias backtest overfitting trials data snooping",
     input: z.object({
-      ...seriesFields,
+      ...seriesFields, ...summaryFields,
       trials: z.number().int().min(1).max(1e9).describe("How many strategy variants were tried, including this one."),
       trial_sharpes: z.array(z.number()).min(2).max(100000).optional().describe("Annual Sharpe ratios of all trials, to estimate their variance."),
-      trial_sharpe_variance: z.number().positive().optional().describe("Or the variance of the trials' annual Sharpe ratios directly."),
+      trial_sharpe_variance: z.number().positive().optional().describe("Or the variance of the trials' annual Sharpe ratios directly (the square of their standard deviation)."),
     }).strict(),
     run(a) {
-      const r = seriesFrom(a), ppy = a.periods_per_year ?? 252, st = trialSharpeStats(r);
+      const ppy = a.periods_per_year ?? 252, st = sharpeStats(a, ppy);
       let v = a.trial_sharpe_variance;
       if (v === undefined) { if (!a.trial_sharpes) throw new Error("Send trial_sharpes or trial_sharpe_variance."); v = variance(a.trial_sharpes); }
       const vPer = v / ppy, N = a.trials;

package/src/tools/options.mjs

@@ -187,7 +187,8 @@ export const TOOLS = [
       const dr = Math.exp(-(a.rate ?? 0) * a.years), dq = Math.exp(-(a.dividend_yield ?? 0) * a.years);
       const gap = a.call - a.put - (a.spot * dq - a.strike * dr);
       const fwd = (a.call - a.put) / dr + a.strike;
-      return { parity_gap: gap, implied_forward: fwd, implied_carry: Math.log(fwd / a.spot) / a.years, meaning: "parity_gap = C - P - (S e^-qT - K e^-rT); positive means the call is rich relative to the put." };
+      // A forward at or below zero means the quotes break parity's bounds; no carry implies it.
+      return { parity_gap: gap, implied_forward: fwd, implied_carry: fwd > 0 ? Math.log(fwd / a.spot) / a.years : null, ...(fwd > 0 ? {} : { implied_carry_note: "The implied forward is not positive, so the quotes cannot be consistent with any carry; check them for staleness." }), meaning: "parity_gap = C - P - (S e^-qT - K e^-rT); positive means the call is rich relative to the put." };
     },
   },
   {

package/src/tools/portfolio.mjs

@@ -51,7 +51,11 @@ export function estimates(a, { needMu = false } = {}) {
   if (a.expected_returns) { if (a.expected_returns.length !== C.length) throw new Error(`expected_returns has ${a.expected_returns.length} entries for ${C.length} assets.`); mu = a.expected_returns; }
   if (needMu && !mu) throw new Error("Send expected_returns with a covariance matrix.");
   if (a.assets && a.assets.length !== C.length) throw new Error(`assets has ${a.assets.length} names for ${C.length} assets.`);
-  return { C, mu, cols, n: C.length, names: a.assets ?? C.map((_, i) => `asset_${i + 1}`) };
+  const names = a.assets ?? C.map((_, i) => `asset_${i + 1}`);
+  // An asset that never moves has no risk to weigh: every optimizer here divides by it.
+  const flat = C.findIndex((row, i) => !(row[i] > 0));
+  if (flat >= 0) throw new Error(`${names[flat]} has no variance (its returns never change), so risk-based weights are undefined. Drop it or check the data.`);
+  return { C, mu, cols, n: C.length, names };
 }
 
 const label = (names, w) => Object.fromEntries(names.map((n, i) => [n, w[i]]));
@@ -382,6 +386,8 @@ export const TOOLS = [
     input: z.object({ returns: sources.returns.unwrap(), periods_per_year: ppyArg }).strict(),
     run(a) {
       const R = a.returns, p = R[0].length, cols = Array.from({ length: p }, (_, j) => R.map((r) => r[j])), ppy = a.periods_per_year ?? 252;
+      const flat = cols.findIndex((c) => !(cov2(c, c, 0) > 0));
+      if (flat >= 0) throw new Error(`asset_${flat + 1} has no variance (its returns never change), so there is no covariance to shrink. Drop it or check the data.`);
       const lw = ledoitWolf(cols), cond = (M) => { const e = symmetricEigen(M).values; return e[0] / e.at(-1); };
       const sample = cols.map((x) => cols.map((y) => cov2(x, y, 0)));
       return { shrinkage: lw.shrinkage, covariance_annual: lw.matrix.map((r) => r.map((v) => v * ppy)), covariance_per_period: lw.matrix, condition_number_sample: cond(sample), condition_number_shrunk: cond(lw.matrix) };
@@ -398,6 +404,8 @@ export const TOOLS = [
       let cols = Array.from({ length: p }, (_, j) => R.map((r) => r[j]));
       if (a.method === "spearman") cols = cols.map(rank);
       const sd = cols.map((c) => std(c));
+      const flat = sd.findIndex((v) => !(v > 0));
+      if (flat >= 0) throw new Error(`${(a.assets ?? [])[flat] ?? `asset_${flat + 1}`} has no variance (its returns never change), so its correlations are undefined. Drop it or check the data.`);
       const M = cols.map((x, i) => cols.map((y, j) => (i === j ? 1 : cov2(x, y) / (sd[i] * sd[j]))));
       let s = 0; for (let i = 0; i < p; i++) for (let j = i + 1; j < p; j++) s += M[i][j];
       const ev = symmetricEigen(M).values;

package/src/tools/sleeves.mjs

@@ -8,14 +8,17 @@
 // Multiple-testing machinery (all deterministic for a given seed):
 // - Deflated Sharpe ratio for the best sleeve, with the raw count of sleeves and with the effective
 //   number of independent sleeves (K^2 / sum of squared pairwise correlations).
-// - Hansen's SPA test against a benchmark, studentized with the stationary-bootstrap variance and
-//   computed the way the arch package does (lower, consistent and upper p-values), plus Romano-Wolf
-//   StepM for the set of sleeves that beat the benchmark with family-wise error control.
+// - White's Reality Check against a benchmark (unstudentized, as arch computes it), and Hansen's SPA
+//   test and Romano-Wolf StepM re-studentized in every resample: each bootstrap mean is divided by
+//   that resample's own standard deviation (Romano and Wolf 2005). The Null Zoo benchmark measured
+//   the fixed-variance studentization, which reuses one variance estimate, rejecting 9.4% of
+//   skill-less searches at block length 8 and 13.5% at 22 under AR(1) at a nominal 5%;
+//   re-studentizing brought it to 6.6%. The default mean block length is round(n^(1/3)).
 // - Probability of backtest overfitting by combinatorially symmetric cross-validation (CSCV).
 // The bootstrap draws come from mulberry32(seed), so anyone can regenerate them.
 import { z } from "zod";
 
-import { correlation, mean, moments, mulberry32, normCdf, normInv, lagProducts, quantile, std, variance } from "../math.mjs";
+import { correlation, mean, moments, mulberry32, normCdf, normInv, quantile, std, variance } from "../math.mjs";
 import { MAX_SERIES, ppyArg } from "../inputs.mjs";
 import { FAMILY_INFO, SLEEVES, SLEEVE_BY_ID } from "../sleeves.mjs";
 import { RECIPES, runEngine, statsOf } from "./strategies.mjs";
@@ -142,17 +145,6 @@ function effectiveTrials(R, C) {
   return (K * K) / s2;
 }
 
-// Stationary-bootstrap long-run variance of each column the way arch's SPA computes it.
-function spaVariance(col, block) {
-  const t = col.length, m = mean(col), d = col.map((v) => v - m), p = 1 / block, s = lagProducts(d);
-  let v = s[0] / t;
-  for (let i = 1; i < t; i++) {
-    const kappa = (1 - i / t) * (1 - p) ** i + (i / t) * (1 - p) ** (t - i);
-    v += 2 * kappa * s[i] / t;
-  }
-  return v;
-}
-
 // Stationary bootstrap (Politis and Romano 1994) as a list of [start, length] runs over n positions,
 // drawn from mulberry32(seed): at each step one uniform decides a new block (probability 1/block),
 // and a second picks its start.
@@ -177,43 +169,46 @@ const runSum = (S, n, start, len) => {
   return total;
 };
 
-// Hansen SPA (studentized) and Romano-Wolf StepM on loss differentials d[k] = sleeve - benchmark.
-function spaStepM(R, B, { reps, block, seed, size }) {
-  const n = B.length;
-  const cols = [], keep = [];
-  R.forEach((x, k) => { const d = x.map((v, t) => v - B[t]); const om = Math.sqrt(spaVariance(d, block)); if (om > 0 && std(d) > 0) { cols.push(d.map((v) => v / om)); keep.push(k); } });
+// Joint tests on d[k] = sleeve - benchmark, with one stationary bootstrap shared by all sleeves.
+function jointTests(R, B, { reps, block, seed, size }) {
+  const n = B.length, cols = [], keep = [];
+  R.forEach((x, k) => { const d = x.map((v, t) => v - B[t]); if (std(d) > 0) { cols.push(d); keep.push(k); } });
   const K = cols.length;
   if (K === 0) return null;
-  const means = cols.map(mean), thresh = -Math.sqrt((1 / n) * 2 * Math.log(Math.log(n)));
-  const centers = [means.map((m) => Math.max(m, 0)), means.map((m) => (m >= thresh ? m : 0)), means];
-  const S = cols.map((c) => { const s = new Float64Array(n + 1); for (let t = 0; t < n; t++) s[t + 1] = s[t] + c[t]; return s; });
-  const rand = mulberry32(seed);
-  const sims = [0, 1, 2].map(() => Array.from({ length: K }, () => new Float64Array(reps)));
+  const m = cols.map(mean), sd = cols.map((c) => std(c)), rn = Math.sqrt(n), tObs = m.map((v, k) => rn * v / sd[k]);
+  const thr = sd.map((v) => -v * Math.sqrt(2 * Math.log(Math.log(n)) / n));
+  const centers = [m.map((v) => Math.max(v, 0)), m.map((v, k) => (v >= thr[k] ? v : 0)), m];
+  const pref = (c, sq) => { const s = new Float64Array(n + 1); for (let t = 0; t < n; t++) s[t + 1] = s[t] + (sq ? c[t] * c[t] : c[t]); return s; };
+  const S1 = cols.map((c) => pref(c, false)), S2 = cols.map((c) => pref(c, true));
+  const rand = mulberry32(seed), rc = new Float64Array(reps).fill(-Infinity), spa = [0, 1, 2].map(() => new Float64Array(reps).fill(0));
+  const tStar = Array.from({ length: K }, () => new Float64Array(reps));
   for (let r = 0; r < reps; r++) {
     const runs = bootstrapRuns(n, block, rand);
     for (let k = 0; k < K; k++) {
-      let tot = 0;
-      for (const [st, len] of runs) tot += runSum(S[k], n, st, len);
-      const mb = tot / n;
-      for (let j = 0; j < 3; j++) sims[j][k][r] = mb - centers[j][k];
+      let s1 = 0, s2 = 0;
+      for (const [st, len] of runs) { s1 += runSum(S1[k], n, st, len); s2 += runSum(S2[k], n, st, len); }
+      const mb = s1 / n, sdb = Math.sqrt(Math.max(0, (s2 - s1 * s1 / n) / (n - 1)));
+      if (mb - m[k] > rc[r]) rc[r] = mb - m[k];
+      for (let j = 0; j < 3; j++) { const v = sdb > 0 ? rn * (mb - centers[j][k]) / sdb : 0; if (v > spa[j][r]) spa[j][r] = v; }
+      tStar[k][r] = sdb > 0 ? rn * (mb - m[k]) / sdb : -Infinity;
     }
   }
-  const maxOver = (j, active) => { const out = new Float64Array(reps).fill(-Infinity); for (const k of active) { const s = sims[j][k]; for (let r = 0; r < reps; r++) if (s[r] > out[r]) out[r] = s[r]; } return out; };
-  const all = [...Array(K).keys()], observed = Math.max(...means);
-  const pv = [0, 1, 2].map((j) => { const mx = maxOver(j, all); let c = 0; for (let r = 0; r < reps; r++) if (mx[r] > observed) c++; return c / reps; });
-  // StepM: reject every sleeve whose studentized mean beats the consistent critical value, drop
-  // them, and repeat on the rest until nothing new is rejected.
+  const obsRC = Math.max(...m), obsSPA = Math.max(0, ...tObs);
+  let rcCount = 0; for (let r = 0; r < reps; r++) if (rc[r] > obsRC) rcCount++;
+  const pv = spa.map((sims) => { let c = 0; for (let r = 0; r < reps; r++) if (sims[r] >= obsSPA) c++; return c / reps; });
+  // StepM: reject every sleeve whose t-statistic beats the (1 - size) quantile of the largest
+  // re-studentized resample among those not yet rejected; repeat until nothing new is rejected.
   const superior = [];
-  let active = all;
-  for (;;) {
-    const crit = quantile(Float64Array.from(maxOver(1, active)).sort(), 1 - size);
-    const better = active.filter((k) => means[k] > crit);
-    if (better.length === 0) break;
+  let active = [...Array(K).keys()];
+  while (active.length) {
+    const mx = new Float64Array(reps).fill(-Infinity);
+    for (const k of active) for (let r = 0; r < reps; r++) if (tStar[k][r] > mx[r]) mx[r] = tStar[k][r];
+    const crit = quantile(mx.sort(), 1 - size), better = active.filter((k) => tObs[k] > crit);
+    if (!better.length) break;
     superior.push(...better);
     active = active.filter((k) => !better.includes(k));
-    if (active.length === 0) break;
   }
-  return { tested: K, statistic: observed * Math.sqrt(n), p_values: { lower: pv[0], consistent: pv[1], upper: pv[2] }, superior: superior.map((k) => keep[k]).sort((x, y) => x - y) };
+  return { tested: K, statistic: obsSPA, p_values: { lower: pv[0], consistent: pv[1], upper: pv[2] }, reality_check: rcCount / reps, superior: superior.map((k) => keep[k]).sort((x, y) => x - y) };
 }
 
 // Combinatorially symmetric cross-validation (Bailey, Borwein, Lopez de Prado and Zhu 2017).
@@ -315,13 +310,13 @@ export const TOOLS = [
   {
     name: "sleeve_tournament",
     title: "Run every sleeve, corrected for multiple testing",
-    description: "Run all library sleeves that fit your prices (up to 399) on a common window and rank them, then correct for the search: deflated Sharpe (raw and effective number of trials), Hansen SPA and Romano-Wolf StepM against a benchmark, and the probability of backtest overfitting (CSCV).",
+    description: "Run all library sleeves that fit your prices (up to 399) on a common window and rank them, then correct for the search: deflated Sharpe (raw and effective number of trials), White's Reality Check, re-studentized Hansen SPA and Romano-Wolf StepM against a benchmark, and the probability of backtest overfitting (CSCV).",
     keywords: "which work survive best all sleeve tournament run all strategies leaderboard multiple testing spa reality check stepm romano wolf pbo cscv deflated sharpe data snooping",
     input: z.object({
       prices: pricesIn, ...engineArgs, ...selectArgs,
       benchmark: z.enum(["buy_and_hold", "cash"]).optional().describe("What a sleeve must beat: equal-weight buy and hold of the columns (default) or cash at risk_free."),
-      reps: z.number().int().min(100).max(5000).optional().describe("Bootstrap repetitions for SPA and StepM; default 1000."),
-      block: z.number().int().min(1).max(1000).optional().describe("Mean bootstrap block length; default floor(sqrt(periods))."),
+      reps: z.number().int().min(100).max(5000).optional().describe("Bootstrap repetitions for the Reality Check, SPA and StepM; default 1000."),
+      block: z.number().int().min(1).max(1000).optional().describe("Mean bootstrap block length; leave unset for the default round(periods^(1/3)). Long blocks make every block-bootstrap test liberal."),
       seed: z.number().int().min(0).max(4294967295).optional().describe("Bootstrap seed; default 7."),
       splits: z.number().int().min(4).max(16).multipleOf(2).optional().describe("CSCV splits (even); default 16, or fewer for short histories."),
       top: z.number().int().min(1).max(400).optional().describe("Leaderboard rows to return; default 15."),
@@ -336,14 +331,15 @@ export const TOOLS = [
       const order = [...rows].sort((x, y) => y.sharpe - x.sharpe || x.k - y.k);
       const best = order[0], K = chosen.length, Keff = effectiveTrials(R);
       const sv = variance(R.map(perSharpe)), dRaw = deflated(R[best.k], K, sv), dEff = deflated(R[best.k], Keff, sv);
-      const S = a.splits ?? (n >= 16 * 40 ? 16 : Math.max(4, 2 * Math.floor(n / 80))), block = a.block ?? Math.floor(Math.sqrt(n));
-      const spa = spaStepM(R, B, { reps: a.reps ?? 1000, block, seed: a.seed ?? 7, size: 0.05 });
+      const S = a.splits ?? (n >= 16 * 40 ? 16 : Math.max(4, 2 * Math.floor(n / 80))), block = a.block ?? Math.max(1, Math.round(n ** (1 / 3)));
+      const spa = jointTests(R, B, { reps: a.reps ?? 1000, block, seed: a.seed ?? 7, size: 0.05 });
       const cv = pbo(R, S), bs = statsOf(B, ppy);
       const superior = spa ? spa.superior.map((k) => chosen[k].id) : [];
       const verdict = [
         `${K} sleeves ran on ${n} common periods (effective independent sleeves ${Keff.toFixed(1)}).`,
-        `Best sleeve ${best.id}: deflated Sharpe probability ${dRaw.dsr.toFixed(3)} counting all ${K} sleeves, ${dEff.dsr.toFixed(3)} counting ${Keff.toFixed(1)} independent bets${dEff.dsr > 0.95 ? (dRaw.dsr > 0.95 ? "; it survives both." : "; it survives only the effective count, which is the fairer one when sleeves are this correlated.") : "; it does not survive deflation, so its Sharpe is what the best of this many tries shows by luck."}`,
-        spa ? (spa.p_values.consistent < 0.05 ? `SPA rejects "no sleeve beats the benchmark" (p ${spa.p_values.consistent}); StepM keeps ${superior.length} sleeve(s).` : `SPA cannot reject that no sleeve beats the benchmark (p ${spa.p_values.consistent}).`) : "No sleeve differs from the benchmark.",
+        `Best sleeve ${best.id}: deflated Sharpe probability ${dRaw.dsr.toFixed(3)} counting all ${K} sleeves, ${dEff.dsr.toFixed(3)} counting ${Keff.toFixed(1)} independent bets${dEff.dsr > 0.95 ? (dRaw.dsr > 0.95 ? "; it survives both." : "; it survives only the effective count, which can be too lenient (the raw count is the conservative bound).") : "; it does not survive deflation, so its Sharpe is what the best of this many tries shows by luck."}`,
+        "Deflation asks whether the Sharpe ratio is above zero; SPA and StepM ask whether a sleeve beats the benchmark, so a long-only sleeve in a rising market can pass the first and fail the second.",
+        spa ? (spa.p_values.consistent < 0.05 ? `SPA rejects "no sleeve beats the benchmark" (p ${spa.p_values.consistent}; Reality Check p ${spa.reality_check}); StepM keeps ${superior.length} sleeve(s).` : `SPA cannot reject that no sleeve beats the benchmark (p ${spa.p_values.consistent}; Reality Check p ${spa.reality_check}).`) : "No sleeve differs from the benchmark.",
         `Probability of backtest overfitting ${cv.probability.toFixed(2)}${cv.probability > 0.5 ? ": picking the in-sample winner did worse than a random pick more often than not" : ""}.`,
       ].join(" ");
       return {
@@ -357,7 +353,8 @@ export const TOOLS = [
         multiple_testing: {
           trials: K, effective_trials: Keff,
           best: { id: best.id, sharpe: best.sharpe, deflated_sharpe_probability: dRaw.dsr, deflated_sharpe_probability_effective: dEff.dsr, expected_max_sharpe_under_null: dRaw.star * Math.sqrt(ppy), expected_max_sharpe_under_null_effective: dEff.star * Math.sqrt(ppy) },
-          spa: spa ? { sleeves_tested: spa.tested, statistic: spa.statistic, p_values: spa.p_values, block, reps: a.reps ?? 1000, seed: a.seed ?? 7, bootstrap: "stationary, mulberry32(seed)" } : null,
+          reality_check: spa ? { p_value: spa.reality_check } : null,
+          spa: spa ? { sleeves_tested: spa.tested, statistic: spa.statistic, p_values: spa.p_values, studentization: "re-estimated in every resample", block, reps: a.reps ?? 1000, seed: a.seed ?? 7, bootstrap: "stationary, mulberry32(seed)" } : null,
           stepm: { family_wise_error: 0.05, superior },
           pbo: cv,
         },