canli-validation-mcp 0.5.0 → 0.7.0

package/src/local/js/validate/backtest-length.js

@@ -0,0 +1,61 @@
+// js/validate/backtest-length.js
+// The pure computation behind POST /api/v1/validate/backtest-length, shared by the API route and the
+// MCP package's local mode (mcp/src/local mirrors it byte for byte), so the two cannot disagree.
+import { expectedMaxStandardNormal, maximumIndependentTrials, minimumBacktestLength } from "../dsr-core.js";
+
+// Minimum Backtest Length: Bailey, Borwein, López de Prado and Zhu, "Pseudo-Mathematics and
+// Financial Charlatanism" (Notices of the AMS, 2014), Theorem 3.1, checked against the paper's own
+// statements in js/minbtl-paper-vectors.test.js. With N independent trials and a target in-sample
+// Sharpe, how many years a backtest needs before the best trial is not expected to reach the target
+// by luck; with the backtest's years, how many independent trials those years allow.
+
+export function compute(body) {
+  const hasTrials = body.effective_independent_trials !== undefined;
+  const hasYears = body.backtest_years !== undefined;
+  if (!hasTrials && !hasYears) throw new RangeError("Send effective_independent_trials, backtest_years, or both");
+  const inputs = { target_sharpe_annualized: body.target_sharpe_annualized === undefined ? 1 : Number(body.target_sharpe_annualized) };
+  if (!(inputs.target_sharpe_annualized > 0 && inputs.target_sharpe_annualized <= 10)) throw new RangeError("target_sharpe_annualized must be greater than 0 and at most 10");
+  if (hasTrials) {
+    inputs.effective_independent_trials = Number(body.effective_independent_trials);
+    if (!Number.isInteger(inputs.effective_independent_trials) || inputs.effective_independent_trials < 2 || inputs.effective_independent_trials > 1e9) {
+      throw new RangeError("effective_independent_trials must be an integer from 2 to 1000000000");
+    }
+  }
+  if (hasYears) {
+    inputs.backtest_years = Number(body.backtest_years);
+    if (!(inputs.backtest_years > 0 && inputs.backtest_years <= 1000)) throw new RangeError("backtest_years must be greater than 0 and at most 1000");
+  }
+  const result = {};
+  if (hasTrials) {
+    const minimum = minimumBacktestLength({ trials: inputs.effective_independent_trials, targetSharpe: inputs.target_sharpe_annualized });
+    result.minimum_backtest_years = minimum.years;
+    result.upper_bound_years = minimum.upper_bound_years;
+  }
+  if (hasYears) {
+    result.maximum_independent_trials = maximumIndependentTrials({ years: inputs.backtest_years, targetSharpe: inputs.target_sharpe_annualized });
+  }
+  if (hasTrials && hasYears) {
+    result.expected_max_sharpe_annualized = expectedMaxStandardNormal(inputs.effective_independent_trials) / Math.sqrt(inputs.backtest_years);
+    result.long_enough = inputs.backtest_years >= result.minimum_backtest_years;
+  }
+  return { derived_inputs: inputs, result, plain_reading: reading(inputs, result) };
+}
+
+function reading(inputs, r) {
+  const sharpe = (x) => String(Number(Number(x).toFixed(3)));
+  const target = sharpe(inputs.target_sharpe_annualized);
+  const parts = [];
+  if (r.minimum_backtest_years !== undefined) {
+    parts.push(`With ${inputs.effective_independent_trials} independent trials, the best one is expected to show an in-sample Sharpe of ${target} by luck alone unless the backtest covers at least ${r.minimum_backtest_years.toFixed(2)} years.`);
+  }
+  if (r.maximum_independent_trials !== undefined) {
+    parts.push(r.maximum_independent_trials === 1
+      ? `${sharpe(inputs.backtest_years)} years of backtest is too short for even two independent trials: their best is expected to reach a Sharpe of ${target} by luck.`
+      : `${sharpe(inputs.backtest_years)} years of backtest allows at most ${r.maximum_independent_trials} independent trials before the best is expected to reach a Sharpe of ${target} by luck.`);
+  }
+  if (r.expected_max_sharpe_annualized !== undefined) {
+    parts.push(`Over ${sharpe(inputs.backtest_years)} years, the best of ${inputs.effective_independent_trials} skill-less trials is expected to show a Sharpe of ${sharpe(r.expected_max_sharpe_annualized)}.`);
+  }
+  parts.push("Meeting this length is necessary, not sufficient: a backtest can still be overfit.");
+  return parts.join(" ");
+}

