canli-validation-mcp 0.11.0 → 0.13.0

package/README.md

@@ -34,14 +34,16 @@ other stdio client (Cursor, VS Code) run the same `npx` command; see "Claude Des
 
 ## What it does
 
-An MCP (Model Context Protocol) server over canlicapital.com's free, keyed validation API. It
-gives a coding agent fifteen tools: issue a free key, run the nine validators (deflated Sharpe,
-CSCV overfitting, data-snooping tests (Hansen's SPA, White's Reality Check and Romano-Wolf StepM),
-paper-evidence conformance, breadth ceiling, minimum track record length, minimum backtest length,
-haircut Sharpe ratio, luck-equivalent trials),
-audit one backtest with three of them in a single call, fetch a stored receipt, verify a
-receipt's signature offline, read service status, and read a company's reported financial history
-from SEC filings. Every validation result carries, beside the number, the sentences that say what
+An MCP (Model Context Protocol) server over canlicapital.com's free, keyed validation API, with a
+lab that computes on your machine. It gives a coding agent twenty tools: issue a free key, run the
+nine validators (deflated Sharpe, CSCV overfitting, data-snooping tests (Hansen's SPA, White's
+Reality Check and Romano-Wolf StepM), paper-evidence conformance, breadth ceiling, minimum track
+record length, minimum backtest length, haircut Sharpe ratio, luck-equivalent trials), audit one
+backtest with several of them in a single call, verify a receipt's signature offline, read service
+status, read a company's reported financial history from SEC filings, and six lab tools: backtest
+a rule over a parameter grid, summarize a long series, stress-test a strategy's returns, check a
+plan against a broker's limits, check a signal for lookahead, and test a whole research pipeline
+on placebo data. Every validation result carries, beside the number, the sentences that say what
 it does not establish and the receipt that records it, success or error, so the agent cannot see a
 number without its limits.
 
@@ -83,7 +85,7 @@ receipt. The current npm/hosted release retains the existing record-only API.
 
 | Tool | Calls | Key required |
 |---|---|---|
-| `get_key` | `POST /api/v1/keys` | no |
+| `get_key` | `POST /api/v1/keys` (listed only when no key is configured) | no |
 | `validate_deflated_sharpe` | `POST /api/v1/validate/deflated-sharpe` | yes |
 | `validate_overfitting` | `POST /api/v1/validate/overfitting` | yes |
 | `validate_paper_evidence` | `POST /api/v1/validate/paper-evidence` | yes |
@@ -93,9 +95,8 @@ receipt. The current npm/hosted release retains the existing record-only API.
 | `validate_haircut_sharpe` | `POST /api/v1/validate/haircut-sharpe` | yes |
 | `validate_luck_trials` | `POST /api/v1/validate/luck-trials` | yes |
 | `validate_reality_check` | `POST /api/v1/validate/reality-check` (a `matrix_file` is read on your machine and sent as numbers) | yes |
-| `audit_backtest` | the deflated Sharpe, track record and, with `variants`, overfitting routes, one validation each | yes |
-| `verify_receipt` | `GET /api/v1/receipts/{id}` when given an id; the checks run locally | no |
-| `get_receipt` | `GET /api/v1/receipts/{id}` | no |
+| `audit_backtest` | the deflated Sharpe and track record routes, then the headline: with `variants`, the overfitting and data-snooping routes; without, luck trials. One validation each | yes |
+| `verify_receipt` | `GET /api/v1/receipts/{id}` when given an id (`include_receipt` returns the stored receipt); the checks run locally | no |
 | `service_status` | `GET /api/v1/validate/status` | no |
 | `company_financial_history` | `GET /company-data/{cik}.json` (a ticker resolves through `GET /api/v1/company-tickers.json`) | no |
 
@@ -137,9 +138,9 @@ original SEC response and the record's own boundary sentence: these are accounti
 reported to the SEC, not market prices, returns or a recommendation. Companies and concepts
 outside the current release return an error with the available concepts listed.
 
-## The lab: backtest, summarize, stress, check feasibility
+## The lab: backtest, summarize, stress, feasibility, lookahead, placebos
 
-Four tools compute in the server process itself, on your machine or on the hosted endpoint, with
+Six tools compute in the server process itself, on your machine or on the hosted endpoint, with
 nothing sent to the API and no receipt stored. Each result names the SHA-256 of exactly the numbers
 it was computed from, and states what it does not establish.
 
@@ -175,6 +176,32 @@ it was computed from, and states what it does not establish.
   share of daily volume, square-root market impact (coefficient Y, default 1) with every copy of the
   same strategy counted, and the capital at which costs and impact eat the expected gross return.
   Every broker fact carries the date it was checked and its source.
