canli-validation-mcp 0.10.1 → 0.12.0

package/README.md

@@ -71,9 +71,19 @@ repository for the full design.
 
 ## Tools
 
+Unreleased source adds local journal binding to `validate_paper_evidence`: run
+`CANLI_LOCAL=1 node mcp/src/server.mjs` from the repository, and send exactly one of `record`
+or `record_file`, plus `journal_file` to check source hashes, signatures and recomputed claims.
+`record_file` accepts a standard record, a `{record,signature}` envelope, or the full execution
+export bundle; companion metrics/observations are checked for full bundles. Signed records
+need the detached signature. `bindings.all_match` must be true for source validation to pass.
+Without a journal, the result explicitly reports structure-only conformance. Files and
+signatures are refused in hosted/remote mode and never uploaded. Local results have no Canli
+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 |
@@ -83,9 +93,8 @@ repository for the full design.
 | `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 |
 
@@ -127,14 +136,72 @@ 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
+
+Four 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.
+
+- **`backtest_strategy`** runs a rule over every parameter set in a grid, on your prices:
+  `sma_cross` (fast, slow), `momentum` (lookback, skip), `mean_reversion` (window, entry_z),
+  `breakout` (lookback) or `buy_and_hold`, long-only or with `allow_short`, after a cost per unit
+  of turnover. The position held over each period is decided from closes up to the one before it,
+  so no rule can see the future (a test changes later prices and checks that no earlier position
+  moves). It then validates the best variant with the number of variants **this call ran**, not a
+  number someone declared: the deflated Sharpe ratio across the grid's measured Sharpe dispersion,
+  the CSCV probability of backtest overfitting on every variant's returns, the probabilistic Sharpe
+  and the minimum track record, next to buy and hold over the same window. At most 200 variants and
+  20,000 prices per call. No code is ever run: a strategy is a family plus numbers.
+- **`summarize_series`** reads a long price or return series and states it in about a hundred words,
+  plus a field for every figure: growth, volatility, Sharpe and drift t-statistic, the worst
+  drawdown with its dates and recovery, trend, the volatility regime (terciles of its own 21-period
+  volatility), tails, jumps (beyond six robust standard deviations), autocorrelation, stale data and,
+  with a benchmark, correlation and beta. A five-year daily series is about 1,260 numbers; the
+  summary is a paragraph.
+- **`stress_test`** resamples a strategy's returns with a stationary block bootstrap (seeded, so a run
+  reproduces exactly) and reports how often the drawdown limit breaks and the Sharpe turns negative,
+  then applies four named scenarios with their rules stated: a crash at the equity high (default the
+  larger of 20% and three times the worst period), volatility multiplied, the worst stretch lived
+  twice, and positions stuck for several periods after the worst one. The fragility share is the part
+  of resampled histories that break the drawdown limit or lose money on a risk-adjusted basis.
+  Generative models are not used: trained on one series they memorize it or invent dynamics nobody
+  can check.
+- **`check_feasibility`** checks a plan against a real broker before it trades: the broker's published
+  order-rate limit against the rebalance's burst of orders (Alpaca 200 a minute, Interactive Brokers
+  about 50 a second), the minimum order (Alpaca 1 USD notional), US day-trading rules as they stand
+  in 2026 (FINRA retired the pattern day trader rule and its 25,000 USD minimum on 4 June 2026; firms
+  may phase in its replacement until 20 October 2027), T+1 settlement in cash accounts, each order's
+  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.
+
+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
+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
@@ -147,11 +214,18 @@ 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 two guided workflows: `validate_backtest` (deflated Sharpe, then
-overfitting, then the track record needed, reported with what each number does not establish) and
-`track_record_needed`. Two resources can be read: `canli://limits`, the boundary sentences every
-result carries, and `canli://sources`, the papers behind each validator and how each is checked
-against them. Every tool result carries its envelope both as text and as `structuredContent`.
+Clients that show MCP prompts offer six 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;
+`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
+against the tools: `canli://schemas/{tool}` returns a tool's exact input and output JSON Schema, and
+`canli://examples/{language}/{tool}` a working call in `python`, `javascript` or `curl` (both
+variables complete). A test compiles every generated Python and JavaScript example and checks that
+every example's arguments are valid input. Every tool result carries its envelope both as text and
+as `structuredContent`.
 
 ## Compact context (0.3.0)
 
@@ -183,7 +257,7 @@ an array of objects.
 | `CANLI_API_BASE` | `https://canlicapital.com` | Where the API lives. Point it at a preview deployment for testing. |
 | `CANLI_KEY` | unset | A key already issued from `POST /api/v1/keys`. When set, `get_key` sends no request and reports the key is already configured; every other tool sends it as `Authorization: Bearer <key>`. |
 | `CANLI_FULL_ENVELOPE` | unset | `1` or `true` returns each validation's full API envelope instead of the compact result (below). |