package/src/local/js/validate/haircut-sharpe.js

@@ -0,0 +1,54 @@
+// js/validate/haircut-sharpe.js
+// The pure computation behind POST /api/v1/validate/haircut-sharpe, shared by the API route and the
+// MCP package's local mode (mcp/src/local mirrors it byte for byte), so the two cannot disagree.
+import { haircutSharpe } from "../haircut-core.js";
+
+// The haircut Sharpe ratio of Harvey and Liu, "Backtesting" (2015), checked against the authors'
+// Haircut_SR.m and R in js/haircut-paper-vectors.test.js. Bonferroni and independent-test adjustments
+// need only the number of tests; Holm and BHY need the other tests' Sharpe ratios, which the caller
+// knows (the authors simulate them from a published factor model when they are unknown).
+
+const MAX_OTHERS = 10000;
+
+export function compute(body) {
+  const missing = ["observed_sharpe_annualized", "periods_per_year", "observations"].filter((k) => body[k] === undefined);
+  if (missing.length) throw new RangeError(`Missing required fields: ${missing.join(", ")}`);
+  const others = body.other_sharpe_ratios_annualized;
+  if (others !== undefined && (!Array.isArray(others) || others.length < 1 || others.length > MAX_OTHERS)) {
+    throw new RangeError(`other_sharpe_ratios_annualized must be an array of 1 to ${MAX_OTHERS} Sharpe ratios`);
+  }
+  if (others === undefined && body.tests === undefined) throw new RangeError("Send tests, other_sharpe_ratios_annualized, or both");
+  const inputs = {
+    observed_sharpe_annualized: Number(body.observed_sharpe_annualized),
+    periods_per_year: Number(body.periods_per_year),
+    observations: Number(body.observations),
+    autocorrelation: body.autocorrelation === undefined ? 0 : Number(body.autocorrelation),
+    ...(body.tests !== undefined ? { tests: Number(body.tests) } : {}),
+    ...(others !== undefined ? { other_tests: others.length } : {}),
+  };
+  if (!(inputs.observations <= 1000000)) throw new RangeError("observations must be at most 1000000");
+  const result = haircutSharpe({
+    sharpeAnnualized: inputs.observed_sharpe_annualized,
+    periodsPerYear: inputs.periods_per_year,
+    observations: inputs.observations,
+    tests: inputs.tests,
+    autocorrelation: inputs.autocorrelation,
+    otherSharpesAnnualized: others,
+  });
+  return { derived_inputs: inputs, result, plain_reading: reading(inputs, result) };
+}
+
+function reading(inputs, r) {
+  const num = (x, d = 3) => String(Number(Number(x).toFixed(d)));
+  const pct = (x) => `${(x * 100).toFixed(1)} percent`;
+  const p = (x) => (x < 0.0001 ? Number(x).toExponential(2) : num(x, 4));
+  const line = (name, a) => `${name} gives an adjusted p-value of ${p(a.adjusted_p)} and a haircut Sharpe of ${num(a.haircut_sharpe_annualized)}, a ${pct(a.haircut)} haircut`;
+  const corrected = inputs.autocorrelation !== 0 ? ` (${num(r.sharpe_annualized_corrected)} after the autocorrelation correction)` : "";
+  const parts = [
+    `Tested alone, an annualized Sharpe of ${num(inputs.observed_sharpe_annualized)}${corrected} over ${inputs.observations} observations has a p-value of ${p(r.p_value_single)}.`,
+    `Counting ${r.tests} tests, ${line("Bonferroni", r.bonferroni)}; treating the tests as independent ${line("", r.independent).trim()}.`,
+  ];
+  if (r.holm) parts.push(`With the other tests' own Sharpe ratios, ${line("Holm", r.holm)}, and ${line("BHY", r.bhy)}.`);
+  parts.push("The haircut counts only the tests declared; tests run and not counted are invisible to it.");
+  return parts.join(" ");
+}

package/src/local/js/validate/luck-trials.js

