@polycode-projects/the-mechanical-code-talker 2.3.0 → 2.5.0

package/corpus/wordnet/generate.mjs

@@ -1,332 +0,0 @@
-#!/usr/bin/env node
-// corpus/wordnet/generate.mjs — converts a LOCAL Open English WordNet (OEWN)
-// checkout into ConceptNet-shape fact rows. Curated + committed, tier-2-shaped
-// — NOT "tier-3" (corpus/README.md's tiering policy already uses that name
-// for something else, runtime-learned facts that are never committed); this
-// bundle is just too large to hand-author like the other tier-2 corpuses.
-// NOT part of the product path — a maintainer tool, run by hand, offline, $0;
-// its OUTPUT (corpus/wordnet/wordnet-{xl,full}.jsonl + manifest.json) is what
-// gets committed, never the source YAML itself.
-//
-//   node corpus/wordnet/generate.mjs [yamlDir]
-//   TMCT_WORDNET_YAML_DIR=/path/to/yaml node corpus/wordnet/generate.mjs
-//
-// Input: `~/projects/globalwordnet/english-wordnet/src/yaml/` by default (a
-// LOCAL clone, never vendored/committed — CC-BY-4.0, see LICENSE-NOTICE in
-// this directory) — Princeton WordNet's 107,526 synsets across
-// `noun.*.yaml`/`verb.*.yaml`/`adj.*.yaml`/`adv.*.yaml` (45 of the checkout's
-// 73 yaml files; the other 28 are `entries-<letter>.yaml` word-form indexes
-// this converter doesn't need — synset records alone carry every relation and
-// member list this converter reads).
-//
-// Two passes, same discipline as corpus/conceptnet/fetch-slice.mjs and
-// corpus/tier2/generate.mjs (deterministic, sorted, one JSON object per
-// line, `{start, rel, end, weight, surfaceText}` — the exact tier-1 slice
-// shape):
-//   1. load every synset (across ALL 45 files) into one global
-//      synsetId -> record map — synset ids ("00034778-n") are globally
-//      unique, POS suffix included, so a single flat Map is correct.
-//   2. walk every synset's structural relations + its own `members` list,
-//      emitting one row per edge (see RELATION_MAP / synonymPairs below).
-//
-// The hand-rolled `parseYaml` this file reuses (imported, not duplicated) is
-// src/domain/wordnet/yaml.mjs's tiny YAML-subset reader — already proven
-// against this exact OEWN dump shape by the persona-tier tooling. Reusing it
-// (rather than adding a general YAML dependency, or re-deriving a second
-// hand-rolled parser) keeps this converter self-consistent with the rest of
-// the tooling that already reads this same source.
-//
-// Licence: Open English WordNet content is CC-BY-4.0 (Princeton WordNet +
-// Open English Wordnet team) — see LICENSE-NOTICE in this directory. The
-// code in this file is tmct code under the repository's MPL-2.0; only the
-// generated data (corpus/wordnet/*.jsonl) carries CC-BY-4.0.
-
-import { readFile, readdir, writeFile, mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { createHash } from "node:crypto";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { parseYaml } from "../../src/domain/wordnet/yaml.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-export const WORDNET_OUT_DIR = HERE;
-
-export const DEFAULT_YAML_DIR = join(homedir(), "projects", "globalwordnet", "english-wordnet", "src", "yaml");
-
-/** Resolve the input yaml directory: CLI positional arg > env var > default.
- *  Exposed as a pure function (argv/env injectable) so it's unit-testable
- *  without touching real process.argv/env. */
-export function resolveYamlDir(argv = process.argv.slice(2), env = process.env) {
-  return argv[0] || env.TMCT_WORDNET_YAML_DIR || DEFAULT_YAML_DIR;
-}
-
-// ---- relation mapping table (pure, unit-tested) ----------------------------
-// WordNet relation key -> { rel: ConceptNet relation URI, flip }. `flip`
-// governs which side of the WordNet edge becomes ConceptNet's `start` vs
-// `end` — WordNet's meronymy relations point WHOLE -> part (the synset that
-// OWNS a `mero_part`/`mero_member` list is the whole; its listed target is
-// the part/member — confirmed via scripts/wordnet.py's own
-// inverse_synset_rels table: mero_part's inverse is holo_part, so "A mero_part
-// B" reads "B is a part-meronym of A", i.e. A HAS PART B), which is the
-// OPPOSITE of ConceptNet's own /r/PartOf convention (start=part, end=whole —
-// confirmed against a real corpus/conceptnet/slice.jsonl row: "action PartOf
-// keyboard" — action, the PART, is start). mero_part/mero_member both need
-// `flip: true` for exactly this reason. mero_substance needs NO flip:
-// ConceptNet's /r/MadeOf is start=whole, end=substance (confirmed against
-// slice.jsonl's "computer MadeOf hardware" — computer, the WHOLE, is start),
-// which already matches WordNet's own A(whole) -> mero_substance -> B
-// (substance) direction untouched. hypernym/causes/attribute/similar/also
-// are all natural A->B mappings with no direction conflict (the specific
-// synset/adjective source relation IS the ConceptNet start side already).
-export const RELATION_MAP = Object.freeze({
-  hypernym: { rel: "/r/IsA", flip: false },
-  mero_part: { rel: "/r/PartOf", flip: true },
-  mero_member: { rel: "/r/PartOf", flip: true },
-  mero_substance: { rel: "/r/MadeOf", flip: false },
-  causes: { rel: "/r/Causes", flip: false },
-  attribute: { rel: "/r/HasProperty", flip: false },
-  similar: { rel: "/r/SimilarTo", flip: false },
-  also: { rel: "/r/RelatedTo", flip: false },
-});
-
-// Deliberately excluded — no mapped ConceptNet relation, and task scope is to
-// use ONLY the relations Phase 1 already added to conceptnet-map.toml, never
-// invent a new map row: `entails` (verb implication — no ConceptNet analog)
-// and `exemplifies` (instance-of-category — closest is /r/IsA, but that would
-// blur "kind of" and "example of", a real semantic difference ConceptNet
-// itself keeps separate via /r/InstanceOf, which conceptnet-map.toml doesn't
-// carry). `definition`/`example` are free prose, never structured facts.
-export const SKIPPED_RELATIONS = Object.freeze(["entails", "exemplifies"]);
-
-// ---- term encoding (pure, unit-tested) -------------------------------------
-// Exact inverse of src/adapters/corpus/conceptnet.mjs's termText() decode
-// (`/^\/c\/en\/([^/]+)/` then `.replace(/_/g, " ")`): lowercase, spaces ->
-// underscores, wrapped as `/c/en/<term>`. Nothing else is touched — any other
-// punctuation (apostrophes, hyphens) round-trips through termText() unchanged
-// because termText only ever substitutes underscores back to spaces.
-export function encodeTerm(raw) {
-  const t = String(raw ?? "").trim().toLowerCase().replace(/\s+/g, "_");
-  return t ? `/c/en/${t}` : null;
-}
-
-/** `/c/en/ice_cream` -> "ice cream" — the human-readable form used in
- *  surfaceText, mirroring corpus/tier2/generate.mjs's own `humanize`. */
-export const humanize = (term) => String(term ?? "").replace(/_/g, " ");
-
-// ---- synonym chaining (pure, unit-tested) ----------------------------------
-// A synset's `members` list are synonyms of each other. Chained N-1 (member
-// [0] paired with each of member[1..N-1]) rather than the full N*(N-1)/2
-// cross product — members average 1.72/synset (185,149 member-slots across
-// 107,526 synsets), and the chain already connects every member into one
-// component (a synonym-chases-synonym graph read), so the cross product would
-// roughly double the fact count for no new information the chain doesn't
-// already encode transitively.
-export function synonymPairs(members) {
-  if (!Array.isArray(members) || members.length < 2) return [];
-  const [first, ...rest] = members;
-  return rest.map((m) => [first, m]);
-}
-
-// ---- pass 1: load every synset across every yaml file ----------------------
-const SYNSET_FILE_RE = /^(noun|verb|adj|adv)\..+\.yaml$/;
-
-export async function loadAllSynsets(yamlDir) {
-  const all = await readdir(yamlDir);
-  const files = all.filter((f) => SYNSET_FILE_RE.test(f)).sort();
-  if (!files.length) {
-    throw new Error(`${yamlDir}: no noun./verb./adj./adv. yaml files found — wrong path?`);
-  }
-  const bySynset = new Map();
-  for (const f of files) {
-    const text = await readFile(join(yamlDir, f), "utf8");
-    const parsed = parseYaml(text);
-    for (const [id, rec] of Object.entries(parsed)) bySynset.set(id, rec);
-  }
-  return { bySynset, files };
-}
-
-const repTerm = (synset) => {
-  const m = Array.isArray(synset?.members) ? synset.members : [];
-  return m.length ? m[0] : null;
-};
-
-// ---- pass 2: synset map -> deduped, sorted ConceptNet-shape rows -----------
-
-function makeRowBuilder() {
-  const rows = new Map(); // dedupe key -> row
-  const add = (rawSubject, rel, rawObject) => {
-    const start = encodeTerm(rawSubject);
-    const end = encodeTerm(rawObject);
-    if (!start || !end || start === end) return; // self-loop / empty term — noise, not a fact
-    const key = `${rel} ${start} ${end}`;
-    if (rows.has(key)) return;
-    rows.set(key, {
-      start,
-      rel,
-      end,
-      weight: 1,
-      surfaceText: `[[${humanize(rawSubject)}]] ${rel.replace("/r/", "")} [[${humanize(rawObject)}]]`,
-    });
-  };
-  return { rows, add };
-}
-
-const sortRows = (rows) => rows.slice().sort((a, b) => (
-  a.rel !== b.rel ? (a.rel < b.rel ? -1 : 1)
-    : a.start !== b.start ? (a.start < b.start ? -1 : 1)
-      : a.end < b.end ? -1 : a.end > b.end ? 1 : 0
-));
-
-/** Every structural + synonym-chain fact, deterministically sorted — the
- *  wordnet-full.jsonl content. */
-export function buildFullFacts(bySynset) {
-  const { rows, add } = makeRowBuilder();
-  for (const synset of bySynset.values()) {
-    const A = repTerm(synset);
-    if (!A) continue;
-    for (const [wnRel, { rel, flip }] of Object.entries(RELATION_MAP)) {
-      const targets = Array.isArray(synset[wnRel]) ? synset[wnRel] : [];
-      for (const targetId of targets) {
-        const B = repTerm(bySynset.get(targetId));
-        if (!B) continue;
-        if (flip) add(B, rel, A); else add(A, rel, B);
-      }
-    }
-    for (const [m0, mi] of synonymPairs(synset.members)) add(m0, "/r/Synonym", mi);
-  }
-  return sortRows([...rows.values()]);
-}
-
-// ---- XL slice: hypernym backbone + synonym chains for the most commonly-
-// referenced synsets, budget-bounded ----------------------------------------
-
-/** How many times each synset appears as a hypernym TARGET — a synset's
- *  "commonly referenced" proxy: a category many other synsets specialize
- *  (e.g. "person", "act", "object") is referenced far more often than a
- *  narrow leaf synset. */
-export function hypernymRefCounts(bySynset) {
-  const refCount = new Map();
-  for (const synset of bySynset.values()) {
-    const targets = Array.isArray(synset.hypernym) ? synset.hypernym : [];
-    for (const t of targets) refCount.set(t, (refCount.get(t) || 0) + 1);
-  }
-  return refCount;
-}
-
-/** Build the bounded XL slice: the `budget` fact rows are split between the
- *  hypernym backbone and synonym chains in the SAME proportion the full
- *  corpus's real hypernym-edge-count : synonym-chain-fact-count ratio has
- *  (measured from `full`, not a hand-picked constant) — the backbone gets the
- *  hypernym edges whose TARGET is most commonly referenced first; the
- *  synonym budget goes to the full chain of the most commonly-referenced
- *  synsets (same ranking), walked in ranked order until the budget is spent. */
-export function buildXlFacts(bySynset, full, budget = 24000) {
-  const refCount = hypernymRefCounts(bySynset);
-
-  const hypernymTotal = full.filter((r) => r.rel === "/r/IsA").length;
-  const synonymTotal = full.filter((r) => r.rel === "/r/Synonym").length;
-  const denom = hypernymTotal + synonymTotal || 1;
-  const hypernymBudget = Math.round(budget * (hypernymTotal / denom));
-  const synonymBudget = budget - hypernymBudget;
-
-  // Backbone: every hypernym EDGE (not yet a fact row), ranked by how
-  // commonly-referenced its TARGET synset is, ties broken deterministically.
-  const edges = [];
-  for (const [id, synset] of bySynset) {
-    const targets = Array.isArray(synset.hypernym) ? synset.hypernym : [];
-    for (const t of targets) edges.push({ source: id, target: t });
-  }
-  edges.sort((a, b) => {
-    const byRef = (refCount.get(b.target) || 0) - (refCount.get(a.target) || 0);
-    if (byRef) return byRef;
-    if (a.target !== b.target) return a.target < b.target ? -1 : 1;
-    return a.source < b.source ? -1 : 1;
-  });
-
-  const { rows, add } = makeRowBuilder();
-  for (const { source, target } of edges) {
-    if (rows.size >= hypernymBudget) break;
-    const A = repTerm(bySynset.get(source));
-    const B = repTerm(bySynset.get(target));
-    if (!A || !B) continue;
-    add(A, "/r/IsA", B);
-  }
-
-  // Synonym chains: rank EVERY synset by the same "commonly referenced"
-  // proxy (0 for a synset that never appears as a hypernym target), then walk
-  // down taking each synset's FULL N-1 chain until the synonym budget is met
-  // (a synset's chain is never split — "~budget", not an exact cap).
-  const rankedSynsets = [...bySynset.entries()].sort((a, b) => {
-    const byRef = (refCount.get(b[0]) || 0) - (refCount.get(a[0]) || 0);
-    if (byRef) return byRef;
-    return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
-  });
-  let synonymCount = 0;
-  for (const [, synset] of rankedSynsets) {
-    if (synonymCount >= synonymBudget) break;
-    const pairs = synonymPairs(synset.members);
-    if (!pairs.length) continue;
-    for (const [m0, mi] of pairs) add(m0, "/r/Synonym", mi);
-    synonymCount += pairs.length;
-  }
-
-  return sortRows([...rows.values()]);
-}
-
-// ---- output ------------------------------------------------------------
-
-const toJsonl = (rows) => rows.map((r) => JSON.stringify(r)).join("\n") + "\n";
-const sha256 = (text) => createHash("sha256").update(text).digest("hex");
-
-async function main() {
-  const yamlDir = resolveYamlDir();
-  process.stderr.write(`corpus/wordnet/generate.mjs: reading ${yamlDir}\n`);
-  const { bySynset, files } = await loadAllSynsets(yamlDir);
-  process.stderr.write(`  loaded ${bySynset.size} synsets across ${files.length} files\n`);
-
-  const full = buildFullFacts(bySynset);
-  const xl = buildXlFacts(bySynset, full);
-  process.stderr.write(`  wordnet-full: ${full.length} facts\n`);
-  process.stderr.write(`  wordnet-xl:   ${xl.length} facts\n`);
-
-  await mkdir(WORDNET_OUT_DIR, { recursive: true });
-  const fullText = toJsonl(full);
-  const xlText = toJsonl(xl);
-  await writeFile(join(WORDNET_OUT_DIR, "wordnet-full.jsonl"), fullText);
-  await writeFile(join(WORDNET_OUT_DIR, "wordnet-xl.jsonl"), xlText);
-
-  const manifest = {
-    version: 1,
-    generated: "by corpus/wordnet/generate.mjs",
-    corpuses: [
-      {
-        id: "wordnet-xl",
-        kind: "language",
-        description: "A bounded ~24,000-fact slice of Princeton WordNet / Open English WordNet, prioritizing the hypernym (IsA) backbone and synonym chains for the most commonly-referenced synsets. Mechanically derived from Open English WordNet (CC-BY-4.0).",
-        source: { kind: "curated", tool: "corpus/wordnet/generate.mjs" },
-        file: "wordnet-xl.jsonl",
-        facts: xl.length,
-        bytes: Buffer.byteLength(xlText),
-        sha256: sha256(xlText),
-        license: "CC-BY-4.0",
-      },
-      {
-        id: "wordnet-full",
-        kind: "language",
-        description: "The complete ConceptNet-shape conversion of Princeton WordNet / Open English WordNet's structural relations (hypernym, meronymy, causes, attribute, similar, also) plus member-synonym chains. Derived from Open English WordNet (CC-BY-4.0).",
-        source: { kind: "curated", tool: "corpus/wordnet/generate.mjs" },
-        file: "wordnet-full.jsonl",
-        facts: full.length,
-        bytes: Buffer.byteLength(fullText),
-        sha256: sha256(fullText),
-        license: "CC-BY-4.0",
-      },
-    ],
-  };
-  const manifestText = JSON.stringify(manifest, null, 2) + "\n";
-  await writeFile(join(WORDNET_OUT_DIR, "manifest.json"), manifestText);
-  process.stderr.write(`wrote corpus/wordnet/manifest.json (${manifest.corpuses.length} corpuses)\n`);
-}
-
-const isMain = process.argv[1] && import.meta.url === new URL(`file://${process.argv[1]}`).href;
-if (isMain) await main();

package/src/adapters/prose-tokens.mjs

@@ -1,98 +0,0 @@
-// prose-tokens.mjs — the adapters layer's own tokenizer, shared by every
-// adapter that writes prose tokens (the memory store, graph-build). Adapters
-// may not import the domain layer, while prose.mjs (the graph/ask side's
-// canonical tokenizer) is domain and may not import adapters — so this layer
-// carries its own copy of the primitives it stores tokens with. The two copies
-// must stay byte-identical: the parity suite in
-// test/adapters/prose-tokens.test.mjs pins every function here to its
-// prose.mjs twin, so a change to either side fails loudly until both move
-// together.
-
-const STOPWORDS = new Set(
-  ("a an and or but the of to in on at for with from by as is are was were be been being " +
-    "it its this that these those i you he she they we me my your our do does did not no " +
-    "yes if then else than so such can will would should could may might about into over " +
-    "under out up down off again more most some any all what which who whom whose when " +
-    "where why how").split(/\s+/),
-);
-
-const MAX_TOKEN_LEN = 40;    // drops hash-like/garbage tokens
-const MAX_TOKENS_PER_DOC = 120; // bounds cost on a pathologically long docstring/name
-
-/** Split an identifier or a path-like name into lowercase word tokens.
- *  Handles camelCase, PascalCase, snake_case, kebab-case, dotted names, path
- *  separators, and acronym runs ("HTTPSConnection" -> https/connection,
- *  "parseXML" -> parse/xml). Filters single-character tokens (loop-variable noise). */
-export function splitIdentifierWords(raw) {
-  if (!raw) return [];
-  let s = String(raw).replace(/\.[A-Za-z0-9]+$/, ""); // strip a trailing file extension only
-  s = s
-    .replace(/[/\\]/g, " ")            // path separators
-    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")     // camelCase / word|Digit boundary
-    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")  // acronym run -> TitleCase (HTTPSConnection)
-    .replace(/([A-Za-z])([0-9])/g, "$1 $2")
-    .replace(/([0-9])([A-Za-z])/g, "$1 $2")
-    .replace(/[_\-.]+/g, " ");
-  return s.split(/\s+/).map((w) => w.toLowerCase()).filter((w) => w.length > 1 && w.length <= MAX_TOKEN_LEN);
-}
-
-/** Tokenize free prose (a docstring/doc-comment) — lowercase words, punctuation stripped,
- *  common stopwords and single-/over-length tokens dropped, capped at MAX_TOKENS_PER_DOC. */
-export function tokenizeProse(text) {
-  if (!text) return [];
-  const out = [];
-  const seen = new Set();
-  for (const raw of String(text).toLowerCase().split(/[^a-z0-9]+/)) {
-    if (raw.length < 2 || raw.length > MAX_TOKEN_LEN || STOPWORDS.has(raw)) continue;
-    if (seen.has(raw)) continue;
-    seen.add(raw);
-    out.push(raw);
-    if (out.length >= MAX_TOKENS_PER_DOC) break;
-  }
-  return out;
-}
-
-/** The combined, deduped, sorted token set for one individual: its (decomposed) name
- *  plus any captured doc text. Returns [] if there's nothing to index (never null). */
-export function proseTokensFor({ name, doc } = {}) {
-  const set = new Set([...splitIdentifierWords(name), ...tokenizeProse(doc)]);
-  return [...set].sort();
-}
-
-/** Attach a `prose_tokens` attribute to every individual, from its (decomposed)
- *  name and captured doc text — except Commit, whose `label` is a truncated
- *  SHA, not a decomposable identifier: it tokenizes `message` instead. Mutates
- *  and returns the same array; `enabled=false` is a no-op. */
-export function attachProseTokens(individuals, { enabled = true } = {}) {
-  if (!enabled) return individuals;
-  for (const ind of individuals) {
-    const attrs = ind.attributes || [];
-    const isCommit = ind.class === "Commit";
-    const name = isCommit ? null : ind.label;
-    const doc = isCommit
-      ? attrs.find((a) => a.key === "message")?.value
-      : attrs.find((a) => a.key === "doc")?.value;
-    const tokens = proseTokensFor({ name, doc });
-    if (tokens.length) {
-      ind.attributes = [...(ind.attributes || []), { prop: "mgx:hasProseTokens", key: "prose_tokens", value: tokens.join(" ") }];
-    }
-  }
-  return individuals;
-}
-
-/** Build the inverted index (word -> sorted, deduped [individual ids]) from individuals
- *  that already carry a `prose_tokens` attribute. Plain object, JSON-serializable —
- *  this is what lands as the payload's `proseIndex`. */
-export function buildProseIndex(individuals) {
-  const index = Object.create(null);
-  for (const ind of individuals) {
-    const tokAttr = (ind.attributes || []).find((a) => a.key === "prose_tokens");
-    if (!tokAttr?.value) continue;
-    for (const word of tokAttr.value.split(" ")) {
-      if (!index[word]) index[word] = [];
-      index[word].push(ind.id);
-    }
-  }
-  for (const word of Object.keys(index)) index[word].sort();
-  return index;
-}

package/src/adapters/wordnet-source.mjs

@@ -1,70 +0,0 @@
-// wordnet-source.mjs — reads a LOCAL Open English WordNet clone off disk and
-// indexes it. The clone is never vendored, never committed, never part of the
-// npm package: point TMCT_WORDNET_SRC at it, or keep it at the default path.
-//
-// This is the disk half of the WordNet reader. The parsing half is pure and
-// lives in src/domain/wordnet/yaml.mjs, so it is testable with no clone
-// present; everything here needs the real files.
-
-import { readFile, readdir } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { parseYaml } from "../domain/wordnet/yaml.mjs";
-
-export const WORDNET_SRC = process.env.TMCT_WORDNET_SRC || join(homedir(), "projects", "globalwordnet", "english-wordnet");
-export const WORDNET_YAML_DIR = join(WORDNET_SRC, "src", "yaml");
-
-/** True iff a WordNet clone is readable at `yamlDir`. Callers use this to fail
- *  with a one-line message rather than a stack trace: these are maintainer
- *  tools, never a build dependency. */
-export function hasWordnetSource(yamlDir = WORDNET_YAML_DIR) {
-  return existsSync(yamlDir);
-}
-
-/** Load one or more noun.<x>/verb.<x>.yaml files into a flat synset-id -> record map. */
-export async function loadSynsets(files, yamlDir = WORDNET_YAML_DIR) {
-  const map = new Map();
-  for (const f of files) {
-    const path = join(yamlDir, f);
-    if (!existsSync(path)) continue;
-    const parsed = parseYaml(await readFile(path, "utf8"));
-    for (const [id, rec] of Object.entries(parsed)) map.set(id, rec);
-  }
-  return map;
-}
-
-/** Load the entries-<letter>.yaml files that could contain any of `words`
- *  (only the letters actually needed — 28 files, ~1MB-3MB each, no reason to
- *  load all 28 when a clump only needs a handful of letters). Returns
- *  word -> { n: [{id, synset}], v: [...], a: [...] }. */
-export async function loadEntriesFor(words, yamlDir = WORDNET_YAML_DIR) {
-  const letters = new Set();
-  for (const w of words) {
-    const c = w[0].toLowerCase();
-    letters.add(/[a-z]/.test(c) ? c : "0");
-  }
-  const index = new Map();
-  for (const letter of letters) {
-    const path = join(yamlDir, `entries-${letter}.yaml`);
-    if (!existsSync(path)) continue;
-    const parsed = parseYaml(await readFile(path, "utf8"));
-    for (const [word, byPos] of Object.entries(parsed)) {
-      if (!words.has(word)) continue;
-      const senses = {};
-      for (const [pos, rec] of Object.entries(byPos || {})) {
-        if (pos === "form") continue;
-        const list = Array.isArray(rec?.sense) ? rec.sense : [];
-        senses[pos] = list.map((s) => ({ id: s.id, synset: s.synset })).filter((s) => s.synset);
-      }
-      index.set(word, senses);
-    }
-  }
-  return index;
-}
-
-/** Every noun.*.yaml synset in the clone. */
-export async function loadAllNounSynsets(yamlDir = WORDNET_YAML_DIR) {
-  const files = (await readdir(yamlDir)).filter((f) => f.startsWith("noun."));
-  return loadSynsets(files, yamlDir);
-}

package/src/domain/corpus-matrix.mjs

@@ -1,87 +0,0 @@
-// corpus-matrix.mjs — the fold and the two gap heuristics behind the
-// capability-by-lane coverage matrix, plus the table renderer. Pure: rows in,
-// counts and text out, so the heuristics can be tested against a handful of
-// made-up rows instead of whatever test/corpus happens to hold today.
-//
-// scripts/corpus-matrix.mjs keeps the readdir, the readFile and the printing.
-
-/** A row's capability group: the first two dot-segments of its key, so
- *  "ask.alias.two-hop" and "ask.alias.miss" are one capability. */
-export const groupOfKey = (key) => key.split(".").slice(0, 2).join(".");
-
-/** The key a row is counted under. A row with no key is still a row, and
- *  hiding it would understate the lane. */
-export const keyOfRow = (row) => String(row.key ?? "(no key)");
-
-/** A key segment naming a miss, a guard or a negation — the row that pins what
- *  a capability DECLINES to do, as opposed to its happy path. */
-const NEGATIVE_RE = /(honest-miss|miss|guard|negation|negative|never|decline|refus|unsolvable|unknown|hedge|no-antecedent|untouched|empty)/;
-
-export const isNegativeKey = (key) => NEGATIVE_RE.test(key);
-
-/** Fold `{ lane, row }` pairs into the two indexes every view needs: the count
- *  per group per lane, and the full keys each group was built from. */
-export function tallyRows(entries) {
-  const counts = new Map(); // group -> Map<lane, rowCount>
-  const fullKeys = new Map(); // group -> Set<full key>
-  for (const { lane, row } of entries) {
-    const key = keyOfRow(row);
-    const group = groupOfKey(key);
-    if (!counts.has(group)) counts.set(group, new Map());
-    const perLane = counts.get(group);
-    perLane.set(lane, (perLane.get(lane) ?? 0) + 1);
-    if (!fullKeys.has(group)) fullKeys.set(group, new Set());
-    fullKeys.get(group).add(key);
-  }
-  return { counts, fullKeys };
-}
-
-/** The groups the gap heuristics judge. bench.* rows assert a rig runs rather
- *  than pinning a capability, so "no negative row" says nothing there. */
-export const behaviourGroups = ({ counts }) =>
-  [...counts.keys()].filter((g) => !g.startsWith("bench.")).sort();
-
-const rowTotal = (counts, group) => [...counts.get(group).values()].reduce((a, b) => a + b, 0);
-
-/** Groups a single row pins end to end. A review candidate, not a hole. */
-export function thinGroups(tally) {
-  return behaviourGroups(tally).filter((g) => rowTotal(tally.counts, g) === 1);
-}
-
-/** Groups whose keys never name a miss, guard or negation — a happy path is
- *  pinned and the decline is not. A review candidate, not a hole. */
-export function groupsWithNoNegativeRow(tally) {
-  return behaviourGroups(tally).filter((g) => ![...tally.fullKeys.get(g)].some(isNegativeKey));
-}
-
-/** The lanes a group has rows in, in the order given. */
-export const lanesOfGroup = ({ counts }, group) => [...counts.get(group).keys()];
-
-/** One row per group, one column per lane, an empty cell where a lane has no
- *  row for that group. The header row comes first. */
-export function matrixRows({ counts }, lanes) {
-  const groups = [...counts.keys()].sort();
-  return [
-    ["key", ...lanes],
-    ...groups.map((group) => [
-      group,
-      ...lanes.map((lane) => {
-        const n = counts.get(group).get(lane);
-        return n ? String(n) : "";
-      }),
-    ]),
-  ];
-}
-
-/** `rows` (header first) as fixed-width text, with a rule under the header.
- *  Each column is as wide as its widest cell; trailing padding is trimmed. */
-export function renderTable(rows) {
-  const [header, ...body] = rows;
-  const widths = header.map((h, col) => Math.max(h.length, ...body.map((r) => r[col].length)));
-  const renderLine = (cells) => cells.map((c, col) => c.padEnd(widths[col])).join("  ").trimEnd();
-  return [
-    renderLine(header),
-    renderLine(widths.map((w) => "-".repeat(w))),
-    ...body.map(renderLine),
-  ].join("\n");
-}

package/src/domain/inflect.mjs

@@ -1,67 +0,0 @@
-// inflect.mjs — the regular English -s/-ed/-ing rules, applied to a lemma.
-//
-// WordNet carries lemmas only ("rest" is present, "rests" is absent), and it is
-// the inflected forms that collide with the fuzzy repair tier's targets —
-// "rests" is one edit from "tests". So the real-word collision table expands
-// every lemma through these rules before it looks for collisions.
-//
-// These are the REGULAR rules and nothing else. No irregular table, no stress
-// model: pastOf("run") is "runned" and pastOf("make") is "maked". That is the
-// intended shape. The table's job is to name words the repair tier must not
-// rewrite, and inflectionsOf is generous on purpose (see below) — an extra form
-// costs one repair we decline to make, and the sentence misses honestly, while
-// a missing form costs a real word rewritten into a different question,
-// answered with confidence. The first is the cheaper mistake.
-
-import { STOPWORDS } from "./interpret/normalize.mjs";
-import {
-  FUZZY_TARGET_WORDS, FUZZY_REPAIR_MIN_LENGTH, fuzzyMatchInSet, fuzzyBound,
-} from "./interpret/fuzzy.mjs";
-
-const VOWELS = new Set(["a", "e", "i", "o", "u"]);
-const isVowel = (c) => VOWELS.has(c);
-
-/** A single final consonant after a single vowel doubles before -ed/-ing
- *  ("run" -> "running"). w, x and y never double. Stress is not modelled, so a
- *  second syllable doubles too ("visit" -> "visitting"). */
-export function doublesFinalConsonant(w) {
-  const [c3, c2, c1] = [w.at(-3), w.at(-2), w.at(-1)];
-  if (!c3 || isVowel(c1) || "wxy".includes(c1)) return false;
-  return isVowel(c2) && !isVowel(c3);
-}
-
-export function pluralOf(w) {
-  if (/(?:s|x|z|ch|sh)$/.test(w)) return `${w}es`;
-  if (/[^aeiou]y$/.test(w)) return `${w.slice(0, -1)}ies`;
-  return `${w}s`;
-}
-
-export function pastOf(w) {
-  if (w.endsWith("e")) return `${w}d`;
-  if (/[^aeiou]y$/.test(w)) return `${w.slice(0, -1)}ied`;
-  if (doublesFinalConsonant(w)) return `${w}${w.at(-1)}ed`;
-  return `${w}ed`;
-}
-
-export function gerundOf(w) {
-  if (w.endsWith("ie")) return `${w.slice(0, -2)}ying`;
-  if (w.endsWith("e") && !/(?:ee|oe|ye)$/.test(w)) return `${w.slice(0, -1)}ing`;
-  if (doublesFinalConsonant(w)) return `${w}${w.at(-1)}ing`;
-  return `${w}ing`;
-}
-
-/** Every surface form of `w` the collision table counts as real English. */
-export const inflectionsOf = (w) => [w, pluralOf(w), pastOf(w), gerundOf(w)];
-
-/** The words in `realWords` that the repair tier would rewrite onto one of its
- *  targets: long enough to reach the tier, not a stopword, not a target itself,
- *  and within the fuzzy bound of some target. Sorted, so the table it feeds is
- *  reproducible. */
-export function collisionsFrom(realWords) {
-  return [...realWords]
-    .filter((w) => w.length >= FUZZY_REPAIR_MIN_LENGTH)
-    .filter((w) => !STOPWORDS.has(w))
-    .filter((w) => !FUZZY_TARGET_WORDS.includes(w))
-    .filter((w) => fuzzyMatchInSet(w, FUZZY_TARGET_WORDS, fuzzyBound(w)) !== null)
-    .sort();
-}