@polycode-projects/the-mechanical-code-talker 2.9.0 → 2.9.3

package/src/domain/reference-pack.mjs

@@ -70,3 +70,105 @@ export function cleanMissReferenceTerm(term, lexicon = loadLexicon()) {
   if (!entry) return null;
   return normFactTerm(entry.lemma);
 }
+
+// ---- the live Wikipedia supplement (opt-in): the pure half -----------------
+
+export const LIVE_PACK_NAME = "wikipedia-live";
+
+/** The provenance tag a fact stored from a LIVE Wikipedia article carries —
+ *  the same reference:<pack>:<article>@<revid> shape the shipped pack uses,
+ *  so memory/trust.mjs parses it with no change: kind "reference", pack
+ *  "wikipedia-live". */
+export function liveProvenanceTag(article) {
+  return `reference:${LIVE_PACK_NAME}:${article.title}@${article.revid}`;
+}
+
+/** The cited answer for a clean miss the live lookup could ground: the
+ *  article's summary with its title, the LIVE source named, the licence and
+ *  the revision-pinned URL always visible. */
+export function renderLiveReferenceAnswer(term, article) {
+  return `${term} — ${article.summary} (source: live Wikipedia article "${article.title}", `
+    + `English Wikipedia, CC BY-SA 4.0 — ${article.url}?oldid=${article.revid})`;
+}
+
+/** The pure half of the LIVE clean-miss gate — same fold, shape check and
+ *  RELATION_TERM exclusion as cleanMissReferenceTerm, but WITHOUT the
+ *  lexicon-membership wall: a word the lexicon has never met is exactly what
+ *  a live lookup is for. A known lexicon entry still resolves to its lemma
+ *  (so "otters" and "otter" share one key); an unknown word keys on its own
+ *  folded form. Capped at three words — longer phrases are never a clean
+ *  vocabulary miss. */
+export function cleanMissLiveTerm(term, lexicon = loadLexicon()) {
+  const t = normFactTerm(term);
+  if (!t || !/^[a-z][a-z' -]*$/.test(t)) return null;
+  if (RELATION_TERM[t]) return null;
+  if (t.split(/\s+/).length > 3) return null;
+  const entry = lookupNoun(lexicon, t);
+  return entry ? normFactTerm(entry.lemma) : t;
+}
+
+// ---- summary/isa extraction, shared by the pack build and the live lookup --
+
+export const SUMMARY_CHAR_CAP = 400;
+
+/** Whole leading sentences of `text` up to `cap` chars; a first sentence
+ *  longer than the cap is hard-cut at it. */
+export function sentencesUpTo(text, cap) {
+  const parts = String(text ?? "").split(/(?<=[.!?])\s+/);
+  let out = "";
+  for (const part of parts) {
+    const candidate = out ? `${out} ${part}` : part;
+    if (candidate.length > cap) break;
+    out = candidate;
+  }
+  return out || String(text ?? "").slice(0, cap);
+}
+
+const ISA_RE = /^[A-Z][^.!?]{0,80}? (?:is|are) (?:(a|an|the) )?([a-z][a-z -]{1,60})/;
+
+// Words that end the noun phrase: a relative clause or a trailing modifier
+// carries detail, not the category ("a place where ships shelter" → place).
+const ISA_CLAUSE_CUT = new Set([
+  "that", "which", "where", "who", "whose", "whom", "when", "used", "found",
+  "made", "with", "in", "on", "for", "from", "by", "to", "and", "or",
+]);
+// Classifier heads carry no category of their own ("a member of the cat
+// family" names family membership, not what the thing is) — no isa beats a
+// generic one, because a stored subClassOf must stay meaningful.
+const ISA_GENERIC_HEADS = new Set([
+  "type", "kind", "sort", "form", "class", "variety", "group", "part",
+  "piece", "member", "way", "term", "name", "word", "thing", "example",
+  "family", "genus", "species", "unit", "series", "set", "list", "number",
+  "amount",
+]);
+const ISA_ARTICLES = new Set(["a", "an", "the"]);
+
+/** The isa lemma of a lead's first sentence, or null. The copula must sit in
+ *  the first sentence; an of-chain resolves to its final noun ("a kind of
+ *  dog" → dog); a bare-plural predicate counts only when the head is an
+ *  inflected plural the lexicon folds ("are animals that…" → animal, but
+ *  "is light" stays null); a generic classifier head is no isa at all. */
+export function isaOf(plain, lexicon) {
+  const m = String(plain ?? "").match(ISA_RE);
+  if (!m) return null;
+  const bare = !m[1];
+  const window = [];
+  for (const word of m[2].trim().split(/\s+/)) {
+    if (ISA_CLAUSE_CUT.has(word)) break;
+    window.push(word);
+    if (window.length >= 6) break;
+  }
+  const lastOf = window.lastIndexOf("of");
+  let headWords = lastOf >= 0 ? window.slice(lastOf + 1) : window;
+  while (headWords.length && ISA_ARTICLES.has(headWords[0])) headWords = headWords.slice(1);
+  if (!headWords.length) return null;
+  const headToken = headWords[headWords.length - 1].split("-").pop();
+  if (!headToken || ISA_GENERIC_HEADS.has(headToken)) return null;
+  const entry = lookupNoun(lexicon, headToken);
+  if (!entry) return null;
+  const lemma = normFactTerm(entry.lemma);
+  // A bare predicate ("is light") is only trusted when the head is an
+  // inflected plural the lexicon folded back to its lemma.
+  if (bare && (!/s$/.test(headToken) || normFactTerm(headToken) === lemma)) return null;
+  return lemma;
+}

package/src/domain/spider-fly-world.mjs

@@ -1,12 +1,16 @@
 // spider-fly-world.mjs — the one pure definition of the spider/fly 10x10
 // grid: cell naming, Chebyshev geometry, the fixed web block, the seed
 // taxonomy, and the static fact/rule/meta rows the shipped world carries.
-// Pure, no imports (PLAN_SPIDER_FLY.md §3/§4/§7) — both
+// Pure — the only import is the sibling pure-data game-config.mjs, so the
+// structural self-description facts below quote the same shipped defaults
+// the engine actually runs. Both
 // scripts/gen-spider-fly-world.mjs (writes corpus/worlds/src/spider-fly.jsonl)
 // and src/services/spider-fly.mjs (the runtime) read the SAME grid/web
 // constants from here, so the shipped world and the engine that plays it can
 // never drift apart.
 
+import { DEFAULT_GAME_CONFIG } from "./game-config.mjs";
+
 export const WORLD_NAME = "spider-fly";
 export const GRID_SIZE = 10;
 
@@ -147,6 +151,55 @@ export function* worldFactRows() {
   for (const [subject, superclass] of SEED_TAXONOMY) {
     yield { world: WORLD_NAME, kind: "fact", subject, predicate: "rdfs:subClassOf", object: superclass };
   }
+  yield* structuralFactRows();
+}
+
+const pluralize = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+/** The board/web/agent structure the page's own controls and copy surface,
+ *  restated as askable facts — so "what is the board?" / "what is the vision
+ *  radius?" ground instead of missing. Every number is either grid geometry
+ *  (fixed here) or a shipped tuning default (game-config.mjs); the tunable
+ *  ones say "by default" because a live session's sliders or tmct.toml can
+ *  move them, and a fact that a slider drag falsifies would be a lie.
+ *  Predicates stick to the curated/readable families the fact reader
+ *  verbalizes cleanly ("has", "is", "covers", "lasts for", "starts with",
+ *  "loses", "lays", "arrives", "hatches after/into"). */
+export function* structuralFactRows() {
+  const fact = (subject, predicate, object) => ({ world: WORLD_NAME, kind: "fact", subject, predicate, object });
+  const knobs = DEFAULT_GAME_CONFIG.spiderFly;
+  let webCellCount = 0;
+  for (let y = 1; y <= GRID_SIZE; y += 1) {
+    for (let x = 1; x <= GRID_SIZE; x += 1) {
+      if (isInWebBlock(x, y)) webCellCount += 1;
+    }
+  }
+  yield fact("board", "rdf:type", "grid");
+  yield fact("board", "mgx:hasA", pluralize(GRID_SIZE, "row"));
+  yield fact("board", "mgx:hasA", pluralize(GRID_SIZE, "column"));
+  yield fact("board", "mgx:hasA", pluralize(GRID_SIZE * GRID_SIZE, "cell"));
+  yield fact("web", "mgx:cover", `${pluralize(webCellCount, "cell")} around ${cellId(WEB_HOME.x, WEB_HOME.y)}`);
+  yield fact("web", "mgx:last-for", `${pluralize(knobs.webDurationTurns, "turn")} by default when a spider builds one`);
+  yield fact("spider", "mgx:hasA", `vision radius of ${pluralize(knobs.spiderVisionRadius, "cell")} by default`);
+  yield fact("spider", "mgx:start-with", `mass ${knobs.spiderInitialMass} by default`);
+  yield fact("spider", "mgx:lose", `${knobs.spiderMassDecrementPerTurn} mass per turn by default`);
+  yield fact("spider", "mgx:lay", `one egg at mass ${knobs.eggLayMassThreshold} by default`);
+  yield fact("fly", "mgx:hasA", `vision radius of ${pluralize(knobs.flyVisionRadius, "cell")} by default`);
+  yield fact("fly", "mgx:start-with", `mass ${knobs.flyInitialMass} by default`);
+  yield fact("fly", "mgx:lose", `${knobs.flyMassDecrementPerTurn} mass per turn by default`);
+  yield fact("fly", "mgx:arrive", `every ${pluralize(knobs.flySpawnIntervalTurns, "turn")} at the edge of the board by default`);
+  yield fact("egg", "mgx:hatch-after", `${pluralize(knobs.eggHatchDelayTurns, "turn")} by default`);
+  yield fact("egg", "mgx:hatch-into", `${pluralize(knobs.eggHatchCount, "spider")} by default`);
+  // The page's own slider label is "vision radius", so that exact term must
+  // describe too, not just the per-class rows above. One combined row while
+  // the two class defaults agree, one row per class if they ever split —
+  // never a combined claim the config doesn't actually make.
+  if (knobs.spiderVisionRadius === knobs.flyVisionRadius) {
+    yield fact("vision radius", "mgx:hasProperty", `${pluralize(knobs.spiderVisionRadius, "cell")} for both the spider and the fly by default`);
+  } else {
+    yield fact("vision radius", "mgx:hasProperty", `${pluralize(knobs.spiderVisionRadius, "cell")} for the spider by default`);
+    yield fact("vision radius", "mgx:hasProperty", `${pluralize(knobs.flyVisionRadius, "cell")} for the fly by default`);
+  }
 }
 
 /** The world's one meta row (its opening line). */