create-tradejs 3.1.24 → 3.1.25

package/dist/skill-bundle/.codex/skills/strategy-improvement-research/scripts/final-composition-board.test.mjs

@@ -0,0 +1,223 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import {
+  generateFinalCompositionBoard,
+  validateBoardSpec,
+} from './final-composition-board.mjs';
+
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+const sha = (character) => character.repeat(64);
+
+const makeCandidate = ({
+  id,
+  role,
+  label,
+  color,
+  pnl,
+  trades,
+  drawdown,
+  artifactSha,
+}) => ({
+  id,
+  role,
+  label,
+  status: 'eligible',
+  color,
+  riskUnit: 10,
+  composition: {
+    kind: 'core+deterministic-gate',
+    gateSource: role === 'baseline' ? 'current' : 'variant',
+    coreResearchId: `${id}-core`,
+    coreConfigSha256: sha('a'),
+    coreResult: { path: `${id}-core.json`, sha256: artifactSha },
+    coreExport: { path: `${id}-export.jsonl`, sha256: artifactSha },
+    gateReport: { path: `${id}-gate.json`, sha256: artifactSha },
+    ...(role === 'baseline'
+      ? {
+          gateAuthority: {
+            path: `${id}-authority.json`,
+            sha256: artifactSha,
+          },
+        }
+      : {}),
+    gateFingerprint: sha('b'),
+    configFingerprint: sha('c'),
+    contextFingerprint: sha('d'),
+    directionPolicy: 'both',
+    minQuality: 4,
+  },
+  metrics: {
+    trades,
+    pnl,
+    profitFactor: 1.5,
+    maxDrawdown: drawdown,
+  },
+  terminal: [
+    { days: 365, trades: Math.min(trades, 20), pnl: pnl * 0.5 },
+    { days: 180, trades: Math.min(trades, 12), pnl: pnl * 0.3 },
+    { days: 90, trades: Math.min(trades, 8), pnl: pnl * 0.2 },
+    { days: 30, trades: Math.min(trades, 3), pnl: pnl * 0.1 },
+    { days: 7, trades: Math.min(trades, 1), pnl: pnl * 0.05 },
+  ],
+  equity: [
+    [1_700_000_000_000, 0],
+    [1_710_000_000_000, pnl],
+  ],
+});
+
+const makeSpec = (artifactSha) => ({
+  schema: 'tradejs-final-composition-board/v1',
+  strategy: 'ExampleStrategy',
+  researchId: 'example-20260825-v1',
+  title: 'ExampleStrategy final compositions',
+  subtitle: 'Common cache-only comparison window',
+  baselineId: 'baseline',
+  selectedId: 'candidate',
+  comparisonWindow: { start: 1_699_000_000_000, end: 1_711_000_000_000 },
+  normalization: { pnlUnit: 'research PnL', maxLossValue: 10 },
+  limitations: ['Untouched test support is small'],
+  candidates: [
+    makeCandidate({
+      id: 'baseline',
+      role: 'baseline',
+      label: 'baseline + own gate',
+      color: '#315f7d',
+      pnl: 100,
+      trades: 20,
+      drawdown: 30,
+      artifactSha,
+    }),
+    makeCandidate({
+      id: 'candidate',
+      role: 'candidate',
+      label: 'candidate + own gate',
+      color: '#d36b2c',
+      pnl: 160,
+      trades: 28,
+      drawdown: 26,
+      artifactSha,
+    }),
+  ],
+});
+
+test('rejects a raw-core row without a candidate-specific deterministic gate', () => {
+  const spec = makeSpec(sha('e'));
+  spec.candidates[1].composition.kind = 'raw-core';
+  assert.throws(
+    () => validateBoardSpec(spec),
+    /composition\.kind must be core\+deterministic-gate/u,
+  );
+});
+
+test('requires production core + current AI-gate as the baseline', () => {
+  const spec = makeSpec(sha('e'));
+  spec.candidates[0].composition.gateSource = 'variant';
+  delete spec.candidates[0].composition.gateAuthority;
+  assert.throws(
+    () => validateBoardSpec(spec),
+    /baseline must use the current AI-gate/u,
+  );
+});
+
+test('requires the fixed terminal chart windows', () => {
+  const spec = makeSpec(sha('e'));
+  spec.candidates[1].terminal.pop();
+  assert.throws(
+    () => validateBoardSpec(spec),
+    /must contain exactly 365d, 180d, 90d, 30d, and 7d/u,
+  );
+});
+
+test('allows the current production baseline to remain selected', () => {
+  const spec = makeSpec(sha('e'));
+  spec.selectedId = 'baseline';
+  spec.terminalComparisonIds = ['candidate'];
+  const board = validateBoardSpec(spec);
+  assert.equal(board.selectedId, 'baseline');
+  assert.deepEqual(board.terminalComparisonIds, ['candidate']);
+});
+
+test('verifies candidate artifacts and renders the dashboard and equity board', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tradejs-final-board-'));
+  const contents = 'immutable-evidence\n';
+  const artifactSha = hash(contents);
+  for (const id of ['baseline', 'candidate']) {
+    for (const suffix of ['core.json', 'export.jsonl', 'gate.json']) {
+      await writeFile(path.join(root, `${id}-${suffix}`), contents, 'utf8');
+    }
+  }
+  await writeFile(path.join(root, 'baseline-authority.json'), contents, 'utf8');
+  const { summary } = await generateFinalCompositionBoard({
+    spec: makeSpec(artifactSha),
+    artifactRoot: root,
+    outDir: path.join(root, 'charts'),
+  });
+  assert.equal(summary.candidates.length, 2);
+  assert.match(summary.candidates[1].compositionFingerprint, /^[a-f0-9]{64}$/u);
+  assert.deepEqual(Object.keys(summary.artifacts).sort(), [
+    'final-composition-dashboard.png',
+    'final-composition-dashboard.svg',
+    'final-composition-equity.png',
+    'final-composition-equity.svg',
+  ]);
+  const dashboard = await readFile(
+    path.join(root, 'charts', 'final-composition-dashboard.svg'),
+    'utf8',
+  );
+  const equity = await readFile(
+    path.join(root, 'charts', 'final-composition-equity.svg'),
+    'utf8',
+  );
+  assert.match(dashboard, /PnL in terminal windows/u);
+  assert.match(dashboard, /Final compositions: PnL ↔ drawdown/u);
+  assert.match(equity, /production core \+ current AI-gate/u);
+  assert.match(equity, /candidate \+ own gate/u);
+});
+
+test('renders an additional terminal comparison without changing selectedId', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'tradejs-final-board-'));
+  const contents = 'immutable-evidence\n';
+  const artifactSha = hash(contents);
+  const spec = makeSpec(artifactSha);
+  spec.candidates.push(
+    makeCandidate({
+      id: 'transition',
+      role: 'candidate',
+      label: 'Transition breakout + own gate',
+      color: '#a82f2f',
+      pnl: 155,
+      trades: 24,
+      drawdown: 22,
+      artifactSha,
+    }),
+  );
+  spec.terminalComparisonIds = ['candidate', 'transition'];
+  for (const id of ['baseline', 'candidate', 'transition']) {
+    for (const suffix of ['core.json', 'export.jsonl', 'gate.json']) {
+      await writeFile(path.join(root, `${id}-${suffix}`), contents, 'utf8');
+    }
+  }
+  await writeFile(path.join(root, 'baseline-authority.json'), contents, 'utf8');
+
+  const { summary } = await generateFinalCompositionBoard({
+    spec,
+    artifactRoot: root,
+    outDir: path.join(root, 'charts'),
+    png: false,
+  });
+  const dashboard = await readFile(
+    path.join(root, 'charts', 'final-composition-dashboard.svg'),
+    'utf8',
+  );
+
+  assert.equal(summary.selectedId, 'candidate');
+  assert.deepEqual(summary.terminalComparisonIds, ['candidate', 'transition']);
+  assert.match(dashboard, /data-terminal-series="baseline"/u);
+  assert.match(dashboard, /data-terminal-series="candidate"/u);
+  assert.match(dashboard, /data-terminal-series="transition"/u);
+  assert.match(dashboard, /Transition breakout \+ own gate/u);
+});

