create-tradejs 3.1.22 → 3.1.23

package/dist/skill-bundle/.codex/skills/strategy-release/references/research-objective.md

@@ -0,0 +1,255 @@
+# Release research objective and candidate revalidation
+
+## Contents
+
+1. Version the objective
+2. Use a hierarchical objective
+3. Condition terminal evidence on support
+4. Revalidate historical candidates
+5. Keep one global trial ledger
+6. Required artifacts
+7. Progress checkpoint payload
+
+## 1. Version the objective
+
+Every release task starts a new immutable lineage unless the user explicitly
+names an existing lineage to continue. Audit prior work, but never count a
+prior round, rescue child, gate ablation, report, or verdict as work completed
+inside the new lineage.
+
+Before the baseline, persist a `tradejs-release-objective/v2` artifact. Its
+file SHA-256 is the `objectiveFingerprint` for the lineage. Freeze:
+
+- the return unit and risk normalization;
+- cost/slippage and adverse-cost scenarios;
+- development, tuning, sealed-test, walk-forward, and terminal partitions;
+- eligibility gates, Pareto dimensions, and tie-break rules;
+- independent-event grouping and support bands;
+- drawdown, concentration, capacity, and execution guardrails;
+- the global trial-ledger reference used for DSR/PBO.
+
+Any change to these fields creates a new objective fingerprint. Do not reuse a
+ranking, verdict, or selected candidate from another fingerprint.
+
+## 2. Use a hierarchical objective
+
+Do not maximize full-period PnL, Sharpe, win rate, or recent-window PnL in
+isolation. Use this hierarchy:
+
+1. **Integrity and causality.** Complete reconciled evidence, signal-time
+   inputs, point-in-time execution semantics, and comparable risk/cost units
+   are mandatory.
+2. **Economic edge.** Require positive aggregate expectancy per unit risk after
+   normal costs and PF above 1 on the maximum-covered historical evaluation.
+   Apply the same check to every active approved side; an explicitly suppressed
+   side remains a zero row. Nested calendar slices do not repeat this gate.
+3. **Selection adjustment.** Report probabilistic and deflated Sharpe using
+   non-IID-aware returns and the complete effective trial count. A raw
+   per-trade annualized Sharpe is diagnostic, not selection authority.
+4. **Risk robustness.** Enforce preregistered realized MaxDD, tail/CVaR,
+   recovery, time-under-water, adverse-cost, concentration, and capacity
+   guardrails.
+5. **Temporal robustness.** Prefer non-overlapping/event-grouped walk-forward
+   evidence and regime coverage. Nested 3y/4y/max and recent calendar windows
+   are context, not independent confirmations or waiting periods.
+6. **Executable support.** Require independent events, viable cadence, and an
+   event-arrival rate consistent with the strategy thesis.
+
+Rank eligible candidates on a Pareto frontier across expectancy/risk, PF,
+deflated Sharpe, MaxDD/recovery, walk-forward stability, cost stress,
+independent support, and cadence. Use a scalar score only as a frozen tie-break,
+never to compensate for a failed integrity or economic gate.
+
+Treat win rate only together with payoff ratio and expectancy. Treat maximum
+loss streak, losing-month streak, drawdown duration, and worst rolling returns
+as risk diagnostics and monitoring bounds, not optimization targets. Absolute
+streaks grow mechanically with sample size and cannot fairly rank candidates
+with different cadence.
+
+## 3. Condition terminal evidence on support
+
+Always report continuous-run 365d/180d/90d/30d/7d rows, including zero rows,
+but use them to describe current regime and cadence rather than to decide when a
+prospective test may start. Classify each ALL/LONG/SHORT cohort by independent
+event count:
+
+- `underpowered`: fewer than 20 independent closed events;
+- `diagnostic`: 20 through 49 independent closed events;
+- `selection_grade`: at least 50 independent closed events.
+
+An `underpowered` terminal row is `n/a` for pass/fail. It cannot reject a
+candidate, prove current-market decay, justify another threshold, or force a
+calendar wait. A `diagnostic` row may motivate the one preregistered causal
+recent-direction repair, but cannot reject an otherwise eligible composition by
+itself. A `selection_grade` row may cap a historical `READY_FOR_RUNTIME` claim
+or lower the candidate's Pareto rank, but it does not block an otherwise valid
+`MAX_LOSS_VALUE=1` prospective test. Hard causality, reconciliation, execution,
+maximum-covered economics, and frozen portfolio-risk failures still block it.
+
+For sparse strategies also report the last 20/50/100 independent events and
+compare observed calendar cadence with the preregistered historical
+event-arrival distribution. Zero trades are a cadence observation, not a loss;
+classify them as abnormal only when they breach that frozen distribution. The
+next review is triggered by independent events or a risk/parity breach, never
+by waiting 7, 30, or 180 calendar days.
+
+## 4. Revalidate historical candidates
+
+Objective changes invalidate old rankings, not the underlying evidence. Before
+inventing new hypotheses, build a deduplicated inventory of every historical
+core, deterministic-gate, direction-policy, rescue, shortlisted, and untested
+candidate. Group semantic duplicates by behavior/config fingerprint.
+
+For every reconstructable candidate:
+
+1. Recompute the new objective from retained normalized trades when window,
+   universe, costs, execution semantics, source behavior, and risk unit match.
+2. Otherwise rerun the exact historical behavior on the new frozen contract
+   with `--cacheOnly` before ranking it when it could reach the new frontier.
+3. Record `rescored`, `bridge-rerun`, `rejected`, `partial`, or
+   `unreconstructable`, with the source inventory entry, evidence paths, and
+   hashes. Use `new-trial-required` for an inventoried behavior that was never
+   economically tested; schedule it inside the normal new-candidate budget.
+4. Put every evaluated behavior in the global trial ledger even when it is no
+   longer shortlisted. Re-scoring does not erase the original selection look.
+5. Preserve exposed tails as exposed. A new lineage or objective fingerprint
+   never makes previously viewed data sealed again.
+
+Metric-only re-scoring and exact bridge reruns of already-tested behavior do
+not consume the new lineage's 18 causal-candidate slots. They remain part of
+the global multiple-testing count. A changed threshold, feature, direction
+policy, payoff rule, or other behavior is a new candidate and consumes the
+normal family/rescue budget.
+
+Finish the revalidation board before freezing the three new causal families.
+An old candidate may become the matched control or finalist under the new
+objective, but the task must still perform its new causal improvement rounds;
+revalidation is evidence-first preparation, not a substitute for new research.
+
+## 5. Keep one global trial ledger
+
+The trial ledger spans tasks, lineages, source branches, objective versions,
+core variants, gate variants, directional policies, and rescue attempts.
+Deduplicate exact behavior reruns but retain every distinct selection look.
+Record at least:
+
+- candidate/behavior fingerprint and parent family;
+- first-seen lineage and every evaluation lineage;
+- objective fingerprint;
+- development/tuning/test exposure status;
+- return series, sample size, skew, kurtosis, and serial-dependence method;
+- raw, probabilistic, and deflated Sharpe;
+- effective independent trial count and PBO/selection diagnostics.
+
+Do not reset DSR/PBO because a new chat, Git commit, research id, or objective
+was created. Repeated research is legitimate only when the ledger makes the
+increasing selection burden explicit.
+
+## 6. Required artifacts
+
+Before round 1, persist:
+
+```json
+{
+  "schema": "tradejs-release-candidate-revalidation/v2",
+  "strategy": "<Strategy>",
+  "lineageId": "<new-lineage-id>",
+  "objectiveFingerprint": "<objective-artifact-sha256>",
+  "historyInventorySha256": "<history-inventory-sha256>",
+  "status": "complete",
+  "priorCandidateCount": 1,
+  "candidates": [
+    {
+      "historyEntryIndex": 0,
+      "disposition": "rescored|bridge-rerun|rejected|partial|unreconstructable|new-trial-required",
+      "behaviorFingerprint": "<sha256>",
+      "evidence": []
+    }
+  ],
+  "unresolved": [],
+  "trialLedger": { "path": "<path>", "sha256": "<sha256>" }
+}
+```
+
+`priorCandidateCount: 0` is valid only when the bound history inventory proves
+that no prior behavior candidate exists. Refactor-only and superseded-duplicate
+entries are excluded; every other deduplicated entry needs exactly one indexed
+disposition. Hash this artifact and reference it from the opportunity map, all
+new round specs/handoffs, the rescue board, selected composition, and final
+decision.
+
+## 7. Progress checkpoint payload
+
+Use `tradejs-release-progress-input/v2`. Completion claims are artifact-backed:
+
+```json
+{
+  "schema": "tradejs-release-progress-input/v2",
+  "strategy": "<Strategy>",
+  "lineageId": "<new-lineage-id>",
+  "objectiveContract": { "artifact": { "path": "...", "sha256": "..." } },
+  "historyAudit": {
+    "complete": true,
+    "artifact": { "path": "...", "sha256": "..." }
+  },
+  "candidateRevalidation": {
+    "required": true,
+    "complete": true,
+    "artifact": { "path": "...", "sha256": "..." }
+  },
+  "baseline": {
+    "complete": true,
+    "reconciled": true,
+    "artifact": { "path": "...", "sha256": "..." }
+  },
+  "opportunityMap": {
+    "complete": true,
+    "artifact": { "path": "...", "sha256": "..." }
+  },
+  "hypothesisPortfolio": {
+    "frozen": true,
+    "artifact": { "path": "...", "sha256": "..." }
+  },
+  "families": [
+    {
+      "id": "<family>",
+      "status": "active",
+      "roundArtifacts": [
+        {
+          "round": 1,
+          "researchId": "<id>",
+          "manifestArtifact": { "path": "...", "sha256": "..." },
+          "resultArtifact": { "path": "...", "sha256": "..." },
+          "traceArtifacts": [{ "path": "...", "sha256": "..." }],
+          "handoffArtifact": { "path": "...", "sha256": "..." }
+        }
+      ]
+    }
+  ],
+  "rescueBoard": { "complete": false },
+  "directionalParameterCheckpoint": { "required": false, "complete": false },
+  "directionPolicyCheckpoint": { "required": false, "complete": false },
+  "fullAiReport": { "complete": false },
+  "chart": { "complete": false },
+  "selectedComposition": null,
+  "limitations": []
+}
+```
+
+Provide exactly three family entries. `roundArtifacts`, not a caller-supplied
+count, determines completed rounds. Each round requires a completed matching
+core manifest, result, trace declared by that result, and causal handoff whose
+`resultSha256` matches the result file. A family retired before round 3 also
+requires a hashed `retirementArtifact`.
+
+A completed rescue board uses `tradejs-release-rescue-board/v2`, binds the same
+strategy/lineage/objective, embeds artifact-backed child evidence, and accounts
+for all three slots through `children` plus bounded `missingSlots` reasons.
+
+After the exact chart is frozen, create
+`tradejs-release-selected-composition/v2`. It binds the strategy, lineage,
+candidate id, composition fingerprint, objective fingerprint, historical
+matrix SHA, chart SHA, and core/gate fingerprints. Pass its reference as
+`selectedComposition.artifact`. The checkpoint returns
+`tradejs-release-progress/v2` and copies the verified selected identity into
+its decision output for `strategy-release decide`.

