@polycode-projects/the-mechanical-code-talker 2.7.12 → 2.7.14

package/src/surfaces/web/adventure-browser-entry.mjs

@@ -0,0 +1,88 @@
+// adventure-browser-entry.mjs — the esbuild entry for the adventure's
+// full-screen/home-page pages (public/adventure-browser.bundle.js, built by
+// scripts/build-adventure-bundle.mjs), mirroring
+// spider-fly-browser-entry.mjs's own session-factory shape.
+//
+// Unlike spider-fly's board, Ashcombe Hall's own facts+rules cannot be
+// regenerated in-browser from a pure JS module — its canonical definition is
+// a Node-only JSONL corpus source, read through an fs/gzip provider the
+// browser cannot run. So this session takes the world as data
+// (`worldPayload`, `{ name, facts, rules, opening }`), embedded into the page
+// at build time by scripts/build-demo-site.mjs's own read through the real
+// worlds-pack provider (see adventure-viz.mjs's header for the full
+// rationale) — the bootstrap below then just appends it, exactly the shape
+// openAdventure() itself writes for a real chat session.
+//
+// This session exposes ONLY a raw autoplay tick and a read-only snapshot —
+// no chat dock. Every state-changing command adventure.mjs's own
+// runWorldCommand issues (go/take/open/...) already re-narrates itself
+// through the extractive completions digest on every turn (the
+// "auto-relook"), so this bundle carries the same wink-nlp/completions
+// dependency chain chat.mjs's own runTurn does; a second, lighter path was
+// not available to duck under it. Nothing here calls runTurn, though — the
+// one entry point exercised is adventureTurn itself, via
+// adventure-autoplay.mjs, which is the "auto-play is a caller of the
+// existing interpreter, never a second one" contract this whole feature
+// rests on.
+import {
+  createInMemoryStore, appendFacts, appendRule, loadMemory, readFactRows,
+} from "../../adapters/memory/core.mjs";
+import { foldWorldState, worldDigestRows } from "../../services/adventure.mjs";
+import { runAdventureAutoplayTick } from "../../services/adventure-autoplay.mjs";
+import { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
+
+/** A live in-memory adventure this page's ticker drives one auto-play tick
+ *  at a time. Returns `{ memoryDir, autoplayTick, snapshot }`.
+ *  `worldPayload.facts`/`.rules` seed the store exactly the way
+ *  openAdventure() itself does for a real session; `planHolder.state` is set
+ *  the same way, so adventureTurn treats every subsequent call as a live,
+ *  already-open world rather than a fresh opening line. */
+export async function createAdventureSession(worldPayload) {
+  const memoryDir = createInMemoryStore();
+  const tag = `world:${worldPayload.name}`;
+  await appendFacts(memoryDir, worldPayload.facts.map((f) => ({
+    subject: f.subject, predicate: f.predicate, object: f.object, provenance: tag,
+  })));
+  for (const rule of worldPayload.rules) {
+    await appendRule(memoryDir, { name: rule.name, kind: rule.ruleKind, slots: rule.slots, provenance: tag });
+  }
+
+  const planHolder = { state: { adventure: { world: worldPayload.name } } };
+  const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
+  let exposedRoomIds = new Set();
+  const openingRows = readFactRows(await loadMemory(memoryDir));
+  const openingHere = foldWorldState(openingRows).placements.get("player")?.object ?? null;
+  if (openingHere) exposedRoomIds = new Set([openingHere]);
+
+  return {
+    memoryDir,
+
+    /** One auto-play tick: infer the goal, execute exactly one move through
+     *  adventureTurn (adventure-autoplay.mjs's own contract), thread the
+     *  exposed-room set forward. Returns runAdventureAutoplayTick's own
+     *  `{ turn, goal, plan, done, stalled }` unmodified. */
+    async autoplayTick() {
+      const result = await runAdventureAutoplayTick(memoryDir, {
+        exposedRoomIds, planHolder, sessionId, env: {},
+      });
+      exposedRoomIds = result.exposedRoomIds;
+      return result;
+    },
+
+    /** A read-only fold of the current room — no engine advance — for the
+     *  page's own redraw after boot and after every tick. */
+    async snapshot() {
+      const rows = readFactRows(await loadMemory(memoryDir));
+      const state = foldWorldState(rows);
+      const here = state.placements.get("player")?.object ?? null;
+      return { rows, state, here, turn: state.turnCount };
+    },
+  };
+}
+
+// Re-exported so the page's own rendering script (adventure-viz.mjs) never
+// has to duplicate sprite resolution or the digest reader — the same posture
+// spider-fly-browser-entry.mjs's own globalThis.tmctSpiderFly re-export takes.
+globalThis.tmctAdventure = {
+  createAdventureSession, resolveSpriteForClass, SPRITE_REGISTRY, worldDigestRows,
+};

package/src/surfaces/web/memory-ask-browser.bundle.js

@@ -3071,6 +3071,7 @@ ${shown.join("\n")}${tail}`;
         "nothing",
         "one",
         "any",
+        "anywhere",
         "last",
         // temporal filler ("when was X last touched")
         "usually",
@@ -3370,9 +3371,10 @@ ${shown.join("\n")}${tail}`;
         fuzzyVerb = { from: lcWords[at], to: fuzzyWords[at] };
       }
     }
