fix(ci): gloss golden suite resolves via committed L&S fixture (M-023i)

test:gloss evals build_glosses.cjs live defs, which load the 30MB
utils/ext_tmp/ L&S dump — gitignored, so CI has none. Every L&S-dependent
golden row resolved null in CI; the step was red from its 2026-08-08
introduction (69 fails, then 67) while staying green locally.

Add utils/build_ls_fixture.cjs + committed utils/ls_golden_fixture.json
(~95 entries / 253 KB: fixpoint closure of the L&S entries the golden rows
can reach, incl. failure-path keys). The test always resolves through the
fixture — identical CI/local semantics — and a local drift guard re-runs
against the full dump and errors ('run npm run build:gloss-fixture') if the
fixture stops reproducing it.

Verified: 2067/2067 with and without utils/ext_tmp/ (CI simulation).

Author: hellpanderrr

wiktionary_pron/CLAUDE.md

@@ -144,6 +144,7 @@ Each of these cost real debugging time in past sessions. Check this list before
 - **Browser Latin ≠ Node Latin**: the browser flow macronizes input first (provinciarum → prōvinciārum), so e2e IPA expectations carry length marks that the Node suite's don't.
 - **RU/UK stress-transfer skips multi-form dictionary entries by design** — test it with a single-form word (голова → голова́), not вода (record "во́да, вода́" has a comma → skipped).
 - **`scripts/tests/init.js` was silently cwd-dependent** — its `fs.readFile` resolved `../../lua_modules/...` against `process.cwd()`, so the IPA suite only ran from `scripts/tests/`. Fixed 2026-08-06 by anchoring `LUA_ROOT` to the module path; keep it cwd-independent (coverage runs it from the repo root).
+- **The gloss golden suite evals `build_glosses.cjs` live defs, so it inherits every file dependency the build has** — including `utils/ext_tmp/ls_*.json` (30MB L&S, gitignored). CI has no `ext_tmp`, so `test:gloss` was red in CI from the day it was added (2026-08-08) while staying green locally. Fixed 2026-08-12: the test resolves through the **committed fixture** `utils/ls_golden_fixture.json` (~95 entries, `npm run build:gloss-fixture` regenerates from ext_tmp); a local drift guard errors if the fixture stops reproducing the full dump. **After editing `utils/gloss_golden.json` or the extractor's L&S keys, regenerate the fixture in the same commit** or CI stays red.
 
 **Dictionary-gloss traps** (2026-08-07, M-005 research)
 - **Perseus tag gender is at index 6, not index 3.** `n-s---fn-` → gender is `tag[6]` (`f`), `tag[3]` (`s`) is number/subcategorization. Reading `tag[3]` makes gender always empty and silently collapses (lemma|POS|gender) to (lemma|POS).

wiktionary_pron/docs/LESSONS.md

@@ -718,3 +718,11 @@ Catilinam I, Vergil Aeneid I, Ovid Metamorphoses I.
   details open — popup stays inside the viewport.
 - **Lesson.** Any non-bubbling structural event on dynamically-rebuilt DOM needs
   a "wire after every rebuild" helper, not a one-time delegated listener.