+- **`check_leakage`** finds lookahead in a signal without seeing its code. A causal signal computed
+  on the first n rows gives exactly the values the full run gives for those rows. `plan` picks the
+  cuts (seeded, between 40% and 95% of the series); you rerun your own code on the rows before each
+  cut, and `compare` checks every column: a value that changed when the later rows were removed
+  used them. On your machine, `columns_file` takes the path of a JSON file `{cuts, columns}` your
+  script wrote (Python's `NaN` reads as missing) instead of thousands of pasted numbers. The result names the pattern: future rows with their horizon (a `shift(-5)` reads as
+  five rows), the full sample (a normalization, rank, scaling or fit over the whole series), or
+  scattered rows (filling gaps backwards). On a fixed zoo of 22 pandas and statsmodels signals
+  (`config/research/leakage-zoo.json`, from `scripts/research/leakage/`), all 11 leaks are found
+  with the right pattern and none of the 11 honest indicators is flagged. A pass covers only the
+  cuts tested: survivorship, vendor revisions or a leak confined to the first rows leave no trace.
+- **`placebo_test`** tests a whole research pipeline at once. `plan` writes your panel (`real.csv`)
+  and 19 placebos to a new folder in the system's temporary directory: the same returns with the
+  periods in a random order, the same order for every asset, so each asset keeps its returns and each
+  day its cross-section, but nothing can be predicted. Run the pipeline unchanged on each, every
+  search, filter and parameter choice included, and `compare` ranks its real result among the
+  placebo results. Every choice the pipeline makes is counted, because it makes them again on every
+  placebo. A pre-registered study chose the reordering (`scripts/research/placebo/v1/`,
+  `config/research/placebo-v1-evaluation.json`): in all 30 combinations of simulated market and
+  pipeline where nothing can be predicted (10,000 tests each; five return shapes, flat,
+  drifting and with assets that differ only in their constant means; SMA, time-series and
+  cross-sectional momentum grids), its false-positive rate at a nominal 5% was 4.6% to 5.5%.
+  On the same markets a t-test on the best rule found an edge 10.9% to 78.9% of the time,
+  and Bonferroni's correction 8.0% to 10.3% wherever the market drifted and 58.5% to
+  59.7% where assets only differed in their means. With 19 placebos the smallest p is 0.05; 99
+  give a finer one.
 
 On your own machine, `prices_file`, `series_file` and `returns_file` take a CSV or JSON path instead
 of the numbers. Only numbers are read, plus an ISO date column when the file has one, so results can
@@ -182,12 +209,27 @@ name the day a drawdown began.
 
 ## Auditing a backtest in one call
 
-`audit_backtest` takes one strategy's return series, the number of variants tried and their Sharpe
-dispersion, and optionally every variant's returns. It runs `validate_deflated_sharpe` on the
-series, then `validate_track_record` on the Sharpe, skew and kurtosis that check derived, then,
-with `variants`, `validate_overfitting`. Each check is exactly what its own tool returns, with its
-own receipt; the boundary sentences they share are stated once. A check that refuses (a Sharpe
-that cannot beat the benchmark has no minimum track record) is reported as that check's error.
+`audit_backtest` takes one strategy's return series and, ideally, every variant's returns
+(`variants` or `variants_file`, the dropped ones too); without them, the number of variants tried
+and their Sharpe spread. The result opens with:
+
+- `headline`: one test chosen because its false-positive rate was measured before anyone looked at
+  your numbers. Null Zoo v1 (`scripts/research/null-zoo/v1/` in the repository) drew hundreds of
+  thousands of simulated searches from nine return shapes with known ground truth; the bar and the
+  rule that picks the test were committed before the run. With variants the headline comes from
+  the data-snooping tests (`validate_reality_check`, with its receipt); without, from luck trials
+  with Lo's autocorrelation correction. Its sentence quotes the measured false-positive rate for
+  returns shaped like yours, and the worst across the nine shapes.
+- `fix_next`: at most five next steps, each `{id, why, next}` with a stable id.
+- `computed`: Lo's adjusted Sharpe, a stationary-bootstrap 95% interval for the Sharpe, the
+  haircut Sharpe, the minimum backtest length and, with variants, how many independent trials
+  they count as (Li and Ji) and the selected variant's out-of-sample decay.
+
+Then the checks: `validate_deflated_sharpe` on the series (an estimate), `validate_track_record`
+on the Sharpe, skew and kurtosis that check derived and, with variants, `validate_overfitting`.
+Each is exactly what its own tool returns, with its own receipt; the deflated Sharpe runs with the
+larger of the declared and counted trials and Sharpe spread, so a search cannot be made to look
+smaller than it was. A check that refuses or cannot be reached is reported as that check's error.
 The audit adds no grade of its own. Through the API it uses one validation per check.
 
 When the server runs on your machine, `returns_file` and `variants_file` take the path of the
@@ -200,10 +242,10 @@ took three audit questions from 4 of 9 to 8 of 9 answered correctly on gpt-5.4-m
 
 ## Prompts, resources and structured results
 
