@polycode-projects/the-mechanical-code-talker 3.3.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";
@@ -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,20 @@ 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 newest mass, the exit map, and the turn counter (the
@@ -346,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
@@ -375,7 +464,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 +554,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 characterTestimonyTag = (character, k) => `mud:${character}:turn${k}`;
+const VOIDED_TESTIMONY_SUFFIX = ":gone";
 
-async function appendTestimony(memoryDir, { knower, source, thing, k, cache }) {
+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),
+    provenance: characterTestimonyTag(source, k, voided),
   }]);
   if (cache) cache.rows = null;
 }
@@ -490,6 +591,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 +716,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 +781,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 +804,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 +912,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 +1097,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,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")) {
@@ -796,7 +1202,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 +1213,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));
 }
 
@@ -854,6 +1260,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 +1316,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
@@ -1006,6 +1419,21 @@ export 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: `${actingSubject}@turn${k}`, predicate: familyEffectPredicate(family) ?? "mgx:currently-in", object: target }],
       `you go ${cmd.direction}. Now in the ${target}.`,
@@ -1063,8 +1491,8 @@ export 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 }],
@@ -1091,29 +1519,75 @@ export async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache
         { 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 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}`);
+    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 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.
+        // 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 })),
+        ] : []),
       ],
-      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}`,
+      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}`,
     );
   }
@@ -1144,6 +1618,11 @@ export async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache
     }
     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) },
@@ -1338,10 +1817,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 +1875,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 +1906,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 +1981,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 +2118,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 +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",
     };
   }
+  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 +2311,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
 }