package/dist/skill-bundle/.codex/skills/strategy-improvement-research/scripts/freeze-gate-variants.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import crypto from 'node:crypto';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const usage = `Usage:
+  node freeze-gate-variants.mjs --pocket <report.json> --candidateId <id> --output <spec.json> [--limit <1..5>]
+`;
+
+const parseArgs = (argv) => {
+  const options = { limit: 5 };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--help') return { help: true };
+    if (!argument.startsWith('--')) throw new Error(`Unexpected argument: ${argument}`);
+    const name = argument.slice(2);
+    const value = argv[++index];
+    if (!value || value.startsWith('--')) throw new Error(`Missing value for ${argument}`);
+    if (name === 'limit') options.limit = Number(value);
+    else if (['pocket', 'candidateId', 'output'].includes(name)) options[name] = value;
+    else throw new Error(`Unknown option: ${argument}`);
+  }
+  if (!options.pocket || !options.candidateId || !options.output) {
+    throw new Error('Required: --pocket, --candidateId, and --output');
+  }
+  if (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > 5) {
+    throw new Error('--limit must be an integer from 1 through 5');
+  }
+  return options;
+};
+
+const sha256 = (value) => crypto.createHash('sha256').update(value).digest('hex');
+
+export const buildFrozenGateSpec = ({ report, candidateId, limit, sourcePath, sourceSha256 }) => {
+  if (report?.run?.featurePolicy !== 'causal-stationary') {
+    throw new Error('Pocket report must use featurePolicy=causal-stationary');
+  }
+  const pockets = report?.pocketSearch?.positivePockets;
+  if (!Array.isArray(pockets) || pockets.length === 0) {
+    throw new Error('Pocket report has no positive pockets to freeze');
+  }
+  const variants = pockets.slice(0, limit).map((pocket, index) => {
+    const predicates = pocket?.predicates;
+    if (!Array.isArray(predicates) || predicates.length === 0) {
+      throw new Error(`Pocket ${index + 1} has no predicates`);
+    }
+    return {
+      name: `${candidateId}-own-gate-${index + 1}`,
+      mode: 'replace',
+      quality: 4,
+      expression: predicates.map((predicate) => predicate.label).join(' && '),
+      discovery: {
+        rank: index + 1,
+        support: pocket.summary?.support ?? null,
+        events: pocket.summary?.events ?? null,
+      },
+    };
+  });
+  return {
+    schema: 'tradejs-candidate-gate-variants/v1',
+    candidateId,
+    sourcePocketReport: { path: sourcePath, sha256: sourceSha256 },
+    discovery: {
+      featurePolicy: report.run.featurePolicy,
+      until: report.run.until,
+      trainRows: report.run.trainRows,
+      validationRows: report.run.validationRows,
+      testRows: report.run.testRows,
+    },
+    variants,
+  };
+};
+
+export const main = async (argv = process.argv.slice(2)) => {
+  const options = parseArgs(argv);
+  if (options.help) {
+    process.stdout.write(usage);
+    return;
+  }
+  const pocketPath = path.resolve(options.pocket);
+  const outputPath = path.resolve(options.output);
+  const pocketText = await fsp.readFile(pocketPath, 'utf8');
+  const spec = buildFrozenGateSpec({
+    report: JSON.parse(pocketText),
+    candidateId: options.candidateId,
+    limit: options.limit,
+    sourcePath: options.pocket,
+    sourceSha256: sha256(pocketText),
+  });
+  await fsp.mkdir(path.dirname(outputPath), { recursive: true });
+  const output = `${JSON.stringify(spec, null, 2)}\n`;
+  await fsp.writeFile(outputPath, output, 'utf8');
+  process.stdout.write(`${sha256(output)}  ${options.output}\n`);
+};
+
+if (pathToFileURL(path.resolve(process.argv[1] ?? '')).href === import.meta.url) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.stack : String(error));
+    process.exitCode = 1;
+  });
+}