package/dist/skill-bundle/.codex/skills/strategy-release/references/verdict-contract.md

@@ -0,0 +1,200 @@
+# Verdict contract
+
+Return exactly one mode-specific verdict. Put the verdict first, then the
+composition/incident identity, evidence completeness, ALL/LONG/SHORT table,
+causal findings, limitations, and approval-safe next action.
+
+## Shared rules
+
+- Treat a verdict as an evidence classification, not an authorization token.
+- Keep ALL, LONG, and SHORT statuses separate. A positive aggregate cannot hide
+  a failed side, and a negative side cannot be silently disabled. An explicit
+  tested `long_only` or `short_only` deterministic-gate policy is allowed, but
+  the suppressed raw side and its zero approved row must remain visible.
+- Apply `evidence-first, novelty-second`. A release verdict is incomplete until
+  the historical commit/evidence inventory is hashed, every stronger prior
+  result is classified and bridged to the current window/universe/config/cost
+  contract, and every selected untested historical behavior has a recorded
+  disposition. Do not call a weaker new search exhaustive while comparable
+  prior evidence remains unexplained.
+- Bind the verdict to one `tradejs-release-objective/v2` fingerprint. Complete
+  the historical-candidate revalidation board under that fingerprint and retain
+  every distinct old/new behavior in the global trial ledger before ranking a
+  finalist.
+- A current gate that approves zero/negligible rows from a profitable raw side
+  is incomplete evidence. Do not return a final market-unsuitable verdict until
+  the mandatory five-variant side-rescue round has been executed and recorded.
+- A raw aggregate that fails because one side is the dominant loss is not a
+  final verdict while the opposite side passes the frozen useful-side rule.
+  Complete the five-variant direction-containment checkpoint before rejecting
+  the composition.
+- `READY_FOR_RUNTIME` requires a genuinely sealed chronological gate test:
+  pocket discovery may know its count and time bounds but not its PnL or feature
+  outcomes. A test opened before variant freeze is permanently exposed and can
+  support only historical diagnosis/forward-candidate selection in that
+  lineage.
+- Treat `MAX_LOSS_VALUE` as risk scale rather than decision-logic identity.
+  Preserve its immutable change history, normalize monetary comparisons to the
+  release risk unit, and return `INSUFFICIENT_EVIDENCE` when either scale is
+  unavailable. Never compare unnormalized dollar drawdowns across risk scales.
+- Treat local Redis config names/ids and deployment/account ids, and
+  server credentials as environment binding rather than composition logic.
+  Never infer production absence from missing local keys. A locally unbound but
+  otherwise verified candidate is `MICRO_FORWARD_READY` with
+  `requiresRuntimeBinding=true`; bind and reverify it on the runtime server.
+  Activation (`ENABLE`) remains execution-critical and must equal the
+  authorized handoff before forward execution.
+- Use aggregate portfolio MaxDD for ALL and side-only realized MaxDD for each
+  direction.
+- Report every terminal row, but apply the support classes from
+  [research-objective.md](research-objective.md). An underpowered row is `n/a`
+  and a diagnostic row cannot reject a composition by itself. A selection-grade
+  row may limit historical readiness and candidate rank, but no terminal
+  calendar row blocks an otherwise valid risk-1 prospective test. Empty recent
+  windows are cadence evidence, not losses.
+- A complete release verdict, including `UNSUITABLE_FOR_CURRENT_MARKET`,
+  requires the full window matrix and the complete `$ai-train-local-research`
+  report. A negative verdict cannot replace omitted statistics with an artifact
+  link or a short rescue leaderboard.
+- Prefer `INSUFFICIENT_EVIDENCE` over extrapolation when lineage, completeness,
+  parity, point-in-time validity, independent support, or reconciliation fails.
+- This classifies the historical claim; it does not automatically mean stop.
+  Retrospective-universe or exposed-holdout limitations require continued
+  bounded research and may end in a risk-1 prospective handoff.
+- Keep any unapproved next composition in forward incubation/advisory mode.
+- A verdict never means “wait”. Pair it with the deterministic research action:
+  bounded recent-direction repair, authorized risk-1 micro-forward, a concrete
+  blocker, or stop. An exposed holdout blocks `READY_FOR_RUNTIME` but does not
+  block prospective micro-forward evidence.
+
+## Release verdicts
+
+### `READY_FOR_RUNTIME`
+
+Use only when all conditions hold:
+
+- the one final core plus deterministic gate composition is immutable and
+  completely reconciled;
+- the bounded core loop used one anchor plus two evidence-driven refinement
+  pairs per surviving family, then completed the mandatory cadence-diverse
+  rescue board, never exceeded 3×5+3 candidates, and completed full
+  metric/match/trace analysis before each child;
+- one isolated-long finalist and one gate round followed the preregistered
+  rules without reopening the held-out evidence;
+- BOTH directions stayed enabled in raw evidence and ALL/LONG/SHORT were
+  reported; the approved composition either passes its explicit rules for both
+  sides or uses a preregistered, held-out-tested `long_only`/`short_only` gate
+  policy whose retained side and ALL stream pass while the suppressed side is
+  shown explicitly as zero approved support;
+- full, terminal, cold-start/reset, concentration, capacity, causality, and
+  current-market evidence satisfy the release contract;
+- no unresolved runtime-parity or data-lineage blocker remains.
+- the progress decision, selected-composition artifact, objective fingerprint,
+  historical matrix, and chart all identify the same candidate/composition.
+
+Meaning: the composition supports the strongest historical claim. The verdict
+alone is not mutation authority; a `release`-mode invocation separately
+authorizes the exact risk-1 rollout unless it explicitly forbids runtime
+changes. Never place, cancel, or close orders manually.
+
+### `UNSUITABLE_FOR_CURRENT_MARKET`
+
+Use when evidence is complete and valid, but no composition satisfies the
+prospective rule: positive maximum-covered economics for every active approved
+side plus frozen drawdown/tail/cost/concentration/support guardrails. A recent
+calendar loss alone is not sufficient. Typical evidence includes failed active
+side economics, unacceptable portfolio DD/capacity, or no qualifying isolated
+finalist.
+
+Do not use this verdict merely because the first three rounds produced no
+eligible finalist. It requires the historical bridge and all available rescue
+slots to be complete. It also requires the direction-policy checkpoint, the
+maximum-window diagnostic handoff, the full window matrix, and the complete
+AI-gate report. A stronger unbridged prior result or an unresolved
+reconstructable historical hypothesis makes the evidence incomplete instead.
+
+Meaning: preserve the composition and failures as immutable research. Keep any
+continued observation advisory/forward-only; do not tune around the exposed
+period inside the same lineage.
+
+### `INSUFFICIENT_EVIDENCE`
+
+Use when a release conclusion cannot be supported, including partial/OOM/error
+runs, missing common cached coverage, incomplete side cohorts, export/Redis
+mismatch, unavailable point-in-time inputs, stale/open holdout, inadequate
+independent support, missing cold-start evidence, ambiguous lineage, an
+incomplete historical hypothesis audit, or a bounded trial cap reached while a
+stronger reconstructable historical backlog remains.
+
+Meaning: identify the smallest missing evidence item and its action ceiling.
+Hard-invalid evidence must be repaired. Retrospective-universe, exposed-tail,
+and prospective-support limitations do not justify waiting for perfect history:
+complete the bounded contour and prepare/start the separately authorized
+`MAX_LOSS_VALUE=1` micro-forward candidate. Do not convert uncertainty into
+current-market unsuitability or historical readiness.
+
+## Diagnose-live verdict precedence
+
+Apply this order:
+
+1. Return `INSUFFICIENT_EVIDENCE` when the released composition, incident
+   evidence, or comparison completeness cannot be established.
+2. Return `RUNTIME_DIVERGENCE` when material runtime/replay/config/context/
+   execution non-parity explains or invalidates the observed sample.
+3. With parity established, return `GENERALIZATION_FAILURE` when adequate new
+   post-cutoff evidence breaches the preregistered generalization bounds.
+4. With parity and adequate support established, return `EXPECTED_DRAWDOWN`
+   when the observation remains inside the frozen release distribution.
+
+### `RUNTIME_DIVERGENCE`
+
+Require concrete mismatched evidence such as closed-candle boundary, config or
+fingerprint, state restoration, causal context, deterministic gate decision,
+allocator/risk/order lifecycle, fill, fee/slippage, or exit differences.
+
+Do not call a strategy generalized or failed while material parity divergence
+remains unresolved.
+
+### `EXPECTED_DRAWDOWN`
+
+Require exact composition parity, adequate incident/forward support, and losses,
+streak, drawdown, cadence, concentration, sides, and regimes within the frozen
+release bounds. This verdict does not imply future recovery or authorize higher
+risk.
+
+### `GENERALIZATION_FAILURE`
+
+Require exact composition parity and adequate independent post-selection
+evidence outside the release cutoff. Show which preregistered ALL/LONG/SHORT,
+regime, concentration, or drawdown bound failed. Do not use an exposed tuning
+window or a handful of correlated symbol rows as proof.
+
+### `INSUFFICIENT_EVIDENCE`
+
+Use when runtime evidence is remote/unavailable, ids cannot be linked, the
+incident window is incomplete, parity is unknown, sample/event support is too
+small, release bounds are missing, or evidence has conflicting lineage.
+
+## Required final shape
+
+```text
+VERDICT: <exact enum>
+MODE: <release|diagnose-live>
+COMPOSITION: <core fingerprint> + <deterministic gate fingerprint>
+EVIDENCE: <complete|incomplete> — <one-line reason>
+HISTORY AUDIT: <inventory SHA> — <bridged/excluded/unresolved counts>
+PRIOR BRIDGE: <strongest prior result and current-contract disposition>
+RESCUE BOARD: <up to 3 seed cadence/failure/child/result rows, or hard reason per empty slot>
+DIRECTION POLICY: <trigger, five variants, selected/rejected policy, checkpoint SHA>
+
+ALL/LONG/SHORT: N, PnL, PnL/trade, PF, WR, realized MaxDD, cadence/day
+WINDOW MATRIX: <full/3y/4y/max-covered/365d/180d/90d/30d/7d for control and best aggregate/LONG/SHORT/policy attempts>
+AI-GATE REPORT: <decision, qN+, full/terminal outcome, cadence/fan-out, risk-adjusted, quality/direction, validation, artifact SHA>
+CAUSAL/PARITY FINDING: <bounded evidence statement>
+LIMITATIONS: <material limitations or none>
+NEXT ACTION: <REPAIR_RECENT_DIRECTION|START_MICRO_FORWARD|MICRO_FORWARD_READY|FORWARD_BLOCKED|STOP_RESEARCH> — <bounded reason>
+```
+
+Also cite the immutable `tradejs-release-progress/v2` artifact. If it reports
+`verdictAllowed=false`, do not emit this final shape yet; perform its next
+action first.