-Clients that show MCP prompts offer six guided workflows: `validate_backtest` (deflated Sharpe, then
+Clients that show MCP prompts offer eight guided workflows: `validate_backtest` (deflated Sharpe, then
 overfitting, then the track record needed, reported with what each number does not establish),
-`track_record_needed`, `backtest_and_validate`, `stress_my_strategy`, `production_check` and
-`summarize_market_series`. Resources: `canli://limits`, the boundary sentences every result carries;
+`track_record_needed`, `backtest_and_validate`, `stress_my_strategy`, `production_check`,
+`summarize_market_series`, `check_signal_for_lookahead` and `test_pipeline_on_placebos`. Resources: `canli://limits`, the boundary sentences every result carries;
 `canli://sources`, the papers behind each validator and how each is checked against them;
 `canli://strategy-spec`, the JSON Schema of every strategy family and its parameters; and
 `canli://openapi`, the API's OpenAPI 3.1 document. Two resource templates are for writing code
@@ -327,7 +369,7 @@ equals the hosted one; it names no receipt id because none was made.
 claude mcp add canli-local --env CANLI_LOCAL=1 -- npx -y canli-validation-mcp
 ```
 
-`get_receipt`, `service_status` and `company_financial_history` still read from canlicapital.com;
+`verify_receipt` by id, `service_status` and `company_financial_history` still read from canlicapital.com;
 they send no series. In the Claude Desktop extension this is the "Private local mode" setting.
 
 ## Generic stdio client
@@ -392,35 +434,39 @@ A validation result is the answer (`data`), the sentences above except the quota
 receipt's id and URL; an error keeps its error. The rest of the API envelope (schema, endpoint,
 timestamps, claim and capital class, the human page, the source-file hashes and the quota line)
 describes the service rather than the answer, and an agent pays for every token of it on every
-call. It stays in the stored receipt, which `get_receipt` returns in full, and in `service_status`.
+call. It stays in the stored receipt, which `verify_receipt` returns in full with `include_receipt`, and in `service_status`.
 On a breadth result this is about half the text. Set `CANLI_FULL_ENVELOPE=1` to receive every field.
 
 ## Toolsets (tokens)
 
 A client sends the model the whole tool list on every turn, and it is most of each turn's prompt:
-a validation result is a few hundred tokens, the list of all nineteen tools several thousand. A
-client that needs one kind of tool can list only that kind, with `CANLI_TOOLSETS` (stdio) or
-`?toolsets=` (hosted endpoint). The default is every tool.
+a validation result is a few hundred tokens, the list of every tool several thousand. A client
+that needs one kind of tool can list only that kind, with `CANLI_TOOLSETS` (stdio) or
+`?toolsets=` (hosted endpoint). The default is every toolset except `company`, whose one tool
+canli-fundamentals-mcp does better and point in time; `all` adds it. `get_key` is listed only when
+no key is configured.
 
 | toolset | tools |
 |---|---|
-| `validate` | `get_key`, the eight validators, `audit_backtest` |
-| `receipts` | `get_receipt`, `verify_receipt` |
+| `validate` | `get_key`, the nine validators, `audit_backtest` |
+| `receipts` | `verify_receipt` |
 | `company` | `company_financial_history` |
 | `status` | `service_status` |
-| `lab` | `backtest_strategy`, `summarize_series`, `stress_test`, `check_feasibility` |
+| `lab` | `backtest_strategy`, `summarize_series`, `stress_test`, `check_feasibility`, `check_leakage`, `placebo_test` |
 
 Measured with `bench/tool_list_tokens.py` (tokenizer: tiktoken `o200k_base`; other models'
 tokenizers give different absolute counts), in the shape an OpenAI-style client sends the list:
 
 | CANLI_TOOLSETS | tools | tokens per turn | of all |
 |---|---|---|---|
-| `all` | 19 | 5,946 | 100% |
-| `validate` | 11 | 3,685 | 62% |
-| `receipts` | 2 | 312 | 5% |
-| `company` | 1 | 273 | 5% |
+| (default) | 19 | 5,970 | 96% |
+| (default, with CANLI_KEY) | 18 | 5,834 | 93% |
+| `all` | 20 | 6,241 | 100% |
+| `validate` | 11 | 3,650 | 58% |
+| `receipts` | 1 | 182 | 3% |
+| `company` | 1 | 273 | 4% |
 | `status` | 1 | 89 | 1% |
-| `lab` | 4 | 1,595 | 27% |
+| `lab` | 6 | 2,055 | 33% |
 
 Providers cache a tool list that is identical from turn to turn and bill the cached part at a
 fraction of the price (`test/tool-list-stable.test.mjs` keeps each list byte-stable); a smaller list

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canli-validation-mcp",
-  "version": "0.11.0",
+  "version": "0.13.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.",
   "keywords": [
     "mcp",

package/src/lab-schemas.mjs

@@ -1,22 +1,26 @@
 // mcp/src/lab-schemas.mjs
 //
 // Input and output schemas for the lab tools (src/lab.mjs): backtest_strategy, summarize_series,
-// stress_test and check_feasibility. Like the validators' descriptions, each tool description
-// carries one sentence of its own result's boundary language verbatim (test/lab.test.mjs checks
-// it against the sentences the computation attaches), so an agent reads what the result cannot be
-// used to claim before it ever calls the tool. Descriptions stay terse: the tool list is re-sent to
-// the model on every turn.
+// stress_test, check_feasibility, check_leakage and placebo_test. Like the validators'
+// descriptions, each tool description carries one sentence of its own result's boundary language
+// verbatim (test/lab.test.mjs checks it against the sentences the computation attaches), so an
+// agent reads what the result cannot be used to claim before it ever calls the tool. Descriptions
+// stay terse: the tool list is re-sent to the model on every turn.
 import { z } from "zod";
 import { BACKTEST_LIMITS_TEXT, FAMILIES } from "./local/js/backtest-core.js";
 import { FEASIBILITY_LIMITS_TEXT } from "./local/js/feasibility-core.js";
 import { SUMMARY_LIMITS_TEXT } from "./local/js/series-summary-core.js";
 import { STRESS_LIMITS_TEXT } from "./local/js/stress-core.js";
+import { LEAKAGE_LIMITS_TEXT } from "./local/js/leakage-core.js";
+import { PLACEBO_LIMITS_TEXT, PLACEBO_METHODS } from "./local/js/placebo-core.js";
 
 export const LAB_BOUNDARY = Object.freeze({
   backtest_strategy: BACKTEST_LIMITS_TEXT[3],
   summarize_series: SUMMARY_LIMITS_TEXT[2],
   stress_test: STRESS_LIMITS_TEXT[2],
   check_feasibility: FEASIBILITY_LIMITS_TEXT[0],
+  check_leakage: LEAKAGE_LIMITS_TEXT[0],
+  placebo_test: PLACEBO_LIMITS_TEXT[0],
 });
 
 export const LAB_TOOL_DESCRIPTIONS = Object.freeze({
@@ -24,6 +28,8 @@ export const LAB_TOOL_DESCRIPTIONS = Object.freeze({
   summarize_series: `A long price or return series in about 100 words plus fields: growth, risk, dated drawdowns, trend, volatility regime, tails, jumps, stale data. Use instead of reading raw bars. ${LAB_BOUNDARY.summarize_series}`,
   stress_test: `Stress a strategy's returns: bootstrap histories (how often the drawdown limit breaks or Sharpe turns negative) and named crash, volatility, repeat and stuck-position scenarios, with a fragility share. ${LAB_BOUNDARY.stress_test}`,
   check_feasibility: `Check a trading plan before it trades: broker order-rate and minimum-order limits, 2026 US day-trading rules, square-root market impact with crowding, and the capital where costs eat the return. ${LAB_BOUNDARY.check_feasibility}`,
+  check_leakage: `Does a signal look ahead? plan gives cuts; rerun your code on the first cut rows for each, then compare. Rows that changed used later rows; the result names the pattern and horizon. No code is sent. ${LAB_BOUNDARY.check_leakage}`,
+  placebo_test: `Does your pipeline find edges in noise? plan writes placebo files (your data's returns in random orders, so nothing is predictable); run the whole pipeline on real.csv and on each, then compare for a p-value that counts every choice it makes. ${LAB_BOUNDARY.placebo_test}`,
 });
 
 const FAMILY_NAMES = Object.keys(FAMILIES);
