create-tradejs 3.1.27 → 3.1.28-beta.252

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

@@ -120,6 +120,55 @@ 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.
 
+For a deterministic timestamp-local portfolio limit, a JSON spec variant may
+also define `selection`. The tool first evaluates the gate, then keeps the
+highest-ranked rows independently inside each decision timestamp. Missing rank
+values sort last; symbol and source sequence are stable tie-breakers.
+
+```json
+{
+  "name": "capacity-five",
+  "mode": "replace",
+  "quality": 4,
+  "expression": "derived.direction == SHORT && feature.margin >= 0",
+  "selection": {
+    "capacity": 5,
+    "rankBy": [
+      { "path": "feature.margin", "order": "desc" },
+      {
+        "path": "additionalIndicators.volumeDivergenceSetup.reclaimPct",
+        "order": "desc"
+      }
+    ]
+  }
+}
+```
+
+Treat every rank path like an approval feature: it must be causal, available at
+decision time, stationary enough for the intended use, and documented with its
+scope and environment dependencies. Capacity ranking is not permission to use
+outcome, current-gate output, or data-availability fields.
+
+A JSON spec can also define an event-count-preserving timestamp-rotation
+placebo. Its own expression defines eligible rows. Inside each train, tuning,
+and test partition, the referenced variant's approved event timestamps are
+shifted through the eligible timestamp sequence. Trade outcomes are never read
+while constructing the shift.
+
+```json
+{
+  "name": "rotated-placebo",
+  "mode": "replace",
+  "quality": 4,
+  "expression": "derived.direction == SHORT",
+  "placebo": {
+    "type": "timestamp-rotation",
+    "referenceVariant": "frozen-gate",
+    "offsetEvents": 37
+  }
+}
+```
+
 ## Expression Grammar
 
 Expressions support parentheses, `&&`, `||`, and comparisons:
@@ -160,6 +209,12 @@ When several core candidates must be compared, pass the same exact UTC
 Exact boundaries take precedence over ratio splits and keep sparse candidates
 on one calendar partition contract.
 
+Use `--windowStart <UTC> --windowEnd <UTC>` to compare candidates over the same
+calendar window. The start is inclusive, and the end is exclusive. Full-period
+cadence and terminal windows use these bounds instead of each export's first
+and last trade. The report includes zero-trade terminal windows. Without these
+options, the existing export-based window remains unchanged.
+
 ## 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

@@ -36,6 +36,8 @@ Options:
   --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
+  --windowStart <timestamp>    Common comparison start, inclusive
+  --windowEnd <timestamp>      Common comparison end, exclusive
   --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