package/dist/skill-bundle/.codex/skills/strategy-improvement-research/scripts/freeze-gate-variants.test.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { buildFrozenGateSpec } from './freeze-gate-variants.mjs';
+
+test('freezes no more than five causal replacement gates', () => {
+  const pocket = (index) => ({
+    predicates: [
+      { label: `feature.value >= ${index}` },
+      { label: 'derived.direction == SHORT' },
+    ],
+    summary: { support: 25 + index, events: 25 },
+  });
+  const spec = buildFrozenGateSpec({
+    report: {
+      run: {
+        featurePolicy: 'causal-stationary',
+        until: 1,
+        trainRows: 100,
+        validationRows: 0,
+        testRows: 0,
+      },
+      pocketSearch: { positivePockets: Array.from({ length: 6 }, (_, index) => pocket(index)) },
+    },
+    candidateId: 'candidate-a',
+    limit: 5,
+    sourcePath: 'pocket.json',
+    sourceSha256: 'a'.repeat(64),
+  });
+
+  assert.equal(spec.variants.length, 5);
+  assert.equal(spec.variants[0].mode, 'replace');
+  assert.equal(spec.variants[0].quality, 4);
+  assert.equal(
+    spec.variants[0].expression,
+    'feature.value >= 0 && derived.direction == SHORT',
+  );
+});
+
+test('rejects pocket reports with a non-causal feature policy', () => {
+  assert.throws(
+    () =>
+      buildFrozenGateSpec({
+        report: { run: { featurePolicy: 'all' }, pocketSearch: { positivePockets: [{}] } },
+        candidateId: 'candidate-a',
+        limit: 1,
+        sourcePath: 'pocket.json',
+        sourceSha256: 'a'.repeat(64),
+      }),
+    /causal-stationary/,
+  );
+});

