@polycode-projects/the-mechanical-code-talker 1.8.20 → 1.9.1

package/src/cli-args.mjs

@@ -5,10 +5,14 @@
 // precedence chain — built on top of toml-config.mjs's already-tested
 // mergeEffective/normalizeConfig (arg > toml > default), not a rebuild of it.
 //
-// Three tiny flag helpers (pure, no I/O) plus the one async resolver:
+// Four tiny flag helpers (pure, no I/O) plus the one async resolver:
 //   strFlag(rest, names, dflt)   → single value, last flag occurrence wins
 //   repeatedFlag(rest, names)    → every value for a repeatable flag (e.g. --graph)
 //   boolFlag(rest, names)        → true if any of `names` appears at all
+//   enumFlag(rest, names, choices) → strFlag, validated against a closed set
+//     (throws a clear error naming the flag + the choices — the shared shape
+//     for a closed-choice option like `--memory-backend default|memory|sqlite`,
+//     matching `--with-persona`'s own "unknown name" error style)
 //   resolveRuntimeConfig({argv, cwd, env, gitRoot}) → the resolved repo/config
 //
 // Graph-path precedence (documented once, here — every subcommand shares it):
@@ -69,6 +73,21 @@ export function boolFlag(rest, names) {
   return rest.some((r) => list.includes(r));
 }
 
