@polycode-projects/the-mechanical-code-talker 2.8.1 → 2.8.4

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

@@ -31,14 +31,16 @@
 // like a real CLI session.
 import { runTurn } from "../../services/chat.mjs";
 import {
-  createInMemoryStore, appendFacts, appendRule, loadMemory, readFactRows,
+  createInMemoryStore, appendFacts, appendRule, loadMemory, readFactRows, removeFacts,
 } from "../../adapters/memory/core.mjs";
 import { parseEntities } from "../../domain/codegraph.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { foldWorldState, worldDigestRows, roomAffordances } from "../../services/adventure.mjs";
 import { runAdventureAutoplayTick, exposedFacts } from "../../services/adventure-autoplay.mjs";
-import { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
+import { parseWorldEditorText, planWorldEditorSync } from "../../services/adventure-editor.mjs";
+import { resolveSpriteForClass, SPRITE_REGISTRY, classAncestorChain } from "../../domain/sprite-map.mjs";
 import { resolveSpriteAsset } from "../../domain/sprite-templates.mjs";
+import { relatedForTerm } from "../../domain/skos-view.mjs";
 
 /** A live in-memory adventure this page's ticker AND chat dock can both
  *  drive. Returns `{ memoryDir, autoplayTick, turn, snapshot }`.
@@ -137,6 +139,30 @@ export async function createAdventureSession(worldPayload) {
       const here = state.placements.get("player")?.object ?? null;
       return { rows, state, here, turn: state.turnCount, visitedRoomIds: [...visitedRoomIds] };
     },
+
+    /** The world editor's own store sync: parse `text` (adventure-editor.mjs's
+     *  own parseWorldEditorText), plan the implied writes (planWorldEditorSync),
+     *  and apply them — scoped to THIS world's own provenance tag only, never
+     *  the default persona's background corpus that shares the same live
+     *  memory store (an unscoped diff would read every unrelated background
+     *  fact as "not in this text" and try to retract it). Retractions
+     *  (removeFacts) only ever run when the WHOLE document parsed cleanly —
+     *  see adventure-editor.mjs's own header for why a typo must never be
+     *  read as "this fact is gone". Returns `{ unrecognized, added, removed }`. */
+    async applyEdit(text) {
+      const allRows = readFactRows(await loadMemory(memoryDir));
+      const worldRows = allRows.filter((r) => typeof r.provenance === "string" && r.provenance.indexOf(tag) === 0);
+      const state = foldWorldState(worldRows);
+      const { triples, unrecognized } = parseWorldEditorText(text, worldRows);
+      const { toAppend, toRemoveIds } = planWorldEditorSync(worldRows, state, triples);
+      if (toAppend.length) {
+        await appendFacts(memoryDir, toAppend.map((f) => ({ subject: f.subject, predicate: f.predicate, object: f.object, provenance: tag })));
+      }
+      const removedCount = unrecognized.length === 0 && toRemoveIds.length ? (await removeFacts(memoryDir, toRemoveIds)).removed.length : 0;
+      const here = foldWorldState(readFactRows(await loadMemory(memoryDir))).placements.get("player")?.object ?? null;
+      if (here) visitedRoomIds.add(here);
+      return { unrecognized, added: toAppend.length, removed: removedCount };
+    },
   };
 }
 
