create-tradejs 3.1.24-beta.240 → 3.1.25-beta.242

package/dist/skill-bundle/.codex/skills/ai-train-local-research/references/gate-ablation.md

@@ -116,6 +116,10 @@ set, pass `--spec path/to/variants.json`:
 }
 ```
 
+JSON reports include timestamp-grouped cumulative `equity` arrays for the
+current-gate baseline and every variant. Use these checksum-bound arrays for
+final-composition charts instead of reconstructing curves by hand.
+
 ## Expression Grammar
 
 Expressions support parentheses, `&&`, `||`, and comparisons:
@@ -151,6 +155,11 @@ Plain `--testSplit` exposes test metrics and cannot be called untouched after
 the report is read. Open the sealed tail once with the frozen fixed-rule
 ablation.
 
+When several core candidates must be compared, pass the same exact UTC
+`--tuningSince` and `--testSince` boundaries to every candidate ablation.
+Exact boundaries take precedence over ratio splits and keep sparse candidates
+on one calendar partition contract.
+
 ## Cross-Strategy Feasibility
 
 Use `--crossStrategy` to test whether the latest merged export for every

package/dist/skill-bundle/.codex/skills/ai-train-local-research/scripts/ai-gate-ablation.mjs

@@ -34,6 +34,8 @@ Options:
   --terminalWindows <list>     Terminal windows in days (default: 180,90,30,7)
   --validationSplit <ratio>    Trailing timestamp-grouped tuning share (default: 0.25)
   --testSplit <ratio>          Later timestamp-grouped test share (default: 0)
+  --tuningSince <timestamp>    Exact UTC boundary where tuning starts
+  --testSince <timestamp>      Exact UTC boundary where test starts
   --capacities <list>          Capacity stress limits (default: 1,3,5)
   --maxLossValue <n>           Per-order loss budget for capacity stress
   --featurePattern <regex>     Inventory matching causal feature paths
@@ -89,6 +91,8 @@ export const parseCliArgs = (argv) => {
     terminalWindows: DEFAULT_WINDOWS,
     validationSplit: 0.25,
     testSplit: 0,
+    tuningSince: null,
+    testSince: null,
     capacities: DEFAULT_CAPACITIES,
     maxLossValue: null,
     variants: [],
@@ -161,6 +165,13 @@ export const parseCliArgs = (argv) => {
       options.testSplit = Number.isFinite(parsed)
         ? Math.max(0, Math.min(0.9, parsed))
         : 0;
+    } else if (name === 'tuningSince' || name === 'testSince') {
+      const numeric = Number(value);
+      const parsed = Number.isFinite(numeric) ? numeric : Date.parse(value);
+      if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid timestamp for --${name}: ${value}`);
+      }
+      options[name] = parsed;
     } else if (name === 'capacities') {
       options.capacities = parseNumberList(value, DEFAULT_CAPACITIES);
     } else if (name === 'maxLossValue') {
@@ -1016,6 +1027,28 @@ export const splitRowsByTimestamp = (rows, validationSplit, testSplit = 0) => {
   };
 };
 
+export const splitRowsByTimestampBounds = (
+  rows,
+  tuningSince,
+  testSince,
+) => {
+  if (!Number.isFinite(tuningSince) || !Number.isFinite(testSince)) {
+    throw new Error(
+      'Exact calendar partitions require both tuningSince and testSince',
+    );
+  }
+  if (tuningSince >= testSince) {
+    throw new Error('tuningSince must be earlier than testSince');
+  }
+  return {
+    train: rows.filter((row) => row.timestamp < tuningSince),
+    tuning: rows.filter(
+      (row) => row.timestamp >= tuningSince && row.timestamp < testSince,
+    ),
+    test: rows.filter((row) => row.timestamp >= testSince),
+  };
+};
+
 const summarizeSplit = (rows, selector, summaryOptions) =>
   summarizeRows(selectRows(rows, selector), getPeriodDays(rows), {
     ...summaryOptions,
@@ -1034,6 +1067,34 @@ const summarizeDirections = (rows, selector, summaryOptions) =>
     ]),
   );
 
