@polycode-projects/the-mechanical-code-talker 3.2.0 → 4.0.0

package/src/services/adventure.mjs

@@ -10,6 +10,7 @@
 
 import { worldProvenanceTag } from "../domain/worlds-pack.mjs";
 import { parseImperative, OBJECT_PRONOUNS } from "../domain/grammar/ace.mjs";
+import { loadLexicon, withProperNames, classify } from "../domain/grammar/lexicon.mjs";
 import { register as registerReferent, bind as bindDiscourseForm } from "../domain/discourse.mjs";
 import { createCompletionsGraphAdapter } from "../domain/completions/graph-adapter.mjs";
 import { actionFamilies } from "../domain/router/taught.mjs";
@@ -183,7 +184,34 @@ const PLACEMENT_PREDICATES = new Set([
 // which surface a thing rests against.
 const POSITION_PREDICATES = new Set(["mgx:on-top-of", "mgx:on-plane", "mgx:under"]);
 const OPEN_PREDICATE = "mgx:is-open";
+const MASS_PREDICATE = "mgx:hasMass";
+const KNOWS_ABOUT_PREDICATE = "mgx:knows-about";
+// What a thing is called on screen, when that differs from its id. A dug
+// object needs a distinct id per instance and a plain name to read by, and
+// this predicate is the only place the two are allowed to differ.
+const DISPLAY_NAME_PREDICATE = "mgx:display-name";
 const EXIT_PREDICATE_RE = /^mgx:has-exit-([a-z]+)$/;
+// The dig mechanic's own wiring: which room a world measures distance from, the
+// kinds a dug room turns up, the richer set a den holds, and who lives in one.
+// All four are the world's answers to the dig verb's questions, never scenery.
+const ORIGIN_PREDICATE = "mgx:is-origin";
+const DIG_SPAWN_PREDICATE = "mgx:dig-spawns";
+const DEN_SPAWN_PREDICATE = "mgx:den-spawns";
+const DEN_RESIDENT_PREDICATE = "mgx:den-resident";
+const DIG_REACH_PREDICATE = "mgx:dig-reach";
+const DIG_SPAWN_MAX_PREDICATE = "mgx:dig-spawn-max";
+const DEN_CHANCE_PREDICATE = "mgx:den-chance-in";
+const DEN_RESIDENT_CHANCE_PREDICATE = "mgx:den-resident-chance-in";
+const MASS_DRAIN_PREDICATE = "mgx:mass-drain-per-turn";
+// Where a thing that has left the world is placed. The world has no other way
+// to say "out of play", and no room can be called either of these, so the
+// sentinel is the whole convention: the readers below skip it exactly as they
+// skip a hiding place. Which sentinel a character sits at IS the reason it is
+// out — eaten by a predator, or starved once its mass ran out — so a caller
+// can say which without a second fact to read.
+const CONSUMED_PLACE = "eaten";
+const STARVED_PLACE = "starved";
+const OUT_OF_PLAY_PLACES = new Set([CONSUMED_PLACE, STARVED_PLACE]);
 
 /** The rows a live world's STATE fold may see: those the world itself wrote
  *  (provenance empty, or `world:*` — the loaded shard and its @turn
@@ -199,14 +227,29 @@ export function worldActionRows(rows) {
   });
 }
 
+/** Every individual the world names — its rooms, its cast, its props, and
+ *  anything dug up since — as the plain id strings a parser has to have
+ *  DECLARED before it can resolve them. @turnN snapshots are skipped: a
+ *  snapshot only ever repeats a subject its base row already named. Pure. */
+export function worldIndividualNames(rows) {
+  const names = new Set();
+  for (const row of rows || []) {
+    if (SNAPSHOT_RE.test(row.subject)) continue;
+    if (row.predicate === "rdf:type" || PLACEMENT_PREDICATES.has(row.predicate)) names.add(row.subject);
+    if (EXIT_PREDICATE_RE.test(row.predicate)) { names.add(row.subject); names.add(row.object); }
+  }
+  return [...names].sort();
+}
+
 /** Fold fact rows into the CURRENT world state: per subject, the newest
  *  placement (base row = turn 0, @turnN snapshots override), the newest
- *  open/closed state, the exit map, and the turn counter (the largest @turnN
- *  suffix written so far — derived, never stored). Pure. */
+ *  open/closed state, the newest mass, the exit map, and the turn counter (the
+ *  largest @turnN suffix written so far — derived, never stored). Pure. */
 export function foldWorldState(factRows) {
   const placements = new Map(); // subject -> { predicate, object, turn }
   const positions = new Map();  // subject -> { predicate, object, turn }
   const openness = new Map();   // subject -> { open, turn }
+  const masses = new Map();     // subject -> { value, turn }
   const exits = new Map();      // room -> Map(direction -> room)
   let turnCount = 0;
   for (const row of factRows || []) {
@@ -229,13 +272,20 @@ export function foldWorldState(factRows) {
       if (!prior || turn >= prior.turn) openness.set(base, { open: row.object === "true", turn });
       continue;
     }
+    if (row.predicate === MASS_PREDICATE) {
+      const value = Number(row.object);
+      if (!Number.isFinite(value)) continue; // masses hold numbers; an unparsable one is no mass at all
+      const prior = masses.get(base);
+      if (!prior || turn >= prior.turn) masses.set(base, { value, turn });
+      continue;
+    }
     const exit = EXIT_PREDICATE_RE.exec(row.predicate);
     if (exit && !m) {
       if (!exits.has(row.subject)) exits.set(row.subject, new Map());
       exits.get(row.subject).set(exit[1], row.object);
     }
   }
-  return { placements, positions, openness, exits, turnCount };
+  return { placements, positions, openness, masses, exits, turnCount };
 }
 
 /** A subject's CURRENT within-room position, or null. A position goes stale
@@ -305,15 +355,17 @@ function visibleRoomOf(thing, { rows, state }) {
   if (!place || place.predicate === "mgx:hidden-in") return null;
   if (place.predicate === "mgx:currently-in" || isTyped(rows, place.object, "room")) return place.object;
   const holder = place.object;
-  if (holder === "player") return null; // carried, not on show in a room
+  // A non-container holder is a character carrying the thing, whoever they
+  // are — carried, so not on show in the room they stand in.
+  if (!isContainer(rows, holder)) return null;
   if (!state.openness.get(holder)?.open) return null;
   const holderPlace = state.placements.get(holder);
   return holderPlace && holderPlace.predicate !== "mgx:hidden-in" ? holderPlace.object : null;
 }
 
-const carriedByPlayer = (state, thing) => {
+const carriedBy = (state, thing, holder) => {
   const place = state.placements.get(thing);
-  return !!place && place.predicate === "mgx:located-in" && place.object === "player";
+  return !!place && place.predicate === "mgx:located-in" && place.object === holder;
 };
 
 /** True when `object` is never a real placed game entity (no entry in
@@ -330,6 +382,59 @@ function backgroundOnlyMention(rows, state, object) {
   return (rows || []).some((r) => r.subject === object || r.object === object);
 }
 
+/** True when `subject` is one of the world's cast rather than a prop: a
+ *  declared person, or anything the world places with mgx:currently-in — the
+ *  predicate every world reserves for a character standing in a room, props
+ *  riding located-in/fixed-in/stands-locked-in instead. Both halves matter:
+ *  ashcombe-hall types its staff `person`, while mud-garden types its animals
+ *  `adventurer` and places them the same way, so a person-only test leaves a
+ *  whole cast with nobody able to speak to it. */
+function isCastMember(rows, state, subject) {
+  return isTyped(rows, subject, "person") || state.placements.get(subject)?.predicate === "mgx:currently-in";
+}
+
+/** Who else is standing in `room` right now, sorted — the same currently-in
+ *  placement the talk verb and the room affordances read, exposed so a caller
+ *  rendering a room can name its cast without re-deriving the test. Pure. */
+export function castInRoom(rows, state, room, exclude = null) {
+  return [...state.placements.keys()]
+    .filter((subject) => subject !== exclude && subject !== room)
+    .filter((subject) => state.placements.get(subject).object === room)
+    .filter((subject) => isCastMember(rows, state, subject))
+    .sort();
+}
+
+// A predator eats whatever walks into its room. The marker is a world fact,
+// so which individual is dangerous is the world's business, never this
+// module's.
+const PREDATOR_PREDICATE = "mgx:is-predator";
+
+/** The predator standing in `room`, or null — read from the same placements
+ *  fold every other presence check uses. Pure. */
+function predatorIn(rows, state, room) {
+  return castInRoom(rows, state, room)
+    .find((subject) => factObjects(rows, subject, PREDATOR_PREDICATE).includes("true")) ?? null;
+}
+
+/** True when `subject` has left the world: placed at an out-of-play sentinel
+ *  no room can be called. Its part in the world is finished — every command it
+ *  gives declines, and its scripted turns stop. Pure. */
+export const isOutOfPlay = (state, subject) => OUT_OF_PLAY_PLACES.has(state.placements.get(subject)?.object);
+
+/** WHY `subject` is out of play — "eaten" or "starved" — or null while it is
+ *  still playing. The two fates end a run the same way and read nothing alike,
+ *  so anything narrating one needs to tell them apart. Pure. */
+export const outOfPlayReasonOf = (state, subject) => {
+  const place = state.placements.get(subject)?.object;
+  return OUT_OF_PLAY_PLACES.has(place) ? place : null;
+};
+
+/** How a fate reads in a sentence: "the mole-1 has been eaten", "the mole-1 has
+ *  starved". One phrase per sentinel, so nothing anywhere else has to spell the
+ *  difference out. Pure. */
+export const outOfPlayPhrase = (subject, reason) =>
+  (reason === STARVED_PLACE ? `the ${subject} has starved` : `the ${subject} has been eaten`);
+
 /** The room's real affordances — every exit, and every visible object's
  *  applicable verb — read from the EXACT SAME data take/open/talk/examine
  *  already check (visibleRoomOf, isContainer, isTyped, the placement
@@ -337,13 +442,13 @@ function backgroundOnlyMention(rows, state, object) {
  *  would then refuse. A locked container offers "unlock", never "open" (that
  *  would only decline); an already-open one offers neither, since there is
  *  nothing left for either verb to do. Pure. */
-export function roomAffordances(rows, state, here) {
+export function roomAffordances(rows, state, here, actingSubject = "player") {
   const actions = [];
   for (const direction of state.exits.get(here)?.keys() ?? []) {
     actions.push(`go ${direction}`);
   }
   for (const subject of [...state.placements.keys()].sort()) {
-    if (subject === "player") continue;
+    if (subject === actingSubject) continue;
     if (visibleRoomOf(subject, { rows, state }) !== here) continue;
     const place = state.placements.get(subject);
     const container = isContainer(rows, subject);
@@ -359,7 +464,7 @@ export function roomAffordances(rows, state, here) {
       actions.push(`examine ${subject}`);
       continue;
     }
-    if (isTyped(rows, subject, "person")) {
+    if (isCastMember(rows, state, subject)) {
       actions.push(`talk to ${subject}`);
       continue;
     }
@@ -433,6 +538,151 @@ async function writeWorldTurn(memoryDir, world, k, facts, cache) {
   if (cache) cache.rows = null;
 }
 
+// ---- what a character knows, and who it heard it from -----------------------
+//
+// A character telling another character about something, or looking at
+// something itself, leaves a REAL fact behind: an mgx:knows-about edge the
+// hearer carries from that turn on, readable by personKnowledgeLines exactly
+// like a world-authored one. Nothing here is per-tick or in-memory — one
+// animal can walk off, come back ten turns later, and still know what it was
+// told.
+//
+// These deliberately bypass writeWorldTurn. That tags everything
+// `world:<name>:turnN`, which credits the WORLD for the claim; a character's
+// testimony belongs to the character, so it carries its own
+// `mud:<character>:turnN` tag and lands on that character's own Source and
+// trust track record. The side effect is that worldActionRows filters these
+// out of the playable state fold, which is what you want — being told about a
+// stone must never move the stone.
+//
+// A claim can also go out of date, and none of them is ever retracted. Eating
+// the last carrot appends a SECOND claim to the same edge, tagged `:gone`, and
+// appendFacts unions the two tags onto the one fact exactly as it unions any
+// repeat assertion. "The carrot was here on turn 2" and "the carrot is gone on
+// turn 5" are both true; the reader's job is to say which one rules, the same
+// recency question the p2p layer asks of its own tags. So reading knowledge
+// back means reading the newest claim per edge, never the union of every claim
+// ever made.
+
+const VOIDED_TESTIMONY_SUFFIX = ":gone";
+
+const characterTestimonyTag = (character, k, voided = false) =>
+  `mud:${character}:turn${k}${voided ? VOIDED_TESTIMONY_SUFFIX : ""}`;
+
+async function appendTestimony(memoryDir, { knower, source, thing, k, voided = false, cache }) {
+  await appendFacts(memoryDir, [{
+    subject: knower, predicate: KNOWS_ABOUT_PREDICATE, object: thing,
+    provenance: characterTestimonyTag(source, k, voided),
+  }]);
+  if (cache) cache.rows = null;
+}
+
+/** Record that `teller` told `asker` about `thing` on turn `k`. The asker is
+ *  the subject — it is the one who now knows — and the teller is named in the
+ *  provenance, so the claim corroborates the teller's Source, not the asker's. */
+export async function recordTold(memoryDir, { asker, teller, thing, k, cache = null }) {
+  return appendTestimony(memoryDir, { knower: asker, source: teller, thing, k, cache });
+}
+
+/** Record that `observer` examined `thing` on turn `k`. The observer is both
+ *  the subject and the provenance's character: it learned this by looking, so
+ *  it is its own source for it. */
+export async function recordExamined(memoryDir, { observer, thing, k, cache = null }) {
+  return appendTestimony(memoryDir, { knower: observer, source: observer, thing, k, cache });
+}
+
+/** Record that `observer` saw `thing` leave the world on turn `k` — it ate the
+ *  last of it. Written as a fresh claim on the SAME edge an older one already
+ *  sits on, so the older claim stands untouched and stops being the one that
+ *  rules. The observer is its own source, the way examining is. */
+export async function recordGone(memoryDir, { observer, thing, k, cache = null }) {
+  return appendTestimony(memoryDir, { knower: observer, source: observer, thing, k, voided: true, cache });
+}
+
+const TESTIMONY_TAG_RE = /^mud:([^:\s]+):turn(\d+)(:gone)?$/;
+const TURN_STAMP_RE = /:turn(\d+)\b/;
+
+/** How one provenance segment on a knows-about edge stands as a claim about
+ *  what `knower` knows: whether the knower vouches for it itself, the turn it
+ *  was asserted on, and whether it says the thing is gone. A tag that is no
+ *  character's testimony — a world's own seed fact, a dig spawn — reads as
+ *  hearsay stamped with whatever turn it carries. */
+function testimonyClaim(segment, knower) {
+  const mine = TESTIMONY_TAG_RE.exec(segment);
+  const stamp = Number(mine ? mine[2] : (TURN_STAMP_RE.exec(segment)?.[1] ?? 0));
+  return {
+    firsthand: !!mine && mine[1] === knower,
+    turn: Number.isFinite(stamp) ? stamp : 0,
+    voided: !!(mine && mine[3]),
+  };
+}
+
+/** Firsthand beats hearsay outright, then the later turn wins, then "gone"
+ *  takes the tie — an animal that examined a carrot and ate it on one turn ate
+ *  it second. Tier ABOVE recency is what stops an animal being talked back into
+ *  a meal it ate itself: a room-mate can tell it about that carrot the turn
+ *  after, and its own eyes still hold. */
+const outranksClaim = (claim, best) => (
+  claim.firsthand !== best.firsthand ? claim.firsthand
+    : claim.turn !== best.turn ? claim.turn > best.turn
+      : claim.voided && !best.voided
+);
+
+/** The claim that rules on one knows-about edge, across every segment its
+ *  provenance carries. */
+function rulingTestimonyClaim(provenance, knower) {
+  let best = null;
+  for (const segment of String(provenance || "").split(" | ")) {
+    const tag = segment.trim();
+    if (!tag) continue;
+    const claim = testimonyClaim(tag, knower);
+    if (!best || outranksClaim(claim, best)) best = claim;
+  }
+  return best;
+}
+
+/** What `person` knows about NOW: the object of every knows-about edge whose
+ *  ruling claim still stands, in the order the edges were first written.
+ *  Nothing is deleted — an edge whose newest claim says the thing is gone just
+ *  stops reading back. */
+function currentKnowsAboutTopics(rows, person) {
+  const topics = [];
+  for (const row of rows || []) {
+    if (row.subject !== person || row.predicate !== KNOWS_ABOUT_PREDICATE) continue;
+    if (rulingTestimonyClaim(row.provenance, person)?.voided) continue;
+    topics.push(row.object);
+  }
+  return topics;
+}
+
+/**
+ * Charge `subject` the mass a turn costs it, and place it out of play at the
+ * starved sentinel once nothing is left. Returns `{ mass, starved }` — the mass
+ * it is left with, and whether that ended its run. Writes nothing and charges
+ * nothing when the drain is zero, when the subject is already out of play, or
+ * when the world gives it no mass at all (`mass` is then null: a thing with no
+ * mass cannot run out of it).
+ *
+ * The write lands on the world's OWN next turn, read fresh here rather than
+ * taken from the caller. A scripted turn runs several world commands, each
+ * stamping a turn of its own, so a caller's tick number can trail the world's
+ * count — and a mass snapshot stamped behind the newest placement would fold
+ * away as stale the moment it was written.
+ */
+export async function recordMassDrain(memoryDir, { world, subject, drainPerTurn, cache = null }) {
+  const rows = readFactRows(await loadMemory(memoryDir));
+  const state = foldWorldState(worldActionRows(rows));
+  const mass = state.masses.get(subject)?.value ?? null;
+  if (mass === null || !(drainPerTurn > 0) || isOutOfPlay(state, subject)) return { mass, starved: false };
+  const left = Math.max(0, Math.round((mass - drainPerTurn) * 100) / 100);
+  const k = state.turnCount + 1;
+  await writeWorldTurn(memoryDir, world, k, [
+    { subject: `${subject}@turn${k}`, predicate: MASS_PREDICATE, object: String(left) },
+    ...(left > 0 ? [] : [{ subject: `${subject}@turn${k}`, predicate: "mgx:currently-in", object: STARVED_PLACE }]),
+  ], cache);
+  return { mass: left, starved: left <= 0 };
+}
+
 // ---- the look/inventory digest ----------------------------------------------
 //
 // "look" and "what am I carrying" are generateCompletion calls (the shipped
@@ -448,6 +698,9 @@ async function writeWorldTurn(memoryDir, world, k, facts, cache) {
 
 const VIEW_EXCLUDED_PREDICATES = new Set([
   "mgx:hidden-in", "mgx:is-open", "mgx:is-npc", "mgx:is-container",
+  // A bare number reads as an untranslated triple in room prose ("Mole-1
+  // mgx:hasMass 8"). Mass reaches a player through the verbs that change it.
+  MASS_PREDICATE,
   "mgx:unlocks-with", "mgx:acts-on-turn", "mgx:acts-toward",
   // is-objective is an internal marker for auto-play's goal inference — the
   // same information the opening narration already tells a human player in
@@ -457,12 +710,27 @@ const VIEW_EXCLUDED_PREDICATES = new Set([
   // Staff knowledge is the whole puzzle: a room look must never leak
   // "Gardener knows-where letter" or the game is spoiled. It reaches the
   // player only through the talk lane, which resolves each pointer live.
-  "mgx:knows-where", "mgx:knows-objective", "mgx:knows-about",
+  "mgx:knows-where", "mgx:knows-objective", KNOWS_ABOUT_PREDICATE,
   // Class-schema facts describe the ontology, not the scene. default-contains
   // is already materialized into real instances at load; default-plane and
   // subClassOf drive positional rendering by their own readers, and read as
   // raw triples if they land in room prose.
   "mgx:default-contains", "mgx:default-plane", "rdfs:subClassOf",
+  // A screen name is presentation, not scenery — it reads as a raw triple in
+  // room prose ("Carrot-1 mgx:display-name carrot") and says nothing the
+  // room's own sentences don't already say.
+  DISPLAY_NAME_PREDICATE,
+  // Which individual is dangerous is the predator mechanic's own wiring; a
+  // room look that announced it would give the trap away as a bare triple.
+  "mgx:is-predator",
+  // The dig mechanic's wiring is the same kind of thing: it tells the verb what
+  // a dug room may hold and how far the world reaches, and says nothing about
+  // the room anyone is standing in.
+  ORIGIN_PREDICATE, DIG_SPAWN_PREDICATE, DEN_SPAWN_PREDICATE, DEN_RESIDENT_PREDICATE,
+  DIG_REACH_PREDICATE, DIG_SPAWN_MAX_PREDICATE, DEN_CHANCE_PREDICATE, DEN_RESIDENT_CHANCE_PREDICATE,
+  // How fast a turn wears a species down is the mass economy's own wiring, and
+  // reads as a bare number in room prose the same way hasMass does.
+  MASS_DRAIN_PREDICATE,
 ]);
 
 const sentenceCase = (term) => String(term).charAt(0).toUpperCase() + String(term).slice(1);
@@ -497,7 +765,7 @@ function isNonWorldSourced(row) {
  *  subjects so the pipeline's sentence splitter sees real sentences. Room text
  *  is world-sourced only — a merged corpus's overlap on a room's own vocabulary
  *  never leaks into the description. Pure. */
-export function worldDigestRows(rows, state) {
+export function worldDigestRows(rows, state, actingSubject = "player") {
   const out = [];
   const seen = new Set();
   const push = (subject, phrase, object) => {
@@ -506,13 +774,19 @@ export function worldDigestRows(rows, state) {
     seen.add(key);
     out.push({ subject: sentenceCase(subject), predicate: phrase, object });
   };
+  // Whoever holds a located-in thing is carrying it rather than housing it,
+  // and the cast are exactly the individuals the world places with
+  // currently-in — props ride located-in/fixed-in/stands-locked-in, rooms are
+  // never placed at all.
+  const isCarryingCharacter = (holder) =>
+    isTyped(rows, holder, "person") || state.placements.get(holder)?.predicate === "mgx:currently-in";
   for (const [subject, place] of state.placements) {
-    if (place.predicate === "mgx:hidden-in") continue;
-    if (place.predicate === "mgx:located-in" && place.object === "player") {
-      push("player", "carries the", subject);
+    if (place.predicate === "mgx:hidden-in" || OUT_OF_PLAY_PLACES.has(place.object)) continue;
+    if (place.predicate === "mgx:located-in" && place.object === actingSubject) {
+      push(actingSubject, "carries the", subject);
       continue;
     }
-    if (place.predicate === "mgx:located-in" && isTyped(rows, place.object, "person")) {
+    if (place.predicate === "mgx:located-in" && isCarryingCharacter(place.object)) {
       push(place.object, "carries the", subject);
       continue;
     }
@@ -530,14 +804,18 @@ export function worldDigestRows(rows, state) {
   // already assumes, so it is left unsaid.
   const POSITION_PHRASE = { "mgx:on-top-of": "is on the", "mgx:on-plane": "is on the", "mgx:under": "is under the" };
   for (const [subject, place] of state.placements) {
-    if (place.predicate === "mgx:hidden-in" || place.object === "player") continue;
+    if (place.predicate === "mgx:hidden-in" || place.object === actingSubject || OUT_OF_PLAY_PLACES.has(place.object)) continue;
     const pos = currentPosition(state, subject);
     if (pos && POSITION_PHRASE[pos.predicate]) { push(subject, POSITION_PHRASE[pos.predicate], pos.object); continue; }
     const plane = classDefaultPlane(rows, subject);
     if (plane && plane !== "floor") push(subject, "is usually on the", plane);
   }
+  const gone = new Set([...state.placements]
+    .filter(([, place]) => OUT_OF_PLAY_PLACES.has(place.object))
+    .map(([subject]) => subject));
   for (const row of rows || []) {
     if (SNAPSHOT_RE.test(row.subject)) continue;                 // folded above
+    if (gone.has(row.subject)) continue;                         // out of the world entirely
     // Room text comes from the world source only. A merged corpus overlaps a
     // room's own vocabulary ("library rdfs:subClassOf literary study"), and
     // without this those rows leak into the room description as stray sentences.
@@ -564,9 +842,9 @@ export function worldDigestRows(rows, state) {
  *  the class hierarchy renders that as its own is-a chain instead. A carried
  *  object surfaces through the "carries the" line the digest already produces.
  *  Pure. */
-export function objectLookProperties(rows, state, object) {
+export function objectLookProperties(rows, state, object, actingSubject = "player") {
   const subjectCased = sentenceCase(object);
-  return worldDigestRows(rows, state)
+  return worldDigestRows(rows, state, actingSubject)
     .filter((r) => (r.subject === subjectCased && r.predicate !== "is a" && r.predicate !== "is an")
       || (r.predicate === "carries the" && r.object === object))
     .map((r) => `${r.subject} ${r.predicate} ${r.object}.`);
@@ -595,8 +873,8 @@ export function objectClassChain(rows, object) {
   return chain;
 }
 
-async function worldDigest(prompt, { memoryDir, memory, rows, state, graph }) {
-  const view = worldDigestRows(rows, state);
+async function worldDigest(prompt, { memoryDir, memory, rows, state, graph, actingSubject = "player" }) {
+  const view = worldDigestRows(rows, state, actingSubject);
   const store = {
     ...COMPLETIONS_STORE,
     readFactRows: () => view,
@@ -626,6 +904,248 @@ const answer = (text, note, { goal, miss = false } = {}) => ({
   text, note, lane: "game-answer", miss, ...(goal ? { goal } : {}),
 });
 
+// A dug room needs the way back written too, and the exit vocabulary is only
+// ever a direction word in a predicate name, so the pairing lives here.
+const OPPOSITE_DIRECTION = new Map([
+  ["north", "south"], ["south", "north"],
+  ["east", "west"], ["west", "east"],
+  ["up", "down"], ["down", "up"],
+]);
+
+// What a freshly dug room holds, and how often a dig opens something better
+// than a bare tunnel. The world names all of it — a room kind declares the
+// kinds a plain dig turns up, how many of them, the richer set a den holds, how
+// often a dig finds one, and which animal lives in it. The numbers below are
+// only the fallback for a world that declares none.
+const DIG_SPAWN_KINDS = ["root", "carrot", "worm"];
+const DIG_SPAWN_MIN = 0;
+const DEFAULT_DIG_SPAWN_MAX = 2;
+const DEFAULT_DEN_CHANCE_IN = 5;
+const DEFAULT_DEN_RESIDENT_CHANCE_IN = 3;
+const DEN_ROOM_CLASS = "den";
+
+// How far from the world's origin room a dig may carry it, when the origin
+// writes no reach of its own. Without a cap a burrow sprawls in every direction
+// at once, and an animal twenty hops out has nothing around it, no food it
+// knows of, and no reason to be anywhere — the stranding this bound exists to
+// stop. Six keeps every room inside one pathfinder search of the origin
+// (mud-turn.mjs walks eight hops), so an animal standing at the frontier can
+// always still walk home to the rooms with food in them.
+const DEFAULT_DIG_REACH = 6;
+
+/** The NEWEST value `subject` declares under `predicate`, as a number, or null
+ *  when it declares none. Newest rather than first on purpose: the store is
+ *  append-only, so a later write is the current truth — the same rule
+ *  foldWorldState already applies to placements, and what lets an edit to one of
+ *  these knobs take effect over the world's own seed fact. Pure. */
+function declaredNumber(rows, subject, predicate) {
+  const written = factObjects(rows, subject, predicate);
+  if (!written.length) return null;
+  const value = Number(written[written.length - 1]);
+  return Number.isFinite(value) ? value : null;
+}
+
+/** A positive count `subject` declares under `predicate`, or `fallback` when it
+ *  declares none (or writes something that is not a usable count). Pure. */
+function declaredCountOr(rows, subject, predicate, fallback) {
+  const written = declaredNumber(rows, subject, predicate);
+  return written !== null && written > 0 ? written : fallback;
+}
+
+/** How many rooms out from its origin this world lets a dig reach — the origin
+ *  room's own `mgx:dig-reach` fact, or the shipped default when it writes none.
+ *  Pure. */
+export function digReachOf(rows) {
+  const origin = originRoomOf(rows);
+  return origin ? declaredCountOr(rows, origin, DIG_REACH_PREDICATE, DEFAULT_DIG_REACH) : DEFAULT_DIG_REACH;
+}
+
+/** What one turn costs `subject` in mass, from a `mgx:mass-drain-per-turn` fact
+ *  on its own class chain (so a whole species is tuned in one line, and one
+ *  individual can still overrule its species by writing its own). Null when
+ *  nothing in the chain declares one — a knob nobody set is not a reason to
+ *  invent a number and starve something with it. Pure. */
+export function massDrainPerTurnOf(rows, subject) {
+  for (const kind of objectClassChain(rows, subject)) {
+    const written = declaredNumber(rows, kind, MASS_DRAIN_PREDICATE);
+    if (written !== null && written >= 0) return written;
+  }
+  return null;
+}
+
+// Which way a room of each kind can be dug, and what the room it opens is
+// typed as. Above ground there is nothing to tunnel sideways through, so the
+// only dig is straight down into the soil; below ground the burrow spreads
+// across its own level and can surface again. Digging deeper is left out so
+// the burrow stays the one level the soil cross-section draws.
+const DIGGABLE_BY_ROOM_KIND = new Map([
+  ["outdoor", new Map([["down", "underground-space"]])],
+  ["underground", new Map([
+    ["north", "underground-space"],
+    ["south", "underground-space"],
+    ["east", "underground-space"],
+    ["west", "underground-space"],
+    ["up", "outdoor-space"],
+  ])],
+  ["indoor", new Map()],
+]);
+
+const DIG_DECLINE_BY_ROOM_KIND = {
+  outdoor: (room, direction) => (direction === "up"
+    ? `there's nothing but sky above the ${room}.`
+    : `you can't tunnel ${direction} out here — the ${room} is open ground, not soil to dig through. Dig down to get under it.`),
+  underground: (room) => `the earth below the ${room} is packed solid — this burrow runs one level deep.`,
+  indoor: (room, direction) => `you can't dig ${direction} out of the ${room}.`,
+};
+
+/** A room's own kind, from the rdf:type facts the world writes about it:
+ *  "outdoor" (the surface), "underground" (the burrow), or "indoor" for a
+ *  walled room that says neither. Pure. */
+export function roomKindOf(rows, room) {
+  const typedAs = (kind) => (rows || []).some((r) => r.subject === room && r.predicate === "rdf:type" && r.object === kind);
+  if (typedAs("outdoor-space")) return "outdoor";
+  if (typedAs("underground-space")) return "underground";
+  return "indoor";
+}
+
+/** The room a world calls its origin — the one every dig is measured from — or
+ *  null when it names none. A world with no origin fact is simply not bounded.
+ *  Pure. */
+export function originRoomOf(rows) {
+  return (rows || []).find((r) => r.predicate === ORIGIN_PREDICATE && r.object === "true")?.subject ?? null;
+}
+
+/** How many exits a walk from the world's origin to `room` crosses, or null
+ *  when the world declares no origin or no chain of exits joins the two. Pure. */
+export function roomDistanceFromOrigin(rows, state, room) {
+  const origin = originRoomOf(rows);
+  if (!origin) return null;
+  if (origin === room) return 0;
+  const seen = new Set([origin]);
+  let frontier = [origin];
+  for (let distance = 1; frontier.length; distance += 1) {
+    const next = [];
+    for (const from of frontier) {
+      for (const target of state.exits.get(from)?.values() ?? []) {
+        if (seen.has(target)) continue;
+        seen.add(target);
+        if (target === room) return distance;
+        next.push(target);
+      }
+    }
+    frontier = next;
+  }
+  return null;
+}
+
+/** True when `room` is as far from the origin as this world digs, or off the
+ *  origin's map altogether. A freshly dug room's only other exit is the one
+ *  back, so its distance is always this room's plus one — which makes the whole
+ *  boundary test a property of where the digger stands, never of the direction
+ *  it faces.
+ *
+ *  A room the origin cannot reach is the strictest case, not the loosest: it
+ *  has no measurable distance, so nothing would ever stop it growing, and a
+ *  burrow with no way home is precisely what the bound exists to prevent. A
+ *  world that declares no origin at all is a different thing and stays
+ *  unbounded. Pure. */
+function atDigBoundary(rows, state, room) {
+  if (!originRoomOf(rows)) return false;
+  const distance = roomDistanceFromOrigin(rows, state, room);
+  return distance === null || distance >= digReachOf(rows);
+}
+
+/** Every direction a dig could actually open a room in from `room`: allowed
+ *  by the room's own kind, with no exit already written that way, and inside
+ *  the world's dig boundary. This is the exact set the dig verb accepts, so a
+ *  caller offering these as hints can never suggest a dig the verb would then
+ *  refuse. Pure. */
+export function diggableDirections(rows, state, room) {
+  if (atDigBoundary(rows, state, room)) return [];
+  const exits = state.exits.get(room);
+  return [...(DIGGABLE_BY_ROOM_KIND.get(roomKindOf(rows, room)) ?? new Map()).keys()]
+    .filter((direction) => !exits?.has(direction));
+}
+
+const FOOD_CLASS = "food";
+// A shared reference mass standing in for per-species maxima until the game
+// config carries them, and what an eaten thing is worth when the world wrote
+// it no mass of its own.
+const ASSUMED_FULL_MASS = 20;
+const HUNGRY_FRACTION = 0.5;
+const DEFAULT_FOOD_MASS = 1;
+
+/** A stable small number for a string, so the same dig always opens the same
+ *  room: this world writes no randomness anywhere, and a re-run that differed
+ *  would make the fold's own history unreproducible. Pure. */
+function stableIndex(seed, span) {
+  let h = 0;
+  for (const ch of String(seed)) h = (h * 31 + ch.codePointAt(0)) % 100003;
+  return h % span;
+}
+
+/** An unused id for a newly dug room, reading as the room it was dug from
+ *  plus the direction ("garden-down"). A collision takes a numeric suffix, so
+ *  digging never renames or overwrites a room that already stands. Pure. */
+function freshRoomId(rows, here, direction) {
+  const base = `${here}-${direction}`;
+  const taken = (id) => (rows || []).some((r) => r.subject === id || r.object === id);
+  if (!taken(base)) return base;
+  for (let n = 2; n <= (rows || []).length + 2; n += 1) {
+    if (!taken(`${base}-${n}`)) return `${base}-${n}`;
+  }
+  return `${base}-${(rows || []).length + 3}`;
+}
+
+/** An unused id for a freshly dug object, reading as its plain kind and a
+ *  small number ("carrot-1"). The short id is what keeps a pouch readable:
+ *  naming a spawned object after the room it came out of inherits that room's
+ *  whole nested dig path ("carrot-sett-1-north-east-east"), which is an id, not
+ *  a name anyone can read. `alsoTaken` holds the ids minted earlier in this
+ *  same dig, which are not in `rows` yet. Pure. */
+function freshObjectId(rows, kind, alsoTaken) {
+  const taken = (id) => alsoTaken.has(id) || (rows || []).some((r) => r.subject === id || r.object === id);
+  for (let n = 1; n <= (rows || []).length + 2; n += 1) {
+    if (!taken(`${kind}-${n}`)) return `${kind}-${n}`;
+  }
+  return `${kind}-${(rows || []).length + 3}`;
+}
+
+/** The kinds a room kind declares for one of the spawn pools, in the order the
+ *  world wrote them, or `fallback` when it declares none. Pure. */
+function declaredKindsOr(rows, roomClass, predicate, fallback) {
+  const declared = factObjects(rows, roomClass, predicate);
+  return declared.length ? declared : fallback;
+}
+
+/** The mass row a freshly minted instance needs, copied off its own class, or
+ *  nothing when the class declares no mass. eat reads the instance's mass, so a
+ *  dug carrot with none would be worth the flat default however the world
+ *  values a carrot. Pure. */
+function classMassFacts(rows, instance, kind) {
+  const mass = factObjects(rows, kind, MASS_PREDICATE)[0];
+  return mass ? [{ subject: instance, predicate: MASS_PREDICATE, object: mass }] : [];
+}
+
+/** What a dig reads like: a bare tunnel, a scrap or two in the loose earth, or
+ *  a den — and, when somebody lives in it, who looked up. Pure. */
+function digNarration(direction, { isDen, spawned, resident }) {
+  const opened = isDen
+    ? `you dig ${direction} and break into a den somebody hollowed out.`
+    : `you dig ${direction} and open up a new room.`;
+  const held = spawned.length
+    ? ` ${isDen ? "Stored in it" : "In the loose earth"}: the ${spawned.join(", the ")}.`
+    : " There's nothing in it but bare earth.";
+  return `${opened}${held}${resident ? ` The ${resident} lives here, and looks up as you come through.` : ""}`;
+}
+
+/** What a thing should be CALLED on screen: its declared display name, else
+ *  its own id. A dug object carries one so a pouch can list "carrot" while the
+ *  world keeps the distinct id ("carrot-1") every verb resolves against. Pure. */
+export function displayNameOf(rows, subject) {
+  return factObjects(rows, subject, DISPLAY_NAME_PREDICATE)[0] ?? subject;
+}
+
 /** A container's open/locked status, stated plainly, and (only once already
  *  open) its visible contents — the one thing examine/talk's reused
  *  worldDigest call never states on its own, since mgx:is-open is a
@@ -668,7 +1188,8 @@ function containerDatatypeState(state, object) {
  *  thing's current location, a hidden one included: talking to the staff is
  *  the sanctioned way to learn a hiding place, while the where-is aside keeps
  *  declining. `knows-objective` states the quest. `knows-about` topics come
- *  back for the caller to digest. Pure. */
+ *  back for the caller to digest, each one read from its newest surviving
+ *  claim. Pure. */
 export function personKnowledgeLines(rows, state, person) {
   const lines = [];
   for (const objective of factObjects(rows, person, "mgx:knows-objective")) {
@@ -681,17 +1202,29 @@ export function personKnowledgeLines(rows, state, person) {
       ? `you'll find the ${thing} in the ${place.object}.`
       : `the ${thing} is in the ${place.object}.`);
   }
-  return { lines, aboutTopics: factObjects(rows, person, "mgx:knows-about") };
+  return { lines, aboutTopics: currentKnowsAboutTopics(rows, person) };
+}
+
+/** The FOOD_CLASS things `person` durably knows about — from being told, or
+ *  from having examined them itself (the mgx:knows-about facts
+ *  recordTold/recordExamined write, read back exactly like
+ *  personKnowledgeLines's own aboutTopics), filtered to whatever's
+ *  objectClassChain reaches "food". Unlike personKnowledgeLines's topics, a
+ *  food query has no per-topic sub-digest to hand back, so this returns the
+ *  plain list of known food things rather than a {lines, topics} pair. Pure. */
+export function personKnownFoodLines(rows, state, person) {
+  return currentKnowsAboutTopics(rows, person)
+    .filter((thing) => objectClassChain(rows, thing).includes(FOOD_CLASS));
 }
 
 /** What a person can report from where they stand this turn — derived each
  *  turn, never stored: who and what shares their room, each container's
  *  open/locked status, and what unlocks a locked one there. Pure. */
-export function personRoomReport(rows, state, person) {
+export function personRoomReport(rows, state, person, actingSubject = "player") {
   const room = state.placements.get(person)?.object ?? null;
   if (!room) return "";
   const here = [...state.placements.keys()]
-    .filter((s) => s !== person && s !== "player" && visibleRoomOf(s, { rows, state }) === room)
+    .filter((s) => s !== person && s !== actingSubject && visibleRoomOf(s, { rows, state }) === room)
     .sort();
   const parts = [];
   if (here.length) parts.push(`here in the ${room}: the ${here.join(", the ")}.`);
@@ -706,11 +1239,11 @@ export function personRoomReport(rows, state, person) {
   return parts.join(" ");
 }
 
-async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
+export async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache, actingSubject = "player" }) {
   const memory = await loadMemory(memoryDir);
   const rows = readFactRows(memory);
   const state = foldWorldState(worldActionRows(rows));
-  const here = state.placements.get("player")?.object ?? null;
+  const here = state.placements.get(actingSubject)?.object ?? null;
   const noteFor = (detail) => `ADVENTURE — ${detail}`;
 
   if (cmd.residue?.length) {
@@ -727,10 +1260,17 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       { miss: true },
     );
   }
+  if (OUT_OF_PLAY_PLACES.has(here)) {
+    return answer(
+      `${outOfPlayPhrase(actingSubject, here)} — it takes no more turns in this world.`,
+      noteFor(`${cmd.verb} — ${actingSubject} is placed out of play (${here}); every command it gives declines from here on`),
+      { miss: true },
+    );
+  }
 
   if (cmd.verb === "look" && !cmd.object) {
-    const digest = await worldDigest(here, { memoryDir, memory, rows, state, graph });
-    const actions = roomAffordances(rows, state, here);
+    const digest = await worldDigest(here, { memoryDir, memory, rows, state, graph, actingSubject });
+    const actions = roomAffordances(rows, state, here, actingSubject);
     return answer(
       `${digest ?? `you are in the ${here}. Nothing more about it is written down yet.`}${affordanceSuffix(actions)}`,
       noteFor(`look — an extractive completions digest over the current world facts mentioning "${here}"; appended the room's roomAffordances action list`),
@@ -744,7 +1284,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     // null for anything held by the player) — examine and look still apply to
     // it, the same way "what am I carrying" already reads inventory contents.
     // talk has no carried exception: NPCs are never portable.
-    const carried = (cmd.verb === "examine" || cmd.verb === "look") && carriedByPlayer(state, object);
+    const carried = (cmd.verb === "examine" || cmd.verb === "look") && carriedBy(state, object, actingSubject);
     // The room the player is standing in is never the SUBJECT of a placement
     // fact (only ever the OBJECT other things are placed in), so
     // visibleRoomOf(object) can never equal `here` for a room's own name —
@@ -776,7 +1316,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
         { miss: true },
       );
     }
-    const person = isTyped(rows, object, "person");
+    const person = isCastMember(rows, state, object);
     // "look <object>" on a real placed prop is the grounded close look: every
     // physical fact the world writes about the thing (its placement, its
     // within-room position, any datatype property — all via the SAME
@@ -786,7 +1326,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     // placed facts of its own, so it falls through to the examine digest below
     // (the same general-knowledge answer "what is a flower" gives).
     if (cmd.verb === "look" && !backgroundOnlyMention(rows, state, object)) {
-      const propLines = objectLookProperties(rows, state, object);
+      const propLines = objectLookProperties(rows, state, object, actingSubject);
       const chain = objectClassChain(rows, object);
       const parts = [`you look closely at the ${object}.`];
       if (propLines.length) parts.push(propLines.join(" "));
@@ -805,10 +1345,10 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       const { lines, aboutTopics } = personKnowledgeLines(rows, state, object);
       const aboutLines = [];
       for (const topic of aboutTopics) {
-        const digested = await worldDigest(topic, { memoryDir, memory, rows, state, graph });
+        const digested = await worldDigest(topic, { memoryDir, memory, rows, state, graph, actingSubject });
         if (digested) aboutLines.push(digested);
       }
-      const report = personRoomReport(rows, state, object);
+      const report = personRoomReport(rows, state, object, actingSubject);
       const said = [...lines, ...aboutLines, report].filter(Boolean).join(" ");
       return answer(
         said ? `the ${object} says: ${said}` : `the ${object} has nothing to tell you right now.`,
@@ -816,7 +1356,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
         { goal: `talk to the ${object}` },
       );
     }
-    const digest = await worldDigest(object, { memoryDir, memory, rows, state, graph });
+    const digest = await worldDigest(object, { memoryDir, memory, rows, state, graph, actingSubject });
     const body = digest ?? `nothing more about the ${object} is written down yet.`;
     const containerNote = !person && isContainer(rows, object) ? ` ${containerStatusPhrase(object, { state })}` : "";
     // Framing follows the VERB the player typed, not the object's type: talking
@@ -858,8 +1398,8 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     const freshMemory = await loadMemory(memoryDir);
     const freshRows = readFactRows(freshMemory);
     const freshState = foldWorldState(worldActionRows(freshRows));
-    const relookDigest = await worldDigest(playerRoomAfter, { memoryDir, memory: freshMemory, rows: freshRows, state: freshState, graph });
-    const actions = roomAffordances(freshRows, freshState, playerRoomAfter);
+    const relookDigest = await worldDigest(playerRoomAfter, { memoryDir, memory: freshMemory, rows: freshRows, state: freshState, graph, actingSubject });
+    const actions = roomAffordances(freshRows, freshState, playerRoomAfter, actingSubject);
     const relook = `you are in the ${playerRoomAfter}. ${relookDigest ?? "Nothing more about it is written down yet."}${affordanceSuffix(actions)}`;
     return answer(
       `${text2} ${relook}`,
@@ -879,10 +1419,25 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
         { miss: true },
       );
     }
+    // A predator eats whatever walks in, and the room it guards is the one
+    // room a move never comes back from — so this write bypasses commit()
+    // entirely: the auto-relook there would describe a room the mover is no
+    // longer standing in, and the world has nobody left to look with.
+    const predator = predatorIn(rows, state, target);
+    if (predator) {
+      await writeWorldTurn(memoryDir, world, k, [
+        { subject: `${actingSubject}@turn${k}`, predicate: "mgx:currently-in", object: CONSUMED_PLACE },
+      ], cache);
+      return answer(
+        `you go ${cmd.direction} into the ${target} — and the ${predator} is waiting. It eats the ${actingSubject}. That's the end of its run.`,
+        noteFor(`go — the ${target} holds the predator ${predator}; ${actingSubject} is placed out of play at turn ${k} and takes no further turns`),
+        { goal: `move through the world (eaten by the ${predator} in the ${target})` },
+      );
+    }
     return commit(
-      [{ subject: `player@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:currently-in", object: target }],
+      [{ subject: `${actingSubject}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:currently-in", object: target }],
       `you go ${cmd.direction}. Now in the ${target}.`,
-      `go — the taught "go" family fired; player moves ${here} -> ${target}`,
+      `go — the taught "go" family fired; ${actingSubject} moves ${here} -> ${target}`,
       `move through the world (now in the ${target})`,
       target,
     );
@@ -892,7 +1447,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     if (isTyped(rows, object, "room")) {
       return answer(`you can't take the ${object} — it's a whole room.`, noteFor("take — the object is a room; declined"), { miss: true });
     }
-    if (carriedByPlayer(state, object)) {
+    if (carriedBy(state, object, actingSubject)) {
       return answer(`you're already carrying the ${object}.`, noteFor("take — already carried; declined"), { miss: true });
     }
     if (place && (place.predicate === "mgx:fixed-in" || place.predicate === "mgx:stands-locked-in") && place.object === here) {
@@ -916,7 +1471,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       return answer(`I don't see a ${object} here.`, noteFor(`take — ${object} isn't visible in the ${here}; declined, hidden things stay hidden`), { miss: true });
     }
     return commit(
-      [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: "player" }],
+      [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: actingSubject }],
       `you take the ${object}.`,
       `take — the taught "take" family fired; ${object} is now carried`,
       `carry the ${object}`,
@@ -924,7 +1479,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
   }
 
   if (cmd.verb === "drop" || cmd.verb === "give") {
-    if (!carriedByPlayer(state, object)) {
+    if (!carriedBy(state, object, actingSubject)) {
       return answer(`you're not carrying the ${object}.`, noteFor(`${cmd.verb} — ${object} isn't carried; precondition declined by name`), { miss: true });
     }
     if (cmd.verb === "drop") {
@@ -936,8 +1491,8 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       );
     }
     const receiver = cmd.indirectObject;
-    if (!isTyped(rows, receiver, "person") || state.placements.get(receiver)?.object !== here) {
-      return answer(`the ${receiver} isn't here.`, noteFor(`give — ${receiver} isn't a person in the ${here}; precondition declined by name`), { miss: true });
+    if (!isCastMember(rows, state, receiver) || state.placements.get(receiver)?.object !== here) {
+      return answer(`the ${receiver} isn't here.`, noteFor(`give — ${receiver} isn't one of the cast standing in the ${here}; precondition declined by name`), { miss: true });
     }
     return commit(
       [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: receiver }],
@@ -947,6 +1502,176 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     );
   }
 
+  if (cmd.verb === "dig") {
+    const direction = cmd.direction;
+    if (state.exits.get(here)?.get(direction)) {
+      return answer(
+        `there's already an exit ${direction} from the ${here}.`,
+        noteFor(`dig — an mgx:has-exit-${direction} fact already stands on ${here}; declined, a dig never overwrites an exit`),
+        { miss: true },
+      );
+    }
+    const back = OPPOSITE_DIRECTION.get(direction);
+    if (!back) {
+      return answer(
+        `I don't know which way back a ${direction} tunnel would run.`,
+        noteFor(`dig — "${direction}" has no opposite to write the return exit with; declined by name`),
+        { miss: true },
+      );
+    }
+    const roomKind = roomKindOf(rows, here);
+    const dugKind = (DIGGABLE_BY_ROOM_KIND.get(roomKind) ?? new Map()).get(direction) ?? null;
+    if (!dugKind) {
+      return answer(
+        DIG_DECLINE_BY_ROOM_KIND[roomKind](here, direction),
+        noteFor(`dig — the ${here} is an ${roomKind} room, which cannot be dug ${direction}; declined by the room's own kind`),
+        { miss: true },
+      );
+    }
+    if (atDigBoundary(rows, state, here)) {
+      const reach = roomDistanceFromOrigin(rows, state, here);
+      return answer(
+        `the earth ${direction} of the ${here} is packed hard and endless — you have reached the far edge of the burrow.`,
+        noteFor(reach === null
+          ? `dig — no chain of exits joins the ${here} to the ${originRoomOf(rows)}, so there is no distance to measure a dig against; declined`
+          : `dig — the ${here} stands ${reach} rooms from the ${originRoomOf(rows)}, and this world digs ${digReachOf(rows)}; declined by distance from the origin`),
+        { miss: true },
+      );
+    }
+    const dug = freshRoomId(rows, here, direction);
+    const denChanceIn = declaredCountOr(rows, dugKind, DEN_CHANCE_PREDICATE, DEFAULT_DEN_CHANCE_IN);
+    const isDen = dugKind === "underground-space" && stableIndex(`den:${dug}`, denChanceIn) === 0;
+    const spawnMax = declaredCountOr(rows, dugKind, DIG_SPAWN_MAX_PREDICATE, DEFAULT_DIG_SPAWN_MAX);
+    const spawnCount = DIG_SPAWN_MIN + stableIndex(dug, spawnMax - DIG_SPAWN_MIN + 1);
+    const spawnedKinds = isDen
+      ? declaredKindsOr(rows, dugKind, DEN_SPAWN_PREDICATE, DIG_SPAWN_KINDS)
+      : declaredKindsOr(rows, dugKind, DIG_SPAWN_PREDICATE, DIG_SPAWN_KINDS).slice(0, spawnCount);
+    const minted = new Set();
+    const spawned = spawnedKinds.map((kind) => {
+      const id = freshObjectId(rows, kind, minted);
+      minted.add(id);
+      return id;
+    });
+    const residentChanceIn = declaredCountOr(rows, dugKind, DEN_RESIDENT_CHANCE_PREDICATE, DEFAULT_DEN_RESIDENT_CHANCE_IN);
+    const residentKind = isDen && stableIndex(`resident:${dug}`, residentChanceIn) === 0
+      ? factObjects(rows, dugKind, DEN_RESIDENT_PREDICATE)[0] ?? null
+      : null;
+    const resident = residentKind ? freshObjectId(rows, residentKind, minted) : null;
+    return commit(
+      [
+        { subject: dug, predicate: "rdf:type", object: "room" },
+        { subject: dug, predicate: "rdf:type", object: dugKind },
+        ...(isDen ? [{ subject: dug, predicate: "rdf:type", object: DEN_ROOM_CLASS }] : []),
+        { subject: here, predicate: `mgx:has-exit-${direction}`, object: dug },
+        { subject: dug, predicate: `mgx:has-exit-${back}`, object: here },
+        // Typed to its OWN kind, not a flat "portable" — a spawned kind the
+        // world declares rdfs:subClassOf food needs its real class reachable
+        // here for isFood's own objectClassChain walk, or digging up "carrot-1"
+        // would still read as inedible scenery. The class's own mass copies
+        // onto the instance for the same reason: eat reads the instance.
+        ...spawnedKinds.flatMap((kind, i) => ([
+          { subject: spawned[i], predicate: "rdf:type", object: kind },
+          { subject: spawned[i], predicate: DISPLAY_NAME_PREDICATE, object: kind },
+          { subject: spawned[i], predicate: "mgx:located-in", object: dug },
+          ...classMassFacts(rows, spawned[i], kind),
+        ])),
+        // A resident is placed with currently-in, the predicate that makes an
+        // individual one of the cast, and knows about what its own den holds —
+        // so an animal that digs one out has somebody new to ask about food.
+        ...(resident ? [
+          { subject: resident, predicate: "rdf:type", object: residentKind },
+          { subject: resident, predicate: DISPLAY_NAME_PREDICATE, object: residentKind },
+          { subject: resident, predicate: "mgx:currently-in", object: dug },
+          ...classMassFacts(rows, resident, residentKind),
+          ...spawned.map((thing) => ({ subject: resident, predicate: KNOWS_ABOUT_PREDICATE, object: thing })),
+        ] : []),
+      ],
+      digNarration(direction, { isDen, spawned, resident }),
+      `dig — minted the ${isDen ? `${DEN_ROOM_CLASS} ` : ""}${dugKind} ${dug} with exits both ways (${direction} out, ${back} back)${spawned.length ? `, and ${spawned.length} object(s) in it` : ""}${resident ? `, lived in by ${resident}` : ""}; digging spends the turn, so the digger stays in the ${here}`,
+      `dig ${direction} out of the ${here}`,
+    );
+  }
+
+  if (cmd.verb === "eat") {
+    const present = visibleRoomOf(object, { rows, state }) === here || carriedBy(state, object, actingSubject);
+    if (!present) {
+      return answer(
+        `I don't see a ${object} here.`,
+        noteFor(`eat — ${object} is neither visible in the ${here} nor carried; declined`),
+        { miss: true },
+      );
+    }
+    if (!objectClassChain(rows, object).includes(FOOD_CLASS)) {
+      return answer(
+        `the ${object} isn't food.`,
+        noteFor(`eat — ${object}'s rdf:type/rdfs:subClassOf chain never reaches "${FOOD_CLASS}"; declined by name`),
+        { miss: true },
+      );
+    }
+    const eaterMass = state.masses.get(actingSubject)?.value ?? null;
+    if (eaterMass !== null && eaterMass >= ASSUMED_FULL_MASS * HUNGRY_FRACTION) {
+      return answer(
+        `you're too full to eat the ${object}.`,
+        noteFor(`eat — ${actingSubject} weighs ${eaterMass}, at or over half of ${ASSUMED_FULL_MASS}; declined by name`),
+        { miss: true },
+      );
+    }
+    const gained = state.masses.get(object)?.value ?? DEFAULT_FOOD_MASS;
+    const grown = Math.round(((eaterMass ?? 0) + gained) * 100) / 100;
+    // Eating is the one act that ends a thing, so the eater is the one witness
+    // whose knowledge of it goes out of date on the spot. Every route into the
+    // eat verb — a typed command, a scripted mud turn — passes here, so the
+    // claim gets written once for all of them.
+    await recordGone(memoryDir, { observer: actingSubject, thing: object, k, cache });
+    return commit(
+      [
+        { subject: `${actingSubject}@turn${k}`, predicate: MASS_PREDICATE, object: String(grown) },
+        { subject: `${object}@turn${k}`, predicate: "mgx:located-in", object: CONSUMED_PLACE },
+      ],
+      `you eat the ${object}. It adds ${gained} to your mass, so you weigh ${grown} now.`,
+      `eat — the ${object}'s ${gained} mass moves onto ${actingSubject} (now ${grown}) and the ${object} leaves the world`,
+      `eat the ${object}`,
+    );
+  }
+
+  if (cmd.verb === "put") {
+    const container = cmd.indirectObject;
+    if (!carriedBy(state, object, actingSubject)) {
+      return answer(
+        `you're not carrying the ${object}.`,
+        noteFor(`put — ${object} isn't carried; precondition declined by name`),
+        { miss: true },
+      );
+    }
+    if (visibleRoomOf(container, { rows, state }) !== here) {
+      return answer(
+        `I don't see a ${container} here.`,
+        noteFor(`put — ${container} isn't visible in the ${here}; declined`),
+        { miss: true },
+      );
+    }
+    if (!isContainer(rows, container)) {
+      return answer(
+        `the ${container} doesn't hold things.`,
+        noteFor(`put — no mgx:is-container fact on ${container}; declined by name`),
+        { miss: true },
+      );
+    }
+    if (!state.openness.get(container)?.open) {
+      return answer(
+        `the ${container} is closed.`,
+        noteFor(`put — the ${container} isn't open; precondition declined by name`),
+        { miss: true },
+      );
+    }
+    return commit(
+      [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: container }],
+      `you put the ${object} in the ${container}.`,
+      `put — the taught "put" family fired; the ${object} now sits in the ${container}`,
+      `put the ${object} in the ${container}`,
+    );
+  }
+
   // open / unlock / close — the container verbs. presence and container-ness
   // stay hand-checked here (visibility gating, not a state precondition);
   // unlock's instrument match stays fully hand-written below it too — it
@@ -981,14 +1706,14 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       );
     }
     const factState = containerDatatypeState(state, object);
-    const failed = taughtAction.preconds.find((p) => !precondHolds(p, "player", object, factState, domain));
+    const failed = taughtAction.preconds.find((p) => !precondHolds(p, actingSubject, object, factState, domain));
     if (failed) {
       const text = failed.predicate === "mgx:stands-locked-in"
         ? `the ${object} is locked.`
         : cmd.verb === "open" ? `the ${object} is already open.` : `the ${object} isn't open.`;
       return answer(text, noteFor(`${cmd.verb} — the taught "${cmd.verb}" family's ${failed.predicate} precondition declined by name`), { miss: true });
     }
-    const effSubject = roleBinding(effect.subjectRole, "player", object, domain);
+    const effSubject = roleBinding(effect.subjectRole, actingSubject, object, domain);
     const writeIsOpen = { subject: `${effSubject}@turn${k}`, predicate: effect.predicate, object: effect.value };
 
     if (cmd.verb === "open") {
@@ -1035,7 +1760,7 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
       { miss: true },
     );
   }
-  if (!carriedByPlayer(state, cmd.instrument)) {
+  if (!carriedBy(state, cmd.instrument, actingSubject)) {
     return answer(
       `you're not carrying the ${cmd.instrument}.`,
       noteFor(`unlock — the ${cmd.instrument} isn't carried; precondition declined by name`),
@@ -1076,7 +1801,7 @@ const WORLD_IS_OPEN_RE = /^is\s+(?:the\s+|a\s+|an\s+)?(.+?)\s+(open|closed|shut)
  *  when the asked thing has no placement in the world, so an ordinary
  *  locative question (a code symbol, a taught board piece) keeps its lane. A
  *  hidden thing is declined without naming its hiding place. */
-async function worldWhereAnswer(line, { memoryDir }) {
+async function worldWhereAnswer(line, { memoryDir, actingSubject = "player" }) {
   const m = String(line).match(WORLD_WHERE_RE);
   if (!m) return null;
   const thing = normFactTerm(m[1]);
@@ -1092,14 +1817,21 @@ async function worldWhereAnswer(line, { memoryDir }) {
       { miss: true, goal: `locate the ${thing}` },
     );
   }
-  if (thing === "player") {
+  if (OUT_OF_PLAY_PLACES.has(place.object)) {
+    return answer(
+      `${outOfPlayPhrase(thing, place.object)} — it's gone from the world.`,
+      `ADVENTURE — where-aside: ${thing} is out of play (${place.object}), so it has no place left to name`,
+      { goal: `locate the ${thing}` },
+    );
+  }
+  if (thing === actingSubject) {
     return answer(
       `you are in the ${place.object}.`,
       "ADVENTURE — where-aside: the player's own room, from the current world fold",
       { goal: "check where you are" },
     );
   }
-  if (place.object === "player") {
+  if (place.object === actingSubject) {
     return answer(
       `you are carrying the ${thing}.`,
       `ADVENTURE — where-aside: ${thing} is carried, from the current world fold`,
@@ -1143,20 +1875,54 @@ async function worldOpennessAnswer(line, { memoryDir }) {
 const WORLD_WHERE_AM_I_RE = /^where\s+am\s+i(?:\s+now)?[?.!\s]*$/i;
 const WORLD_OPTIONS_RE = /^(?:what\s+can\s+i\s+do(?:\s+(?:here|now))?|what\s+are\s+my\s+options|what\s+(?:should|do)\s+i\s+do(?:\s+(?:here|now))?|what\s+now)[?.!\s]*$/i;
 const WORLD_QUEST_RE = /^(?:what(?:'s|\s+is)\s+(?:the\s+|my\s+)?(?:quest|goal|objective|mission|aim)|what\s+am\s+i\s+(?:trying\s+to\s+do|(?:supposed|meant)\s+to\s+do)|what\s+do\s+i\s+do\s+here)[?.!\s]*$/i;
+// "who is here" — the room's cast, the question a shared world invites the
+// moment a second animal walks in. Answered from the same currently-in
+// placements the talk verb resolves against, so who is named is exactly who
+// can be talked to.
+const WORLD_WHO_HERE_RE =
+  /^(?:who(?:'s|\s+is|\s+are)\s+(?:else\s+)?(?:here|in\s+(?:the\s+|this\s+)?room|with\s+me)|who\s+else\s+is\s+(?:here|around))[?.!\s]*$/i;
+// "what food do you know about" and its natural variants — the asking
+// character's OWN durable food knowledge (personKnownFoodLines), never the
+// whole world's food. The trailing "about" is optional, "know" swaps for
+// "found"/"seen"/"heard about", and the "what do you know about food"
+// inversion and a plain yes/no lead-in both count: every one of these is the
+// same question, and a phrasing this lane doesn't recognise leaves the world
+// entirely and comes back answered as vocabulary.
+const WORLD_KNOWN_FOOD_RE = new RegExp(
+  "^(?:"
+  + "what\\s+foods?\\s+(?:do\\s+you\\s+know(?:\\s+about)?|have\\s+you\\s+(?:found|seen|heard\\s+(?:about|of))|do\\s+you\\s+know\\s+of)"
+  + "|what\\s+do\\s+you\\s+know\\s+about\\s+(?:any\\s+)?foods?"
+  + "|do\\s+you\\s+know\\s+(?:about|of)\\s+(?:any\\s+)?foods?"
+  + "|where\\s+is\\s+(?:the\\s+)?food"
+  + ")[?.!\\s]*$",
+  "i",
+);
 
 /** The in-game orientation asides, answered from the world fold: the player's
  *  room, the room's real affordances, and the world's objective. Null when the
  *  line is none of them, so an ordinary question keeps its lane. */
-async function worldContextAnswer(line, { memoryDir }) {
+async function worldContextAnswer(line, { memoryDir, actingSubject = "player" }) {
   const l = String(line).trim();
   const asksWhere = WORLD_WHERE_AM_I_RE.test(l);
   const asksOptions = WORLD_OPTIONS_RE.test(l);
   const asksQuest = WORLD_QUEST_RE.test(l);
-  if (!asksWhere && !asksOptions && !asksQuest) return null;
+  const asksWhoIsHere = WORLD_WHO_HERE_RE.test(l);
+  if (!asksWhere && !asksOptions && !asksQuest && !asksWhoIsHere) return null;
   let rows;
   try { rows = readFactRows(await loadMemory(memoryDir)); } catch { return null; }
   const state = foldWorldState(worldActionRows(rows));
-  const here = state.placements.get("player")?.object ?? null;
+  const here = state.placements.get(actingSubject)?.object ?? null;
+
+  if (asksWhoIsHere) {
+    const cast = here ? castInRoom(rows, state, here, actingSubject) : [];
+    return answer(
+      cast.length
+        ? `here with you in the ${here}: the ${cast.join(", the ")}. You can talk to ${cast.length > 1 ? "any of them" : `the ${cast[0]}`}.`
+        : `nobody else is${here ? ` in the ${here}` : " here"} right now.`,
+      `ADVENTURE — who-is-here aside: the ${here}'s cast from the current placements fold, the same set the talk verb resolves against`,
+      { goal: "see who else is here" },
+    );
+  }
 
   if (asksWhere) {
     return here
@@ -1165,7 +1931,7 @@ async function worldContextAnswer(line, { memoryDir }) {
   }
 
   if (asksOptions) {
-    const actions = here ? roomAffordances(rows, state, here) : [];
+    const actions = here ? roomAffordances(rows, state, here, actingSubject) : [];
     return answer(
       actions.length ? `you can: ${actions.join(", ")}.` : `nothing obvious here — say "look" to look around${here ? ` the ${here}` : ""}.`,
       `ADVENTURE — options aside: the ${here}'s roomAffordances, the same list "look" appends`,
@@ -1187,12 +1953,73 @@ async function worldContextAnswer(line, { memoryDir }) {
       );
 }
 
-async function inventoryAnswer({ memoryDir, graph }) {
+/** "what food do you know about" — the ASKING character's own durable food
+ *  knowledge, read from the same mgx:knows-about facts recordTold/
+ *  recordExamined write (personKnownFoodLines). An honest "you don't know of
+ *  any food yet" when none is known — a real, on-topic answer, not a miss,
+ *  the same convention inventoryAnswer's own empty-carry case already uses.
+ *  Null when the line isn't this aside, so an ordinary question keeps its
+ *  lane. */
+async function worldKnownFoodAnswer(line, { memoryDir, actingSubject = "player" }) {
+  const l = String(line).trim();
+  if (!WORLD_KNOWN_FOOD_RE.test(l)) return null;
+  let rows;
+  try { rows = readFactRows(await loadMemory(memoryDir)); } catch { return null; }
+  const state = foldWorldState(worldActionRows(rows));
+  const foods = personKnownFoodLines(rows, state, actingSubject);
+  if (!foods.length) {
+    return answer(
+      "you don't know of any food yet.",
+      `ADVENTURE — known-food aside: ${actingSubject}'s mgx:knows-about facts reach no food-classed thing; the honest empty answer`,
+      { goal: "check what food you know about" },
+    );
+  }
+  return answer(
+    `you know about: the ${foods.join(", the ")}.`,
+    `ADVENTURE — known-food aside: ${actingSubject}'s durable mgx:knows-about facts, filtered to the food class`,
+    { goal: "check what food you know about" },
+  );
+}
+
+// A question that names one of the world's OWN minted ids — "sett-1",
+// "groundhog-1", "carrot-2" — can only be about this world: nothing else in
+// the session has ever heard that token. So when no world shape matched it,
+// the fall-through is a plain misroute, and in a session with no code graph it
+// comes back as the code-graph wall, which says nothing true about a burrow.
+// The gate is the hyphen: a world id that is a plain dictionary word ("lamp",
+// "garden") stays out of this, so an ordinary mid-game question about an
+// ordinary word keeps the lane it has always had.
+const WORLD_QUESTION_LEAD_RE =
+  /^(?:who|what|where|which|how|why|when|tell\s+me|describe|do\s+you|does|is|are|can\s+you|any)\b/i;
+const WORLD_MINTED_ID_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/;
+
+/** A digest about the world-minted id a question names, or null when the line
+ *  is not a question, names none, or the world places nothing by that name. */
+async function worldMentionAnswer(line, { memoryDir, graph, actingSubject = "player" }) {
+  const l = String(line).trim();
+  if (!/\?\s*$/.test(l) && !WORLD_QUESTION_LEAD_RE.test(l)) return null;
+  const spoken = new Set(l.toLowerCase().replace(/[?.!,;:"']/g, " ").split(/\s+/).filter(Boolean));
+  let memory;
+  try { memory = await loadMemory(memoryDir); } catch { return null; }
+  const rows = readFactRows(memory);
+  const state = foldWorldState(worldActionRows(rows));
+  const named = worldIndividualNames(rows)
+    .find((subject) => WORLD_MINTED_ID_RE.test(subject) && spoken.has(subject));
+  if (!named) return null;
+  const digest = await worldDigest(named, { memoryDir, memory, rows, state, graph, actingSubject });
+  return answer(
+    digest ?? `nothing more about the ${named} is written down yet.`,
+    `ADVENTURE — world-mention aside: "${named}" is an id this world minted, so the question is the world's to answer; digested from the current fold`,
+    { goal: `find out about the ${named}` },
+  );
+}
+
+async function inventoryAnswer({ memoryDir, graph, actingSubject = "player" }) {
   const memory = await loadMemory(memoryDir);
   const rows = readFactRows(memory);
   const state = foldWorldState(worldActionRows(rows));
   const carried = [...state.placements]
-    .filter(([, p]) => p.predicate === "mgx:located-in" && p.object === "player")
+    .filter(([, p]) => p.predicate === "mgx:located-in" && p.object === actingSubject)
     .map(([thing]) => thing)
     .sort();
   if (!carried.length) {
@@ -1202,7 +2029,7 @@ async function inventoryAnswer({ memoryDir, graph }) {
       { goal: "check what you carry" },
     );
   }
-  const digest = await worldDigest("player", { memoryDir, memory, rows, state, graph });
+  const digest = await worldDigest(actingSubject, { memoryDir, memory, rows, state, graph, actingSubject });
   return answer(
     digest ?? `you are carrying the ${carried.join(", the ")}.`,
     "ADVENTURE — inventory: an extractive completions digest over the facts mentioning the player",
@@ -1246,14 +2073,14 @@ const commandHasPronoun = (cmd) => PRONOUN_SLOTS.some((s) => cmd[s] && OBJECT_PR
  *  real, actionable object from the current room when one is on show (else a
  *  static example). Never the "I don't know the word" line — the vocabulary
  *  misdiagnosis is unreachable for a pronoun. */
-async function noFocusPronounNudge(pronoun, { memoryDir }) {
+async function noFocusPronounNudge(pronoun, { memoryDir, actingSubject = "player" }) {
   let example = null;
   try {
     const rows = readFactRows(await loadMemory(memoryDir));
     const state = foldWorldState(worldActionRows(rows));
-    const here = state.placements.get("player")?.object ?? null;
+    const here = state.placements.get(actingSubject)?.object ?? null;
     if (here) {
-      for (const action of roomAffordances(rows, state, here)) {
+      for (const action of roomAffordances(rows, state, here, actingSubject)) {
         const m = action.match(/^(?:examine|take|open|unlock|talk to) (.+)$/);
         if (m) { example = m[1]; break; }
       }
@@ -1274,14 +2101,15 @@ async function noFocusPronounNudge(pronoun, { memoryDir }) {
  *  passes straight through untouched. All four surface pronouns
  *  (it/them/him/her) normalize to the one `it` probe, then bind to the newest
  *  referent THIS lane registered — the record may also hold code-graph
- *  referents, so the bind is scoped to `lane: "adventure"`. */
-async function bindPronouns(cmd, { discourseHolder, memoryDir }) {
+ *  referents, so the bind is scoped to `lane: "adventure"`. The record is one
+ *  per session, so several acting subjects sharing a world share one focus. */
+async function bindPronouns(cmd, { discourseHolder, memoryDir, actingSubject = "player" }) {
   if (!commandHasPronoun(cmd)) return { cmd };
   const probe = discourseHolder ? bindDiscourseForm(discourseHolder.record, "it") : null;
   const focusTerm = (probe?.candidates || []).find((r) => r.from?.lane === "adventure")?.label ?? null;
   if (!focusTerm) {
     const pronoun = PRONOUN_SLOTS.map((s) => cmd[s]).find((v) => v && OBJECT_PRONOUNS.has(v));
-    return { nudge: await noFocusPronounNudge(pronoun, { memoryDir }) };
+    return { nudge: await noFocusPronounNudge(pronoun, { memoryDir, actingSubject }) };
   }
   const bound = { ...cmd };
   for (const s of PRONOUN_SLOTS) {
@@ -1290,6 +2118,78 @@ async function bindPronouns(cmd, { discourseHolder, memoryDir }) {
   return { cmd: bound };
 }
 
+// ---- the world's own vocabulary ----------------------------------------------
+//
+// A world's minted ids are words only that world knows. "groundhog-1" is in no
+// dictionary, so the parser's lexicon gate rejects "talk to groundhog-1" as an
+// undeclared word and the whole command dies before the talk verb ever sees
+// it. Declaring those ids as PROPER NAMES for the duration of a world command
+// fixes that: a proper name outranks every other category, so the id resolves
+// as itself. Ids the core lexicon already knows are left out, so no ordinary
+// word changes category because a world happens to use it — and the extension
+// is scoped to this lane, so the teach and ask lanes keep the plain lexicon.
+
+let worldLexiconCache = { key: null, base: null, lexicon: null };
+
+function worldLexicon(rows, base) {
+  const names = worldIndividualNames(rows).filter((name) => !classify(name, base));
+  const key = names.join("");
+  if (worldLexiconCache.base === base && worldLexiconCache.key === key) return worldLexiconCache.lexicon;
+  const lexicon = withProperNames(base, names);
+  worldLexiconCache = { key, base, lexicon };
+  return lexicon;
+}
+
+async function worldAwareLexicon(memoryDir, lexicon) {
+  const base = lexicon ?? loadLexicon();
+  try {
+    return worldLexicon(readFactRows(await loadMemory(memoryDir)), base);
+  } catch {
+    return base;
+  }
+}
+
+// ---- the vocative: naming who the line is addressed to ------------------------
+//
+// Give a window a character's name and players start using it: "groundhog-1
+// what do you know about food", "mole-1, dig north". The name is who the line
+// is addressed to, not part of the question — but it makes the line fit no
+// world shape at all, so the whole turn leaves this lane and comes back
+// answered as something else entirely (a code question, in a session with no
+// code graph). Stripping a vocative that names one of the world's OWN placed
+// individuals costs one fold read, and only on a line that has already failed
+// on its own terms.
+
+const escapeForRegExp = (s) => String(s).replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+
+/** `line` with a leading or trailing vocative naming a placed world
+ *  individual removed, or null when it carries none (or when the name is the
+ *  whole line, which is a bare mention, not an address). Pure. */
+export function withoutWorldVocative(line, names) {
+  const l = String(line).trim();
+  for (const name of names) {
+    const escaped = escapeForRegExp(name);
+    const leading = new RegExp(`^${escaped}\\s*[,:;]?\\s+`, "i");
+    if (leading.test(l)) {
+      const rest = l.replace(leading, "").trim();
+      if (rest) return rest;
+    }
+    const trailing = new RegExp(`[\\s,]+${escaped}\\s*([?.!]*)$`, "i");
+    if (trailing.test(l)) {
+      const rest = l.replace(trailing, "$1").trim();
+      if (rest) return rest;
+    }
+  }
+  return null;
+}
+
+async function addressedLine(line, { memoryDir }) {
+  let rows;
+  try { rows = readFactRows(await loadMemory(memoryDir)); } catch { return null; }
+  const state = foldWorldState(worldActionRows(rows));
+  return withoutWorldVocative(line, [...state.placements.keys()].sort());
+}
+
 // ---- the lane ----------------------------------------------------------------
 
 /**
@@ -1301,7 +2201,7 @@ async function bindPronouns(cmd, { discourseHolder, memoryDir }) {
  * recognizer, injected so the two lanes can never disagree about what a plan
  * frame is.
  */
-export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "", env, lexicon = null, graph = null, cache = null, isPlanFrameLine = () => false, discourseHolder = null }) {
+export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "", env, lexicon = null, graph = null, cache = null, isPlanFrameLine = () => false, discourseHolder = null, actingSubject = "player" }) {
   const slot = planHolder?.state ?? null;
   const adventure = slot?.adventure ?? null;
   const opening = matchAdventureOpening(line);
@@ -1357,13 +2257,29 @@ export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "
       note: "ADVENTURE — a plan frame arrived mid-adventure; the slot holds one thing at a time",
     };
   }
-  if (INVENTORY_RE.test(line)) return inventoryAnswer({ memoryDir, graph });
-  const parsed = parseImperative(line, lexicon ?? undefined);
+  const direct = await liveWorldAnswer(line, { world: adventure.world, memoryDir, env, graph, cache, lexicon, discourseHolder, actingSubject });
+  if (direct) return direct;
+  const addressed = await addressedLine(line, { memoryDir });
+  if (addressed) {
+    const readdressed = await liveWorldAnswer(addressed, { world: adventure.world, memoryDir, env, graph, cache, lexicon, discourseHolder, actingSubject });
+    if (readdressed) return readdressed;
+  }
+  return null; // a mid-game aside — the ordinary lanes answer, world untouched
+}
+
+/** One line against a LIVE world: inventory, an imperative command, then the
+ *  in-game asides. Null when the world has no answer for it, which is what
+ *  lets an ordinary mid-game question keep its own lane. Split out from the
+ *  lane itself so a line carrying a vocative can be re-offered here once,
+ *  stripped, without the two paths ever drifting apart. */
+async function liveWorldAnswer(line, { world, memoryDir, env, graph, cache, lexicon, discourseHolder, actingSubject }) {
+  if (INVENTORY_RE.test(line)) return inventoryAnswer({ memoryDir, graph, actingSubject });
+  const parsed = parseImperative(line, await worldAwareLexicon(memoryDir, lexicon));
   if (parsed) {
-    const bound = await bindPronouns(parsed, { discourseHolder, memoryDir });
+    const bound = await bindPronouns(parsed, { discourseHolder, memoryDir, actingSubject });
     if (bound.nudge) return bound.nudge;
     const cmd = bound.cmd;
-    const result = await runWorldCommand(cmd, { world: adventure.world, memoryDir, env, graph, cache });
+    const result = await runWorldCommand(cmd, { world, memoryDir, env, graph, cache, actingSubject });
     // The object a command SUCCESSFULLY named registers as a discourse referent
     // a later pronoun binds to — so "look lamp" then "examine it" reads the
     // lamp, and "talk to housekeeper" makes "him"/"her" the housekeeper. A miss
@@ -1387,11 +2303,15 @@ export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "
       note: `${result.note}; corrected ${cmd.corrected.map((c) => `"${c.from}" -> "${c.to}"`).join(", ")} before executing`,
     };
   }
-  const whereAside = await worldWhereAnswer(line, { memoryDir });
+  const whereAside = await worldWhereAnswer(line, { memoryDir, actingSubject });
   if (whereAside) return whereAside;
   const opennessAside = await worldOpennessAnswer(line, { memoryDir });
   if (opennessAside) return opennessAside;
-  const contextAside = await worldContextAnswer(line, { memoryDir });
+  const contextAside = await worldContextAnswer(line, { memoryDir, actingSubject });
   if (contextAside) return contextAside;
+  const knownFoodAside = await worldKnownFoodAnswer(line, { memoryDir, actingSubject });
+  if (knownFoodAside) return knownFoodAside;
+  const mentionAside = await worldMentionAnswer(line, { memoryDir, graph, actingSubject });
+  if (mentionAside) return mentionAside;
   return null; // a mid-game aside — the ordinary lanes answer, world untouched
 }