@@ -145,8 +171,13 @@ export async function createAdventureSession(worldPayload) {
 // affordances the chat dock's own pills read from, or (foldWorldState,
 // exposedFacts) the exposure-filtered fold the goal-status panel mirrors —
 // the same posture spider-fly-browser-entry.mjs's own
-// globalThis.tmctSpiderFly re-export takes.
+// globalThis.tmctSpiderFly re-export takes. `relatedForTerm`/
+// `classAncestorChain` back the edit mode's own cursor-suggestion pills
+// (adventure-viz.mjs's suggestionsForTerm mirrors this same pairing against
+// the global, the same reach-through-the-global pattern captionFor/pillsFor
+// already use for their own adventure.mjs calls).
 globalThis.tmctAdventure = {
   createAdventureSession, resolveSpriteForClass, SPRITE_REGISTRY, resolveSpriteAsset,
   worldDigestRows, roomAffordances, foldWorldState, exposedFacts,
+  relatedForTerm, classAncestorChain,
 };

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

@@ -23594,10 +23594,13 @@ ${JSON.stringify(envelope, null, 2)}`;
       spiderMassDecrementPerTurn: 0.5,
       flyInitialMass: 10,
       flyMassDecrementPerTurn: 1,
-      visionRadius: 4,
+      spiderVisionRadius: 4,
+      flyVisionRadius: 4,
       eggHatchDelayTurns: 3,
       flySpawnIntervalTurns: 3,
-      eggsEatenThreshold: 2,
+      eggLayMassThreshold: 25,
+      eggHatchCount: 2,
+      minHatchlingMass: 3,
       webDurationTurns: 10
     }),
     guessNumber: Object.freeze({
@@ -23614,10 +23617,13 @@ ${JSON.stringify(envelope, null, 2)}`;
     spider_mass_decrement_per_turn: "spiderMassDecrementPerTurn",
     fly_initial_mass: "flyInitialMass",
     fly_mass_decrement_per_turn: "flyMassDecrementPerTurn",
-    vision_radius: "visionRadius",
+    spider_vision_radius: "spiderVisionRadius",
+    fly_vision_radius: "flyVisionRadius",
     egg_hatch_delay_turns: "eggHatchDelayTurns",
     fly_spawn_interval_turns: "flySpawnIntervalTurns",
-    eggs_eaten_threshold: "eggsEatenThreshold",
+    egg_lay_mass_threshold: "eggLayMassThreshold",
+    egg_hatch_count: "eggHatchCount",
+    min_hatchling_mass: "minHatchlingMass",
     web_duration_turns: "webDurationTurns"
   });
   var GUESS_NUMBER_KEY_MAP = Object.freeze({

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

@@ -0,0 +1,114 @@
+// plan-browser-entry.mjs — the esbuild entry for the "it plans, and shows
+// the work" page's live session (public/plan-browser.bundle.js, built by
+// scripts/build-plan-bundle.mjs), mirroring spider-fly-browser-entry.mjs's
+// and adventure-browser-entry.mjs's own session-factory shape.
+//
+// Unlike spider-fly's board or Ashcombe Hall's world, hanoi has no
+// structured fact/rule corpus to bootstrap from — its canonical definition
+// (data/games/hanoi-3.txt) IS taught English, one sentence per teach frame.
+// So this session seeds itself the same way `tmct import --file` teaches
+// that file (src/services/import-file.mjs): every sentence
+// hanoi-lesson.mjs's hanoiLessonSentences() generates runs as its own
+// `turn()`, over the exact same runTurn the CLI and every other viz page's
+// chat dock run — not raw appendFacts/appendRule, since there is no
+// structured fact list to append here, only taught English.
+//
+// createPlanSession({ diskCount, maxDepth }) teaches a fresh N-disk puzzle
+// and solves it once (mirroring the "disk-1 rests on disk-2. … the goal is
+// that every disk rests on peg-c. solve it." prompt scripts/build-demo-
+// site.mjs used to shell out to the CLI for), returning `{ plan, turn, ... }`
+// — `plan` is the freshly solved plan (or null on an honest miss, e.g. a
+// max-depth too low to find one), `turn(line, { maxDepth })` is the SAME
+// chat-dock entry point adventure/spider-fly expose, so a visitor's typed
+// fact and a visitor's typed "solve it" both dispatch through the real
+// engine. `maxDepth` is overridable PER CALL (not just at session creation)
+// so the page's own max-search-depth control can re-run "solve it" on the
+// CURRENT board without tearing down and re-teaching the whole puzzle.
+import { runTurn } from "../../services/chat.mjs";
+import { createInMemoryStore } from "../../adapters/memory/core.mjs";
+import { parseEntities } from "../../domain/codegraph.mjs";
+import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
+import { DEFAULT_GAME_CONFIG } from "../../domain/game-config.mjs";
+import { hanoiLessonSentences } from "../../domain/hanoi-lesson.mjs";
+import { computeBlocksLayout, planToPageData, renderInputsFromPlan } from "../../services/plan-viz.mjs";
+import { planToPddl } from "../../services/plan-pddl.mjs";
+// Re-exported so the page can register a CDN-loaded wink-nlp pair before the
+// first teach, the same seam chat-browser-entry.mjs exposes as
+// tmctChat.registerWinkModel — see wink-model.mjs's own header. The hanoi
+// lesson's own "moving a disk onto a target makes the disk rest on the
+// target" sentence needs a REAL lemmatiser (verbLemma reduces "moving" to
+// "move" to match the taught "move onto" action family) — without it, that
+// one sentence honestly declines ("the lemmatizer isn't available"), the
+// action rule never gets its effect, and every later locative fact for the
+// puzzle fails to teach in turn. spider-fly/adventure never register a wink
+// model because their own gameplay never asks a taught rule to reduce a
+// verb; the hanoi lesson is the first live session here that does.
+import { registerWinkModel } from "../../adapters/wink-model.mjs";
+
+/** A live in-memory towers-of-hanoi session this page's live controls AND
+ *  chat dock can both drive. Returns `{ memoryDir, sessionId, diskCount,
+ *  maxDepth, plan, turn }`. `plan` is the puzzle's freshly solved plan (the
+ *  same shape chat.mjs's planLaneAnswer returns, enriched with
+ *  `becauseText` — see `turn()` below), or null when `maxDepth` was too low
+ *  to find one (an honest miss, not an error: `turn()`'s own answer text
+ *  names it). */
+export async function createPlanSession({ diskCount = 3, maxDepth = DEFAULT_GAME_CONFIG.planning.maxDepth } = {}) {
+  const memoryDir = createInMemoryStore();
+  const graph = parseEntities({ individuals: [], objectProperties: [] });
+  const lexicon = loadLexicon();
+  const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
+  const planHolder = { state: null };
+  let focus = null;
+  let last = null;
+
+  /** One dispatched chat turn — the SAME runTurn the CLI and every other
+   *  viz page's own chat dock 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. `maxDepth` overrides the session's
+   *  own default for just this one call (the page's own max-search-depth
+   *  control threads it on every call, including a plain typed "solve
+   *  it"), so raising or lowering it never requires re-teaching the board.
+   *  A returned `plan` carries `becauseText` folded in from the session's
+   *  own plan slot — the plan-lane contract's returned object never carries
+   *  it itself (only planHolder.state does), and the PDDL panel's own
+   *  "because —" line needs it. */
+  async function turn(line, { maxDepth: maxDepthOverride } = {}) {
+    const gameConfig = {
+      ...DEFAULT_GAME_CONFIG,
+      planning: { ...DEFAULT_GAME_CONFIG.planning, maxDepth: maxDepthOverride ?? maxDepth },
+    };
+    let result;
+    try {
+      result = await runTurn(line, {
+        config: null, source: null, graph, focus, last, memoryDir, sessionId,
+        env: {}, lexicon, vocabHint: "", planState: planHolder.state, gameConfig,
+      });
+    } 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) planHolder.state = result.planState;
+    const plan = result.plan
+      ? { ...result.plan, becauseText: planHolder.state?.becauseText ?? null }
+      : null;
+    return { answer: result.answer, end: Boolean(result.end), record: result.record ?? null, plan };
+  }
+
+  let plan = null;
+  for (const sentence of hanoiLessonSentences(diskCount)) {
+    const r = await turn(sentence);
+    if (r.plan) plan = r.plan;
+  }
+
+  return { memoryDir, sessionId, diskCount, maxDepth, plan, turn };
+}
+
+// Re-exported so the page's own rendering script (plan-viz.mjs's inlined
+// script) never has to duplicate board layout or PDDL/OWL-RDF formatting —
+// the same posture adventure-browser-entry.mjs/spider-fly-browser-entry.mjs
+// take re-exporting their own engines' pure helpers.
+globalThis.tmctPlan = {
+  createPlanSession, computeBlocksLayout, planToPageData, renderInputsFromPlan, planToPddl, registerWinkModel,
+};

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

@@ -53,8 +53,10 @@ import {
   worldFactRows, WORLD_NAME, WORLD_OPENING, cellId, parseCellId, DIRECTION_DELTA, visibleCells,
 } from "../../domain/spider-fly-world.mjs";
 import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame, liveWebs, DEFAULT_VISION_RADIUS } from "../../services/spider-fly.mjs";