+/** Closed-choice single-value flag: `strFlag` plus validation against
+ *  `choices`. Returns `undefined` when absent (never a default — the caller
+ *  decides what "absent" means, same as an omitted `strFlag` call). Throws a
+ *  clear, user-facing error naming the flag and the valid choices when a
+ *  value IS given but isn't one of them — validate-before-any-disk-write,
+ *  the same discipline `tmct init --with-persona <unknown>` already uses. */
+export function enumFlag(rest, names, choices) {
+  const val = strFlag(rest, names, undefined);
+  if (val !== undefined && !choices.includes(val)) {
+    const flagName = asList(names)[0];
+    throw new Error(`invalid ${flagName} "${val}". Choices: ${choices.join(", ")}.`);
+  }
+  return val;
+}
+
 /**
  * Resolve one subcommand invocation's repo root, tmct.toml, and graph
  * path(s) — the shared precedence chain every subcommand (chat/memory/init/

package/src/codegraph.mjs

@@ -3,7 +3,7 @@ import { cosine } from "./embed.mjs";
 // Single-sourced predicate strings (memory/core.mjs owns these constants) — no
 // circular-import risk: core.mjs imports trust.mjs/shacl.mjs/planning.mjs, never
 // codegraph.mjs, in either direction.
-import { CREATED_AT_PROP, UPDATED_AT_PROP } from "./memory/core.mjs";
+import { CREATED_AT_PROP, UPDATED_AT_PROP, provenanceTagToSource } from "./memory/core.mjs";
 
 // Pure (no-network, no-fs) query logic over the typed `entities` payload that the
 // deterministic indexer writes to <repo>/.tmct/graph.json (shape produced by
@@ -102,11 +102,29 @@ const PROP_KIND = {
   "mgx:inreplyto": "inReplyTo",
   "mgx:statedby": "statedBy",
   "mgx:canonicalisedfrom": "canonicalisedFrom",
+  // PLAN_VIZ_MEMORY.md Bug 2 fix: the two FIXED structural link kinds
+  // deriveFactTermGraph (below) synthesizes on every Fact — Fact -> its own
+  // subject/object Term individual. Without these a walk seeded on a Fact (the
+  // default mostRecentIndividual seed right after a teach turn) could never
+  // reach the term graph at all. Distinct from the per-predicate kinds below
+  // (an open-ended, DYNAMIC set — see relationKind's "factrel:" branch), these
+  // two are fixed and few, so a plain PROP_KIND row is the simplest fit.
+  "mgx:factsubjectterm": "factSubjectTerm",
+  "mgx:factobjectterm": "factObjectTerm",
 };
 
 export function relationKind(group) {
   const prop = String(group?.prop || "").toLowerCase();
   if (PROP_KIND[prop]) return PROP_KIND[prop];
+  // PLAN_VIZ_MEMORY.md Bug 2 fix: deriveFactTermGraph's per-predicate relation
+  // groups (Term -> Term, one group per DISTINCT fact predicate actually
+  // present in the data — there is no fixed vocabulary to enumerate here: a
+  // freshly taught "mgx:<verb>" predicate (generalVerbTeach) must classify
+  // automatically, never requiring a PROP_KIND edit per predicate). Those
+  // groups self-namespace their `prop` as `factrel:<predicate>` specifically
+  // so they can self-classify here, verbatim, with zero collision risk against
+  // any real code-graph or memory-graph prop token (none use this prefix).
+  if (prop.startsWith("factrel:")) return group.predicate || null;
   const pred = String(group?.predicate || "").toLowerCase();
   // symbol-granular fallbacks first, so a near-miss token name still classifies to the
   // fine-grained kind rather than collapsing to module-coarse calls/touches.
@@ -828,6 +846,18 @@ function beamExpand(graph, scored, beamWidth) {
  *   - `seeds` (default derived from `scored`, as before) — an explicit id iterable, so a caller
  *     with no `scored` list at all (e.g. `mostRecentIndividual`'s single seed) can still drive
  *     the walk.
+ *   - `hubDegree` (default `Infinity`, PLAN_VIZ_MEMORY.md's page-size strategy — seonix's own
+ *     third cap, default 40 there): stop expanding THROUGH a node with MORE than this many
+ *     in-graph neighbours over `kinds` — the node itself is still popped/emitted normally (still
+ *     shown), it just contributes no candidates for the NEXT hop. Distinct from `q` (a relative,
+ *     per-step quantile gate that always keeps at least one candidate) and from `nodeLimit` (a
+ *     total emit budget): `hubDegree` is an absolute per-node gate that can drop a hub's entire
+ *     fan-out to zero, so an ultra-common hypernym ("thing", "entity" — reachable from thousands
+ *     of IsA facts) can't swallow the whole node budget in one hop. `Infinity` (no gate) keeps
+ *     every existing caller byte-identical. EXEMPTS the seed(s) (hop 0) themselves — a walk
+ *     started directly ON a hub (e.g. `tmct viz --term tree` where "tree" is a 1,972-fact
+ *     ConceptNet hub, measured live this session) still shows that hub's own immediate
+ *     neighbourhood; only a hub reached MID-walk (hop > 0) has its own further fan-out gated.
  *  The score-nudge machinery (mutating `scored`/introducing newly-surfaced individuals into it)
  *  is gated behind `scored.length > 0 && maxSeed > 0` — the exact condition the original early
  *  return checked — so an empty `scored` degrades gracefully into a pure walk rather than erroring.
@@ -842,6 +872,7 @@ export function spiralExpand(graph, scored = [], {
   classPredicate = (ind) => (ind.class || "") === "Module",
   idNormalizer = null,
   seeds: seedsOpt = null,
+  hubDegree = Infinity,
 } = {}) {
   const byId = new Map(scored.map((s) => [s.ind.id, s]));
   let maxSeed = 0;
@@ -912,6 +943,16 @@ export function spiralExpand(graph, scored = [], {
       emitted++;
     }
     if (node.hop >= depth) continue;
+    // hubDegree gate: a node above the cap is still shown (already emitted above) but never
+    // expanded THROUGH — its own neighbours contribute nothing to the next hop. EXEMPTS hop 0
+    // (a seed) deliberately: measured live against a real init:xl-scale corpus this session,
+    // `tmct viz --term tree` (a 1,972-fact hub term) with the gate applied unconditionally
+    // returned a single, useless lone node — seeding directly ON a term the user explicitly
+    // asked to centre on must always show ITS OWN immediate neighbourhood, or the whole
+    // `--term`/click-to-recentre feature is pointless on exactly the popular, interesting terms
+    // it exists for. A hub only reached mid-walk (hop > 0) still gates normally — this only
+    // changes the walk's own STARTING point(s), not general hub suppression elsewhere.
+    if (node.hop > 0 && degree(node.id) > hubDegree) continue;
     // This step's candidate set = the popped node's unvisited neighbours matching classPredicate;
     // quantile-gate by degree, keeping the lowest-degree ⌊q·n⌋ (drop the densest hubs), never
     // fewer than one.
@@ -1416,6 +1457,270 @@ export function buildVizNodesAndEdges(graph, walked, { createdAtProp = CREATED_A
   return { nodes, edges };
 }
 
+// PLAN_VIZ_MEMORY.md Bug 2 fix: the FACT_CLASS string, mirrored here rather than
+// imported (memory/core.mjs's own FACT_CLASS export is a plain "Fact" literal —
+// importing one more binding across this already-imported module isn't worth
+// it for a single string every reader of this file can eyeball is exactly what
+// memory/core.mjs's own appendFact writes).
+const MEMORY_FACT_CLASS = "Fact";
+const MEMORY_TERM_CLASS = "Term";
+
+/** Derive a TERM-relation VIEW of a memory graph's reified Facts (Bug 2 fix,
+ *  PLAN_VIZ_MEMORY.md) — never mutates `graph`, never persisted, viz-only.
+ *
+ *  A Fact individual stores its subject/predicate/object as plain normalized
+ *  STRING attributes (`rdf:subject`/`rdf:predicate`/`rdf:object`,
+ *  memory/core.mjs's appendFact) — there is no individual node for "dog" at
+ *  all. So the real subject->predicate->object concept structure is
+ *  structurally invisible to any walk over `graph.relations` as it stands:
+ *  every edge there connects two INDIVIDUAL ids (Utterance/Session/Fact/
+ *  Source), never a concept term. This function materializes the missing
+ *  structure as a NEW, derived graph:
+ *   - one synthetic `Term` individual per distinct normalized subject/object
+ *     string (id `term:<t>`, label `t`);
+ *   - one synthetic relation group per DISTINCT fact predicate actually
+ *     present in the data (Term -> Term, `subject`/`object` = the two terms'
+ *     ids) — no hardcoded predicate vocabulary: a freshly taught "mgx:<verb>"
+ *     predicate (generalVerbTeach) becomes walkable automatically, the same
+ *     turn it's asserted;
+ *   - two FIXED structural link groups, `factSubjectTerm`/`factObjectTerm`
+ *     (Fact -> its own subject/object Term) — without these a walk seeded on
+ *     a Fact (the default `mostRecentIndividual` seed right after a teach
+ *     turn) could never reach the term graph in the first place; a `--term`
+ *     seed reaches the SAME facts via the same links, in reverse.
+ *  Returns `{ graph: <augmented graph>, factRelationKinds: [<predicate>, …] }`
+ *  — `factRelationKinds` is exactly the dynamic `kinds` list a caller passes
+ *  to `spiralExpand` for the "concept relation" walk (see MEMORY_SPIRAL_EXPAND_KINDS
+ *  for the sibling "provenance/meta" kinds list). A graph with no Fact
+ *  individuals (or a code graph passed in by mistake) is a safe no-op:
+ *  `{ graph, factRelationKinds: [] }`, the SAME graph object, unchanged.
+ *  Pure; deterministic (Map iteration order = insertion order = first-seen
+ *  order over `graph.individuals`, so re-running on the same input is
+ *  byte-identical). */
+export function deriveFactTermGraph(graph) {
+  const termById = new Map(); // term:<t> -> individual
+  const groupByPredicate = new Map(); // predicate -> relation group
+  const subjectLinks = []; // Fact -> its subject Term
+  const objectLinks = [];  // Fact -> its object Term
+  const termId = (t) => `term:${t}`;
+  const ensureTerm = (t) => {
+    const id = termId(t);
+    if (!termById.has(id)) termById.set(id, { id, label: t, class: MEMORY_TERM_CLASS, attributes: [] });
+    return id;
+  };
+
+  for (const ind of graph?.individuals || []) {
+    if ((ind?.class || "") !== MEMORY_FACT_CLASS) continue;
+    const attrs = ind.attributes || [];
+    const s = attrs.find((a) => a?.prop === "rdf:subject")?.value;
+    const p = attrs.find((a) => a?.prop === "rdf:predicate")?.value;
+    const o = attrs.find((a) => a?.prop === "rdf:object")?.value;
+    if (!s || !p || !o) continue; // a malformed/legacy Fact — skip, never throw
+    const subjectTermId = ensureTerm(s);
+    const objectTermId = ensureTerm(o);
+    let group = groupByPredicate.get(p);
+    if (!group) {
+      // `factrel:` namespace: relationKind's own dedicated branch self-classifies
+      // any group with this prefix to its raw predicate, verbatim — see that
+      // function's comment for why (an open-ended, dynamically-discovered kind
+      // set with no PROP_KIND row to add per predicate).
+      group = { predicate: p, prop: `factrel:${p}`, count: 0, edges: [] };
+      groupByPredicate.set(p, group);
+    }
+    group.edges.push({ subject: subjectTermId, object: objectTermId, subjectLabel: s, objectLabel: o });
+    group.count = group.edges.length;
+    subjectLinks.push({ subject: ind.id, object: subjectTermId, subjectLabel: ind.label, objectLabel: s });
+    objectLinks.push({ subject: ind.id, object: objectTermId, subjectLabel: ind.label, objectLabel: o });
+  }
+
+  if (!termById.size) return { graph, factRelationKinds: [] };
+
+  const individuals = [...(graph.individuals || []), ...termById.values()];
+  const byId = new Map(graph.byId);
+  for (const term of termById.values()) byId.set(term.id, term);
+  const relations = [
+    ...(graph.relations || []),
+    ...groupByPredicate.values(),
+    { predicate: "factSubjectTerm", prop: "mgx:factSubjectTerm", count: subjectLinks.length, edges: subjectLinks },
+    { predicate: "factObjectTerm", prop: "mgx:factObjectTerm", count: objectLinks.length, edges: objectLinks },
+  ];
+
+  return {
+    graph: { ...graph, individuals, byId, relations },
+    factRelationKinds: [...groupByPredicate.keys()],
+  };
+}
+
+/** The two FIXED structural link kinds `deriveFactTermGraph` always emits
+ *  (Fact -> its own subject/object Term) — see that function's own doc for
+ *  why they're needed at all. Bundled into the "relation" (concept) walk, not
+ *  the "meta" (provenance) one: a user who toggles to meta-only still gets
+ *  today's exact byte-identical provenance-only view (see viz.mjs's edge-kind
+ *  toggle). */
+export const MEMORY_FACT_LINK_KINDS = ["factSubjectTerm", "factObjectTerm"];
+
+/** Bug 2 fix: the combined kinds list a memory-graph walk actually uses, for a
+ *  given edge-kind MODE — "meta" (today's exact provenance-only walk, kept as
+ *  a filterable toggle, never deleted), "relation" (the NEW concept view —
+ *  Bug 2's fix), or "both" (the default: meta AND relation kinds together, so
+ *  a click on a recently-taught Fact reaches its own concept neighbourhood the
+ *  same turn). `factRelationKinds` is the dynamic per-predicate list
+ *  `deriveFactTermGraph` discovered in THIS graph — there is no fixed
+ *  vocabulary, a freshly taught predicate is walkable the same turn it's
+ *  asserted. Lives here (not viz.mjs) and is re-exported through
+ *  ask-browser-entry.mjs specifically so BOTH the CLI's own generation-time
+ *  walk (viz.mjs's computeVizGraph) AND the browser bundle's client-side
+ *  re-walk (a recentre or an edge-kind-toggle change) combine kinds via the
+ *  SAME function — viz.mjs itself can't be bundled for the browser (it does
+ *  real fs I/O), so this had to live in the shared, browser-safe module. */
+export function edgeKindsFor(mode, factRelationKinds) {
+  const relationKinds = [...factRelationKinds, ...MEMORY_FACT_LINK_KINDS];
+  if (mode === "meta") return [...MEMORY_SPIRAL_EXPAND_KINDS];
+  if (mode === "relation") return relationKinds;
+  return [...MEMORY_SPIRAL_EXPAND_KINDS, ...relationKinds]; // "both" (default)
+}
+
+const LEGEND_MAX_BUCKETS = 20; // seonix precedent, PLAN_VIZ_MEMORY.md: too many chips to be usable
+const LEGEND_MIN_BUCKETS = 2;  // nothing to filter with only one bucket
+const LEGEND_COLLAPSE_TOP_N = 15; // "top 15 by count, rest grouped as Other" — stays under the max
+
+/** Normalized Shannon entropy (`H / log2(k)`, `k` = bucket count) of a
+ *  {value, count} bucket list — 1.0 for a perfectly even split, ~0 for one
+ *  dominant bucket swallowing everything, undefined (returns 0) for k<2. */
+function normalizedEntropy(buckets) {
+  const k = buckets.length;
+  if (k < 2) return 0;
+  const total = buckets.reduce((sum, b) => sum + b.count, 0);
+  if (!total) return 0;
+  let h = 0;
+  for (const b of buckets) {
+    if (!b.count) continue;
+    const p = b.count / total;
+    h -= p * Math.log2(p);
+  }
+  return h / Math.log2(k);
+}
+
+/** Collapse a raw {value,count} bucket list down to at most LEGEND_MAX_BUCKETS
+ *  entries: keep the top LEGEND_COLLAPSE_TOP_N by count, fold the rest into a
+ *  single "Other" bucket — the plan's own "may need a top-15-by-count, rest
+ *  grouped as Other" escape hatch, applied generically (not predicate-only) so
+ *  any dimension that happens to be high-cardinality degrades the same way.
+ *  A no-op (returns `buckets` unchanged, same array) when already <= the cap.
+ *  Exported (not just used internally by pickLegendDimension) so the browser
+ *  bundle's client-side legend (live per-view recomputation, viz.mjs's own
+ *  computeLegendBuckets) collapses high-cardinality dimensions the SAME way,
+ *  never a second hand-rolled copy that could drift. */
+export function collapseToTopN(buckets) {
+  if (buckets.length <= LEGEND_MAX_BUCKETS) return buckets;
+  const sorted = [...buckets].sort((a, b) => b.count - a.count || (a.value < b.value ? -1 : 1));
+  const kept = sorted.slice(0, LEGEND_COLLAPSE_TOP_N);
+  const restCount = sorted.slice(LEGEND_COLLAPSE_TOP_N).reduce((sum, b) => sum + b.count, 0);
+  return restCount ? [...kept, { value: "Other", count: restCount }] : kept;
+}
+
+function bucketCounts(values) {
+  const counts = new Map();
+  for (const v of values) {
+    if (v == null || v === "") continue;
+    counts.set(v, (counts.get(v) || 0) + 1);
+  }
+  return [...counts.entries()].map(([value, count]) => ({ value, count }));
+}
+
+/** The normalized provenance-prefix label for a Fact's FIRST recorded
+ *  provenance tag (a Fact may carry a " | "-joined union of several; the
+ *  legend buckets on the primary/first-recorded one, not a multiset) —
+ *  reuses memory/core.mjs's own provenanceTagToSource parser (the SAME
+ *  collapse-the-session-id/timestamp-suffix, keep-the-corpus/source-name
+ *  logic the trust layer already relies on) rather than re-deriving it.
+ *  Null when the Fact carries no provenance tag at all (a legacy/malformed
+ *  row) or the tag doesn't parse to a known Source kind. */
+function provenanceBucketLabel(rawTag) {
+  const tag = String(rawTag || "").split(" | ")[0].trim();
+  if (!tag) return null;
+  const src = provenanceTagToSource(tag);
+  if (!src) return null;
+  if (src.kind === "corpus" || src.kind === "corpusWeak") {
+    return `${src.kind === "corpusWeak" ? "corpus-weak" : "corpus"}:${src.name || "unknown"}`;
+  }
+  if (src.kind === "extracted") return `extracted:${src.name || "unknown"}`;
+  if (src.kind === "entailed") return `entailed:${src.rule || "unknown"}`;
+  if (src.kind === "operator") return "ace:chat";
+  if (src.kind === "teach") return "teach:chat";
+  if (src.kind === "web") return "web";
+  return src.kind;
+}
+
+/** A single walked NODE's bucket value under one legend dimension — the
+ *  per-node counterpart to `pickLegendDimension`'s aggregate bucket counts,
+ *  exported so both the CLI's own legend computation AND the browser bundle's
+ *  client-side dimension-switcher (a user flipping from "split by predicate"
+ *  to "split by trust source" without regenerating the page,
+ *  PLAN_VIZ_MEMORY.md's Controls section) filter/color by the SAME derivation,
+ *  never a second hand-rolled copy. `"class"` reads every node; `"predicate"`/
+ *  `"provenance"` only ever return non-null for a Fact-class node (any other
+ *  class simply has no predicate/provenance of its own to bucket on). */
+export function legendValueFor(graph, node, dimension) {
+  if (dimension === "class") return node?.class || "(none)";
+  if (!node || node.class !== MEMORY_FACT_CLASS) return null;
+  const attrs = graph?.byId?.get?.(node.id)?.attributes || [];
+  if (dimension === "predicate") return attrs.find((a) => a?.prop === "rdf:predicate")?.value || null;
+  if (dimension === "provenance") return provenanceBucketLabel(attrs.find((a) => a?.prop === "mgx:factProvenance")?.value);
+  return null;
+}
+
+/** Auto-pick the filter/legend dimension at generation time (PLAN_VIZ_MEMORY.md
+ *  "Auto-picking the filter/legend dimension" section — full algorithm/
+ *  rationale there). seonix hardcodes its legend dimension (a small, near-
+ *  uniform set of code-graph classes) — tmct's memory graph does NOT have that
+ *  property: `class` is `{Fact, Session, Source, Utterance, Term}` and once
+ *  real data is seeded, Fact dominates so heavily that a class-based legend
+ *  filters almost nothing. This scores three candidate dimensions by
+ *  normalized Shannon entropy over their bucket-size distribution (rewards an
+ *  even-ish split, penalizes one dominant bucket) and picks the best-scoring
+ *  QUALIFYING one (`LEGEND_MIN_BUCKETS <= k <= LEGEND_MAX_BUCKETS`, after a
+ *  top-15+Other collapse for anything over the cap) as the PRIMARY legend:
+ *   1. `class` — every walked node's own `.class`.
+ *   2. `predicate` — every walked Fact node's `rdf:predicate` attribute (a
+ *      relation-shaped split: "show me only IsA facts").
+ *   3. `provenance` — every walked Fact node's provenance prefix, collapsed
+ *      (see provenanceBucketLabel) — a TRUST-shaped split.
+ *  Pure, one pass over the already-walked `nodes` (no new graph traversal) —
+ *  computed ONCE at generation time and embedded into the page's JSON, never
+ *  recomputed client-side. `graph` supplies the per-Fact attribute lookups
+ *  `nodes` itself doesn't carry (predicate/provenance are Fact ATTRIBUTES,
+ *  not part of the {id,hop,label,class,createdAt,updatedAt} viz node shape).
+ *  Returns `{ primary, dimensions: { class, predicate, provenance } }`, each
+ *  entry `{ score, qualifies, buckets: [{value, count}] }`. When nothing
+ *  qualifies (e.g. a tiny 1-2-node walk), `primary` falls back to `"class"` —
+ *  today's behavior — so the legend is never simply empty. */
+export function pickLegendDimension(graph, nodes) {
+  const classBuckets = bucketCounts((nodes || []).map((n) => legendValueFor(graph, n, "class")));
+  const predicateBuckets = bucketCounts((nodes || []).map((n) => legendValueFor(graph, n, "predicate")));
+  const provenanceBuckets = bucketCounts((nodes || []).map((n) => legendValueFor(graph, n, "provenance")));
+
+  const score = (rawBuckets) => {
+    const buckets = collapseToTopN(rawBuckets);
+    const qualifies = buckets.length >= LEGEND_MIN_BUCKETS && buckets.length <= LEGEND_MAX_BUCKETS;
+    return { score: normalizedEntropy(buckets), qualifies, buckets };
+  };
+
+  const dimensions = {
+    class: score(classBuckets),
+    predicate: score(predicateBuckets),
+    provenance: score(provenanceBuckets),
+  };
+
+  let primary = "class";
+  let bestScore = -1;
+  for (const [name, d] of Object.entries(dimensions)) {
+    if (!d.qualifies) continue;
+    if (d.score > bestScore) { bestScore = d.score; primary = name; }
+  }
+  return { primary, dimensions };
+}
+
 /** moduleIdOf by raw edge-endpoint id: resolves through byId when the individual exists,
  *  else falls back to parsing an `fn:<path>#name` id directly (callsSymbol objects may name
  *  symbols with no individual of their own). Null if it cannot be mapped. */

