@polycode-projects/the-mechanical-code-talker 6.0.18 → 6.0.20

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 } 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 };
 
@@ -77,6 +84,9 @@ export const NEWS_DEFAULTS = Object.freeze({
   enrichTermsPerCycle: 3,
   negativeCacheTtlHours: 24,
   syllogismsPerIngest: 12,
+  // Per source, not across the whole poll: each enabled source keeps its own
+  // window of up to this many snapshots, so one prolific source can never
+  // crowd another out of the window before either has been read.
   itemCap: 30,
   newsFactCap: 4000,
   feedTop: 3,
@@ -246,18 +256,19 @@ function abortSignalOf(ctx) {
   return typeof ctx?.shouldAbort === "function" ? ctx.shouldAbort : () => false;
 }
 
-// A feed title rarely carries its own terminal punctuation ("Scientists
-// Discover New Species"); a fixture built from a full sentence ("A module is
-// a component.") already does. Joining unconditionally with ". " doubles the
-// period in the second case and corrupts sentence splitting downstream — so
-// the separator is a bare space when the title already ends the sentence.
-const SENTENCE_END_RE = /[.!?]["')\]]*$/;
+// The headline and the item's own description are two separate texts, so they
+// reach the ingest as two PARAGRAPHS. Run together on one line they merge into
+// one sentence whenever the headline ends on something the sentence splitter
+// will not break after — an abbreviation ("… Arrives in the U.S." + "Russia
+// released …" reads as one 26-word sentence, and the fact that falls out of it
+// has "u.s. russia" for a subject) or a description that opens on a quotation.
+// A blank line between them is the boundary ingestText already splits on.
 function joinTitleAndSummary(title, summary) {
   const t = String(title || "").trim();
   const s = String(summary || "").trim();
   if (!t) return s;
   if (!s) return t;
-  return `${t}${SENTENCE_END_RE.test(t) ? " " : ". "}${s}`;
+  return `${t}\n\n${s}`;
 }
 
 function toMs(value) {
@@ -305,6 +316,31 @@ function buildSourcesByFactId(items) {
   return map;
 }
 
+/** The entity names a card's own article text carries, read through the same
+ *  capture the enrichment queue is fed from (`ungroundedTermOccurrences`), so a
+ *  name reaches a card's background under exactly the key enrichment stored it
+ *  under. The fact set handed in is empty on purpose: that call's own filter
+ *  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.
+ *
+ *  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();
+}
+
 // ---------------------------------------------------------------------------
 // grounding definitions (10.2)
 // ---------------------------------------------------------------------------
@@ -639,10 +675,15 @@ export async function pollNewsSources(ctx) {
       recordSuccess(health, nowVal, "not-modified");
     } else {
       recordSuccess(health, nowVal, "ok");
-      const merged = mergeSnapshots(state.items, result.items, {
+      // itemCap bounds THIS source's own window: mergeSnapshots sees only
+      // sourceId's existing snapshots, so one prolific source's window
+      // never crowds out another's before either has been read.
+      const ownItems = (state.items || []).filter((snap) => snap?.sourceId === sourceId);
+      const otherItems = (state.items || []).filter((snap) => snap?.sourceId !== sourceId);
+      const merged = mergeSnapshots(ownItems, result.items, {
         cap: config.itemCap, seen: state.seenItemKeys,
       });
-      state.items = merged.items;
+      state.items = [...otherItems, ...merged.items].sort(byFetchedAtThenId);
       added = merged.added;
       newItemsTotal += added.length;
     }
@@ -715,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
@@ -722,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);
@@ -731,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)}`,
@@ -757,6 +953,68 @@ async function ingestResearchArticle(ctx, term, provider, article) {
   return { facts: distinct.size, derived };
 }
 
+// The one band this fallback reads. WordNet is dictionary content — real
+// words, not news entities — so it grounds the everyday nouns a headline
+// mentions in passing ("harbor", "senator") without ever costing a KB round
+// trip on those.
+const BAND_TERM_LOOKUP_BAND = "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.
+const BAND_TERM_LOOKUP_TIMEOUT_MS = 750;
+
+/** `term`'s rows from the wordnet-complete band, as `{subject, predicate,
+ *  object, provenance}` triples ready for `appendFacts` — or `[]` when the
+ *  band carries nothing for it, the query errors, or it doesn't return in
+ *  time. `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 [];
+  const timeout = new Promise((resolve) => { setTimeout(() => resolve(null), BAND_TERM_LOOKUP_TIMEOUT_MS); });
+  let response;
+  try {
+    response = await Promise.race([
+      queryBandTerm({ band: BAND_TERM_LOOKUP_BAND, term, limit: BAND_TERM_LOOKUP_LIMIT }),
+      timeout,
+    ]);
+  } catch {
+    return [];
+  }
+  if (!response) return [];
+  const facts = [];
+  for (const row of response.rows || []) {
+    const fact = factFromBandRow(row);
+    if (fact) facts.push(fact);
+  }
+  return facts;
+}
+
+/** 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
@@ -825,6 +1083,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 wordnet-complete band before giving up. It's 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 the 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);
@@ -875,7 +1147,15 @@ export async function enrichTopTerms(ctx, { limit } = {}) {
  *
  *  `newName` is a display-only badge (never a gate): true when the lexicon
  *  has no everyday-noun reading for the hub, computed here rather than in
- *  buildNewsItems because the domain layer carries no lexicon. */
+ *  buildNewsItems because the domain layer carries no lexicon.
+ *
+ *  `articleEntityNames` is wired in for the same reason: reading the entity
+ *  names out of a card's own article text takes the lexicon and the wink
+ *  tagger, so the domain asks for them through a seam and this layer answers
+ *  with the capture the enrichment queue already uses. It is what puts a
+ *  definition and the card that needed it on the same page — a lookup on
+ *  "amigados" reaches a card whose only fact is that a site discussed the
+ *  headline the name sits inside. */
 export async function buildFeed(ctx) {
   const { memoryDir, store, config, state, now, lexicon } = ctx;
   const nowVal = resolveNow(now);
@@ -886,7 +1166,12 @@ export async function buildFeed(ctx) {
 
   const lex = lexicon || loadLexicon();
   const items = buildNewsItems(rows, {
-    now: nowVal, windowMs, limit: config.itemCap, sourcesByFactId, readsAsEntityTerm,
+    now: nowVal,
+    windowMs,
+    limit: config.itemCap,
+    sourcesByFactId,
+    readsAsEntityTerm,
+    articleEntityNames: (texts) => articleEntityNames(texts, { lexicon: lex }),
   }).map((item) => ({ ...item, newName: !isVocabGroundedTerm(lex, item.hub) }));
   return { items, seedFallback: false, builtAt: 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" };

package/src/services/sprite-catalog-viz.mjs

@@ -64,6 +64,11 @@ import { splitSceneBackdrop } from "../domain/scene-compose.mjs";
 const DEFAULT_TITLE = "tmct — the sprite library";
 const MAX_CHAIN_DISPLAY = 6;
 
+// Codepoint order, never localeCompare — an ancestor/class term walks the
+// same rdfs:subClassOf fact rows the cards' ancestry pills print, and two
+// readers must render the same ontology-tree order regardless of locale.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /** A curated gap-fill for classes wordnet-xl's own prioritized subset
  *  happens to carry NO rdfs:subClassOf row for at all (115 of 198 catalog
  *  classes, checked directly against a build of this page) — every pair
@@ -244,8 +249,8 @@ export function clusterEntriesByAncestor(entries, spritedClasses) {
     if (key && list.length >= 2) clusters.push({ ancestor: key, entries: list });
     else rest.push(...list);
   }
-  clusters.sort((a, b) => b.entries.length - a.entries.length || a.ancestor.localeCompare(b.ancestor));
-  if (rest.length) clusters.push({ ancestor: null, entries: [...rest].sort((a, b) => a.className.localeCompare(b.className)) });
+  clusters.sort((a, b) => b.entries.length - a.entries.length || byCodepoint(a.ancestor, b.ancestor));
+  if (rest.length) clusters.push({ ancestor: null, entries: [...rest].sort((a, b) => byCodepoint(a.className, b.className)) });
   return clusters;
 }
 
@@ -463,12 +468,12 @@ export function buildOntologyTree(section, { index, spritedClasses, entriesByCla
       levels[level].push(nodeFor(term));
     }
     for (let i = 0; i < levels.length; i += 1) {
-      levels[i] = (levels[i] || []).sort((a, b) => a.term.localeCompare(b.term));
+      levels[i] = (levels[i] || []).sort((a, b) => byCodepoint(a.term, b.term));
     }
     branches.push({ size: terms.length, key: terms.slice().sort()[0], levels });
   }
-  branches.sort((a, b) => b.size - a.size || a.key.localeCompare(b.key));
-  apart.sort((a, b) => a.term.localeCompare(b.term));
+  branches.sort((a, b) => b.size - a.size || byCodepoint(a.key, b.key));
+  apart.sort((a, b) => byCodepoint(a.term, b.term));
   return { branches, apart, termCount: allTerms.size, truncated };
 }
 

package/src/surfaces/web/adventure-browser-entry.mjs

@@ -44,7 +44,7 @@ import { parseEntities } from "../../domain/codegraph.mjs";
 import { memoryFactGraphPayload } from "../../domain/memory-facts.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { DEFAULT_GAME_CONFIG } from "../../domain/game-config.mjs";
-import { foldWorldState, worldDigestRows, roomAffordances, worldActionRows, snapshotSubject } from "../../services/adventure.mjs";
+import { foldWorldState, worldDigestRows, roomAffordances, worldActionRows } from "../../services/adventure.mjs";
 import { runAdventureAutoplayTick, exposedFacts } from "../../services/adventure-autoplay.mjs";
 import { parseWorldEditorText, planWorldEditorSync } from "../../services/adventure-editor.mjs";
 import { resolveSpriteForClass, SPRITE_REGISTRY, classAncestorChain } from "../../domain/sprite-map.mjs";
@@ -209,24 +209,18 @@ export async function createAdventureSession(worldPayload, { restoredPayload = n
      *  see adventure-editor.mjs's own header for why a typo must never be
      *  read as "this fact is gone". Returns `{ unrecognized, added, removed }`.
      *
-     *  A placement or openness edit is written as a TURN SNAPSHOT, the way
-     *  every played turn writes one. foldWorldState ranks an unstamped row as
-     *  turn 0, so an edit to something already played — the lamp taken on
-     *  turn 4, then moved back to the desk in the editor — would be outranked
-     *  by the very move it was meant to correct, and the edit would land in
-     *  the store and change nothing anyone can see. Type/exit/puzzle rows are
-     *  read raw and keep their bare subject: a stamped one names a subject no
-     *  verb resolves. */
+     *  A placement or openness edit arrives from the planner already written
+     *  as a TURN SNAPSHOT, the way every played turn writes one, so all this
+     *  has to add is the matching provenance tag. */
     async applyEdit(text) {
       const allRows = readFactRows(await loadMemory(memoryDir));
       const worldRows = allRows.filter((r) => typeof r.provenance === "string" && r.provenance.indexOf(tag) === 0);
       const state = foldWorldState(worldRows);
       const { triples, unrecognized } = parseWorldEditorText(text, worldRows);
-      const { toAppend, toRemoveIds } = planWorldEditorSync(worldRows, state, triples);
-      const editTurn = state.turnCount + 1;
+      const { toAppend, toRemoveIds, editTurn } = planWorldEditorSync(worldRows, state, triples);
       if (toAppend.length) {
         await appendFacts(memoryDir, toAppend.map((f) => ({
-          subject: f.kind === "other" ? f.subject : snapshotSubject(f.subject, editTurn, state.epoch),
+          subject: f.subject,
           predicate: f.predicate,
           object: f.object,
           provenance: f.kind === "other" ? tag : `${tag}:turn${editTurn}`,