@polycode-projects/the-mechanical-code-talker 2.7.3 → 2.7.5

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

@@ -9675,6 +9675,8 @@ ${bodyText}` : graphText, tier });
         return { id: `src:provider:${desc.name}`, type: "provider" };
       case "corpus":
         return { id: `src:corpus:${desc.name}`, type: "corpus" };
+      case "corpusWeak":
+        return { id: `src:corpus-weak:${desc.name}`, type: "corpusWeak" };
       // One Source per pack article (the @revid stays in the article segment),
       // so two facts from the same article corroborate nothing extra.
       case "reference":
@@ -10580,6 +10582,94 @@ CREATE INDEX IF NOT EXISTS edges_by_prop ON edges(prop);
     }
   });
 
+  // src/domain/skos-view.mjs
+  function buildSkosConceptView(rows, { conceptBase = "concept:", relationMap = DEFAULT_RELATION_MAP } = {}) {
+    const synonymPreds = new Set(relationMap.synonym || []);
+    const relatedPreds = new Set(relationMap.related || []);
+    const parent = /* @__PURE__ */ new Map();
+    const ensure = (t) => {
+      if (!parent.has(t)) parent.set(t, t);
+    };
+    const find = (x) => {
+      let r = x;
+      while (parent.get(r) !== r) r = parent.get(r);
+      while (parent.get(x) !== r) {
+        const next = parent.get(x);
+        parent.set(x, r);
+        x = next;
+      }
+      return r;
+    };
+    const union = (a, b) => {
+      const ra = find(a), rb = find(b);
+      if (ra === rb) return;
+      if (ra < rb) parent.set(rb, ra);
+      else parent.set(ra, rb);
+    };
+    const relatedRaw = [];
+    for (const r of rows) {
+      const p = r.predicate;
+      if (!synonymPreds.has(p) && !relatedPreds.has(p)) continue;
+      const s = normFactTerm(r.subject), o = normFactTerm(r.object);
+      if (!s || !o) continue;
+      ensure(s);
+      ensure(o);
+      if (synonymPreds.has(p)) union(s, o);
+      else relatedRaw.push({ s, o });
+    }
+    const iriFor = (rep) => conceptBase + rep.replace(/ /g, "_");
+    const componentTerms = /* @__PURE__ */ new Map();
+    for (const t of parent.keys()) {
+      const rep = find(t);
+      if (!componentTerms.has(rep)) componentTerms.set(rep, /* @__PURE__ */ new Set());
+      componentTerms.get(rep).add(t);
+    }
+    const concepts = [];
+    for (const [rep, terms] of componentTerms) {
+      const sorted = [...terms].sort();
+      concepts.push({ id: iriFor(rep), prefLabel: rep, altLabels: sorted.filter((t) => t !== rep) });
+    }
+    concepts.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const seen = /* @__PURE__ */ new Set();
+    const related = [];
+    for (const { s, o } of relatedRaw) {
+      const cs = iriFor(find(s)), co = iriFor(find(o));
+      if (cs === co) continue;
+      const key = cs < co ? `${cs}\0${co}` : `${co}\0${cs}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      related.push({ subject: cs, object: co });
+    }
+    related.sort((a, b) => `${a.subject}${a.object}` < `${b.subject}${b.object}` ? -1 : 1);
+    const conceptIdForTerm = (term) => {
+      const t = normFactTerm(term);
+      return parent.has(t) ? iriFor(find(t)) : null;
+    };
+    return { concepts, related, conceptIdForTerm, namespace: SKOS_NS };
+  }
+  function relatedForTerm(rows, term, options = {}) {
+    const view = buildSkosConceptView(rows, options);
+    const conceptId = view.conceptIdForTerm(term);
+    if (!conceptId) return null;
+    const byId = new Map(view.concepts.map((c) => [c.id, c]));
+    const concept = byId.get(conceptId);
+    const queried = normFactTerm(term);
+    const synonyms = [concept.prefLabel, ...concept.altLabels].filter((label) => label !== queried);
+    const related = view.related.filter((r) => r.subject === conceptId || r.object === conceptId).map((r) => byId.get(r.subject === conceptId ? r.object : r.subject)).filter(Boolean);
+    return { conceptId, prefLabel: concept.prefLabel, altLabels: concept.altLabels, synonyms, related };
+  }
+  var SKOS_NS, DEFAULT_RELATION_MAP;
+  var init_skos_view = __esm({
+    "src/domain/skos-view.mjs"() {
+      init_hash();
+      SKOS_NS = "http://www.w3.org/2004/02/skos/core#";
+      DEFAULT_RELATION_MAP = {
+        synonym: ["mgx:synonym"],
+        related: ["mgx:relatedTo", "mgx:similarTo"]
+      };
+    }
+  });
+
   // adapter-stub-ask-nlp.mjs:../adapters/ask-nlp.mjs
   var nlpAdapter;
   var init_ask_nlp = __esm({
@@ -22968,91 +23058,7 @@ ${hint}` : ""}${cand}`;
 
   // src/tools/handlers/tmct-related.mjs
   init_config();
-
-  // src/domain/skos-view.mjs
-  init_hash();
-  var SKOS_NS = "http://www.w3.org/2004/02/skos/core#";
-  var DEFAULT_RELATION_MAP = {
-    synonym: ["mgx:synonym"],
-    related: ["mgx:relatedTo", "mgx:similarTo"]
-  };
-  function buildSkosConceptView(rows, { conceptBase = "concept:", relationMap = DEFAULT_RELATION_MAP } = {}) {
-    const synonymPreds = new Set(relationMap.synonym || []);
-    const relatedPreds = new Set(relationMap.related || []);
-    const parent = /* @__PURE__ */ new Map();
-    const ensure = (t) => {
-      if (!parent.has(t)) parent.set(t, t);
-    };
-    const find = (x) => {
-      let r = x;
-      while (parent.get(r) !== r) r = parent.get(r);
-      while (parent.get(x) !== r) {
-        const next = parent.get(x);
-        parent.set(x, r);
-        x = next;
-      }
-      return r;
-    };
-    const union = (a, b) => {
-      const ra = find(a), rb = find(b);
-      if (ra === rb) return;
-      if (ra < rb) parent.set(rb, ra);
-      else parent.set(ra, rb);
-    };
-    const relatedRaw = [];
-    for (const r of rows) {
-      const p = r.predicate;
-      if (!synonymPreds.has(p) && !relatedPreds.has(p)) continue;
-      const s = normFactTerm(r.subject), o = normFactTerm(r.object);
-      if (!s || !o) continue;
-      ensure(s);
-      ensure(o);
-      if (synonymPreds.has(p)) union(s, o);
-      else relatedRaw.push({ s, o });
-    }
-    const iriFor = (rep) => conceptBase + rep.replace(/ /g, "_");
-    const componentTerms = /* @__PURE__ */ new Map();
-    for (const t of parent.keys()) {
-      const rep = find(t);
-      if (!componentTerms.has(rep)) componentTerms.set(rep, /* @__PURE__ */ new Set());
-      componentTerms.get(rep).add(t);
-    }
-    const concepts = [];
-    for (const [rep, terms] of componentTerms) {
-      const sorted = [...terms].sort();
-      concepts.push({ id: iriFor(rep), prefLabel: rep, altLabels: sorted.filter((t) => t !== rep) });
-    }
-    concepts.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-    const seen = /* @__PURE__ */ new Set();
-    const related = [];
-    for (const { s, o } of relatedRaw) {
-      const cs = iriFor(find(s)), co = iriFor(find(o));
-      if (cs === co) continue;
-      const key = cs < co ? `${cs}\0${co}` : `${co}\0${cs}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      related.push({ subject: cs, object: co });
-    }
-    related.sort((a, b) => `${a.subject}${a.object}` < `${b.subject}${b.object}` ? -1 : 1);
-    const conceptIdForTerm = (term) => {
-      const t = normFactTerm(term);
-      return parent.has(t) ? iriFor(find(t)) : null;
-    };
-    return { concepts, related, conceptIdForTerm, namespace: SKOS_NS };
-  }
-  function relatedForTerm(rows, term, options = {}) {
-    const view = buildSkosConceptView(rows, options);
-    const conceptId = view.conceptIdForTerm(term);
-    if (!conceptId) return null;
-    const byId = new Map(view.concepts.map((c) => [c.id, c]));
-    const concept = byId.get(conceptId);
-    const queried = normFactTerm(term);
-    const synonyms = [concept.prefLabel, ...concept.altLabels].filter((label) => label !== queried);
-    const related = view.related.filter((r) => r.subject === conceptId || r.object === conceptId).map((r) => byId.get(r.subject === conceptId ? r.object : r.subject)).filter(Boolean);
-    return { conceptId, prefLabel: concept.prefLabel, altLabels: concept.altLabels, synonyms, related };
-  }
-
-  // src/tools/handlers/tmct-related.mjs
+  init_skos_view();
   init_memory_fallthrough();
   async function tmct_related(args, { config }) {
     const term = requiredArg(args, "term");
@@ -23396,6 +23402,9 @@ ${JSON.stringify(envelope, null, 2)}`;
     "game-inform": "inform"
   });
 
+  // src/services/chat.mjs
+  init_skos_view();
+
   // src/domain/worlds-pack.mjs
   var WORLD_NAME_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
   var WORLD_RULE_KINDS = Object.freeze([
@@ -23509,6 +23518,35 @@ ${JSON.stringify(envelope, null, 2)}`;
   init_core();
   init_completions();
 
+  // src/domain/spider-fly-world.mjs
+  var WEB_HOME = Object.freeze({ x: 2, y: 2 });
+  var DIRECTION_DELTA = Object.freeze({
+    north: Object.freeze({ dx: 0, dy: -1 }),
+    south: Object.freeze({ dx: 0, dy: 1 }),
+    east: Object.freeze({ dx: 1, dy: 0 }),
+    west: Object.freeze({ dx: -1, dy: 0 })
+  });
+  var SEED_TAXONOMY = Object.freeze([
+    Object.freeze(["poodle", "dog"]),
+    Object.freeze(["sheepdog", "dog"]),
+    Object.freeze(["dog", "animal"]),
+    Object.freeze(["spider", "arachnid"]),
+    Object.freeze(["arachnid", "animal"]),
+    Object.freeze(["fly", "insect"]),
+    Object.freeze(["insect", "animal"])
+  ]);
+
+  // src/services/spider-fly.mjs
+  init_planning();
+  init_core();
+
+  // src/services/spider-fly-turn.mjs
+  init_core();
+  var SPIDER_FLY_TOLD_RE = new RegExp(
+    "^@(spider|fly)(?:-(\\d+))?[,:]?\\s+the\\s+(spider|fly)(?:-(\\d+))?\\s+is\\s+(?:(north|south|east|west)|at\\s+(cell-\\d+-\\d+))[.!?\\s]*$",
+    "i"
+  );
+
   // src/services/chat-session.mjs
   init_node_path();
   init_node_fs();

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

@@ -0,0 +1,152 @@
+// spider-fly-browser-entry.mjs — the esbuild entry for the spider-and-fly
+// full-screen/home-page pages (public/spider-fly-browser.bundle.js, built by
+// scripts/build-spider-fly-bundle.mjs).
+//
+// Exposes ONE session factory over the real engine, `createSpiderFlySession`,
+// mirroring chat-browser-entry.mjs's `createChatSession` shape exactly (same
+// underlying runTurn, same minus-every-filesystem-side-effect posture — no
+// transcript log, no sidecar, no graph upsert) with two additions specific to
+// this game's rendering needs:
+//
+//   - `session.tick()` runs ONE real engine turn directly
+//     (spider-fly.mjs's runSpiderFlyTick), unmediated by chat text, so the
+//     page's own ticker gets back the structured `{ turn, agents, ecology }`
+//     shape it needs to redraw the board and the HUD's goal lines. This is
+//     the "page's ticker calls a turn" half of the brief.
+//   - `session.turn(line)` runs the FULL chat turn engine (chat.mjs's
+//     runTurn — the exact dispatch the CLI and the home page's own chat run,
+//     with the spider-fly lane already wired in), so the in-page chat dock
+//     supports the addressed teach-frame ("@spider the fly is east"), the
+//     bare "tick" command, and any ordinary fallthrough question ("where is
+//     the spider") exactly as the CLI does. This is the "chat dock runs
+//     runTurn" half.
+//   - `session.snapshot()` is a READ-ONLY fold (spider-fly.mjs's own
+//     foldSpiderFlyState, no engine advance) so the page can resync agent
+//     positions after a CHAT-driven tick/address turn (whose reply is text,
+//     not the structured tick() shape) without double-advancing the turn.
+//     It carries no `.goal` — the chat reply text itself already narrates
+//     that turn's outcome; only a raw tick() refreshes the HUD's goal lines.
+//
+// tick(), turn() and snapshot() all read/write the SAME in-memory store
+// (`memoryDir`), so the board and the chat dock never disagree about the
+// game's state. A caller that lets a play button and a chat submit fire
+// concurrently must serialize its own calls against this session — this
+// module runs each call to completion but does not queue overlapping ones
+// itself (see spider-fly-viz.mjs's own inlined `withLock` wrapper).
+//
+// The world bootstrap never touches the worlds-pack fetch/provider machinery
+// spider-fly-turn.mjs's openSpiderFlyGame uses (that path needs a Node fs
+// read or a registered fetch provider, neither of which this bundle carries):
+// spider-fly-world.mjs's worldFactRows()/startSpiderFlyGame are already pure/
+// in-memory, so the browser bootstraps the identical board directly from
+// them. The world's rule rows (worldRuleRows) are skipped on purpose —
+// spider-fly.mjs's own header comment confirms grid movement never reads
+// them back (hand-written pathfinding over has-exit-* facts, not the taught
+// action-rule DSL), so nothing here depends on them being loaded.
+import { runTurn } from "../../services/chat.mjs";
+import {
+  createInMemoryStore, normFactTerm, appendFacts, loadMemory, readFactRows,
+} from "../../adapters/memory/core.mjs";
+import { parseEntities } from "../../domain/codegraph.mjs";
+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 { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
+
+/** A live in-memory game the page's ticker and chat dock can both drive.
+ *  Returns { memoryDir, sessionId, opening, initial, taxonomyRows, tick,
+ *  turn, snapshot }. `initial` is the freshly-bootstrapped board's starting
+ *  agents ({ [id]: { cell } }, turn 0, no goal computed yet — the CLI's own
+ *  opener shows the same static starting board before any real tick runs).
+ *  `taxonomyRows` is the world's static rdfs:subClassOf rows, for
+ *  resolveSpriteForClass — immutable for the life of the session, so it is
+ *  computed once here rather than re-read from memory on every render. */
+export async function createSpiderFlySession({ flyCount = 1 } = {}) {
+  const memoryDir = createInMemoryStore();
+  const tag = `world:${WORLD_NAME}`;
+  const worldRows = [...worldFactRows()];
+  await appendFacts(memoryDir, worldRows.map((f) => ({
+    subject: f.subject, predicate: f.predicate, object: f.object, provenance: tag,
+  })));
+  const taxonomyRows = worldRows
+    .filter((f) => f.predicate === "rdfs:subClassOf")
+    .map((f) => ({ subject: f.subject, predicate: f.predicate, object: f.object }));
+
+  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 };
+  }
+
+  const graph = parseEntities({ individuals: [], objectProperties: [] });
+  const lexicon = loadLexicon();
+  const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
+
+  let focus = null;
+  let last = null;
+  let planState = { spiderFly: { turn: 0 } };
+
+  return {
+    memoryDir,
+    sessionId,
+    opening: WORLD_OPENING,
+    initial: { turn: 0, agents: initialAgents },
+    taxonomyRows,
+
+    /** Run one real engine turn directly. Returns spider-fly.mjs's own
+     *  { turn, agents, ecology } shape unmodified. */
+    async tick() {
+      const result = await runSpiderFlyTick(memoryDir);
+      planState = { spiderFly: { turn: result.turn } };
+      return result;
+    },
+
+    /** One dispatched chat turn — the SAME runTurn the CLI and the home
+     *  page's own chat run, over this session's own memoryDir. A throwing
+     *  runTurn must never kill the session — the page has no other chance
+     *  to show this turn's answer. */
+    async turn(line) {
+      let result;
+      try {
+        result = await runTurn(line, {
+          config: null, source: null, graph, focus, last, memoryDir, sessionId,
+          env: {}, lexicon, vocabHint: "", planState,
+        });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, record: null, plan: null };
+      }
+      focus = result.focus;
+      last = result.last;
+      if ("planState" in result) planState = result.planState;
+      return { answer: result.answer, end: Boolean(result.end), record: result.record ?? null, plan: result.plan ?? null };
+    },
+
+    /** 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. */
+    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 };
+      }
+      return { turn: state.turnCount, agents };
+    },
+  };
+}
+
+// cellId/parseCellId/DIRECTION_DELTA/visibleCells/DEFAULT_VISION_RADIUS are
+// re-exported so the page's own rendering script (spider-fly-viz.mjs) never
+// has to duplicate grid geometry or the vision-radius default: reconstructing
+// a spider's remaining silk-thread path from its returned direction list, and
+// computing the POV overlay's visible-cell mask, both need them.
+globalThis.tmctSpiderFly = {
+  createSpiderFlySession, normFactTerm, resolveSpriteForClass, SPRITE_REGISTRY,
+  cellId, parseCellId, DIRECTION_DELTA, visibleCells, DEFAULT_VISION_RADIUS,
+};