+
+## The golden gloss suite never ran in CI — it needed the gitignored 30MB L&S dump (2026-08-12)
+
+- **Symptom.** CI `node-tests` failing only on `test:gloss`: `2000 passed, 67 failed`, every `got: null`. Locally green. `e2e`, `unit`, `ipa`, `census` all fine.
+- **Root cause.** `test_gloss_regression.cjs` evals the head of `build_glosses.cjs` and resolves golden rows through the extractor's **live defs**. Those defs populate `lsByKey` from `utils/ext_tmp/ls_*.json` — the 30MB Lewis & Short dump, **gitignored** ("build input, not shipped"). A fresh CI checkout has no `ext_tmp`, so every L&S-dependent lemma (`terra`, `qui`, `venio`, the numbered homographs…) resolved to `null`. The suite was added 2026-08-08 and **both** CI runs since failed — it had simply never been green. Nothing caught it because `npm test` is green locally, where the 30MB sits on disk.
+- **Lesson.** A test that evals production build code inherits every file dependency that code has. If any of those files are gitignored, the test can only ever be green on the author's machine. CI is the truth-teller: check what a fresh checkout actually has.
+- **Fix.** `utils/build_ls_fixture.cjs` extracts the ~95 Lewis & Short entries the 2067 golden rows can *reach* (fixpoint over the eval'd defs, growing by missed-key base-families → 253KB) into **committed** `utils/ls_golden_fixture.json`. The test always resolves through the fixture (`makeDefs(true)`), giving identical semantics in CI and locally; when `utils/ext_tmp/` IS present, a **drift guard** re-runs against the full dump and errors with "run `npm run build:gloss-fixture`" if the fixture stops reproducing it. Regenerate after golden edits: `npm run build:gloss-fixture`, commit the fixture in the same commit.
+- **Lesson.** Two-source divergence is the failure mode to kill: making the committed fixture the *authoritative* source (not "full data locally, fixture in CI") is what prevents "passes locally, red in CI". The drift guard only exists to catch the fixture going stale locally, before it ships.

wiktionary_pron/package.json

@@ -15,6 +15,7 @@
     "test:gloss": "node utils/test_gloss_regression.cjs",
     "test:census": "node utils/gloss_census.cjs",
     "build:gloss": "node utils/build_glosses.cjs",
+    "build:gloss-fixture": "node utils/build_ls_fixture.cjs",
     "serve": "http-server .. -p 8993 -s",
     "build:ext": "node utils/sync_extension.cjs"
   },