-    if (!verbHit && lcWords.includes("by")) {
+    if (!verbHit) {
       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;
@@ -6195,14 +6197,23 @@ ${options2}
             }
           }
         }
-        if (nearest) pool = [...pool, nearest];
+        if (nearest) {
+          pool = [...pool, nearest];
+          if (branches) {
+            const branchResult = traverse(graph, parsed, { pinnedObjMatch: nearest });
+            branches = [...branches, { candidate: nearest, result: branchResult, rendered: render(parsed, branchResult, graph) }];
+          }
+        }
       }
       const noun = pool.length && pool.every((i) => i.class === "Commit") ? "commit" : "module";
       const shown = pool.slice(0, OVERFLOW_CAP).map((i) => i.label);
       const extra2 = pool.length > OVERFLOW_CAP ? `, \u2026and ${pool.length - OVERFLOW_CAP} more` : "";
       const lead = `"${parsed.object}" matches more than one ${noun} ambiguously \u2014 did you mean ${listJoin(shown)}${extra2}? Try one of those. If you're not sure, narrow it to one name.`;
+      const term = String(parsed.object || "");
+      const termRe = term ? new RegExp(`\\b${escapeRegex(term)}\\b`, "gi") : null;
+      const branchText = (b) => termRe ? b.rendered.content.replace(termRe, b.candidate.label) : b.rendered.content;
       const content = branches && branches.length ? `${lead}
-${branches.map((b, i) => `${i + 1}) ${b.candidate.label}: ${b.rendered.content}`).join("\n")}` : lead;
+${branches.map((b, i) => `${i + 1}) ${b.candidate.label}: ${branchText(b)}`).join("\n")}` : lead;
       return {
         content,
         miss: false,
@@ -23574,6 +23585,7 @@ ${JSON.stringify(envelope, null, 2)}`;
   // src/services/spider-fly.mjs
   init_planning();
   init_core();
+  init_hash();
 
   // src/services/spider-fly-turn.mjs
   init_core();
@@ -23982,7 +23994,7 @@ ${JSON.stringify(envelope, null, 2)}`;
     const w = String(word || "").trim();
     if (/[a-z]ies$/i.test(w)) return `${w.slice(0, -3)}y`;
     if (/(ses|xes|zes|ches|shes)$/i.test(w)) return w.slice(0, -2);
-    if (/[a-z]s$/i.test(w) && !/ss$/i.test(w)) return w.slice(0, -1);
+    if (/[a-z]s$/i.test(w) && !/(?:ss|ous)$/i.test(w)) return w.slice(0, -1);
     return w;
   }
   var TEACH_ADVERB_SKIP_SRC = "(?:(?:usually|often|sometimes|rarely|always|typically|generally|occasionally|frequently|normally|regularly|commonly|mostly|currently|still|also|really|actually)\\s+)?";
@@ -24700,7 +24712,11 @@ ${shown.map(renderFactLine).join("\n")}`,
       const subj = factTermVariants(normFactTerm2, subjTerm);
       const obj = factTermVariants(normFactTerm2, objTerm);
       const hit2 = facts.find((f) => f.predicate === compPredicate && subj.has(f.subject) && obj.has(f.object));