@@ -102,6 +108,37 @@ export const feasibilityInput = z
   })
   .strict();
 
+export const leakageInput = z
+  .object({
+    action: z.enum(["plan", "compare"]),
+    observations: z.number().int().optional().describe("plan: rows in the series."),
+    prefixes: z.number().int().optional().describe("plan: cuts, default 5."),
+    seed: z.number().int().optional(),
+    cuts: z.array(z.number().int()).optional().describe("compare: plan's cuts."),
+    // Shapes and lengths are checked by the computation (js/leakage-core.js) with messages that
+    // say what to send; the advertised schema stays small because it is re-sent every turn.
+    columns: z.record(z.string(), z.looseObject({})).optional().describe("compare: {name: {full: [all rows], prefixes: [[first cuts[i] rows], ...]}}, null for missing."),
+    columns_file: z.string().optional().describe("compare, on your machine: a JSON file {cuts, columns} instead."),
+    timestamps: z.array(z.string()).optional(),
+    tolerance: z.number().optional().describe("Default 1e-9."),
+  })
+  .strict();
+
+export const placeboInput = z
+  .object({
+    action: z.enum(["plan", "compare"]),
+    data_file: z.string().optional().describe("plan, on your machine: CSV or JSON, a column per asset, dates optional."),
+    columns: z.record(z.string(), z.array(z.number())).optional().describe("plan: {asset: [values]} instead of data_file."),
+    kind: z.enum(["prices", "returns"]).optional().describe("plan: default prices."),
+    placebos: z.number().int().optional().describe("plan: default 19, up to 199."),
+    method: z.enum(PLACEBO_METHODS).optional(),
+    seed: z.number().int().optional(),
+    real: z.number().optional().describe("compare: the pipeline's result on the real data."),
+    placebo_results: z.array(z.number()).optional().describe("compare: its result on each placebo, in file order."),
+    lower_is_better: z.boolean().optional(),
+  })
+  .strict();
+
 const loose = z.looseObject({}).optional();
 const sentences = z.array(z.string()).optional();
 