wiktionary_pron/utils/build_ls_fixture.cjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+// Build utils/ls_golden_fixture.json — the minimal Lewis & Short entry set the
+// golden suite touches, so `npm run test:gloss` runs in CI, where the 30MB
+// utils/ext_tmp/ L&S dump is deliberately NOT committed (gitignore: "build input
+// ... not shipped"). The test resolves every golden row through the LIVE defs of
+// build_glosses.cjs, so it needs real L&S entries; the fixture supplies exactly
+// the ones the 2067+ rows can reach — including the failure-path entries a
+// resolve() only touches when an earlier lookup misses (the "vestitus2" class).
+//
+//   node utils/build_ls_fixture.cjs
+//
+// Regenerate after adding/editing rows in utils/gloss_golden.json that touch new
+// L&S lemmas, or after the extractor starts reading different keys. Commit the
+// regenerated utils/ls_golden_fixture.json in the same commit as the golden edit.
+// Needs utils/ext_tmp/ on disk — run locally, never in CI.
+//
+// Method: fixpoint over the eval'd defs. Start with an empty selected set and
+// repeatedly (1) eval the defs with only the selected entries loaded, (2) run
+// every golden row through resolve(), recording every lsByKey key it looked for
+// but missed, (3) add the whole base-family of each missed key. Grows until no
+// new entries appear — by construction the committed fixture reproduces the full
+// 30MB dump for every golden row (enforced as a drift guard by
+// test_gloss_regression.cjs when utils/ext_tmp/ is present locally).
+
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+
+const GOLDEN = "utils/gloss_golden.json";
+const OUT = "utils/ls_golden_fixture.json";
+const EXTRACT_ROOT = path.join("utils", "ext_tmp");
+
+// ---- full L&S dump (local only) ----
+const lsAll = new Map();
+for (const c of "ABCDEFGHIJKLMNOPQRSTUVXYZ") {
+  const p = path.join(EXTRACT_ROOT, `ls_${c}.json`);
+  if (!fs.existsSync(p)) continue;
+  for (const e of JSON.parse(fs.readFileSync(p, "utf8"))) {
+    if (e && e.key) lsAll.set(String(e.key).toLowerCase(), e);
+  }
+}
+if (!lsAll.size) {
+  console.error(`${EXTRACT_ROOT}/ has no L&S data — run this locally, not in CI.`);
+  process.exit(1);
+}
+// base ("mora", digits stripped) → all keys in that family, for O(1) closure.
+const famByBase = new Map();
+for (const ek of lsAll.keys()) {
+  const b = ek.replace(/\d+$/, "");
+  if (!famByBase.has(b)) famByBase.set(b, []);
+  famByBase.get(b).push(ek);
+}
+
+// ---- eval the extractor defs with the L&S load redirected to a global array ----
+const src = fs.readFileSync("utils/build_glosses.cjs", "utf8");
+const head = src.slice(0, src.indexOf("// ---- build ----"));
+const LS_BLOCK_RE = /\/\/ ---- L&S index ----\nconst lsByKey = new Map\(\), lsByBase = new Map\(\);\n[\s\S]*?\n\}\n/;
+const WL_BLOCK = `const rows = new Map();
+const formSets = new Map();
+const lemmaPosCount = new Map();
+for (const line of fs.readFileSync("macronizer/macrons.txt","utf8").split("\\n")) {
+  const p = line.split("\\t"); if (p.length<4) continue;
+  const lem = p[2].toLowerCase();
+  rows.set(p[2]+"|"+p[1], {lemma:p[2], tag:p[1]});
+  if (!formSets.has(lem)) formSets.set(lem, new Set());
+  formSets.get(lem).add(p[0]+"|"+p[3]);
+  const pos = POS_MAP[p[1][0]] || p[1][0];
+  if (!lemmaPosCount.has(lem)) lemmaPosCount.set(lem, {});
+  lemmaPosCount.get(lem)[pos] = (lemmaPosCount.get(lem)[pos]||0)+1;
+}
+`;
+function makeDefs() {
+  if (!LS_BLOCK_RE.test(head)) {
+    throw new Error("build_glosses.cjs L&S load changed — update LS_BLOCK_RE in " + __filename);
+  }
+  let d = head
+    .replace(WL_BLOCK, "var rows = new Map(), formSets = new Map(), formSetsTag = new Map(), lemmaPosCount = new Map();\n")
+    .replace(LS_BLOCK_RE, `// ---- L&S index (fixture source) ----
+var lsByKey = new Map(), lsByBase = new Map();
+for (const e of globalThis.__LS_SOURCE__) {
+  if (!e || !e.key) continue;
+  const key = String(e.key).toLowerCase();
+  lsByKey.set(key, e);
+  const base = key.replace(/\\d+$/, "");
+  if (!lsByBase.has(base)) lsByBase.set(base, []);
+  lsByBase.get(base).push(e);
+}
+`);
+  d = d.replace(/^const \{ createEngine \} = .*$/gm, "").replace(/^const (fs|path|zlib|engine) = .*$/gm, "").replace(/^const engine = .*$/gm, "");
+  d = d.replace(/\bconst\s+/g, "var ").replace(/\blet\s+/g, "var ");
+  return d;
+}
+const defs = makeDefs();
+const golden = JSON.parse(fs.readFileSync(GOLDEN, "utf8"));
+
+function loadCache() {
+  const cache = JSON.parse(zlib.gunzipSync(fs.readFileSync("utils/gloss_lemma_cache.json.gz")));
+  for (const [lem, e] of Object.entries(cache)) {
+    if (e.forms) formSets.set(lem, new Set(e.forms));
+    if (e.formsTag) formSetsTag.set(lem, new Set(e.formsTag));
+  }
+  for (const [lem, e] of Object.entries(cache)) lemmaPosCount.set(lem, e.pos);
+  const origDominantPos = dominantPos;
+  dominantPos = function (l) {
+    const cnt = lemmaPosCount.get(l);
+    if (!cnt) return origDominantPos(l);
+    let best = null, bestN = 0;
+    for (const [p, n] of Object.entries(cnt)) if (n > bestN) { best = p; bestN = n; }
+    return best || "N";
+  };
+}
+
+// ---- fixpoint ----
+let selected = new Set();
+for (let iter = 0; ; iter++) {
+  if (iter > 60) { console.error("fixture fixpoint did not converge"); process.exit(1); }
+  globalThis.__LS_SOURCE__ = [...selected].map((k) => lsAll.get(k));
+  eval(defs);
+  loadCache();
+  // record every lsByKey lookup that came up empty
+  const miss = new Set();
+  const origGet = lsByKey.get.bind(lsByKey);
+  lsByKey.get = function (k) {
+    if (k != null && !lsByKey.has(String(k))) miss.add(String(k));
+    return origGet(k);
+  };
+  for (const row of golden) {
+    try { resolve(row.lemma, dominantPos(row.lemma.toLowerCase())); } catch (e) {}
+  }
+  let added = 0;
+  for (const k of miss) {
+    for (const ek of famByBase.get(k.replace(/\d+$/, "")) || []) {
+      if (!selected.has(ek)) { selected.add(ek); added++; }
+    }
+  }
+  if (added === 0) break;
+  console.log(`iter ${iter}: ${selected.size} entries (+${added})`);
+}
+
+const out = [...selected].sort().map((k) => lsAll.get(k));
+fs.writeFileSync(OUT, JSON.stringify(out));
+const kb = Math.round(fs.statSync(OUT).size / 1024);
+console.log(`wrote ${OUT}: ${out.length} entries, ${kb} KB (of ${lsAll.size} total)`);