+import { pillsForSpiderFly, oneStepDirectionBetween } from "../../services/spider-fly-turn.mjs";
 import { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
 import { resolveSpriteAsset } from "../../domain/sprite-templates.mjs";
+import { DEFAULT_GAME_CONFIG } from "../../domain/game-config.mjs";
 
 /** A live in-memory game the page's ticker and chat dock can both drive.
  *  Returns { memoryDir, sessionId, opening, initial, taxonomyRows, tick,
@@ -89,6 +91,14 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
   let focus = null;
   let last = null;
   let planState = { spiderFly: { turn: 0 } };
+  // The live, in-page-slider-adjustable knobs (mass-loss-rate/spawn-rate/
+  // vision-radius per class, and every other spiderFly tunable) — starts at
+  // the shipped defaults, mutated only through setConfig() below, and
+  // forwarded into every future tick()/turn() call. Never rewinds a value
+  // that was already written to a past turn's facts (e.g. a spider already
+  // above the OLD lay threshold isn't retroactively un-laid) — a config
+  // change only changes what happens FROM HERE ON, same as tmct.toml would.
+  let config = { ...DEFAULT_GAME_CONFIG.spiderFly };
 
   return {
     memoryDir,
@@ -100,7 +110,7 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
     /** Run one real engine turn directly. Returns spider-fly.mjs's own
      *  { turn, agents, ecology } shape unmodified. */
     async tick() {
-      const result = await runSpiderFlyTick(memoryDir);
+      const result = await runSpiderFlyTick(memoryDir, { config });
       planState = { spiderFly: { turn: result.turn } };
       return result;
     },
@@ -115,6 +125,7 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
         result = await runTurn(line, {
           config: null, source: null, graph, focus, last, memoryDir, sessionId,
           env: {}, lexicon, vocabHint: "", planState,
+          gameConfig: { ...DEFAULT_GAME_CONFIG, spiderFly: config },
         });
       } catch (e) {
         const message = e instanceof Error ? e.message : String(e);
@@ -141,6 +152,23 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
       }
       return { turn: state.turnCount, agents, activeWebs: liveWebs(state.webs, state.turnCount) };
     },