package/src/corpus/conceptnet-map.toml

@@ -187,44 +187,49 @@ note = "mutual exclusion; ACE pattern 6 ('no N1 is a N2')"
 [[relation]]
 rel = "/r/RelatedTo"
 surface = "{start} is related to {end}"
-ace = "none"
-note = "weakest, undirected association — too vague for an axiom; useful later as a fuzzy-match hint, never a fact"
+ace = "ObjectProperty"
+predicate = "mgx:relatedTo"
+note = "weakest, undirected association — re-examined 2026-07-12 (TOO_HARD_AUDIT.md): the surface template above was already fully authored, so the prior 'too vague for an axiom' exclusion was a design call dressed as a technical one, not a real blocker. Emitted at LOWER trust (src/corpus/conceptnet.mjs routes RelatedTo facts through the corpus-weak: provenance prefix -> SOURCE_PRIOR.corpusWeak, memory/trust.mjs) rather than either full-strength or excluded."
 
 [[relation]]
 rel = "/r/Synonym"
 surface = "{start} means the same as {end}"
-ace = "none"
-note = "lexical alias, not an axiom — feeds the grammar lexicon / phrasebook synonym families instead"
+ace = "ObjectProperty"
+predicate = "mgx:synonym"
+note = "lexical alias — re-examined 2026-07-12 (TOO_HARD_AUDIT.md): genuinely fact-shaped ('X means the same as Y' is a real, answerable claim), no real reason it was excluded"
 
 [[relation]]
 rel = "/r/Antonym"
 surface = "{start} is the opposite of {end}"