package/dist/skill-bundle/.codex/tradejs-skill-bundle.json

@@ -1,7 +1,7 @@
 {
   "schema": "tradejs-skill-bundle/v1",
   "source": "TradeJS-Dev/TradeJS:.codex/skills",
-  "bundleSha256": "f058077d43fc342e82062908fa7512b74981c2bee878901508dd8d3fdba32e23",
+  "bundleSha256": "30e3254a3cc0e82d8625b754897f226d23861d2357e23196197f69bfa6a568ee",
   "skills": [
     "ai-train-local-research",
     "backtest-config-redis",
@@ -19,10 +19,10 @@
     "strategy-release"
   ],
   "files": {
-    ".codex/skills/ai-train-local-research/references/gate-ablation.md": "5bd50a225864b518c1ca3400716c384f289899f8b81dd33df6aee3dc2998ff0b",
+    ".codex/skills/ai-train-local-research/references/gate-ablation.md": "a1011bf0c9fcccf1692983364da168a1bac6d044b24ed3bfd7cb44e4b0ca9ed5",
     ".codex/skills/ai-train-local-research/references/reporting.md": "a5a5cc6438a8cc228560e302e944f1ff320f4c963988af83e1ba1443728f7149",
-    ".codex/skills/ai-train-local-research/scripts/ai-gate-ablation.mjs": "b3a4bceff25219644e96d5309d3c11c59761b9cd7d7096ee701f95654853cfa8",
-    ".codex/skills/ai-train-local-research/scripts/ai-gate-ablation.test.mjs": "dc5128b8743f67cc496a296d52a21ec3cc139308ffc80eac07cf3a77dc4c78bf",
+    ".codex/skills/ai-train-local-research/scripts/ai-gate-ablation.mjs": "494dea5fc2ef02e4ab07a9aa82b8d531e576975b12bb0723f6fa0403db2e3a56",
+    ".codex/skills/ai-train-local-research/scripts/ai-gate-ablation.test.mjs": "c7e61f5f1a607e88a9e371fade9822fa68503575cbc718c7d437b0d681691ed8",
     ".codex/skills/ai-train-local-research/SKILL.md": "479e44aad9cb6ab6b5c8931c807c63cf2a1938a59d01f553c20f44645716a23a",
     ".codex/skills/backtest-config-redis/scripts/get_backtest_config.sh": "833e950d6348c5b7a4bd3f00d25af60f6394190bff744bd5ab64db9e43d826d5",
     ".codex/skills/backtest-config-redis/SKILL.md": "85e7b1fa425aa23dfa7950de05c1d3ce046d044dc3872f3665705e9e2f2a1977",
@@ -35,13 +35,20 @@
     ".codex/skills/strategy-backtest-research/scripts/fast-ai-export-metrics.mjs": "1d1747d34269ad15a610dcd687334c3d47ed9460d891285ad1dd851c7658d1af",
     ".codex/skills/strategy-backtest-research/scripts/fast-ai-export-metrics.test.mjs": "4caab52646504afd2a6f1e4ba9f43d6b07d714baca89d2a2010545fb4210a9da",
     ".codex/skills/strategy-backtest-research/scripts/research-notes-check.mjs": "435aa6560abcf4e8a60fb86230d8d8de2f2dc9e4c52acc7a272ce30287d40325",
-    ".codex/skills/strategy-backtest-research/SKILL.md": "4acc57b255cfe8b16a2b2bf0af0c8ee50e79e2bcea3f8045d422342007b8a779",
+    ".codex/skills/strategy-backtest-research/SKILL.md": "526197e5f196d80dc4f4cc3688d2e0d232eb010267c53d2a71589e4ddddac4e4",
     ".codex/skills/strategy-candidate-compare/SKILL.md": "34dbca2c77ce74836f5c264131cefb751313147128ab1c3f947002f975be051c",
     ".codex/skills/strategy-candidate-report/SKILL.md": "3cad1241ce2107d7e30a5d78eafd6429514a10d1a8e9cf3d0e97ffef9d691ab6",
-    ".codex/skills/strategy-forward-start/SKILL.md": "1591bd1c64864283320793b3c0bb4e1677aab960951ef8b487a1101ca7b6f82c",
+    ".codex/skills/strategy-forward-start/SKILL.md": "a86311aeb4c5b46e43011806ffa0f665c4ec0fddce8d7f8c1232184e4a14bfa7",
     ".codex/skills/strategy-forward-status/SKILL.md": "b41f117680259fd7b4d5cbe3c0a1be75a42f08c8cf78f9ad7ccb0d90bfc66269",
     ".codex/skills/strategy-improvement-plan/SKILL.md": "f5f0f390941dd3332890a2f0ffae1248abde4925db2cf49a41c0c0c1b47e7864",
-    ".codex/skills/strategy-improvement-research/SKILL.md": "634b6d4d7e9e8e22db9c073bef0410ae90ab1b68d0fc2610d8def48b5fc687c4",
+    ".codex/skills/strategy-improvement-research/references/final-composition-board.md": "05b49ea4aba85792ccea0aeaf4ee2637b808157962f0a38631d6468c342349d6",
+    ".codex/skills/strategy-improvement-research/scripts/build-final-composition-spec.mjs": "b51873691fafbcf2dd70d8c9a6da842fec5f8358346c632cfe79211db08b18ba",
+    ".codex/skills/strategy-improvement-research/scripts/build-final-composition-spec.test.mjs": "85d06b8fe09ee7611a3fb989173c361ba32f0e9364422925ff221bfe127b2bfa",
+    ".codex/skills/strategy-improvement-research/scripts/final-composition-board.mjs": "e5c5a1f91467f25e76f4f294b803c2602221d62fa5bd2be454a4345c3097773d",
+    ".codex/skills/strategy-improvement-research/scripts/final-composition-board.test.mjs": "240c4cf13208a9fbbfcade622789dc9f142b68e79b490da7583ab793795d2f35",
+    ".codex/skills/strategy-improvement-research/scripts/freeze-gate-variants.mjs": "17b3c868880ddd5b326d309e6e42eaeef1ea22d625a5db947997ac73b221ad6d",
+    ".codex/skills/strategy-improvement-research/scripts/freeze-gate-variants.test.mjs": "963e1c64ab3deef11fd48a96e10f3827af38036dfe2eb28daf7849f19dd414d8",
+    ".codex/skills/strategy-improvement-research/SKILL.md": "6964eb154e40b0b775aa2735b2ebbe998984479f46333ed03eab88d2ee150d48",
     ".codex/skills/strategy-period-revalidate/SKILL.md": "f367ba1c632506a7d9bf92662a40b61df55f7a56ad04f3600a475b3c365bbbcb",
     ".codex/skills/strategy-release/agents/openai.yaml": "46ddb09119b08ae3be3b9509121b57492342012e774789b615767b24270dba17",
     ".codex/skills/strategy-release/references/diagnose-live.md": "dc2effa6eba34e3cfcc1eaf4d2fd1c96d6ccdda971a0edec76c9eed1ec293a3d",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-tradejs",
-  "version": "3.1.24",
+  "version": "3.1.25",
   "description": "Create a ready-to-run TradeJS project with local infrastructure and the Web UI.",
   "keywords": [
     "tradejs",