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

package/corpus/worlds/manifest.json

@@ -50,17 +50,17 @@
     {
       "file": "src/town-square-chapel.jsonl",
       "bytes": 108408,
-      "sha256": "2c378e51c2f7d53d700e557970b72035aadcbea9496cc959adee09dd77181334"
+      "sha256": "02036d284ec27244494e1f575b750efa71d9a0fc232e57dbd8b5dab7e6a6b7b3"
     },
     {
       "file": "src/town-square-market.jsonl",
       "bytes": 52311,
-      "sha256": "91682ef54cdddd3d3fe0c5877d107f9577bff9d85621bfb4979947f89b029a45"
+      "sha256": "dd374f9cb1c6a13ccfab62badeb4150b8cfefdc349f834430c2c9e105c1d7a4f"
     },
     {
       "file": "src/town-square.jsonl",
       "bytes": 75251,
-      "sha256": "3238dcd53827e4139c0752bebc204257cac4a4663a8263183d387cc98e739779"
+      "sha256": "2fb87416759d8cee1464b55d4e811b91e772d52f65e0f06a88eac1d3a8fc5e7f"
     }
   ],
   "files": [
@@ -106,18 +106,18 @@
     },
     {
       "file": "shards/town-square-chapel.jsonl.gz",
-      "bytes": 5540,
-      "sha256": "f7515fc12de8bf40f5a5c0635032be2d4fe2f5a18d153a1b64fdc2adbcf5745c"
+      "bytes": 5538,
+      "sha256": "826e8732b419b506098f4fbce1adcc07d11bd7d91ea672aa46f13ed3ccebb0bb"
     },
     {
       "file": "shards/town-square-market.jsonl.gz",
-      "bytes": 3116,
-      "sha256": "5791be29b86ad2329978a8bca76dafb9a0ae2419beb0d8d00b83b958adb989d6"
+      "bytes": 3113,
+      "sha256": "c6834f0754498ff800e7be620e3e2268c375686bd753fa9da9b7dd89a63aa009"
     },
     {
       "file": "shards/town-square.jsonl.gz",
-      "bytes": 4277,
-      "sha256": "657e3a8825e579e38b24b64f4df95c17ee95caa10862afc0067acdf1f2db842f"
+      "bytes": 4275,
+      "sha256": "460864ccee3a6eed9dae93f158abaf9780f2b7fb4051f45c3ebc63c7400b01d2"
     }
   ]
 }

package/corpus/worlds/src/town-square-chapel.jsonl

@@ -920,7 +920,7 @@
 {"world":"town-square-chapel","kind":"fact","subject":"goblin","predicate":"mgx:lose","object":"0.06 mass per turn by default"}
 {"world":"town-square-chapel","kind":"fact","subject":"goblin","predicate":"mgx:arrive","object":"every 5 turns at the edge of the board by default"}
 {"world":"town-square-chapel","kind":"fact","subject":"crumb","predicate":"mgx:arrive","object":"every 3 turns on any open cell by default"}
-{"world":"town-square-chapel","kind":"fact","subject":"crumb","predicate":"mgx:start-with","object":"mass 1 by default"}
+{"world":"town-square-chapel","kind":"fact","subject":"crumb","predicate":"mgx:start-with","object":"mass 2 by default"}
 {"world":"town-square-chapel","kind":"fact","subject":"morsel","predicate":"mgx:start-with","object":"mass 2 by default"}
 {"world":"town-square-chapel","kind":"fact","subject":"morsel","predicate":"mgx:arrive","object":"where the player puts it"}
 {"world":"town-square-chapel","kind":"fact","subject":"vision radius","predicate":"mgx:hasProperty","object":"4 cells for the fox by default"}

package/corpus/worlds/src/town-square-market.jsonl

@@ -446,7 +446,7 @@
 {"world":"town-square-market","kind":"fact","subject":"goblin","predicate":"mgx:lose","object":"0.06 mass per turn by default"}
 {"world":"town-square-market","kind":"fact","subject":"goblin","predicate":"mgx:arrive","object":"every 5 turns at the edge of the board by default"}
 {"world":"town-square-market","kind":"fact","subject":"crumb","predicate":"mgx:arrive","object":"every 3 turns on any open cell by default"}
-{"world":"town-square-market","kind":"fact","subject":"crumb","predicate":"mgx:start-with","object":"mass 1 by default"}
+{"world":"town-square-market","kind":"fact","subject":"crumb","predicate":"mgx:start-with","object":"mass 2 by default"}
 {"world":"town-square-market","kind":"fact","subject":"morsel","predicate":"mgx:start-with","object":"mass 2 by default"}
 {"world":"town-square-market","kind":"fact","subject":"morsel","predicate":"mgx:arrive","object":"where the player puts it"}
 {"world":"town-square-market","kind":"fact","subject":"vision radius","predicate":"mgx:hasProperty","object":"4 cells for the fox by default"}

