@polycode-projects/the-mechanical-code-talker 3.3.0 → 4.0.1

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";
@@ -185,11 +186,32 @@ 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]+)$/;
-// Where an eaten thing is placed. The world has no other way to say "out of
-// play", and no room can be called this, so the sentinel is the whole
-// convention: the readers below skip it exactly as they skip a hiding place.
+// 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
@@ -205,6 +227,47 @@ export function worldActionRows(rows) {
   });
 }
 
+// The predicates a played turn can write. Every one of them already exists
+// above as a private constant; this set is the one place they are gathered so
+// a caller outside this file can ask "is this fact part of the live world"
+// without learning each name. rdf:type and the display name earn their place
+// alongside the folded ones: a dug room and a dug object are minted mid-play,
+// and a reader that never receives their class or their plain name cannot draw
+// them at all.
+const MUD_STATE_PREDICATES = new Set([
+  ...PLACEMENT_PREDICATES,
+  ...POSITION_PREDICATES,
+  OPEN_PREDICATE,
+  MASS_PREDICATE,
+  KNOWS_ABOUT_PREDICATE,
+  DISPLAY_NAME_PREDICATE,
+  "rdf:type",
+]);
+
+/** Whether `predicate` carries live world state — where a thing stands, what
+ *  it weighs, whether it is open, what somebody knows, which way a room leads,
+ *  and the class and name a dug thing is minted with. The P2P sync filter
+ *  reads this to tell a fact a turn produced from the page chrome around it.
+ *  Pure. */
+export function isMudStatePredicate(predicate) {
+  const p = String(predicate || "");
+  return MUD_STATE_PREDICATES.has(p) || EXIT_PREDICATE_RE.test(p);
+}
+
+/** 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 newest mass, the exit map, and the turn counter (the
@@ -346,6 +409,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
@@ -375,7 +491,7 @@ export function roomAffordances(rows, state, here, actingSubject = "player") {
       actions.push(`examine ${subject}`);
       continue;
     }
-    if (isTyped(rows, subject, "person")) {
+    if (isCastMember(rows, state, subject)) {
       actions.push(`talk to ${subject}`);
       continue;
     }
@@ -465,13 +581,25 @@ async function writeWorldTurn(memoryDir, world, k, facts, cache) {
 // 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) => `mud:${character}:turn${k}`;
+const characterTestimonyTag = (character, k, voided = false) =>
+  `mud:${character}:turn${k}${voided ? VOIDED_TESTIMONY_SUFFIX : ""}`;
 
-async function appendTestimony(memoryDir, { knower, source, thing, k, cache }) {
+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),
+    provenance: characterTestimonyTag(source, k, voided),
   }]);
   if (cache) cache.rows = null;
 }
@@ -490,6 +618,98 @@ export async function recordExamined(memoryDir, { observer, thing, k, cache = nu
   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
@@ -523,6 +743,21 @@ const VIEW_EXCLUDED_PREDICATES = new Set([
   // 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);
@@ -573,7 +808,7 @@ export function worldDigestRows(rows, state, actingSubject = "player") {
   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" || place.object === CONSUMED_PLACE) continue;
+    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;
@@ -596,18 +831,18 @@ export function worldDigestRows(rows, state, actingSubject = "player") {
   // 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 === actingSubject || place.object === CONSUMED_PLACE) 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 consumed = new Set([...state.placements]
-    .filter(([, place]) => place.object === CONSUMED_PLACE)
+  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 (consumed.has(row.subject)) continue;                     // eaten, so out of the world entirely
+    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.
@@ -704,12 +939,160 @@ const OPPOSITE_DIRECTION = new Map([
   ["up", "down"], ["down", "up"],
 ]);
 
-// What a freshly dug room holds. The pool is placeholder scenery so a new room
-// is never bare; a later workstream swaps it for the garden's real food
-// content, which this module has no business naming.
+// 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 DIG_SPAWN_MAX = 2;
+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
@@ -741,6 +1124,55 @@ function freshRoomId(rows, here, direction) {
   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
@@ -783,11 +1215,12 @@ 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")) {
-    lines.push(`the ${objective} is what you're after — find it and carry it out of the house.`);
+    lines.push(`the ${objective} is what you're after — find it and carry it, and the adventure is won.`);
   }
   for (const thing of factObjects(rows, person, "mgx:knows-where")) {
     const place = state.placements.get(thing);
@@ -796,7 +1229,7 @@ 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, KNOWS_ABOUT_PREDICATE) };
+  return { lines, aboutTopics: currentKnowsAboutTopics(rows, person) };
 }
 
 /** The FOOD_CLASS things `person` durably knows about — from being told, or
@@ -807,7 +1240,7 @@ export function personKnowledgeLines(rows, state, person) {
  *  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 factObjects(rows, person, KNOWS_ABOUT_PREDICATE)
+  return currentKnowsAboutTopics(rows, person)
     .filter((thing) => objectClassChain(rows, thing).includes(FOOD_CLASS));
 }
 
@@ -833,6 +1266,410 @@ export function personRoomReport(rows, state, person, actingSubject = "player")
   return parts.join(" ");
 }
 
+// ---- state-changing verb handlers --------------------------------------------
+//
+// One function per state-changing verb (or per shared-precondition group of
+// verbs), keyed by name in STATE_VERB_HANDLERS below rather than chained as
+// if/else-if branches: adding a verb means adding a table entry, never
+// widening an existing conditional. Each handler takes the one `ctx` object
+// runWorldCommand builds once per call — cmd, the current fold, the taught
+// action family, and the shared `commit`/`noteFor` closures — so a handler
+// reads exactly like the branch it replaces, just lifted to its own name.
+
+async function handleGoVerb(ctx) {
+  const { cmd, rows, state, here, k, family, commit, noteFor, memoryDir, world, cache, actingSubject } = ctx;
+  const target = state.exits.get(here)?.get(cmd.direction);
+  if (!target) {
+    return answer(
+      `there's no exit ${cmd.direction} from the ${here}.`,
+      noteFor(`go — no mgx:has-exit-${cmd.direction} fact on ${here}; precondition declined by name`),
+      { 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: `${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; ${actingSubject} moves ${here} -> ${target}`,
+    `move through the world (now in the ${target})`,
+    target,
+  );
+}
+
+async function handleTakeVerb(ctx) {
+  const { rows, state, here, k, family, object, place, commit, noteFor, actingSubject } = ctx;
+  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 (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) {
+    return answer(
+      `the ${object} is fixed in place — it can't be taken.`,
+      noteFor(`take — ${object} is placed by ${place.predicate}, not portable; precondition declined by name`),
+      { miss: true },
+    );
+  }
+  if (place && place.predicate === "mgx:currently-in" && place.object === here) {
+    return answer(`you can't take the ${object}.`, noteFor("take — the object is one of the cast; declined"), { miss: true });
+  }
+  if (visibleRoomOf(object, { rows, state }) !== here) {
+    if (backgroundOnlyMention(rows, state, object)) {
+      return answer(
+        `the ${object} isn't something you can take — it's only mentioned in passing here, not a real prop in this scene.`,
+        noteFor(`take — ${object} is a background-only mention, never a placed object; declined honestly`),
+        { miss: true },
+      );
+    }
+    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: actingSubject }],
+    `you take the ${object}.`,
+    `take — the taught "take" family fired; ${object} is now carried`,
+    `carry the ${object}`,
+  );
+}
+
+async function handleDropOrGiveVerb(ctx) {
+  const { cmd, rows, state, here, k, family, object, commit, noteFor, actingSubject } = ctx;
+  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") {
+    return commit(
+      [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: here }],
+      `you drop the ${object} in the ${here}.`,
+      `drop — the taught "drop" family fired; ${object} rests in the ${here}`,
+      `set the ${object} down`,
+    );
+  }
+  const receiver = cmd.indirectObject;
+  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 }],
+    `you give the ${object} to the ${receiver}.`,
+    `give — the taught "give" family fired; the ${receiver} holds the ${object}`,
+    `hand the ${object} over`,
+  );
+}
+
+async function handleDigVerb(ctx) {
+  const { cmd, rows, state, here, k, commit, noteFor } = ctx;
+  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}`,
+  );
+}
+
+async function handleEatVerb(ctx) {
+  const { rows, state, here, k, object, commit, noteFor, memoryDir, cache, actingSubject } = ctx;
+  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}`,
+  );
+}
+
+async function handlePutVerb(ctx) {
+  const { cmd, rows, state, here, k, family, object, commit, noteFor, actingSubject } = ctx;
+  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, sharing one handler (all
+// three keys in STATE_VERB_HANDLERS below point here) because they share a
+// precondition: presence and container-ness stay hand-checked (visibility
+// gating, not a state precondition), the same visibleRoomOf check
+// examine/talk/take already use, not a hand-rolled duplicate. unlock's
+// instrument match stays fully hand-written below it too — it needs a
+// third, externally-supplied binding beyond subject/target, which this
+// retrofit does not attempt. open/close's lock-state and open/closed
+// checks, and their mgx:is-open write, are taught "fact-value" precond/
+// effect rows consulted through domain.mjs; only the hidden-contents
+// reveal (a variable-arity effect over a discovered set) stays hand-written
+// JS, since no shipped rule shape covers that either.
+async function handleContainerVerb(ctx) {
+  const { cmd, rows, state, here, k, object, place, commit, noteFor, ruleRows } = ctx;
+  if (visibleRoomOf(object, { rows, state }) !== here) {
+    return answer(`I don't see a ${object} here.`, noteFor(`${cmd.verb} — ${object} isn't in the ${here}; declined`), { miss: true });
+  }
+  if (!isContainer(rows, object)) {
+    return answer(`the ${object} doesn't open.`, noteFor(`${cmd.verb} — no mgx:is-container fact on ${object}; declined by name`), { miss: true });
+  }
+
+  if (cmd.verb === "open" || cmd.verb === "close") {
+    const domain = compileDomain(rows, ruleRows);
+    const taughtAction = domain.actions.find((a) => a.name === cmd.verb);
+    const effect = taughtAction?.effects.find((e) => e.predicate === OPEN_PREDICATE);
+    if (!effect) {
+      return answer(
+        `this world doesn't teach how ${cmd.verb === "open" ? "opening" : "closing"} changes the ${object}.`,
+        noteFor(`${cmd.verb} — the taught "${cmd.verb}" family carries no ${OPEN_PREDICATE} effect; honest decline`),
+        { miss: true },
+      );
+    }
+    const factState = containerDatatypeState(state, object);
+    const failed = taughtAction.preconds.find((p) => !precondHolds(p, ctx.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, ctx.actingSubject, object, domain);
+    const writeIsOpen = { subject: `${effSubject}@turn${k}`, predicate: effect.predicate, object: effect.value };
+
+    if (cmd.verb === "open") {
+      const revealed = [...state.placements]
+        .filter(([, p]) => p.predicate === "mgx:hidden-in" && p.object === object)
+        .map(([thing]) => thing)
+        .sort();
+      return commit(
+        [
+          writeIsOpen,
+          ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
+        ],
+        revealed.length
+          ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
+          : `you open the ${object}. It's empty.`,
+        `open — ${object} opens${revealed.length ? `, revealing ${revealed.join(", ")}` : ""} via the taught "open" family's effect`,
+        `open the ${object}`,
+      );
+    }
+    return commit(
+      [writeIsOpen],
+      `you close the ${object}.`,
+      `close — ${object} closes via the taught "close" family's effect`,
+      `close the ${object}`,
+    );
+  }
+
+  // unlock
+  if (place.predicate !== "mgx:stands-locked-in") {
+    return answer(`the ${object} isn't locked.`, noteFor("unlock — not locked; declined"), { miss: true });
+  }
+  if (!cmd.instrument) {
+    return answer(
+      `unlock the ${object} with what? Name the thing to use, e.g. "unlock the ${object} with the key".`,
+      noteFor("unlock — no instrument named; asked, never guessed"),
+      { miss: true },
+    );
+  }
+  const required = factObjects(rows, object, "mgx:unlocks-with")[0] ?? null;
+  if (!required) {
+    return answer(
+      `nothing in this world says what unlocks the ${object}.`,
+      noteFor(`unlock — no mgx:unlocks-with fact on ${object}; honest decline`),
+      { miss: true },
+    );
+  }
+  if (!carriedBy(state, cmd.instrument, ctx.actingSubject)) {
+    return answer(
+      `you're not carrying the ${cmd.instrument}.`,
+      noteFor(`unlock — the ${cmd.instrument} isn't carried; precondition declined by name`),
+      { miss: true },
+    );
+  }
+  if (cmd.instrument !== required) {
+    return answer(
+      `the ${cmd.instrument} doesn't fit the ${object}'s lock.`,
+      noteFor(`unlock — the taught instrument is ${required}, not ${cmd.instrument}; declined by name`),
+      { miss: true },
+    );
+  }
+  return commit(
+    [{ subject: `${object}@turn${k}`, predicate: "mgx:fixed-in", object: here }],
+    `you unlock the ${object} with the ${required}.`,
+    `unlock — the lock releases; ${object} now stands unlocked (still fixed) in the ${here}`,
+    `unlock the ${object}`,
+  );
+}
+
+// The data-driven verb table itself: every state-changing verb this engine
+// knows, mapped to the handler that runs it. A world's own taught action
+// family (checked before this table is ever consulted) decides whether the
+// verb exists in THIS world; this table decides which JS runs once it does.
+const STATE_VERB_HANDLERS = {
+  go: handleGoVerb,
+  take: handleTakeVerb,
+  drop: handleDropOrGiveVerb,
+  give: handleDropOrGiveVerb,
+  dig: handleDigVerb,
+  eat: handleEatVerb,
+  put: handlePutVerb,
+  open: handleContainerVerb,
+  close: handleContainerVerb,
+  unlock: handleContainerVerb,
+};
+
 export async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache, actingSubject = "player" }) {
   const memory = await loadMemory(memoryDir);
   const rows = readFactRows(memory);
@@ -854,6 +1691,13 @@ export 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, actingSubject });
@@ -903,7 +1747,7 @@ export 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
@@ -997,310 +1841,18 @@ export async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache
   const object = cmd.object;
   const place = object ? state.placements.get(object) ?? null : null;
 
-  if (cmd.verb === "go") {
-    const target = state.exits.get(here)?.get(cmd.direction);
-    if (!target) {
-      return answer(
-        `there's no exit ${cmd.direction} from the ${here}.`,
-        noteFor(`go — no mgx:has-exit-${cmd.direction} fact on ${here}; precondition declined by name`),
-        { miss: true },
-      );
-    }
-    return commit(
-      [{ 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; ${actingSubject} moves ${here} -> ${target}`,
-      `move through the world (now in the ${target})`,
-      target,
-    );
-  }
-
-  if (cmd.verb === "take") {
-    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 (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) {
-      return answer(
-        `the ${object} is fixed in place — it can't be taken.`,
-        noteFor(`take — ${object} is placed by ${place.predicate}, not portable; precondition declined by name`),
-        { miss: true },
-      );
-    }
-    if (place && place.predicate === "mgx:currently-in" && place.object === here) {
-      return answer(`you can't take the ${object}.`, noteFor("take — the object is one of the cast; declined"), { miss: true });
-    }
-    if (visibleRoomOf(object, { rows, state }) !== here) {
-      if (backgroundOnlyMention(rows, state, object)) {
-        return answer(
-          `the ${object} isn't something you can take — it's only mentioned in passing here, not a real prop in this scene.`,
-          noteFor(`take — ${object} is a background-only mention, never a placed object; declined honestly`),
-          { miss: true },
-        );
-      }
-      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: actingSubject }],
-      `you take the ${object}.`,
-      `take — the taught "take" family fired; ${object} is now carried`,
-      `carry the ${object}`,
-    );
-  }
-
-  if (cmd.verb === "drop" || cmd.verb === "give") {
-    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") {
-      return commit(
-        [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: here }],
-        `you drop the ${object} in the ${here}.`,
-        `drop — the taught "drop" family fired; ${object} rests in the ${here}`,
-        `set the ${object} down`,
-      );
-    }
-    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 });
-    }
-    return commit(
-      [{ subject: `${object}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:located-in", object: receiver }],
-      `you give the ${object} to the ${receiver}.`,
-      `give — the taught "give" family fired; the ${receiver} holds the ${object}`,
-      `hand the ${object} over`,
-    );
-  }
-
-  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 dug = freshRoomId(rows, here, direction);
-    const spawnCount = DIG_SPAWN_MIN + stableIndex(dug, DIG_SPAWN_MAX - DIG_SPAWN_MIN + 1);
-    const spawnedKinds = DIG_SPAWN_KINDS.slice(0, spawnCount);
-    const spawned = spawnedKinds.map((kind) => `${kind}-${dug}`);
-    return commit(
-      [
-        { subject: dug, predicate: "rdf:type", object: "room" },
-        { 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 already declares rdfs:subClassOf food (DIG_SPAWN_KINDS may
-        // carry one) needs its real class reachable here for isFood's own
-        // objectClassChain walk, or digging up "carrot-..." would still read
-        // as inedible scenery.
-        ...spawnedKinds.flatMap((kind, i) => ([
-          { subject: spawned[i], predicate: "rdf:type", object: kind },
-          { subject: spawned[i], predicate: "mgx:located-in", object: dug },
-        ])),
-      ],
-      spawned.length
-        ? `you dig ${direction} and open up a new room. In the loose earth: the ${spawned.join(", the ")}.`
-        : `you dig ${direction} and open up a new room. There's nothing in it but bare earth.`,
-      `dig — minted the room ${dug} with exits both ways (${direction} out, ${back} back)${spawned.length ? `, and ${spawned.length} object(s) in it` : ""}; 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;
-    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
-  // needs a third, externally-supplied binding beyond subject/target, which
-  // this retrofit does not attempt. open/close's lock-state and open/closed
-  // checks, and their mgx:is-open write, are now taught "fact-value"
-  // precond/effect rows consulted through domain.mjs below; only the
-  // hidden-contents reveal (a variable-arity effect over a discovered set)
-  // stays hand-written JS, since no shipped rule shape covers that either.
-  // Presence reuses visibleRoomOf (the SAME check examine/talk/take already
-  // use), not a hand-rolled duplicate: an earlier version of this check
-  // excluded mgx:currently-in outright, so a genuinely-present NPC (placed
-  // that way, not fixed-in/stands-locked-in) fell into "I don't see a X
-  // here" instead of reaching the isContainer check just below, which would
-  // have honestly said "the X doesn't open."
-  if (visibleRoomOf(object, { rows, state }) !== here) {
-    return answer(`I don't see a ${object} here.`, noteFor(`${cmd.verb} — ${object} isn't in the ${here}; declined`), { miss: true });
-  }
-  if (!isContainer(rows, object)) {
-    return answer(`the ${object} doesn't open.`, noteFor(`${cmd.verb} — no mgx:is-container fact on ${object}; declined by name`), { miss: true });
-  }
-
-  if (cmd.verb === "open" || cmd.verb === "close") {
-    const domain = compileDomain(rows, ruleRows);
-    const taughtAction = domain.actions.find((a) => a.name === cmd.verb);
-    const effect = taughtAction?.effects.find((e) => e.predicate === OPEN_PREDICATE);
-    if (!effect) {
-      return answer(
-        `this world doesn't teach how ${cmd.verb === "open" ? "opening" : "closing"} changes the ${object}.`,
-        noteFor(`${cmd.verb} — the taught "${cmd.verb}" family carries no ${OPEN_PREDICATE} effect; honest decline`),
-        { miss: true },
-      );
-    }
-    const factState = containerDatatypeState(state, object);
-    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, actingSubject, object, domain);
-    const writeIsOpen = { subject: `${effSubject}@turn${k}`, predicate: effect.predicate, object: effect.value };
-
-    if (cmd.verb === "open") {
-      const revealed = [...state.placements]
-        .filter(([, p]) => p.predicate === "mgx:hidden-in" && p.object === object)
-        .map(([thing]) => thing)
-        .sort();
-      return commit(
-        [
-          writeIsOpen,
-          ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
-        ],
-        revealed.length
-          ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
-          : `you open the ${object}. It's empty.`,
-        `open — ${object} opens${revealed.length ? `, revealing ${revealed.join(", ")}` : ""} via the taught "open" family's effect`,
-        `open the ${object}`,
-      );
-    }
-    return commit(
-      [writeIsOpen],
-      `you close the ${object}.`,
-      `close — ${object} closes via the taught "close" family's effect`,
-      `close the ${object}`,
-    );
-  }
-
-  // unlock
-  if (place.predicate !== "mgx:stands-locked-in") {
-    return answer(`the ${object} isn't locked.`, noteFor("unlock — not locked; declined"), { miss: true });
-  }
-  if (!cmd.instrument) {
+  const handler = STATE_VERB_HANDLERS[cmd.verb];
+  if (!handler) {
     return answer(
-      `unlock the ${object} with what? Name the thing to use, e.g. "unlock the ${object} with the key".`,
-      noteFor("unlock — no instrument named; asked, never guessed"),
+      `this world doesn't know how to run the verb "${cmd.verb}" yet.`,
+      noteFor(`${cmd.verb} — a taught family exists but no handler is wired for it; honest decline`),
       { miss: true },
     );
   }
-  const required = factObjects(rows, object, "mgx:unlocks-with")[0] ?? null;
-  if (!required) {
-    return answer(
-      `nothing in this world says what unlocks the ${object}.`,
-      noteFor(`unlock — no mgx:unlocks-with fact on ${object}; honest decline`),
-      { miss: true },
-    );
-  }
-  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`),
-      { miss: true },
-    );
-  }
-  if (cmd.instrument !== required) {
-    return answer(
-      `the ${cmd.instrument} doesn't fit the ${object}'s lock.`,
-      noteFor(`unlock — the taught instrument is ${required}, not ${cmd.instrument}; declined by name`),
-      { miss: true },
-    );
-  }
-  return commit(
-    [{ subject: `${object}@turn${k}`, predicate: "mgx:fixed-in", object: here }],
-    `you unlock the ${object} with the ${required}.`,
-    `unlock — the lock releases; ${object} now stands unlocked (still fixed) in the ${here}`,
-    `unlock the ${object}`,
-  );
+  return handler({
+    cmd, rows, state, here, k, family, families, ruleRows, object, place,
+    commit, noteFor, actingSubject, memoryDir, world, cache, graph, memory,
+  });
 }
 
 // A mid-game "where is X" aside. Optional trailing "now": the question means
@@ -1338,10 +1890,10 @@ async function worldWhereAnswer(line, { memoryDir, actingSubject = "player" }) {
       { miss: true, goal: `locate the ${thing}` },
     );
   }
-  if (place.object === CONSUMED_PLACE) {
+  if (OUT_OF_PLAY_PLACES.has(place.object)) {
     return answer(
-      `the ${thing} has been eaten — it's gone from the world.`,
-      `ADVENTURE — where-aside: ${thing} was eaten, so it has no place left to name`,
+      `${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}` },
     );
   }
@@ -1396,11 +1948,28 @@ 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. Covers the plural ("foods") and the "what do you know
-// about food" inversion alongside the base phrasing.
-const WORLD_KNOWN_FOOD_RE = /^(?:what\s+foods?\s+do\s+you\s+know\s+about|what\s+do\s+you\s+know\s+about\s+food)[?.!\s]*$/i;
+// 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
@@ -1410,12 +1979,24 @@ async function worldContextAnswer(line, { memoryDir, actingSubject = "player" })
   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(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
       ? answer(`you are in the ${here}.`, "ADVENTURE — where-am-I aside: the player's own room from the current world fold", { goal: "check where you are" })
@@ -1473,6 +2054,39 @@ async function worldKnownFoodAnswer(line, { memoryDir, actingSubject = "player"
   );
 }
 
+// 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);
@@ -1577,6 +2191,78 @@ async function bindPronouns(cmd, { discourseHolder, memoryDir, actingSubject = "
   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 ----------------------------------------------------------------
 
 /**
@@ -1644,13 +2330,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",
     };
   }
+  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, lexicon ?? undefined);
+  const parsed = parseImperative(line, await worldAwareLexicon(memoryDir, lexicon));
   if (parsed) {
     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, actingSubject });
+    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
@@ -1682,5 +2384,7 @@ export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "
   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
 }