-ace = "none"
-note = "lexical opposition; OWL disjointness would over-claim (hot/cold are not disjoint classes) — DistinctFrom carries the real disjointness"
+ace = "ObjectProperty"
+predicate = "mgx:antonym"
+note = "lexical opposition — re-examined 2026-07-12 (TOO_HARD_AUDIT.md): OWL disjointness would over-claim (hot/cold are not disjoint classes), so this does NOT reuse DistinctFrom/owl:disjointWith, but a plain ObjectProperty edge ('X is the opposite of Y') is a real, fact-shaped claim, not an axiom"
 
 [[relation]]
 rel = "/r/FormOf"
 surface = "{start} is a form of the word {end}"
 ace = "none"
-note = "inflection → root; lexicon normalization, not knowledge"
+note = "inflection → root; lexicon normalization, not knowledge — genuinely a different kind of thing than RelatedTo/Synonym/Antonym/SimilarTo (morphology, not world-knowledge); stays excluded, re-confirmed 2026-07-12 (TOO_HARD_AUDIT.md)"
 
 [[relation]]
 rel = "/r/DerivedFrom"
 surface = "the word {start} is derived from {end}"
 ace = "none"
-note = "word derivation; lexicon material, not an axiom"
+note = "word derivation; lexicon material, not an axiom — genuinely a different kind of thing than RelatedTo/Synonym/Antonym/SimilarTo (morphology, not world-knowledge); stays excluded, re-confirmed 2026-07-12 (TOO_HARD_AUDIT.md)"
 
 [[relation]]
 rel = "/r/SymbolOf"
 surface = "{start} is a symbol of {end}"