wiktionary_pron/utils/ls_golden_fixture.json

@@ -3,6 +3,13 @@
 // expectations in utils/gloss_golden.json are resolved through the LIVE defs of
 // utils/build_glosses.cjs (same eval trick as _probe_one.cjs) — no 6-minute build.
 //
+// The L&S source is the COMMITTED fixture utils/ls_golden_fixture.json (the 30MB
+// utils/ext_tmp/ dump is gitignored, so CI has no L&S data), giving the suite
+// IDENTICAL semantics in CI and locally. Regenerate the fixture after golden
+// edits with `npm run build:gloss-fixture` and commit it alongside. When
+// utils/ext_tmp/ IS present locally, a drift guard re-runs against the full dump
+// and fails if the fixture no longer reproduces it (see utils/build_ls_fixture.cjs).
+//
 // The wordlist parse (macrons.txt, 812k lines) is cached in
 // utils/gloss_lemma_cache.json.gz so a run is ~1-2s, not ~4s+3.3s.
 //
@@ -41,9 +48,37 @@ for (const line of fs.readFileSync("macronizer/macrons.txt","utf8").split("\\n")
 }
 `;
 let defs = head.replace(WL_BLOCK, "var rows = new Map(), formSets = new Map(), formSetsTag = new Map(), lemmaPosCount = new Map();\n");
-defs = defs.replace(/^const \{ createEngine \} = .*$/gm, "").replace(/^const (fs|path|zlib|engine) = .*$/gm, "").replace(/^const engine = .*$/gm, "");
-defs = defs.replace(/\bconst\s+/g, "var ").replace(/\blet\s+/g, "var ");
-eval(defs);
+const FIXTURE = "utils/ls_golden_fixture.json";
+const hasFullLs = fs.existsSync(path.join("utils", "ext_tmp"));
+// ---- L&S source = the committed fixture (see build_ls_fixture.cjs) ----
+const LS_BLOCK_RE = /\/\/ ---- L&S index ----\nconst lsByKey = new Map\(\), lsByBase = new Map\(\);\n[\s\S]*?\n\}\n/;
+const LS_FIXTURE_BLOCK = `// ---- L&S index (CI fixture: utils/ls_golden_fixture.json) ----
+var lsByKey = new Map(), lsByBase = new Map();
+for (const e of JSON.parse(fs.readFileSync("utils/ls_golden_fixture.json", "utf8"))) {
+  if (!e || !e.key) continue;
+  const key = String(e.key).toLowerCase();
+  lsByKey.set(key, e);
+  const base = key.replace(/\\d+$/, "");
+  if (!lsByBase.has(base)) lsByBase.set(base, []);
+  lsByBase.get(base).push(e);
+}
+`;
+function makeDefs(useFixture) {
+  let d = head.replace(WL_BLOCK, "var rows = new Map(), formSets = new Map(), formSetsTag = new Map(), lemmaPosCount = new Map();\n");
+  if (useFixture) {
+    if (!LS_BLOCK_RE.test(d)) throw new Error("build_glosses.cjs L&S load changed — update LS_BLOCK_RE in " + __filename);
+    d = d.replace(LS_BLOCK_RE, LS_FIXTURE_BLOCK);
+  }
+  d = d.replace(/^const \{ createEngine \} = .*$/gm, "").replace(/^const (fs|path|zlib|engine) = .*$/gm, "").replace(/^const engine = .*$/gm, "");
+  d = d.replace(/\bconst\s+/g, "var ").replace(/\blet\s+/g, "var ");
+  return d;
+}
+if (!fs.existsSync(FIXTURE)) {
+  console.error(`Missing ${FIXTURE} — run \`npm run build:gloss-fixture\` locally (needs utils/ext_tmp/) and commit it.`);
+  process.exit(1);
+}
+// Authoritative pass always uses the fixture → identical semantics in CI and locally.
+eval(makeDefs(true));
 
 // ---- wordlist cache ----
 if (process.argv.includes("--rebuild-cache") || !fs.existsSync(CACHE)) {
@@ -72,60 +107,90 @@ if (process.argv.includes("--rebuild-cache") || !fs.existsSync(CACHE)) {
   console.log(`cached ${Object.keys(out).length} lemmas`);
 }
 
-const cache = JSON.parse(zlib.gunzipSync(fs.readFileSync(CACHE)));
-for (const [lem, e] of Object.entries(cache)) {
-  if (e.forms) formSets.set(lem, new Set(e.forms));
-  if (e.formsTag) formSetsTag.set(lem, new Set(e.formsTag));
+function loadWordlistCache() {
+  const cache = JSON.parse(zlib.gunzipSync(fs.readFileSync(CACHE)));
+  for (const [lem, e] of Object.entries(cache)) {
+    if (e.forms) formSets.set(lem, new Set(e.forms));
+    if (e.formsTag) formSetsTag.set(lem, new Set(e.formsTag));
+  }
+  // dominantPos reads lemmaPosCount — rebuild it faithfully, then override dominantPos
+  for (const [lem, e] of Object.entries(cache)) lemmaPosCount.set(lem, e.pos);
+  const origDominantPos = dominantPos;
+  dominantPos = function (l) {
+    const cnt = lemmaPosCount.get(l);
+    if (!cnt) return origDominantPos(l);
+    let best = null, bestN = 0;
+    for (const [p, n] of Object.entries(cnt)) if (n > bestN) { best = p; bestN = n; }
+    return best || "N";
+  };
+  return cache;
 }
-// dominantPos reads lemmaPosCount — rebuild it faithfully, then override dominantPos
-for (const [lem, e] of Object.entries(cache)) lemmaPosCount.set(lem, e.pos);
-const origDominantPos = dominantPos;
-dominantPos = function (l) {
-  const cnt = lemmaPosCount.get(l);
-  if (!cnt) return origDominantPos(l);
-  let best = null, bestN = 0;
-  for (const [p, n] of Object.entries(cnt)) if (n > bestN) { best = p; bestN = n; }
-  return best || "N";
-};
+const cache = loadWordlistCache();
 
 // ---- golden suite ----
 const golden = JSON.parse(fs.readFileSync(GOLDEN, "utf8"));
-let pass = 0, fail = 0;
-const fails = [];
+const norm = (s) => (s || "").toLowerCase().replace(/[.,;]$/, "").replace(/\s+/g, " ").trim();
 let engine = null;
 // CORE_GLOSS keys must each have a golden row — a curated override with no
 // regression gate would silently rot (monotone rule: every override gets a golden
 // row in the same commit). No-op when utils/core_gloss.json doesn't exist yet.
 const coreGlossPath = "utils/core_gloss.json";
+const coreFails = [];
 if (fs.existsSync(coreGlossPath)) {
   const core = JSON.parse(fs.readFileSync(coreGlossPath, "utf8"));
   const covered = new Set(golden.map(r => r.lemma.toLowerCase()));
   for (const k of Object.keys(core)) {
-    if (!covered.has(k)) { fail++; fails.push({ lemma: k, expect: { contains: core[k] }, got: "(no golden row)", note: "core_gloss override missing from golden suite" }); }
+    if (!covered.has(k)) coreFails.push({ lemma: k, expect: { contains: core[k] }, got: "(no golden row)", note: "core_gloss override missing from golden suite" });
   }
   for (const row of golden) {
     if (core[row.lemma] && row.expect !== null && !evalExpect(row.expect, core[row.lemma], (s)=>(s||"").toLowerCase())) {
-      fail++; fails.push({ lemma: row.lemma, expect: row.expect, got: core[row.lemma], note: "core_gloss override contradicts golden expectation" });
+      coreFails.push({ lemma: row.lemma, expect: row.expect, got: core[row.lemma], note: "core_gloss override contradicts golden expectation" });
     }
   }
 }
-for (const row of golden) {
-  const { lemma, expect, note, wordsOnly } = row;
-  let got = null;
-  try {
-    const pos = dominantPos(lemma.toLowerCase());
-    got = resolve(lemma, pos);
-    if (!got && wordsOnly) {
-      // WORDS-only fallback path (gender-tolerant): lazily init the engine.
-      if (!engine) engine = require("whitakers-words/node").createEngine();
-      got = wGloss(lemma, pos, "");
+function runGoldenSuite() {
+  const fails = [];
+  let pass = 0;
+  for (const row of golden) {
+    const { lemma, expect, note, wordsOnly } = row;
+    let got = null;
+    try {
+      const pos = dominantPos(lemma.toLowerCase());
+      got = resolve(lemma, pos);
+      if (!got && wordsOnly) {
+        // WORDS-only fallback path (gender-tolerant): lazily init the engine.
+        if (!engine) engine = require("whitakers-words/node").createEngine();
+        got = wGloss(lemma, pos, "");
+      }
+    } catch (e) { got = "ERROR: " + e.message; }
+    if (evalExpect(expect, got, norm)) pass++;
+    else fails.push({ lemma, expect, got, note });
+  }
+  return { pass, fails };
+}
+// The authoritative run resolves through the fixture (identical in CI and locally).
+const main = runGoldenSuite();
+
+// ---- drift guard (local only): the full 30MB dump must reproduce the fixture ----
+// Re-eval with the full dump whenever it exists (so --tier=full below still
+// resolves against real L&S); compare against the fixture only in normal mode.
+if (hasFullLs) {
+  eval(makeDefs(false));
+  loadWordlistCache();
+  if (!process.argv.includes("--tier=full")) {
+    const full = runGoldenSuite();
+    const stale = main.fails.filter(f => !full.fails.some(g => g.lemma === f.lemma));
+    if (stale.length) {
+      console.error(`\nL&S fixture STALE: ${stale.length} rows pass with utils/ext_tmp/ but not with ${FIXTURE}.`);
+      console.error(`Run \`npm run build:gloss-fixture\` and commit the regenerated fixture.`);
+      for (const s of stale) console.error(`  ${s.lemma}: expect ${JSON.stringify(s.expect)} got ${JSON.stringify(s.got)}`);
     }
-  } catch (e) { got = "ERROR: " + e.message; }
-  const norm = (s) => (s || "").toLowerCase().replace(/[.,;]$/, "").replace(/\s+/g, " ").trim();
-  const ok = evalExpect(expect, got, norm);
-  if (ok) { pass++; }
-  else { fail++; fails.push({ lemma, expect, got, note }); }
+  }
 }
+
+const fails = [...coreFails, ...main.fails];
+const fail = fails.length;
+const pass = golden.length - main.fails.length;
 console.log(`\n${pass} passed, ${fail} failed (${golden.length} total)`);
 for (const f of fails) {
   console.log(`\nFAIL ${f.lemma}  (${f.note || ""})`);