@polycode-projects/the-mechanical-code-talker 2.11.9 → 2.11.11

package/src/services/adventure.mjs

@@ -556,6 +556,44 @@ export function worldDigestRows(rows, state) {
   return out;
 }
 
+/** The physical-property lines a close "look <object>" states: the object's
+ *  own world facts, phrased through the SAME worldDigestRows view a room look
+ *  reads (so mgx:knows-*, the NPC schedule, is-objective and the rest of the
+ *  puzzle wiring are already excluded there), minus its bare rdf:type line —
+ *  the class hierarchy renders that as its own is-a chain instead. A carried
+ *  object surfaces through the "carries the" line the digest already produces.
+ *  Pure. */
+export function objectLookProperties(rows, state, object) {
+  const subjectCased = sentenceCase(object);
+  return worldDigestRows(rows, state)
+    .filter((r) => (r.subject === subjectCased && r.predicate !== "is a" && r.predicate !== "is an")
+      || (r.predicate === "carries the" && r.object === object))
+    .map((r) => `${r.subject} ${r.predicate} ${r.object}.`);
+}
+
+/** An object's class hierarchy as an is-a chain, nearest-first and opening
+ *  with the object itself ("housekeeper → person"): a breadth-first walk up
+ *  the world's OWN rdf:type and rdfs:subClassOf edges (worldActionRows, so a
+ *  merged corpus's taxonomy for the same word never joins the chain), the same
+ *  upward-class rendering chat's "what do you know about X" shows. Pure. */
+export function objectClassChain(rows, object) {
+  const worldRows = worldActionRows(rows);
+  const parentsOf = (node) => worldRows
+    .filter((r) => r.subject === node && (r.predicate === "rdf:type" || r.predicate === "rdfs:subClassOf"))
+    .map((r) => r.object);
+  const seen = new Set([object]);
+  const chain = [object];
+  const queue = [...parentsOf(object)];
+  while (queue.length) {
+    const node = queue.shift();
+    if (seen.has(node)) continue;
+    seen.add(node);
+    chain.push(node);
+    queue.push(...parentsOf(node));
+  }
+  return chain;
+}
+
 async function worldDigest(prompt, { memoryDir, memory, rows, state, graph }) {
   const view = worldDigestRows(rows, state);
   const store = {
@@ -689,7 +727,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     );
   }
 