@@ -0,0 +1,63 @@
+// js/validate/luck-trials.js
+// The pure computation behind POST /api/v1/validate/luck-trials, shared by the API route and the
+// MCP package's local mode (mcp/src/local mirrors it byte for byte), so the two cannot disagree.
+import { luckEquivalentTrials, TRIAL_CAP } from "../luck-core.js";
+
+// Luck-equivalent trials (js/luck-core.js): how many skill-less strategies a search would have had
+// to try for its best to reach the observed Sharpe by luck. Calibrated by Monte Carlo in
+// js/luck-core.test.js; too kind to negatively skewed strategies, which the reading says when the
+// caller sends the skew.
+
+const NEGATIVE_SKEW = -0.5;
+
+export function compute(body) {
+  const missing = ["observed_sharpe_annualized", "periods_per_year", "observations"].filter((k) => body[k] === undefined);
+  if (missing.length) throw new RangeError(`Missing required fields: ${missing.join(", ")}`);
+  const inputs = {
+    observed_sharpe_annualized: Number(body.observed_sharpe_annualized),
+    periods_per_year: Number(body.periods_per_year),
+    observations: Number(body.observations),
+    ...(body.effective_independent_trials !== undefined ? { effective_independent_trials: Number(body.effective_independent_trials) } : {}),
+    ...(body.skew !== undefined ? { skew: Number(body.skew) } : {}),
+    ...(body.autocorrelation !== undefined ? { autocorrelation: Number(body.autocorrelation) } : {}),
+  };
+  if (!(Math.abs(inputs.observed_sharpe_annualized) <= 20)) throw new RangeError("observed_sharpe_annualized must be a number from -20 to 20");
+  if (!(inputs.periods_per_year > 0 && inputs.periods_per_year <= 100000)) throw new RangeError("periods_per_year must be greater than 0 and at most 100000");
+  if (!Number.isInteger(inputs.observations) || inputs.observations < 3 || inputs.observations > 1000000) throw new RangeError("observations must be an integer from 3 to 1000000");
+  const trials = inputs.effective_independent_trials;
+  if (trials !== undefined && (!Number.isInteger(trials) || trials < 1 || trials > 1e9)) throw new RangeError("effective_independent_trials must be an integer from 1 to 1000000000");
+  if (inputs.skew !== undefined && !Number.isFinite(inputs.skew)) throw new RangeError("skew must be a finite number");
+  if (inputs.autocorrelation !== undefined && !(inputs.autocorrelation > -1 && inputs.autocorrelation < 1)) throw new RangeError("autocorrelation must be strictly between -1 and 1");
+  const result = luckEquivalentTrials({ sharpe: inputs.observed_sharpe_annualized, observations: inputs.observations, periodsPerYear: inputs.periods_per_year, trials, autocorrelation: inputs.autocorrelation });
+  return { derived_inputs: inputs, result, plain_reading: reading(inputs, result) };
+}
+
+const whole = (n) => Math.floor(n).toLocaleString("en-US");
+
+function reading(inputs, r) {
+  const sharpe = String(Number(inputs.observed_sharpe_annualized.toFixed(3)));
+  const over = `over these ${inputs.observations} observations`;
+  const parts = [];
+  if (r.trials_for_five_percent >= TRIAL_CAP) {
+    parts.push(`Luck alone would need more than ${TRIAL_CAP.toExponential(0).replace("e+", "e")} skill-less strategies to reach a Sharpe of ${sharpe} ${over}.`);
+  } else if (r.trials_for_even_odds < 2) {
+    parts.push(`A single skill-less strategy shows a Sharpe of ${sharpe} or more ${over} with probability ${r.single_trial_probability.toFixed(3)}: luck alone readily explains it.`);
+  } else if (r.trials_for_five_percent < 1) {
+    parts.push(`The best of ${whole(r.trials_for_even_odds)} skill-less strategies reaches a Sharpe of ${sharpe} ${over} about half the time, and even one reaches it more than 5 percent of the time.`);
+  } else {
+    parts.push(`The best of ${whole(r.trials_for_even_odds)} skill-less strategies reaches a Sharpe of ${sharpe} ${over} about half the time; with at most ${whole(r.trials_for_five_percent)} tried, luck reaches it less than 5 percent of the time.`);
+  }
+  if (r.best_of_trials_probability !== undefined) {
+    parts.push(`With ${inputs.effective_independent_trials} independent trials, the chance that the best reaches it by luck is ${(r.best_of_trials_probability * 100).toPrecision(3)} percent.`);
+  }
+  if (inputs.skew !== undefined && inputs.skew < NEGATIVE_SKEW) {
+    parts.push(`With a return skew of ${inputs.skew}, these counts are too generous: negatively skewed returns reach high Sharpe ratios by luck more often than this assumes.`);
+  }
+  if (inputs.autocorrelation === undefined) {
+    parts.push("Without the returns' autocorrelation this assumes none; positively autocorrelated returns reach high Sharpe ratios by luck more often.");
+  } else if (inputs.autocorrelation !== 0) {
+    parts.push(`The Sharpe was first corrected for an autocorrelation of ${inputs.autocorrelation} (Lo, 2002), to ${String(Number((inputs.observed_sharpe_annualized * r.autocorrelation_factor).toFixed(3)))}.`);
+  }
+  parts.push("It counts independent trials; correlated trials count as fewer.");
+  return parts.join(" ");
+}