-| `CANLI_TOOLSETS` | all | Which tools to list: a comma-separated choice of `validate`, `receipts`, `company` and `status`, or `all`. An unknown name is refused at startup. See "Toolsets" below. |
+| `CANLI_TOOLSETS` | all | Which tools to list: a comma-separated choice of `validate`, `receipts`, `company`, `status` and `lab`, or `all`. An unknown name is refused at startup. See "Toolsets" below. |
 | `CANLI_LOCAL` | unset | `1` or `true` runs the eight validators on this machine (private local mode, below): no key, no network, no receipt. |
 
 If `CANLI_KEY` is not set and local mode is off, call `get_key` once per session before the validators. The key it
@@ -267,7 +341,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
@@ -332,33 +406,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 fifteen 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` |
+| `receipts` | `verify_receipt` |
 | `company` | `company_financial_history` |
 | `status` | `service_status` |
+| `lab` | `backtest_strategy`, `summarize_series`, `stress_test`, `check_feasibility` |
 
 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` | 15 | 4,194 | 100% |
-| `validate` | 11 | 3,526 | 84% |
-| `receipts` | 2 | 312 | 7% |
-| `company` | 1 | 273 | 7% |
+| (default) | 17 | 5,581 | 95% |
+| (default, with CANLI_KEY) | 16 | 5,445 | 93% |
+| `all` | 18 | 5,852 | 100% |
+| `validate` | 11 | 3,708 | 63% |
+| `receipts` | 1 | 195 | 3% |
+| `company` | 1 | 273 | 5% |
 | `status` | 1 | 89 | 2% |
+| `lab` | 4 | 1,595 | 27% |
 
 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.10.1",
+  "version": "0.12.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",
@@ -15,7 +15,10 @@
     "overfitting",
     "quantitative-finance",
     "quant",
-    "trading"
+    "trading",
+    "backtest-engine",
+    "stress-test",
+    "market-impact"
   ],
   "private": false,
   "type": "module",

package/src/journal-evidence.mjs

@@ -0,0 +1,35 @@
+import { resolve } from 'node:path';
+import { computeLocally } from './local.mjs';
+import { MAX_JOURNAL_BYTES, readBoundedFile, readRecordFile } from './local/js/journal-files.js';
+import { journalBindings } from './local/js/trade-journal-export-core.js';
+
+export function validateLocalJournalEvidence(input) {
+  let record = input.record, signature = input.signature, bundle;
+  if (input.record_file) {
+    const file = readRecordFile(resolve(input.record_file));
+    if (file && typeof file === 'object' && Object.hasOwn(file, 'record')) {
+      record = file.record;
+      // A {record,signature} envelope is also accepted. Full exports advertise their
+      // financial companion fields and those must be recomputed, not ignored.
+      if (Object.keys(file).some(k => !['record', 'signature'].includes(k))) bundle = file;
+      if (signature !== undefined && file.signature !== undefined) throw new Error('send a detached signature inline or in the record file, not both');
+      signature ??= file.signature;
+    } else record = file;
+    if (!record || typeof record !== 'object' || Array.isArray(record) || record.schema !== 'canli.paper-evidence.v0') throw new Error('record file must contain a canli.paper-evidence.v0 record or export bundle');
+  }
+  const result = computeLocally('validate_paper_evidence', { record });
+  if (result.failed) return result;
+  const data = result.envelope.data;
+  const unchecked = { checked: false, all_match: null, reason: 'No source journal checked; conformance covers structure and field relationships only.' };
+  // Conformance first prevents malformed record members from reaching the financial verifier.
+  const bindings = input.journal_file && data.valid
+    ? journalBindings(record, readBoundedFile(resolve(input.journal_file), { maxBytes: MAX_JOURNAL_BYTES }), signature, bundle)
+    : input.journal_file ? { checked: false, all_match: false, reason: 'Source verification requires a conforming record.' } : unchecked;
+  data.bindings = bindings;
+  data.conformance_valid = data.valid;
+  if (input.journal_file) {
+    data.valid = data.valid && bindings.all_match === true;
+    data.plain_reading = data.valid ? 'The record conforms and its reconstructable claims match the supplied signed journal and selected range. Key possession is self-attestation; broker authenticity, completeness and trusted time are not established.' : 'Conformance or source-bound recomputation failed; this record has not passed journal verification.';
+  } else data.plain_reading += ' No source journal or record signature was checked.';
+  return result;
+}

package/src/lab-schemas.mjs

