@polycode-projects/the-mechanical-code-talker 2.10.5 → 2.11.1

package/src/domain/interpret/strategies/keywords.mjs

@@ -8,7 +8,7 @@
 import {
   VERB_TO_KIND, ENTITY_TO_TYPE, MODIFIER_TO_KIND,
   WHERE_MARKERS, MENTION_MARKERS, PLACEHOLDER_NOUNS, PASSIVE_PARTICIPLE_TO_KIND,
-  INHERITS_REVERSE_VERBS,
+  INHERITS_REVERSE_VERBS, HAS_FAMILY_VERBS,
 } from "../../ask-vocab.mjs";
 import { STOPWORDS } from "../normalize.mjs";
 import { VOCAB_WORDS, eligibleForCanon, fuzzyVocabWord } from "../fuzzy.mjs";
@@ -19,6 +19,10 @@ import { VOCAB_WORDS, eligibleForCanon, fuzzyVocabWord } from "../fuzzy.mjs";
 const PASSIVE_AUX = new Set(["is", "are", "was", "were", "be", "been", "being", "get", "gets", "got"]);
 const WH_WORDS = new Set(["which", "what", "who", "whom", "whose"]);
 const PLACEHOLDER_SET = new Set(PLACEHOLDER_NOUNS.map((w) => w.toLowerCase()));
