@polycode-projects/the-mechanical-code-talker 5.0.2 → 5.0.4

package/src/services/mudiii-scene.mjs

@@ -130,16 +130,14 @@ export function chebyshevDistanceBetweenCells(a, b) {
   return Math.max(Math.abs(Number(ma[1]) - Number(mb[1])), Math.abs(Number(ma[2]) - Number(mb[2])));
 }
 
-/** A facing word to a Y rotation in radians, `south` (the world's own
- *  `defaultFacing`) at zero — matches `cameraRigFor`'s own FACING_VECTOR
- *  convention (`south: {x:0,z:1}`, `north: {x:0,z:-1}`, `east: {x:1,z:0}`,
- *  `west: {x:-1,z:0}`) so an agent mesh turns to face the same way its own
- *  follow/pov camera rig would sit behind it. A rig's own forward axis may
- *  need a per-model offset once real assets are in place; this is the
- *  world-facing convention, not a guarantee about any one GLB's neutral
- *  pose. Pure. */
+/** A facing word to a Y rotation in radians. Assumes a model's own local
+ *  forward is +Z (true for fox and goblin, the two rigs in the current
+ *  manifest, checked by walking each GLB's own bind-pose bone chain) so a
+ *  rotated mesh matches `cameraRigFor`'s own FACING_VECTOR table exactly for
+ *  all four cardinals — a model with a -Z neutral pose would need its own
+ *  offset. Pure. */
 export function yawForFacing(facing) {
-  const YAW = { south: 0, north: Math.PI, east: -Math.PI / 2, west: Math.PI / 2 };
+  const YAW = { south: 0, north: Math.PI, east: Math.PI / 2, west: -Math.PI / 2 };
   return YAW[facing] ?? YAW.south;
 }
 
@@ -188,12 +186,14 @@ export function currentActionFor(agentId, agentsById, moving) {
  *  so acting on the ecology row too would double it). `kind` is one of
  *  "death" (the rig's own Death clip, then scale to zero) or "consume" (an
  *  eaten item scales to zero, no clip — items are primitive geometry).