@@ -0,0 +1,122 @@
+// 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.
+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";
+
+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],
+});
+
+export const LAB_TOOL_DESCRIPTIONS = Object.freeze({
+  backtest_strategy: `Backtest a rule on your prices over a whole parameter grid, then validate the best with the count of variants actually run: deflated Sharpe, overfitting probability, minimum track record, vs buy and hold, after costs. ${LAB_BOUNDARY.backtest_strategy}`,
+  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}`,
+});
+
+const FAMILY_NAMES = Object.keys(FAMILIES);
+// Lengths, counts and magnitudes are checked by the computation itself (src/local/js/*-core.js),
+// with messages that say what to send instead; the advertised schema keeps types, enums and the
+// bounds that tell a model what a value means (fractions, signs), because every bound here is
+// re-sent to the model on every turn.
+const series = () => z.array(z.number());
+const file = (what) => z.string().describe(`CSV or JSON of ${what} on this machine; local server only.`);
+const column = z.union([z.string(), z.number().int()]).describe("Column name or 1-based position.");
+const periods = z.number().describe("252 daily (default), 365 crypto, 52 weekly, 12 monthly.");
+const dates = z.array(z.string()).describe("Optional ISO dates, one per value.");
+
+export const backtestInput = z
+  .object({
+    family: z.enum(FAMILY_NAMES).describe("sma_cross (fast, slow), momentum (lookback, skip), mean_reversion (window, entry_z), breakout (lookback), buy_and_hold."),
+    grid: z.record(z.string(), z.union([z.number(), z.array(z.number())])).optional()
+      .describe('Values per parameter, e.g. {"fast":[10,20],"slow":[50,200]}; every valid combination runs (max 200).'),
+    prices: series().optional().describe("Prices, oldest first."),
+    prices_file: file("prices").optional(),
+    prices_column: column.optional(),
+    dates: dates.optional(),
+    periods_per_year: periods.optional(),
+    cost_bps: z.number().min(0).optional().describe("Cost per unit of turnover, bps; default 5."),
+    allow_short: z.boolean().optional().describe("Short instead of flat; default false."),
+  })
+  .strict();
+
+export const summarizeInput = z
+  .object({
+    prices: series().optional().describe("Prices, oldest first; or returns, or series_file."),
+    returns: z.array(z.number()).optional().describe("Returns as fractions, oldest first."),
+    series_file: file("prices or returns").optional(),
+    series_column: column.optional(),
+    series_kind: z.enum(["prices", "returns"]).optional().describe("series_file holds; default prices."),
+    dates: dates.optional(),
+    periods_per_year: periods.optional(),
+    benchmark_returns: z.array(z.number()).optional().describe("Same-period benchmark returns; adds beta."),
+    name: z.string().optional().describe("Label for the text."),
+  })
+  .strict();
+
+export const stressInput = z
+  .object({
+    returns: z.array(z.number()).optional().describe("Strategy returns as fractions, oldest first."),
+    returns_file: file("returns").optional(),
+    returns_column: column.optional(),
+    periods_per_year: periods.optional(),
+    paths: z.number().int().optional().describe("Default 1000."),
+    block: z.number().optional().describe("Mean block length; default cube root of n."),
+    seed: z.number().int().optional().describe("Default 42; reproduces exactly."),
+    drawdown_limit: z.number().gt(0).lt(1).optional().describe("Fraction; default 0.2."),
+    crash: z.number().gt(-1).lt(0).optional().describe("Crash size, negative; default min(-0.2, 3x worst period)."),
+    volatility_multiplier: z.number().optional().describe("Default 2."),
+    outage_periods: z.number().int().optional().describe("Stuck periods after the worst; default 5."),
+  })
+  .strict();
+
+export const feasibilityInput = z
+  .object({
+    broker: z.enum(["alpaca", "ibkr", "other"]).optional().describe("Default other."),
+    asset_class: z.enum(["us_equity", "crypto", "futures", "fx", "options"]).optional(),
+    account: z.enum(["cash", "margin"]).optional(),
+    capital_usd: z.number(),
+    orders_per_rebalance: z.number().int(),
+    rebalances_per_year: z.number(),
+    turnover_per_year: z.number().min(0).describe("Buys plus sells a year / capital."),
+    adv_usd: z.number().describe("Daily dollar volume of a typical holding."),
+    daily_volatility: z.number().max(1).describe("Of a typical holding, e.g. 0.02."),
+    copies: z.number().int().optional().describe("Agents trading the same signal at once; default 1."),
+    expected_gross_return: z.number().min(-1).optional().describe("Annual, before costs; adds capacity."),
+    spread_and_fees_bps: z.number().min(0).optional().describe("Per trade; default 0."),
+    impact_coefficient: z.number().optional().describe("Square-root law Y; default 1."),
+    minutes_per_rebalance: z.number().optional().describe("Default 1."),
+    orders_per_minute_limit: z.number().optional().describe("If the broker's is not on file."),
+  })
+  .strict();
+
+const loose = z.looseObject({}).optional();
+const sentences = z.array(z.string()).optional();
+
+export const backtestOutput = z
+  .looseObject({ variants: loose, selected: loose, buy_and_hold: loose, validation: loose, plain_reading: z.string().optional(), limits: sentences, source: loose })
+  .describe("selected holds the best variant's parameters and metrics; validation the deflated Sharpe, overfitting probability and minimum track record counting every variant run; plain_reading states them.");
+
+export const summaryOutput = z
+  .looseObject({ text: z.string().optional(), growth: loose, risk: loose, drawdown: loose, trend: loose, volatility: z.looseObject({}).nullable().optional(), tails: loose, jumps: loose, limits: sentences, source: loose })
+  .describe("text is the summary to read; the other fields hold each figure by the rule named in it.");
+
+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 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.");