@@ -117,6 +154,14 @@ export const stressOutput = z
   .looseObject({ baseline: loose, resampled: loose, scenarios: z.array(z.unknown()).optional(), fragility: loose, plain_reading: z.string().optional(), limits: sentences, source: loose })
   .describe("resampled holds bootstrap percentiles and breach frequencies; scenarios each named stress and its rule; fragility the share of histories breaking the limit or losing.");
 
+export const leakageOutput = z
+  .looseObject({ verdict: z.string().optional(), cuts: z.array(z.number()).optional(), seed: z.number().optional(), columns: loose, flagged_columns: z.array(z.string()).optional(), plain_reading: z.string().optional(), limits: sentences, source: loose })
+  .describe("plan: cuts and seed. compare: verdict over all columns, flagged_columns, and per column its pattern, sentence and per-cut changes.");
+
+export const placeboOutput = z
+  .looseObject({ verdict: z.string().optional(), p_value: z.number().optional(), dir: z.string().optional(), files: z.array(z.string()).optional(), placebo: loose, plain_reading: z.string().optional(), limits: sentences, source: loose })
+  .describe("plan: dir, real.csv and the placebo files, method and seed. compare: verdict, p_value, and what the pipeline found on the placebos.");
+
 export const feasibilityOutput = z
   .looseObject({ verdict: z.string().optional(), checks: z.array(z.unknown()).optional(), to_change: z.array(z.string()).optional(), sources: loose, plain_reading: z.string().optional(), limits: sentences })
   .describe("verdict summarizes the checks; each check has a status (ok, warning, blocking, unknown), its finding and numbers; to_change lists what to fix.");

package/src/lab.mjs

@@ -13,17 +13,23 @@
 //
 // Also here: the code-generation resources (every tool's exact JSON Schemas, the strategy spec,
 // runnable client examples, the API's OpenAPI document) and the lab's guided prompts.
-import { createHash } from "node:crypto";
+import { createHash, randomInt } from "node:crypto";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { ResourceTemplate } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import { BACKTEST_LIMITS, BACKTEST_LIMITS_TEXT, FAMILIES, runBacktest } from "./local/js/backtest-core.js";
 import { FEASIBILITY_LIMITS_TEXT, checkFeasibility } from "./local/js/feasibility-core.js";
 import { SUMMARY_LIMITS_TEXT, summarizeSeries } from "./local/js/series-summary-core.js";
 import { STRESS_LIMITS_TEXT, stressTest } from "./local/js/stress-core.js";
-import { LAB_TOOL_DESCRIPTIONS, backtestInput, backtestOutput, feasibilityInput, feasibilityOutput, stressInput, stressOutput, summarizeInput, summaryOutput } from "./lab-schemas.mjs";
-import { readSeriesWithDates } from "./series-file.mjs";
+import { LEAKAGE_LIMITS, LEAKAGE_LIMITS_TEXT, checkLeakage, planPrefixes } from "./local/js/leakage-core.js";
+import { PLACEBO_DEFAULT_METHOD, PLACEBO_LIMITS, PLACEBO_LIMITS_TEXT, checkPanel, placeboPValue, placeboPanels } from "./local/js/placebo-core.js";
+import { LAB_TOOL_DESCRIPTIONS, backtestInput, backtestOutput, feasibilityInput, feasibilityOutput, leakageInput, leakageOutput, placeboInput, placeboOutput, stressInput, stressOutput, summarizeInput, summaryOutput } from "./lab-schemas.mjs";
+import { readColumnsFile, readPanelFile, readSeriesWithDates, writePanelFile } from "./series-file.mjs";
+import { leanJsonSchema } from "./schemas.mjs";
 
-export const LAB_TOOLS = Object.freeze(["backtest_strategy", "summarize_series", "stress_test", "check_feasibility"]);
+export const LAB_TOOLS = Object.freeze(["backtest_strategy", "summarize_series", "stress_test", "check_feasibility", "check_leakage", "placebo_test"]);
 
 // Same shape as every other tool's result: the object as text, and as structured content.
 const labText = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }], structuredContent: value });
@@ -83,16 +89,129 @@ export async function toolCheckFeasibility(session, args) {
   return labText({ ...checkFeasibility(input), limits: FEASIBILITY_LIMITS_TEXT });
 }
 