+
+    /** The live spiderFly config this session's future tick()/turn() calls
+     *  will read — a plain copy, safe for a caller to inspect without
+     *  risking a shared-reference mutation. */
+    getConfig() {
+      return { ...config };
+    },
+
+    /** Merge `partial` (any subset of DEFAULT_GAME_CONFIG.spiderFly's own
+     *  keys, e.g. `{ spiderMassDecrementPerTurn: 0.2 }`) over the live
+     *  config — the in-page sliders' own write path. Every unset sibling
+     *  keeps its current value, mirroring resolveGameConfig's own
+     *  toml-merge shape so a slider and tmct.toml can never disagree about
+     *  what "partial" means. */
+    setConfig(partial) {
+      config = { ...config, ...partial };
+    },
   };
 }
 
@@ -149,7 +177,11 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
 // 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.
+// pillsForSpiderFly/oneStepDirectionBetween are re-exported so the same page
+// can build its own dynamic deception-pill container without duplicating
+// spider-fly-turn.mjs's own pill logic.
 globalThis.tmctSpiderFly = {
   createSpiderFlySession, normFactTerm, resolveSpriteForClass, SPRITE_REGISTRY, resolveSpriteAsset,
   cellId, parseCellId, DIRECTION_DELTA, visibleCells, DEFAULT_VISION_RADIUS,
+  pillsForSpiderFly, oneStepDirectionBetween, DEFAULT_GAME_CONFIG,
 };