+// See ask-vocab.mjs's own HAS_FAMILY_VERBS for why a bare have-family verb
+// never resolves to `defines` in this strategy's two-named-role "ask" shape
+// below (the forward/reverse branches keep their own tested grain-check
+// decline, per that constant's own docblock).
 
 /** Find the longest phrase from `table`'s keys that appears as a contiguous
  *  run of `words` (case already lowercased by the caller). Longest-match-first
@@ -107,6 +111,13 @@ export function parseKeywordSpot(text, nlp = null) {
       fuzzyVerb = { from: lcWords[at], to: fuzzyWords[at] };
     }
   }
+  // Tracks whether verbHit came from PASSIVE_PARTICIPLE_TO_KIND's fallback
+  // rather than an active VERB_TO_KIND entry — that table's own header says
+  // it's only meant to fire once a passive auxiliary AND an agent-marking
+  // "by" are confirmed. A direct complement with no "by" ("my cat is called
+  // whiskers") is the naming sense of "call", not the invoke-relation passive,
+  // so this flag gates the ask-shape SVO fallback below from misreading it.
+  let verbFromParticiple = false;
   if (!verbHit) {
     // A participle with no active verb entry still marks a passive when a passive
     // auxiliary precedes it — with or without an agent "by" phrase. "is http.mjs
@@ -125,10 +136,28 @@ export function parseKeywordSpot(text, nlp = null) {
     for (let i = 0; i < lcWords.length; i += 1) {
       const k = PASSIVE_PARTICIPLE_TO_KIND[lcWords[i]];
       if (k && lcWords[i] === "used" && lcWords[i + 1] === "for") continue;
-      if (k && lcWords.slice(0, i).some((w) => PASSIVE_AUX.has(w))) { verbHit = { kind: k, start: i, end: i + 1 }; break; }
+      if (k && lcWords.slice(0, i).some((w) => PASSIVE_AUX.has(w))) {
+        verbHit = { kind: k, start: i, end: i + 1 };
+        verbFromParticiple = true;
+        break;
+      }
     }
   }
   if (!verbHit) return null;
+  // A single-word verbHit whose LITERAL surface text (not the lemma the tier-2
+  // pass may have rewritten it to) is itself a PASSIVE_PARTICIPLE_TO_KIND entry,
+  // preceded by a passive auxiliary, is the same "needs a confirmed 'by' agent"
+  // case the fallback loop above already flags — checked here too because the
+  // lemma tier reaches it independently: lemma("called") is "call", an ACTIVE
+  // verb-table entry in its own right, so tier 2 resolves verbHit before the
+  // fallback loop ever runs, silently losing the participle reading. "my cat is
+  // called whiskers" (the naming sense of "call") must not be read as though
+  // "cat" were the active subject invoking "whiskers".
+  if (!verbFromParticiple && verbHit.end - verbHit.start === 1
+    && PASSIVE_PARTICIPLE_TO_KIND[lcWords[verbHit.start]]
+    && lcWords.slice(0, verbHit.start).some((w) => PASSIVE_AUX.has(w))) {
+    verbFromParticiple = true;
+  }
   // A tier-3 verb is a REPAIR, not a reading — downstream consumers (the teach
   // lane's canonical receipt, and the chat surface's fuzzy-verb decline) need
   // to know the difference AND which word was rewritten, so {from, to} rides
@@ -221,15 +250,35 @@ export function parseKeywordSpot(text, nlp = null) {
     const [patient, agent] = agentIsFronted
       ? [roleText(passiveAuxIdx + 1, words.length), roleText(byIdx + 1, passiveAuxIdx)]
       : [roleText(0, byIdx), roleText(byIdx + 1, words.length)];
-    if (patient && agent) return stamp({ shape: "ask", entityType: null, modifier: "direct", kind, subject: agent, object: patient });
+    if (patient && agent) {
+      if (kind === "defines" && HAS_FAMILY_VERBS.has(canonWords.slice(verbHit.start, verbHit.end).join(" "))) return null;
+      return stamp({ shape: "ask", entityType: null, modifier: "direct", kind, subject: agent, object: patient });
+    }
     if (agent) return stamp({ shape: "forward", entityType, modifier, kind, object: agent });
     if (patient) return stamp({ shape: "reverse", entityType, modifier, kind, object: patient });
   }
 
+  // "called" specifically (never the rest of the participle family — "was it
+  // touched recently"/"is X used anywhere" are genuine bare-passive code
+  // queries with a trailing adverb, not a competing sense, and must keep
+  // reaching their existing reading) carries a whole separate NAMING sense
+  // ("my cat is called whiskers") distinct from the invoke-relation passive
+  // this table exists for. A following complement with no "by" agent is that
+  // naming sense, not "whiskers calls cat" — falling through to the
+  // active-SVO/reverse branches below would read the participle as if it
+  // were an active verb and answer a code-graph question nobody asked, so
+  // this misses honestly instead.
+  if (verbFromParticiple && byIdx < 0 && afterText && lcWords[verbHit.start] === "called") return null;
+
   if (beforeText && afterText) {
+    const verbPhrase = canonWords.slice(verbHit.start, verbHit.end).join(" ");
+    // The bare have-family "ask" shape ("does X have Y") declines here, same
+    // reasoning as grammar.mjs's T1 (see HAS_FAMILY_VERBS above) — never for
+    // the entityType-driven forward/reverse branches below, which keep their
+    // own tested grain-check decline.
+    if (kind === "defines" && HAS_FAMILY_VERBS.has(verbPhrase)) return null;
     // A semantically-reverse verb ("superclass of") swaps subject/object, same as
     // grammar.mjs's T1.
-    const verbPhrase = canonWords.slice(verbHit.start, verbHit.end).join(" ");
     let subject = beforeText;
     let object = afterText;
     if (INHERITS_REVERSE_VERBS.includes(verbPhrase)) [subject, object] = [object, subject];

package/src/domain/memory/trust.mjs

@@ -77,6 +77,17 @@ export function provenanceTagToSource(tag) {
     const pack = rest.slice(0, colon) || "unknown";
     return { kind: referenceKindFor(pack), pack, article: rest.slice(colon + 1) };
   }
+  // research:<topic>@<depth> — the research lane's Simple English Wikipedia
+  // loads. Live-fetched at query time like the wikipedia-live pack, so it
+  // scores at the same referenceLive prior, below every curated pack. Parsed
+  // from the FULL tag (a topic may contain spaces); the depth segment records
+  // how far the fan-out reached and is not part of the Source identity.
+  if (t.startsWith("research:")) {
+    const rest = t.slice("research:".length);
+    const at = rest.lastIndexOf("@");
+    const topic = (at >= 0 ? rest.slice(0, at) : rest).trim();
+    return { kind: "referenceLive", pack: "research", article: topic || "unknown" };
+  }
   const head = t.split(/\s+/)[0]; // drop trailing " /r/IsA" etc.
   if (head.startsWith("corpus-weak:")) return { kind: "corpusWeak", name: head.slice("corpus-weak:".length) || "unknown" };
   if (head.startsWith("corpus:")) return { kind: "corpus", name: head.slice("corpus:".length) || "unknown" };

package/src/domain/router/registry.mjs

@@ -242,11 +242,18 @@ export function registerCapability(cap) {
 }
 
 // ---- unregistered dispatch tools ---------------------------------------------
-// Dispatch tools not yet registered; each names the precondition work it needs first.
+// Dispatch tools not yet registered; each names the work it needs first — a
+// precondition/effect design, or resolver wiring, before it can join the registry.
 export const EXCLUDED_FROM_REGISTRY = Object.freeze({
   tmct_context: "unbounded edit-context bundle (multi-file); needs a size/budget precondition",
   tmct_context_more: "unbounded context continuation; same as tmct_context",
   tmct_snippet: "raw source-file read (reads the filesystem); needs a file-read + span precondition",
+  tmct_ask: "the plain-English question entry point itself — calls ask.mjs directly and bypasses the capability planner; not one of the planner's operators",
+  tmct_export: "reads the memory store's whole fact set with no discriminating param and no resolver goal frame; needs NL-reachability wiring before it can join",
+  tmct_ingest: "writes into the memory store (grounds facts); capability() only models read-only operators, so a write path needs its own precondition/effect design first",
+  tmct_file_history: "a module-grain cut of the same history edge tmct_history already models; no NL frame distinguishes the granularities yet",
+  tmct_method_history: "a method-grain cut of the same history edge tmct_history already models; no NL frame distinguishes the granularities yet",
+  tmct_class_history: "a class-grain cut of the same history edge tmct_history already models; no NL frame distinguishes the granularities yet",
 });
 
 /** The full registry as a plain frozen object (facts + index), for callers that

package/src/domain/worlds-pack.mjs

@@ -69,3 +69,53 @@ export function isWorldRow(row) {
 export function worldProvenanceTag(worldName) {
   return `world:${worldName}`;
 }
+
+const DEFAULT_CONTAINS_PREDICATE = "mgx:default-contains";
+
+/** Materialize a world's class-default contents: for every
+ *  `<room> mgx:default-contains <class>` fact, mint one placed, portable
+ *  instance of that class in that room unless the room already holds one. A
+ *  minted book gets `rdf:type <class>` (so it resolves its own sprite),
+ *  `rdf:type portable` (so the take family accepts it), and
+ *  `mgx:located-in <room>` (so it shows up in the room and can be carried
+ *  out). Pure and deterministic: defaults are visited in sorted order, and a
+ *  collision mints `<class>-2`, `<class>-3`… so re-running never renames an
+ *  earlier instance. Rows keep whatever world/kind wrapper the input rows
+ *  carry, so both a loaded shard (world rows) and a bare triple list expand
+ *  the same way. */
+export function expandWorldDefaultContents(facts) {
+  const rows = facts || [];
+  const defaults = rows
+    .filter((r) => r.predicate === DEFAULT_CONTAINS_PREDICATE)
+    .sort((a, b) => `${a.subject}\0${a.object}`.localeCompare(`${b.subject}\0${b.object}`));
+  if (!defaults.length) return rows;
+
+  const instanceIds = new Set(rows.filter((r) => r.predicate === "rdf:type").map((r) => r.subject));
+  const placedIn = new Map();
+  for (const r of rows) {
+    if (r.predicate === "mgx:located-in") placedIn.set(r.subject, r.object);
+  }
+  const roomAlreadyHas = (klass, room) =>
+    rows.some((r) => r.predicate === "rdf:type" && r.object === klass && placedIn.get(r.subject) === room);
+
+  const wrapper = rows.find((r) => typeof r.world === "string" && r.kind === "fact");
+  const wrap = (subject, predicate, object) => ({
+    ...(wrapper ? { world: wrapper.world, kind: "fact" } : {}),
+    subject, predicate, object,
+  });
+
+  const minted = [];
+  for (const d of defaults) {
+    const room = d.subject;
+    const klass = d.object;
+    if (roomAlreadyHas(klass, room)) continue;
+    let id = klass;
+    let n = 1;
+    while (instanceIds.has(id)) { n += 1; id = `${klass}-${n}`; }
+    instanceIds.add(id);
+    minted.push(wrap(id, "rdf:type", klass));
+    minted.push(wrap(id, "rdf:type", "portable"));
+    minted.push(wrap(id, "mgx:located-in", room));
+  }
+  return minted.length ? [...rows, ...minted] : rows;
+}

