kenaz 0.3.18 → 0.3.20

package/core/dev/scripts/probe/prediction-signal-auc.js

@@ -1,483 +0,0 @@
-#!/usr/bin/env node
-// TASK_1903 R2: read-only AUC report per prediction_ledger signal.
-//
-// Background: main-thread + agent measurement (2026-08-27/09,
-// dev/TASK_1903_SIGNAL_AUC_MEASUREMENT.md) found raw EFE (predicted_value)
-// carries no measurable relationship to whether a symbol gets touched
-// (AUC 0.4784, CI spans 0.5) — the folded composites (g_risk/g_novelty/...)
-// mix multiple raw sources whose individual contribution can't be
-// attributed after the fact. This card (re-scoped 2026-09-21) added
-// heat_raw/co_change_raw/recency_raw columns so the PURE per-signal values
-// get persisted going forward; this script is the read-only instrument that
-// re-measures AUC per signal once 30 days of that data has accrued.
-//
-// Method: Mann-Whitney U -> AUC (rank-based, average-rank tie handling),
-// bootstrap 95% CI (resample rows with replacement), permutation p-value
-// (shuffle labels), and best-achievable single-threshold accuracy scanned
-// against the majority-class baseline — same method used for the
-// 2026-08-27 baseline this script reproduces as its own control.
-//
-// Uses Node's built-in `node:sqlite` (experimental, stable since v22.5,
-// present on this repo's pinned Node 24) opened READ-ONLY — no new
-// dependency added; checked package.json first per the dispatch note, no
-// better-sqlite3/sqlite3 present anywhere in the repo.
-//
-// SAFETY: never opens the live memory.db. Always copies the .db (+ -wal/
-// -shm sidecars, since the db runs in WAL mode) to a temp file first and
-// reads the copy read-only.
-//
-// Usage:
-//   node dev/scripts/probe/prediction-signal-auc.js [--project-path <dir>] [--db <path>] [--json]
-//
-// --project-path: project root containing .synapse/db/memory.db (default: repo root).
-// --db:           explicit path to a memory.db (overrides --project-path).
-// --json:         also print the raw result object as JSON (for tooling).
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { DatabaseSync } = require('node:sqlite');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
-
-// TASK_1903: pure-signal columns (heat_raw/co_change_raw/recency_raw) were
-// added to prediction_ledger on this date. Historical rows before this
-// cutover carry the migration's DEFAULT 0.0 for those columns — that is
-// "not measured", not "measured as zero" — so pure-signal AUC MUST exclude
-// rows predicted before this cutover. The existing predicted_value/
-// component_breakdown columns have no such gap and use full history.
-const PURE_SIGNAL_CUTOVER_ISO = '2026-09-21T00:00:00Z';
-const PURE_SIGNAL_CUTOVER_EPOCH = Math.floor(Date.parse(PURE_SIGNAL_CUTOVER_ISO) / 1000);
-
-// A4: the re-measure decision rule recorded on the card.
-const REMEASURE_DUE_ISO = '2026-10-21T00:00:00Z';
-const REMEASURE_MIN_N = 300;
-const REMEASURE_REOPEN_AUC = 0.60;
-
-// 2026-08-27 baseline (main thread + agent-verified, independently
-// reproduced in dev/TASK_1903_SIGNAL_AUC_MEASUREMENT.md) for header context.
-const BASELINE_2026_08_27 = {
-  n: 597,
-  hit: 88,
-  miss: 509,
-  majority_baseline_pct: 85.26,
-  auc_raw_efe: 0.4784,
-  ci_raw_efe: [0.4134, 0.5450],
-};
-
-function parseArgs(argv) {
-  const args = { projectPath: REPO_ROOT, db: null, json: false };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--project-path') args.projectPath = argv[++i];
-    else if (a === '--db') args.db = argv[++i];
-    else if (a === '--json') args.json = true;
-  }
-  return args;
-}
-
-/** Copy a sqlite db (+ WAL/SHM sidecars if present) to a temp location. */
-function copyDbToTemp(dbPath) {
-  if (!fs.existsSync(dbPath)) {
-    throw new Error(`memory.db not found at ${dbPath}`);
-  }
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'task1903-auc-'));
-  const tmpDb = path.join(tmpDir, 'memory.db');
-  fs.copyFileSync(dbPath, tmpDb);
-  for (const suffix of ['-wal', '-shm']) {
-    const side = dbPath + suffix;
-    if (fs.existsSync(side)) {
-      fs.copyFileSync(side, tmpDb + suffix);
-    }
-  }
-  return { tmpDir, tmpDb };
-}
-
-/** Rank-based Mann-Whitney AUC with average-rank tie handling. */
-function mannWhitneyAuc(values, labels) {
-  const n = values.length;
-  const idx = Array.from({ length: n }, (_, i) => i);
-  idx.sort((a, b) => values[a] - values[b]);
-
-  const ranks = new Array(n);
-  let i = 0;
-  while (i < n) {
-    let j = i;
-    while (j + 1 < n && values[idx[j + 1]] === values[idx[i]]) j++;
-    const avgRank = (i + j) / 2 + 1; // 1-based average rank across the tie block
-    for (let k = i; k <= j; k++) ranks[idx[k]] = avgRank;
-    i = j + 1;
-  }
-
-  let rankSumPos = 0;
-  let nPos = 0;
-  let nNeg = 0;
-  for (let k = 0; k < n; k++) {
-    if (labels[k] === 1) {
-      rankSumPos += ranks[k];
-      nPos++;
-    } else {
-      nNeg++;
-    }
-  }
-  if (nPos === 0 || nNeg === 0) return { auc: null, nPos, nNeg };
-  const u1 = rankSumPos - (nPos * (nPos + 1)) / 2;
-  const auc = u1 / (nPos * nNeg);
-  return { auc, nPos, nNeg };
-}
-
-function mulberry32(seed) {
-  let a = seed >>> 0;
-  return function () {
-    a |= 0;
-    a = (a + 0x6d2b79f5) | 0;
-    let t = Math.imul(a ^ (a >>> 15), 1 | a);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-function bootstrapCI(values, labels, iterations, rng) {
-  const n = values.length;
-  const aucs = [];
-  for (let it = 0; it < iterations; it++) {
-    const sv = new Array(n);
-    const sl = new Array(n);
-    for (let k = 0; k < n; k++) {
-      const r = Math.floor(rng() * n);
-      sv[k] = values[r];
-      sl[k] = labels[r];
-    }
-    const { auc } = mannWhitneyAuc(sv, sl);
-    if (auc !== null) aucs.push(auc);
-  }
-  aucs.sort((a, b) => a - b);
-  const lo = aucs[Math.floor(0.025 * aucs.length)];
-  const hi = aucs[Math.min(aucs.length - 1, Math.floor(0.975 * aucs.length))];
-  return [lo, hi];
-}
-
-function permutationP(values, labels, observedAuc, iterations, rng) {
-  const n = labels.length;
-  const shuffled = labels.slice();
-  let extreme = 0;
-  const observedDist = Math.abs(observedAuc - 0.5);
-  for (let it = 0; it < iterations; it++) {
-    // Fisher-Yates shuffle
-    for (let k = n - 1; k > 0; k--) {
-      const j = Math.floor(rng() * (k + 1));
-      const tmp = shuffled[k];
-      shuffled[k] = shuffled[j];
-      shuffled[j] = tmp;
-    }
-    const { auc } = mannWhitneyAuc(values, shuffled);
-    if (auc !== null && Math.abs(auc - 0.5) >= observedDist) extreme++;
-  }
-  return extreme / iterations;
-}
-
-/**
- * Best achievable single-threshold accuracy, scanned over unique values, both
- * directions, PLUS the two degenerate "always predict one class" rules
- * (threshold beyond the data range in each direction) — without those, a
- * signal with little-to-no variance can score below the majority-class
- * baseline, which would misrepresent "no threshold beats the baseline" as
- * "the baseline itself is unreachable". The 2026-08-27 baseline report found
- * raw EFE's best-threshold accuracy exactly equal to the majority baseline
- * (both 85.26%) — that tie is only representable if the always-predict-
- * majority rule is in the candidate set.
- */
-function bestThresholdAccuracy(values, labels) {
-  const uniq = Array.from(new Set(values)).sort((a, b) => a - b);
-  const n = values.length;
-  const nHit = labels.filter((l) => l === 1).length;
-  let best = Math.max(nHit, n - nHit) / n; // always-predict-majority-class floor
-  let bestThreshold = null;
-  let bestDirection = best === nHit / n ? 'always-hit' : 'always-miss';
-  for (const t of uniq) {
-    // Direction A: predict hit when value >= t
-    let correctA = 0;
-    // Direction B: predict hit when value <= t
-    let correctB = 0;
-    for (let k = 0; k < n; k++) {
-      const predA = values[k] >= t ? 1 : 0;
-      const predB = values[k] <= t ? 1 : 0;
-      if (predA === labels[k]) correctA++;
-      if (predB === labels[k]) correctB++;
-    }
-    if (correctA / n > best) {
-      best = correctA / n;
-      bestThreshold = t;
-      bestDirection = '>=';
-    }
-    if (correctB / n > best) {
-      best = correctB / n;
-      bestThreshold = t;
-      bestDirection = '<=';
-    }
-  }
-  return { accuracy: best, threshold: bestThreshold, direction: bestDirection };
-}
-
-function medianOf(values) {
-  const s = values.slice().sort((a, b) => a - b);
-  const n = s.length;
-  if (n === 0) return null;
-  const mid = Math.floor(n / 2);
-  return n % 2 === 0 ? (s[mid - 1] + s[mid]) / 2 : s[mid];
-}
-
-/**
- * Compute the full AUC report for one signal over the rows that have it.
- * `predictedAtCutoverEpoch`, when set, drops rows predicted before it —
- * used for the pure signals which only became meaningful after TASK_1903.
- */
-function evaluateSignal(name, rows, extractor, opts) {
-  opts = opts || {};
-  const iterations = opts.iterations || 2000;
-  const seed = opts.seed || 20260921;
-  const cutover = opts.cutoverEpoch || null;
-
-  const values = [];
-  const labels = [];
-  for (const row of rows) {
-    if (cutover !== null && row.predicted_at < cutover) continue;
-    const v = extractor(row);
-    if (v === null || v === undefined || Number.isNaN(v)) continue;
-    values.push(v);
-    labels.push(row.is_hit);
-  }
-
-  const n = values.length;
-  const nHit = labels.filter((l) => l === 1).length;
-  const nMiss = n - nHit;
-  if (n === 0) {
-    return { signal: name, n: 0, note: 'no rows (cutover filter or missing values)' };
-  }
-  const majorityBaseline = Math.max(nHit, nMiss) / n;
-
-  const { auc } = mannWhitneyAuc(values, labels);
-  const rng1 = mulberry32(seed);
-  const ci = auc === null ? [null, null] : bootstrapCI(values, labels, iterations, rng1);
-  const rng2 = mulberry32(seed + 1);
-  const p = auc === null ? null : permutationP(values, labels, auc, iterations, rng2);
-  const thresholdResult = bestThresholdAccuracy(values, labels);
-
-  const hitValues = values.filter((_, k) => labels[k] === 1);
-  const missValues = values.filter((_, k) => labels[k] === 0);
-
-  return {
-    signal: name,
-    n,
-    hit: nHit,
-    miss: nMiss,
-    majority_baseline_pct: +(majorityBaseline * 100).toFixed(2),
-    auc: auc === null ? null : +auc.toFixed(4),
-    ci_95: ci[0] === null ? null : [+ci[0].toFixed(4), +ci[1].toFixed(4)],
-    permutation_p: p === null ? null : +p.toFixed(4),
-    best_threshold_accuracy_pct: +(thresholdResult.accuracy * 100).toFixed(2),
-    best_threshold: thresholdResult.threshold,
-    best_threshold_direction: thresholdResult.direction,
-    hit_median: medianOf(hitValues),
-    miss_median: medianOf(missValues),
-  };
-}
-
-/**
- * Idempotently add the TASK_1903 pure-signal columns to a (already-copied,
- * never the live) db if the running Rust binary hasn't migrated it yet —
- * mirrors memory/schema.rs's migrate_prediction_ledger ALTER TABLE pattern
- * exactly (additive, default 0.0, silently ignored if already present).
- * Opens the COPY briefly in writable mode; the live file is never touched —
- * see copyDbToTemp / main(), which always operate on a temp copy first.
- */
-function ensurePureSignalColumns(dbPath) {
-  const db = new DatabaseSync(dbPath);
-  try {
-    for (const col of ['heat_raw', 'co_change_raw', 'recency_raw']) {
-      try {
-        db.exec(`ALTER TABLE prediction_ledger ADD COLUMN ${col} REAL NOT NULL DEFAULT 0.0`);
-      } catch (e) {
-        // Column already exists (duplicate column name) — expected on a
-        // db the live Rust binary has already migrated. Anything else
-        // would also surface downstream when loadRows queries it.
-      }
-    }
-  } finally {
-    db.close();
-  }
-}
-
-function loadRows(dbPath) {
-  ensurePureSignalColumns(dbPath);
-  const db = new DatabaseSync(dbPath, { readOnly: true });
-  try {
-    const stmt = db.prepare(
-      `SELECT predicted_value, confidence, component_breakdown,
-              heat_raw, co_change_raw, recency_raw,
-              predicted_at, outcome_quality
-       FROM prediction_ledger
-       WHERE prediction_type = 'efe'
-         AND verified = 1
-         AND predicted_value IS NOT NULL
-         AND outcome_quality IN ('hit', 'miss')`
-    );
-    const rawRows = stmt.all();
-    return rawRows.map((r) => {
-      let breakdown = {};
-      try {
-        breakdown = JSON.parse(r.component_breakdown || '{}');
-      } catch (e) {
-        breakdown = {};
-      }
-      return {
-        predicted_value: r.predicted_value,
-        confidence: r.confidence,
-        g_risk: typeof breakdown.g_risk === 'number' ? breakdown.g_risk : null,
-        g_ambiguity: typeof breakdown.g_ambiguity === 'number' ? breakdown.g_ambiguity : null,
-        g_novelty: typeof breakdown.g_novelty === 'number' ? breakdown.g_novelty : null,
-        g_salience: typeof breakdown.g_salience === 'number' ? breakdown.g_salience : null,
-        complexity_penalty:
-          typeof breakdown.complexity_penalty === 'number' ? breakdown.complexity_penalty : null,
-        heat_raw: r.heat_raw,
-        co_change_raw: r.co_change_raw,
-        recency_raw: r.recency_raw,
-        predicted_at: r.predicted_at,
-        is_hit: r.outcome_quality === 'hit' ? 1 : 0,
-      };
-    });
-  } finally {
-    db.close();
-  }
-}
-
-function buildReport(dbPath) {
-  const rows = loadRows(dbPath);
-
-  const foldedSignals = [
-    ['raw_efe (predicted_value)', (r) => r.predicted_value, null],
-    ['confidence', (r) => r.confidence, null],
-    ['g_risk (heat-dominated composite)', (r) => r.g_risk, null],
-    ['g_ambiguity', (r) => r.g_ambiguity, null],
-    ['g_novelty (co-change-dominated composite)', (r) => r.g_novelty, null],
-    ['g_salience', (r) => r.g_salience, null],
-    ['complexity_penalty', (r) => r.complexity_penalty, null],
-  ];
-
-  const pureSignals = [
-    ['heat_raw (pure Heat)', (r) => r.heat_raw, PURE_SIGNAL_CUTOVER_EPOCH],
-    ['co_change_raw (pure Co-change)', (r) => r.co_change_raw, PURE_SIGNAL_CUTOVER_EPOCH],
-    ['recency_raw (pure Recency)', (r) => r.recency_raw, PURE_SIGNAL_CUTOVER_EPOCH],
-  ];
-
-  const results = [];
-  for (const [name, extractor, cutover] of foldedSignals) {
-    results.push(evaluateSignal(name, rows, extractor, { cutoverEpoch: cutover }));
-  }
-  for (const [name, extractor, cutover] of pureSignals) {
-    results.push(evaluateSignal(name, rows, extractor, { cutoverEpoch: cutover }));
-  }
-
-  return {
-    baseline_2026_08_27: BASELINE_2026_08_27,
-    pure_signal_cutover: PURE_SIGNAL_CUTOVER_ISO,
-    remeasure_rule: {
-      due: REMEASURE_DUE_ISO,
-      min_n: REMEASURE_MIN_N,
-      reopen_if_auc_at_least: REMEASURE_REOPEN_AUC,
-      description:
-        'Any signal with AUC >= 0.60 at n >= 300 (post-cutover rows) by the due date reopens the ' +
-        'grounding question; otherwise P3 grounding stays closed (TASK_1903 A4).',
-    },
-    total_rows_all_time: rows.length,
-    results,
-  };
-}
-
-function printReport(report) {
-  const b = report.baseline_2026_08_27;
-  console.log('TASK_1903 — Prediction Signal AUC Report');
-  console.log('='.repeat(60));
-  console.log(
-    `2026-08-27 baseline (control): n=${b.n} (hit=${b.hit}/miss=${b.miss}), ` +
-      `majority=${b.majority_baseline_pct}%, raw EFE AUC=${b.auc_raw_efe} ` +
-      `CI[${b.ci_raw_efe[0]}, ${b.ci_raw_efe[1]}]`
-  );
-  console.log(
-    `Pure-signal cutover: ${report.pure_signal_cutover} (rows before this date have ` +
-      `heat_raw/co_change_raw/recency_raw = migration default 0.0, excluded from pure-signal rows)`
-  );
-  console.log(
-    `Re-measure rule: reopen if any signal AUC >= ${report.remeasure_rule.reopen_if_auc_at_least} ` +
-      `at n >= ${report.remeasure_rule.min_n} by ${report.remeasure_rule.due}`
-  );
-  console.log(`Total ledger rows (all-time, verified efe hit/miss): ${report.total_rows_all_time}`);
-  console.log('-'.repeat(60));
-
-  const header = [
-    'signal',
-    'n',
-    'hit/miss',
-    'baseline%',
-    'AUC',
-    '95% CI',
-    'perm p',
-    'best-thr acc%',
-  ];
-  console.log(header.join(' | '));
-  for (const r of report.results) {
-    if (r.n === 0) {
-      console.log(`${r.signal} | n=0 (${r.note})`);
-      continue;
-    }
-    console.log(
-      [
-        r.signal,
-        r.n,
-        `${r.hit}/${r.miss}`,
-        r.majority_baseline_pct,
-        r.auc,
-        r.ci_95 ? `[${r.ci_95[0]}, ${r.ci_95[1]}]` : 'n/a',
-        r.permutation_p,
-        r.best_threshold_accuracy_pct,
-      ].join(' | ')
-    );
-  }
-}
-
-function main() {
-  const args = parseArgs(process.argv.slice(2));
-  const dbPath = args.db || path.join(args.projectPath, '.synapse', 'db', 'memory.db');
-
-  let tmpDir = null;
-  try {
-    const copy = copyDbToTemp(dbPath);
-    tmpDir = copy.tmpDir;
-    const report = buildReport(copy.tmpDb);
-    printReport(report);
-    if (args.json) {
-      console.log('\n--- JSON ---');
-      console.log(JSON.stringify(report, null, 2));
-    }
-  } finally {
-    if (tmpDir) {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  mannWhitneyAuc,
-  bootstrapCI,
-  permutationP,
-  bestThresholdAccuracy,
-  evaluateSignal,
-  buildReport,
-  PURE_SIGNAL_CUTOVER_EPOCH,
-};

package/core/dev/scripts/probe/prediction-signal-auc.test.js

@@ -1,200 +0,0 @@
-#!/usr/bin/env node
-// TASK_1903 R4: unit tests for prediction-signal-auc.js's pure functions.
-//
-// Fixtures per the card's explicit requirement: a perfectly separable
-// signal must score AUC ~1.0, and a random (label-independent) signal must
-// score AUC ~0.5. Also covers the persist -> read round trip end-to-end via
-// a real temp sqlite db (node:sqlite), and the pure-signal cutover filter
-// that excludes pre-migration rows (which default to 0.0, not "measured 0").
-//
-// Run: node --test dev/scripts/probe/prediction-signal-auc.test.js
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const { DatabaseSync } = require('node:sqlite');
-
-const mod = require('./prediction-signal-auc.js');
-
-function mulberry32(seed) {
-  let a = seed >>> 0;
-  return function () {
-    a |= 0;
-    a = (a + 0x6d2b79f5) | 0;
-    let t = Math.imul(a ^ (a >>> 15), 1 | a);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-test('mannWhitneyAuc: perfectly separable signal scores AUC 1.0', () => {
-  // All hits strictly greater than all misses -> AUC == 1.0.
-  const values = [10, 11, 12, 13, 14, 0, 1, 2, 3, 4];
-  const labels = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
-  const { auc } = mod.mannWhitneyAuc(values, labels);
-  assert.equal(auc, 1.0);
-});
-
-test('mannWhitneyAuc: perfectly inverted signal scores AUC 0.0', () => {
-  const values = [0, 1, 2, 3, 4, 10, 11, 12, 13, 14];
-  const labels = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
-  const { auc } = mod.mannWhitneyAuc(values, labels);
-  assert.equal(auc, 0.0);
-});
-
-test('mannWhitneyAuc: random (label-independent) signal scores ~0.5 at scale', () => {
-  const rng = mulberry32(42);
-  const n = 4000;
-  const values = [];
-  const labels = [];
-  for (let i = 0; i < n; i++) {
-    values.push(rng()); // uniform noise, unrelated to label
-    labels.push(rng() < 0.15 ? 1 : 0); // 15% hit rate, matches the real data's imbalance
-  }
-  const { auc } = mod.mannWhitneyAuc(values, labels);
-  assert.ok(
-    Math.abs(auc - 0.5) < 0.03,
-    `expected AUC near 0.5 for a random signal at n=${n}, got ${auc}`
-  );
-});
-
-test('mannWhitneyAuc: tied values are handled via average rank without crashing', () => {
-  const values = [1, 1, 1, 2, 2, 3];
-  const labels = [1, 0, 1, 0, 1, 0];
-  const { auc, nPos, nNeg } = mod.mannWhitneyAuc(values, labels);
-  assert.equal(nPos, 3);
-  assert.equal(nNeg, 3);
-  assert.ok(auc >= 0 && auc <= 1);
-});
-
-test('bestThresholdAccuracy: separable signal achieves 100% accuracy', () => {
-  const values = [10, 11, 12, 0, 1, 2];
-  const labels = [1, 1, 1, 0, 0, 0];
-  const { accuracy } = mod.bestThresholdAccuracy(values, labels);
-  assert.equal(accuracy, 1.0);
-});
-
-test('bestThresholdAccuracy: never scores below the always-predict-majority floor', () => {
-  // Same value for every row -> no observed threshold can isolate the single
-  // hit, so the only candidates that can win are the two degenerate
-  // "always predict one class" rules. Majority class is miss (4/5 = 80%).
-  const values = [5, 5, 5, 5, 5];
-  const labels = [1, 0, 0, 0, 0];
-  const { accuracy, direction } = mod.bestThresholdAccuracy(values, labels);
-  assert.equal(accuracy, 0.8, 'majority-class floor (4 miss / 5) must be reachable');
-  assert.equal(direction, 'always-miss');
-});
-
-test('evaluateSignal: end-to-end on a separable fixture reproduces AUC 1.0 with n and baseline', () => {
-  const rows = [
-    { my_signal: 9, predicted_at: 100, is_hit: 1 },
-    { my_signal: 8, predicted_at: 100, is_hit: 1 },
-    { my_signal: 1, predicted_at: 100, is_hit: 0 },
-    { my_signal: 2, predicted_at: 100, is_hit: 0 },
-    { my_signal: 3, predicted_at: 100, is_hit: 0 },
-  ];
-  const result = mod.evaluateSignal('my_signal', rows, (r) => r.my_signal, { iterations: 200 });
-  assert.equal(result.n, 5);
-  assert.equal(result.hit, 2);
-  assert.equal(result.miss, 3);
-  assert.equal(result.auc, 1);
-  assert.equal(result.majority_baseline_pct, 60);
-  assert.equal(result.best_threshold_accuracy_pct, 100);
-});
-
-test('evaluateSignal: pure-signal cutover excludes pre-migration rows (default-0.0 pollution guard)', () => {
-  const cutover = mod.PURE_SIGNAL_CUTOVER_EPOCH;
-  const rows = [
-    // Pre-cutover rows: heat_raw defaults to 0.0 (migration backfill), not a real measurement.
-    { heat_raw: 0.0, predicted_at: cutover - 1000, is_hit: 1 },
-    { heat_raw: 0.0, predicted_at: cutover - 2000, is_hit: 0 },
-    // Post-cutover rows: real values.
-    { heat_raw: 5.0, predicted_at: cutover + 1000, is_hit: 1 },
-    { heat_raw: 0.5, predicted_at: cutover + 2000, is_hit: 0 },
-  ];
-  const result = mod.evaluateSignal('heat_raw', rows, (r) => r.heat_raw, {
-    cutoverEpoch: cutover,
-    iterations: 50,
-  });
-  assert.equal(result.n, 2, 'only post-cutover rows should be counted');
-});
-
-test('persistence + report round trip: a real temp sqlite prediction_ledger reproduces expected AUC', () => {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'task1903-roundtrip-'));
-  const dbPath = path.join(tmpDir, 'memory.db');
-  try {
-    const db = new DatabaseSync(dbPath);
-    db.exec(`
-      CREATE TABLE prediction_ledger (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        prediction_type TEXT NOT NULL,
-        symbol_id TEXT NOT NULL DEFAULT '',
-        predicted_at INTEGER NOT NULL,
-        predicted_value REAL NOT NULL DEFAULT 0.0,
-        confidence REAL NOT NULL DEFAULT 0.0,
-        component_breakdown TEXT NOT NULL DEFAULT '{}',
-        resolution_condition TEXT NOT NULL DEFAULT '',
-        outcome_symbol_id TEXT NOT NULL DEFAULT '',
-        outcome_timestamp INTEGER,
-        outcome_quality TEXT NOT NULL DEFAULT '',
-        surprise_magnitude REAL,
-        verified INTEGER NOT NULL DEFAULT 0,
-        scored INTEGER NOT NULL DEFAULT 0,
-        rune_id TEXT NOT NULL DEFAULT '',
-        heat_raw REAL NOT NULL DEFAULT 0.0,
-        co_change_raw REAL NOT NULL DEFAULT 0.0,
-        recency_raw REAL NOT NULL DEFAULT 0.0
-      );
-    `);
-    const insert = db.prepare(
-      `INSERT INTO prediction_ledger
-         (prediction_type, symbol_id, predicted_at, predicted_value, confidence,
-          component_breakdown, verified, outcome_quality, heat_raw, co_change_raw, recency_raw)
-       VALUES ('efe', ?, ?, ?, ?, ?, 1, ?, ?, ?, ?)`
-    );
-    const cutover = mod.PURE_SIGNAL_CUTOVER_EPOCH;
-    const breakdown = JSON.stringify({
-      g_risk: 1.0,
-      g_ambiguity: 0.2,
-      g_novelty: 0.1,
-      g_salience: 0.05,
-      complexity_penalty: 0.3,
-    });
-    // 6 rows post-cutover: heat_raw perfectly separates hit/miss for this fixture.
-    const fixtureRows = [
-      ['sym_a', cutover + 10, 0.5, 0.1, 'hit', 9.0, 1.0, 1.0],
-      ['sym_b', cutover + 20, 0.5, 0.1, 'hit', 8.0, 1.0, 1.0],
-      ['sym_c', cutover + 30, 0.5, 0.1, 'miss', 1.0, 1.0, 1.0],
-      ['sym_d', cutover + 40, 0.5, 0.1, 'miss', 2.0, 1.0, 1.0],
-      ['sym_e', cutover + 50, 0.5, 0.1, 'miss', 3.0, 1.0, 1.0],
-    ];
-    for (const [sym, ts, pv, conf, quality, heat, cc, rec] of fixtureRows) {
-      insert.run(sym, ts, pv, conf, breakdown, quality, heat, cc, rec);
-    }
-    db.close();
-
-    // Read back exactly as the report script's loadRows() would, via buildReport
-    // against this temp db path (already a "copy" for test purposes).
-    const report = mod.buildReport(dbPath);
-    const heatSignal = report.results.find((r) => r.signal.startsWith('heat_raw'));
-    assert.ok(heatSignal, 'heat_raw signal should be present in the report');
-    assert.equal(heatSignal.n, 5);
-    assert.equal(heatSignal.hit, 2);
-    assert.equal(heatSignal.miss, 3);
-    assert.equal(heatSignal.auc, 1, 'heat_raw perfectly separates hit/miss in this fixture');
-
-    const efeSignal = report.results.find((r) => r.signal.startsWith('raw_efe'));
-    assert.equal(efeSignal.n, 5);
-    assert.equal(
-      efeSignal.auc,
-      0.5,
-      'constant predicted_value across every row ties all ranks -> AUC collapses to exactly 0.5'
-    );
-  } finally {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-});