@ijfw/memory-server 1.5.6 → 1.6.0

package/src/profile/eval/stylometry.js

@@ -0,0 +1,224 @@
+// stylometry.js — a richer, judge-free style metric for the Gate B research
+// program (docs/superpowers/plans/2026-06-08-gate-b-research-program.md, Phase 1.1).
+//
+// WHY: the old Gate B style metric was 3 shallow axes (length-as-terseness + a
+// 12-word formality keyword count + an emoji bit). A skeptic correctly rejects
+// "matched your length profile" as evidence of "writes in your voice", and a
+// model trivially games it via maxTokens alone. This vector adds axes that move
+// INDEPENDENTLY of length — lexical diversity, sentence-length variance,
+// punctuation signature, hedging and contraction rates — so a real voice match
+// must move several dimensions, not just shorten the output.
+//
+// Everything here is deterministic and dependency-free (no LLM, no network).
+// All nine features are normalized to [0,1] so styleDistance is a well-behaved
+// mean-absolute-difference in [0,1].
+
+import {
+  FUNCTION_WORDS, TRIGRAM_KEYS, PUNCT_KEYS,
+  REF_MEAN_FUNC, REF_SD_FUNC, REF_MEAN_TRI, REF_SD_TRI, REF_MEAN_PUNCT, REF_SD_PUNCT,
+} from './stylometry-reference.js';
+import { relFreqFunc, relFreqTrigrams, relFreqPunct } from './stylometry-features.js';
+
+const FORMAL_MARKERS = [
+  'however', 'therefore', 'furthermore', 'moreover', 'nevertheless',
+  'consequently', 'accordingly', 'thus', 'hence', 'whereas', 'regarding',
+  'additionally', 'subsequently',
+];
+const HEDGES = [
+  'maybe', 'perhaps', 'possibly', 'probably', 'might', 'could', 'i think',
+  'i guess', 'sort of', 'kind of', 'somewhat', 'arguably', 'presumably',
+  'it seems', 'roughly', 'approximately',
+];
+// Conservative emoji + pictograph ranges (no external dep).
+// eslint-disable-next-line security/detect-unsafe-regex, no-misleading-character-class -- character class, no backtracking; intentional emoji + variation-selector (U+FE0F) class, match semantics must not change.
+const EMOJI_RE = /[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2190}-\u{21FF}\u{2B00}-\u{2BFF}\u{FE0F}]/gu;
+const CONTRACTION_RE = /\b\w+'(?:s|t|re|ve|ll|d|m)\b/gi;
+
+function saturate(x, scale) {
+  if (!(x > 0) || !(scale > 0)) return 0;
+  return x / (x + scale);
+}
+function clamp01(x) {
+  return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function words(text) {
+  return (String(text).toLowerCase().match(/[a-z0-9']+/gi) || []);
+}
+function sentences(text) {
+  return String(text).split(/[.!?]+(?:\s|$)/).map((s) => s.trim()).filter(Boolean);
+}
+function countMatches(text, list) {
+  const lc = String(text).toLowerCase();
+  let n = 0;
+  for (const term of list) {
+    if (term.includes(' ')) {
+      // phrase: count non-overlapping occurrences
+      let idx = 0;
+      while ((idx = lc.indexOf(term, idx)) !== -1) { n += 1; idx += term.length; }
+    } else {
+      const re = new RegExp(`\\b${term}\\b`, 'g');
+      n += (lc.match(re) || []).length;
+    }
+  }
+  return n;
+}
+
+// The nine-axis style vector. Each component is in [0,1].
+export function styleVector(text) {
+  const s = String(text || '');
+  const w = words(s);
+  const nW = w.length;
+  const sents = sentences(s);
+  const chars = s.length || 1;
+
+  // 1. terseness — short output = terse. (Length-driven, kept for continuity.)
+  const terseness = 1 - saturate(chars, 240);
+
+  // 2. formality — formal connective density (per word), saturated.
+  const formality = saturate(countMatches(s, FORMAL_MARKERS) / Math.max(nW, 1), 0.03);
+
+  // 3. emojiRate — emoji per char, saturated.
+  const emojiRate = saturate((s.match(EMOJI_RE) || []).length / chars, 0.02);
+
+  // 4. typeTokenRatio — lexical diversity (unique/total). Already [0,1].
+  const ttr = nW ? new Set(w).size / nW : 0;
+
+  // 5. meanSentenceLen — words per sentence, saturated at ~22.
+  const sentLens = sents.map((x) => words(x).length);
+  const meanSent = sentLens.length ? sentLens.reduce((a, b) => a + b, 0) / sentLens.length : 0;
+  const meanSentenceLen = saturate(meanSent, 22);
+
+  // 6. sentenceLenVar — burstiness of sentence length (stdev/mean), saturated.
+  let sentenceLenVar = 0;
+  if (sentLens.length > 1 && meanSent > 0) {
+    const variance = sentLens.reduce((a, b) => a + (b - meanSent) ** 2, 0) / sentLens.length;
+    sentenceLenVar = saturate(Math.sqrt(variance) / meanSent, 0.6);
+  }
+
+  // 7. punctProfile — punctuation density (per char), saturated.
+  const punct = (s.match(/[!?;:,—–\-()"]/g) || []).length;
+  const punctProfile = saturate(punct / chars, 0.06);
+
+  // 8. hedgeRate — hedging-marker density (per word), saturated.
+  const hedgeRate = saturate(countMatches(s, HEDGES) / Math.max(nW, 1), 0.04);
+
+  // 9. contractionRate — contractions per word, saturated.
+  const contractionRate = saturate((s.match(CONTRACTION_RE) || []).length / Math.max(nW, 1), 0.05);
+
+  return {
+    terseness: clamp01(terseness),
+    formality: clamp01(formality),
+    emojiRate: clamp01(emojiRate),
+    typeTokenRatio: clamp01(ttr),
+    meanSentenceLen: clamp01(meanSentenceLen),
+    sentenceLenVar: clamp01(sentenceLenVar),
+    punctProfile: clamp01(punctProfile),
+    hedgeRate: clamp01(hedgeRate),
+    contractionRate: clamp01(contractionRate),
+  };
+}
+
+export const STYLE_AXES = [
+  'terseness', 'formality', 'emojiRate', 'typeTokenRatio', 'meanSentenceLen',
+  'sentenceLenVar', 'punctProfile', 'hedgeRate', 'contractionRate',
+];
+
+// Mean absolute difference over the nine axes → [0,1]. Accepts either raw text
+// or pre-computed vectors. Optional per-axis weights (default equal).
+export function styleDistance(a, b, weights = null) {
+  const va = (a && typeof a === 'object') ? a : styleVector(a);
+  const vb = (b && typeof b === 'object') ? b : styleVector(b);
+  let sum = 0;
+  let wsum = 0;
+  for (const ax of STYLE_AXES) {
+    const wt = weights && Number.isFinite(weights[ax]) ? weights[ax] : 1;
+    sum += wt * Math.abs((va[ax] ?? 0) - (vb[ax] ?? 0));
+    wsum += wt;
+  }
+  return wsum ? sum / wsum : 0;
+}
+
+// ---------------------------------------------------------------------------
+// AUTHORSHIP LAYER (Gate B v2) — function-word / char-trigram / punct-n-gram
+// stylometry. The 9-axis styleVector above captures REGISTER (terse/formal/emoji);
+// these sub-vectors capture INDIVIDUAL voice — the idiosyncratic markers that
+// separate two same-register strangers. fullStyleDistance combines both.
+// ---------------------------------------------------------------------------
+
+// z-scores beyond this magnitude are clamped — guards against a function word that is
+// rare-or-absent in the (small) reference corpus producing a blow-up component that
+// would dominate the cosine direction.
+const Z_CAP = 8;
+
+// Standardize a raw relative-frequency vector against the FROZEN reference mean/sd.
+// CRITICAL (anti-circularity): refMean/refSd are the imported constants from
+// stylometry-reference.js — they are NEVER computed from `raw` (the scored text). The
+// only operations on `raw` here are subtraction of a constant and division by a
+// constant; no mean/variance is taken over the input. (Enforced by the anti-recompute
+// guard test.)
+function zStandardize(raw, refMean, refSd) {
+  const out = Array.from({ length: raw.length });
+  for (let i = 0; i < raw.length; i += 1) {
+    let z = (raw[i] - refMean[i]) / refSd[i];
+    if (z > Z_CAP) z = Z_CAP; else if (z < -Z_CAP) z = -Z_CAP;
+    out[i] = z;
+  }
+  return out;
+}
+
+// authorVector(text) → { func[180], tri[250], punct[24] } z-standardized sub-vectors.
+// Pure function of (text, frozen constants): independent of any other scored text.
+export function authorVector(text) {
+  return {
+    func: zStandardize(relFreqFunc(text, FUNCTION_WORDS), REF_MEAN_FUNC, REF_SD_FUNC),
+    tri: zStandardize(relFreqTrigrams(text, TRIGRAM_KEYS), REF_MEAN_TRI, REF_SD_TRI),
+    punct: zStandardize(relFreqPunct(text, PUNCT_KEYS), REF_MEAN_PUNCT, REF_SD_PUNCT),
+  };
+}
+
+// Frozen composite weights (spec §1.4). func-word distribution carries the most
+// individual-voice signal, so it dominates; register is a minority contributor.
+export const STYLO_WEIGHTS = Object.freeze({
+  register: 0.20, func: 0.50, tri: 0.25, punct: 0.05,
+});
+
+// fullStyleVector(text) → { register (9-axis), func, tri, punct }. Accepts an already
+// computed full vector (idempotent) so callers can precompute once and reuse.
+export function fullStyleVector(text) {
+  if (text && typeof text === 'object' && text.__full === true) return text;
+  const av = authorVector(text);
+  return { __full: true, register: styleVector(text), func: av.func, tri: av.tri, punct: av.punct };
+}
+
+// Cosine distance mapped to [0,1]: (1 - cos)/2. Zero-norm handling: both zero → 0
+// (identical/empty), exactly one zero → 0.5 (maximally undecided).
+function cosineDistance(u, v) {
+  let dot = 0; let nu = 0; let nv = 0;
+  for (let i = 0; i < u.length; i += 1) { dot += u[i] * v[i]; nu += u[i] * u[i]; nv += v[i] * v[i]; }
+  if (nu === 0 && nv === 0) return 0;
+  if (nu === 0 || nv === 0) return 0.5;
+  let cos = dot / (Math.sqrt(nu) * Math.sqrt(nv));
+  cos = cos > 1 ? 1 : cos < -1 ? -1 : cos;
+  const d = (1 - cos) / 2;
+  return d < 1e-12 ? 0 : d; // snap float dust so d(x,x) is exactly 0
+
+}
+
+// fullStyleDistance(a, b) → weighted authorship+register distance in [0,1]. Accepts
+// raw text OR fullStyleVector objects for either argument.
+export function fullStyleDistance(a, b, weights = STYLO_WEIGHTS) {
+  const fa = fullStyleVector(a);
+  const fb = fullStyleVector(b);
+  const registerD = styleDistance(fa.register, fb.register);
+  const funcD = cosineDistance(fa.func, fb.func);
+  const triD = cosineDistance(fa.tri, fb.tri);
+  const punctD = cosineDistance(fa.punct, fb.punct);
+  const w = weights;
+  const wsum = w.register + w.func + w.tri + w.punct;
+  return wsum ? (w.register * registerD + w.func * funcD + w.tri * triD + w.punct * punctD) / wsum : 0;
+}
+
+export default {
+  styleVector, styleDistance, STYLE_AXES,
+  authorVector, fullStyleVector, fullStyleDistance, STYLO_WEIGHTS,
+};

package/src/profile/eval/stylometry.test.mjs

@@ -0,0 +1,103 @@
+// Gate B v2 — authorship-layer stylometry (Task T1). These tests enforce the
+// properties the design audit made load-bearing: the metric is a sane distance, it
+// carries INDIVIDUAL-voice signal that survives length (not just register), and the
+// z-standardization is provably NOT recomputed from the scored text (the anti-circularity
+// guard — both structural source-scan and behavioral independence).
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import {
+  authorVector, fullStyleVector, fullStyleDistance, STYLO_WEIGHTS,
+} from './stylometry.js';
+import {
+  FUNCTION_WORDS, TRIGRAM_KEYS, PUNCT_KEYS, REFERENCE_SOURCE,
+  REF_MEAN_FUNC, REF_SD_FUNC,
+} from './stylometry-reference.js';
+
+// Same-author (formal/expository), two lengths.
+const A_SHORT = 'The matter, however, is one which must be considered with the greatest of care; the consequences of a hasty decision are, as the records of the past have shown, considerable.';
+const A_LONG = 'The matter, however, is one which must be considered with the greatest of care, for the consequences of a hasty decision are, as the records of the past have repeatedly shown, considerable. It is therefore the case that the wise observer, having weighed the whole of the evidence which is before him, will tend toward the conclusion that nothing of importance ought to be undertaken until the question itself has been examined with the patience that such a matter properly demands.';
+// Different author (casual/personal), length-matched to A_SHORT.
+const B_CASUAL = "yeah so i just think you're gonna really like it, it's kinda cool and you just click on the thing and then you're basically done, i mean it barely took me any time at all honestly.";
+
+test('authorVector emits fixed-length func(180)/tri(250)/punct(24), deterministic', () => {
+  const v = authorVector(A_SHORT);
+  assert.equal(v.func.length, 180);
+  assert.equal(v.tri.length, 250);
+  assert.equal(v.punct.length, 24);
+  for (const x of [...v.func, ...v.tri, ...v.punct]) assert.ok(Number.isFinite(x));
+  // deterministic
+  const v2 = authorVector(A_SHORT);
+  assert.deepEqual(v2.func, v.func);
+  assert.deepEqual(v2.tri, v.tri);
+  assert.deepEqual(v2.punct, v.punct);
+});
+
+test('fullStyleDistance is a sane metric: [0,1], symmetric, d(x,x)=0', () => {
+  assert.equal(fullStyleDistance(A_SHORT, A_SHORT), 0);
+  const d = fullStyleDistance(A_SHORT, B_CASUAL);
+  assert.ok(d >= 0 && d <= 1, `in [0,1], got ${d}`);
+  const d2 = fullStyleDistance(B_CASUAL, A_SHORT);
+  assert.ok(Math.abs(d - d2) < 1e-12, 'symmetric');
+});
+
+test('NOT-GAMEABLE-BY-LENGTH: same-author/diff-length is CLOSER than diff-author/same-length', () => {
+  const sameAuthorDiffLength = fullStyleDistance(A_SHORT, A_LONG);
+  const diffAuthorSameLength = fullStyleDistance(A_SHORT, B_CASUAL);
+  assert.ok(
+    diffAuthorSameLength > sameAuthorDiffLength,
+    `expected diff-author (${diffAuthorSameLength.toFixed(4)}) > same-author-diff-length (${sameAuthorDiffLength.toFixed(4)})`,
+  );
+});
+
+test('ANTI-RECOMPUTE (structural): standardization uses imported REF constants, not input stats', () => {
+  const src = fs.readFileSync(fileURLToPath(new URL('./stylometry.js', import.meta.url)), 'utf8');
+  // imports the frozen reference module
+  assert.ok(/from '\.\/stylometry-reference\.js'/.test(src), 'imports the frozen reference module');
+  // REF constants are passed into the standardizer at the call site
+  assert.ok(/zStandardize\(\s*relFreqFunc\([^)]*\),\s*REF_MEAN_FUNC,\s*REF_SD_FUNC\)/.test(src),
+    'authorVector standardizes func against imported REF_MEAN_FUNC/REF_SD_FUNC');
+  // the standardizer body must not recompute a mean/variance over the scored input
+  const m = src.match(/function zStandardize[\s\S]*?\n}/);
+  assert.ok(m, 'found zStandardize body');
+  assert.ok(!/Math\.sqrt/.test(m[0]), 'standardizer does not compute a stdev (no Math.sqrt) over input');
+  assert.ok(!/\.reduce\(/.test(m[0]), 'standardizer does not aggregate over the input vector');
+});
+
+test('ANTI-RECOMPUTE (behavioral): authorVector(A) is independent of other scored texts', () => {
+  const before = authorVector(A_SHORT);
+  // score a pile of unrelated texts — must not mutate any global standardization state
+  for (let i = 0; i < 50; i += 1) {
+    authorVector(`${B_CASUAL} ${i} ${A_LONG}`);
+    fullStyleDistance(A_LONG, B_CASUAL);
+  }
+  const after = authorVector(A_SHORT);
+  assert.deepEqual(after.func, before.func);
+  assert.deepEqual(after.tri, before.tri);
+  assert.deepEqual(after.punct, before.punct);
+});
+
+test('reference constants are frozen, aligned, and documented as persona-disjoint', () => {
+  assert.equal(FUNCTION_WORDS.length, 180);
+  assert.equal(TRIGRAM_KEYS.length, 250);
+  assert.equal(PUNCT_KEYS.length, 24);
+  assert.equal(REF_MEAN_FUNC.length, 180);
+  assert.equal(REF_SD_FUNC.length, 180);
+  assert.ok(REF_SD_FUNC.every((s) => s > 0), 'all SDs strictly positive (no divide-by-zero)');
+  assert.match(REFERENCE_SOURCE, /disjoint/i);
+});
+
+test('STYLO_WEIGHTS is frozen and sums sensibly with func dominant', () => {
+  assert.ok(Object.isFrozen(STYLO_WEIGHTS));
+  assert.ok(STYLO_WEIGHTS.func >= STYLO_WEIGHTS.tri);
+  assert.ok(STYLO_WEIGHTS.func > STYLO_WEIGHTS.register);
+});
+
+test('fullStyleVector is idempotent on an already-computed full vector', () => {
+  const fv = fullStyleVector(A_SHORT);
+  const again = fullStyleVector(fv);
+  assert.equal(again, fv);
+  assert.equal(fullStyleDistance(fv, fv), 0);
+});

package/src/profile/eval/synthetic-personas.js

@@ -0,0 +1,91 @@
+// synthetic-personas.js — Gate B v2, Task T3 (synthetic half). Deterministic, neutral,
+// controlled-style personas. EXISTS ONLY to (a) exercise the harness plumbing offline
+// and (b) add a SANITY/power check — NEVER to carry the verdict. Every synthetic persona
+// is stamped { synthetic:true, headlineEligible:false } so the decision runner (T7) can
+// only ever let real authors set the headline N and license the PASS/CUT.
+//
+// Anti-circularity note (C2): because synthetic text is generated FROM style archetypes
+// and then scored by the SAME metric family, a synthetic "win" is partly tautological.
+// That is exactly why synthetic is downgrade-only and never licenses the mission claim.
+
+import { fullStyleVector } from './stylometry.js';
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function rng() {
+    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 pick(rng, arr) { return arr[Math.floor(rng() * arr.length)]; }
+
+const SUBJECTS = ['the system', 'a user', 'the team', 'one approach', 'the process', 'this method', 'the result', 'a change', 'the design', 'the plan'];
+const PREDICATES = ['works as expected', 'needs another review', 'depends on the input', 'improves over time', 'handles the edge case', 'reduces the cost', 'follows the plan', 'meets the stated goal', 'remains stable under load', 'scales with demand'];
+
+// Style archetypes control function-word / connector / punctuation habits — the features
+// the authorship metric reads. Neutral content throughout.
+const ARCHETYPES = [
+  { // formal
+    connectors: ['however', 'therefore', 'moreover', 'consequently', 'furthermore'],
+    join: (a, b, c) => `${cap(a)}, ${c}, ${b}.`,
+  },
+  { // casual
+    connectors: ['so', 'and', 'but', 'plus', 'anyway'],
+    join: (a, b, c) => `${a} ${c} it ${b}, honestly.`,
+  },
+  { // terse
+    connectors: ['', '', ''],
+    join: (a, b) => `${cap(a)} ${b}.`,
+  },
+  { // discursive
+    connectors: ['which means', 'in other words', 'that is to say', 'as it happens'],
+    join: (a, b, c) => `${cap(a)} ${b}, ${c} the outcome is broadly acceptable for now.`,
+  },
+];
+function cap(s) { return s.charAt(0).toUpperCase() + s.slice(1); }
+
+// Generate neutral persona text in a fixed style (archetypeIdx) with content variation
+// driven by contentSeed — so train and test slices share STYLE but differ in content.
+export function generatePersonaText(archetypeIdx, contentSeed, nSentences) {
+  const arch = ARCHETYPES[archetypeIdx % ARCHETYPES.length];
+  const rng = mulberry32(contentSeed >>> 0);
+  const out = [];
+  for (let i = 0; i < nSentences; i += 1) {
+    const s = pick(rng, SUBJECTS);
+    const p = pick(rng, PREDICATES);
+    const c = pick(rng, arch.connectors);
+    out.push(arch.join(s, p, c));
+  }
+  return out.join(' ');
+}
+
+// makePersonas(n, seed) → n synthetic personas, same shape as real personas.
+export function makePersonas(n, seed = 1) {
+  const personas = [];
+  for (let k = 0; k < n; k += 1) {
+    const archetypeIdx = k % ARCHETYPES.length;
+    const styleBase = (seed * 1000 + k) >>> 0;
+    // distinct content seeds for train vs test → same style, disjoint content
+    const trainDocs = [
+      generatePersonaText(archetypeIdx, styleBase + 1, 16),
+      generatePersonaText(archetypeIdx, styleBase + 2, 16),
+    ];
+    const testDocs = [
+      generatePersonaText(archetypeIdx, styleBase + 9001, 12),
+    ];
+    personas.push({
+      id: `syn-${seed}-${k}`,
+      synthetic: true,
+      headlineEligible: false,
+      archetype: archetypeIdx,
+      trainDocs,
+      testDocs,
+      fingerprint: fullStyleVector(testDocs.join('\n')),
+    });
+  }
+  return personas;
+}
+
+export default { makePersonas, generatePersonaText };

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

@@ -0,0 +1,170 @@
+// verifier-features.mjs — Gate B v3 (trained pairwise verifier), chunk-level feature
+// extraction. ZERO deps. Reuses the shipped func(180)/tri(250)/punct(24) extractors and
+// adds TOPIC-ROBUST per-chunk features (word-shape/casing, char-affix n-grams,
+// sentence/paragraph length distributions, whitespace/quote/emoji/typo habits) so the
+// downstream verifier keys on individual VOICE, not subreddit topic vocabulary.
+//
+// Does NOT import or mutate the shipped stylometry.js scoring path. The frozen
+// reference here is INJECTED (built from DEV held-out authors by the harness), never the
+// shipped REF_MEAN/SD — calibration regen requirement (Task B).
+
+import { relFreqFunc, relFreqTrigrams, relFreqPunct } from './stylometry-features.js';
+import { FUNCTION_WORDS, TRIGRAM_KEYS, PUNCT_KEYS } from './stylometry-reference.js';
+
+const Z_CAP = 8;
+
+// ---- chunking --------------------------------------------------------------
+// Split an author's docs into whitespace-token chunks of `size` tokens. Punctuation is
+// kept attached (raw whitespace split) so punct/affix features survive. We chunk WITHIN
+// each doc (no cross-doc bleed) then concatenate the chunk lists.
+export function chunkDocs(docs, size) {
+  const chunks = [];
+  for (const doc of docs) {
+    const toks = String(doc).split(/\s+/).filter(Boolean);
+    if (toks.length < Math.floor(size * 0.6)) {
+      // too short to be a clean chunk on its own; keep only if it is at least ~60% of a
+      // chunk (avoids tiny noisy slices dominating the distribution).
+      if (toks.length >= 120) chunks.push(toks.join(' '));
+      continue;
+    }
+    for (let i = 0; i + size <= toks.length; i += size) {
+      chunks.push(toks.slice(i, i + size).join(' '));
+    }
+    // tail: keep if it is at least 60% of a chunk so we don't waste long tails
+    const rem = toks.length % size;
+    if (rem >= Math.floor(size * 0.6)) {
+      chunks.push(toks.slice(toks.length - rem).join(' '));
+    }
+  }
+  return chunks;
+}
+
+// ---- topic-robust scalar features (each is a function-word/shape RATE, topic-agnostic) -
+function topicRobustScalars(text) {
+  const s = String(text);
+  const chars = s.length || 1;
+  // word tokens (case-preserving for shape features)
+  const rawToks = s.split(/\s+/).filter(Boolean);
+  const alphaToks = (s.match(/[A-Za-z]+(?:'[A-Za-z]+)?/g) || []);
+  const nW = alphaToks.length || 1;
+
+  // casing / word-shape
+  let allCaps = 0; let titleCase = 0; let allLower = 0; let hasDigitTok = 0;
+  for (const t of rawToks) {
+    if (/^[A-Z0-9]{2,}$/.test(t) && /[A-Z]/.test(t)) allCaps += 1;
+    else if (/^[A-Z][a-z]+$/.test(t)) titleCase += 1;
+    else if (/^[a-z]+$/.test(t)) allLower += 1;
+    if (/\d/.test(t)) hasDigitTok += 1;
+  }
+  const nTok = rawToks.length || 1;
+
+  // sentences + paragraphs
+  const sents = s.split(/[.!?]+(?:\s|$)/).map((x) => x.trim()).filter(Boolean);
+  const sentLens = sents.map((x) => (x.match(/[A-Za-z']+/g) || []).length).filter((n) => n > 0);
+  const meanSent = sentLens.length ? sentLens.reduce((a, b) => a + b, 0) / sentLens.length : 0;
+  let sdSent = 0;
+  if (sentLens.length > 1 && meanSent > 0) {
+    sdSent = Math.sqrt(sentLens.reduce((a, b) => a + (b - meanSent) ** 2, 0) / sentLens.length);
+  }
+  const paras = s.split(/\n{2,}/).map((x) => x.trim()).filter(Boolean);
+  const paraLens = paras.map((p) => (p.match(/[A-Za-z']+/g) || []).length);
+  const meanPara = paraLens.length ? paraLens.reduce((a, b) => a + b, 0) / paraLens.length : 0;
+
+  // whitespace / quote / emoji / typo habits
+  const doubleSpace = (s.match(/ {2,}/g) || []).length;
+  const newlineRate = (s.match(/\n/g) || []).length / chars;
+  const straightQuote = (s.match(/"/g) || []).length;
+  const curlyQuote = (s.match(/[“”‘’]/g) || []).length;
+  const apostrophe = (s.match(/'/g) || []).length;
+  // oxlint-disable-next-line no-misleading-character-class -- intentional emoji + variation-selector (U+FE0F) class; match semantics must not change.
+  const emoji = (s.match(/[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}\u{FE0F}]/gu) || []).length;
+  // "typo"-ish signals: repeated-letter runs (sooo), lone i, multi-punct
+  const repeatRun = (s.match(/([a-zA-Z])\1\1+/g) || []).length;
+  const loneI = (s.match(/\bi\b/g) || []).length;       // lowercase pronoun i
+  const multiPunct = (s.match(/[!?]{2,}/g) || []).length;
+  const ellipsis = (s.match(/\.{2,}/g) || []).length;
+  const parenRate = (s.match(/[()]/g) || []).length / chars;
+  const dashRate = (s.match(/[-—–]/g) || []).length / chars;
+  const digitRate = (s.match(/\d/g) || []).length / chars;
+  // mean word length (chars per alpha token) — idiolect signal, topic-light
+  const meanWordLen = alphaToks.reduce((a, t) => a + t.length, 0) / nW;
+  const ttr = nW ? new Set(alphaToks.map((t) => t.toLowerCase())).size / nW : 0;
+
+  const sat = (x, k) => (x > 0 ? x / (x + k) : 0);
+  return [
+    allCaps / nTok,
+    titleCase / nTok,
+    allLower / nTok,
+    hasDigitTok / nTok,
+    sat(meanSent, 22),
+    meanSent > 0 ? sdSent / meanSent : 0,
+    sat(meanPara, 60),
+    sat(doubleSpace / nTok, 0.05),
+    sat(newlineRate, 0.02),
+    sat(straightQuote / chars, 0.01),
+    sat(curlyQuote / chars, 0.01),
+    sat(apostrophe / chars, 0.02),
+    sat(emoji / chars, 0.005),
+    sat(repeatRun / nTok, 0.01),
+    sat(loneI / nW, 0.02),
+    sat(multiPunct / chars, 0.005),
+    sat(ellipsis / chars, 0.005),
+    sat(parenRate, 0.02),
+    sat(dashRate, 0.02),
+    sat(digitRate, 0.05),
+    sat(meanWordLen, 5),
+    ttr,
+  ];
+}
+export const N_SCALAR = 22;
+
+// ---- char-affix n-grams (prefix/suffix 3-grams) — topic-robust morphology -----------
+// We fix a key list per fold (the harness passes them in). Returns rel-freq over keys.
+export function affixCounts(text) {
+  const toks = (String(text).toLowerCase().match(/[a-z']{2,}/g) || []);
+  const pre = Object.create(null);
+  const suf = Object.create(null);
+  for (const t of toks) {
+    if (t.length >= 4) {
+      const p = 'P' + t.slice(0, 3);
+      const s = 'S' + t.slice(-3);
+      pre[p] = (pre[p] || 0) + 1;
+      suf[s] = (suf[s] || 0) + 1;
+    }
+  }
+  return { pre, suf, nTok: toks.length || 1 };
+}
+export function relFreqAffix(text, keys) {
+  const { pre, suf, nTok } = affixCounts(text);
+  return keys.map((k) => ((k[0] === 'P' ? pre[k] : suf[k]) || 0) / nTok);
+}
+
+// ---- z-standardize against an INJECTED reference (DEV-derived) ----------------------
+function zStd(raw, mean, sd) {
+  const out = Array.from({ length: raw.length });
+  for (let i = 0; i < raw.length; i += 1) {
+    let z = (raw[i] - mean[i]) / (sd[i] || 1e-6);
+    if (z > Z_CAP) z = Z_CAP; else if (z < -Z_CAP) z = -Z_CAP;
+    out[i] = z;
+  }
+  return out;
+}
+
+// Per-chunk full feature object. `ref` = { funcMean, funcSd, triMean, triSd, punctMean,
+// punctSd, scalarMean, scalarSd, affixKeys, affixMean, affixSd } built by the harness
+// from DEV held-out authors. Families are kept SEPARATE so the pair stage can compute a
+// per-family Burrows-Delta.
+export function chunkFeatures(text, ref) {
+  const func = zStd(relFreqFunc(text, FUNCTION_WORDS), ref.funcMean, ref.funcSd);
+  const tri = zStd(relFreqTrigrams(text, TRIGRAM_KEYS), ref.triMean, ref.triSd);
+  const punct = zStd(relFreqPunct(text, PUNCT_KEYS), ref.punctMean, ref.punctSd);
+  const scalar = zStd(topicRobustScalars(text), ref.scalarMean, ref.scalarSd);
+  const affix = ref.affixKeys && ref.affixKeys.length
+    ? zStd(relFreqAffix(text, ref.affixKeys), ref.affixMean, ref.affixSd)
+    : [];
+  return { func, tri, punct, scalar, affix };
+}
+
+export const FAMILIES = ['func', 'tri', 'punct', 'scalar', 'affix'];
+
+export { topicRobustScalars };

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

@@ -0,0 +1,74 @@
+// verifier-logreg.mjs — Gate B v3. Plain-JS L2 logistic regression (batch gradient
+// descent) over standardized pair-summary features. ZERO deps. Trains on same- vs
+// different-author pair vectors; predicts P(same-author). That probability becomes the
+// verifier score fed (as distance = 1 - p) into validateInstrument.
+
+// Standardizer fit on TRAIN features only (mean/sd per column), applied to val.
+export function fitStandardizer(rows) {
+  const d = rows[0].length;
+  const mean = new Float64Array(d);
+  const sd = new Float64Array(d);
+  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) || 1e-6;
+  return { mean, sd };
+}
+export function applyStandardizer(row, st) {
+  const out = new Float64Array(row.length);
+  for (let j = 0; j < row.length; j += 1) out[j] = (row[j] - st.mean[j]) / st.sd[j];
+  return out;
+}
+
+function sigmoid(z) {
+  if (z >= 0) { const e = Math.exp(-z); return 1 / (1 + e); }
+  const e = Math.exp(z); return e / (1 + e);
+}
+
+// trainLogReg(X, y, opts) — X: array of standardized Float64Array rows, y: 0/1 labels.
+// L2 (lambda) on weights (not bias). Class-balanced sample weights so the (rarer)
+// same-author positives are not swamped by the abundant different-author negatives.
+export function trainLogReg(X, y, opts = {}) {
+  const lambda = opts.lambda ?? 1.0;
+  const lr = opts.lr ?? 0.1;
+  const iters = opts.iters ?? 4000;
+  const n = X.length;
+  const d = X[0].length;
+  const w = new Float64Array(d);
+  let b = 0;
+
+  const nPos = y.reduce((a, v) => a + v, 0);
+  const nNeg = n - nPos;
+  const wPos = nPos ? n / (2 * nPos) : 1;
+  const wNeg = nNeg ? n / (2 * nNeg) : 1;
+
+  for (let it = 0; it < iters; it += 1) {
+    const gw = new Float64Array(d);
+    let gb = 0;
+    let wsum = 0;
+    for (let i = 0; i < n; i += 1) {
+      const xi = X[i];
+      let z = b;
+      for (let j = 0; j < d; j += 1) z += w[j] * xi[j];
+      const p = sigmoid(z);
+      const sw = y[i] ? wPos : wNeg;
+      const err = (p - y[i]) * sw;
+      for (let j = 0; j < d; j += 1) gw[j] += err * xi[j];
+      gb += err;
+      wsum += sw;
+    }
+    const inv = 1 / (wsum || 1);
+    for (let j = 0; j < d; j += 1) {
+      gw[j] = gw[j] * inv + lambda * w[j] / n;
+      w[j] -= lr * gw[j];
+    }
+    b -= lr * gb * inv;
+  }
+  return { w, b };
+}
+
+export function predictProba(row, model) {
+  let z = model.b;
+  for (let j = 0; j < row.length; j += 1) z += model.w[j] * row[j];
+  return sigmoid(z);
+}