package/src/services/adventure-autoplay.mjs

@@ -26,7 +26,7 @@
 // fact simply has nothing for this module to infer a goal toward.
 import { findActionPath } from "../domain/planning.mjs";
 import { loadMemory, readFactRows } from "../adapters/memory/core.mjs";
-import { foldWorldState, adventureTurn } from "./adventure.mjs";
+import { foldWorldState, adventureTurn, worldActionRows } from "./adventure.mjs";
 
 const SNAPSHOT_RE = /^(.+)@turn(\d+)$/;
 const baseSubjectOf = (subject) => SNAPSHOT_RE.exec(subject)?.[1] ?? subject;
@@ -138,7 +138,10 @@ async function stepTowardThenAct({
  */
 export async function runAdventureAutoplayTick(memoryDir, opts = {}) {
   const { exposedRoomIds, planHolder, sessionId = "", env = {}, graph = null, cache = null } = opts;
-  const rows = readFactRows(await loadMemory(memoryDir));
+  // Auto-play reasons over the game world only — the same isolation the manual
+  // command path uses, so a fact the player taught mid-game never steers the
+  // planner toward a room the world never placed anything in.
+  const rows = worldActionRows(readFactRows(await loadMemory(memoryDir)));
   const state = foldWorldState(rows);
   const here = state.placements.get("player")?.object ?? null;
   const exposed = new Set(exposedRoomIds || []);