-ace = "none"
-note = "symbolism — no OWL fit"
+ace = "ObjectProperty"
+predicate = "mgx:symbolOf"
+note = "symbolism — re-examined 2026-07-12 (TOO_HARD_AUDIT.md): same stale shape as the RelatedTo/Synonym/Antonym/SimilarTo exclusions — a fully-authored surface template sitting right next to a 'no OWL fit' exclusion note. Genuinely fact-shaped and precise (more so than RelatedTo), so full corpus trust, not weak."
 
 [[relation]]
 rel = "/r/SimilarTo"
 surface = "{start} is similar to {end}"
-ace = "none"
-note = "graded similarity — no crisp OWL fit; potential fuzzy-match hint only"
+ace = "ObjectProperty"
+predicate = "mgx:similarTo"
+note = "graded similarity — re-examined 2026-07-12 (TOO_HARD_AUDIT.md): genuinely fact-shaped ('X is similar to Y'), no real reason it was excluded"
 
 [[relation]]
 rel = "/r/HasContext"

package/src/corpus/conceptnet.mjs

@@ -43,6 +43,21 @@ export const SEON_DEFINITIONS_FILE = join(PKG_ROOT, "corpus", "seon", "definitio
 export const TIER2_DIR = join(PKG_ROOT, "corpus", "tier2");
 export const TIER2_MANIFEST_FILE = join(TIER2_DIR, "manifest.json");
 
+// corpus/wordnet/generate.mjs's output: the Open English WordNet ->
+// ConceptNet-shape conversion, same slice shape/loader path as tier-1/tier-2.
+// Lives alongside its own generator (corpus/conceptnet/'s own precedent:
+// fetch-slice.mjs + slice.jsonl share one directory) rather than under a new
+// "tier-3" name — corpus/README.md's tiering policy already uses "tier-3" for
+// something else entirely (runtime-learned facts, NEVER committed), and this
+// bundle is curated + committed, the same shape as a tier-2 corpus, just too
+// large/mechanically-derived to hand-curate. "wordnet-xl"/"wordnet-full" are
+// wired as BUILTIN_EXTENSIONS corpus entries in src/extensions.mjs, so
+// `tmct import --corpus wordnet-xl` resolves directly there rather than
+// through TIER2_MANIFEST_FILE's id lookup — see that module's own
+// BUILTIN_EXTENSIONS comment.
+export const WORDNET_DIR = join(PKG_ROOT, "corpus", "wordnet");
+export const WORDNET_MANIFEST_FILE = join(WORDNET_DIR, "manifest.json");
+
 const ACE_PATTERNS = new Set(["subClassOf", "type", "ObjectProperty", "someValuesFrom", "disjointWith", "property", "none"]);
 
 /** Load the slice JSONL as a stream (never the whole file as one string) and
@@ -121,11 +136,18 @@ export function toFacts(assertions, map, provenancePrefix = "corpus:conceptnet")
     const subject = termText(a.start);
     const object = termText(a.end);
     if (!subject || !object) continue; // non-en endpoint slipped in — filtered, not fatal
+    // mgx:relatedTo is real but low-precision (undirected, ambiguous) — routed
+    // through the corpus-weak: prefix so memory/trust.mjs's SOURCE_PRIOR.corpusWeak
+    // (below plain corpus, above web) applies, computed from the Source's kind
+    // like every other tier, never hand-set on the Fact.
+    const prefix = row.predicate === "mgx:relatedTo"
+      ? provenancePrefix.replace(/^corpus:/, "corpus-weak:")
+      : provenancePrefix;
     facts.push({
       subject,
       predicate: row.predicate,
       object,
-      provenance: `${provenancePrefix} ${a.rel}`,
+      provenance: `${prefix} ${a.rel}`,
     });
   }
   return facts;

package/src/extensions.mjs

@@ -50,19 +50,27 @@
 // seedBootstrapMemory already establishes (seon's curated facts should win the
 // content-hash idempotency race over general ConceptNet noise).
 
-import { isAbsolute, join, resolve } from "node:path";
+import { isAbsolute, join, resolve, dirname } from "node:path";
 import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import { loadTomlConfig } from "./toml-config.mjs";
 import {
   SEON_CONCEPTS_FILE,
   SLICE_FILE as CONCEPTNET_SLICE_FILE,
   MAP_FILE as CONCEPTNET_MAP_FILE,
   TIER2_DIR,
+  WORDNET_DIR,
   loadSlice,
   loadMap,
   toFacts,
 } from "./corpus/conceptnet.mjs";
 
+// corpus/namenet/generate.mjs's output — same small-top-up shape as the
+// wordnet-xl/wordnet-full entries below, just a single bundle (not
+// worth PKG_ROOT-style plumbing through corpus/conceptnet.mjs for one
+// directory constant, so computed locally here instead).
+const NAMENET_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "corpus", "namenet");
+
 export const EXTENSION_KINDS = Object.freeze(["corpus", "lexicon", "templates", "pack", "ontology"]);
 
 // The definitional-band-first predicate order chat.mjs's bootstrap has always
@@ -154,6 +162,41 @@ function builtinExtensions() {
       corpusPath: join(TIER2_DIR, "general.jsonl"),
       provenancePrefix: "corpus:tier2-general",
     },
+    // corpus/wordnet/generate.mjs's output: a mechanical ConceptNet-shape
+    // conversion of Open English WordNet's structural relations, not
+    // hand-curated like the tier-2 bundles above (NOT called "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
+    // curated + committed, tier-2-shaped, just too large to hand-author).
+    // Named directly "wordnet-xl"/"wordnet-full" so `tmct import --corpus
+    // wordnet-xl` resolves straight through this BUILTIN_EXTENSIONS lookup,
+    // the same seam every other recognized name already uses — no change
+    // needed to bin/tmct.mjs's tier-2-manifest-id resolution path. Shipped
+    // inactive, like every other opt-in bundle here.
+    "wordnet-xl": {
+      kind: "corpus",
+      active: false,
+      corpusPath: join(WORDNET_DIR, "wordnet-xl.jsonl"),
+      provenancePrefix: "corpus:wordnet-xl",
+    },
+    "wordnet-full": {
+      kind: "corpus",
+      active: false,
+      corpusPath: join(WORDNET_DIR, "wordnet-full.jsonl"),
+      provenancePrefix: "corpus:wordnet-full",
+    },
+    // corpus/namenet/generate.mjs's output: species/common-name and
+    // Wikidata-label/WordNet-lemma synonym pairs, mechanically derived from
+    // three human-reviewed Open English Namenet linking tables. A small,
+    // explicitly OPTIONAL top-up bundle (not a primary corpus) — same
+    // BUILTIN_EXTENSIONS seam as wordnet-xl/wordnet-full above, so `tmct
+    // import --corpus namenet` resolves directly here. Shipped inactive.
+    namenet: {
+      kind: "corpus",
+      active: false,
+      corpusPath: join(NAMENET_DIR, "namenet.jsonl"),
+      provenancePrefix: "corpus:namenet",
+    },
   };
 }