package/dist/skill-bundle/.codex/skills/strategy-release/scripts/direction-policy-checkpoint.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+
+const DIRECTIONS = ['LONG', 'SHORT'];
+
+function assertMetric(metric, label) {
+  for (const field of [
+    'trades',
+    'pnl',
+    'pnlPerTrade',
+    'profitFactor',
+    'cadencePerDay',
+  ]) {
+    if (!Number.isFinite(metric?.[field])) {
+      throw new Error(`${label}.${field} must be finite`);
+    }
+  }
+}
+
+function isUseful(metric, rule) {
+  return (
+    metric.trades >= rule.minimumTrades &&
+    metric.cadencePerDay >= rule.minimumCadencePerDay &&
+    metric.pnl > rule.minimumPnl &&
+    metric.pnlPerTrade > rule.minimumPnlPerTrade &&
+    metric.profitFactor > rule.minimumProfitFactor
+  );
+}
+
+export function evaluateDirectionPolicyCheckpoint(input) {
+  const rule = {
+    minimumTrades: 0,
+    minimumCadencePerDay: 0,
+    minimumPnl: 0,
+    minimumPnlPerTrade: 0,
+    minimumProfitFactor: 1,
+    maximumNegligibleApprovalShare: 0.05,
+    ...input?.usefulSideRule,
+  };
+
+  assertMetric(input?.raw?.ALL, 'raw.ALL');
+  for (const direction of DIRECTIONS) {
+    assertMetric(input?.raw?.[direction], `raw.${direction}`);
+  }
+
+  const statuses = Object.fromEntries(
+    DIRECTIONS.map((direction) => [
+      direction,
+      isUseful(input.raw[direction], rule) ? 'useful' : 'failed',
+    ]),
+  );
+
+  const hidden = DIRECTIONS.find((direction) => {
+    if (statuses[direction] !== 'useful' || !input.gateApproved) {
+      return false;
+    }
+    const approved = input.gateApproved[direction];
+    if (!approved || !Number.isFinite(approved.trades)) {
+      throw new Error(`gateApproved.${direction}.trades must be finite`);
+    }
+    const share = input.raw[direction].trades
+      ? approved.trades / input.raw[direction].trades
+      : 0;
+    return share <= rule.maximumNegligibleApprovalShare;
+  });
+
+  if (hidden) {
+    return {
+      schema: 'tradejs-direction-policy-decision/v1',
+      trigger: 'profitable_side_hidden',
+      required: true,
+      usefulSideRule: rule,
+      rawSideStatuses: statuses,
+      retainedSide: hidden,
+      proposedPolicy: `${hidden.toLowerCase()}_pass_through`,
+    };
+  }
+
+  const usefulDirections = DIRECTIONS.filter(
+    (direction) => statuses[direction] === 'useful',
+  );
+  if (usefulDirections.length === 1) {
+    const retainedSide = usefulDirections[0];
+    const failingSide = retainedSide === 'LONG' ? 'SHORT' : 'LONG';
+    const contamination =
+      input.raw[failingSide].pnl < 0 &&
+      input.raw.ALL.pnl < input.raw[retainedSide].pnl;
+    if (contamination) {
+      return {
+        schema: 'tradejs-direction-policy-decision/v1',
+        trigger: 'losing_side_contamination',
+        required: true,
+        usefulSideRule: rule,
+        rawSideStatuses: statuses,
+        retainedSide,
+        failingSide,
+        proposedPolicy: `${retainedSide.toLowerCase()}_only`,
+      };
+    }
+  }
+
+  return {
+    schema: 'tradejs-direction-policy-decision/v1',
+    trigger: 'no_side_salvage',
+    required: false,
+    usefulSideRule: rule,
+    rawSideStatuses: statuses,
+    retainedSide: null,
+    proposedPolicy: 'both',
+  };
+}
+
+async function main() {
+  const inputIndex = process.argv.indexOf('--input');
+  if (inputIndex === -1 || !process.argv[inputIndex + 1]) {
+    throw new Error(
+      'Usage: direction-policy-checkpoint.mjs --input <input.json>',
+    );
+  }
+  const input = JSON.parse(
+    await readFile(process.argv[inputIndex + 1], 'utf8'),
+  );
+  process.stdout.write(
+    `${JSON.stringify(evaluateDirectionPolicyCheckpoint(input), null, 2)}\n`,
+  );
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  main().catch((error) => {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}\n`,
+    );
+    process.exitCode = 1;
+  });
+}

package/dist/skill-bundle/.codex/skills/strategy-release/scripts/direction-policy-checkpoint.test.mjs

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { evaluateDirectionPolicyCheckpoint } from './direction-policy-checkpoint.mjs';
+
+const rule = {
+  minimumTrades: 144,
+  minimumCadencePerDay: 0.1,
+  minimumPnl: 0,
+  minimumPnlPerTrade: 0,
+  minimumProfitFactor: 1,
+};
+
+const metric = (trades, pnl, pnlPerTrade, profitFactor, cadencePerDay) => ({
+  trades,
+  pnl,
+  pnlPerTrade,
+  profitFactor,
+  cadencePerDay,
+});
+
+test('requires LONG-only containment for the RelativeRotation control profile', () => {
+  const decision = evaluateDirectionPolicyCheckpoint({
+    usefulSideRule: rule,
+    raw: {
+      ALL: metric(1203, -39, -0.032, 0.995, 0.835),
+      LONG: metric(886, 157.67, 0.178, 1.031, 0.615),
+      SHORT: metric(317, -196.67, -0.62, 0.907, 0.22),
+    },
+  });
+
+  assert.equal(decision.required, true);
+  assert.equal(decision.trigger, 'losing_side_contamination');
+  assert.equal(decision.retainedSide, 'LONG');
+  assert.equal(decision.proposedPolicy, 'long_only');
+});
+
+test('requires recovery when a useful raw side has negligible gate approvals', () => {
+  const decision = evaluateDirectionPolicyCheckpoint({
+    usefulSideRule: rule,
+    raw: {
+      ALL: metric(500, 100, 0.2, 1.1, 0.5),
+      LONG: metric(250, 120, 0.48, 1.2, 0.25),
+      SHORT: metric(250, -20, -0.08, 0.97, 0.25),
+    },
+    gateApproved: {
+      LONG: { trades: 0 },
+      SHORT: { trades: 40 },
+    },
+  });
+
+  assert.equal(decision.required, true);
+  assert.equal(decision.trigger, 'profitable_side_hidden');
+  assert.equal(decision.proposedPolicy, 'long_pass_through');
+});
+
+test('does not manufacture a side policy when neither side passes the frozen rule', () => {
+  const decision = evaluateDirectionPolicyCheckpoint({
+    usefulSideRule: rule,
+    raw: {
+      ALL: metric(500, -200, -0.4, 0.8, 0.5),
+      LONG: metric(250, -80, -0.32, 0.9, 0.25),
+      SHORT: metric(250, -120, -0.48, 0.85, 0.25),
+    },
+  });
+
+  assert.equal(decision.required, false);
+  assert.equal(decision.trigger, 'no_side_salvage');
+  assert.equal(decision.proposedPolicy, 'both');
+});
+
+test('rejects incomplete metric inputs instead of guessing', () => {
+  assert.throws(
+    () =>
+      evaluateDirectionPolicyCheckpoint({
+        usefulSideRule: rule,
+        raw: {
+          ALL: metric(1, 1, 1, 1, 1),
+          LONG: metric(1, 1, 1, 1, 1),
+          SHORT: { trades: 1 },
+        },
+      }),
+    /raw\.SHORT\.pnl must be finite/,
+  );
+});