package/corpus/worlds/src/town-square.jsonl

@@ -678,7 +678,7 @@
 {"world":"town-square","kind":"fact","subject":"goblin","predicate":"mgx:lose","object":"0.06 mass per turn by default"}
 {"world":"town-square","kind":"fact","subject":"goblin","predicate":"mgx:arrive","object":"every 5 turns at the edge of the board by default"}
 {"world":"town-square","kind":"fact","subject":"crumb","predicate":"mgx:arrive","object":"every 3 turns on any open cell by default"}
-{"world":"town-square","kind":"fact","subject":"crumb","predicate":"mgx:start-with","object":"mass 1 by default"}
+{"world":"town-square","kind":"fact","subject":"crumb","predicate":"mgx:start-with","object":"mass 2 by default"}
 {"world":"town-square","kind":"fact","subject":"morsel","predicate":"mgx:start-with","object":"mass 2 by default"}
 {"world":"town-square","kind":"fact","subject":"morsel","predicate":"mgx:arrive","object":"where the player puts it"}
 {"world":"town-square","kind":"fact","subject":"vision radius","predicate":"mgx:hasProperty","object":"4 cells for the fox by default"}

package/data/mudiii-assets.json

@@ -21,7 +21,7 @@
       "destPath": "public/models/creatures/fox.glb",
       "licence": "CC0-1.0",
       "author": "Quaternius",
-      "source": "https://poly.pizza/u/Quaternius · https://quaternius.com",
+      "source": "https://poly.pizza/u/Quaternius \u00b7 https://quaternius.com",
       "bytes": 332748,
       "sha256": "2694028b47e84bad3b9d985aa7743dae02a3bcfddd6becd73b46c747a1e067b3",
       "targetHeight": 1.0,
@@ -30,7 +30,10 @@
         "walk": "Walk",
         "run": "Gallop",
         "attack": "Attack",
-        "hit": ["Idle_HitReact_Left", "Idle_HitReact_Right"],
+        "hit": [
+          "Idle_HitReact_Left",
+          "Idle_HitReact_Right"
+        ],
         "death": "Death",
         "eat": "Eating"
       }
@@ -41,7 +44,7 @@
       "destPath": "public/models/creatures/goblin.glb",
       "licence": "CC0-1.0",
       "author": "Quaternius",
-      "source": "https://poly.pizza/u/Quaternius · https://quaternius.com",
+      "source": "https://poly.pizza/u/Quaternius \u00b7 https://quaternius.com",
       "bytes": 47924,
       "sha256": "2f02ce927a8871554f3931655d75f1abb8237d36be8a19a35b09920d0812bc3c",
       "targetHeight": 2.1,
@@ -50,7 +53,9 @@
         "walk": "Walk",
         "run": "Run",
         "attack": "Attack",
-        "hit": ["HitRecieve"],
+        "hit": [
+          "HitRecieve"
+        ],
         "death": "Death"
       }
     },
@@ -207,7 +212,7 @@
       "source": "https://github.com/KayKit-Game-Assets/KayKit-Dungeon-Remastered-1.0",
       "bytes": 14004,
       "sha256": "8b340af18ea1325d5a9bd4a967d3ef37bb90838ca2d90927b123e23877f7ddad",
-      "targetHeight": 0.16,
+      "targetHeight": 0.6,
       "clips": null
     },
     {
@@ -219,7 +224,7 @@
       "source": "https://github.com/KayKit-Game-Assets/KayKit-Dungeon-Remastered-1.0",
       "bytes": 14004,
       "sha256": "8b340af18ea1325d5a9bd4a967d3ef37bb90838ca2d90927b123e23877f7ddad",
-      "targetHeight": 0.36,
+      "targetHeight": 0.6,
       "clips": null
     }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "5.0.3",
+  "version": "5.0.4",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; indexes a repo on request (tmct index) or reads any producer's graph.",

package/src/domain/game-config.mjs