-      if (hit2) return { text: `yes \u2014 ${renderFactLine(hit2)}`, replace: true };
+      if (hit2) {
+        const reversed = facts.find((f) => f.predicate === compPredicate && subj.has(f.object) && obj.has(f.subject));
+        const caveat = reversed ? ` \u2014 though you also told me the opposite: ${renderFactLine(reversed)}. Both are stored; I won't silently pick one.` : "";
+        return { text: `yes \u2014 ${renderFactLine(hit2)}${caveat}`, replace: true };
+      }
       const known = facts.filter((f) => f.predicate === compPredicate && (subj.has(f.subject) || subj.has(f.object)));
       const shown = known.length ? ` I do know: ${known.slice(0, 3).map(renderFactLine).join("; ")}.` : "";
       return {
@@ -24780,19 +24796,25 @@ ${shown.map(renderFactLine).join("\n")}`,
       );
       const hit2 = hasHit(subj);
       if (hit2) return { text: `yes \u2014 ${renderFactLine(hit2)}`, replace: true };
-      let liftFrontier = subj;
-      const liftChain = [];
+      let frontier = [{ terms: subj, chain: [] }];
       const liftSeen = /* @__PURE__ */ new Set();
       for (let hop = 0; hop < 4; hop += 1) {
-        const step = facts.find((f) => ISA_PREDICATES2.has(f.predicate) && liftFrontier.has(f.subject) && !liftSeen.has(f.object));
-        if (!step) break;
-        liftSeen.add(step.object);
-        liftChain.push(step);
-        const lifted = hasHit(factTermVariants(normFactTerm2, step.object));
-        if (lifted) {
-          return { text: `yes \u2014 ${[...liftChain.map(renderFactLine), renderFactLine(lifted)].join("; ")}`, replace: true };
+        const nextFrontier = [];
+        for (const { terms, chain } of frontier) {
+          const steps = facts.filter((f) => ISA_PREDICATES2.has(f.predicate) && terms.has(f.subject) && !liftSeen.has(f.object));
+          for (const step of steps) {
+            if (liftSeen.has(step.object)) continue;
+            liftSeen.add(step.object);
+            const nextChain = [...chain, step];
+            const lifted = hasHit(factTermVariants(normFactTerm2, step.object));
+            if (lifted) {
+              return { text: `yes \u2014 ${[...nextChain.map(renderFactLine), renderFactLine(lifted)].join("; ")}`, replace: true };
+            }
+            nextFrontier.push({ terms: factTermVariants(normFactTerm2, step.object), chain: nextChain });
+          }
         }
-        liftFrontier = factTermVariants(normFactTerm2, step.object);
+        if (!nextFrontier.length) break;
+        frontier = nextFrontier;
       }
       return null;
     }
@@ -25310,6 +25332,38 @@ ${shown.join("\n")}${extra}`, replace: true, ...rest.length ? { pending: { items
       }
       const polarityReply = isaPolarityReply(hit2, negHit || directDisjoint);
       if (polarityReply) return polarityReply;
+      if (disjointRows.length) {
+        const ancestryOf = (seed) => {
+          const closure = new Set(seed);
+          let frontier = new Set(seed);
+          for (let hop = 0; hop < 8 && frontier.size; hop += 1) {
+            const next = /* @__PURE__ */ new Set();
+            for (const [a, b] of mixedSubClassEdges) {
+              if (frontier.has(a) && !closure.has(b)) next.add(b);
+            }
+            if (!next.size) break;
+            for (const t of next) closure.add(t);
+            frontier = next;
+          }
+          return closure;
+        };
+        const objectAncestry = ancestryOf(objVariants);
+        const objViolation = disjointGateViolations.find((vv) => subjCandidates.has(vv.subject) && objectAncestry.has(vv.object) && !ancestryOf([vv.viaClass]).has(vv.object) && !ancestryOf([vv.object]).has(vv.viaClass));
+        if (objViolation) {
+          const posFact = isa.filter((f) => subjCandidates.has(f.subject) && f.object === objViolation.viaClass).sort(byTrust)[0];
+          const disjointFact = disjointRows.find((f) => f.subject === objViolation.viaClass && f.object === objViolation.object || f.subject === objViolation.object && f.object === objViolation.viaClass);
+          const objectNeedsLift = !objVariants.has(objViolation.object);
+          const objFact = objectNeedsLift ? isa.filter((f) => objVariants.has(f.subject) && f.object === objViolation.object).sort(byTrust)[0] : null;
+          if (posFact && disjointFact && (!objectNeedsLift || objFact)) {
+            const kindEcho = stripTrailingDiscourseTag(isaAsk[2]).trim();
+            const chain = [posFact, ...objFact ? [objFact] : []].map(renderFactLine).join("; ");
+            return {
+              text: `no \u2014 ${chain}; and ${factPhrase(disjointFact)}${disjointFact.provenance ? ` (source: ${disjointFact.provenance})` : ""} \u2014 so ${isaSubject} can never be ${indefiniteArticleFor(kindEcho)} ${kindEcho}.`,
+              replace: true
+            };
+          }
+        }
+      }
       const ent = await resolveEntity(graph, isaSubject);
       if (ent) {
         const bridgeSubjects = /* @__PURE__ */ new Map();

package/src/surfaces/web/spider-fly-browser-entry.mjs

@@ -52,7 +52,7 @@ import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import {
   worldFactRows, WORLD_NAME, WORLD_OPENING, cellId, parseCellId, DIRECTION_DELTA, visibleCells,
 } from "../../domain/spider-fly-world.mjs";
-import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame, DEFAULT_VISION_RADIUS } from "../../services/spider-fly.mjs";
+import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame, liveWebs, DEFAULT_VISION_RADIUS } from "../../services/spider-fly.mjs";
 import { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
 
 /** A live in-memory game the page's ticker and chat dock can both drive.
@@ -77,8 +77,8 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
   const { facts: startFacts } = await startSpiderFlyGame(memoryDir, { flyCount });
   const initialAgents = {};
   for (const f of startFacts) {
-    if (f.predicate !== "mgx:currently-in") continue;
-    initialAgents[f.subject] = { cell: f.object };
+    if (f.predicate === "mgx:currently-in") initialAgents[f.subject] = { ...initialAgents[f.subject], cell: f.object };
+    else if (f.predicate === "mgx:mass") initialAgents[f.subject] = { ...initialAgents[f.subject], mass: Number(f.object) };
   }
 
   const graph = parseEntities({ individuals: [], objectProperties: [] });
@@ -93,7 +93,7 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
     memoryDir,
     sessionId,
     opening: WORLD_OPENING,
-    initial: { turn: 0, agents: initialAgents },
+    initial: { turn: 0, agents: initialAgents, activeWebs: [] },
     taxonomyRows,
 
     /** Run one real engine turn directly. Returns spider-fly.mjs's own
@@ -127,16 +127,18 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
 
     /** A read-only fold of the CURRENT board — no engine advance, no goal
      *  lines (see the header comment: only a raw tick() recomputes those).
-     *  Lets the page resync positions/turn count after a chat-driven tick. */
+     *  Lets the page resync positions/turn count/mass/active webs after a
+     *  chat-driven tick. Web individuals are never listed as agents (that's
+     *  spider-1/fly-1/... only) — they surface only through activeWebs. */
     async snapshot() {
       const rows = readFactRows(await loadMemory(memoryDir));
       const state = foldSpiderFlyState(rows);
       const agents = {};
       for (const [id, place] of state.placements) {
-        if (state.removed.has(id)) continue;
-        agents[id] = { cell: place.cell };
+        if (state.removed.has(id) || /^web-\d+$/.test(id)) continue;
+        agents[id] = { cell: place.cell, mass: state.mass.get(id)?.value ?? null };
       }
-      return { turn: state.turnCount, agents };
+      return { turn: state.turnCount, agents, activeWebs: liveWebs(state.webs, state.turnCount) };
     },
   };
 }