@ijfw/memory-server 1.5.6 → 1.6.1

package/src/profile/eval/verifier-pair.mjs

@@ -0,0 +1,122 @@
+// verifier-pair.mjs — Gate B v3. Turn two authors' chunk-feature sets into ONE fixed
+// pair-summary feature vector for the trained logistic verifier. ZERO deps.
+//
+// For an author pair (A,B) we compute, over all (or sampled) cross-author chunk pairs,
+// the DISTRIBUTION of per-family Burrows-Delta distances (mean |z_a - z_b| over that
+// family's dims — NOT a single channel cosine, which washes out the few idiosyncratic
+// dims). We summarize each family's cross-pair distance distribution with
+// mean/median/min/max + 10/25/75/90 percentiles + fraction-below-cutpoint, and add a
+// within-author consistency term (how tight each author's own chunks cluster). These
+// summaries are the verifier's input — the logreg learns the same/different boundary.
+
+import { FAMILIES } from './verifier-features.mjs';
+
+// mean |z_a - z_b| over a family's dimensions = Burrows-Delta-style distance for ONE
+// chunk pair within ONE family.
+function familyDelta(za, zb) {
+  const n = za.length;
+  if (!n) return 0;
+  let s = 0;
+  for (let i = 0; i < n; i += 1) s += Math.abs(za[i] - zb[i]);
+  return s / n;
+}
+
+function percentile(sorted, p) {
+  if (!sorted.length) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.round((p / 100) * (sorted.length - 1))));
+  return sorted[idx];
+}
+
+function summarize(dists, cutpoint) {
+  if (!dists.length) return [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  const s = [...dists].sort((a, b) => a - b);
+  const mean = s.reduce((a, b) => a + b, 0) / s.length;
+  const median = percentile(s, 50);
+  const belowCut = s.filter((d) => d <= cutpoint).length / s.length;
+  return [
+    mean, median, s[0], s[s.length - 1],
+    percentile(s, 10), percentile(s, 25), percentile(s, 75), percentile(s, 90),
+    belowCut,
+  ];
+}
+const SUMMARY_LEN = 9; // mean,median,min,max,p10,p25,p75,p90,fracBelow
+
+// within-author consistency: mean cross-chunk family delta among an author's OWN chunks
+// (low = tight idiolect). Returns one scalar per family.
+function withinConsistency(chunkFeats) {
+  const out = {};
+  for (const fam of FAMILIES) {
+    const cs = chunkFeats.map((c) => c[fam]).filter((v) => v && v.length);
+    if (cs.length < 2) { out[fam] = 0; continue; }
+    let s = 0; let n = 0;
+    const cap = 40; // bound the within-author pair count for speed
+    for (let i = 0; i < cs.length && n < cap * cs.length; i += 1) {
+      for (let j = i + 1; j < cs.length; j += 1) { s += familyDelta(cs[i], cs[j]); n += 1; }
+    }
+    out[fam] = n ? s / n : 0;
+  }
+  return out;
+}
+
+// Deterministic sampling of cross-author chunk pairs (seeded) so the pair vector is
+// reproducible and bounded for large authors.
+function sampleCrossPairs(nA, nB, cap, rng) {
+  const total = nA * nB;
+  if (total <= cap) {
+    const out = [];
+    for (let i = 0; i < nA; i += 1) for (let j = 0; j < nB; j += 1) out.push([i, j]);
+    return out;
+  }
+  const seen = new Set();
+  const out = [];
+  while (out.length < cap) {
+    const i = Math.floor(rng() * nA);
+    const j = Math.floor(rng() * nB);
+    const k = i * nB + j;
+    if (seen.has(k)) continue;
+    seen.add(k); out.push([i, j]);
+  }
+  return out;
+}
+
+// pairFeatures(featsA, featsB, cfg) -> Float64Array. featsA/featsB are arrays of
+// chunkFeatures objects. The feature layout is fixed (same length every call).
+export function pairFeatures(featsA, featsB, cfg = {}) {
+  const cap = cfg.pairCap || 400;
+  const rng = cfg.rng || Math.random;
+  const cutByFam = cfg.cutpoints || {}; // per-family DEV-learned cutpoint
+  const idxs = sampleCrossPairs(featsA.length, featsB.length, cap, rng);
+
+  // collect cross-pair family-delta distributions
+  const dists = {};
+  for (const fam of FAMILIES) dists[fam] = [];
+  for (const [i, j] of idxs) {
+    const a = featsA[i]; const b = featsB[j];
+    for (const fam of FAMILIES) {
+      if (a[fam] && a[fam].length) dists[fam].push(familyDelta(a[fam], b[fam]));
+    }
+  }
+
+  const consA = withinConsistency(featsA);
+  const consB = withinConsistency(featsB);
+
+  const vec = [];
+  for (const fam of FAMILIES) {
+    const cut = Number.isFinite(cutByFam[fam]) ? cutByFam[fam] : 2.0;
+    vec.push(...summarize(dists[fam], cut));
+    // consistency context: each author's own tightness + the ratio cross/within
+    const cA = consA[fam]; const cB = consB[fam];
+    const crossMean = dists[fam].length
+      ? dists[fam].reduce((a, b) => a + b, 0) / dists[fam].length : 0;
+    vec.push(cA, cB, (cA + cB) / 2);
+    // separation ratio: cross distance vs the tighter within-author distance (a strong
+    // same/diff signal — within-author cross-pair distance ~ cross distance for same).
+    const denom = Math.max(1e-6, (cA + cB) / 2);
+    vec.push(crossMean / denom);
+  }
+  return Float64Array.from(vec);
+}
+
+export const PAIR_FEATURE_LEN = FAMILIES.length * (SUMMARY_LEN + 4);
+
+export const __test = { familyDelta, summarize, withinConsistency, sampleCrossPairs };

package/src/profile/eval/verifier-reference.mjs

@@ -0,0 +1,68 @@
+// verifier-reference.mjs — Gate B v3, Task B (calibration regen). Build the per-family
+// reference mean/SD from a set of TRAIN-author chunks (DEV, author-disjoint from the
+// validation fold). Percentile SD floor; floored dims dropped from the scalar/affix
+// families is NOT done (fixed-length vectors needed) — instead a robust SD floor keeps
+// rare dims from blowing up to the z-cap. ZERO deps. Never reads sealed corpora.
+
+import { relFreqFunc, relFreqTrigrams, relFreqPunct } from './stylometry-features.js';
+import { FUNCTION_WORDS, TRIGRAM_KEYS, PUNCT_KEYS } from './stylometry-reference.js';
+import { topicRobustScalars, affixCounts, relFreqAffix } from './verifier-features.mjs';
+
+function meanSd(rows, floorPct) {
+  const d = rows[0].length;
+  const mean = Array.from({ length: d }, () => 0);
+  const sd = Array.from({ length: d }, () => 0);
+  for (const r of rows) for (let j = 0; j < d; j += 1) mean[j] += r[j];
+  for (let j = 0; j < d; j += 1) mean[j] /= rows.length;
+  for (const r of rows) for (let j = 0; j < d; j += 1) sd[j] += (r[j] - mean[j]) ** 2;
+  for (let j = 0; j < d; j += 1) sd[j] = Math.sqrt(sd[j] / rows.length);
+  // percentile SD floor: floor at the `floorPct` percentile of the POSITIVE sds, so rare
+  // near-constant dims don't divide by ~0 (which sends them to the z-cap and dominates).
+  const pos = sd.filter((x) => x > 0).sort((a, b) => a - b);
+  const floor = pos.length ? pos[Math.floor((floorPct / 100) * (pos.length - 1))] : 1e-6;
+  for (let j = 0; j < d; j += 1) if (!(sd[j] > floor)) sd[j] = floor;
+  return { mean, sd };
+}
+
+// Pick the top-K most frequent affix keys across the train chunks (content-light:
+// 3-char prefixes/suffixes). Deterministic by (count desc, key asc).
+function pickAffixKeys(chunks, k) {
+  const counts = Object.create(null);
+  for (const c of chunks) {
+    const { pre, suf } = affixCounts(c);
+    for (const key in pre) counts[key] = (counts[key] || 0) + pre[key];
+    for (const key in suf) counts[key] = (counts[key] || 0) + suf[key];
+  }
+  return Object.entries(counts)
+    .sort((a, b) => (b[1] - a[1]) || (a[0] < b[0] ? -1 : 1))
+    .slice(0, k)
+    .map(([key]) => key);
+}
+
+// buildReference(trainChunks, opts) -> ref object consumed by chunkFeatures.
+export function buildReference(trainChunks, opts = {}) {
+  const floorPct = opts.floorPct ?? 10;
+  const affixK = opts.affixK ?? 150;
+  const affixKeys = pickAffixKeys(trainChunks, affixK);
+
+  const funcRows = trainChunks.map((c) => relFreqFunc(c, FUNCTION_WORDS));
+  const triRows = trainChunks.map((c) => relFreqTrigrams(c, TRIGRAM_KEYS));
+  const punctRows = trainChunks.map((c) => relFreqPunct(c, PUNCT_KEYS));
+  const scalarRows = trainChunks.map((c) => topicRobustScalars(c));
+  const affixRows = trainChunks.map((c) => relFreqAffix(c, affixKeys));
+
+  const f = meanSd(funcRows, floorPct);
+  const t = meanSd(triRows, floorPct);
+  const p = meanSd(punctRows, floorPct);
+  const s = meanSd(scalarRows, floorPct);
+  const a = meanSd(affixRows, floorPct);
+
+  return {
+    funcMean: f.mean, funcSd: f.sd,
+    triMean: t.mean, triSd: t.sd,
+    punctMean: p.mean, punctSd: p.sd,
+    scalarMean: s.mean, scalarSd: s.sd,
+    affixKeys, affixMean: a.mean, affixSd: a.sd,
+    nTrainChunks: trainChunks.length,
+  };
+}

package/src/profile/eval/verifier-scorer.mjs

@@ -0,0 +1,30 @@
+// verifier-scorer.mjs — Gate B v3. Adapts the trained chunk-pair logistic verifier to
+// the `scorer` interface validateInstrument expects: { vectorize, distance }.
+//
+// UNIT OF PAIRING = one CHUNK per "doc". vectorize(text) -> per-family z-vectors for that
+// chunk (against the DEV-derived reference). distance(a,b) -> 1 - P(same-author) from the
+// trained logreg over the single chunk-pair summary. Training (in the harness) uses the
+// IDENTICAL single-pair summary representation, so train and score are consistent.
+
+import { chunkFeatures } from './verifier-features.mjs';
+import { pairFeatures } from './verifier-pair.mjs';
+import { applyStandardizer, predictProba } from './verifier-logreg.mjs';
+
+// Build a single chunk-pair summary vector (two singleton chunk sets). cutpoints kept
+// fixed across train/score (DEV-learned, passed in).
+export function chunkPairFeatures(featA, featB, cfg) {
+  return pairFeatures([featA], [featB], cfg);
+}
+
+// makeScorer(ref, model, standardizer, cfg) -> { vectorize, distance }.
+export function makeScorer(ref, model, standardizer, cfg = {}) {
+  return {
+    vectorize(text) { return chunkFeatures(text, ref); },
+    distance(a, b) {
+      const pf = chunkPairFeatures(a, b, cfg);
+      const std = applyStandardizer(pf, standardizer);
+      const p = predictProba(std, model); // P(same-author)
+      return 1 - p; // distance: higher = more different (validateInstrument convention)
+    },
+  };
+}

package/src/profile/eval/wrong-target-control.mjs

@@ -0,0 +1,168 @@
+// wrong-target-control.mjs — Gate B v2, Task T5. THE discriminator.
+//
+// For each subject P and arm, the margin is:
+//     m_P = distance(output, NEAREST same-register foreigner) − distance(output, OWN test)
+// m_P > 0 means the styled output landed closer to P's OWN held-out fingerprint than to
+// the CLOSEST same-register stranger. A generic register-obeyer is ~equidistant from all
+// same-register targets ⇒ m≈0 ⇒ NULL. Only idiosyncratic voice capture wins.
+//
+// Audit must-fixes baked in:
+//   * Foreign pool restricted to the SAME register band (δ=0.15), by the register metric
+//     only — a register-obeyer cannot false-PASS.
+//   * NEAREST foreigner, never a centroid/mean of foreigners (centroid regresses to the
+//     population center and manufactures a positive margin).
+//   * Undecidable subjects (no same-register foreigner) are EXCLUDED — never fall back to
+//     a register-diverse pool.
+//   * Bootstrap resamples SUBJECTS (the margins array is length = nDecidableSubjects).
+//   * One-sided 99% lower bound = bootstrapCI(margins, {alpha:0.02}).lo.
+//   * Measured-scale floor (minMeanMargin) must bite: significant-but-trivial ⇒ NULL.
+//   * McNemar vs baseline reads .pValue and applies perTestAlpha locally (ignores the
+//     helper's hardcoded .significant=0.05).
+
+import { fullStyleDistance, styleDistance } from './stylometry.js';
+import { bootstrapCI, mcnemar } from '../../memory/bench-metrics.js';
+
+export const CONTROL_DEFAULTS = Object.freeze({
+  registerDelta: 0.15,
+  alpha: 0.02,          // two-sided helper @0.02 → one-sided 99% lower bound
+  minMeanMargin: 0.01,  // TEST-ONLY default; the real run derives floorK*(between-within) (prereg.deriveMinMeanMargin)
+  minDz: 0.5,           // minimum standardized effect size (mean/sd) — kills "few subjects carry it"
+  perTestAlpha: 0.01,   // Bonferroni-adjusted at T7; default single-test 0.01
+  bootstrapIters: 2000,
+  seed: 42,
+});
+
+function mean(xs) { return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : NaN; }
+function stdev(xs) {
+  if (xs.length < 2) return NaN;
+  const mu = mean(xs);
+  return Math.sqrt(xs.reduce((a, b) => a + (b - mu) ** 2, 0) / (xs.length - 1));
+}
+
+// Same-register foreigners of P: other personas whose TEST register vector is within δ of
+// P's. Register-only — independent of the authorship distance under test.
+export function sameRegisterForeigners(p, personas, delta) {
+  const pReg = p.fingerprint.register;
+  return personas.filter((q) => q.id !== p.id && styleDistance(pReg, q.fingerprint.register) <= delta);
+}
+
+// Margin of one arm output for subject P against the NEAREST same-register foreigner.
+export function subjectMargin(armVector, p, foreigners) {
+  const dOwn = fullStyleDistance(armVector, p.fingerprint);
+  let dNearestForeign = Infinity;
+  for (const q of foreigners) {
+    const d = fullStyleDistance(armVector, q.fingerprint);
+    if (d < dNearestForeign) dNearestForeign = d;
+  }
+  return { dOwn, dNearestForeign, margin: dNearestForeign - dOwn };
+}
+
+// Significance at a given alpha, reading the raw p-value (NOT mcnemar's hardcoded .significant).
+export function significantAt(pValue, alpha) { return Number.isFinite(pValue) && pValue < alpha; }
+
+function fmt4(x) { return Number.isFinite(x) ? x.toFixed(4) : 'NaN'; }
+
+// Pure arm-level control verdict. PASS requires ALL of (spec §4.4 + §4.7):
+//   1. one-sided 99% CI lower bound > 0          (the effect is real)
+//   2. meanMargin >= measured-scale floor        (the effect is non-trivial in instrument units)
+//   3. majority of subjects positive (>50%)      (NOT a few subjects carrying it)
+//   4. standardized effect dz = mean/sd >= minDz  (the effect is large relative to spread)
+//   5. sign-test pValue < perTestAlpha            (the majority is statistically significant)
+// A heavy-tailed margin that clears 1+2 but fails 3/4/5 is a NULL, not a PASS.
+export function controlVerdict(armStats, cfg) {
+  const reasons = [];
+  const {
+    ciLower, meanMargin, sd, pctPositive, signPValue,
+  } = armStats;
+  const minDz = cfg.minDz ?? 0.5;
+  const dz = (Number.isFinite(sd) && sd > 0)
+    ? meanMargin / sd
+    : (meanMargin > 0 ? Infinity : 0); // sd≈0 with positive mean = perfectly consistent effect
+
+  if (!(Number.isFinite(ciLower) && ciLower > 0)) reasons.push(`CI-lower ${fmt4(ciLower)} not > 0`);
+  if (!(Number.isFinite(meanMargin) && meanMargin >= cfg.minMeanMargin)) reasons.push(`meanMargin ${fmt4(meanMargin)} < floor ${cfg.minMeanMargin}`);
+  if (!(Number.isFinite(pctPositive) && pctPositive > 0.5)) reasons.push(`pctPositive ${fmt4(pctPositive)} <= 0.5 (minority of subjects)`);
+  if (!(dz >= minDz)) reasons.push(`dz ${Number.isFinite(dz) ? dz.toFixed(3) : dz} < ${minDz}`);
+  if (!(Number.isFinite(signPValue) && signPValue < cfg.perTestAlpha)) reasons.push(`sign-test p ${fmt4(signPValue)} >= perTestAlpha ${cfg.perTestAlpha}`);
+
+  return { passes: reasons.length === 0, reasons, dz };
+}
+
+// wrongTargetControl(harnessOut, personas, opts) → per-arm margin stats + verdicts.
+export function wrongTargetControl(harnessOut, personas, opts = {}) {
+  const cfg = { ...CONTROL_DEFAULTS, ...opts };
+  const byId = new Map(personas.map((p) => [p.id, p]));
+
+  // foreigners per persona (register-only); decidable = has >=1 same-register foreigner
+  const foreignersById = {};
+  for (const p of personas) foreignersById[p.id] = sameRegisterForeigners(p, personas, cfg.registerDelta);
+  const decidableIds = personas.filter((p) => foreignersById[p.id].length > 0).map((p) => p.id);
+
+  const perArm = {};
+  for (const arm of harnessOut.arms) {
+    const margins = [];
+    const ownWin = [];
+    const regGaps = [];
+    for (const id of decidableIds) {
+      const p = byId.get(id);
+      const armVec = harnessOut.results[id][arm].vector;
+      const sm = subjectMargin(armVec, p, foreignersById[id]);
+      margins.push(sm.margin);
+      ownWin.push(sm.margin > 0 ? 1 : 0);
+      // diagnostic: register distance to the nearest same-register foreigner
+      const nearest = foreignersById[id].reduce((best, q) => {
+        const d = fullStyleDistance(armVec, q.fingerprint);
+        return d < best.d ? { q, d } : best;
+      }, { q: null, d: Infinity }).q;
+      if (nearest) regGaps.push(styleDistance(p.fingerprint.register, nearest.fingerprint.register));
+    }
+    const ownLoss = margins.map((m) => (m < 0 ? 1 : 0));
+    const ci = bootstrapCI(margins, { iters: cfg.bootstrapIters, alpha: cfg.alpha, seed: cfg.seed });
+    // zeros-vs-wins sign test: b = #(margin>0), c = #(margin<0); two-sided p on |b−c|.
+    const sign = mcnemar(ownLoss, ownWin);
+    perArm[arm] = {
+      arm,
+      nDecidable: margins.length,
+      margins,
+      ownWin,
+      meanMargin: mean(margins),
+      sd: stdev(margins),
+      pctPositive: mean(ownWin),
+      signPValue: sign.pValue,
+      signPositives: sign.b,
+      signNegatives: sign.c,
+      ciLower: ci.lo,
+      ciPoint: ci.point,
+      registerGap: mean(regGaps),
+    };
+  }
+
+  // McNemar vs baseline for each verdict arm (own-match win indicator), pValue exposed.
+  for (const arm of harnessOut.arms) {
+    if (arm === 'baseline' || !perArm.baseline) continue;
+    const m = mcnemar(perArm.baseline.ownWin, perArm[arm].ownWin);
+    // mcnemar.pValue is TWO-SIDED (|b−c|), so the direction guard m.b > m.c is mandatory:
+    // the arm must FLIP MORE subjects to own-match than baseline does, not merely differ.
+    perArm[arm].vsBaseline = {
+      b: m.b, c: m.c, pValue: m.pValue, beatsBaseline: significantAt(m.pValue, cfg.perTestAlpha) && m.b > m.c,
+    };
+  }
+
+  // arm verdicts
+  for (const arm of harnessOut.arms) perArm[arm].verdict = controlVerdict(perArm[arm], cfg);
+
+  return {
+    cfg,
+    nSubjects: personas.length,
+    nDecidable: decidableIds.length,
+    nUndecidable: personas.length - decidableIds.length,
+    decidableIds,
+    perArm,
+    // VOID rail input: PASS of a register-only-echo arm means the control is fooled by
+    // register alone. undefined (no registerEcho arm present) ⇒ the decision layer THROWS
+    // rather than silently treating the missing rail as false.
+    registerEchoPasses: perArm.registerEcho ? perArm.registerEcho.verdict.passes : undefined,
+  };
+}
+
+export const __test = { mean };

package/src/profile/eval/wrong-target-control.test.mjs

@@ -0,0 +1,124 @@
+// Gate B v2 — Task T5: wrong-target control. The discriminator's guards: same-register
+// foreign pool, undecidable exclusion, NEAREST (not centroid) margin, subject-level
+// bootstrap, measured-scale floor, McNemar by p-value. Positive control (own output)
+// PASSES; generic output NULLs.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  wrongTargetControl, sameRegisterForeigners, subjectMargin, controlVerdict, significantAt,
+} from './wrong-target-control.mjs';
+import { mcnemar } from '../../memory/bench-metrics.js';
+import { generatePersonaText } from './synthetic-personas.js';
+import { fullStyleVector } from './stylometry.js';
+
+function persona(id, text) { return { id, fingerprint: fullStyleVector(text) }; }
+// formal personas (archetype 0) — same register, different authors. n=10 so the sign test
+// can clear perTestAlpha=0.01 when every subject is positive (the positive control).
+const FORMAL = Array.from({ length: 10 }, (_, i) => persona(`f${i}`, generatePersonaText(0, 17 * (i + 1), 16)));
+// Unambiguously different register: emoji + contractions + exclamations + casual (several
+// axes differ from formal, clearing the 0.15 band).
+const CASUAL = persona('c0', "omg yes!! 🚀 lol i love it, it's so cool 😄 you're gonna wanna try it, honestly it's the best, i can't even, no cap!! 💯");
+
+function fakeHarness(arms, personas, vectorFor) {
+  const results = {};
+  for (const p of personas) {
+    results[p.id] = {};
+    for (const arm of arms) results[p.id][arm] = { vector: vectorFor(p, arm) };
+  }
+  return { arms, personaIds: personas.map((p) => p.id), results };
+}
+
+test('foreign pool is restricted to the SAME register band (δ=0.15)', () => {
+  const pool = [...FORMAL, CASUAL];
+  const f = sameRegisterForeigners(FORMAL[0], pool, 0.15).map((q) => q.id);
+  assert.ok(f.includes('f1'), 'a same-register formal peer is in the pool');
+  assert.ok(!f.includes('c0'), 'the different-register casual author is excluded');
+});
+
+test('undecidable subjects (no same-register foreigner) are EXCLUDED, no diverse fallback', () => {
+  const personas = [FORMAL[0], CASUAL]; // each other is a different register
+  const h = fakeHarness(['baseline'], personas, (p) => p.fingerprint);
+  const r = wrongTargetControl(h, personas);
+  assert.equal(r.nDecidable, 0);
+  assert.equal(r.nUndecidable, 2);
+  assert.deepEqual(r.decidableIds, []);
+});
+
+test('margin uses NEAREST foreigner, not a centroid', () => {
+  const p = FORMAL[0];
+  const foreigners = [FORMAL[1], FORMAL[2], FORMAL[3]];
+  // output IS a foreigner (f1) → nearest distance is 0 → margin must be negative
+  const sm = subjectMargin(FORMAL[1].fingerprint, p, foreigners);
+  assert.equal(sm.dNearestForeign, 0, 'nearest foreigner distance is 0 (output == f1)');
+  assert.ok(sm.margin < 0, 'matching a stranger yields a NEGATIVE margin (centroid would hide this)');
+  // output IS own → margin positive
+  const smOwn = subjectMargin(p.fingerprint, p, foreigners);
+  assert.ok(smOwn.margin > 0, 'matching OWN yields a positive margin');
+});
+
+test('POSITIVE control: own-output arm PASSES (margins positive, CI-lower>0, floor cleared)', () => {
+  const h = fakeHarness(['baseline'], FORMAL, (p) => p.fingerprint); // output == own
+  const r = wrongTargetControl(h, FORMAL);
+  assert.equal(r.nDecidable, 10);
+  assert.equal(r.perArm.baseline.margins.length, 10, 'bootstrap operates on SUBJECTS (=10), not probes');
+  assert.equal(r.perArm.baseline.verdict.passes, true);
+  assert.ok(r.perArm.baseline.ciLower > 0);
+  assert.ok(r.perArm.baseline.pctPositive > 0.5 && r.perArm.baseline.signPValue < 0.01);
+});
+
+test('NEGATIVE control: generic constant output does NOT pass the control (≈NULL)', () => {
+  const constVec = fullStyleVector(generatePersonaText(1, 999, 16)); // casual generic, matches no formal voice
+  const h = fakeHarness(['derived'], FORMAL, () => constVec);
+  const r = wrongTargetControl(h, FORMAL);
+  assert.equal(r.perArm.derived.verdict.passes, false, 'generic output is not closer to OWN than to nearest stranger');
+});
+
+const FULL_PASS = {
+  ciLower: 0.02, meanMargin: 0.05, sd: 0.05, pctPositive: 0.8, signPValue: 0.001,
+};
+const FULL_CFG = { minMeanMargin: 0.01, minDz: 0.5, perTestAlpha: 0.01 };
+
+test('controlVerdict PASSES only when ALL legs hold (not vacuously false)', () => {
+  assert.equal(controlVerdict(FULL_PASS, FULL_CFG).passes, true);
+});
+
+test('measured-scale floor BITES: significant-but-trivial ⇒ NULL', () => {
+  assert.equal(controlVerdict({ ...FULL_PASS, meanMargin: 0.004 }, FULL_CFG).passes, false);
+  assert.equal(controlVerdict({ ...FULL_PASS, ciLower: -0.01 }, FULL_CFG).passes, false);
+});
+
+test('NEW LEG — effect size dz: a few subjects carrying it (high sd) ⇒ NULL', () => {
+  // mean clears floor and CI>0, but sd is huge ⇒ dz<0.5 ⇒ NULL (heavy-tail false-PASS killed)
+  const g = controlVerdict({ ...FULL_PASS, sd: 0.5 }, FULL_CFG);
+  assert.equal(g.passes, false);
+  assert.ok(g.reasons.some((r) => /dz/.test(r)));
+});
+
+test('NEW LEG — majority: <=50% of subjects positive ⇒ NULL', () => {
+  const g = controlVerdict({ ...FULL_PASS, pctPositive: 0.5 }, FULL_CFG);
+  assert.equal(g.passes, false);
+  assert.ok(g.reasons.some((r) => /pctPositive/.test(r)));
+});
+
+test('NEW LEG — sign-test: p >= perTestAlpha ⇒ NULL (even with mean+CI+majority)', () => {
+  const g = controlVerdict({ ...FULL_PASS, signPValue: 0.03 }, FULL_CFG);
+  assert.equal(g.passes, false);
+  assert.ok(g.reasons.some((r) => /sign-test/.test(r)));
+});
+
+test('McNemar reads p-value with perTestAlpha — ignores the helper hardcoded .significant(0.05)', () => {
+  const baseline = Array.from({ length: 20 }, () => 0);
+  const arm = Array.from({ length: 20 }, (_, i) => (i < 7 ? 1 : 0)); // 7 flips, 0 losses
+  const m = mcnemar(baseline, arm);
+  assert.ok(m.pValue > 0.01 && m.pValue < 0.05, `p=${m.pValue.toFixed(3)} lands between the alphas`);
+  assert.equal(significantAt(m.pValue, 0.01), false, 'not significant at the strict Bonferroni alpha');
+  assert.equal(significantAt(m.pValue, 0.05), true, 'would be "significant" at the lax 0.05 the helper hardcodes');
+});
+
+test('registerGap diagnostic is emitted for decidable arms', () => {
+  const h = fakeHarness(['baseline'], FORMAL, (p) => p.fingerprint);
+  const r = wrongTargetControl(h, FORMAL);
+  assert.ok(Number.isFinite(r.perArm.baseline.registerGap));
+  assert.ok(r.perArm.baseline.registerGap <= 0.15, 'nearest foreigner really is same-register');
+});