@polycode-projects/the-mechanical-code-talker 6.0.19 → 6.0.21

package/src/services/init.mjs

@@ -199,8 +199,8 @@ source = ${JSON.stringify(config.research.source)}
   if (!Object.keys(extras).length) return out;
   return `${out}
 # Extension packs + bias (src/services/extensions.mjs) — written by \`tmct init --with-persona\`
-# or a manual edit. Recognized names (human, seon, code, conceptnet, tier2-aws,
-# tier2-python, tier2-java, tier2-general) override the shipped defaults; any
+# or a manual edit. Recognized names (human, seon, code, conceptnet, child,
+# namenet, tier2-general) override the shipped defaults; any
 # other name declares a new host-supplied bundle (needs its own "kind").
 # [bias] is a flat bundle-name -> weight table consumed by
 # src/domain/memory/bias.mjs's ranking.
@@ -298,8 +298,8 @@ export async function initRepo(dir, { force = false, seed, env = process.env, pe
         "",
         "Corpus bundles (activate by id — no local copy needed):",
         "  tmct import --corpus human | human-medium | human-large",
-        "  tmct import --corpus seon | conceptnet | aws | python | java | general",
-        "  tmct import --corpus wordnet-xl | wordnet-full | namenet   (large: tens of thousands of facts)",
+        "  tmct import --corpus code | seon | conceptnet | general",
+        "  tmct import --corpus wordnet-xl | wordnet-full | namenet | child   (large: tens of thousands of facts)",
         "",
         "Ontology / lexicon resources are file paths declared as extension entries:",
         "  tmct import --ontology <path> | --lexicon <path>",

package/src/services/ledger-viz.mjs

@@ -25,6 +25,11 @@ import { dirname, join } from "node:path";
 
 const LEDGER_ROW_LIMIT_DEFAULT = 20000;
 
+/** Codepoint order, never localeCompare — every string sorted below (a fact
+ *  row's id or createdAt, a term label, a source bundle key, a predicate) is
+ *  read off the stored fact set, so two locales have to render the same page. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 // The ledger reads as an observability dashboard (dense stat tiles, bar
 // panels, a log-style fact stream) rather than an editorial page, so its
 // chrome runs the system sans everywhere instead of THEME_TOKENS_CSS's
@@ -168,7 +173,7 @@ export function computeLedgerDataFromPayload(payload, { focus, term, rowLimit =
       src: r.provenance || (r.sourceTypes || []).join(" ") || "unrecorded",
     };
   });
-  rows.sort((a, b) => (b.createdAt || "").localeCompare(a.createdAt || "") || a.id.localeCompare(b.id));
+  rows.sort((a, b) => byCodepoint(b.createdAt || "", a.createdAt || "") || byCodepoint(a.id, b.id));
 
   // Term index + adjacency.
   const termMap = new Map(); // term -> { degree, best: {trust, prov}, newest }
@@ -187,7 +192,7 @@ export function computeLedgerDataFromPayload(payload, { focus, term, rowLimit =
   }
   const terms = [...termMap.values()]
     .map(({ term: t, degree, prov, newest }) => ({ term: t, degree, prov, newest }))
-    .sort((a, b) => b.degree - a.degree || a.term.localeCompare(b.term));
+    .sort((a, b) => b.degree - a.degree || byCodepoint(a.term, b.term));
   const edges = rows.map((r) => ({ s: r.s, o: r.o, id: r.id }));
 
   // Focus: the asked term when it resolves; otherwise the newest taught
@@ -382,11 +387,11 @@ export function computeLedgerStats(rows, terms, contradictions) {
   }
   const bundles = [...bundleCounts.entries()]
     .map(([key, count]) => ({ key, label: bundleLabelFor(key), count }))
-    .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key))
+    .sort((a, b) => b.count - a.count || byCodepoint(a.key, b.key))
     .slice(0, BUNDLE_TOP_N);
   const predicates = [...predicateCounts.entries()]
     .map(([predicate, v]) => ({ predicate, phrase: v.phrase, count: v.count }))
-    .sort((a, b) => b.count - a.count || a.predicate.localeCompare(b.predicate))
+    .sort((a, b) => b.count - a.count || byCodepoint(a.predicate, b.predicate))
     .slice(0, PREDICATE_TOP_N);
 
   const totalDegree = (terms || []).reduce((sum, t) => sum + (t.degree || 0), 0);

package/src/services/memory-panel-viz.mjs

@@ -23,10 +23,9 @@ export function bandLabelFor(key) {
     "human-large": "human persona (large)",
     seon: "seon ontology",
     conceptnet: "ConceptNet",
-    "tier2-aws": "AWS",
-    "tier2-python": "Python",
-    "tier2-java": "Java",
     "wordnet-xl": "WordNet",
+    namenet: "NameNet",
+    child: "child vocabulary",
   };
   return BAND_LABELS[key] || key;
 }
@@ -39,7 +38,7 @@ export function bandLabelFor(key) {
 export function statsSummaryLine(stats, bandLabel) {
   const BAND_ORDER = [
     "human", "human-medium", "human-large", "seon", "conceptnet",
-    "tier2-aws", "tier2-python", "tier2-java", "wordnet-xl",
+    "wordnet-xl", "namenet", "child",
     "taught this session", "other",
   ];
   if (!stats || !stats.total) return "no starter memory; starting empty";
@@ -172,7 +171,7 @@ export function renderStatsPanelInto(panelEl, stats, opts) {
   const { bandLabel, taughtHint, onForget = null, persistNote = null } = opts;
   const BAND_ORDER = [
     "human", "human-medium", "human-large", "seon", "conceptnet",
-    "tier2-aws", "tier2-python", "tier2-java", "wordnet-xl",
+    "wordnet-xl", "namenet", "child",
     "taught this session", "other",
   ];
   function bandRow(label, count) {

package/src/services/mud-editor.mjs

@@ -24,10 +24,15 @@
 // Two predicate families sync differently, for the reason adventure-editor.mjs's
 // own header sets out:
 //   - PLACEMENT (currently-in/located-in/fixed-in/hidden-in), OPENNESS and MASS
-//     are fold-versioned — foldWorldState already reads the newest write as the
-//     current truth, which is how every turn's own move and mass drain lands — so
-//     an edit to one is a plain new write superseding the old, never a
-//     retraction. Mass belongs here and not below precisely because it MOVES: a
+//     are fold-versioned — foldWorldState ranks these rows by the (epoch, turn)
+//     pair stamped on the subject, which is how every turn's own move and mass
+//     drain lands — so an edit to one is a plain new write superseding the old,
+//     never a retraction. The superseding write is stamped one turn past the
+//     world's own turn count, exactly the way every in-game action's commit()
+//     writes, so it OUTRANKS what it replaces instead of merely arriving after
+//     it — at equal turn the fold takes whichever row comes later in the array,
+//     and array order is nobody's to promise once a peer's facts have merged
+//     in. Mass belongs here and not below precisely because it MOVES: a
 //     playing animal's weight is a fold over turn snapshots, so an editor
 //     diffing raw mass rows would show the seed and fight the drain.
 //   - Everything else (typing, the class hierarchy, exits, the predator flag,
@@ -37,6 +42,8 @@
 //     that fails to parse this keystroke must never be read as "this fact is
 //     gone".
 
+import { snapshotSubject } from "../domain/world-snapshot.mjs";
+
 export { wordBeforeCursor } from "./viz-theme.mjs";
 
 const PLACEMENT_KIND = "placement";
@@ -296,15 +303,26 @@ export function editableMudOtherRows(rows) {
 
 /** Plan the fact-store writes one parsed edit implies, from already-parsed
  *  `triples` against the world's current `rows`/`state`. Returns
- *  `{ toAppend, toRemoveIds }` — pure, no I/O.
+ *  `{ toAppend, toRemoveIds, editTurn }` — pure, no I/O. `toAppend` rows are
+ *  store-ready: a fold-versioned one already carries its `subject@turnN`
+ *  stamp, and `editTurn` is the turn every one of them was stamped at, for
+ *  the caller's own provenance tag.
+ *
+ *  Placement, openness and mass triples are never retracted: one joins
+ *  `toAppend` only when it actually differs from the subject's current folded
+ *  value, so re-asserting an unchanged line doesn't append a no-op duplicate
+ *  per keystroke. Each one is stamped one turn past the world's own turn
+ *  count, which is what makes it outrank the row it supersedes rather than
+ *  tie with it and win on array position.
  *
- *  Placement and openness triples are never retracted: one joins `toAppend` only
- *  when it actually differs from the subject's current folded value, so
- *  re-asserting an unchanged line doesn't append a no-op duplicate per keystroke.
- *  Everything else gets a real add/remove diff — but the CALLER decides whether
- *  `toRemoveIds` is safe to apply, and must skip it whenever the parse reported
- *  any unrecognized line. */
+ *  Everything else keeps its bare subject — every reader takes those raw, and
+ *  a stamped one names a subject no verb resolves. They get a real add/remove
+ *  diff — but the CALLER decides whether `toRemoveIds` is safe to apply, and
+ *  must skip it whenever the parse reported any unrecognized line. */
 export function planMudEditorSync(rows, state, triples) {
+  const editTurn = (state?.turnCount ?? 0) + 1;
+  const editEpoch = state?.epoch ?? 0;
+  const stampedForFold = (t) => ({ ...t, subject: snapshotSubject(t.subject, editTurn, editEpoch) });
   const toAppend = [];
   // One "already said this" set per fold-versioned family, never one shared set:
   // a subject can carry a placement, an openness and a mass at once, and a
@@ -320,13 +338,13 @@ export function planMudEditorSync(rows, state, triples) {
     seen.add(t.subject);
     if (t.kind === PLACEMENT_KIND) {
       const current = state.placements?.get(t.subject);
-      if (!current || current.predicate !== t.predicate || current.object !== t.object) toAppend.push(t);
+      if (!current || current.predicate !== t.predicate || current.object !== t.object) toAppend.push(stampedForFold(t));
     } else if (t.kind === OPENNESS_KIND) {
       const current = state.openness?.get(t.subject);
-      if (!current || current.open !== (t.object === "true")) toAppend.push(t);
+      if (!current || current.open !== (t.object === "true")) toAppend.push(stampedForFold(t));
     } else {
       const current = state.masses?.get(t.subject);
-      if (!current || Number(current.value) !== Number(t.object)) toAppend.push(t);
+      if (!current || Number(current.value) !== Number(t.object)) toAppend.push(stampedForFold(t));
     }
   }
 
@@ -342,7 +360,7 @@ export function planMudEditorSync(rows, state, triples) {
   for (const [key, id] of currentKeys) {
     if (!newOtherKeys.has(key)) toRemoveIds.push(id);
   }
-  return { toAppend, toRemoveIds };
+  return { toAppend, toRemoveIds, editTurn };
 }
 
 /** The additive half of planMudEditorSync, for ONE already-parsed triple: the
@@ -350,7 +368,13 @@ export function planMudEditorSync(rows, state, triples) {
  *  document says what the world contains, so a fact missing from it has gone;
  *  one sentence only ever says what it says, so nothing it leaves out is
  *  evidence of anything. Re-asserting a fact the world already holds appends
- *  nothing, and `reason` says which of the two happened. Pure. */
+ *  nothing, and `reason` says which of the two happened. Pure.
+ *
+ *  The triple comes back with its bare subject, unlike planMudEditorSync's
+ *  rows: a taught sentence can MINT the thing it talks about, and the caller
+ *  picks the fresh id, so only the caller knows which subject the fold stamp
+ *  belongs on. world-teach.mjs stamps a fold-versioned one at `turnCount + 1`
+ *  there, for the same reason planMudEditorSync does. */
 export function planTaughtMudTriple(rows, state, triple) {
   if (!triple?.subject || !triple?.object) return { toAppend: [], reason: "nothing parsed" };
   if (triple.kind === PLACEMENT_KIND) {

package/src/services/mud-viz.mjs

@@ -170,7 +170,10 @@ export function carriedItemsFor(rows, state, character) {
   return [...state.placements]
     .filter(([, p]) => p.predicate === "mgx:located-in" && p.object === character)
     .map(([subject]) => ({ subject, spriteClass: spriteClassForObject(rows, subject) }))
-    .sort((a, b) => a.subject.localeCompare(b.subject));
+    // Codepoint order, never localeCompare — inlined, not a module-level
+    // helper, because this function is spliced verbatim into the page's own
+    // inline script and can carry no outer-scope reference with it.
+    .sort((a, b) => (a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : 0));
 }
 
 /** Every room's depth level, `Map<roomId, number>`, BFS from `root` at level
@@ -1994,7 +1997,10 @@ function pageScript() {
         svg: creature ? spriteSvgFor(speciesOfCharacter(subject), editRows, subject) : objectSvgFor(subject, editRows),
       });
     }
-    here.sort(function (a, b) { return a.subject.localeCompare(b.subject); });
+    // Codepoint order, never localeCompare — a placed subject traces back to
+    // a world fact, and two readers must render the same room-detail cast
+    // order regardless of the browser's own locale.
+    here.sort(function (a, b) { return a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : 0; });
     castEl.innerHTML = here.map(function (t) { return editCardHtml(t.subject, t.label, t.svg); }).join("");
     const kind = roomKindForRoom(editRows, selectedRoomId);
     const ways = [...(editState.exits.get(selectedRoomId) || new Map()).keys()].sort();

package/src/services/mudiii-turn.mjs

@@ -805,10 +805,12 @@ const PLACED_BY_PREDICATE = "mgx:placed-by";
 
 // The families foldTownSquareState ranks by (epoch, turn). A row in one of
 // them needs a snapshot subject or it ranks as turn 0 and loses to anything
-// already played about the same thing. mgx:placed-by is read raw and keeps
-// its bare subject, exactly as placeFood writes it.
+// already played about the same thing. mgx:placed-by is one of them: placeFood
+// writes the item's first placer under a bare subject when it mints the item,
+// so a taught placer that stayed bare too would tie with it at turn 0 and win
+// only by sitting later in the array.
 const TAUGHT_SNAPSHOT_PREDICATES = new Set([
-  PLACEMENT_PREDICATE, MASS_PREDICATE, MOOD_PREDICATE, FACING_PREDICATE,
+  PLACEMENT_PREDICATE, MASS_PREDICATE, MOOD_PREDICATE, FACING_PREDICATE, PLACED_BY_PREDICATE,
 ]);
 
 // The closed cast vocabulary a taught sentence may name, matching the lane's

package/src/services/mudiii-viz.mjs

@@ -230,7 +230,10 @@ export function propPlacementsFrom(rows, assetManifest) {
       asset: byKey.get(entry.model) || null,
     });
   }
-  placements.sort((a, b) => a.id.localeCompare(b.id));
+  // Codepoint order, never localeCompare — inlined, not a module-level
+  // helper, because this function is spliced verbatim into the page's own
+  // inline script and can carry no outer-scope reference with it.
+  placements.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
   return placements;
 }
 
@@ -286,7 +289,10 @@ export function currentPlacementsFrom(rows) {
   for (const [subject, entry] of latest) {
     if (!gone.has(subject)) placements.push({ subject, cell: entry.cell });
   }
-  placements.sort((a, b) => a.subject.localeCompare(b.subject));
+  // Codepoint order, never localeCompare — inlined, not a module-level
+  // helper, because this function is spliced verbatim into the page's own
+  // inline script and can carry no outer-scope reference with it.
+  placements.sort((a, b) => (a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : 0));
   return placements;
 }
 

package/src/services/news.mjs

@@ -23,10 +23,14 @@
 //              ledger is built from state.ledger via ledgerFromPayload only
 //              for the span of one call, then folded back with ledgerPayload.
 //   providers  { newsFetchers: Map<sourceId, { id, fetchItems }>,
-//              getResearchProvider({ source }), preflightNewsUrl?(url) } —
+//              getResearchProvider({ source }), preflightNewsUrl?(url),
+//              queryBandTerm?({band, term, exclusiveStartKey, limit}) } —
 //              every fetcher and provider this session may call, already
 //              constructed (adapters own I/O construction, never this
-//              module).
+//              module). `queryBandTerm` is subgraph-retrieval.mjs's
+//              `termQueryOverDocumentClient`, built once over the caller's own
+//              DynamoDB client; absent (the browser surface, tests with no
+//              band fixture) simply skips the band-grounding fallback below.
 //   now        a function returning the caller's clock reading (ISO string
 //              or ms), or a fixed reading directly. Never read from here —
 //              the wall clock enters only through this parameter.
@@ -41,7 +45,7 @@
 // section 3). Network lives in the adapters this module is handed, never
 // inside it.
 
-import { normFactTerm, normFactPredicate, factIdFor } from "../domain/hash.mjs";
+import { normFactTerm, normFactPredicate, normText, factIdFor } from "../domain/hash.mjs";
 import {
   newsWindowRows, renderNewsParagraph, buildNewsItems, evictNewsFacts,
   conceptTerms, isQuantityTerm, newsItemKeys,
@@ -59,8 +63,11 @@ import {
 } from "../adapters/corpus/news-sources.mjs";
 import { DEFAULT_MIN_INTERVAL_MS } from "../adapters/corpus/courtesy.mjs";
 import { researchFacts } from "../adapters/corpus/research-source.mjs";
+import { factFromBandRow } from "../adapters/memory/corpus-bands.mjs";
 import { throughSourceBreaker, sourceSkipStatusLine } from "../domain/source-breaker.mjs";
-import { ingestText, readsAsEntityTerm, ungroundedTermOccurrences } from "./extract-facts.mjs";
+import {
+  ingestText, readsAsEntityTerm, ungroundedTermOccurrences, termsUsedOnlyAsVerbs,
+} from "./extract-facts.mjs";
 
 export { NEWS_SOURCE_RECORDS, DEFAULT_NEWS_SOURCE_IDS, DEFAULT_NEWS_KB_IDS };
 
@@ -316,11 +323,19 @@ function buildSourcesByFactId(items) {
  *  drops a term the graph already holds facts about, and a card wants precisely
  *  those. A single word the lexicon reads as an everyday noun drops out here —
  *  "developer" names nothing a lookup could define — while a name run keeps its
- *  whole spelling, "tim king" and "amigados" alike. */
+ *  whole spelling, "tim king" and "amigados" alike.
+ *
+ *  A word the article only ever uses as a clause's verb names no entity either,
+ *  however the tagger read it: "many say it is …" is the article saying
+ *  something, and "the government moves to assert control" is the government
+ *  moving. Either one reaching this list gives a card's background walk an
+ *  anchor the article never named. */
 export function articleEntityNames(texts, { lexicon } = {}) {
   const lex = lexicon || loadLexicon();
+  const verbs = termsUsedOnlyAsVerbs(texts, { lexicon: lex });
   const names = [];
   for (const term of ungroundedTermOccurrences(texts, [], { lexicon: lex }).keys()) {
+    if (verbs.has(term)) continue;
     if (term.includes(" ") || !isVocabGroundedTerm(lex, term)) names.push(term);
   }
   return names.sort();
@@ -741,6 +756,139 @@ const KB_SOURCE_TO_RESEARCH_CHOICE = Object.freeze({
   "dbpedia-lookup": "dbpedia",
 });
 
+const ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
+
+const WORD_CHARACTER_RE = /[a-z0-9]/;
+
+/** True when `prose` names `term` as a whole word — the test for whether a
+ *  looked-up body is a STATEMENT about the term or merely a LABEL for it.
+ *
+ *  A reference article's summary opens on the word it defines ("AmigaDOS is
+ *  the disk operating system of the AmigaOS"). An entity description field
+ *  does not: it is a bare noun phrase naming the class instead ("disk
+ *  operating system of the AmigaOS"), and a sentence recognizer reading one
+ *  finds a subject, a verb and an object inside the phrase itself — "disk
+ *  operates a system of the amigaos", a claim about a word the lookup was
+ *  never about. The class such a phrase names is what the structured tier
+ *  already carries, so there is nothing to lose by leaving it unread. */
+function proseNamesTerm(prose, term) {
+  const haystack = normText(prose).toLowerCase();
+  const needle = normFactTerm(term);
+  if (!haystack || !needle) return false;
+  for (let from = 0; ; from += 1) {
+    const at = haystack.indexOf(needle, from);
+    if (at < 0) return false;
+    const before = at === 0 ? "" : haystack[at - 1];
+    const after = haystack[at + needle.length] ?? "";
+    if (!WORD_CHARACTER_RE.test(before) && !WORD_CHARACTER_RE.test(after)) return true;
+    from = at;
+  }
+}
+
+/** Every name the looked-up definition is ABOUT: the term that was asked and
+ *  the title the source answered with ("solar eclipse" and "Solar eclipse",
+ *  "u.s. virgin islands" and "United States Virgin Islands"), each with its
+ *  plural, since a body says "Solar eclipses can only happen during a new
+ *  moon" as readily as it says "a solar eclipse". */
+function definedTermKeys(term, article) {
+  const keys = new Set();
+  for (const name of [term, article?.term, article?.title]) {
+    const key = normFactTerm(name ?? "");
+    if (!key) continue;
+    keys.add(key);
+    keys.add(normFactTerm(pluralOf(key)));
+  }
+  return keys;
+}
+
+const SENTENCE_WORD_RE = /[a-z0-9][a-z0-9'’-]*/g;
+
+const COPULAS = new Set(["is", "are", "was", "were", "be", "been", "being"]);
+
+// Words that mean the copula opened something other than the term's class:
+// a clause ("an earthquake is WHEN tectonic plates shake"), a denial ("Puerto
+// Rico is NOT an independent country"), a second phrase ("is one OF the...")
+// or a list ("is a state AND a...").
+const CLASS_PHRASE_BREAKERS = new Set([
+  "not", "no", "never", "n't", "nor",
+  "when", "where", "while", "why", "how", "who", "whom", "whose", "which", "that",
+  "what", "because", "if", "whether", "unless", "until", "since", "though", "although",
+  "of", "in", "on", "at", "from", "with", "by", "to", "for", "about", "into", "onto",
+  "over", "under", "between", "among", "during", "near", "across", "through", "against",
+  "and", "or", "but",
+]);
+
+/** True when `sentence` states `object` as the class the copula introduces —
+ *  the test for whether a class claim read out of a definition body is what
+ *  the body actually says the term is.
+ *
+ *  The optimistic tier answers with a class it found somewhere in the
+ *  sentence, which is right when the sentence is a definition ("A tsunami is
+ *  a natural disaster" -> disaster) and wrong the moment the copula opens
+ *  anything else. "An earthquake is when Earth's tectonic plates shake"
+ *  yields "an earthquake is an earth"; "Puerto Rico is not an independent
+ *  country" yields the exact claim the sentence denies. So the class has to
+ *  sit inside the noun phrase the copula introduces: only determiners,
+ *  numbers and adjectives may stand between them, never a clause, a
+ *  preposition, a conjunction or a negation. A body that states its class
+ *  some other way keeps it to itself, which costs a fact and never a wrong
+ *  one. */
+function bodyStatesClass(sentence, object) {
+  const words = String(sentence ?? "").toLowerCase().match(SENTENCE_WORD_RE) || [];
+  const head = (normFactTerm(object).match(SENTENCE_WORD_RE) || [])[0];
+  if (!head || !words.length) return false;
+  const plural = pluralOf(head);
+  const namesHead = (word) => {
+    const bare = word.replace(/['’]s$/, "");
+    return bare === head || bare === plural || pluralOf(bare) === head;
+  };
+  for (let at = 0; at < words.length; at += 1) {
+    if (!namesHead(words[at])) continue;
+    for (let back = at - 1; back >= 0; back -= 1) {
+      if (CLASS_PHRASE_BREAKERS.has(words[back])) break;
+      if (COPULAS.has(words[back])) return true;
+    }
+  }
+  return false;
+}
+
+/** The rows a definition body is allowed to give up: those about the term it
+ *  defines, and — for a class claim — those the body states as that term's
+ *  class. A body is evidence about its own subject, so a row whose subject is
+ *  some other term the prose merely mentions ("Every year there are about two
+ *  solar eclipses" -> a year is a kind of eclipse; "The Calpine Corporation
+ *  operates and owns 19 of the 22 facilities" -> a corporation owns a
+ *  facility) is not a definition of anything and is dropped. */
+function factsDefinitionBodyStates(rows, termKeys) {
+  return rows.filter((row) => {
+    if (!termKeys.has(normFactTerm(row.subject))) return false;
+    if (!ISA_PREDICATES.has(row.predicate)) return true;
+    return bodyStatesClass(row.sentence, row.object);
+  });
+}
+
+const provenanceHead = (tag) => String(tag ?? "").split(/[\s@]/)[0];
+
+const tripleKeyOf = (row) => `${normFactTerm(row.subject)}\0${normFactPredicate(row.predicate)}\0${normFactTerm(row.object)}`;
+
+/** Retracts rows this call's ingest wrote and the definition-body rule then
+ *  turned down. ingestText has already stored them by the time their rows
+ *  come back, so they are matched by triple under this ingest's own
+ *  provenance and removed — the same retract-after-write path the recognizer
+ *  takes for a fragment term. */
+async function retractRejectedBodyFacts(ctx, rejected, provenance) {
+  const { memoryDir, store, now } = ctx;
+  if (!rejected.length) return;
+  const keys = new Set(rejected.map(tripleKeyOf));
+  const rows = store.readFactRows(await store.loadMemory(memoryDir));
+  const ids = rows
+    .filter((row) => keys.has(tripleKeyOf(row)) && provenanceHead(row.provenance).endsWith(provenanceHead(provenance)))
+    .map((row) => row.id);
+  if (!ids.length) return;
+  await store.removeFacts(memoryDir, ids, { retractedAt: resolveNow(now) });
+  invalidateCache(ctx.cache);
+}
+
 /** Grounds `article` under `provider`'s own provenance tag, through the SAME
  *  ingest seam a polled article takes: the structured or isa facts the
  *  research-source seam licenses (researchFacts), then the article's own
@@ -748,7 +896,23 @@ const KB_SOURCE_TO_RESEARCH_CHOICE = Object.freeze({
  *  looked-up article therefore reaches the graph with the density of
  *  relations a polled one does, and the feed's paraphrase templates have the
  *  same kind of material to write a card from — a bare isa edge left the
- *  reader with one bald sentence where a polled item got a paragraph. */
+ *  reader with one bald sentence where a polled item got a paragraph.
+ *
+ *  Two things a definition body is not allowed to do, both of them ways of
+ *  restating the lookup's own class claim worse than the lookup already
+ *  stated it. It is not read at all unless it names the term (proseNamesTerm,
+ *  above). And where the lookup already licensed a class for the term, the
+ *  body is read by the strict recognizer only: the optimistic tier's guess at
+ *  a class can then only agree with what the structured rows say or truncate
+ *  it — "AmigaDOS is the disk operating system" mints "amigados is a disk"
+ *  beside the structured "amigados is a disk operating system" — while the
+ *  relations the body states ("Rottnest has a lighthouse") are the strict
+ *  tier's own work and survive either way.
+ *
+ *  What the body does give up is then held to what it says about the term it
+ *  defines (factsDefinitionBodyStates): a row about some other term the prose
+ *  mentions, or a class the sentence never states, is retracted before it can
+ *  reach the feed or a syllogism. */
 async function ingestResearchArticle(ctx, term, provider, article) {
   const { memoryDir, store, config, lexicon, now } = ctx;
   const provenance = provider.provenanceTag(term);
@@ -757,19 +921,25 @@ async function ingestResearchArticle(ctx, term, provider, article) {
     await store.appendFacts(memoryDir, structured);
     invalidateCache(ctx.cache);
   }
+  const lookupStatedClass = structured.some(
+    (f) => ISA_PREDICATES.has(f.predicate) && normFactTerm(f.subject) === normFactTerm(term),
+  );
 
   const prose = String(article.summary || article.text || "").trim();
-  let ingested = { extracted: [], optimistic: [] };
-  if (prose) {
-    ingested = await ingestText(prose, {
-      memoryDir, sourceTag: provenance, optimistic: true,
+  let fromBody = [];
+  if (prose && proseNamesTerm(prose, term)) {
+    const ingested = await ingestText(prose, {
+      memoryDir, sourceTag: provenance, optimistic: !lookupStatedClass,
       lexicon: lexicon || loadLexicon(), observedAt: resolveNow(now), findings: true,
       attributeToSource: true,
     });
     invalidateCache(ctx.cache);
+    const read = [...ingested.extracted, ...ingested.optimistic];
+    fromBody = factsDefinitionBodyStates(read, definedTermKeys(term, article));
+    await retractRejectedBodyFacts(ctx, read.filter((row) => !fromBody.includes(row)), provenance);
   }
 
-  const facts = [...structured, ...ingested.extracted, ...ingested.optimistic];
+  const facts = [...structured, ...fromBody];
   if (!facts.length) return { facts: 0, derived: 0 };
   const distinct = new Set(facts.map(
     (f) => `${normFactTerm(f.subject)}\0${normFactPredicate(f.predicate)}\0${normFactTerm(f.object)}`,
@@ -783,6 +953,88 @@ async function ingestResearchArticle(ctx, term, provider, article) {
   return { facts: distinct.size, derived };
 }
 
+// The bands this fallback reads. All three are reference content — dictionary
+// senses and everyday commonsense edges, not news entities — so they ground
+// the ordinary nouns a headline mentions in passing ("harbor", "senator",
+// "penguin") without ever costing a KB round trip on those.
+const BAND_TERM_LOOKUP_BANDS = Object.freeze(["child", "conceptnet", "wordnet-complete"]);
+const BAND_TERM_LOOKUP_LIMIT = 50;
+// A local DynamoDB Query has no courtesy throttle and nothing external to
+// protect, but it still has to return: the enrich cycle shares the same wall
+// budget every other phase does, and this runs once per candidate term. A
+// slow or hung Query loses the race and reads as a miss — a timeout is a
+// miss, never a guess — rather than stalling the whole cycle behind it.
+// The bands are read in parallel against one deadline, so the budget buys
+// every band at once: each is a single-partition begins_with read of its own,
+// and the worst case stays one timeout however many bands there are.
+const BAND_TERM_LOOKUP_TIMEOUT_MS = 750;
+
+/** `term`'s rows from one band, as `{subject, predicate, object, provenance}`
+ *  triples — or `[]` when the band carries nothing for it or the Query
+ *  throws. A band that fails is a band with nothing to say, so the others'
+ *  rows survive it. */
+async function bandTermFacts(queryBandTerm, band, term) {
+  let response;
+  try {
+    response = await queryBandTerm({ band, term, limit: BAND_TERM_LOOKUP_LIMIT });
+  } catch {
+    return [];
+  }
+  const facts = [];
+  for (const row of response?.rows || []) {
+    const fact = factFromBandRow(row);
+    if (fact) facts.push(fact);
+  }
+  return facts;
+}
+
+/** `term`'s rows from every band, as `{subject, predicate, object,
+ *  provenance}` triples ready for `appendFacts` — or `[]` when no band
+ *  carries it. Each band's Query races the SAME deadline, so a band that
+ *  hangs costs the cycle one timeout rather than one per band, and the bands
+ *  that answered inside it keep their rows. A fact both a band and the seed
+ *  already hold arrives with the band's own provenance, so it corroborates
+ *  rather than duplicating. `ctx.providers.queryBandTerm` is absent on the
+ *  browser surface and in most tests, so this is a no-op there by
+ *  construction, not a special case here. */
+async function groundTermFromBand(ctx, term) {
+  const queryBandTerm = ctx.providers?.queryBandTerm;
+  if (typeof queryBandTerm !== "function") return [];
+  let deadlineTimer;
+  const deadline = new Promise((resolve) => {
+    deadlineTimer = setTimeout(() => resolve(null), BAND_TERM_LOOKUP_TIMEOUT_MS);
+  });
+  try {
+    const perBand = await Promise.all(BAND_TERM_LOOKUP_BANDS.map(
+      (band) => Promise.race([bandTermFacts(queryBandTerm, band, term), deadline]),
+    ));
+    return perBand.flatMap((facts) => facts || []);
+  } finally {
+    clearTimeout(deadlineTimer);
+  }
+}
+
+/** Grounds `term` from `facts` — a band's own rows, already resolved
+ *  `{subject, predicate, object, provenance}` triples with no article prose
+ *  to walk, so this skips straight to append + syllogise rather than
+ *  repeating ingestResearchArticle's structured/prose split. Same shape of
+ *  return as ingestResearchArticle, so the caller folds it in identically. */
+async function ingestBandFacts(ctx, facts) {
+  const { memoryDir, store, config } = ctx;
+  await store.appendFacts(memoryDir, facts);
+  invalidateCache(ctx.cache);
+  const distinct = new Set(facts.map(
+    (f) => `${normFactTerm(f.subject)}\0${normFactPredicate(f.predicate)}\0${normFactTerm(f.object)}`,
+  ));
+  let derived = 0;
+  if (config.syllogismsPerIngest > 0) {
+    const focus = [...termFocusOf(facts)];
+    const res = await syllogise(memoryDir, { focus, expandFocus: true, budget: config.syllogismsPerIngest, store });
+    derived = res?.count || 0;
+  }
+  return { facts: distinct.size, derived };
+}
+
 /** One KB lookup behind its source's circuit breaker. A source that has been
  *  timing out or throttling is skipped without a round trip, and the skip is
  *  reported so the cycle can tell "this source had nothing" from "this source
@@ -851,6 +1103,20 @@ export async function enrichTopTerms(ctx, { limit } = {}) {
     // pending so the next cycle picks it up, never into the negative cache.
     if (aborted) { markTerm(ledger, entry.term, "pending", nowVal); break; }
     if (!hit) {
+      // Every configured KB source came back empty (or none is configured) —
+      // try the corpus bands before giving up. They're another source the
+      // resolver can reach, not a replacement for the KB walk above: a
+      // headline's proper nouns still need a KB lookup, but its everyday
+      // vocabulary is often already sitting in a band.
+      const bandFacts = await groundTermFromBand(ctx, entry.term);
+      if (bandFacts.length) {
+        const res = await ingestBandFacts(ctx, bandFacts);
+        factsTotal += res.facts;
+        derivedTotal += res.derived;
+        markTerm(ledger, entry.term, "grounded", nowVal);
+        enriched.push(entry.term);
+        continue;
+      }
       // No source was asked, so nothing learned this term is missing —
       // the same posture a stop takes, for the same reason.
       markTerm(ledger, entry.term, askedAnySource ? "missed" : "pending", nowVal);

package/src/services/research-viz.mjs

@@ -54,7 +54,7 @@ export function sourceLabelFor(source) {
   const BANDS = {
     human: "human persona", "human-medium": "human persona", "human-large": "human persona",
     seon: "SEON ontology", conceptnet: "ConceptNet",
-    "tier2-aws": "AWS", "tier2-python": "Python", "tier2-java": "Java", "wordnet-xl": "WordNet",
+    "wordnet-xl": "WordNet", namenet: "NameNet", child: "child vocabulary",
   };
   const key = (source && source.key) || "";
   if (key === "taught") return { label: "taught by telling", tone: "taught" };