-  if (cmd.verb === "look") {
+  if (cmd.verb === "look" && !cmd.object) {
     const digest = await worldDigest(here, { memoryDir, memory, rows, state, graph });
     const actions = roomAffordances(rows, state, here);
     return answer(
@@ -699,13 +737,13 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     );
   }
 
-  if (cmd.verb === "examine" || cmd.verb === "talk") {
+  if (cmd.verb === "examine" || cmd.verb === "talk" || cmd.verb === "look") {
     const object = cmd.object;
     // A carried object has no room to be "visible in" (visibleRoomOf returns
-    // null for anything held by the player) — examine still applies to it,
-    // the same way "what am I carrying" already reads inventory contents.
+    // null for anything held by the player) — examine and look still apply to
+    // it, the same way "what am I carrying" already reads inventory contents.
     // talk has no carried exception: NPCs are never portable.
-    const carried = cmd.verb === "examine" && carriedByPlayer(state, object);
+    const carried = (cmd.verb === "examine" || cmd.verb === "look") && carriedByPlayer(state, object);
     // The room the player is standing in is never the SUBJECT of a placement
     // fact (only ever the OBJECT other things are placed in), so
     // visibleRoomOf(object) can never equal `here` for a room's own name —
@@ -730,7 +768,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
         { miss: true },
       );
     }
-    if (notHere && !(cmd.verb === "examine" && backgroundOnlyMention(rows, state, object))) {
+    if (notHere && !((cmd.verb === "examine" || cmd.verb === "look") && backgroundOnlyMention(rows, state, object))) {
       return answer(
         `I don't see a ${object} here.`,
         noteFor(`${cmd.verb} — ${object} isn't visible in the ${here}; declined, hidden things stay hidden`),
@@ -738,6 +776,27 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       );
     }
     const person = isTyped(rows, object, "person");
+    // "look <object>" on a real placed prop is the grounded close look: every
+    // physical fact the world writes about the thing (its placement, its
+    // within-room position, any datatype property — all via the SAME
+    // worldDigestRows view that already drops the puzzle wiring and the
+    // staff-knowledge pointers), plus its class hierarchy as an is-a chain,
+    // plus a container's open/locked state. A background-only mention has no
+    // placed facts of its own, so it falls through to the examine digest below
+    // (the same general-knowledge answer "what is a flower" gives).
+    if (cmd.verb === "look" && !backgroundOnlyMention(rows, state, object)) {
+      const propLines = objectLookProperties(rows, state, object);
+      const chain = objectClassChain(rows, object);
+      const parts = [`you look closely at the ${object}.`];
+      if (propLines.length) parts.push(propLines.join(" "));
+      if (chain.length > 1) parts.push(`Class: ${chain.join(" → ")}.`);
+      if (!person && isContainer(rows, object)) parts.push(containerStatusPhrase(object, { state }));
+      return answer(
+        parts.join(" "),
+        noteFor(`look at ${object} — its world-fact properties (via worldDigestRows, knows-*/puzzle-wiring excluded) and its rdf:type/subClassOf is-a chain`),
+        { goal: `take a closer look at the ${object}` },
+      );
+    }
     // Talking to a person is the game's reveal channel: the staff share what
     // they know (a hiding place, the quest, a topic) and report their own
     // room, all resolved from the live fold this turn.

package/src/services/chat.mjs

@@ -52,7 +52,8 @@ import {
 } from "../domain/reference-pack.mjs";
 import { getReferencePackProvider } from "../adapters/corpus/reference-pack.mjs";
 import { getLiveReferenceProvider, getResearchProvider } from "../adapters/corpus/wikipedia-live.mjs";
-import { researchTurn, researchSnapshot, resolveResearchConfig, RESEARCH_DEFAULTS } from "./research.mjs";
+import { researchTurn, researchSnapshot, resolveResearchConfig, RESEARCH_DEFAULTS, parseResearchRequest } from "./research.mjs";
+import { loadResearchQueue, saveResearchQueue } from "../adapters/research-queue-store.mjs";
 import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
 import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
@@ -14548,7 +14549,16 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // behind /wiki on. Queue state threads turn-to-turn as researchState, the
   // same way planState does.
   {
-    const researchHolder = { state: researchState };
+    // A fresh CLI session carries no in-memory queue, so a research-family line
+    // arriving with none resumes the queue persisted under .tmct/ — that is
+    // what makes "research next"/"status"/"stop" work across process restarts.
+    // The gate keeps ordinary turns off the disk (only a parsed research line
+    // loads), and a store with no path (the browser) simply reads back null.
+    let priorResearchState = researchState;
+    if (!priorResearchState && parseResearchRequest(workingLine)) {
+      priorResearchState = await loadResearchQueue(memoryDir);
+    }
+    const researchHolder = { state: priorResearchState };
     const resolvedResearchConfig = researchConfig ?? RESEARCH_DEFAULTS;
     const rTurn = await researchTurn(workingLine, {
       holder: researchHolder,
@@ -14569,6 +14579,10 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       result.lane = "research";
       const snapshot = researchSnapshot(researchHolder.state);
       if (snapshot) result.record.research = snapshot;
+      // Write-through: persist the queue this turn just mutated (start, next,
+      // skip), and clear the file when it ended (stop, or a failed start that
+      // left no run). A store with no path no-ops, so the browser is untouched.
+      await saveResearchQueue(memoryDir, researchHolder.state);
       const rec = withLast(result, rTurn.goal);
       rec.planState = planHolder.state;
       rec.researchState = researchHolder.state;

package/src/services/extract-facts.mjs

@@ -118,6 +118,13 @@ const COPULA_OF_READ_THROUGH = new Set(["type", "kind", "sort", "form", "class",
 // bare copula does, unlike any other verb after "is".
 const COPULA_NAMING_PARTICIPLES = new Set(["termed", "known", "defined", "described", "referred", "called", "classified"]);
 const COPULA_PARTITIVE_HEADS = new Set(["body", "mass", "group", "collection", "set", "series", "number", "amount", "piece", "part", "lot", "pair", "bunch", "pile"]);
+// The relative pronouns that open a clause predicating about the SENTENCE
+// subject: "a mountain that has lava" is a fact about the volcano, so the
+// relative clause's verb binds to the copula's own subject, not to its object.
+const RELATIVE_PRONOUNS = new Set(["that", "which", "who", "whom", "whose"]);
+// At most this many triples from one sentence — a bound so a run-on can never
+// shatter into noise, not a first-wins cap.
+const MAX_TRIPLES_PER_SENTENCE = 4;
 
 /** Fold an entity surface to its stored key: a lexicon noun's lemma, else the
  *  word's own normFactTerm (the optimistic tier mints unlisted content nouns
@@ -144,6 +151,7 @@ function optimisticTriplesPos(sentence, lexicon, nlp) {
   // folded — "a string instrument" is the class "string instrument", never
   // its modifier "string"; a single-word run keeps the plain lemma fold.
   const isNounish = (i) => pos[i] === "NOUN" || pos[i] === "PROPN";
+  const runLoOf = (i) => { let lo = i; while (lo - 1 >= 0 && isNounish(lo - 1)) lo -= 1; return lo; };
   const entityRunAt = (i) => {
     let lo = i;
     let hi = i;
@@ -153,18 +161,63 @@ function optimisticTriplesPos(sentence, lexicon, nlp) {
     const head = lookupNoun(lexicon, String(values[hi]).toLowerCase());
     return normFactTerm([...values.slice(lo, hi), head ? head.lemma : values[hi]].join(" "));
   };
-  const nearestEntity = (idx, step, blocked = null) => {
+  const nearestEntityIndex = (idx, step, blocked = null) => {
     for (let i = idx + step; i >= 0 && i < values.length; i += step) {
       if (pos[i] === "PUNCT") break;
       if (blocked && blocked.has(pos[i])) break;
-      if (isNounish(i)) return entityRunAt(i);
+      if (isNounish(i)) return i;
     }
     return null;
   };
-  const tripleAt = (i, predicate, blocked = null) => {
-    const subject = nearestEntity(i, -1, blocked);
-    const object = nearestEntity(i, +1, blocked);
-    return subject && object && subject !== object ? { subject, predicate, object } : null;
+  const nearestEntity = (idx, step, blocked = null) => {
+    const i = nearestEntityIndex(idx, step, blocked);
+    return i === null ? null : entityRunAt(i);
+  };
+  // The subject-side mirror of the copula-object of-chain rule: when a found
+  // subject run is the inner noun of an of-chain ("the weight of all of the
+  // snow …"), climb to the outer run's nominal head ("weight"), bounded to two
+  // hops. A classifier head (type/kind/sort/…) reads THROUGH — a "kind of X"
+  // outer never becomes the subject, so the inner noun is kept. When the run is
+  // governed by "of" but no readable noun heads the chain (a mis-tagged head,
+  // e.g. "the top of the mountain …"), return null: an honest abstain, never the
+  // inner-noun confusion ("mountain", "snow"). A run not governed by "of" is
+  // returned unchanged. Returns a run-lo index to fold, or null to abstain.
+  const ofChainSkip = (k) => {
+    const p = pos[k];
+    return p === "DET" || p === "ADJ" || p === "ADV" || p === "NUM";
+  };
+  const climbSubjectRun = (found) => {
+    let lo = runLoOf(found);
+    for (let hop = 0; hop < 2; hop += 1) {
+      let g = lo - 1;
+      while (g >= 0 && ofChainSkip(g)) g -= 1;
+      if (g < 0 || values[g]?.toLowerCase() !== "of") return lo; // not an of-chain object
+      let k = g - 1;
+      while (k >= 0 && !isNounish(k) && (ofChainSkip(k) || values[k]?.toLowerCase() === "of")) k -= 1;
+      if (k < 0 || !isNounish(k)) return null; // no readable head — abstain
+      if (COPULA_OF_READ_THROUGH.has(String(values[k]).toLowerCase())) return lo; // classifier reads through
+      lo = runLoOf(k);
+    }
+    return lo;
+  };
+  // The subject resolution shared by the relation-verb tiers: a run climbed
+  // through its of-chain and folded, or null when the of-chain has no readable
+  // head (abstain rather than store the inner-noun confusion).
+  const climbedSubjectAt = (idx) => {
+    const found = nearestEntityIndex(idx, -1);
+    if (found === null) return null;
+    const climbed = climbSubjectRun(found);
+    return climbed === null ? null : entityRunAt(climbed);
+  };
+  // A relation verb whose nearest content token leftward (skipping adverbs and
+  // the auxiliaries of its own verb complex) is a relative pronoun sits in a
+  // "that/which …" relative clause — its subject is the sentence subject.
+  const inRelativeFrame = (i) => {
+    for (let k = i - 1; k >= 0; k -= 1) {
+      if (pos[k] === "ADV" || pos[k] === "AUX") continue;
+      return RELATIVE_PRONOUNS.has(String(values[k]).toLowerCase());
+    }
+    return false;
   };
   // An isa needs a CLEAN copula frame: only determiners/adjectives/adverbs/
   // numerals may sit between each entity and the copula. Crossing a verb or
@@ -191,36 +244,87 @@ function optimisticTriplesPos(sentence, lexicon, nlp) {
       while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
       const headWord = String(values[hi]).toLowerCase();
       const nextIsOf = values[hi + 1]?.toLowerCase() === "of";
-      if (!nextIsOf) return entityRunAt(j);
+      if (!nextIsOf) return { label: entityRunAt(j), hi };
       if (COPULA_OF_READ_THROUGH.has(headWord)) { i = hi + 1; j = hi + 1; continue; }
       if (COPULA_PARTITIVE_HEADS.has(headWord)) return null;
-      return entityRunAt(j);
+      return { label: entityRunAt(j), hi };
     }
     return null;
   };
   // The copula's own modal chain ("can be", "may be") is part of one verb
   // complex — the subject scan starts left of it, while a free-standing VERB
-  // on the way still voids the frame.
+  // on the way still voids the frame. An of-chain subject climbs to its head
+  // ("the weight of the snow is …" → weight); a mis-headed of-chain abstains.
   const copulaSubjectAt = (i) => {
     let k = i - 1;
     while (k >= 0 && pos[k] === "AUX") k -= 1;
-    return nearestEntity(k + 1, -1, COPULA_FRAME_BLOCKERS);
+    const found = nearestEntityIndex(k + 1, -1, COPULA_FRAME_BLOCKERS);
+    if (found === null) return null;
+    const climbed = climbSubjectRun(found);
+    return climbed === null ? null : entityRunAt(climbed);
   };
+
+  const triples = [];
+  const seen = new Set();
+  const push = (subject, predicate, object) => {
+    if (!(subject && object && subject !== object)) return;
+    const key = `${subject}\0${predicate}\0${object}`;
+    if (seen.has(key) || triples.length >= MAX_TRIPLES_PER_SENTENCE) return;
+    seen.add(key);
+    triples.push({ subject, predicate, object });
+  };
+
+  // Pass 1 — the first clean copula frame yields the isa (all guards unchanged);
+  // its subject and object-run end anchor the relative-clause continuation.
+  let copulaSubject = null;
+  let copulaObjHi = -1;
   for (let i = 1; i < values.length - 1; i += 1) {
     if (pos[i] === "AUX" && OPTIMISTIC_COPULAS.has(values[i].toLowerCase())) {
       const subject = copulaSubjectAt(i);
       const object = copulaObjectAt(i);
-      if (subject && object && subject !== object) return [{ subject, predicate: "rdfs:subClassOf", object }];
+      if (subject && object && subject !== object.label) {
+        push(subject, "rdfs:subClassOf", object.label);
+        copulaSubject = subject;
+        copulaObjHi = object.hi;
+        break;
+      }
+    }
+  }
+
+  // Pass 2a — with a copula isa in hand, CONTINUE past its object for relation
+  // verbs (has/creates/…), so one sentence contributes every fact it grounds.
+  // A "that/which <verb>" clause right after the object predicates about the
+  // SENTENCE subject ("a mountain that has lava" → volcano has lava); any other
+  // relation verb keeps its nearest-entity-leftward subject. AUX relation verbs
+  // ("has") count here — but only inside a copula frame that already resolved,
+  // so a bare "… is that Earth has …" complement never mints "earth has lot".
+  if (copulaSubject) {
+    for (let i = copulaObjHi + 1; i < values.length; i += 1) {
+      if (pos[i] !== "VERB" && pos[i] !== "AUX") continue;
+      const word = values[i].toLowerCase();
+      if (OPTIMISTIC_COPULAS.has(word)) continue;
+      const verb = lookupVerb(lexicon, word);
+      if (!verb) continue;
+      const subject = inRelativeFrame(i) ? copulaSubject : climbedSubjectAt(i);
+      if (subject === null) continue;
+      push(subject, predicateOf(verb), nearestEntity(i, +1));
     }
+    return triples;
   }
+
+  // Pass 2b — no copula isa: the relation-verb tier over the whole sentence,
+  // climbing an of-chain subject to its head ("the weight of the snow creates
+  // pressure" → weight creates pressure, not snow). VERB-tagged only, so a bare
+  // AUX ("Earth has …") in a non-frame sentence stays an honest miss.
   for (let i = 1; i < values.length - 1; i += 1) {
     if (pos[i] !== "VERB") continue;
     const verb = lookupVerb(lexicon, values[i].toLowerCase());
     if (!verb) continue;
-    const t = tripleAt(i, predicateOf(verb));
-    if (t) return [t];
+    const subject = climbedSubjectAt(i);
+    if (subject === null) continue;
+    push(subject, predicateOf(verb), nearestEntity(i, +1));
   }
-  return [];
+  return triples;
 }
 
 /** The lexical fallback for a checkout with no wink model: a copula flanked by
@@ -254,11 +358,15 @@ function optimisticTriplesLexical(sentence, lexicon) {
 }
 
 /**
- * A bounded triple candidate from a sentence the strict recognizer skipped: a
- * copula (→ rdfs:subClassOf) or a lexicon-known relation verb (→ its predicate)
- * flanked by two entities. At most one triple per sentence; [] when nothing
- * resolves both sides — no guessing past the shape. Uses wink POS tags when a
- * model is available (the precise tier), else a narrower lexicon-only fallback.
+ * The bounded triple candidates from a sentence the strict recognizer skipped:
+ * a copula (→ rdfs:subClassOf) and, past its object, the relation verbs it
+ * grounds (→ their predicates), so one sentence contributes every fact it holds
+ * ("a volcano is a mountain that has lava" → volcano ⊑ mountain AND volcano has
+ * lava). Every triple passes the same entity/guard checks on its own, deduped,
+ * capped at MAX_TRIPLES_PER_SENTENCE so a run-on never shatters into noise; []
+ * when nothing resolves both sides — no guessing past the shape. Uses wink POS
+ * tags when a model is available (the precise tier), else a narrower
+ * lexicon-only fallback.
  *
  *   opts.lexicon  a loaded lexicon (the core vocabulary when absent).
  *   opts.nlp      a wink instance (winkInstance() when absent); null forces the