canli-validation-mcp 0.7.0 → 0.8.0

package/README.md

@@ -5,6 +5,34 @@
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/14954/badge)](https://www.bestpractices.dev/projects/14954)
 [![Glama score](https://glama.ai/mcp/servers/arhancanli/canli-validation-mcp/badges/score.svg)](https://glama.ai/mcp/servers/arhancanli/canli-validation-mcp)
 
+**Is your best backtest real, or just the luckiest of the variants you tried?** This MCP server
+lets Claude, Cursor or any MCP client answer that with the standard corrections: the deflated
+Sharpe ratio, the CSCV probability of backtest overfitting, the minimum track record length, the
+haircut Sharpe ratio, and luck-equivalent trials. Free and MIT-licensed.
+
+## Quick start
+
+```bash
+# Claude Code, computed on your machine: no key, nothing sent anywhere
+claude mcp add canli-local --env CANLI_LOCAL=1 -- npx -y canli-validation-mcp
+
+# the same tools with signed, stored receipts from the free API (a free key is issued on first use)
+claude mcp add canli -- npx -y canli-validation-mcp
+
+# nothing to install: the hosted endpoint
+claude mcp add --transport http canli https://canlicapital.com/mcp
+```
+
+Then ask, for example: *"I tried 229 variants and kept the best: an annualised Sharpe of
+1.5 over 730 daily returns (365 a year), skew -0.5, kurtosis 5, and the variants'
+Sharpe ratios spread by 0.57. Is it real?"* The assistant calls `validate_deflated_sharpe`: the
+best of 229 skill-less variants would reach 1.60 by luck alone, so the probability that the
+Sharpe is above zero falls from 98.1% to 44.4% once the search is counted. Claude Desktop and any
+other stdio client (Cursor, VS Code) run the same `npx` command; see "Claude Desktop" and
+"Generic stdio client" below.
+
+## What it does
+
 An MCP (Model Context Protocol) server over canlicapital.com's free, keyed validation API. It
 gives a coding agent fourteen tools: issue a free key, run the eight validators (deflated Sharpe,
 CSCV overfitting, paper-evidence conformance, breadth ceiling, minimum track record length,
@@ -165,7 +193,9 @@ claude mcp add --transport http canli https://canlicapital.com/mcp
 ```
 
 Without a key, requests run under a shared anonymous key, so the daily validation quota is shared
-by every hosted caller. For your own quota, issue a free key (see
+by every hosted caller. When that shared quota is used up for the day, validations are still
+answered, computed by the same code on the hosted endpoint, but without a stored receipt; the
+result says so. For your own quota, issue a free key (see
 [/developers](https://canlicapital.com/developers#quickstart)) and send it as a header:
 
 ```bash
@@ -348,6 +378,8 @@ HTTP stub. It neither publishes a package nor issues a production API key.
 
 ## Dependencies
 
-Only `@modelcontextprotocol/sdk` (pinned exact) and `zod` (pinned exact). No other runtime
-dependency is added, and nothing in this package touches the site's root `package.json`,
+Only `@modelcontextprotocol/server` (pinned exact; the MCP SDK's server package, which itself
+depends only on `@modelcontextprotocol/core` and `zod`) and `zod` (pinned exact): four packages in
+the installed tree, where 0.7 and earlier pulled in about 95 through `@modelcontextprotocol/sdk`.
+No other runtime dependency is added, and nothing in this package touches the site's root `package.json`,
 `.vercelignore`, `api/`, `scripts/`, `js/`, or `public/`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "canli-validation-mcp",
-  "version": "0.7.0",
-  "description": "MCP server for canlicapital.com's free validation API: deflated Sharpe, CSCV overfitting, paper-evidence conformance, and breadth ceiling, each returned as the full API envelope so the boundary language cannot be dropped.",
+  "version": "0.8.0",
+  "description": "Check whether a backtest is real: deflated Sharpe, CSCV probability of backtest overfitting, minimum track record and backtest length, haircut Sharpe and luck-equivalent trials, as an MCP server. Local mode, hosted endpoint, signed receipts.",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -16,11 +16,11 @@
     "README.md"
   ],
   "scripts": {
-    "test": "node --test test/*.test.mjs",
+    "test": "node --test test/*.test.mjs test/*.test.js",
     "test:package": "node test/package-smoke.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.30.0",
+    "@modelcontextprotocol/server": "2.1.0",
     "zod": "4.6.5"
   },
   "mcpName": "io.github.arhancanli/canli-validation-mcp",
@@ -34,6 +34,7 @@
     "url": "https://github.com/arhancanli/canlicapital/issues"
   },
   "devDependencies": {
+    "@modelcontextprotocol/client": "2.1.0",
     "fast-check": "4.10.2"
   }
 }

package/src/schemas.mjs

@@ -303,17 +303,61 @@ export const REGISTRY_DESCRIPTION_MAX = 100;
 // calls the tool, not only inside the returned envelope.
 export const TOOL_DESCRIPTIONS = Object.freeze({
   get_key: `Issue a free canlicapital.com validation key (POST /api/v1/keys) and hold it in memory for this session. Only needed before a validation when neither CANLI_KEY nor local mode is set; the read tools (get_receipt, service_status, company_financial_history) never need a key. ${LIMITS_SENTENCES.quotas}`,
-  validate_deflated_sharpe: `Whether a Sharpe survives the number of variants tried: probabilistic and deflated Sharpe (0 to 1) and the Sharpe luck alone would reach. Send the seven statistics or a return series, not both. ${LIMITS_SENTENCES.notAdmission}`,
-  audit_backtest: `Audit one strategy's return series in one call: deflated Sharpe, the minimum track record length for its Sharpe to beat the benchmark, and, with every variant's returns, the probability of backtest overfitting. Point returns_file at the backtest's CSV or JSON rather than copying long series into the call. Each check is the matching validate_ tool's result with its own receipt, side by side; the audit does not grade the strategy. Uses one validation per check. ${LIMITS_SENTENCES.notAdmission}`,
-  validate_overfitting: `Probability (0 to 1) that picking the best of several backtested variants was overfitting, by CSCV over every variant's returns. ${LIMITS_SENTENCES.notAdmission}`,
-  validate_paper_evidence: `Whether a paper or simulated performance record meets canli.paper-evidence.v0, with each failure's JSON pointer. ${LIMITS_SENTENCES.scope}`,
-  validate_backtest_length: `Minimum backtest length, in years, before the best of N independent trials is not expected to reach a target Sharpe by luck, and with backtest_years, the most independent trials those years allow. Send effective_independent_trials, backtest_years, or both. ${LIMITS_SENTENCES.notAdmission}`,
-  validate_luck_trials: `How many skill-less strategies a search would have had to try for its best to reach this Sharpe by luck, and, with a trial count, the chance that it did. Calibrated by Monte Carlo. ${LIMITS_SENTENCES.notAdmission}`,
-  validate_haircut_sharpe: `Haircut Sharpe ratio for multiple testing (Harvey and Liu, 2015): the Sharpe a single test would have needed once the number of tests is counted, by Bonferroni and for independent tests, and with the other tests' Sharpe ratios by Holm and BHY. ${LIMITS_SENTENCES.notAdmission}`,
-  validate_track_record: `Minimum track record length, in observations and years, for an observed Sharpe to beat a benchmark at a confidence level, and with observations, the record's probabilistic Sharpe so far. ${LIMITS_SENTENCES.notAdmission}`,
-  validate_breadth: `Highest book Sharpe reachable by adding sleeves of this quality and correlation, the Sharpe at a sleeve count, and the sleeves a target needs. ${LIMITS_SENTENCES.scope}`,
+  validate_deflated_sharpe: `Deflated Sharpe ratio: the probability (0 to 1) that one selected strategy's Sharpe beats the best Sharpe that luck alone would give across the variants tried, with the probabilistic Sharpe and that luck benchmark. Use it for the strategy you kept after a search, when you know how many variants were tried and how their Sharpe ratios spread; send the seven statistics or a return series, not both. With every variant's returns use validate_overfitting; to state luck as a trial count use validate_luck_trials; for a multiple-testing haircut use validate_haircut_sharpe. ${LIMITS_SENTENCES.notAdmission}`,
+  audit_backtest: `Audit one strategy's return series in one call: deflated Sharpe, the minimum track record length for its Sharpe to beat the benchmark, and, with every variant's returns, the probability of backtest overfitting. Point returns_file at the backtest's CSV or JSON rather than copying long series into the call. Each check is the matching validate_ tool's result with its own receipt, side by side; the audit does not grade the strategy. Prefer it to calling those validators one by one when you have one strategy's return series. Uses one validation per check. ${LIMITS_SENTENCES.notAdmission}`,
+  validate_overfitting: `Probability of backtest overfitting (0 to 1) by CSCV: how often the variant that is best in sample falls below the median out of sample. Use it when you have every variant's returns as a matrix (periods by variants); with summary statistics only, use validate_deflated_sharpe. ${LIMITS_SENTENCES.notAdmission}`,
+  validate_paper_evidence: `Whether a paper or simulated performance record meets canli.paper-evidence.v0, with each failure's JSON pointer. Use it on a record document before publishing or relying on it: it checks structure and required disclosures, not whether the returns are good. ${LIMITS_SENTENCES.scope}`,
+  validate_backtest_length: `Minimum backtest length, in years, before the best of N independent trials is not expected to reach a target Sharpe by luck, and with backtest_years, the most independent trials those years allow. Send effective_independent_trials, backtest_years, or both. Use it before or while planning a search, to size the backtest for the number of trials; once a search has a result, use validate_deflated_sharpe. ${LIMITS_SENTENCES.notAdmission}`,
+  validate_luck_trials: `How many skill-less strategies a search would have had to try for its best to reach this Sharpe by luck, and, with a trial count, the chance that it did. Calibrated by Monte Carlo. Use it to state luck as a count ("as good as the best of N random tries") or to test a result against the trials actually run; for a probability that the Sharpe is real, use validate_deflated_sharpe. ${LIMITS_SENTENCES.notAdmission}`,
+  validate_haircut_sharpe: `Haircut Sharpe ratio for multiple testing (Harvey and Liu, 2015): the Sharpe a single test would have needed once the number of tests is counted, by Bonferroni and for independent tests, and with the other tests' Sharpe ratios by Holm and BHY. Use it to report a Sharpe adjusted for the number of tests, as finance papers do; for a probability that the Sharpe is real, use validate_deflated_sharpe. ${LIMITS_SENTENCES.notAdmission}`,
+  validate_track_record: `Minimum track record length, in observations and years, for an observed Sharpe to beat a benchmark at a confidence level, and with observations, the record's probabilistic Sharpe so far. Use it for a live or paper record: how long it must run before its Sharpe is evidence. To size a backtest against the number of trials, use validate_backtest_length. ${LIMITS_SENTENCES.notAdmission}`,
+  validate_breadth: `Highest book Sharpe reachable by adding sleeves of this quality and correlation, the Sharpe at a sleeve count, and the sleeves a target needs. Use it for portfolio construction, to see what adding strategies can and cannot do; it validates no single strategy. ${LIMITS_SENTENCES.scope}`,
   verify_receipt: `Check a validation receipt's Ed25519 signature offline against the canlicapital.com public key bundled in this package, that its output hashes to its output_sha256, and that its content hashes to its id. Send an id to fetch the receipt first, or a receipt already fetched. ${LIMITS_SENTENCES.unsigned}`,
-  get_receipt: `Fetch a stored verdict by receipt id (GET /api/v1/receipts/{id}) to re-check an earlier result. No key. ${LIMITS_SENTENCES.unsigned}`,
+  get_receipt: `Fetch a stored verdict by receipt id (GET /api/v1/receipts/{id}) to re-read an earlier result. No key. To check that the receipt is genuine, use verify_receipt. ${LIMITS_SENTENCES.unsigned}`,
   service_status: `Whether the validation API is up, with quota constants (GET /api/v1/validate/status); check after a timeout before resubmitting. No key. ${LIMITS_SENTENCES.scope}`,
   company_financial_history: `SEC-reported financial history for one company from the canlicapital.com company reference (GET /company-data/{cik}.json), by cik or by ticker (resolved through GET /api/v1/company-tickers.json, companies in the release only). Without a concept it lists the available histories; with one it returns observations, newest first, each with its filing accession, form, filed date and unit, plus the SHA-256 of the original SEC response. No key required. ${COMPANY_REFERENCE_BOUNDARY}`,
 });
+
+// Output schemas (0.8.0). Published OPEN: extra fields always pass. A client validates a tool's
+// structured result against the output schema it listed, so a closed schema turns every field a
+// later version adds into a failed call (2026-09-26, the mcp-factory servers). Every field is
+// optional because refusals and local results carry different subsets. They are kept terse: the
+// tool list is re-sent to the model every turn, and one sentence per schema says what to read.
+const refusal = z.looseObject({}).nullable().optional();
+const sentences = z.array(z.string()).optional();
+const loose = z.looseObject({}).optional();
+
+export const validationOutput = z
+  .looseObject({
+    data: loose,
+    error: refusal,
+    limits: sentences,
+    receipt: z.looseObject({}).nullable().optional(),
+    computed: z.string().optional(),
+    note: z.string().optional(),
+  })
+  .describe("data.result holds the statistics (data.plain_reading states them); limits say what the result does not establish; receipt ({id, url}) is the signed record, null when none was stored; error ({code, message}) is set only on refusal.");
+
+export const auditOutput = z
+  .looseObject({ readings: loose, checks: loose, not_run: loose, limits: sentences, note: z.string().optional(), error: refusal })
+  .describe("checks holds each check's full validate_ result by name; readings one sentence per check; not_run the checks skipped and why.");
+
+export const keyOutput = z
+  .looseObject({ note: z.string().optional(), key_source: z.string().optional(), key_present: z.boolean().optional(), data: loose, error: refusal })
+  .describe("key_source says which key the session uses; data.key is set when a new key was issued.");
+
+export const receiptOutput = z
+  .looseObject({ data: loose, error: refusal, limits: sentences })
+  .describe("data is the stored receipt: validator, input, output, their hashes, source hashes and signature.");
+
+export const verifyReceiptOutput = z
+  .looseObject({ receipt_id: z.string().nullable().optional(), valid: z.boolean().optional(), checks: z.unknown().optional(), key_id: z.string().nullable().optional(), meaning: z.string().optional(), error: refusal })
+  .describe("valid is true only when the signature, output hash and content id all check out; checks lists each.");
+
+export const statusOutput = z
+  .looseObject({ data: loose, limits: sentences, error: refusal })
+  .describe("data.store_reachable, data.quotas and, when available, data.usage for this key.");
+
+export const companyHistoryOutput = z
+  .looseObject({ company: loose, claim_boundary: z.string().optional(), source: loose, histories: z.array(z.unknown()).optional(), history: loose, error: refusal })
+  .describe("Without a concept, histories lists what is available; with one, history holds the observations newest first as columns and rows, each with its filing. Values are as reported to the SEC.");

package/src/server.mjs

@@ -8,33 +8,13 @@
 // CANLI_KEY; when CANLI_KEY is set, get_key does not call the network.
 import { readFileSync, realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import { computeLocally } from "./local.mjs";
 import { readMatrixFile, readSeriesFile } from "./series-file.mjs";
 import { verifyReceipt } from "./local/js/receipt-statement.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  breadthInput,
-  trackRecordInput,
-  auditBacktestInput,
-  verifyReceiptToolShape,
-  backtestLengthInput,
-  haircutSharpeInput,
-  luckTrialsInput,
-  auditBacktestToolShape,
-  companyHistoryInput,
-  companyHistoryToolShape,
-  deflatedSharpeInput,
-  deflatedSharpeToolShape,
-  emptyInput,
-  getKeyInput,
-  getReceiptInput,
-  overfittingInput,
-  LIMITS_SENTENCES,
-  paperEvidenceInput,
-  TOOL_DESCRIPTIONS,
-} from "./schemas.mjs";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { breadthInput, trackRecordInput, auditBacktestInput, verifyReceiptToolShape, backtestLengthInput, haircutSharpeInput, luckTrialsInput, auditBacktestToolShape, companyHistoryInput, companyHistoryToolShape, deflatedSharpeInput, deflatedSharpeToolShape, emptyInput, getKeyInput, getReceiptInput, overfittingInput, LIMITS_SENTENCES, paperEvidenceInput, TOOL_DESCRIPTIONS, validationOutput, auditOutput, keyOutput, receiptOutput, verifyReceiptOutput, statusOutput, companyHistoryOutput } from "./schemas.mjs";
 
 export const DEFAULT_BASE = "https://canlicapital.com";
 export const SERVER_NAME = "canlicapital-validation-mcp";
@@ -132,6 +112,29 @@ async function callApi(session, { path, method = "GET", body }) {
   return { envelope, failed: res.status >= 400 || Boolean(envelope?.error) };
 }
 
+// The hosted endpoint's shared anonymous key has one daily quota for every caller who connects
+// without a key of their own. When it is used up, the answer is still computed, by the same code
+// the API runs (src/local, byte for byte), on the hosted endpoint; what the caller loses is the
+// stored, signed receipt, and the note says how to get one. A caller's own key, or a missing
+// shared key, still gets the API's refusal unchanged.
+export const SHARED_QUOTA_NOTE = "The shared anonymous quota of this hosted endpoint is used up for today (it resets at 00:00 UTC), so this result was computed by the same code on the hosted endpoint and no receipt was stored. For a receipt and a quota of your own, get a free key at https://canlicapital.com/developers#quickstart and send it as 'Authorization: Bearer <key>'. To run with no quota at all, on your own machine: npx -y canli-validation-mcp with CANLI_LOCAL=1.";
+
+async function validateRemote(session, tool, path, body) {
+  let response = await callApi(session, { path, method: "POST", body });
+  // stdio without CANLI_KEY: the first validation used to come back 401 and the model had to work
+  // out that get_key comes first. Issue the free key once, as get_key would, and retry once.
+  if (response.failed && response.envelope?.error?.code === "unauthorized" && !session.hosted && !session.key && !session.envKey) {
+    const issued = await callApi(session, { path: "/api/v1/keys", method: "POST", body: { label: "auto" } });
+    if (!issued.failed && issued.envelope?.data?.key) {
+      session.key = issued.envelope.data.key;
+      response = await callApi(session, { path, method: "POST", body });
+    }
+  }
+  if (!response.failed || session.hosted?.keySource !== "shared" || response.envelope?.error?.code !== "quota_exhausted") return response;
+  const fallback = computeLocally(tool, body);
+  return { ...fallback, envelope: { ...fallback.envelope, computed: "hosted_without_receipt", note: SHARED_QUOTA_NOTE } };
+}
+
 // Compact context (0.3.0): minified JSON. Indentation is whitespace an agent pays for in tokens and
 // never reads; every field, boundary sentence and provenance value is kept. Measured on the live
 // Apple StockholdersEquity record (README, "Compact context"): 2,214 -> 1,560 tokens minified,
@@ -230,56 +233,56 @@ export async function toolValidateDeflatedSharpe(session, args) {
     );
   }
   if (session.local) { const local = computeLocally("validate_deflated_sharpe", parsed.data); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/deflated-sharpe", method: "POST", body: parsed.data });
+  const response = await validateRemote(session, "validate_deflated_sharpe", "/api/v1/validate/deflated-sharpe", parsed.data);
   return validationText(session, response);
 }
 
 export async function toolValidateOverfitting(session, args) {
   const body = parseOrThrow(overfittingInput, args, "validate_overfitting");
   if (session.local) { const local = computeLocally("validate_overfitting", body); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/overfitting", method: "POST", body });
+  const response = await validateRemote(session, "validate_overfitting", "/api/v1/validate/overfitting", body);
   return validationText(session, response);
 }
 
 export async function toolValidatePaperEvidence(session, args) {
   const body = parseOrThrow(paperEvidenceInput, args, "validate_paper_evidence");
   if (session.local) { const local = computeLocally("validate_paper_evidence", body); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/paper-evidence", method: "POST", body });
+  const response = await validateRemote(session, "validate_paper_evidence", "/api/v1/validate/paper-evidence", body);
   return validationText(session, response);
 }
 
 export async function toolValidateBreadth(session, args) {
   const body = parseOrThrow(breadthInput, args, "validate_breadth");
   if (session.local) { const local = computeLocally("validate_breadth", body); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/breadth", method: "POST", body });
+  const response = await validateRemote(session, "validate_breadth", "/api/v1/validate/breadth", body);
   return validationText(session, response);
 }
 
 export async function toolValidateTrackRecord(session, args) {
   const body = parseOrThrow(trackRecordInput, args, "validate_track_record");
   if (session.local) { const local = computeLocally("validate_track_record", body); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/track-record", method: "POST", body });
+  const response = await validateRemote(session, "validate_track_record", "/api/v1/validate/track-record", body);
   return validationText(session, response);
 }
 
 export async function toolValidateBacktestLength(session, args) {
   const body = parseOrThrow(backtestLengthInput, args, "validate_backtest_length");
   if (session.local) { const local = computeLocally("validate_backtest_length", body); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/backtest-length", method: "POST", body });
+  const response = await validateRemote(session, "validate_backtest_length", "/api/v1/validate/backtest-length", body);
   return validationText(session, response);
 }
 
 export async function toolValidateHaircutSharpe(session, args) {
   const body = parseOrThrow(haircutSharpeInput, args, "validate_haircut_sharpe");
   if (session.local) { const local = computeLocally("validate_haircut_sharpe", body); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/haircut-sharpe", method: "POST", body });
+  const response = await validateRemote(session, "validate_haircut_sharpe", "/api/v1/validate/haircut-sharpe", body);
   return validationText(session, response);
 }
 
 export async function toolValidateLuckTrials(session, args) {
   const body = parseOrThrow(luckTrialsInput, args, "validate_luck_trials");
   if (session.local) { const local = computeLocally("validate_luck_trials", body); return validationText(session, local); }
-  const response = await callApi(session, { path: "/api/v1/validate/luck-trials", method: "POST", body });
+  const response = await validateRemote(session, "validate_luck_trials", "/api/v1/validate/luck-trials", body);
   return validationText(session, response);
 }
 
@@ -287,7 +290,7 @@ export async function toolValidateLuckTrials(session, args) {
 // through the API (one validation of quota, one receipt).
 async function runValidator(session, tool, path, body) {
   if (session.local) return computeLocally(tool, body);
-  return callApi(session, { path, method: "POST", body });
+  return validateRemote(session, tool, path, body);
 }
 
 const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
@@ -503,72 +506,72 @@ export function registerTools(server, session) {
   const register = (name, ...rest) => { if (enabled.has(name)) server.registerTool(name, ...rest); };
   register(
     "get_key",
-    { title: "Get a free validation key", annotations: { title: "Get a free validation key", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }, description: TOOL_DESCRIPTIONS.get_key, inputSchema: getKeyInput },
+    { title: "Get a free validation key", annotations: { title: "Get a free validation key", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }, description: TOOL_DESCRIPTIONS.get_key, inputSchema: getKeyInput, outputSchema: keyOutput },
     (args) => toolGetKey(session, args),
   );
   register(
     "validate_deflated_sharpe",
-    { title: "Validate deflated Sharpe", annotations: { title: "Validate deflated Sharpe", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_deflated_sharpe, inputSchema: deflatedSharpeToolShape },
+    { title: "Validate deflated Sharpe", annotations: { title: "Validate deflated Sharpe", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_deflated_sharpe, inputSchema: deflatedSharpeToolShape, outputSchema: validationOutput },
     (args) => toolValidateDeflatedSharpe(session, args),
   );
   register(
     "validate_overfitting",
-    { title: "Validate overfitting (CSCV)", annotations: { title: "Validate overfitting (CSCV)", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_overfitting, inputSchema: overfittingInput },
+    { title: "Validate overfitting (CSCV)", annotations: { title: "Validate overfitting (CSCV)", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_overfitting, inputSchema: overfittingInput, outputSchema: validationOutput },
     (args) => toolValidateOverfitting(session, args),
   );
   register(
     "validate_paper_evidence",
-    { title: "Validate paper evidence", annotations: { title: "Validate paper evidence", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_paper_evidence, inputSchema: paperEvidenceInput },
+    { title: "Validate paper evidence", annotations: { title: "Validate paper evidence", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_paper_evidence, inputSchema: paperEvidenceInput, outputSchema: validationOutput },
     (args) => toolValidatePaperEvidence(session, args),
   );
   register(
     "validate_breadth",
-    { title: "Validate breadth ceiling", annotations: { title: "Validate breadth ceiling", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_breadth, inputSchema: breadthInput },
+    { title: "Validate breadth ceiling", annotations: { title: "Validate breadth ceiling", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_breadth, inputSchema: breadthInput, outputSchema: validationOutput },
     (args) => toolValidateBreadth(session, args),
   );
   register(
     "validate_track_record",
-    { title: "Minimum track record length", annotations: { title: "Minimum track record length", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_track_record, inputSchema: trackRecordInput },
+    { title: "Minimum track record length", annotations: { title: "Minimum track record length", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_track_record, inputSchema: trackRecordInput, outputSchema: validationOutput },
     (args) => toolValidateTrackRecord(session, args),
   );
   register(
     "validate_backtest_length",
-    { title: "Minimum backtest length", annotations: { title: "Minimum backtest length", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_backtest_length, inputSchema: backtestLengthInput },
+    { title: "Minimum backtest length", annotations: { title: "Minimum backtest length", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_backtest_length, inputSchema: backtestLengthInput, outputSchema: validationOutput },
     (args) => toolValidateBacktestLength(session, args),
   );
   register(
     "validate_haircut_sharpe",
-    { title: "Haircut Sharpe ratio", annotations: { title: "Haircut Sharpe ratio", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_haircut_sharpe, inputSchema: haircutSharpeInput },
+    { title: "Haircut Sharpe ratio", annotations: { title: "Haircut Sharpe ratio", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_haircut_sharpe, inputSchema: haircutSharpeInput, outputSchema: validationOutput },
     (args) => toolValidateHaircutSharpe(session, args),
   );
   register(
     "validate_luck_trials",
-    { title: "Luck-equivalent trials", annotations: { title: "Luck-equivalent trials", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_luck_trials, inputSchema: luckTrialsInput },
+    { title: "Luck-equivalent trials", annotations: { title: "Luck-equivalent trials", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.validate_luck_trials, inputSchema: luckTrialsInput, outputSchema: validationOutput },
     (args) => toolValidateLuckTrials(session, args),
   );
   register(
     "audit_backtest",
-    { title: "Audit a backtest", annotations: { title: "Audit a backtest", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.audit_backtest, inputSchema: auditBacktestToolShape },
+    { title: "Audit a backtest", annotations: { title: "Audit a backtest", ...WRITES_RECEIPT }, description: TOOL_DESCRIPTIONS.audit_backtest, inputSchema: auditBacktestToolShape, outputSchema: auditOutput },
     (args) => toolAuditBacktest(session, args),
   );
   register(
     "get_receipt",
-    { title: "Get a receipt", annotations: { title: "Get a receipt", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.get_receipt, inputSchema: getReceiptInput },
+    { title: "Get a receipt", annotations: { title: "Get a receipt", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.get_receipt, inputSchema: getReceiptInput, outputSchema: receiptOutput },
     (args) => toolGetReceipt(session, args),
   );
   register(
     "verify_receipt",
-    { title: "Verify a receipt", annotations: { title: "Verify a receipt", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.verify_receipt, inputSchema: verifyReceiptToolShape },
+    { title: "Verify a receipt", annotations: { title: "Verify a receipt", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.verify_receipt, inputSchema: verifyReceiptToolShape, outputSchema: verifyReceiptOutput },
     (args) => toolVerifyReceipt(session, args),
   );
   register(
     "service_status",
-    { title: "Service status", annotations: { title: "Service status", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.service_status, inputSchema: emptyInput },
+    { title: "Service status", annotations: { title: "Service status", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.service_status, inputSchema: emptyInput, outputSchema: statusOutput },
     () => toolServiceStatus(session),
   );
   register(
     "company_financial_history",
-    { title: "Company financial history (SEC)", annotations: { title: "Company financial history (SEC)", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.company_financial_history, inputSchema: companyHistoryToolShape },
+    { title: "Company financial history (SEC)", annotations: { title: "Company financial history (SEC)", ...READ_ONLY }, description: TOOL_DESCRIPTIONS.company_financial_history, inputSchema: companyHistoryToolShape, outputSchema: companyHistoryOutput },
     (args) => toolCompanyFinancialHistory(session, args),
   );
 }