+// check_leakage: plan picks the cut points (a fresh seed unless one is sent, so the caller does not
+// choose them); compare reads the caller's outputs and reports, per column, what changed and why.
+export async function toolCheckLeakage(session, args) {
+  const input = parse(leakageInput, args, "check_leakage");
+  if (input.action === "plan") {
+    if (input.observations === undefined) throw new Error("check_leakage: plan needs observations, the number of rows in the full series");
+    const seed = input.seed ?? randomInt(1, 2 ** 31);
+    const cuts = planPrefixes(input.observations, { prefixes: input.prefixes ?? LEAKAGE_LIMITS.default_prefixes, seed });
+    return labText({
+      schema: "canli.leakage-plan.v1", observations: input.observations, cuts, seed,
+      plain_reading: `Run your signal code ${cuts.length + 1} times: on all ${input.observations} rows, and on the first ${cuts.join(", ")} rows. Send each output column with action compare and these cuts; prefixes[i] holds the run on the first cuts[i] rows.`,
+      limits: LEAKAGE_LIMITS_TEXT,
+    });
+  }
+  let { cuts, columns, timestamps } = input;
+  if (input.columns_file !== undefined) {
+    if (columns !== undefined) throw new Error("check_leakage: send columns or columns_file, not both");
+    if (session.hosted) throw new Error("check_leakage: the hosted endpoint cannot read files on your machine; send columns as numbers, or run the server locally with npx -y canli-validation-mcp.");
+    const file = readColumnsFile(input.columns_file);
+    if (cuts !== undefined && file.cuts !== undefined && JSON.stringify(cuts) !== JSON.stringify(file.cuts)) throw new Error("check_leakage: the cuts sent differ from the cuts in columns_file");
+    cuts ??= file.cuts;
+    columns = file.columns;
+    timestamps ??= file.timestamps;
+  }
+  if (cuts === undefined || columns === undefined) throw new Error("check_leakage: compare needs cuts (from plan) and columns, sent or in a columns_file");
+  const result = checkLeakage({ cuts, columns, tolerance: input.tolerance, timestamps: labels(timestamps) });
+  // Per cut, only what a reader needs: where the changes start and how large they are.
+  const report = Object.fromEntries(Object.entries(result.columns).map(([name, c]) => [name, {
+    verdict: c.verdict, pattern: c.pattern, sentence: c.sentence,
+    ...(c.horizon_rows !== undefined ? { horizon_rows: c.horizon_rows } : {}),
+    ...(c.share_changed !== undefined ? { share_changed: c.share_changed } : {}),
+    ...(c.first_changed_at !== undefined ? { first_changed_at: c.first_changed_at } : {}),
+    per_cut: c.prefixes.map((p) => ({ cut: p.cut, changed: p.changed, first_changed: p.first_changed, max_abs_difference: p.max_abs_difference })),
+  }]));
+  const flagged = result.flagged_columns;
+  return labText({
+    schema: "canli.leakage.v1", verdict: result.verdict, flagged_columns: flagged, cuts: result.cuts, columns: report,
+    source: { ...(input.columns_file !== undefined ? { columns_file: input.columns_file } : {}), input_sha256: digest({ cuts, columns }) },
+    plain_reading: flagged.length
+      ? `Lookahead in ${flagged.length} of ${Object.keys(report).length} column${Object.keys(report).length === 1 ? "" : "s"} (${flagged.join(", ")}). ${flagged.map((n) => `${n}: ${report[n].sentence}`).join(" ")}`
+      : `No value changed in ${Object.keys(report).length} column${Object.keys(report).length === 1 ? "" : "s"} at ${result.cuts.length} cuts: these prefixes found no lookahead.`,
+    limits: LEAKAGE_LIMITS_TEXT,
+  });
+}
+
+// placebo_test: plan reorders the periods of the caller's panel, the same order for every column,
+// and writes the real panel and each placebo as CSV to a new folder in the system's temporary
+// directory (the hosted endpoint, which writes nothing, returns small placebos inline); compare
+// ranks the pipeline's real result among its placebo results.
+const PLACEBO_INLINE_MAX = 50000;
+const short = (x) => Number(x.toPrecision(4));
+
+export async function toolPlaceboTest(session, args) {
+  const input = parse(placeboInput, args, "placebo_test");
+  if (input.action === "compare") {
+    if (input.real === undefined || input.placebo_results === undefined) throw new Error("placebo_test: compare needs real and placebo_results, from the pipeline's runs on real.csv and the placebo files");
+    const r = placeboPValue(input.real, input.placebo_results, { higherIsBetter: !input.lower_is_better });
+    const beats = r.as_good_as_real === 0;
+    const luck = `On the placebos, where nothing can be predicted, it found a median of ${short(r.placebo.median)} and at best ${short(r.placebo.best)}.`;
+    return labText({
+      schema: "canli.placebo.v1", verdict: r.p_value <= 0.05 ? "beats_placebos" : "within_placebo_range", ...r,
+      source: { input_sha256: digest({ real: input.real, placebo_results: input.placebo_results }) },
+      plain_reading: beats
+        ? `The pipeline's real result, ${short(r.real)}, beat all ${r.placebos} placebos: p = ${short(r.p_value)}, the smallest ${r.placebos} placebos can give${r.placebos < 99 ? "; 99 placebos give a finer p" : ""}. ${luck}`
+        : `${r.as_good_as_real} of ${r.placebos} placebos gave a result at least as good as the real one, ${short(r.real)}: p = ${short(r.p_value)}. ${luck}`,
+      limits: PLACEBO_LIMITS_TEXT,
+    });
+  }
+  if ((input.data_file === undefined) === (input.columns === undefined)) throw new Error("placebo_test: plan needs exactly one of data_file or columns");
+  const kind = input.kind ?? "prices";
+  const method = input.method ?? PLACEBO_DEFAULT_METHOD;
+  const placebos = input.placebos ?? PLACEBO_LIMITS.default_placebos;
+  const seed = input.seed ?? randomInt(1, 2 ** 31);
+  let panel;
+  if (input.data_file !== undefined) {
+    if (session.hosted) throw new Error("placebo_test: the hosted endpoint cannot read files on your machine; send columns as numbers, or run the server locally with npx -y canli-validation-mcp.");
+    panel = readPanelFile(input.data_file);
+  } else {
+    const names = Object.keys(input.columns);
+    panel = { columns: names.map((n) => input.columns[n]), names, dates: null, date_name: null, skipped: [], format: "csv" };
+  }
+  checkPanel(panel.columns, kind);
+  const source = {
+    ...(input.data_file !== undefined ? { data_file: input.data_file, column_positions: panel.positions, ...(panel.date_column ? { date_column_position: panel.date_column } : {}), ...(panel.skipped.length ? { skipped_row_counter_columns: panel.skipped } : {}) } : {}),
+    columns: panel.columns.length, rows: panel.columns[0].length, input_sha256: digest(panel.columns),
+  };
+  const made = placeboPanels(panel.columns, { kind, method, placebos, seed });
+  const plan = { schema: "canli.placebo-plan.v1", kind, method, placebos, seed };
+  if (session.hosted) {
+    if (placebos * panel.columns.length * panel.columns[0].length > PLACEBO_INLINE_MAX) throw new Error(`placebo_test: the hosted endpoint returns at most ${PLACEBO_INLINE_MAX} placebo numbers; send fewer rows or columns, or run the server locally with npx -y canli-validation-mcp, which writes the placebos to files`);
+    const names = panel.names;
+    return labText({ ...plan, placebo_columns: [...made].map((p) => Object.fromEntries(names.map((n, i) => [n, p[i]]))), plain_reading: `Run the pipeline unchanged on the real columns and on each of the ${placebos} placebos, then send its results to compare in this order.`, limits: PLACEBO_LIMITS_TEXT, source });
+  }
+  const dir = mkdtempSync(join(tmpdir(), "canli-placebo-"));
+  const layout = { names: panel.names, dates: panel.dates, dateName: panel.date_name, format: panel.format };
+  const real = `real.${panel.format}`;
+  writePanelFile(join(dir, real), { ...layout, columns: panel.columns });
+  const files = [];
+  for (const columns of made) {
+    const name = `placebo_${String(files.length + 1).padStart(3, "0")}.${panel.format}`;
+    writePanelFile(join(dir, name), { ...layout, columns });
+    files.push(name);
+  }
+  return labText({
+    ...plan, dir, real, files,
+    plain_reading: `Run the pipeline unchanged, every search and choice included, on ${real} and on each of the ${placebos} placebo files in ${dir}, record the one number it reports (such as its best Sharpe), and send them to compare in file order.`,
+    limits: PLACEBO_LIMITS_TEXT, source,
+  });
+}
+
 // The lab computes locally and changes nothing anywhere: read-only, closed world, idempotent.
 const LAB_ANNOTATIONS = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 
 export function labToolSpecs(session) {
-  const spec = (name, title, input, output, handler) => [name, { title, annotations: { title, ...LAB_ANNOTATIONS }, description: LAB_TOOL_DESCRIPTIONS[name], inputSchema: input, outputSchema: output }, (args) => handler(session, args)];
+  const spec = (name, title, input, output, handler, annotations = LAB_ANNOTATIONS) => [name, { title, annotations: { title, ...annotations }, description: LAB_TOOL_DESCRIPTIONS[name], inputSchema: input, outputSchema: output }, (args) => handler(session, args)];
   return [
     spec("backtest_strategy", "Backtest a rule over a parameter grid, validated", backtestInput, backtestOutput, toolBacktestStrategy),
     spec("summarize_series", "Summarize a price or return series", summarizeInput, summaryOutput, toolSummarizeSeries),
     spec("stress_test", "Stress-test a strategy's returns", stressInput, stressOutput, toolStressTest),
     spec("check_feasibility", "Check a plan against broker limits and impact", feasibilityInput, feasibilityOutput, toolCheckFeasibility),
+    spec("check_leakage", "Check a signal for lookahead", leakageInput, leakageOutput, toolCheckLeakage),
+    // plan writes files, each call to a new temporary folder: not read-only, not idempotent.
+    spec("placebo_test", "Test a research pipeline on placebo data", placeboInput, placeboOutput, toolPlaceboTest, { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }),
   ];
 }
 
