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

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;
 }