@@ -165,7 +167,9 @@ export const parseCliArgs = (argv) => {
       options.testSplit = Number.isFinite(parsed)
         ? Math.max(0, Math.min(0.9, parsed))
         : 0;
-    } else if (name === 'tuningSince' || name === 'testSince') {
+    } else if (
+      ['tuningSince', 'testSince', 'windowStart', 'windowEnd'].includes(name)
+    ) {
       const numeric = Number(value);
       const parsed = Number.isFinite(numeric) ? numeric : Date.parse(value);
       if (!Number.isFinite(parsed)) {
@@ -668,11 +672,55 @@ const loadVariants = async (inlineVariants, specPath) => {
       entry.quality == null ? '' : `@${Math.trunc(Number(entry.quality))}`;
     const directionSuffix =
       entry.direction == null ? '' : `[${String(entry.direction)}]`;
-    variants.push(
-      parseVariant(
-        `${entry.name}::${entry.mode}${qualitySuffix}${directionSuffix}::${entry.expression}`,
-      ),
+    const variant = parseVariant(
+      `${entry.name}::${entry.mode}${qualitySuffix}${directionSuffix}::${entry.expression}`,
     );
+    if (entry.selection != null) {
+      const capacity = Math.trunc(Number(entry.selection.capacity));
+      const rankBy = entry.selection.rankBy;
+      if (!Number.isFinite(capacity) || capacity < 1) {
+        throw new Error(
+          `Variant ${entry.name} selection.capacity must be a positive integer`,
+        );
+      }
+      if (!Array.isArray(rankBy) || rankBy.length === 0) {
+        throw new Error(
+          `Variant ${entry.name} selection.rankBy must be a non-empty array`,
+        );
+      }
+      variant.selection = {
+        capacity,
+        rankBy: rankBy.map((rank, index) => {
+          const pathValue = String(rank?.path ?? '').trim();
+          const order = String(rank?.order ?? 'desc').toLowerCase();
+          if (!pathValue || !['asc', 'desc'].includes(order)) {
+            throw new Error(
+              `Variant ${entry.name} selection.rankBy[${index}] requires path and asc|desc order`,
+            );
+          }
+          return { path: pathValue, order };
+        }),
+      };
+    }
+    if (entry.placebo != null) {
+      const type = String(entry.placebo.type ?? '').trim();
+      const referenceVariant = String(
+        entry.placebo.referenceVariant ?? '',
+      ).trim();
+      const offsetEvents = Math.trunc(Number(entry.placebo.offsetEvents));
+      if (
+        type !== 'timestamp-rotation' ||
+        !referenceVariant ||
+        !Number.isFinite(offsetEvents) ||
+        offsetEvents < 1
+      ) {
+        throw new Error(
+          `Variant ${entry.name} placebo requires type=timestamp-rotation, referenceVariant, and positive offsetEvents`,
+        );
+      }
+      variant.placebo = { type, referenceVariant, offsetEvents };
+    }
+    variants.push(variant);
   }
   const names = new Set();
   for (const variant of variants) {
@@ -681,6 +729,16 @@ const loadVariants = async (inlineVariants, specPath) => {
     }
     names.add(variant.name);
   }
+  for (const variant of variants) {
+    if (
+      variant.placebo != null &&
+      !names.has(variant.placebo.referenceVariant)
+    ) {
+      throw new Error(
+        `Variant ${variant.name} references unknown placebo variant ${variant.placebo.referenceVariant}`,
+      );
+    }
+  }
   return variants;
 };
 
@@ -962,6 +1020,111 @@ const candidateSelectedAt = (
     defaultQuality: minQuality,
   });
 
+const compareRankValue = (left, right, order) => {
+  const leftMissing = left == null || Number.isNaN(left);
+  const rightMissing = right == null || Number.isNaN(right);
+  if (leftMissing || rightMissing) {
+    if (leftMissing && rightMissing) return 0;
+    return leftMissing ? 1 : -1;
+  }
+  let comparison;
+  if (typeof left === 'number' && typeof right === 'number') {
+    comparison = left - right;
+  } else {
+    comparison = String(left).localeCompare(String(right));
+  }
+  return order === 'asc' ? comparison : -comparison;
+};
+
+export const selectRowsWithinCapacity = ({ rows, selector, selection }) => {
+  const selected = rows.filter(selector);
+  if (selection == null) return new Set(selected);
+  const byTimestamp = new Map();
+  for (const row of selected) {
+    const eventRows = byTimestamp.get(row.timestamp) ?? [];
+    eventRows.push(row);
+    byTimestamp.set(row.timestamp, eventRows);
+  }
+  const accepted = new Set();
+  for (const eventRows of byTimestamp.values()) {
+    eventRows.sort((left, right) => {
+      for (const rank of selection.rankBy) {
+        const comparison = compareRankValue(
+          left.features?.[rank.path],
+          right.features?.[rank.path],
+          rank.order,
+        );
+        if (comparison !== 0) return comparison;
+      }
+      return (
+        String(left.symbol ?? '').localeCompare(String(right.symbol ?? '')) ||
+        Number(left.sequence ?? 0) - Number(right.sequence ?? 0)
+      );
+    });
+    for (const row of eventRows.slice(0, selection.capacity)) {
+      accepted.add(row);
+    }
+  }
+  return accepted;
+};
+
+export const applyTimestampRotationPlacebos = (
+  rows,
+  variants,
+  partitions = [rows],
+) => {
+  const variantIndexes = new Map(
+    variants.map((variant, index) => [variant.name, index]),
+  );
+  for (
+    let placeboIndex = 0;
+    placeboIndex < variants.length;
+    placeboIndex += 1
+  ) {
+    const placebo = variants[placeboIndex].placebo;
+    if (placebo?.type !== 'timestamp-rotation') continue;
+    const referenceIndex = variantIndexes.get(placebo.referenceVariant);
+    if (referenceIndex == null) {
+      throw new Error(
+        `Unknown timestamp-rotation reference ${placebo.referenceVariant}`,
+      );
+    }
+    for (const partitionRows of partitions) {
+      const eligibleTimestamps = [
+        ...new Set(
+          partitionRows
+            .filter((row) => row.variantMatches[placeboIndex])
+            .map((row) => row.timestamp),
+        ),
+      ].sort((left, right) => left - right);
+      if (eligibleTimestamps.length === 0) continue;
+      const eligibleIndex = new Map(
+        eligibleTimestamps.map((timestamp, index) => [timestamp, index]),
+      );
+      const referenceTimestamps = new Set(
+        partitionRows
+          .filter((row) => row.variantMatches[referenceIndex])
+          .map((row) => row.timestamp),
+      );
+      const rotatedTimestamps = new Set();
+      for (const timestamp of referenceTimestamps) {
+        const index = eligibleIndex.get(timestamp);
+        if (index == null) continue;
+        rotatedTimestamps.add(
+          eligibleTimestamps[
+            (index + placebo.offsetEvents) % eligibleTimestamps.length
+          ],
+        );
+      }
+      for (const row of partitionRows) {
+        row.variantMatches[placeboIndex] =
+          row.variantMatches[placeboIndex] &&
+          rotatedTimestamps.has(row.timestamp);
+      }
+    }
+  }
+};
+
 const selectRows = (rows, predicate) => rows.filter(predicate);
 
 const buildPeriodSummaries = ({
@@ -972,15 +1135,17 @@ const buildPeriodSummaries = ({
   maxTimestamp,
   summaryOptions,
 }) => {
-  const withCalendarDays = (periodRows) => ({
+  const withCalendarDays = (periodRows, start, end) => ({
     ...summaryOptions,
-    calendarDays: getCalendarDays(periodRows),
+    calendarDays: summaryOptions.comparisonWindow
+      ? getCalendarDays([{ timestamp: start }, { timestamp: end - 1 }])
+      : getCalendarDays(periodRows),
   });
   const result = {
     full: summarizeRows(
       selectRows(rows, selector),
       Math.max((maxTimestamp - minTimestamp) / DAY_MS, 1),
-      withCalendarDays(rows),
+      withCalendarDays(rows, minTimestamp, maxTimestamp),
     ),
   };
   for (const days of windows) {
@@ -989,7 +1154,7 @@ const buildPeriodSummaries = ({
     result[`${days}d`] = summarizeRows(
       selectRows(periodRows, selector),
       days,
-      withCalendarDays(periodRows),
+      withCalendarDays(periodRows, from, maxTimestamp),
     );
   }
   return result;
@@ -1027,11 +1192,7 @@ export const splitRowsByTimestamp = (rows, validationSplit, testSplit = 0) => {
   };
 };
 
-export const splitRowsByTimestampBounds = (
-  rows,
-  tuningSince,
-  testSince,
-) => {
+export const splitRowsByTimestampBounds = (rows, tuningSince, testSince) => {
   if (!Number.isFinite(tuningSince) || !Number.isFinite(testSince)) {
     throw new Error(
       'Exact calendar partitions require both tuningSince and testSince',
@@ -1061,7 +1222,7 @@ const summarizeDirections = (rows, selector, summaryOptions) =>
       direction,
       summarizeRows(
         selectRows(rows, (row) => row.direction === direction && selector(row)),
-        getPeriodDays(rows),
+        summaryOptions?.denominatorDays ?? getPeriodDays(rows),
         summaryOptions,
       ),
     ]),
@@ -1091,7 +1252,8 @@ export const buildEquitySeries = (
     if (timestamp === minTimestamp) result[0] = [timestamp, cumulative];
     else result.push([timestamp, cumulative]);
   }
-  if (result.at(-1)[0] !== maxTimestamp) result.push([maxTimestamp, cumulative]);
+  if (result.at(-1)[0] !== maxTimestamp)
+    result.push([maxTimestamp, cumulative]);
   return result;
 };
 
@@ -1105,7 +1267,12 @@ const buildPeriodDirectionSummaries = ({
   const result = {
     full: summarizeDirections(rows, selector, {
       ...summaryOptions,
-      calendarDays: getCalendarDays(rows),
+      calendarDays: summaryOptions.comparisonWindow
+        ? getCalendarDays([
+            { timestamp: summaryOptions.comparisonWindow.start },
+            { timestamp: maxTimestamp - 1 },
+          ])
+        : getCalendarDays(rows),
     }),
   };
   for (const days of windows) {
@@ -1113,7 +1280,13 @@ const buildPeriodDirectionSummaries = ({
     const periodRows = selectRows(rows, (row) => row.timestamp >= from);
     result[`${days}d`] = summarizeDirections(periodRows, selector, {
       ...summaryOptions,
-      calendarDays: getCalendarDays(periodRows),
+      ...(summaryOptions.comparisonWindow ? { denominatorDays: days } : {}),
+      calendarDays: summaryOptions.comparisonWindow
+        ? getCalendarDays([
+            { timestamp: from },
+            { timestamp: maxTimestamp - 1 },
+          ])
+        : getCalendarDays(periodRows),
     });
   }
   return result;
@@ -1254,9 +1427,8 @@ export const loadStandaloneStrategyEntries = async (sourceRepositoryRoot) => {
       `Expected a standalone TradeJS strategy repository: ${sourceRepositoryRoot}`,
     );
   }
-  const { entrypoint, packageJson } = resolveStandaloneStrategyEntrypoint(
-    sourceRepositoryRoot,
-  );
+  const { entrypoint, packageJson } =
+    resolveStandaloneStrategyEntrypoint(sourceRepositoryRoot);
   let outputStat;
   try {
     outputStat = await fsp.stat(entrypoint);
@@ -1317,9 +1489,15 @@ export const ensureRuntimeBuild = async (frameworkRepositoryRoot) => {
       output: aiModulePath,
       sources: [
         path.join(frameworkRepositoryRoot, 'packages/node/src/ai.ts'),
-        path.join(frameworkRepositoryRoot, 'packages/node/src/aiMarketContext.ts'),
+        path.join(
+          frameworkRepositoryRoot,
+          'packages/node/src/aiMarketContext.ts',
+        ),
         path.join(frameworkRepositoryRoot, 'packages/node/src/aiShared.ts'),
-        path.join(frameworkRepositoryRoot, 'packages/node/src/strategyAdapters'),
+        path.join(
+          frameworkRepositoryRoot,
+          'packages/node/src/strategyAdapters',
+        ),
       ],
       command: 'yarn workspace @tradejs/node build',
     },
@@ -1372,9 +1550,8 @@ const loadResearchRows = async ({
   const require = createRequire(import.meta.url);
   const { collectAiPocketFeatures } = require(pocketModulePath);
   if (getSourceRepositoryKind(sourceRepositoryRoot) === 'strategy') {
-    const { strategyEntries } = await loadStandaloneStrategyEntries(
-      sourceRepositoryRoot,
-    );
+    const { strategyEntries } =
+      await loadStandaloneStrategyEntries(sourceRepositoryRoot);
     registryModule.resetStrategyRegistryCache(projectRoot);
     registryModule.registerStrategyEntries(strategyEntries, projectRoot);
   } else {
@@ -1430,6 +1607,7 @@ const loadResearchRows = async ({
             analysis.direction === source.direction &&
             quality != null &&
             quality >= minQuality,
+          features,
           movingAverageSource: {
             provider: String(source.connectorName ?? '')
               .trim()
@@ -3841,6 +4019,8 @@ export const buildAblationReport = ({
   testSplit = 0,
   tuningSince = null,
   testSince = null,
+  windowStart = null,
+  windowEnd = null,
   capacities = DEFAULT_CAPACITIES,
   maxLossValue = null,
   filePaths,
@@ -3851,8 +4031,29 @@ export const buildAblationReport = ({
   featureInventory = [],
 }) => {
   if (!rows.length) throw new Error('No rows were evaluated');
-  const minTimestamp = rows[0].timestamp;
-  const maxTimestamp = rows.at(-1).timestamp;
+  if ((windowStart == null) !== (windowEnd == null)) {
+    throw new Error(
+      'Common comparison window requires both windowStart and windowEnd',
+    );
+  }
+  const explicitWindow = windowStart != null;
+  if (
+    explicitWindow &&
+    (!Number.isFinite(windowStart) ||
+      !Number.isFinite(windowEnd) ||
+      windowStart >= windowEnd)
+  ) {
+    throw new Error(
+      'Common comparison window must have finite increasing bounds',
+    );
+  }
+  if (explicitWindow) {
+    rows = rows.filter(
+      (row) => row.timestamp >= windowStart && row.timestamp < windowEnd,
+    );
+  }
+  const minTimestamp = windowStart ?? rows[0].timestamp;
+  const maxTimestamp = windowEnd ?? rows.at(-1).timestamp;
   if ((tuningSince == null) !== (testSince == null)) {
     throw new Error(
       'Exact calendar partitions require both tuningSince and testSince',
@@ -3862,6 +4063,11 @@ export const buildAblationReport = ({
   const split = exactCalendarPartitions
     ? splitRowsByTimestampBounds(rows, tuningSince, testSince)
     : splitRowsByTimestamp(rows, validationSplit, testSplit);
+  applyTimestampRotationPlacebos(rows, variants, [
+    split.train,
+    split.tuning,
+    split.test,
+  ]);
   const partitionEvidence = (partitionRows) => ({
     rows: partitionRows.length,
     events: new Set(partitionRows.map((row) => row.timestamp)).size,
@@ -3872,14 +4078,23 @@ export const buildAblationReport = ({
       ? new Date(partitionRows.at(-1).timestamp).toISOString()
       : null,
   });
-  const summaryOptions = { capacities, maxLossValue };
+  const summaryOptions = {
+    capacities,
+    maxLossValue,
+    ...(explicitWindow
+      ? {
+          comparisonWindow: { start: windowStart, end: windowEnd },
+          denominatorDays: Math.max((windowEnd - windowStart) / DAY_MS, 1),
+        }
+      : {}),
+  };
   const baselineSelector = (row) => baselineSelectedAt(row, minQuality);
   const baseline = {
     equity: buildEquitySeries(
       rows,
       baselineSelector,
       minTimestamp,
-      maxTimestamp,
+      maxTimestamp - Number(explicitWindow),
     ),
     periods: buildPeriodSummaries({
       rows,
@@ -3913,8 +4128,17 @@ export const buildAblationReport = ({
     months: summarizeMonths(rows, baselineSelector, summaryOptions),
   };
   const variantReports = variants.map((variant, variantIndex) => {
-    const candidateSelector = (row) =>
-      candidateSelectedAt(row, variant, variantIndex, minQuality, minQuality);
+    const candidateSelectorFor = (threshold) => {
+      const baseSelector = (row) =>
+        candidateSelectedAt(row, variant, variantIndex, threshold, minQuality);
+      const selectedRows = selectRowsWithinCapacity({
+        rows,
+        selector: baseSelector,
+        selection: variant.selection,
+      });
+      return (row) => selectedRows.has(row);
+    };
+    const candidateSelector = candidateSelectorFor(minQuality);
     const matchedSelector = (row) => row.variantMatches[variantIndex];
     const removedSelector = (row) =>
       baselineSelector(row) && !candidateSelector(row);
@@ -3926,11 +4150,13 @@ export const buildAblationReport = ({
       quality: variant.quality,
       direction: variant.direction,
       expression: variant.expression,
+      selection: variant.selection ?? null,
+      placebo: variant.placebo ?? null,
       equity: buildEquitySeries(
         rows,
         candidateSelector,
         minTimestamp,
-        maxTimestamp,
+        maxTimestamp - Number(explicitWindow),
       ),
       periods: buildPeriodSummaries({
         rows,
@@ -3951,22 +4177,17 @@ export const buildAblationReport = ({
       tuning: summarizeSplit(split.tuning, candidateSelector, summaryOptions),
       test: summarizeSplit(split.test, candidateSelector, summaryOptions),
       qualityThresholds: Object.fromEntries(
-        qualityThresholds.map((threshold) => [
-          `q${threshold}+`,
-          summarizeRows(
-            selectRows(rows, (row) =>
-              candidateSelectedAt(
-                row,
-                variant,
-                variantIndex,
-                threshold,
-                minQuality,
-              ),
+        qualityThresholds.map((threshold) => {
+          const thresholdSelector = candidateSelectorFor(threshold);
+          return [
+            `q${threshold}+`,
+            summarizeRows(
+              selectRows(rows, thresholdSelector),
+              getPeriodDays(rows),
+              summaryOptions,
             ),
-            getPeriodDays(rows),
-            summaryOptions,
-          ),
-        ]),
+          ];
+        }),
       ),
       directions: summarizeDirections(rows, candidateSelector, summaryOptions),
       months: summarizeMonths(rows, candidateSelector, summaryOptions),
@@ -4003,6 +4224,9 @@ export const buildAblationReport = ({
       validationSplit,
       testSplit,
       partitionMode: exactCalendarPartitions ? 'exact-calendar' : 'ratio',
+      comparisonWindow: explicitWindow
+        ? { start: windowStart, end: windowEnd, interval: '[start, end)' }
+        : null,
       tuningSince: exactCalendarPartitions
         ? new Date(tuningSince).toISOString()
         : null,
@@ -5021,9 +5245,8 @@ export const main = async () => {
   }
   const sourceRepositoryRoot = findSourceRepositoryRoot();
   const sourceRepositoryKind = getSourceRepositoryKind(sourceRepositoryRoot);
-  const frameworkRepositoryRoot = findFrameworkRepositoryRoot(
-    sourceRepositoryRoot,
-  );
+  const frameworkRepositoryRoot =
+    findFrameworkRepositoryRoot(sourceRepositoryRoot);
   if (options.crossStrategy) {
     if (options.tuningSince != null || options.testSince != null) {
       throw new Error(
@@ -5134,6 +5357,8 @@ export const main = async () => {
     testSplit: options.testSplit,
     tuningSince: options.tuningSince,
     testSince: options.testSince,
+    windowStart: options.windowStart,
+    windowEnd: options.windowEnd,
     capacities: options.capacities,
     maxLossValue: options.maxLossValue,
     sourceRepositoryRoot,

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

@@ -7,6 +7,7 @@ import test from 'node:test';
 
 import {
   aggregateBenchmarkDiscoveryRows,
+  applyTimestampRotationPlacebos,
   applyBenchmarkEventSnapshots,
   balanceCrossStrategyRows,
   buildAblationReport,
@@ -35,6 +36,7 @@ import {
   parseVariant,
   partitionCrossStrategyFeatures,
   resolveArtifactProjectRoot,
+  selectRowsWithinCapacity,
   splitRowsByTimestamp,
   splitRowsByTimestampBounds,
   summarizeRows,
@@ -959,6 +961,181 @@ test('applies filter, exclude, add, and replace selection semantics', () => {
   assert.equal(selected('replace', false, true), true);
 });
 
+test('applies deterministic timestamp-local capacity ranking', () => {
+  const timestamp = Date.UTC(2026, 0, 1);
+  const rows = [
+    { timestamp, symbol: 'B', sequence: 0, features: { margin: 2 } },
+    { timestamp, symbol: 'A', sequence: 1, features: { margin: 2 } },
+    { timestamp, symbol: 'C', sequence: 2, features: { margin: 1 } },
+    { timestamp, symbol: 'D', sequence: 3, features: {} },
+  ];
+  const selected = selectRowsWithinCapacity({
+    rows,
+    selector: () => true,
+    selection: {
+      capacity: 2,
+      rankBy: [{ path: 'margin', order: 'desc' }],
+    },
+  });
+
+  assert.deepEqual(
+    rows.filter((row) => selected.has(row)).map((row) => row.symbol),
+    ['B', 'A'],
+  );
+});
+
+test('applies variant capacity before every report slice', () => {
+  const timestamp = Date.UTC(2026, 0, 1);
+  const variant = parseVariant('ranked::replace@4::true');
+  variant.selection = {
+    capacity: 2,
+    rankBy: [{ path: 'margin', order: 'desc' }],
+  };
+  const rows = [1, 3, 2].map((margin, sequence) => ({
+    timestamp,
+    profit: margin,
+    symbol: `S${sequence}`,
+    direction: 'SHORT',
+    directionMatches: true,
+    quality: 4,
+    variantMatches: [true],
+    features: { margin },
+    sequence,
+  }));
+  const report = buildAblationReport({
+    rows,
+    variants: [variant],
+    minQuality: 4,
+    qualityThresholds: [4],
+    terminalWindows: [7],
+    validationSplit: 0,
+    filePaths: ['part1.jsonl'],
+  });
+
+  assert.equal(report.variants[0].periods.full.trades, 2);
+  assert.equal(report.variants[0].periods.full.totalProfit, 5);
+  assert.equal(report.variants[0].train.trades, 2);
+  assert.deepEqual(report.variants[0].selection, variant.selection);
+});
+
+test('uses common half-open comparison bounds for sparse gate exports', () => {
+  const start = Date.UTC(2025, 0, 1);
+  const day = 86400000;
+  const end = start + 365 * day;
+  const rows = [-1, 0, 100, 365].map((offset, sequence) => ({
+    timestamp: start + offset * day,
+    profit: 10,
+    symbol: 'A',
+    direction: 'LONG',
+    directionMatches: true,
+    quality: 4,
+    variantMatches: [true],
+    sequence,
+  }));
+  const args = {
+    rows,
+    variants: [parseVariant('pass::replace@4::true')],
+    minQuality: 4,
+    qualityThresholds: [4],
+    terminalWindows: [30, 7],
+    validationSplit: 0,
+    filePaths: ['fixture.jsonl'],
+    windowStart: start,
+    windowEnd: end,
+  };
+  const report = buildAblationReport(args);
+  assert.equal(report.run.rows, 2);
+  assert.equal(report.variants[0].periods.full.totalProfit, 20);
+  assert.equal(report.variants[0].periods.full.cadencePerDay, 2 / 365);
+  assert.equal(
+    report.variants[0].periodDirections.full.LONG.cadencePerDay,
+    2 / 365,
+  );
+  assert.equal(report.variants[0].periods['30d'].trades, 0);
+  assert.deepEqual(report.variants[0].equity.at(-1), [end - 1, 20]);
+  assert.throws(
+    () => buildAblationReport({ ...args, windowEnd: null }),
+    /both windowStart/,
+  );
+  assert.throws(
+    () => buildAblationReport({ ...args, windowEnd: start }),
+    /increasing bounds/,
+  );
+  const empty = buildAblationReport({
+    ...args,
+    windowStart: end + day,
+    windowEnd: end + 2 * day,
+  });
+  assert.equal(empty.variants[0].periods.full.trades, 0);
+  assert.equal(empty.variants[0].periods.full.totalProfit, 0);
+  const parsed = parseCliArgs([
+    '--windowStart',
+    String(start),
+    '--windowEnd',
+    new Date(end).toISOString(),
+  ]);
+  assert.equal(parsed.windowStart, start);
+  assert.equal(parsed.windowEnd, end);
+});
+
+test('rotates placebo approval timestamps while preserving event count', () => {
+  const variants = [
+    { name: 'reference' },
+    {
+      name: 'rotated',
+      placebo: {
+        type: 'timestamp-rotation',
+        referenceVariant: 'reference',
+        offsetEvents: 1,
+      },
+    },
+  ];
+  const rows = [0, 1, 2, 3].map((index) => ({
+    timestamp: Date.UTC(2026, 0, index + 1),
+    variantMatches: [index === 0 || index === 2, true],
+  }));
+
+  applyTimestampRotationPlacebos(rows, variants);
+
+  assert.deepEqual(
+    rows.filter((row) => row.variantMatches[1]).map((row) => row.timestamp),
+    [Date.UTC(2026, 0, 2), Date.UTC(2026, 0, 4)],
+  );
+});
+
+test('preserves timestamp-rotation event count inside each supplied partition', () => {
+  const variants = [
+    { name: 'reference' },
+    {
+      name: 'rotated',
+      placebo: {
+        type: 'timestamp-rotation',
+        referenceVariant: 'reference',
+        offsetEvents: 1,
+      },
+    },
+  ];
+  const rows = [0, 1, 2, 3, 4, 5].map((index) => ({
+    timestamp: Date.UTC(2026, 0, index + 1),
+    variantMatches: [[0, 2, 3, 5].includes(index), true],
+  }));
+  const partitions = [rows.slice(0, 3), rows.slice(3)];
+
+  applyTimestampRotationPlacebos(rows, variants, partitions);
+
+  assert.deepEqual(
+    partitions.map(
+      (partition) =>
+        new Set(
+          partition
+            .filter((row) => row.variantMatches[1])
+            .map((row) => row.timestamp),
+        ).size,
+    ),
+    [2, 2],
+  );
+});
+
 test('calculates required profit, drawdown, strict-loss, and cadence metrics', () => {
   const rows = [
     {
@@ -1067,12 +1244,18 @@ test('uses exact calendar boundaries without splitting timestamp events', () =>
 
   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']);
+  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', () => {

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

@@ -480,7 +480,7 @@ const dashboardSvg = (board) => {
   const terminalLegend = terminalSeries
     .map((candidate, index) => {
       const x = bar.x + index * terminalLegendWidth;
-      return `<g data-terminal-legend="${escapeXml(candidate.id)}"><rect x="${x}" y="402" width="16" height="16" rx="3" fill="${candidate.color}"/><text x="${x + 24}" y="416" class="axis">${escapeXml(truncate(candidate.label, 40))}</text></g>`;
+      return `<g data-terminal-legend="${escapeXml(candidate.id)}"><rect x="${x}" y="402" width="16" height="16" rx="3" fill="${candidate.color}"/><text x="${x + 24}" y="416" class="axis">${escapeXml(truncate(candidate.label, Math.floor((terminalLegendWidth - 35) / 9)))}</text></g>`;
     })
     .join('');
   const pnlValues = terminalSeries.flatMap(({ terminal }) =>
@@ -556,18 +556,18 @@ const dashboardSvg = (board) => {
       const x = sx(candidate.metrics.maxDrawdown);
       const y = sy(candidate.metrics.pnl);
       const selectedPoint = candidate.id === selected.id;
-      const labelY = y + ((index % 3) - 1) * 24;
+      const labelY = y + 5;
       const labelOnLeft = x > scatter.x + scatter.width * 0.66;
       const labelX = x + (labelOnLeft ? -14 : 14);
       const anchor = labelOnLeft ? 'end' : 'start';
-      return `${selectedPoint ? `<circle cx="${x}" cy="${y}" r="24" fill="${candidate.color}" opacity="0.18"/>` : ''}<circle cx="${x}" cy="${y}" r="${selectedPoint ? 12 : 9}" fill="${candidate.color}" stroke="${selectedPoint ? '#7a321b' : '#ffffff'}" stroke-width="${selectedPoint ? 3 : 2}"/><text x="${labelX}" y="${labelY}" text-anchor="${anchor}" class="pointLabel" fill="${selectedPoint ? candidate.color : '#24302a'}">${escapeXml(truncate(candidate.label, 25))}</text>`;
+      return `${selectedPoint ? `<circle cx="${x}" cy="${y}" r="24" fill="${candidate.color}" opacity="0.18"/>` : ''}<circle cx="${x}" cy="${y}" r="${selectedPoint ? 12 : 9}" fill="${candidate.color}" stroke="${selectedPoint ? '#7a321b' : '#ffffff'}" stroke-width="${selectedPoint ? 3 : 2}"/><text x="${labelX}" y="${labelY}" text-anchor="${anchor}" class="pointLabel" fill="${selectedPoint ? candidate.color : '#24302a'}">${index === 0 ? '0' : String.fromCharCode(64 + index)}</text>`;
     })
     .join('');
 
   const limitations = board.limitations.length
     ? `Limitations: ${board.limitations.join(' · ')}`
     : 'Limitations: none recorded';
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(board.strategy)} final composition dashboard"><style>.bg{fill:#f5f4ef}.panel{fill:#fff;stroke:#ddd9d0;stroke-width:2}.title{font:500 42px Arial,sans-serif;fill:#17211d}.subtitle{font:22px Arial,sans-serif;fill:#38433e}.cardLabel{font:21px Arial,sans-serif;fill:#303a35}.cardValue{font:500 44px Arial,sans-serif}.cardDetail{font:18px Arial,sans-serif;fill:#303a35}.section{font:500 27px Arial,sans-serif;fill:#17211d}.muted{font:18px Arial,sans-serif;fill:#45514a}.axis{font:15px Arial,sans-serif;fill:#58645e}.grid{stroke:#d9ddd9;stroke-width:1.5}.faint{opacity:.5}.barValue{font:16px Arial,sans-serif;fill:#24302a}.windowLabel{font:20px Arial,sans-serif;fill:#24302a}.windowCount{font:15px Arial,sans-serif;fill:#45514a}.pointLabel{font:16px Arial,sans-serif}.footer{font:18px Arial,sans-serif;fill:#6b4b1f}</style><rect width="100%" height="100%" class="bg"/><text x="72" y="70" class="title">${escapeXml(board.strategy)} · ${escapeXml(selected.label)}</text><text x="72" y="108" class="subtitle">${escapeXml(board.subtitle)}</text>${cardsMarkup}<rect x="72" y="330" width="1040" height="650" rx="20" class="panel"/><text x="100" y="380" class="section">PnL in terminal windows</text>${terminalLegend}<rect x="1145" y="330" width="585" height="650" rx="20" class="panel"/><text x="1180" y="380" class="section">Final compositions: PnL ↔ drawdown</text><text x="1180" y="412" class="muted">Higher and farther left is preferable</text><g>${barGrid}<line x1="${bar.x}" x2="${bar.x + bar.width}" y1="${zeroY}" y2="${zeroY}" stroke="#8f9994" stroke-width="1.5"/>${bars}</g><g>${scatterGrid}${points}<text x="${scatter.x + scatter.width / 2}" y="${scatter.y + scatter.height + 65}" text-anchor="middle" class="muted">Realized MaxDD</text></g><g><rect x="72" y="1020" width="1658" height="112" rx="16" fill="#fff5dd" stroke="#efd79c" stroke-width="2"/>${svgTextLines({ lines: [truncate(limitations, 155), `Risk normalization: MAX_LOSS_VALUE=${board.normalization.maxLossValue} · ${board.normalization.pnlUnit} · ${board.researchId}`], x: 98, y: 1062, lineHeight: 30, className: 'footer' })}</g></svg>`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(board.strategy)} final composition dashboard"><style>.bg{fill:#f5f4ef}.panel{fill:#fff;stroke:#ddd9d0;stroke-width:2}.title{font:500 42px Arial,sans-serif;fill:#17211d}.subtitle{font:22px Arial,sans-serif;fill:#38433e}.cardLabel{font:21px Arial,sans-serif;fill:#303a35}.cardValue{font:500 44px Arial,sans-serif}.cardDetail{font:18px Arial,sans-serif;fill:#303a35}.section{font:500 27px Arial,sans-serif;fill:#17211d}.muted{font:18px Arial,sans-serif;fill:#45514a}.axis{font:15px Arial,sans-serif;fill:#58645e}.grid{stroke:#d9ddd9;stroke-width:1.5}.faint{opacity:.5}.barValue{font:16px Arial,sans-serif;fill:#24302a}.windowLabel{font:20px Arial,sans-serif;fill:#24302a}.windowCount{font:15px Arial,sans-serif;fill:#45514a}.pointLabel{font:16px Arial,sans-serif}.footer{font:18px Arial,sans-serif;fill:#6b4b1f}</style><rect width="100%" height="100%" class="bg"/><text x="72" y="70" class="title">${escapeXml(board.strategy)} · ${escapeXml(selected.label)}</text><text x="72" y="108" class="subtitle">${escapeXml(board.subtitle)}</text>${cardsMarkup}<rect x="72" y="330" width="1040" height="650" rx="20" class="panel"/><text x="100" y="380" class="section">PnL in terminal windows</text>${terminalLegend}<rect x="1145" y="330" width="585" height="650" rx="20" class="panel"/><text x="1180" y="380" class="section">Final compositions: PnL ↔ drawdown</text><text x="1180" y="412" class="muted">Higher and farther left is preferable</text><g>${barGrid}<line x1="${bar.x}" x2="${bar.x + bar.width}" y1="${zeroY}" y2="${zeroY}" stroke="#8f9994" stroke-width="1.5"/>${bars}</g><g>${scatterGrid}${points}<text x="${scatter.x + scatter.width / 2}" y="${scatter.y + scatter.height + 65}" text-anchor="middle" class="muted">MaxDD (trade stream)</text></g><g><rect x="72" y="1020" width="1658" height="112" rx="16" fill="#fff5dd" stroke="#efd79c" stroke-width="2"/>${svgTextLines({ lines: [truncate(limitations, 155), `Risk normalization: MAX_LOSS_VALUE=${board.normalization.maxLossValue} · ${board.normalization.pnlUnit} · ${board.researchId}`], x: 98, y: 1062, lineHeight: 30, className: 'footer' })}</g></svg>`;
 };
 
 const downsample = (points, maxPoints = 1200) => {
@@ -621,9 +621,7 @@ const equitySvg = (board) => {
   }).join('');
   const spanDays = (maxTime - minTime) / 86_400_000;
   const xTicks = Array.from({ length: 6 }, (_, index) => {
-    const timestamp = Math.round(
-      minTime + ((maxTime - minTime) * index) / 5,
-    );
+    const timestamp = Math.round(minTime + ((maxTime - minTime) * index) / 5);
     const date = new Date(timestamp);
     const label =
       spanDays >= 730
@@ -650,6 +648,9 @@ const equitySvg = (board) => {
   const curves = board.candidates
     .map((candidate) => {
       const points = downsample(candidate.equity)
+        .flatMap((point, index, series) =>
+          index === 0 ? [point] : [[point[0], series[index - 1][1]], point],
+        )
         .map(
           ([timestamp, pnl]) =>
             `${x(timestamp).toFixed(1)},${y(pnl).toFixed(1)}`,
@@ -667,11 +668,11 @@ const equitySvg = (board) => {
       const row = Math.floor(index / columns);
       const lx = left + column * legendWidth;
       const ly = height - bottom + 110 + row * 58;
-      return `<g transform="translate(${lx},${ly})"><rect width="18" height="18" rx="3" fill="${candidate.color}"/><text x="28" y="15" class="legendLabel">${escapeXml(truncate(candidate.label, 35))}</text><text x="28" y="37" class="legendMetric">N=${candidate.metrics.trades} · PnL=${formatNumber(candidate.metrics.pnl, 1)} · DD=${formatNumber(candidate.metrics.maxDrawdown, 1)}</text></g>`;
+      return `<g transform="translate(${lx},${ly})"><rect width="18" height="18" rx="3" fill="${candidate.color}"/><text x="28" y="15" class="legendLabel">${index === 0 ? '0' : String.fromCharCode(64 + index)} · ${escapeXml(truncate(candidate.label, 35))}</text><text x="28" y="37" class="legendMetric">N=${candidate.metrics.trades} · PnL=${formatNumber(candidate.metrics.pnl, 1)} · DD=${formatNumber(candidate.metrics.maxDrawdown, 1)}</text></g>`;
     })
     .join('');
   const selected = board.candidates.find(({ id }) => id === board.selectedId);
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(board.strategy)} final composition equity"><style>.bg{fill:#fff}.title{font:700 36px Arial,sans-serif;fill:#172033}.subtitle{font:18px Arial,sans-serif;fill:#687184}.axis{font:15px Arial,sans-serif;fill:#687184}.grid{stroke:#e2e6eb;stroke-width:1.5}.faint{opacity:.55}.legendLabel{font:600 17px Arial,sans-serif;fill:#263044}.legendMetric{font:15px Arial,sans-serif;fill:#687184}.axisTitle{font:17px Arial,sans-serif;fill:#394459}</style><rect width="100%" height="100%" class="bg"/><text x="${left}" y="58" class="title">${escapeXml(board.title)}</text><text x="${left}" y="92" class="subtitle">Baseline = production core + current AI-gate · candidates = core + own deterministic gate</text><text x="${left}" y="120" class="subtitle">Selected: ${escapeXml(selected.label)} · ${escapeXml(board.subtitle)}</text>${yGrid}${xGrid}<line x1="${left}" x2="${width - right}" y1="${y(0)}" y2="${y(0)}" stroke="#aab2bd" stroke-width="1.5"/>${curves}<line x1="${left}" x2="${left}" y1="${top}" y2="${height - bottom}" stroke="#7d8795" stroke-width="1.5"/><line x1="${left}" x2="${width - right}" y1="${height - bottom}" y2="${height - bottom}" stroke="#7d8795" stroke-width="1.5"/><text x="${left + plotWidth / 2}" y="${height - bottom + 67}" text-anchor="middle" class="axisTitle">Exit date (UTC)</text><text x="30" y="${top + plotHeight / 2}" transform="rotate(-90 30 ${top + plotHeight / 2})" text-anchor="middle" class="axisTitle">Cumulative PnL (${escapeXml(board.normalization.pnlUnit)})</text>${legend}</svg>`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(board.strategy)} final composition equity"><style>.bg{fill:#fff}.title{font:700 36px Arial,sans-serif;fill:#172033}.subtitle{font:18px Arial,sans-serif;fill:#687184}.axis{font:15px Arial,sans-serif;fill:#687184}.grid{stroke:#e2e6eb;stroke-width:1.5}.faint{opacity:.55}.legendLabel{font:600 17px Arial,sans-serif;fill:#263044}.legendMetric{font:15px Arial,sans-serif;fill:#687184}.axisTitle{font:17px Arial,sans-serif;fill:#394459}</style><rect width="100%" height="100%" class="bg"/><text x="${left}" y="58" class="title">${escapeXml(board.title)}</text><text x="${left}" y="92" class="subtitle">Baseline = current gate behavior; candidates = core + own deterministic gate</text><text x="${left}" y="120" class="subtitle">Selected: ${escapeXml(selected.label)} · ${escapeXml(board.subtitle)}</text>${yGrid}${xGrid}<line x1="${left}" x2="${width - right}" y1="${y(0)}" y2="${y(0)}" stroke="#aab2bd" stroke-width="1.5"/>${curves}<line x1="${left}" x2="${left}" y1="${top}" y2="${height - bottom}" stroke="#7d8795" stroke-width="1.5"/><line x1="${left}" x2="${width - right}" y1="${height - bottom}" y2="${height - bottom}" stroke="#7d8795" stroke-width="1.5"/><text x="${left + plotWidth / 2}" y="${height - bottom + 67}" text-anchor="middle" class="axisTitle">Date (UTC)</text><text x="30" y="${top + plotHeight / 2}" transform="rotate(-90 30 ${top + plotHeight / 2})" text-anchor="middle" class="axisTitle">Cumulative PnL (${escapeXml(board.normalization.pnlUnit)})</text>${legend}</svg>`;
 };
 
 const verifyCandidateArtifacts = async (board, artifactRoot) => {

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

@@ -174,9 +174,23 @@ test('verifies candidate artifacts and renders the dashboard and equity board',
   );
   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, /Baseline = current gate behavior/u);
   assert.match(equity, /candidate \+ own gate/u);
-  assert.match(equity, /Exit date \(UTC\)/u);
+  assert.match(equity, /Date \(UTC\)/u);
+  for (const [, coordinates] of equity.matchAll(
+    /<polyline points="([^"]+)"/gu,
+  )) {
+    const points = coordinates
+      .split(' ')
+      .map((point) => point.split(',').map(Number));
+    for (let index = 1; index < points.length; index += 1) {
+      assert.ok(
+        points[index][0] === points[index - 1][0] ||
+          points[index][1] === points[index - 1][1],
+        'Cumulative PnL must not interpolate gains between trade events',
+      );
+    }
+  }
   assert.match(equity, /Nov 2023/u);
   assert.match(equity, /Mar 2024/u);
 });

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": "80078cbf06c8239edffb266a36db3a9b7127000a26001381f7fa99b92aa3e4eb",
+  "bundleSha256": "be995341ae9459133ad1bb60da5c8fac01c5ffbe6d72309c1d68448abbe03c0e",
   "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": "a1011bf0c9fcccf1692983364da168a1bac6d044b24ed3bfd7cb44e4b0ca9ed5",
+    ".codex/skills/ai-train-local-research/references/gate-ablation.md": "a32ca7272a74678aca97dfce6b098ed15ca41fc385b936f25492f47bce4ec621",
     ".codex/skills/ai-train-local-research/references/reporting.md": "a5a5cc6438a8cc228560e302e944f1ff320f4c963988af83e1ba1443728f7149",
-    ".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/scripts/ai-gate-ablation.mjs": "4275088307342ef35d848f1bdd39528c22d2c66cf41aa7d3ed26f851c2fe803b",
+    ".codex/skills/ai-train-local-research/scripts/ai-gate-ablation.test.mjs": "f9adcb02a779fb1da23e9c0aa99dead6152c5f45464138dd1de4283ece4ed363",
     ".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",
@@ -44,8 +44,8 @@
     ".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": "759ed89f0afcfdff8c710a13d907b959f9bce648d185a15d16034b898656deda",
-    ".codex/skills/strategy-improvement-research/scripts/final-composition-board.test.mjs": "9bcb15f7a53ca9c55a1e45fc80f6030135952c69cc71179a18f0a714e21be38c",
+    ".codex/skills/strategy-improvement-research/scripts/final-composition-board.mjs": "b00f0160823a25c31afbcab66ce0c16fc70055928463a5741b3ffe8063ee8a81",
+    ".codex/skills/strategy-improvement-research/scripts/final-composition-board.test.mjs": "a40e8b395ed1c758dc9862b44887e71e8cb9352ce26443d244397f76af891b62",
     ".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",

package/package.json

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