@@ -78,7 +78,9 @@ export const DEFAULT_GAME_CONFIG = Object.freeze({
     preyVisionRadius: 3,
     preySpawnIntervalTurns: 5,
     foodSpawnIntervalTurns: 3,
-    spawnedFoodMass: 1,
+    // Spawned and placed food are one thing: the same hay bale, worth the
+    // same. The two knobs stay separate so a world can still tell them apart.
+    spawnedFoodMass: 2,
     placedFoodMass: 2,
     maxPreyPopulation: 6,
     maxFoodItems: 8,

package/src/domain/spider-fly-world.mjs

@@ -57,9 +57,9 @@ export const chebyshevDistance = (ax, ay, bx, by) => Math.max(Math.abs(ax - bx),
 export const inBounds = (x, y) => x >= 1 && x <= GRID_SIZE && y >= 1 && y <= GRID_SIZE;
 
 /** Every cell within Chebyshev `radius` of (cx, cy), clipped to the board, in
- *  raster order — the one visibility primitive PLAN_SPIDER_FLY.md §4 names
- *  ("visibleCells(cx, cy, radius=4)"), shared by both agents' belief and this
- *  module's own web-block derivation below. */
+ *  raster order — the one visibility primitive ("visibleCells(cx, cy, radius=4)")
+ *  shared by both agents' belief and this module's own web-block derivation
+ *  below. */
 export function visibleCells(cx, cy, radius) {
   const out = [];
   for (let y = Math.max(1, cy - radius); y <= Math.min(GRID_SIZE, cy + radius); y += 1) {
@@ -72,8 +72,7 @@ export function visibleCells(cx, cy, radius) {
 
 export const isInWebBlock = (x, y) => chebyshevDistance(x, y, WEB_HOME.x, WEB_HOME.y) <= WEB_RADIUS;
 
-/** Every board-edge (perimeter) cell, raster order — where a spawned fly
- *  arrives (PLAN_SPIDER_FLY.md §10). */
+/** Every board-edge (perimeter) cell, raster order. */
 export function perimeterCells() {
   const out = [];
   for (let y = 1; y <= GRID_SIZE; y += 1) {
@@ -110,11 +109,10 @@ export function oneStepDirectionBetween(fromCell, toCell) {
   return null;
 }
 
-/** The world's seed taxonomy (PLAN_SPIDER_FLY.md §7): enough for the
- *  ontology-to-sprite worked example (a poodle sprite, a sheepdog falling
- *  back to the generic dog sprite) to run on the default persona, no
- *  --persona-size large flag required. [subject, superclass] pairs, written
- *  as rdfs:subClassOf facts. */
+/** The world's seed taxonomy — enough for the ontology-to-sprite worked example
+ *  (a poodle sprite, a sheepdog falling back to the generic dog sprite) to run
+ *  on the default persona without the --persona-size large flag. [subject,
+ *  superclass] pairs, written as rdfs:subClassOf facts. */
 export const SEED_TAXONOMY = Object.freeze([
   Object.freeze(["poodle", "dog"]),
   Object.freeze(["sheepdog", "dog"]),
@@ -293,9 +291,9 @@ export function isLiveRenderableAgent(id, state) {
 /** A minimal, inert rule-row family, so scripts/build-worlds-pack.mjs's
  *  shared validator ("every world needs at least one rule row") passes.
  *  src/services/spider-fly-turn.mjs never reads these back: grid movement is
- *  hand-written pathfinding over findActionPath/findReachableSet
- *  (PLAN_SPIDER_FLY.md §5), not the taught action-Rule DSL, so this rides in
- *  the shard unused, same as an unrelated fact would. */
+ *  hand-written pathfinding over findActionPath/findReachableSet, not the
+ *  taught action-Rule DSL, so this rides in the shard unused, same as an
+ *  unrelated fact would. */
 export function* worldRuleRows() {
   yield {
     world: WORLD_NAME, kind: "rule", name: "go", ruleKind: "action-signature",

package/src/services/mudiii-scene.mjs

@@ -186,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":
@@ -359,6 +361,11 @@ 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;
@@ -385,9 +392,6 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
       });
     });
   }
-  var glbCache = null;
-  function loadGlb(url) { return glbCache.load(url); }
-
   async function ensureThree() {
     if (THREE) return true;
     var result = await loadThreeVendor();
@@ -396,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;
   }
@@ -513,13 +516,23 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     object3D.userData.tmctNormalized = true;
   }
 
-  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;
+  // 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) {
@@ -544,13 +557,11 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
     }
   }
 
-  // ---- items: crumbs and morsels, primitive geometry ------------------------
-  // Doubled from 0.08/0.18: against the fox's own 1m targetHeight and a 1-unit
-  // cell, the old radii read as barely-visible dots on the board.
-  var CRUMB_RADIUS = 0.16, MORSEL_RADIUS = 0.36;
-  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;
@@ -566,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 recordRemoval(kind, id, source) {
+    removalLog.push({ kind: kind, id: id, source: source });
   }
 
-  function removeItem(id, withFlourish) {
+  // 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);
   }
@@ -603,7 +640,7 @@ 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);
@@ -628,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;
@@ -637,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);
@@ -667,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) {
@@ -683,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));
+        }
+      }
     }
   }
 
@@ -741,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 });
@@ -754,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);
@@ -812,6 +895,15 @@ export function mudiiiSceneScript({ canvasId, statusId, gridSize, cellSize } = {
       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 });
   }