@@ -114,7 +233,6 @@ export const EXAMPLE_ARGS = Object.freeze({
   validate_haircut_sharpe: { observed_sharpe_annualized: 1.5, periods_per_year: 252, observations: 1260, tests: 50 },
   validate_luck_trials: { observed_sharpe_annualized: 1.5, periods_per_year: 252, observations: 1260 },
   audit_backtest: { returns_file: "backtest_returns.csv", periods_per_year: 252, effective_independent_trials: 20, cross_trial_sharpe_sd_annualized: 0.5 },
-  get_receipt: { id: "0123456789abcdef01234567" },
   verify_receipt: { id: "0123456789abcdef01234567" },
   service_status: {},
   company_financial_history: { ticker: "AAPL", concept: "Assets", limit: 8 },
@@ -122,6 +240,8 @@ export const EXAMPLE_ARGS = Object.freeze({
   summarize_series: { series_file: "prices.csv", series_kind: "prices", name: "My asset" },
   stress_test: { returns_file: "strategy_returns.csv", drawdown_limit: 0.2, paths: 1000, seed: 42 },
   check_feasibility: { broker: "alpaca", asset_class: "us_equity", account: "margin", capital_usd: 250000, orders_per_rebalance: 40, rebalances_per_year: 52, turnover_per_year: 8, adv_usd: 20000000, daily_volatility: 0.02, copies: 1, expected_gross_return: 0.12, spread_and_fees_bps: 3 },
+  check_leakage: { action: "plan", observations: 2520, prefixes: 5 },
+  placebo_test: { action: "plan", data_file: "prices.csv" },
 });
 
 const usesFile = (args) => Object.keys(args).some((k) => k.endsWith("_file"));
@@ -221,7 +341,7 @@ export function registerCodeResources(server, session, catalog) {
     (uri, { tool }) => {
       const entry = catalog[tool];
       if (!entry) throw new Error(`No tool ${tool}; tools are ${names.join(", ")}`);
-      const body = { tool, description: entry.description, input_schema: z.toJSONSchema(entry.inputSchema, { io: "input" }), output_schema: z.toJSONSchema(entry.outputSchema, { io: "output" }) };
+      const body = { tool, description: entry.description, input_schema: leanJsonSchema(z.toJSONSchema(entry.inputSchema, { io: "input" })), output_schema: leanJsonSchema(z.toJSONSchema(entry.outputSchema, { io: "output" })) };
       return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(body, null, 2) }] };
     },
   );