+export const buildEquitySeries = (
+  rows,
+  selector,
+  minTimestamp = rows[0]?.timestamp ?? null,
+  maxTimestamp = rows.at(-1)?.timestamp ?? null,
+) => {
+  if (!Number.isFinite(minTimestamp) || !Number.isFinite(maxTimestamp)) {
+    return [];
+  }
+  const byTimestamp = new Map();
+  for (const row of rows) {
+    if (!selector(row)) continue;
+    byTimestamp.set(
+      row.timestamp,
+      (byTimestamp.get(row.timestamp) ?? 0) + row.profit,
+    );
+  }
+  let cumulative = 0;
+  const result = [[minTimestamp, 0]];
+  for (const [timestamp, profit] of byTimestamp) {
+    cumulative += profit;
+    if (timestamp === minTimestamp) result[0] = [timestamp, cumulative];
+    else result.push([timestamp, cumulative]);
+  }
+  if (result.at(-1)[0] !== maxTimestamp) result.push([maxTimestamp, cumulative]);
+  return result;
+};
+
 const buildPeriodDirectionSummaries = ({
   rows,
   selector,
@@ -3778,6 +3839,8 @@ export const buildAblationReport = ({
   terminalWindows,
   validationSplit,
   testSplit = 0,
+  tuningSince = null,
+  testSince = null,
   capacities = DEFAULT_CAPACITIES,
   maxLossValue = null,
   filePaths,
@@ -3790,7 +3853,15 @@ export const buildAblationReport = ({
   if (!rows.length) throw new Error('No rows were evaluated');
   const minTimestamp = rows[0].timestamp;
   const maxTimestamp = rows.at(-1).timestamp;
-  const split = splitRowsByTimestamp(rows, validationSplit, testSplit);
+  if ((tuningSince == null) !== (testSince == null)) {
+    throw new Error(
+      'Exact calendar partitions require both tuningSince and testSince',
+    );
+  }
+  const exactCalendarPartitions = tuningSince != null;
+  const split = exactCalendarPartitions
+    ? splitRowsByTimestampBounds(rows, tuningSince, testSince)
+    : splitRowsByTimestamp(rows, validationSplit, testSplit);
   const partitionEvidence = (partitionRows) => ({
     rows: partitionRows.length,
     events: new Set(partitionRows.map((row) => row.timestamp)).size,
@@ -3804,6 +3875,12 @@ export const buildAblationReport = ({
   const summaryOptions = { capacities, maxLossValue };
   const baselineSelector = (row) => baselineSelectedAt(row, minQuality);
   const baseline = {
+    equity: buildEquitySeries(
+      rows,
+      baselineSelector,
+      minTimestamp,
+      maxTimestamp,
+    ),
     periods: buildPeriodSummaries({
       rows,
       selector: baselineSelector,
@@ -3849,6 +3926,12 @@ export const buildAblationReport = ({
       quality: variant.quality,
       direction: variant.direction,
       expression: variant.expression,
+      equity: buildEquitySeries(
+        rows,
+        candidateSelector,
+        minTimestamp,
+        maxTimestamp,
+      ),
       periods: buildPeriodSummaries({
         rows,
         selector: candidateSelector,
@@ -3919,6 +4002,13 @@ export const buildAblationReport = ({
       terminalWindows,
       validationSplit,
       testSplit,
+      partitionMode: exactCalendarPartitions ? 'exact-calendar' : 'ratio',
+      tuningSince: exactCalendarPartitions
+        ? new Date(tuningSince).toISOString()
+        : null,
+      testSince: exactCalendarPartitions
+        ? new Date(testSince).toISOString()
+        : null,
       capacities,
       maxLossValue,
       trainRows: split.train.length,
@@ -4935,6 +5025,11 @@ export const main = async () => {
     sourceRepositoryRoot,
   );
   if (options.crossStrategy) {
+    if (options.tuningSince != null || options.testSince != null) {
+      throw new Error(
+        '--tuningSince/--testSince are supported by candidate ablation only',
+      );
+    }
     const groups = latestDatasetGroupsByStrategy(
       await listDatasetGroups(outDir),
     );
@@ -5037,6 +5132,8 @@ export const main = async () => {
     terminalWindows: options.terminalWindows,
     validationSplit: options.validationSplit,
     testSplit: options.testSplit,
+    tuningSince: options.tuningSince,
+    testSince: options.testSince,
     capacities: options.capacities,
     maxLossValue: options.maxLossValue,
     sourceRepositoryRoot,

package/dist/skill-bundle/.codex/skills/ai-train-local-research/scripts/ai-gate-ablation.test.mjs

@@ -11,6 +11,7 @@ import {
   balanceCrossStrategyRows,
   buildAblationReport,
   buildCrossStrategyReport,
+  buildEquitySeries,
   buildMovingAverageVariants,
   calculateMovingAverageGrid,
   buildShiftedProfitLookups,
@@ -35,6 +36,7 @@ import {
   partitionCrossStrategyFeatures,
   resolveArtifactProjectRoot,
   splitRowsByTimestamp,
+  splitRowsByTimestampBounds,
   summarizeRows,
   summarizeMovingAverageRedundancy,
 } from './ai-gate-ablation.mjs';
@@ -195,6 +197,8 @@ test('parses repeated variants and research windows', () => {
     '--qualityThresholds',
     '4,5',
     '--testSplit=0.2',
+    '--tuningSince=2025-01-01T00:00:00.000Z',
+    '--testSince=2025-07-01T00:00:00.000Z',
     '--capacities=1,3,5',
     '--maxLossValue=0.2',
   ]);
@@ -207,6 +211,8 @@ test('parses repeated variants and research windows', () => {
   assert.deepEqual(options.terminalWindows, [180, 90, 30, 7]);
   assert.deepEqual(options.qualityThresholds, [4, 5]);
   assert.equal(options.testSplit, 0.2);
+  assert.equal(options.tuningSince, Date.UTC(2025, 0, 1));
+  assert.equal(options.testSince, Date.UTC(2025, 6, 1));
   assert.deepEqual(options.capacities, [1, 3, 5]);
   assert.equal(options.maxLossValue, 0.2);
 });
@@ -1048,6 +1054,46 @@ test('groups split and fan-out metrics by decision timestamp', () => {
   );
 });
 
+test('uses exact calendar boundaries without splitting timestamp events', () => {
+  const train = Date.UTC(2025, 0, 1);
+  const tuning = Date.UTC(2025, 3, 1);
+  const testStart = Date.UTC(2025, 6, 1);
+  const rows = [
+    { timestamp: train, id: 'train' },
+    { timestamp: tuning, id: 'tuning-a' },
+    { timestamp: tuning, id: 'tuning-b' },
+    { timestamp: testStart, id: 'test' },
+  ];
+
+  const split = splitRowsByTimestampBounds(rows, tuning, testStart);
+
+  assert.deepEqual(split.train.map((row) => row.id), ['train']);
+  assert.deepEqual(split.tuning.map((row) => row.id), [
+    'tuning-a',
+    'tuning-b',
+  ]);
+  assert.deepEqual(split.test.map((row) => row.id), ['test']);
+});
+
+test('builds timestamp-grouped cumulative equity with common endpoints', () => {
+  const start = Date.UTC(2025, 0, 1);
+  const end = Date.UTC(2025, 0, 3);
+  const rows = [
+    { timestamp: start, profit: 2, keep: true },
+    { timestamp: start, profit: -1, keep: true },
+    { timestamp: Date.UTC(2025, 0, 2), profit: 10, keep: false },
+    { timestamp: end, profit: 3, keep: true },
+  ];
+
+  assert.deepEqual(
+    buildEquitySeries(rows, (row) => row.keep, start, end),
+    [
+      [start, 1],
+      [end, 4],
+    ],
+  );
+});
+
 test('builds full and terminal period comparisons for a candidate', () => {
   const start = Date.UTC(2025, 0, 1);
   const variants = [parseVariant('keep::filter[SHORT]::feature.keep == true')];

package/dist/skill-bundle/.codex/skills/strategy-backtest-research/SKILL.md

@@ -113,14 +113,15 @@ and PnL reconcile within the documented per-symbol rounding tolerance, use the
 row-level export as the authoritative trade-economic total instead of swapping
 in the cent-rounded Redis aggregate.
 
-For a `$strategy-improvement-research` final composition, extend the same permanent report
+For every `$strategy-improvement-research` final composition, extend the same permanent report
 to `1095d/1460d/1825d-or-exact-maximum/365d/180d/90d/30d/7d`. When cached
 coverage is shorter than 1825 days, report the exact covered duration (for
 example 1800d) and do not label it a complete five-year window. Reuse this
 tool's full ALL/LONG/SHORT statistics; do not replace them with a compact custom
-parser. The release workflow must then run `ai-train --localOnly --chart -n 0`
-on the exact full export so the UI chart and structured gate statistics share
-the finalist lineage.
+parser. The improvement workflow then builds one independently verified
+deterministic gate on each exact core export, including the baseline export, and
+compares only the resulting `core + own gate` compositions. Raw-core metrics
+remain diagnostic and must never be mixed into the final-composition chart.
 
 ## Required Core Metric Cohorts
 

package/dist/skill-bundle/.codex/skills/strategy-forward-start/SKILL.md

@@ -51,10 +51,16 @@ Do not infer production from Redis.
 Stop before mutation if the target binding is ambiguous, credentials/registry
 authorization is missing, the candidate is not reproducible or implementable,
 the maximum-covered historical edge is non-positive, required evidence/chart
-hashes are missing, required checks fail, another rollout is active, or safe
-atomic deployment is unavailable. These are operational or falsifiability
-boundaries and operator-directed mode does not waive them. Give the exact
-command or UI boundary the user must complete; never start an interactive
+hashes are missing, required checks fail, another rollout for the same strategy
+is active, a deployment or rollout cutover on the target is still in flight, or
+safe atomic deployment is unavailable. An active risk-1 forward test for a
+different strategy on the same deployment or account is not a blocker: preserve
+its declaration and evidence, and do not confuse the presence of its active
+rollout ledger with an in-flight cutover. Multiple strategies may intentionally
+run concurrent forward tests, including when the operator uses
+`MAX_LOSS_VALUE=1` as the forward-test marker. These operational and
+falsifiability boundaries are not waived by operator-directed mode. Give the
+exact command or UI boundary the user must complete; never start an interactive
 authentication flow.
 
 ## Release and configure

package/dist/skill-bundle/.codex/skills/strategy-improvement-research/SKILL.md

@@ -48,11 +48,17 @@ hypothesis-family choice, trial budget, parent/child decisions, candidate
 selection, and final handoff. Delegate each preregistered core implementation
 and backtest to `$strategy-backtest-research`; that skill returns reconciled
 experiment evidence and does not choose the next candidate. After freezing the
-core finalist/export, delegate deterministic-gate analysis to
-`$ai-train-local-research`; it must not reopen core selection. Read those
+complete core board, delegate one independent deterministic-gate board for the
+baseline and for every complete, reconciled, behavior-changing core candidate
+to `$ai-train-local-research`; it must not reopen core selection. Read those
 specialist skills when their stage begins instead of duplicating their command,
 metric, or reporting contracts here.
 
+Before preregistration, read
+[`references/final-composition-board.md`](references/final-composition-board.md).
+It defines candidate-specific gate isolation, common partitions, the final
+composition ledger, and the mandatory visual artifacts.
+
 ## Required contour
 
 1. Start a new immutable research lineage. Freeze data bounds, point-in-time
@@ -74,15 +80,36 @@ metric, or reporting contracts here.
    tail. Stop only when a reproducible best candidate is frozen, the fresh
    budget is exhausted, or every remaining family has a recorded hard causal
    blocker.
-6. Keep one chronological tail sealed during discovery when coverage permits.
-   Open it once for the final selected behavior. Track all exposed tests for
-   multiple-testing/deflated-Sharpe interpretation.
-7. Freeze the selected core/export before opening deterministic-gate research.
-   Run the gate stage through `$ai-train-local-research`; do not retune or
-   relabel the raw-core result inside gate tooling.
-8. Run package formatting, typecheck, tests, and build in the lineage worktree.
-   Commit only the selected candidate and its tests on that worktree branch;
-   preserve rejected experiments as immutable evidence, not source clutter.
+6. Keep one common chronological core tail sealed during core discovery when
+   coverage permits. Freeze the complete raw-core board before any gate result
+   may influence core-family selection. Track all exposed core and gate tests
+   for multiple-testing/deflated-Sharpe interpretation.
+7. Freeze an acceptance-grade export for the baseline and every complete,
+   reconciled, behavior-changing core candidate. Give each export its own gate
+   discovery and exactly one selected deterministic gate; never reuse another
+   core's gate metrics or compare a gated candidate with an ungated baseline.
+   On the production core export, also replay the exact current production
+   AI-gate and bind it to its checksum-verified gate-authority report. This
+   `production core + current AI-gate` composition is the mandatory baseline;
+   the production core with its newly rebuilt gate is a separate research
+   candidate and must not replace the current-gate baseline.
+   Use common calendar train/tuning/test boundaries and open every sealed gate
+   tail together only after all per-core gate variants are frozen. Run every
+   gate board through `$ai-train-local-research`; do not retune or relabel the
+   raw-core result inside gate tooling.
+8. Build the final leaderboard from the mandatory `production core + current
+AI-gate` baseline and `core + own deterministic gate` research candidates,
+   including `production core + rebuilt gate` as its own candidate. Preserve
+   raw-core metrics in a separate diagnostic table. Apply the final selection
+   rules and multiple-testing denominator to the complete core-by-gate trial
+   ledger, not only to the winning core or gate.
+9. Generate and checksum the mandatory final-composition dashboard and
+   cumulative-equity chart with the permanent script from the referenced
+   contract. A metrics-only handoff or a chart mixing raw and gated candidates
+   is incomplete.
+10. Run package formatting, typecheck, tests, and build in the lineage worktree.
+    Commit only the selected candidate and its tests on that worktree branch;
+    preserve rejected experiments as immutable evidence, not source clutter.
 
 ## Selection objective
 
@@ -102,3 +129,12 @@ source/package SHA, full resolved core config, deterministic gate/context,
 direction policy, evidence hashes, trial count, metric matrix, chart, freshness,
 limitations, and forward-test eligibility. End with the selected candidate,
 why it beat production and prior candidates, and exactly one next skill.
+
+The handoff must link both visual artifacts for the final compositions:
+
+- `final-composition-dashboard.{svg,png}` with KPI deltas against the exact
+  production-core + current-AI-gate baseline, terminal
+  `365d/180d/90d/30d/7d` PnL, and the all-candidate PnL-versus-MaxDD plane;
+- `final-composition-equity.{svg,png}` with cumulative PnL for the gated
+  production baseline, the rebuilt production-core gate, and every final
+  `core + own gate` composition over the common comparison window.

package/dist/skill-bundle/.codex/skills/strategy-improvement-research/references/final-composition-board.md

@@ -0,0 +1,188 @@
+# Final composition board
+
+Use this contract after raw-core discovery is complete. Its purpose is to make
+the research unit an executable strategy composition, not an intermediate core
+or a gate tuned on another core's signal population.
+
+## Gate isolation
+
+1. Freeze the raw-core board first. It contains the authoritative baseline and
+   every complete, reconciled, behavior-changing core candidate. Core family
+   continuation and rescue choices use only raw-core evidence; a gate result
+   cannot reopen or rewrite that board.
+2. Produce one acceptance-grade raw AI export for every board member, including
+   the baseline. Bind its core research ID, resolved-config SHA-256, source diff
+   or commit, export SHA-256, window, universe, execution assumptions, and
+   context lineage.
+3. Run `$ai-train-local-research` independently for every export. Each core gets
+   its own current-gate control, pocket discovery, five-variant maximum ablation,
+   selected gate expression or implementation, full structured report, and
+   fingerprint. On the production core export, preserve two distinct final
+   compositions: the exact current AI-gate replay, checksum-bound to its
+   gate-authority report, and the independently rebuilt gate. The current gate
+   is the baseline; the rebuilt gate is a research candidate. A no-op,
+   zero-approval, or rejected gate still receives a checksum-bound report and
+   explicit disposition; it is not silently omitted.
+4. Freeze common calendar train, tuning, and test boundaries once in the parent
+   lineage. Keep all rows sharing a timestamp in one partition. Candidate
+   exports may have different row counts, but final comparison windows and test
+   timestamps must not move to make one candidate look better. Discovery may
+   inspect only train and tuning. Open all candidate test tails together after
+   every gate spec is immutable.
+   Use `ai-gate-ablation.mjs --tuningSince <UTC> --testSince <UTC>` with the
+   same values for every candidate; ratio-only splits are not comparable when
+   core event cadence differs.
+5. Count every inspected core and gate behavior in the final trial ledger. The
+   selected strategy is `core identity + candidate-specific gate identity +
+context identity + direction policy + quality threshold`. Reusing economics
+   from another core, using the production gate without replaying it on the new
+   export, or comparing a gated candidate with raw baseline is invalid.
+
+The five gate slots are a hard per-core maximum, not a target. Prefer a compact
+causal board: current gate, explicit direction pass-through/block when the raw
+side evidence warrants it, one causal pocket, one protected pocket, and one
+direction-aware replacement. Do not fill slots with adjacent threshold nudges.
+
+Freeze independently discovered causal pockets into an auditable candidate
+spec before opening comparison evidence:
+
+```bash
+node .codex/skills/strategy-improvement-research/scripts/freeze-gate-variants.mjs \
+  --pocket data/ai/output/<candidate>-pocket.json \
+  --candidateId <candidate> --output data/ai/output/<candidate>-gate-spec.json
+```
+
+## Final comparison
+
+Build two separate tables:
+
+- **Raw-core diagnostics**: baseline and every raw core with the fixed
+  ALL/LONG/SHORT contract. These metrics explain the mechanism but never enter
+  the final strategy leaderboard as if they were deployable compositions.
+- **Final compositions**: the exact production core + current AI-gate baseline,
+  the production core + rebuilt gate candidate, and exactly one frozen own-gate
+  result for every other raw-core candidate. Apply economic validity, support,
+  drawdown, cadence, concentration, stability, cost, and holdout rules here.
+
+Normalize PnL and drawdown to one recorded `MAX_LOSS_VALUE` risk unit before
+ranking or charting. Use the same half-open comparison window and terminal
+`365d`, `180d`, `90d`, `30d`, and `7d` slices for every composition, including
+zero-trade windows. A gate without sufficient untouched support remains visible
+as `research-only` or `blocked`; the chart is not evidence of readiness.
+
+## Mandatory visual artifacts
+
+Create the board from authoritative structured reports with:
+
+```bash
+node .codex/skills/strategy-improvement-research/scripts/build-final-composition-spec.mjs \
+  --selection data/strategy-release/<lineage>/final-composition-selection.json \
+  --output data/strategy-release/<lineage>/final-composition-board.json \
+  --terminalComparisonIds <selected-id>,<additional-candidate-id>
+node .codex/skills/strategy-improvement-research/scripts/final-composition-board.mjs \
+  --spec data/strategy-release/<lineage>/final-composition-board.json \
+  --outDir data/strategy-release/<lineage>/final-composition-charts
+```
+
+The input uses schema `tradejs-final-composition-board/v1`. Every composition
+must declare `composition.kind = core+deterministic-gate` and `gateSource` as
+`current` or `variant`, the same normalized risk unit, complete full/terminal
+metrics, cumulative equity points, and three checksum-verified inputs: core
+result, core export, and gate report. The baseline additionally requires the
+checksum-verified current `gateAuthority`. The script recomputes those hashes,
+requires `baselineId` to identify the current-gate composition, and derives the
+composition fingerprint; do not paste an unverified fingerprint into the spec.
+`--terminalComparisonIds` is an optional presentation override for a derived
+board: it leaves `selectedId` unchanged and allows a versioned comparison chart
+without rewriting the frozen selection artifact.
+
+Required outputs:
+
+- `final-composition-dashboard.svg` and `.png`: selected composition KPI cards
+  versus the production core + current AI-gate baseline, grouped terminal PnL bars with trade counts for
+  the baseline plus `terminalComparisonIds`, a PnL-versus-realized-MaxDD plot
+  of every final composition, and limitations. `terminalComparisonIds`
+  defaults to `[selectedId]`; it may include up to three candidate IDs, must
+  include `selectedId`, and does not change the research selection;
+- `final-composition-equity.svg` and `.png`: cumulative PnL curves for the
+  current production composition and every research composition on the common
+  time axis;
+- `final-composition-summary.json`: derived composition fingerprints, source
+  hashes, normalized metrics, and hashes of all four rendered files.
+
+SVG is the canonical deterministic rendering. PNG is the chat-ready rendering
+of the same SVG. Link or display both charts in the final answer and immutable
+research note. Store the complete board spec and summary in Project-owned
+evidence; paths alone do not replace the note's machine-readable metrics.
+
+## Spec shape
+
+```json
+{
+  "schema": "tradejs-final-composition-board/v1",
+  "strategy": "ExampleStrategy",
+  "researchId": "example-improvement-20260825-v1",
+  "title": "ExampleStrategy final compositions",
+  "subtitle": "Common cache-only window; sealed test opened once",
+  "baselineId": "production-current-gate",
+  "selectedId": "candidate-a-own-gate",
+  "terminalComparisonIds": ["candidate-a-own-gate", "candidate-b-own-gate"],
+  "comparisonWindow": { "start": 1690848000000, "end": 1787616000000 },
+  "normalization": { "pnlUnit": "research PnL", "maxLossValue": 10 },
+  "limitations": ["Point-in-time universe is incomplete"],
+  "candidates": [
+    {
+      "id": "production-current-gate",
+      "label": "production core + current AI-gate",
+      "role": "baseline",
+      "status": "eligible",
+      "color": "#315f7d",
+      "riskUnit": 10,
+      "composition": {
+        "kind": "core+deterministic-gate",
+        "gateSource": "current",
+        "coreResearchId": "example-control",
+        "coreConfigSha256": "<sha256>",
+        "coreResult": {
+          "path": "data/research/core/example-control/result.json",
+          "sha256": "<sha256>"
+        },
+        "coreExport": {
+          "path": "data/ai/export/example.jsonl",
+          "sha256": "<sha256>"
+        },
+        "gateReport": {
+          "path": "data/ai/output/example-gate.json",
+          "sha256": "<sha256>"
+        },
+        "gateAuthority": {
+          "path": "data/ai/output/example-current-gate-authority.json",
+          "sha256": "<sha256>"
+        },
+        "gateFingerprint": "<sha256>",
+        "configFingerprint": "<sha256>",
+        "contextFingerprint": "<sha256>",
+        "directionPolicy": "both",
+        "minQuality": 4
+      },
+      "metrics": {
+        "trades": 100,
+        "pnl": 250,
+        "profitFactor": 1.5,
+        "maxDrawdown": 70
+      },
+      "terminal": [
+        { "days": 365, "trades": 40, "pnl": 120 },
+        { "days": 180, "trades": 20, "pnl": 60 },
+        { "days": 90, "trades": 10, "pnl": 30 },
+        { "days": 30, "trades": 3, "pnl": 8 },
+        { "days": 7, "trades": 1, "pnl": 2 }
+      ],
+      "equity": [
+        [1690848000000, 0],
+        [1787615999999, 250]
+      ]
+    }
+  ]
+}
+```