- *  Pure. */
+ *  `eat-agent` alone also carries `actorId`, the predator that gets a
+ *  one-shot attack clip while its prey plays death — the one event where a
+ *  second, surviving agent has its own flourish to play. Pure. */
 export function flourishForEcologyEvent(event) {
   if (!event || !event.type) return null;
   switch (event.type) {
     case "eat-agent":
-      return { kind: "death", targetId: event.prey, cell: event.cell };
+      return { kind: "death", targetId: event.prey, cell: event.cell, actorId: event.predator };
     case "starve":
       return { kind: "death", targetId: event.agent, cell: event.cell };
     case "eat-item":
@@ -352,7 +352,7 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
 
   var loadThreeVendor = createThreeVendorLoader();
   var THREE = null, GLTFLoaderCtor = null, OrbitControlsCtor = null, MeshoptDecoderRef = null;
-  var gltfLoader = null, loadQueue = createConcurrencyQueue(4), rawLoader = null;
+  var gltfLoader = null, loadQueue = createConcurrencyQueue(4);
   var scene = null, camera3 = null, renderer = null, orbitControls = null, groundMesh = null, raycaster = null;
   var agentGroups = {};
   var itemMeshes = {};
@@ -361,21 +361,37 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
   var manifestByKind = {};
   var lastAgentsById = {};
   var lastItemsById = {};
+  // Every removeAgent/removeItem call, kept small and reset on boot — an
+  // e2e assertion's read, so it can tell an eaten agent/item's flourish
+  // removal (source "ecology") apart from applyTick's own diff no-op
+  // (source "diff") without guessing from a vanished mesh alone.
+  var removalLog = [];
   var cameraState = { mode: "overhead", selectedId: null };
   var cameraTween = null, lookAtTween = null;
   var lastFrameTs = null;
   var booted = false;
 
+  // Cache the fetched BYTES, not the parsed scene: one network request per
+  // model URL, however many agents share that kind, then a GLTFLoader.parse
+  // per caller off the shared ArrayBuffer. Each caller still ends up owning
+  // its own object graph, so normalizeToHeight's own guards still hold.
+  function fetchGlbBytes(url) {
+    return fetch(url).then(function (res) {
+      if (!res.ok) throw new Error("model fetch failed with status " + res.status + ": " + url);
+      return res.arrayBuffer();
+    });
+  }
+  var glbBytesCache = createCachedLoader(fetchGlbBytes);
+
   function loadGlbRaw(url) {
-    return loadQueue.run(function () {
-      return new Promise(function (resolve, reject) {
-        gltfLoader.load(url, resolve, undefined, reject);
+    return glbBytesCache.load(url).then(function (buffer) {
+      return loadQueue.run(function () {
+        return new Promise(function (resolve, reject) {
+          gltfLoader.parse(buffer, THREE.LoaderUtils.extractUrlBase(url), resolve, reject);
+        });
       });
     });
   }
-  var glbCache = null;
-  function loadGlb(url) { return glbCache.load(url); }
-
   async function ensureThree() {
     if (THREE) return true;
     var result = await loadThreeVendor();
@@ -384,7 +400,6 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     OrbitControlsCtor = result.OrbitControls; MeshoptDecoderRef = result.MeshoptDecoder;
     gltfLoader = new GLTFLoaderCtor();
     gltfLoader.setMeshoptDecoder(MeshoptDecoderRef);
-    glbCache = createCachedLoader(loadGlbRaw);
     setUpScene();
     return true;
   }
@@ -473,24 +488,51 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
   }
 
   // ---- props ---------------------------------------------------------------
+  // Box3.setFromObject reads through a parent's world matrix, so measuring a
+  // parented object reads whatever that parent's spawn flourish is doing in
+  // that frame and applies a scale that depends on the frame. The guards make
+  // both misuses fail loudly rather than render a wrong size silently. Keep
+  // no backtick in this block: the function's source sits inside the module's
+  // own template literal.
   function normalizeToHeight(object3D, targetHeight) {
+    if (object3D.parent) {
+      throw new Error("normalizeToHeight refused an object that already has a parent: " + (object3D.name || object3D.uuid));
+    }
+    if (object3D.userData.tmctNormalized) {
+      throw new Error("normalizeToHeight refused a second call on the same object: " + (object3D.name || object3D.uuid));
+    }
     var box = new THREE.Box3().setFromObject(object3D);
     var size = new THREE.Vector3();
     box.getSize(size);
-    var height = size.y || 1;
-    var scale = targetHeight && height ? targetHeight / height : 1;
+    if (!size.y) {
+      // Substituting 1 here invented a scale from an unmeasurable height, and
+      // that is what produced the house-height mesh.
+      throw new Error("normalizeToHeight found no measurable height on: " + (object3D.name || object3D.uuid));
+    }
+    var scale = targetHeight ? targetHeight / size.y : 1;
     object3D.scale.setScalar(scale);
     var seated = new THREE.Box3().setFromObject(object3D);
     object3D.position.y -= seated.min.y;
-  }
-
-  async function loadPropTemplate(asset) {
-    var url = modelUrlFor(asset.destPath);
-    if (propTemplates[url]) return propTemplates[url];
-    var gltf = await loadGlb(url);
-    normalizeToHeight(gltf.scene, asset.targetHeight);
-    propTemplates[url] = gltf.scene;
-    return gltf.scene;
+    object3D.userData.tmctNormalized = true;
+  }
+
+  // Keyed on the manifest row's own key field, not its destPath: food-crumb
+  // and food-morsel share one GLB at two different targetHeights, and
+  // normalizeToHeight refuses a second call on the same object, so a
+  // destPath-keyed cache would hand the second row the first row's
+  // already-normalized graph and throw.
+  function loadPropTemplate(asset) {
+    var key = asset.key;
+    if (!propTemplates[key]) {
+      var url = modelUrlFor(asset.destPath);
+      var promise = loadGlbRaw(url).then(function (gltf) {
+        normalizeToHeight(gltf.scene, asset.targetHeight);
+        return gltf.scene;
+      });
+      promise.catch(function () { delete propTemplates[key]; });
+      propTemplates[key] = promise;
+    }
+    return propTemplates[key];
   }
 
   async function placeProps(propPlacements) {
@@ -515,11 +557,11 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     }
   }
 
-  // ---- items: crumbs and morsels, primitive geometry ------------------------
-  var CRUMB_RADIUS = 0.08, MORSEL_RADIUS = 0.18;
-  function itemGeometryFor(kind) { return new THREE.SphereGeometry(kind === "morsel" ? MORSEL_RADIUS : CRUMB_RADIUS, 10, 8); }
-  function itemMaterialFor(kind) { return new THREE.MeshStandardMaterial({ color: kind === "morsel" ? 0xd98a2b : 0x8c6a3f }); }
-  function itemHeightFor(kind) { return kind === "morsel" ? MORSEL_RADIUS : CRUMB_RADIUS; }
+  // ---- items: crumbs and morsels, the committed hay bale at two target
+  // heights (food-crumb 0.16, food-morsel 0.36 in data/mudiii-assets.json),
+  // matching the on-ground footprint the primitive spheres they replace were
+  // already tuned to. ---------------------------------------------------------
+  function itemAssetKeyFor(kind) { return kind === "morsel" ? "food-morsel" : "food-crumb"; }
 
   function animateScaleTo(object3D, target, now) {
     var duration = tweenDurationMs;
@@ -535,29 +577,55 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     requestAnimationFrame(step);
   }
 
+  // A Group per live item, the same shape ensureAgent uses for agents: the
+  // group is in the scene (and in itemMeshes) synchronously so a second tick
+  // arriving before the GLB resolves finds an existing entry rather than
+  // starting a second load, but stays invisible until the model is in it.
   function applyItemTick(id, item, now) {
     var world = cellToWorld(item.cell, GRID_SIZE, CELL_SIZE);
     if (!world) return;
     var entry = itemMeshes[id];
-    if (!entry) {
-      var mesh = new THREE.Mesh(itemGeometryFor(item.kind), itemMaterialFor(item.kind));
-      mesh.name = "item-" + id;
-      mesh.position.set(world.x, itemHeightFor(item.kind), world.z);
-      mesh.scale.setScalar(0);
-      scene.add(mesh);
-      entry = { mesh: mesh, cell: item.cell, kind: item.kind };
-      itemMeshes[id] = entry;
-      animateScaleTo(mesh, 1, now);
+    if (entry) {
+      entry.cell = item.cell;
+      entry.mesh.position.set(world.x, 0, world.z);
       return;
     }
-    entry.cell = item.cell;
-    entry.mesh.position.set(world.x, itemHeightFor(item.kind), world.z);
+    var group = new THREE.Group();
+    group.name = "item-" + id;
+    group.position.set(world.x, 0, world.z);
+    group.visible = false;
+    scene.add(group);
+    entry = { mesh: group, cell: item.cell, kind: item.kind };
+    itemMeshes[id] = entry;
+    var asset = manifestByKind[itemAssetKeyFor(item.kind)];
+    if (!asset) return;
+    loadPropTemplate(asset).then(function (template) {
+      if (itemMeshes[id] !== entry) return; // removed while the model was still loading
+      var instance = template.clone();
+      instance.position.y = template.position.y;
+      group.add(instance);
+      group.visible = true;
+      group.scale.setScalar(0);
+      animateScaleTo(group, 1, performance.now());
+    }).catch(function (err) {
+      // eslint-disable-next-line no-console
+      console.warn("tmct: an item model failed to load", id, err);
+    });
   }
 
-  function removeItem(id, withFlourish) {
+  function recordRemoval(kind, id, source) {
+    removalLog.push({ kind: kind, id: id, source: source });
+  }
+
+  // source ("ecology" | "diff") is recorded, never branched on — it exists
+  // so an e2e assertion can tell an eaten item's flourish removal apart from
+  // a plain diff no-op, since a vanished mesh alone does not say which path
+  // did the removing.
+  function removeItem(id, withFlourish, source) {
     var entry = itemMeshes[id];
     if (!entry) return;
     delete itemMeshes[id];
+    recordRemoval("item", id, source);
     if (withFlourish) animateScaleTo(entry.mesh, 0, performance.now());
     else if (entry.mesh.parent) entry.mesh.parent.remove(entry.mesh);
   }
@@ -572,14 +640,14 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     var kind = roleOfAgentId(id);
     var entry = {
       group: new THREE.Group(), tween: null, cell: null, facing: agent.facing, role: agent.role,
-      kind: kind, mixer: null, actions: {}, currentClip: null, clipMap: null,
+      kind: kind, mixer: null, actions: {}, currentClip: null, clipMap: null, oneShotAction: null,
     };
     entry.group.visible = false;
     scene.add(entry.group);
     agentGroups[id] = entry;
     var asset = manifestByKind[kind];
     if (asset) {
-      loadGlb(modelUrlFor(asset.destPath)).then(function (gltf) {
+      loadGlbRaw(modelUrlFor(asset.destPath)).then(function (gltf) {
         normalizeToHeight(gltf.scene, asset.targetHeight);
         entry.group.add(gltf.scene);
         entry.group.visible = true;
@@ -597,6 +665,15 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
   }
 
   function playClip(entry, clipName) {
+    // A one-shot flourish left its own action running at full weight (see
+    // playClipOnce below — fadeIn ramps the NEW action in but never ramps
+    // the old one out on its own, so without this the flourish pose would
+    // keep blending into every clip after it, forever). Fade it out before
+    // any of the guards below can skip the rest of this call.
+    if (entry.oneShotAction) {
+      entry.oneShotAction.fadeOut(0.15);
+      entry.oneShotAction = null;
+    }
     if (!entry.mixer || !clipName || entry.currentClip === clipName) return;
     var next = entry.actions[clipName];
     if (!next) return;
@@ -606,6 +683,28 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     entry.currentClip = clipName;
   }
 
+  // A one-shot version of playClip for a flourish (the predator's own bite
+  // on eat-agent): LoopOnce + clampWhenFinished so the clip plays through and
+  // holds its last pose rather than looping. Never skips a repeat of
+  // entry.currentClip the way playClip does — a flourish must always play,
+  // even if the actor happened to already be on this same clip. Clears
+  // entry.currentClip to null so the next applyAgentTick's own playClip call
+  // is never refused as "already on this clip", and records the action on
+  // entry.oneShotAction so that same next call fades it back out.
+  function playClipOnce(entry, clipName) {
+    if (!entry.mixer || !clipName) return;
+    var action = entry.actions[clipName];
+    if (!action) return;
+    var prev = entry.currentClip && entry.currentClip !== clipName ? entry.actions[entry.currentClip] : null;
+    action.reset();
+    action.setLoop(THREE.LoopOnce, 1);
+    action.clampWhenFinished = true;
+    action.fadeIn(0.15).play();
+    if (prev) prev.fadeOut(0.15);
+    entry.oneShotAction = action;
+    entry.currentClip = null;
+  }
+
   function playSpawnFlourish(group, now) {
     group.scale.setScalar(0);
     animateScaleTo(group, 1, now);
@@ -636,10 +735,11 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     }
   }
 
-  function removeAgent(id) {
+  function removeAgent(id, source) {
     var entry = agentGroups[id];
     if (!entry) return;
     delete agentGroups[id];
+    recordRemoval("agent", id, source);
     var deathClip = entry.clipMap && entry.clipMap.death;
     var deathClipName = Array.isArray(deathClip) ? deathClip[0] : deathClip;
     if (deathClipName) {
@@ -652,10 +752,17 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
 
   function applyEcology(ecology) {
     for (var i = 0; i < (ecology || []).length; i += 1) {
-      var flourish = flourishForEcologyEvent(ecology[i]);
+      var event = ecology[i];
+      var flourish = flourishForEcologyEvent(event);
       if (!flourish) continue;
-      if (flourish.kind === "death") removeAgent(flourish.targetId);
-      else if (flourish.kind === "consume") removeItem(flourish.targetId, true);
+      if (flourish.kind === "death") removeAgent(flourish.targetId, "ecology");
+      else if (flourish.kind === "consume") removeItem(flourish.targetId, true, "ecology");
+      if (flourish.actorId) {
+        var actorEntry = agentGroups[flourish.actorId];
+        if (actorEntry && actorEntry.clipMap) {
+          playClipOnce(actorEntry, clipForAction(actorEntry.role, event.type, actorEntry.clipMap));
+        }
+      }
     }
   }
 
@@ -710,6 +817,7 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     itemMeshes = {};
     lastAgentsById = {};
     lastItemsById = {};
+    removalLog = [];
     manifestByKind = buildManifestByKind(input && input.assetManifest);
     await placeProps((input && input.propPlacements) || []);
     setCamera({ mode: "overhead", selectedId: null });
@@ -723,9 +831,15 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     var items = (tick && tick.items) || {};
     for (var id in agents) if (Object.prototype.hasOwnProperty.call(agents, id)) applyAgentTick(id, agents[id], now);
     for (var itemId in items) if (Object.prototype.hasOwnProperty.call(items, itemId)) applyItemTick(itemId, items[itemId], now);
-    for (var goneAgent in lastAgentsById) if (!(goneAgent in agents)) removeAgent(goneAgent);
-    for (var goneItem in lastItemsById) if (!(goneItem in items)) removeItem(goneItem, false);
+    // Ecology first: an eaten agent/item is already gone from this tick's own
+    // agents/items map, so applyEcology's own removeAgent/removeItem call is
+    // what actually removes it (with its flourish). The two diff loops below
+    // then find that id already deleted and no-op — removeAgent/removeItem
+    // both delete their map entry before anything else, so a second call for
+    // the same id returns immediately.
     applyEcology(tick && tick.ecology);
+    for (var goneAgent in lastAgentsById) if (!(goneAgent in agents)) removeAgent(goneAgent, "diff");
+    for (var goneItem in lastItemsById) if (!(goneItem in items)) removeItem(goneItem, false, "diff");
     lastAgentsById = agents;
     lastItemsById = items;
     refreshCameraTween(now);
@@ -760,6 +874,36 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
       if (itemMeshes[id]) return itemMeshes[id].cell;
       return null;
     },
+    // The live agent group's own applied Y rotation, in radians -- an e2e
+    // assertion's read, so it can compare the yaw actually applied against
+    // the direction an agent travelled between two cells rather than trusting
+    // yawForFacing's own output in isolation.
+    yawOf: function (id) {
+      var entry = agentGroups[id];
+      return entry ? entry.group.rotation.y : null;
+    },
+    // The live agent mesh's world-space height and lowest point, plus the
+    // manifest's own targetHeight to compare it against — an e2e assertion's
+    // read, so it goes through the group actually in the scene rather than a
+    // second, locally invented measurement.
+    meshHeightOf: function (id) {
+      var entry = agentGroups[id];
+      if (!entry || !entry.group || entry.group.children.length === 0) return null;
+      var box = new THREE.Box3().setFromObject(entry.group);
+      var size = new THREE.Vector3();
+      box.getSize(size);
+      var asset = manifestByKind[entry.kind];
+      return { height: size.y, minY: box.min.y, targetHeight: asset ? asset.targetHeight : null };
+    },
+    // Every removal recorded for id, oldest first — each entry's own
+    // source is "ecology" (an eat/starve flourish removed it) or "diff"
+    // (applyTick found it missing from a tick's own agents/items map with no
+    // ecology event driving that). An e2e assertion's read.
+    removalsFor: function (id) {
+      var out = [];
+      for (var i = 0; i < removalLog.length; i += 1) if (removalLog[i].id === id) out.push(removalLog[i]);
+      return out;
+    },
     ready: function () { return booted; },
   };
 })();`;

package/src/services/mudiii-turn.mjs

@@ -15,7 +15,7 @@
 import {
   TOWN_SQUARE_LAYOUTS, DEFAULT_GRID_SIZE, DIRECTION_DELTA,
   cellId, parseCellId, inBounds, chebyshevDistance, oneStepDirectionBetween,
-  agentKindOf, liveIdsOfKind, layoutNamed,
+  agentKindOf, liveIdsOfKind, layoutNamed, isFoodId,
 } from "../domain/town-square-world.mjs";
 import {
   MUDIII_ROLES, foldTownSquareState, startTownSquareGame, runTownSquareTick,
@@ -88,6 +88,25 @@ const MUDIII_TOLD_RE = new RegExp(
 // never ground truth.
 const MUDIII_SEE_RE = /^what (?:does|can) the (fox|goblin)(?:-(\d+))?\s+see[.!?\s]*$/i;
 
+// "who put/placed that there?" — provenance, ground truth (not belief), read
+// from placeFood's own mgx:placed-by row. The subject must be named, either
+// an item id ("who put morsel-1 there?") or a cell ("who put food at
+// cell-3-4?") — a bare "who put that there?" with no referent at all names
+// nothing to look up and is left to the ordinary lanes. Requires the leading
+// "who put/placed/dropped" verb, so it never collides with an unrelated "who"
+// question (the fox's own catches, the goblins' names, anything not about a
+// placement) — those never start with this verb at all.
+const MUDIII_WHO_PLACED_RE = new RegExp(
+  "^who\\s+(?:put|placed|dropped)\\s+"
+  + "(?:"
+  + "(?:the\\s+)?(morsel|crumb)(?:-(\\d+))?"
+  + "|"
+  + "(?:(?:the\\s+)?(?:food|morsel|crumb|that|it)\\s+)?(?:at|on)\\s+(cell-\\d+-\\d+)"
+  + ")"
+  + "(?:\\s+there)?[?.!\\s]*$",
+  "i",
+);
+
 // The player's own verb: "put food at cell-3-4" (primary, never shadowed —
 // the adventure imperative grammar's own "put" arm hard-requires a literal
 // "in", so "at" never parses there) and "drop a morsel at cell-3-4"
@@ -441,6 +460,63 @@ async function mudiiiBeliefAnswer(match, { memoryDir, gameConfig = DEFAULT_GAME_
   };
 }
 
+function noLivePlacedSubjectAnswer(kind) {
+  return {
+    text: `there's no live ${kind} on the board for that to be about.`,
+    lane: "game-inform",
+    note: `MUDIII — who-placed declined: no live ${kind} resolves`,
+    miss: true,
+  };
+}
+
+/** "who put/placed <item|cell> there?": ground truth read off the folded
+ *  state's own placedBy Map (predator-prey.mjs's fold of every mgx:placed-by
+ *  row), never belief. Resolves the subject the same way the told-fact and
+ *  see recognizers already do — resolveAgentId for a named item, a direct
+ *  placements scan for a cell — then declines, naming the reason, when the
+ *  item isn't on the board at all or is on the board but carries no placedBy
+ *  row (spawned food never does; placeFood is the only writer of that row). */
+async function mudiiiWhoPlacedAnswer(match, { memoryDir }) {
+  const [, kindRaw, num, cellLiteral] = match;
+  const rows = readFactRows(await loadMemory(memoryDir));
+  const state = foldTownSquareState(rows);
+
+  let itemId = null;
+  if (kindRaw) {
+    itemId = resolveAgentId(kindRaw.toLowerCase(), num, state);
+  } else {
+    const entry = [...state.placements.entries()].find(([id, place]) =>
+      isFoodId(id) && !state.removed.has(id) && place.cell === cellLiteral);
+    itemId = entry ? entry[0] : null;
+  }
+
+  if (!itemId) {
+    if (kindRaw) return noLivePlacedSubjectAnswer(kindRaw.toLowerCase());
+    return {
+      text: `there's no food at ${cellLiteral} to ask about.`,
+      lane: "game-inform",
+      note: `MUDIII — who-placed declined: no live food item sits at ${cellLiteral}`,
+      miss: true,
+    };
+  }
+
+  const placed = state.placedBy.get(itemId);
+  if (!placed) {
+    return {
+      text: `${itemId} was never placed — it spawned on its own.`,
+      lane: "game-inform",
+      note: `MUDIII — who-placed declined: ${itemId} carries no mgx:placed-by row (spawned food)`,
+      miss: true,
+    };
+  }
+
+  return {
+    text: `${placed.by} put ${itemId} at ${state.placements.get(itemId).cell}.`,
+    lane: "game-inform",
+    note: `MUDIII — who-placed answered from state.placedBy for ${itemId}`,
+  };
+}
+
 /** The addressed teach-frame turn: resolve the addressee and the belief
  *  subject (an agent OR a food item), resolve the told cell, and run ONE tick
  *  with that told-fact fed in. Told-facts are not persisted across turns —
@@ -659,6 +735,11 @@ export async function mudiiiTurn(line, { planHolder, memoryDir, env, cache = nul
     return mudiiiBeliefAnswer(seeMatch, { memoryDir, gameConfig });
   }
 
+  const whoPlacedMatch = trimmed.match(MUDIII_WHO_PLACED_RE);
+  if (whoPlacedMatch) {
+    return mudiiiWhoPlacedAnswer(whoPlacedMatch, { memoryDir });
+  }
+
   if (MUDIII_TICK_RE.test(line)) {
     return runTickAndRender({ planHolder, memoryDir, cache, world: mudiii.world, toldFacts: [], gameConfig });
   }

package/src/services/mudiii-viz.mjs

@@ -82,7 +82,7 @@ const NPC_COUNT_MIN = 1;
 const NPC_COUNT_MAX = 10;
 const NPC_COUNT_LABELLED = [1, 5, 10];
 const DEFAULT_NPC_COUNT = 2;
-const DEFAULT_DELAY_MS = 650;
+const DEFAULT_DELAY_MS = 220;
 const DEFAULT_MAX_TURNS = 400;
 // test/fixtures/mudiii-ticks.json's own board size — the fallback for a
 // scenario that names no gridSize of its own.
@@ -813,6 +813,7 @@ function pageScript() {
   const el = (id) => document.getElementById(id);
   let scenarioIndex = 0;
   const scenario = function () { return DATA.scenarios[scenarioIndex]; };
+  const gridSizeOf = function () { return scenario().gridSize || DATA.gridSize; };
   const rosterOf = function (s, role) {
     return (s.agents || []).filter(function (a) { return !role || a.role === role; }).map(function (a) { return a.id; });
   };
@@ -881,6 +882,9 @@ function pageScript() {
 
   function applyTickResult(result) {
     if (!result) return;
+    // The engine owns the count. Anything that advances a turn — the deck, a
+    // chat frame — lands here, so the page never keeps a rival tally.
+    if (typeof result.turn === "number") globalTurn = result.turn;
     if (result.agents) agentsById = result.agents;
     if (result.items) itemsById = result.items;
     callScene("applyTick", { agents: result.agents, items: result.items, ecology: result.ecology });
@@ -892,8 +896,7 @@ function pageScript() {
   async function runOneTick() {
     return serializeTick(async function () {
       if (!session) return null;
-      globalTurn += 1;
-      const result = await session.tick(globalTurn);
+      const result = await session.tick();
       applyTickResult(result);
       renderAll();
       return result;
@@ -921,8 +924,16 @@ function pageScript() {
   function sendCommand(line) {
     appendChat("u", line);
     if (!session) { appendChat("a", "no session is open yet \\u2014 reset to start one."); return Promise.resolve(); }
-    return serializeTick(function () { return tmct.turn(line); }).then(function (res) {
+    // A chat line can run a real turn. An addressed told-fact does, and the
+    // visitor should watch the lie land, so the board is read back in the same
+    // queue slot. board() spends no turn, so a line that ran none costs
+    // nothing. It reports no goal or plan either, because a resting board has
+    // decided nothing, which is the blank boot() already draws at turn 0.
+    return serializeTick(async function () {
+      const res = await tmct.turn(line);
+      const board = await session.board();
       appendChat("a", res.answer);
+      applyTickResult(board);
       renderAll();
       return res;
     });
@@ -1027,7 +1038,7 @@ function pageScript() {
 
   // ---- the top-down map panel ---------------------------------------------
   function renderMapPanel() {
-    const dots = mapDotsFor(agentsList(), itemsList(), DATA.gridSize);
+    const dots = mapDotsFor(agentsList(), itemsList(), gridSizeOf());
     el("mapPanelBoard").innerHTML = dots.map(function (d) {
       return '<span class="map-dot map-dot-' + esc(d.kind) + '" style="left:' + d.xPct + '%;top:' + d.yPct + '%" title="' + esc(d.id) + '"></span>';
     }).join("");
@@ -1216,7 +1227,7 @@ function pageScript() {
     agentsById = {};
     itemsById = {};
     el("chatInput").disabled = false;
-    callScene("boot", { propPlacements: props, assetManifest: DATA.assetManifest, gridSize: DATA.gridSize, cellSize: 1 });
+    await callScene("boot", { propPlacements: props, assetManifest: DATA.assetManifest, gridSize: gridSizeOf(), cellSize: 1 });
 
     // The opening board, drawn through the very path a tick takes. Without
     // this the page's first sight of where anything stands is the first tick,
@@ -1225,7 +1236,6 @@ function pageScript() {
     // the cells both come back from it rather than being guessed here.
     const opening = await session.board();
     if (seq !== bootSeq) return;
-    globalTurn = opening.turn || 0;
     camera.selectedId = Object.keys(opening.agents || {}).sort()[0] || null;
     applyTickResult(opening);
     renderAll();