@@ -306,4 +426,26 @@ export function registerLabPrompts(server) {
       "Point out anything in the data check (stale prices, jumps) that should be fixed before the series is backtested.",
     ],
   );
+  prompt(
+    "check_signal_for_lookahead",
+    "Does my signal look ahead?",
+    "Rerun your own signal code on prefixes the server picks, and find any value that depends on later rows.",
+    { rows: z.string().describe("Rows in the full series the signal is computed on") },
+    ({ rows }) => [
+      `Call check_leakage with action plan and observations ${rows}.`,
+      "Run your own signal and feature code once on all rows and once on the first cut rows for each cut it returns, changing nothing else, and send every output column with action compare. On this machine, write them to a JSON file {cuts, columns} and send its path as columns_file instead of pasting numbers.",
+      "For each flagged column, explain the pattern (future rows with their horizon, full-sample statistics, filled gaps), find the line of code that causes it, fix it, and run the check again. Say that a pass covers only these cuts.",
+    ],
+  );
+  prompt(
+    "test_pipeline_on_placebos",
+    "Does my pipeline find edges in noise?",
+    "Run your whole research pipeline on placebo data, where nothing can be predicted, and see whether its real result beats what it finds there.",
+    { data_file: z.string().describe("Path to the CSV or JSON the pipeline reads: a column per asset, dates optional") },
+    ({ data_file }) => [
+      `Call placebo_test with action plan and data_file ${data_file}.`,
+      "Run the research pipeline unchanged, every search, filter and parameter choice included, on real.csv and on each placebo file in the folder it returns, and record the one number the pipeline reports, such as its best Sharpe.",
+      "Call placebo_test with action compare, the real number as real and the placebo numbers in file order as placebo_results. Explain the p-value and what the pipeline finds on data where nothing can be predicted, and say that only this pipeline's search is counted, not pipelines tried before it.",
+    ],
+  );
 }