package/src/local/js/validate/track-record.js

@@ -41,7 +41,9 @@ export function compute(body) {
 
 function reading(inputs, r) {
   const pct = (x) => `${(x * 100).toFixed(1)} percent`;
-  const need = `To be ${pct(r.confidence)} confident that a Sharpe of ${inputs.observed_sharpe_annualized} is above ${inputs.benchmark_sharpe_annualized}, the track record needs at least ${r.minimum_observations} observations, about ${r.minimum_years.toFixed(2)} years.`;
+  // A Sharpe derived from a return series carries every digit of the float; three decimals read.
+  const sharpe = (x) => String(Number(Number(x).toFixed(3)));
+  const need = `To be ${pct(r.confidence)} confident that a Sharpe of ${sharpe(inputs.observed_sharpe_annualized)} is above ${sharpe(inputs.benchmark_sharpe_annualized)}, the track record needs at least ${r.minimum_observations} observations, about ${r.minimum_years.toFixed(2)} years.`;
   if (!r.record) return `${need} This counts sample uncertainty and the shape of the returns only; it is not a forecast.`;
   const verdict = r.record.long_enough ? "is long enough" : "is not long enough yet";
   return `${need} The record sent, ${r.record.observations} observations, ${verdict}: the probability its Sharpe is above the benchmark is ${pct(r.record.psr_against_benchmark)}. Neither number is a forecast.`;

package/src/local/scripts/canonical-json.mjs

@@ -0,0 +1,176 @@
+// =============================================================================
+// canonical-json.mjs
+// -----------------------------------------------------------------------------
+// ONE canonicalisation for every published `content_hash` on this site.
+//
+// WHY THIS FILE EXISTS. `reproduce.py` -- the kit a reader runs to check that the
+// published record reproduces -- recomputes every artifact's hash with Python's
+//
+//     json.dumps(payload_without_content_hash, sort_keys=True, separators=(",", ":"))
+//
+// Seven generators carried their own copy-pasted `canonical()` that happened to
+// agree with it. `build-paper-evidence-vectors.mjs` carried NO copy and hashed
+// with a bare `JSON.stringify`, which preserves insertion order instead of
+// sorting. Its artifact therefore never reproduced, L1 read 158/1, and because
+// the nightly ceremony gates on L1 the whole publish halted -- OTS anchoring,
+// capacity and founder commitments included. One generator missing a helper the
+// other seven had duplicated took the ceremony down.
+//
+// That is the same shape as `normalizeEditableCopy`, which was pasted into three
+// generators while the verifier had no copy at all. A helper that must agree
+// across N call sites cannot live as N copies. It lives here.
+//
+// WHAT "CANONICAL" MEANS HERE, exactly, because two of these are traps:
+//
+//   * KEY ORDER -- recursively sorted, matching `sort_keys=True`. This is the one
+//     the missing copy got wrong.
+//   * SEPARATORS -- "," and ":" with no spaces, matching `separators=(",", ":")`.
+//   * NON-ASCII -- escaped to \uXXXX, matching Python's default `ensure_ascii=True`.
+//     JS `JSON.stringify` emits raw UTF-8 instead. For a pure-ASCII document the
+//     two settings emit IDENTICAL bytes, so this divergence stays invisible until
+//     the first accented character -- which is exactly how "Lopez de Prado" in one
+//     contract halted the nightly for three nights.
+//   * NUMBERS -- Python and JS disagree on when to switch to exponent form
+//     (Python at >=1e16 and <1e-4, JS at >=1e21 and <1e-6) and on the exponent's
+//     own spelling (Python "1e-05", JS "1e-5"). `pythonNumber` reproduces
+//     Python's rule. A number this cannot render faithfully THROWS rather than
+//     emitting a hash that will not reproduce: a wrong hash fails at 22:12 in the
+//     nightly, an exception fails in the generator that caused it.
+//
+// The differential test in `canonical-json.test.mjs` is what makes any of this
+// believable: it hands the same values to Python and compares the bytes.
+// =============================================================================
+
+/**
+ * Render a number the way Python re-emits it after parsing the literal JS wrote.
+ *
+ * THE CHAIN THIS HAS TO PREDICT, because getting it wrong is invisible until the
+ * nightly ceremony halts: a JS generator builds an object, writes it with
+ * `JSON.stringify(payload, null, 2)`, and `reproduce.py` later PARSES that file and
+ * re-emits it with `json.dumps`. So the target is not "what Python's repr does to
+ * this JS number" -- it is "what Python does to the LITERAL JSON.stringify writes".
+ *
+ * That distinction is the whole rule. `1e16` reaches the file as
+ * `10000000000000000`, which Python parses as an INT and echoes digit for digit;
+ * predicting Python's float repr (`1e+16`) there would be wrong. `1e-7` reaches the
+ * file as `1e-7`, which Python parses as a float and re-spells `1e-07`.
+ *
+ * KNOWN LIMIT, stated because it bounds where this module may be used: a float
+ * Python wrote as `1.0` parses to the JS number `1`, and no JS function can tell it
+ * from an integer. So this canonicalisation is faithful for payloads BUILT in JS and
+ * written by `JSON.stringify` -- the artifact and its hash then agree -- and is NOT a
+ * general re-canonicaliser for files a Python exporter produced.
+ */
+export function pythonNumber(value) {
+  if (!Number.isFinite(value)) {
+    // Python writes Infinity/NaN; JSON has no such literals and JS writes null.
+    // Neither is reproducible, so refuse rather than publish an unreproducible hash.
+    throw new Error(`canonical-json: ${value} has no reproducible JSON form`);
+  }
+  // Exactly the bytes JSON.stringify will put in the artifact file.
+  const literal = JSON.stringify(value);
+  if (!/[.eE]/.test(literal)) {
+    // No decimal point and no exponent: Python parses an int and echoes the digits.
+    return literal;
+  }
+  // Python parses a float, so the output is `repr(float)`: shortest round-trip
+  // digits -- identical in both languages -- laid out by Python's rule, which is
+  // fixed notation for a decimal exponent in [-4, 16) and exponent form otherwise.
+  const [mantissa, exponent] = value.toExponential().split("e");
+  const e = Number(exponent);
+  const negative = mantissa.startsWith("-");
+  const digits = mantissa.replace("-", "").replace(".", "");
+  if (e >= -4 && e < 16) {
+    let whole;
+    let fraction;
+    if (e >= 0) {
+      whole = digits.slice(0, e + 1).padEnd(e + 1, "0");
+      fraction = digits.slice(e + 1);
+    } else {
+      whole = "0";
+      fraction = "0".repeat(-e - 1) + digits;
+    }
+    // Python always keeps at least one fractional digit on a float.
+    return `${negative ? "-" : ""}${whole}.${fraction === "" ? "0" : fraction}`;
+  }
+  const sign = e < 0 ? "-" : "+";
+  const magnitude = String(Math.abs(e)).padStart(2, "0");
+  return `${mantissa}e${sign}${magnitude}`;
+}
+
+// Every code unit above ASCII. Written as an escape range rather than as literal
+// characters so the source file itself stays ASCII -- a file about non-ASCII
+// escaping is the worst possible place to smuggle in a stray accented byte.
+const NON_ASCII = /[\u0080-\uffff]/g;
+
+/** Escape a string the way Python's `json.dumps(ensure_ascii=True)` does. */
+export function pythonString(value) {
+  // JSON.stringify already handles quotes, backslashes and control characters
+  // identically to Python. Only non-ASCII is spelled differently, so escape that
+  // and leave the rest of JS's output alone. Astral characters are already
+  // surrogate pairs in JS, and Python escapes them as a surrogate pair too.
+  return JSON.stringify(value).replace(
+    NON_ASCII,
+    (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`,
+  );
+}
+
+/** The canonical byte string an artifact's `content_hash` is taken over. */
+export function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .sort()
+      .map((k) => `${pythonString(k)}:${canonicalJson(value[k])}`)
+      .join(",")}}`;
+  }
+  if (typeof value === "number") return pythonNumber(value);
+  if (typeof value === "string") return pythonString(value);
+  if (value === null || typeof value === "boolean") return JSON.stringify(value);
+  // undefined, function, symbol, bigint: JSON.stringify would silently drop or
+  // throw. Neither belongs in a published artifact, so say so by name.
+  throw new Error(`canonical-json: ${typeof value} has no canonical JSON form`);
+}
+
+/** `sha256:...` over the payload with its own `content_hash` field removed. */
+export function contentHash(payload, createHash) {
+  const body = Object.fromEntries(
+    Object.entries(payload).filter(([k]) => k !== "content_hash"),
+  );
+  return `sha256:${createHash("sha256").update(canonicalJson(body)).digest("hex")}`;
+}
+
+/**
+ * Write a glass-box artifact, stamp its `content_hash`, and PROVE the file on disk
+ * reproduces that hash before returning.
+ *
+ * WHY THE READ-BACK. Computing a hash and writing a file are two steps, and every
+ * incident in this pipeline's history lives in the gap between them: a generator
+ * that hashed insertion-ordered bytes while the reader sorted them, an exporter that
+ * emitted raw UTF-8 while the reader escaped it. In both cases the generator
+ * succeeded, the artifact looked fine, and the failure surfaced days later as a
+ * halted nightly ceremony pointing at the reader rather than the writer.
+ *
+ * So this re-reads what it just wrote, re-canonicalises it the way `reproduce.py`
+ * will, and throws if the two disagree. The generator that caused the problem is the
+ * thing that fails, at the moment it causes it. A list of "artifacts to check" would
+ * have to be maintained and would silently omit the next new one; a self-check
+ * cannot be omitted by anyone who uses the helper.
+ */
+export function writeArtifact(path, payload, { createHash, readFileSync, writeFileSync }) {
+  const stamped = { ...payload };
+  delete stamped.content_hash;
+  stamped.content_hash = contentHash(stamped, createHash);
+  writeFileSync(path, `${JSON.stringify(stamped, null, 2)}\n`);
+
+  const reread = JSON.parse(readFileSync(path, "utf8"));
+  const observed = contentHash(reread, createHash);
+  if (observed !== reread.content_hash) {
+    throw new Error(
+      `canonical-json: ${path} does not reproduce its own content_hash ` +
+        `(wrote ${reread.content_hash}, re-read as ${observed}). ` +
+        "The published record would not reproduce and the nightly ceremony would halt.",
+    );
+  }
+  return stamped.content_hash;
+}

package/src/local.mjs

@@ -7,6 +7,9 @@ import { compute as deflatedSharpe } from "./local/js/validate/deflated-sharpe.j
 import { compute as overfitting } from "./local/js/validate/overfitting.js";
 import { compute as paperEvidence } from "./local/js/validate/paper-evidence.js";
 import { compute as trackRecord } from "./local/js/validate/track-record.js";
+import { compute as backtestLength } from "./local/js/validate/backtest-length.js";
+import { compute as haircutSharpe } from "./local/js/validate/haircut-sharpe.js";
+import { compute as luckTrials } from "./local/js/validate/luck-trials.js";
 
 export const LOCAL_VALIDATORS = Object.freeze({
   validate_deflated_sharpe: { endpoint: "validate/deflated-sharpe", compute: deflatedSharpe },
@@ -14,6 +17,9 @@ export const LOCAL_VALIDATORS = Object.freeze({
   validate_paper_evidence: { endpoint: "validate/paper-evidence", compute: paperEvidence },
   validate_breadth: { endpoint: "validate/breadth", compute: breadth },
   validate_track_record: { endpoint: "validate/track-record", compute: trackRecord },
+  validate_backtest_length: { endpoint: "validate/backtest-length", compute: backtestLength },
+  validate_haircut_sharpe: { endpoint: "validate/haircut-sharpe", compute: haircutSharpe },
+  validate_luck_trials: { endpoint: "validate/luck-trials", compute: luckTrials },
 });
 
 const NOTE = "Computed on this machine in local mode. Nothing was sent to canlicapital.com and no receipt was stored.";

package/src/receipt-keys.json

@@ -0,0 +1,13 @@
+{
+  "schema": "canli.receipt-keys.v1",
+  "description": "Public keys that sign canlicapital.com validation receipts. A receipt's signature is Ed25519 over the canonical JSON of {schema, id, endpoint, input_sha256, output_sha256, bindings}; its key_id is the first 16 hex characters of sha256 over the key's 32 raw bytes.",
+  "keys": [
+    {
+      "key_id": "269d381734732ea6",
+      "alg": "Ed25519",
+      "x": "k1ojmfzJlaiXwaEU5aql0CvNyHMS_vXTj9Q9-zTeYAw",
+      "status": "active",
+      "valid_from": "2026-09-26"
+    }
+  ]
+}