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

package/src/adapters/corpus/worlds-pack.mjs

@@ -15,7 +15,7 @@ import { readFileSync } from "node:fs";
 import { gunzipSync } from "node:zlib";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { isWorldsIndexEntry, isWorldRow, isWorldFactRow, isWorldRuleRow, isWorldMetaRow } from "../../domain/worlds-pack.mjs";
+import { isWorldsIndexEntry, isWorldRow, isWorldFactRow, isWorldRuleRow, isWorldMetaRow, expandWorldDefaultContents } from "../../domain/worlds-pack.mjs";
 
 const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
 
@@ -84,7 +84,13 @@ export function loadWorld(dir, worldName) {
         else if (isWorldMetaRow(row) && !meta) meta = row;
       } catch { /* tolerated: a bad line loses one row, not the world */ }
     }
-    if (facts.length || rules.length || meta) payload = { name: worldName, facts, rules, meta };
+    // Class-default contents (library -> a book, kitchen -> a pan) are
+    // materialized here, the one choke point every loader path runs through
+    // (openAdventure, the site build, the tests) — never baked into the
+    // shipped shard, which stays a byte-copy of its hand-authored source.
+    if (facts.length || rules.length || meta) {
+      payload = { name: worldName, facts: expandWorldDefaultContents(facts), rules, meta };
+    }
   }
   worldCacheByKey.set(key, payload);
   return payload;

package/src/adapters/toml-config.mjs

@@ -125,6 +125,12 @@ export async function normalizeConfig(raw, { configDir } = {}) {
   if (src.games !== undefined) cfg.games = src.games;
   if (src.planning !== undefined) cfg.planning = src.planning;
 
+  // Research-lane knobs (src/services/research.mjs): sparse PASS-THROUGH,
+  // same discipline as [games.*] — the raw `[research]` table
+  // (fanout_limit / depth_limit / min_interval_ms, snake_case) rides through
+  // unmodified; clamping and default-filling is resolveResearchConfig's job.
+  if (src.research !== undefined) cfg.research = src.research;
+
   const idx = src.index || {};
   const index = {};
   if (idx.languages !== undefined) index.languages = idx.languages;

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/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 || []);