create-tradejs 3.1.22 → 3.1.23

package/dist/skill-bundle/.codex/skills/strategy-release/scripts/directional-parameter-checkpoint.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+
+const EFFECTS = new Set(['improved', 'worsened', 'neutral', 'inconclusive']);
+const RESOLUTIONS = new Set([
+  'decision_time',
+  'detector_state',
+  'shared_lifecycle',
+]);
+
+function assertBoolean(value, label) {
+  if (typeof value !== 'boolean') {
+    throw new Error(`${label} must be boolean`);
+  }
+}
+
+function readSide(evidence, side) {
+  const value = evidence?.[side];
+  if (!EFFECTS.has(value?.effect)) {
+    throw new Error(`${side}.effect must be a supported effect`);
+  }
+  assertBoolean(value.supportAdequate, `${side}.supportAdequate`);
+  return value;
+}
+
+export function evaluateDirectionalParameterCheckpoint(input) {
+  const parameter = input?.parameter;
+  const evidence = input?.evidence;
+  if (!parameter?.name) throw new Error('parameter.name is required');
+  if (!RESOLUTIONS.has(parameter.resolution)) {
+    throw new Error('parameter.resolution is invalid');
+  }
+  assertBoolean(parameter.isolatedChange, 'parameter.isolatedChange');
+  assertBoolean(
+    parameter.legacyFallbackSupported,
+    'parameter.legacyFallbackSupported',
+  );
+  assertBoolean(evidence?.complete, 'evidence.complete');
+  assertBoolean(evidence?.reconciled, 'evidence.reconciled');
+  assertBoolean(
+    evidence?.intendedTransitionChanged,
+    'evidence.intendedTransitionChanged',
+  );
+  const long = readSide(evidence, 'LONG');
+  const short = readSide(evidence, 'SHORT');
+
+  const result = (overrides) => ({
+    schema: 'tradejs-directional-parameter-checkpoint/v1',
+    parameter: parameter.name,
+    required: false,
+    targetDirection: null,
+    implementationMode: null,
+    action: 'KEEP_GLOBAL_PARAMETER',
+    reason: 'No supported opposing directional effect was established.',
+    ...overrides,
+  });
+
+  if (!evidence.complete || !evidence.reconciled) {
+    return result({
+      action: 'REPAIR_DIRECTIONAL_EVIDENCE',
+      reason: 'Directional evidence must be complete and reconciled.',
+    });
+  }
+  if (!parameter.isolatedChange) {
+    return result({
+      action: 'RUN_SINGLE_PARAMETER_ABLATION',
+      reason: 'The observed side conflict is not attributable to one field.',
+    });
+  }
+  if (!evidence.intendedTransitionChanged) {
+    return result({
+      action: 'REJECT_DIRECTIONAL_NO_OP',
+      reason: 'The parameter did not change its intended causal transition.',
+    });
+  }
+  if (
+    !long.supportAdequate ||
+    !short.supportAdequate ||
+    long.effect === 'inconclusive' ||
+    short.effect === 'inconclusive'
+  ) {
+    return result({
+      action: 'COLLECT_DIRECTIONAL_EVIDENCE',
+      reason: 'Both sides need adequate support under the frozen side rule.',
+    });
+  }
+
+  const targetDirection =
+    long.effect === 'improved' && short.effect === 'worsened'
+      ? 'LONG'
+      : short.effect === 'improved' && long.effect === 'worsened'
+        ? 'SHORT'
+        : null;
+  if (!targetDirection) return result({});
+
+  if (!parameter.legacyFallbackSupported) {
+    return result({
+      required: true,
+      targetDirection,
+      action: 'DESIGN_LEGACY_FALLBACK',
+      reason: 'Directional overrides must preserve the original global field.',
+    });
+  }
+
+  const implementationMode =
+    parameter.resolution === 'decision_time'
+      ? 'fallback_override'
+      : parameter.resolution === 'detector_state'
+        ? 'separate_directional_state'
+        : 'fallback_override_with_occupancy_audit';
+  const action =
+    parameter.resolution === 'detector_state'
+      ? 'DESIGN_DIRECTIONAL_STATE_ISOLATION'
+      : 'FREEZE_DIRECTIONAL_PARAMETER_SPLIT';
+
+  return result({
+    required: true,
+    targetDirection,
+    implementationMode,
+    action,
+    reason: `${targetDirection} improves while the opposite side worsens under the matched one-field comparison.`,
+  });
+}
+
+async function main() {
+  const inputIndex = process.argv.indexOf('--input');
+  if (inputIndex === -1 || !process.argv[inputIndex + 1]) {
+    throw new Error(
+      'Usage: directional-parameter-checkpoint.mjs --input <checkpoint.json>',
+    );
+  }
+  const input = JSON.parse(
+    await readFile(process.argv[inputIndex + 1], 'utf8'),
+  );
+  process.stdout.write(
+    `${JSON.stringify(evaluateDirectionalParameterCheckpoint(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/directional-parameter-checkpoint.test.mjs

@@ -0,0 +1,120 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { evaluateDirectionalParameterCheckpoint } from './directional-parameter-checkpoint.mjs';
+
+const input = (overrides = {}) => ({
+  parameter: {
+    name: 'ENTRY_THRESHOLD',
+    isolatedChange: true,
+    legacyFallbackSupported: true,
+    resolution: 'decision_time',
+  },
+  evidence: {
+    complete: true,
+    reconciled: true,
+    intendedTransitionChanged: true,
+    LONG: { effect: 'improved', supportAdequate: true },
+    SHORT: { effect: 'worsened', supportAdequate: true },
+  },
+  ...overrides,
+});
+
+test('requires a LONG override for an opposing matched side effect', () => {
+  const result = evaluateDirectionalParameterCheckpoint(input());
+
+  assert.equal(result.required, true);
+  assert.equal(result.targetDirection, 'LONG');
+  assert.equal(result.implementationMode, 'fallback_override');
+  assert.equal(result.action, 'FREEZE_DIRECTIONAL_PARAMETER_SPLIT');
+});
+
+test('mirrors the target direction and requires detector state isolation', () => {
+  const result = evaluateDirectionalParameterCheckpoint(
+    input({
+      parameter: {
+        name: 'ZONE_LOOKBACK',
+        isolatedChange: true,
+        legacyFallbackSupported: true,
+        resolution: 'detector_state',
+      },
+      evidence: {
+        complete: true,
+        reconciled: true,
+        intendedTransitionChanged: true,
+        LONG: { effect: 'worsened', supportAdequate: true },
+        SHORT: { effect: 'improved', supportAdequate: true },
+      },
+    }),
+  );
+
+  assert.equal(result.targetDirection, 'SHORT');
+  assert.equal(result.implementationMode, 'separate_directional_state');
+  assert.equal(result.action, 'DESIGN_DIRECTIONAL_STATE_ISOLATION');
+});
+
+test('keeps a globally useful parameter global', () => {
+  const result = evaluateDirectionalParameterCheckpoint(
+    input({
+      evidence: {
+        complete: true,
+        reconciled: true,
+        intendedTransitionChanged: true,
+        LONG: { effect: 'improved', supportAdequate: true },
+        SHORT: { effect: 'improved', supportAdequate: true },
+      },
+    }),
+  );
+
+  assert.equal(result.required, false);
+  assert.equal(result.action, 'KEEP_GLOBAL_PARAMETER');
+});
+
+test('requires a single-parameter ablation before splitting a bundle', () => {
+  const result = evaluateDirectionalParameterCheckpoint(
+    input({
+      parameter: {
+        name: 'ENTRY_THRESHOLD',
+        isolatedChange: false,
+        legacyFallbackSupported: true,
+        resolution: 'decision_time',
+      },
+    }),
+  );
+
+  assert.equal(result.required, false);
+  assert.equal(result.action, 'RUN_SINGLE_PARAMETER_ABLATION');
+});
+
+test('does not split under insufficient side support', () => {
+  const result = evaluateDirectionalParameterCheckpoint(
+    input({
+      evidence: {
+        complete: true,
+        reconciled: true,
+        intendedTransitionChanged: true,
+        LONG: { effect: 'improved', supportAdequate: true },
+        SHORT: { effect: 'worsened', supportAdequate: false },
+      },
+    }),
+  );
+
+  assert.equal(result.required, false);
+  assert.equal(result.action, 'COLLECT_DIRECTIONAL_EVIDENCE');
+});
+
+test('requires a backward-compatible fallback contract', () => {
+  const result = evaluateDirectionalParameterCheckpoint(
+    input({
+      parameter: {
+        name: 'ENTRY_THRESHOLD',
+        isolatedChange: true,
+        legacyFallbackSupported: false,
+        resolution: 'shared_lifecycle',
+      },
+    }),
+  );
+
+  assert.equal(result.required, true);
+  assert.equal(result.action, 'DESIGN_LEGACY_FALLBACK');
+});