@polycode-projects/the-mechanical-code-talker 2.6.0 → 2.7.0

package/src/services/chat.mjs

@@ -50,6 +50,7 @@ import { REFERENCE_PACK_NAME, cleanMissReferenceTerm, renderReferenceAnswer, ref
 import { getReferencePackProvider } from "../adapters/corpus/reference-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
+import { adventureTurn } from "./adventure.mjs";
 
 // Composition: the chat surface supplies the domain parser's default lemma/POS
 // adapter (the browser bundle's ask-nlp stub carries no factory, so this is a
@@ -312,7 +313,7 @@ export const COMMANDS = {
   signature:  { tool: "tmct_signature",    arg: "symbol",  help: "a symbol's signature only" },
   members:    { tool: "tmct_members",      arg: "class",   help: "the methods/attributes of a class" },
   subclasses: { tool: "tmct_subclasses",   arg: "class",   help: "the subclasses of a class" },
-  impact:     { tool: "tmct_impact",       arg: "module",  help: "what a change to this module reaches (impact closure)" },
+  impact:     { tool: "tmct_impact",       arg: "module",  help: "what a change to this module or symbol reaches (impact closure)" },
   callers:    { tool: "tmct_callers",      arg: "symbol",  help: "functions that call this symbol" },
   callees:    { tool: "tmct_callees",      arg: "symbol",  help: "functions this symbol calls" },
   tests:      { tool: "tmct_tests_for",    arg: "symbol",  help: "the tests covering this symbol" },
@@ -1554,7 +1555,13 @@ function conversationalTurn(line, ctx) {
     }
   }
   {
-    const thanksHit = closedOrCollapsed(q, THANKS, THANKS_COLLAPSED) || (OK_ACK.has(q) ? q : null);
+    // "ok cool thanks" — an ack RUN in front of a bare thanks word: the ack
+    // preamble peel (the same closed frames every other surface uses) leaves
+    // the thanks word standing, so the stacked form lands where its parts do
+    // instead of on the orientation blurb.
+    const ackPeeled = applyPreambleFrames(q);
+    const thanksHit = closedOrCollapsed(q, THANKS, THANKS_COLLAPSED) || (OK_ACK.has(q) ? q : null)
+      || (ackPeeled !== q && (THANKS.has(ackPeeled) || OK_ACK.has(ackPeeled)) ? ackPeeled : null);
     if (thanksHit) {
       note(ctx.trace, "goal: casual/social — acknowledgement, no graph intent");
       note(ctx.trace, `lane: conversational — thanks/acknowledgement (${OK_ACK.has(q) ? "OK_ACK" : "THANKS"} closed set${thanksHit === q ? "" : ", elongation-collapsed"})`);
@@ -1812,7 +1819,10 @@ const QUESTION_LEAD_RE = /^(?:what|who|which|where|when|why|how|is|are|do|does|d
  *  not a storage decision). Used by runAsk's relaxedTeachCollision guard (below)
  *  to recognize when a query the ask engine "answered" via relaxation was
  *  actually a teach-shaped sentence, not a real question. */
-const DECLARATIVE_KIND_OF_RE = /^(?:every\s+|each\s+|all\s+|a\s+|an\s+)?[\w-]+(?:\s+[\w-]+)?\s+(?:is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?[\w-]+[.!]*$/i;
+// The object takes 1–2 tokens: the shipped hanoi recipe's own "a disk is a
+// kind of game piece" is exactly this shape, and a single-token object left
+// its sentence-pair line unsplittable (the split gate reads this regex).
+const DECLARATIVE_KIND_OF_RE = /^(?:every\s+|each\s+|all\s+|a\s+|an\s+)?[\w-]+(?:\s+[\w-]+)?\s+(?:is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?[\w-]+(?:\s+[\w-]+)?[.!]*$/i;
 /** A bare wh-word token, tested one word at a time against `hasMidSentenceInterrogative`'s
  *  own tokenization below — never re-anchored, so it matches at ANY word position. */
 const MID_SENTENCE_WH_RE = /^(?:which|who|what|where|when|why|how)$/i;
@@ -1839,6 +1849,11 @@ async function hasMidSentenceInterrogative(text) {
     if (MID_SENTENCE_WH_RE.test(words[i].replace(/^[.,!?;:'"]+|[.,!?;:'"]+$/g, ""))) whIdx.push(i);
   }
   if (!whIdx.length) return false;
+  // A wh-word opening a NEW CLAUSE ("I'm new here, what should I read
+  // first") is an interrogative clause, full stop — no POS evidence needed:
+  // the clause boundary (the preceding word's trailing comma/semicolon) is
+  // itself the signal, and it holds with or without the wink adapter.
+  if (whIdx.some((i) => /[,;:]["')]*$/.test(words[i - 1]))) return true;
   try {
     const { nlpAdapter } = await import("../adapters/ask-nlp.mjs");
     const adapter = nlpAdapter();
@@ -2145,6 +2160,7 @@ async function repairSharesLemma(from, to) {
  *    the two-word object; single-word objects stay with the ACE path. */
 async function bareTaxonomyTeach(line, { memoryDir, sessionId }) {
   if (!memoryDir || QUESTION_LEAD_RE.test(line)) return null;
+  if (/\?\s*$/.test(String(line).trim())) return null; // a question never writes
   const inst = line.match(INSTANCE_TYPE_TEACH_RE);
   if (inst) {
     return teachFact(memoryDir, sessionId, {
@@ -2191,6 +2207,11 @@ const ACTION_SIGNATURE_ASK_RE = new RegExp(
 const PLAN_SOLVE_RE = /^(?:solve\s+it|solve\s+(?:the\s+)?(?:towers?\s+of\s+hanoi|hanoi|puzzle|game|river\s+crossing|this)|plan\s+the\s+moves|how\s+do\s+i\s+get(?:\s+from\s+here)?\s+to\s+the\s+goal)[?.!\s]*$/i;
 const LEGAL_MOVES_RE = /^what\s+moves\s+are\s+legal(?:\s+now)?[?.!\s]*$/i;
 const PLAN_NEXT_RE = /^(?:next|next\s+move|go\s+on|continue)[.!?\s]*$/i;
+// Plan-navigation gestures beyond "next": the unwind ask (not supported —
+// answered honestly, never the blurb) and the goal drop (a real action on the
+// session's plan slot; taught board facts are never touched by it).
+const PLAN_UNDO_RE = /^(?:undo(?:\s+(?:that|it|the\s+last\s+move))?|go\s+back(?:\s+(?:one|a)\s+move)?|take\s+(?:that|it)\s+back|revert(?:\s+(?:that|it|the\s+last\s+move))?)[.!?\s]*$/i;
+const PLAN_FORGET_GOAL_RE = /^(?:forget|drop|clear|abandon|cancel|scrap)\s+(?:the\s+|that\s+|my\s+)?(?:goal|plan)[.!?\s]*$/i;
 // The imperative voicing of a universal goal ("get all the disks onto peg-c"):
 // like the verbless frame it names no board verb, so planLaneAnswer reads that
 // off the taught locative facts. Captures a quantifier, a (possibly plural)
@@ -2767,8 +2788,12 @@ const GENERAL_VERB_DETERMINER_TEACH_RE = new RegExp(
 /** The quantified possession teach ("every dog has fur", "all dogs have
  *  tails") — the closed has/have verb pins the split the way the preposition
  *  pins GENERAL_VERB_DETERMINER_TEACH_RE's, so a universal quantifier can
- *  lead without any verb-position guessing. */
-const QUANTIFIED_HAS_TEACH_RE = /^(?:every|each|all)\s+([\w'-]+)\s+(?:has|have)\s+(.+?)[.!?]*$/i;
+ *  lead without any verb-position guessing. The quantifier is captured:
+ *  "every"/"each" take a grammatically SINGULAR noun, so only "all" folds
+ *  the plural — the naive fold clipped an s-final singular ("every lens" was
+ *  stored, and cited, as "len"). */
+const QUANTIFIED_HAS_TEACH_RE = /^(every|each|all)\s+([\w'-]+)\s+(?:has|have)\s+(.+?)[.!?]*$/i;
+const quantifiedHasSubject = (m) => (/^all$/i.test(m[1]) ? singularizeSurface(m[2]) : m[2]);
 /** Verbs owned by an earlier, more specific recognizer in this lane — is/are
  *  (class-membership/property, above) and owns/maintains (ownership, above).
  *  generalVerbTeach declines outright on these so it can never race a more
@@ -2915,9 +2940,9 @@ async function generalVerbTeach(payload) {
   if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) {
     const quantHas = p.match(QUANTIFIED_HAS_TEACH_RE);
     if (quantHas) {
-      subjectRaw = singularizeSurface(quantHas[1]);
+      subjectRaw = quantifiedHasSubject(quantHas);
       verbRaw = "has";
-      objectRaw = quantHas[2];
+      objectRaw = quantHas[3];
     } else {
       const det = p.match(GENERAL_VERB_DETERMINER_TEACH_RE);
       if (!det) return null; // not a bare-name subject, and no preposition to pin the verb
@@ -3288,7 +3313,13 @@ function habitualGroundingHintText(line, habitual) {
  *  grammatical category error regardless of the verb — keeping the guard
  *  ahead of every teach recognizer (copula AND general-verb alike) the same
  *  way it already stood ahead of teachSuggestion/unknownSubjectFallback. */
-const TEACH_PRONOUNS = Object.freeze(["you", "i", "it", "they", "he", "she", "we"]);
+// The contracted forms ("i'm new here …") join the bare pronouns: a leading
+// pronoun+copula contraction is exactly as invalid a fact subject, and it
+// slipped past this guard into the general-verb mint as a one-token "i'm".
+const TEACH_PRONOUNS = Object.freeze([
+  "you're", "i'm", "it's", "they're", "he's", "she's", "we're",
+  "you", "i", "it", "they", "he", "she", "we",
+]);
 const TEACH_PRONOUN_RE = new RegExp(`^(?:every\\s+|each\\s+|all\\s+|some\\s+|a few\\s+|a\\s+|an\\s+)?(${TEACH_PRONOUNS.join("|")})\\s+\\S+`, "i");
 /** The same closed set, read as a whole-word membership test: a pronoun is no
  *  more a legal fact subject when a reader LIFTS one out of a prior answer than
@@ -3311,8 +3342,61 @@ const RETRACT_NOT_A_RE = /^(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:(?:is|are)
  *  (unwrapped) sentence, unlike RETRACT_NOT_A_RE above which is tried against
  *  the remember-wrapped surface too. */
 const RETRACT_FORGET_RE = /^forget\s+(?:that\s+)?(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
+/** The locative teach shape ("disk-1 rests on peg-b") — the board-fact
+ *  surface, shared by the mid-plan write guard and the locative forget. */
+const BOARD_TEACH_LOCATIVE_RE = new RegExp(`^([\\w-]+)\\s+([a-z]+)s\\s+(${PREP_SRC})\\s+([\\w-]+)$`, "i");
+/** "forget that disk-1 rests on peg-b" — the locative twin of
+ *  RETRACT_FORGET_RE: a plain minted mgx:<verb>-<prep> fact has no entailment
+ *  cascade, so removing the one row IS the retraction. */
+const RETRACT_FORGET_LOCATIVE_RE = new RegExp(`^forget\\s+(?:that\\s+)?([\\w-]+)\\s+([a-z]+)s\\s+(${PREP_SRC})\\s+([\\w-]+)$`, "i");
+
+/** The closed related-to pair — "X relates to Y" / "X is related to Y" —
+ *  minted onto mgx:relatedTo (the SKOS view's skos:related source), so the
+ *  synonym/related lane has a teach phrasing. Single-token subject, 1–2
+ *  token object, articles tolerated on both. */
+const RELATED_TO_TEACH_RE = /^(?:a\s+|an\s+|the\s+)?([\w-]+)\s+(?:relates\s+to|is\s+related\s+to)\s+(?:a\s+|an\s+|the\s+)?([\w-]+(?:\s+[\w-]+)?)$/i;
+
+/** NEGATIVE UNIVERSAL — "no X is a Y" / "no Xs are Ys": a class-level
+ *  exclusion, stored as `X owl:disjointWith Y` on the RESOLVED class pair.
+ *  The ACE grammar already mints exactly this triple when both words sit in
+ *  its closed lexicon; this frame is the SAME mint for the words outside it,
+ *  so the sentence never falls through to the unknown-subject fallback, which
+ *  would warehouse it under the subject-literal "no X" — a spelling no
+ *  reader (the cax-dw veto included) ever consults, leaving a later chain
+ *  proof free to certify the very thing the user excluded. Single-token
+ *  sides only (the disjointness readers resolve class TERMS, not phrases);
+ *  a plural surface folds to the singular the ⊑ facts use. */
+const NEGATIVE_UNIVERSAL_TEACH_RE = /^no\s+([\w-]+)\s+(is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)[.!]*$/i;
+
+/** The mint (or the reflexive refusal) for a NEGATIVE_UNIVERSAL_TEACH_RE
+ *  match, shared by teachLane and the ACE-path reflexive gate: null when the
+ *  sentence isn't this shape. */
+async function negativeUniversalTeach(sentence, { memoryDir, sessionId }) {
+  const m = String(sentence || "").trim().match(NEGATIVE_UNIVERSAL_TEACH_RE);
+  if (!m || !memoryDir) return null;
+  const plural = m[2].toLowerCase() === "are";
+  const subject = plural ? singularizeSurface(m[1]) : m[1];
+  const object = plural ? singularizeSurface(m[3]) : m[3];
+  if (subject.toLowerCase() === object.toLowerCase()) {
+    return {
+      text: `I can't store "no ${subject} is a ${object}" — every ${subject} is a ${subject} by definition, so that exclusion contradicts itself. Nothing was stored.`,
+      via: "teach-miss", miss: true,
+    };
+  }
+  const { DISJOINT_PREDICATE } = await import("../domain/syllogise.mjs");
+  const stored = await teachFact(memoryDir, sessionId, {
+    subject, predicate: DISJOINT_PREDICATE, object,
+  });
+  if (!stored) {
+    return {
+      text: `I couldn't store the exclusion "no ${subject} is a ${object}" — say it with single-word class names ("no dog is a mammal") and I'll remember it as a disjointness.`,
+      via: "teach-miss", miss: true,
+    };
+  }
+  return stored;
+}
 
-async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null }) {
+async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null }) {
   // A closed discourse-marker preamble ahead of a teach sentence ("howdy
   // pardner, remember that TaskController is fragile") would otherwise
   // corrupt TEACH_RE's own match, so strip it first. applyPreambleFrames is
@@ -3321,6 +3405,17 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // topic-switch/hedge — match ordinary teach phrasing), so this is purely
   // additive.
   const rawInput = applyPreambleFrames(String(query).trim());
+  // A trailing "?" is an unambiguous "this is a question" marker, and a
+  // question must never reach the write boundary — the ESL missing-"does"
+  // yes/no ("dog have tail?") is a bare declarative to every shape gate in
+  // this lane, and it STORED, at teach trust, until this gate existed. The
+  // whole lane stands down; the ask cascade owns question marks.
+  if (/\?\s*$/.test(rawInput)) return null;
+  // A typo'd interrogative ("wat is a hrose") reads as a declarative to every
+  // anchored QUESTION_LEAD_RE gate below — run the SAME closed misspelling
+  // repair ask.mjs's typo tolerance applies BEFORE classifying, so the
+  // question goes back to the question side instead of a teach suggestion.
+  if (QUESTION_LEAD_RE.test(correctMisspellings(rawInput))) return null;
   const m = rawInput.match(TEACH_RE);
   const wrappedInput = m ? m[1].trim() : null;
   // Refuse an existential BEFORE any frame below can read it as a universal:
@@ -3406,7 +3501,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (memoryDir && !QUESTION_LEAD_RE.test(conjSrc) && /\s+and\s+/i.test(conjSrc)
     && !(await hasMidSentenceInterrogative(conjSrc))) {
     const rewrap = (half) => (wrapped != null ? `remember that ${half}` : half);
-    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache });
+    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache, planHolder });
     const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
     const shared = conjSrc.match(/^(.+?)\s+and\s+((?:is|are|has|have|can)\b.+)$/i);
     const sharedSubject = shared ? shared[1].match(/^(.+?)\s+(?:is|are|has|have|can)\b/i)?.[1]?.trim() : null;
@@ -3503,6 +3598,32 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const retractNotMatch = memoryDir && !QUESTION_LEAD_RE.test(retractSrc) && !retractSrcMidQuestion
     ? retractSrc.match(RETRACT_NOT_A_RE) : null;
   const forgetSrc = raw.replace(/[.!?]+\s*$/, "");
+  // The locative forget rides beside the subclass one, on the same raw
+  // surface: find the one stored row and remove it — no cascade exists for a
+  // plain minted mgx:<verb>-<prep> fact. A no-match falls through unchanged.
+  const forgetLocative = memoryDir && !QUESTION_LEAD_RE.test(forgetSrc)
+    ? forgetSrc.match(RETRACT_FORGET_LOCATIVE_RE) : null;
+  if (forgetLocative) {
+    try {
+      const { loadMemory: loadMemForLoc, readFactRows: readRowsForLoc, removeFacts: removeFactsForLoc, normFactTerm: normTermForLoc } = await import("../adapters/memory/core.mjs");
+      const locPredicate = foldPrepositionIntoPredicate(
+        await generalVerbPredicate(forgetLocative[2].toLowerCase()),
+        `${forgetLocative[3].toLowerCase()} ${forgetLocative[4]}`,
+      ).predicate;
+      const locSubject = normTermForLoc(forgetLocative[1]);
+      const locObject = normTermForLoc(forgetLocative[4]);
+      const row = readRowsForLoc(await loadMemForLoc(memoryDir))
+        .find((r) => r.subject === locSubject && r.predicate === locPredicate && r.object === locObject);
+      if (row?.id) {
+        await removeFactsForLoc(memoryDir, [row.id]);
+        return {
+          text: `noted — forgotten: "${locSubject} ${predicatePhrase(locPredicate)} ${locObject}" is no longer stored.`,
+          via: "retract", miss: false,
+        };
+      }
+      // nothing stored under that triple — fall through to the ordinary cascade
+    } catch { /* store unavailable — fall through */ }
+  }
   const retractForgetMatch = !retractNotMatch && memoryDir && !QUESTION_LEAD_RE.test(forgetSrc)
     ? forgetSrc.match(RETRACT_FORGET_RE) : null;
   const retractMatch = retractNotMatch || retractForgetMatch;
@@ -3596,6 +3717,45 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     }
   }
 
+  // MID-PLAN BOARD TEACH — a locative fact about a piece the LIVE plan's
+  // moves touch is declined naming the plan, never accepted-then-ignored:
+  // the plan's board rides @step snapshots, so a base-fact write here would
+  // be confirmed ("noted — remembered") and then contradicted by the very
+  // next "next". Scoped to the locative teach shape over the plan's own
+  // pieces; every other teach (new vocabulary, new pieces, rules) is
+  // untouched, and with no live plan nothing changes at all.
+  {
+    const livePlan = planHolder?.state && !planHolder.state.done
+      && Array.isArray(planHolder.state.actions) && planHolder.state.actions.length
+      ? planHolder.state : null;
+    const boardSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
+    const board = livePlan ? boardSrc.match(BOARD_TEACH_LOCATIVE_RE) : null;
+    if (board && memoryDir && !QUESTION_LEAD_RE.test(boardSrc)) {
+      const { normFactTerm } = await import("../adapters/memory/core.mjs");
+      const planPieces = new Set(livePlan.actions.flatMap((a) => [normFactTerm(a.subject), normFactTerm(a.target)]));
+      if (planPieces.has(normFactTerm(board[1])) || planPieces.has(normFactTerm(board[4]))) {
+        const at = livePlan.cursor > 0 ? `step ${livePlan.cursor} of ${livePlan.actions.length}` : `0 of ${livePlan.actions.length} moves made`;
+        return {
+          text: `a plan is live (${at}, toward: ${livePlan.goalText ?? livePlan.goalTexts?.join("; ") ?? "the held goal"}) — I won't change the board mid-plan: the plan's moves write board@step snapshots, and "${board[0]}" would sit under them, silently contradicted by the next move. Say "forget the goal" first, re-teach the board, then "solve it" to replan.`,
+          via: "teach-miss", miss: true,
+        };
+      }
+    }
+  }
+
+  // NEGATIVE UNIVERSAL — "no X is a Y": the class-pair disjointness mint (or
+  // the reflexive refusal). Tried on both surfaces, ahead of every frame that
+  // could otherwise read "no X" as a subject literal — see
+  // NEGATIVE_UNIVERSAL_TEACH_RE's own docblock.
+  {
+    const negUniversalSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
+    if (memoryDir && !QUESTION_LEAD_RE.test(negUniversalSrc)
+      && !(await hasMidSentenceInterrogative(negUniversalSrc))) {
+      const negUniversal = await negativeUniversalTeach(negUniversalSrc, { memoryDir, sessionId });
+      if (negUniversal) return negUniversal;
+    }
+  }
+
   // OWNERSHIP — "<Name> owns/maintains <X>", bare or remember-wrapped. The bare
   // form is double-gated: no interrogative lead, PLUS either side spelling a
   // Capitalized token — so the "who owns <X>" READ question and ordinary
@@ -3632,6 +3792,19 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     if (stored) return stored;
   }
 
+  // RELATED-TO — the closed pair "X relates to Y" / "X is related to Y"
+  // maps onto mgx:relatedTo, the SAME predicate the SKOS view reads as
+  // skos:related — giving the synonym/related lane its natural teach
+  // phrasing. Without this the general-verb mint stored a preposition-glued
+  // object ("cat mgx:relate 'to milk'") no reader could ever match.
+  const relatedTo = ownSrc.match(RELATED_TO_TEACH_RE);
+  if (relatedTo && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: relatedTo[1], predicate: "mgx:relatedTo", object: relatedTo[2],
+    });
+    if (stored) return stored;
+  }
+
   // RELATIONAL FACT — "<Name> is the <role> of <Name>". Grouped with the
   // other relational/possessive teach shapes just above (both ownership
   // forms), tried on the SAME ownSrc, unconditionally
@@ -4047,8 +4220,12 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     const detLed = raw.match(GENERAL_VERB_DETERMINER_TEACH_RE);
     const quantHasLed = detLed ? null : raw.match(QUANTIFIED_HAS_TEACH_RE);
     const subjectWord = detLed ? detLed[1].split(/\s+/).pop()
-      : (quantHasLed ? singularizeSurface(quantHasLed[1]) : raw.match(/^([\w'-]+)/)?.[1]);
-    if (subjectWord && (await subjectIsNounOrPropn(subjectWord))) {
+      : (quantHasLed ? quantifiedHasSubject(quantHasLed) : raw.match(/^([\w'-]+)/)?.[1]);
+    // The quantifier lead ("every … has …") is itself a strong declarative
+    // signal, so it overrides the single-token POS gate: a noun that doubles
+    // as a verb ("every overbid has a gouger" — wink tags "overbid" VERB)
+    // used to be a SILENT no-op and a later miss.
+    if (subjectWord && (quantHasLed || (await subjectIsNounOrPropn(subjectWord)))) {
       // A PLURAL explicit-capability surface ("wrens can hum") whose
       // SINGULAR is a grounded term stores under the singular first — the
       // spelling the grounding fact and every query-side variant fold use —
@@ -4430,10 +4607,19 @@ async function moduleOrientLane(query, { graph }) {
 }
 
 async function metaLane(query, { graph, memoryDir, last = null, templates = null, vocabHint = null, focus = null }) {
+  // Preamble-peeled twin of `q`: a self-intro/greeting lead ("I'm new here,
+  // what should I read first") wraps exactly the orientation questions this
+  // lane owns, and the anchored META_ORIENT_RE can't see past it. Peeling
+  // with the SAME closed frames every other surface uses is purely additive.
+  const peeled = applyPreambleFrames(String(query).trim()).toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ").trim();
   const q = String(query).trim().toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
   if (WHAT_KNOW_RE.test(q) || q === "what have you learned" || q === "what have you learnt") {
     return { text: await memorySummary(memoryDir, graph), via: "meta" };
   }
+  if (peeled !== q && META_ORIENT_RE.test(peeled)) {
+    const text = orientationText(graph, templates, vocabHint);
+    return { text: last?.answer === text ? META_ORIENT_REPEAT_ONELINER : text, via: "meta" };
+  }
   if (META_ORIENT_RE.test(q)) {
     // This META_ORIENT_RE branch is a SEPARATE route to the same class of
     // full-blurb text as the isConversational-triggered orientation branch
@@ -5138,6 +5324,9 @@ function renderFactLine(f) {
   // SOLID corpus facts are background DATA — present the relation plainly, cited
   // to its source, never "i learned: …" (a first-person claim over corpus data).
   if (f.provenance.includes("corpus:")) return `${factPhrase(f)}${cite}`;
+  // Reference-pack facts are the same class of cited data — the "i learned:"
+  // frame read as a definition-less non-answer on the re-ask.
+  if (f.provenance.includes("reference:")) return `${factPhrase(f)}${cite}`;
   return `i learned: ${factPhrase(f)}${cite}`;
 }
 
@@ -6382,12 +6571,24 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     );
     const hit = hasHit(subj);
     if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
-    const isaStep = facts.find((f) => ISA_PREDICATES.has(f.predicate) && subj.has(f.subject));
-    if (isaStep) {
-      const lifted = hasHit(factTermVariants(normFactTerm, isaStep.object));
+    // The ⊑-lift walks a BOUNDED chain (not one hop): "every canine has fur"
+    // + "every dog is a canine" + "rex is a dog" answers "does rex have fur"
+    // citing all three premises. One chain, first parent per level (the
+    // 1-hop behavior generalized), cycle-safe, and the bound keeps a deep
+    // taught taxonomy from turning a yes/no into a graph scan.
+    let liftFrontier = subj;
+    const liftChain = [];
+    const liftSeen = new Set();
+    for (let hop = 0; hop < 4; hop += 1) {
+      const step = facts.find((f) => ISA_PREDICATES.has(f.predicate) && liftFrontier.has(f.subject) && !liftSeen.has(f.object));
+      if (!step) break;
+      liftSeen.add(step.object);
+      liftChain.push(step);
+      const lifted = hasHit(factTermVariants(normFactTerm, step.object));
       if (lifted) {
-        return { text: `yes — ${renderFactLine(isaStep)}; ${renderFactLine(lifted)}`, replace: true };
+        return { text: `yes — ${[...liftChain.map(renderFactLine), renderFactLine(lifted)].join("; ")}`, replace: true };
       }
+      liftFrontier = factTermVariants(normFactTerm, step.object);
     }
     return null;
   }
@@ -7084,6 +7285,17 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         const directSup = inheritsChain(graph, ent.id)
           .find((sup) => [...factTermVariants(normFactTerm, sup.label)].some((v) => directObjVariants.has(v)));
         if (directSup) return { text: `yes — the code graph says ${ent.label} inherits ${directSup.label}.`, replace: true };
+        // CONVERSE NUDGE, code-graph half: the taught-fact lane already names
+        // a stored converse instead of the bare wall; the graph's inherits
+        // relation deserves the same. Still a miss — the converse holding
+        // says nothing about the asked direction, and a "no" would guess.
+        const objEnt = await resolveEntity(graph, stripTrailingDiscourseTag(directIsaAsk[2]));
+        if (objEnt && inheritsChain(graph, objEnt.id).some((sup) => sup.id === ent.id)) {
+          return {
+            text: `I can't confirm that — the code graph's stored direction runs the other way: ${objEnt.label} inherits ${ent.label}. An inheritance doesn't reverse.`,
+            replace: true, miss: true,
+          };
+        }
       }
     }
   }
@@ -8552,8 +8764,12 @@ function discourseRewrite(query, last) {
     // question — a code drill-down chain keeps the code-ish NAME_TOKEN rule
     // below unchanged.
     const articled = cand.match(/^(?:an?|the)\s+([a-z][\w-]*)$/i);
+    // A what-else EXPANSION turn is still a vocabulary turn — the swap has to
+    // survive it, or "tell me about a dog" / "what else can dogs do" / "and a
+    // cat" strands the third turn on the blurb.
     const prevWasVocab = last?.query
-      && (BARE_WHATIS_RE.test(String(last.query)) || vagueTouchTermOf(String(last.query)));
+      && (BARE_WHATIS_RE.test(String(last.query)) || vagueTouchTermOf(String(last.query))
+        || /^(?:what|anything)\s+else\b/i.test(String(last.query).trim()));
     if (articled && prevWasVocab) return `what is a ${singularizeSurface(articled[1])}`;
     if (!NAME_TOKEN_RE.test(cand)) return null;
     newSubj = cand;
@@ -9040,6 +9256,11 @@ async function describeGrainRescue(graph, term) {
 }
 
 async function describeWrapperAnswer(query, { config, source, focus, graph, tel = null }) {
+  // The detailed-summary/overview phrasings belong to the completions rescue
+  // (4e, tried right after this lane) — applyPreambleFrames' show/give-me
+  // bridge would otherwise rewrite them into a describe this lane claims
+  // with a worse answer.
+  if (DETAILED_HOW_WORKS_RE.test(String(query || "").trim()) || DETAILED_OVERVIEW_RE.test(String(query || "").trim())) return null;
   // This lane is the LAST-RESORT rescue (4d), tried after every earlier lane
   // declines. applyPreambleFrames + correctMisspellings run first, the same
   // general-purpose normalization every other lane in this file applies,
@@ -9067,6 +9288,24 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
       // — resolveSymbol (codegraph.mjs) has no component/overlap tier at all,
       // so a leading "the"/"a"/"an" is pure noise here, safe to strip.
       term = term.replace(/^(?:the|a|an)\s+/i, "");
+      // The stale-modifier residue guard, carried into this lane — the last
+      // of the 1.4 family without it: "describe the old Task class" must not
+      // return the Task card with "old" silently swallowed. The resolver's
+      // own unplaced-words verdict decides; a term it reads fully proceeds.
+      if (graph && /\s/.test(term)) {
+        try {
+          const { resolveObject } = await import("../domain/ask.mjs");
+          const guarded = resolveObject(graph, term);
+          if (guarded?.unplacedWords?.length) {
+            const words = guarded.unplacedWords;
+            const quoted = words.map((w) => `"${w}"`).join(" and ");
+            return {
+              text: `nothing matching "${term}" is in the index. ${quoted} name${words.length === 1 ? "s" : ""} nothing here, and reading past ${words.length === 1 ? "it" : "them"} would answer a different question.${guarded.nearestLabel ? ` Did you mean ${guarded.nearestLabel}?` : ""}`,
+              miss: true,
+            };
+          }
+        } catch { /* resolver unavailable — the ordinary dispatch decides */ }
+      }
     }
   }
   try {
@@ -9217,6 +9456,20 @@ async function completionsRescueAnswer(query, { memoryDir, graph }) {
   if (!term) return null;
   term = term.replace(/^(?:the|a|an)\s+/i, "").trim();
   if (!term) return null;
+  // The APP-DEICTIC subject ("how this app works") names the whole program,
+  // not a searchable symbol — the pipeline's best-match collapsed it to a
+  // bare module name. Ground the overview on the ranked ENTRY-POINT module
+  // instead: named as the way in, with its full module-grain overview.
+  if (graph && /^(?:this|the)?\s*(?:app|application|codebase|project|repo|repository|system|program)$/i.test(term)) {
+    try {
+      const { ask } = await import("../domain/ask.mjs");
+      const entry = ask(graph, "where is the entry point")?.tmct_ask?.matches?.[0];
+      const ind = entry?.id ? graph.byId?.get?.(entry.id) : null;
+      if (ind) {
+        return { text: `the app enters at ${ind.label} — here is that module in detail:\n\n${moduleOverviewText(graph, ind)}` };
+      }
+    } catch { /* no entry point rankable — the ordinary pipeline below decides */ }
+  }
   try {
     const { generateCompletion } = await import("./completions.mjs");
     // createCompletionsGraphAdapter wraps the SAME graph object this turn
@@ -9408,7 +9661,18 @@ const sameGoalSpec = (a, b) =>
  *  { text, via, deduced, note, plan? } or null when the query is none of the
  *  three shapes. Mutates planHolder.state (the session's plan slot). */
 async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", }) {
-  const q = String(query).trim();
+  let q = String(query).trim();
+  // GOAL REVISION — "actually the goal is …", "instead, the goal is …", "the
+  // goal is now …": a revision marker ahead of (or inside) a goal frame means
+  // REPLACE the held goal, not accumulate beside it — restating used to pile
+  // up an unsatisfiable conjunction that burned the full search.
+  let goalRevision = false;
+  {
+    const lead = q.match(/^(?:actually|instead|no|wait|scratch\s+that|on\s+second\s+thought)[,\s]+(.+)$/i);
+    if (lead && /\bgoal\b/i.test(lead[1])) { q = lead[1].trim(); goalRevision = true; }
+    const now = q.match(/^the\s+(?:new\s+goal\s+is|goal\s+is\s+now)\s+(.+)$/i);
+    if (now) { q = `the goal is ${now[1].trim()}`; goalRevision = true; }
+  }
 
   // "can you move a disk onto a peg?" — read the taught action signatures back.
   // Answered HERE rather than beside the other capability readers because
@@ -9532,7 +9796,8 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
           ? q.replace(/^the\s+goal\s+is\s+that\s+/i, "").replace(/[.!?]+$/, "")
           : `${m[1] ? `${m[1].toLowerCase()} ` : ""}${m[2].toLowerCase()} ${verb}s ${m[4].toLowerCase()} ${m[5].toLowerCase()}`));
     }
-    const prev = planHolder.state && Array.isArray(planHolder.state.goals) && !planHolder.state.done ? planHolder.state : null;
+    const prev = !goalRevision && planHolder.state && Array.isArray(planHolder.state.goals) && !planHolder.state.done ? planHolder.state : null;
+    const replaced = goalRevision && planHolder.state?.goalTexts?.length ? planHolder.state.goalTexts.join("; ") : null;
     // Restating a goal you already set is one goal, not two. The spec is four
     // normalized scalars, so the same goal in either voicing ("the goal is
     // that …" / "the goal is to …") compiles to the identical object and a
@@ -9557,11 +9822,12 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
       actions: null, states: null, stepGoals: null, cursor: 0, done: false,
     };
     const n = heldGoals.length;
+    const replacedClause = replaced ? ` (replacing the earlier goal: ${replaced})` : "";
     return {
-      text: `${added ? "noted" : "already noted"} — the goal is that ${tails.join(" and ")}.${n > 1 ? ` (${n} goals held)` : ""} Say "solve it" when the state is taught.`,
+      text: `${added ? "noted" : "already noted"} — the goal is that ${tails.join(" and ")}${replacedClause}.${n > 1 ? ` (${n} goals held)` : ""} Say "solve it" when the state is taught.`,
       via: "plan", lane: "goal", deduced: "record the goal state for a later plan",
       note: added
-        ? `GOAL frame — ${added === 1 ? "goal spec" : `${added} goal specs`} accumulated on the session plan slot`
+        ? `GOAL frame — ${added === 1 ? "goal spec" : `${added} goal specs`} ${replaced ? "REPLACED the held goal (revision marker)" : "accumulated on the session plan slot"}`
         : "GOAL frame — the same goal spec was already held, so it folded onto the existing one",
     };
   }
@@ -9639,6 +9905,49 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
       note: "plan lane — honest decline: the goal names an untaught term, search never started",
     };
   }
+  // An UNSATISFIABLE conjunction — two held goals put the same subject (or
+  // the same universal class) in two different places under one predicate —
+  // is named BEFORE the search, so it never burns the full move budget just
+  // to report "no plan found".
+  {
+    const texts = planHolder.state.goalTexts || [];
+    for (let i = 0; i < goals.length; i += 1) {
+      for (let j = i + 1; j < goals.length; j += 1) {
+        const a = goals[i];
+        const b = goals[j];
+        if (a.universal === b.universal && a.term === b.term && a.predicate === b.predicate && a.object !== b.object) {
+          return {
+            text: `those goals can't both hold — "${texts[i] ?? `${a.term} … ${a.object}`}" and "${texts[j] ?? `${b.term} … ${b.object}`}" put the same thing in two places, so no plan exists and I won't search for one. Say "forget the goal", then state the goal you mean.`,
+            via: "plan", deduced: "plan a move sequence (unsatisfiable goal conjunction)",
+            note: "plan lane — honest decline: conflicting goal atoms named before the search",
+          };
+        }
+      }
+    }
+  }
+  // A CONTRADICTORY taught board — one piece placed in two places by the base
+  // facts — makes every "shortest" claim depend on which placement you
+  // resolve, so it is flagged before planning rather than silently read.
+  {
+    const placements = new Map();
+    for (const r of state) {
+      const key = `${r.subject} ${r.predicate}`;
+      if (!placements.has(key)) placements.set(key, new Set());
+      placements.get(key).add(r.object);
+    }
+    const clashes = [...placements.entries()].filter(([, objs]) => objs.size > 1);
+    if (clashes.length) {
+      const shown = clashes.map(([key, objs]) => {
+        const [subj, pred] = key.split(" ");
+        return [...objs].map((o) => `${subj} ${predicatePhrase(pred)} ${o}`).join(" AND ");
+      }).join("; ");
+      return {
+        text: `the taught board contradicts itself — ${shown}. A shortest plan depends on which placement is real, so I won't pick one. Say "forget that <the wrong placement>" (e.g. "forget that ${clashes[0][0].split(" ")[0]} ${predicatePhrase(clashes[0][0].split(" ")[1])} ${[...clashes[0][1]][1]}"), then "solve it" again.`,
+        via: "plan", deduced: "plan a move sequence (contradictory board)",
+        note: "plan lane — honest decline: contradictory placements flagged before planning",
+      };
+    }
+  }
   let isGoal;
   try {
     isGoal = compileGoal(goals, domain);
@@ -9684,11 +9993,20 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
   };
   const ruleNames = [...new Set(domain.actions.map((a) => a.name))].join('", "');
   const moveLines = actions.map((a, i) => `  ${i + 1}. ${a.label}`);
-  // A piece the goal reaches for with no taught position is an ASSUMPTION the
-  // plan silently makes (it reads the board as taught, without that piece) —
-  // said out loud with the plan rather than left implicit.
+  // A piece with no taught position is an ASSUMPTION the plan silently makes
+  // (it reads the board as taught, without that piece) — said out loud with
+  // the plan rather than left implicit. Covers every piece a plan STEP
+  // touches, not just the goal-named ones ("move disk-1 onto disk-3" with
+  // disk-3 never placed is the same silent gap-fill). Scoped to pieces whose
+  // CLASS has at least one positioned member, so a peg — whose class never
+  // takes a position — is not "unplaced".
   const goalPieces = [...new Set(goals.flatMap((g) => (g.universal ? (domain.classMembers?.[g.term] || []) : [g.term])))];
-  const unplacedPieces = goalPieces.filter((p) => !state.some((r) => r.subject === p));
+  const touchedPieces = [...new Set(actions.flatMap((a) => [a.subject, a.target]))];
+  const classOfPiece = (p) => Object.keys(domain.classMembers || {}).find((cls) => (domain.classMembers[cls] || []).includes(p));
+  const positionedClasses = new Set(state.map((r) => classOfPiece(r.subject)).filter(Boolean));
+  const unplacedPieces = [...new Set([...goalPieces, ...touchedPieces])]
+    .filter((p) => !state.some((r) => r.subject === p))
+    .filter((p) => positionedClasses.has(classOfPiece(p)));
   const assumptionNote = unplacedPieces.length
     ? `\n\nnote — ${unplacedPieces.join(" and ")} ha${unplacedPieces.length === 1 ? "s" : "ve"} no taught position, so this plan reads the board without ${unplacedPieces.length === 1 ? "it" : "them"}. Teach the missing position(s) and solve again if that's wrong.`
     : "";
@@ -9756,11 +10074,43 @@ async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
  *  "next" moves a piece, "what rests on X" reflects the snapshot, not the stale
  *  pre-plan facts. Clearness is derived, never stored — a piece is clear iff
  *  nothing rests on it on the current board. */
-async function planFollowUpAnswer(query, { memoryDir, planHolder }) {
+async function planFollowUpAnswer(query, { memoryDir, planHolder, pendingPager = false }) {
   const q = String(query).trim();
   const ps = planHolder?.state;
   const activePlan = ps && Array.isArray(ps.actions) && ps.actions.length;
 
+  // PLAN-NAVIGATION GESTURES — routed, honest replies while a plan (or a
+  // held goal) stands, so the orientation blurb never fronts a mid-plan
+  // turn. With nothing standing these return null and a cold "undo" keeps
+  // its ordinary path.
+  if (PLAN_UNDO_RE.test(q)) {
+    if (!activePlan) return null;
+    const k = ps.cursor;
+    const board = k > 0 ? `the board stands at board@step${k}` : "no move has been made yet";
+    return {
+      text: `there's no undo — each move wrote a board@step snapshot and I don't unwind them. ${board}. Say "solve it" to replan from the current board, or "forget the goal" to drop the plan.`,
+      deduced: "unwind a plan move (not supported — honest decline)",
+      note: "PLAN FOLLOW-UP — undo/go-back gesture named the snapshot model instead of the blurb",
+    };
+  }
+  if (PLAN_FORGET_GOAL_RE.test(q)) {
+    if (!ps || !(ps.goals?.length || activePlan)) return null;
+    const held = ps.goalTexts?.length ? ` (${ps.goalTexts.join("; ")})` : "";
+    planHolder.state = null;
+    return {
+      text: `forgotten — the goal${held} and its plan are dropped. The taught board facts stay; set a new goal with "the goal is that …".`,
+      deduced: "drop the held goal and plan",
+      note: "PLAN FOLLOW-UP — forget-the-goal cleared the session plan slot",
+    };
+  }
+  if (PLAN_NEXT_RE.test(q) && ps?.done && Array.isArray(ps.actions) && ps.actions.length && !pendingPager) {
+    return {
+      text: `the plan is complete — all ${ps.actions.length} moves are made and the goal was checked against the written board. Teach a new goal ("the goal is that …") to plan again.`,
+      deduced: "continue a plan that is already complete (honest decline)",
+      note: "PLAN FOLLOW-UP — next-after-done answered from the finished plan instead of the blurb",
+    };
+  }
+
   if (PLAN_WHAT_NEXT_RE.test(q)) {
     if (!activePlan) return null;
     if (ps.done || ps.cursor >= ps.actions.length) {
@@ -9846,6 +10196,30 @@ async function planFollowUpAnswer(query, { memoryDir, planHolder }) {
     : { text: `nothing ${emptyPhrase} ${x} on the current board.`, deduced: "read the current board (what rests on a piece)", note: "BOARD — reverse locative, nothing on the current board" };
 }
 
+/** "what was X called/named before" and its siblings — a name-HISTORY ask.
+ *  The index records current names only, so the whole family declines by
+ *  name (mirrors the guarded "renamed X" adjective — the verb slipped). */
+const RENAME_HISTORY_RE = /^what\s+(?:was|were)\s+(.+?)\s+(?:called|named|known\s+as)\s+(?:before|previously|originally|earlier|at\s+first)[?.!\s]*$|^what\s+did\s+(.+?)\s+use(?:d)?\s+to\s+be\s+(?:called|named)[?.!\s]*$/i;
+
+/** "what do the handlers import" — a COLLECTIVE plural subject naming a
+ *  module GROUP (a directory/path component), not a single module. The
+ *  resolver's best-match tiers read "handlers" as one module and answer for
+ *  it alone, silently — a wrong set with no disclosure. The closed verb set
+ *  mirrors the forward relations; a plural that names a graph KIND
+ *  (modules/classes/…) stays with the engine's own kind-level reading. */
+const COLLECTIVE_FORWARD_RE = /^what\s+(?:do|does)\s+the\s+([a-z][\w-]*s)\s+(import|call|use|export|touch|test|define|contain)s?[?.!\s]*$/i;
+
+/** Decision-recall — "remind me what we decided about X", "what did we agree
+ *  on about X": a question about the CONVERSATION's record, so it belongs to
+ *  the session-recall surface, never the definition locator ("decided" used
+ *  to be read-as-rewritten into "defined"). */
+const DECISION_RECALL_RE = /^(?:remind\s+me\s+)?what\s+(?:did\s+)?(?:we|i|you)\s+(?:decided?|agreed?(?:\s+on)?|settled?(?:\s+on)?|concluded?)\s+(?:about|on|regarding|for)\s+(?:the\s+)?(.+?)[?.!\s]*$/i;
+
+/** "where did X move to" — a move-HISTORY ask, sibling of RENAME_HISTORY_RE:
+ *  the index records current locations only, so the premise is named rather
+ *  than silently accepted alongside the current location. */
+const MOVE_HISTORY_RE = /^where\s+did\s+(.+?)\s+(?:move|get\s+moved|go)(?:\s+to)?[?.!\s]*$/i;
+
 async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
@@ -9871,6 +10245,96 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       .replace(/^(?:and|so|then|also)\s+/i, "")
       .replace(/how many\s+/i, "how many of those ");
   }
+  // RENAME HISTORY — "what was X called before" and its siblings. The index
+  // records current names only, and without this gate "called" fuzzes onto
+  // the calls relation ("before" simply drops), so the reply read as fluent
+  // confirmation of a rename that never happened. Checked BEFORE the ask
+  // engine because the misread ANSWERS — a miss-gated lane never gets a turn.
+  {
+    const rename = String(query).trim().match(RENAME_HISTORY_RE);
+    if (rename) {
+      const term = (rename[1] ?? rename[2]).trim().replace(/^the\s+/i, "");
+      const ent = graph ? await resolveEntity(graph, term) : null;
+      const named = ent ? `${ent.label} is its only recorded name` : `"${term}" has no recorded prior name`;
+      note(trace, "goal: recover a name history the index does not record (honest decline)");
+      note(trace, "lane: RENAME_HISTORY_RE — the index carries no rename data, so the calls-relation misread is refused by name");
+      return plainTurn(query, `I can't say what ${ent ? ent.label : `"${term}"`} was called before — this index records current names only, no rename history. ${named}${ent ? ` here; "who touched ${ent.label}" lists its recorded commits` : ""}.`, {
+        via: "miss", miss: true, focus,
+      });
+    }
+  }
+  // COLLECTIVE PLURAL SUBJECT — see COLLECTIVE_FORWARD_RE. Members are the
+  // modules whose path carries the plural as a component; two or more make it
+  // a group question, answered as the disclosed union over every member. One
+  // or zero members leaves the ordinary resolver reading untouched.
+  {
+    const collective = graph ? String(query).trim().match(COLLECTIVE_FORWARD_RE) : null;
+    const stem = collective ? collective[1].toLowerCase() : null;
+    if (collective && !ENTITY_TO_TYPE[stem] && !ENTITY_TO_TYPE[singularizeSurface(stem)]) {
+      const memberRe = new RegExp(`(^|/)${escapeRegex(stem)}(/|\\.|$)`, "i");
+      const members = graph.individuals.filter((i) => i.class === "Module" && memberRe.test(String(i.label)));
+      if (members.length > 1) {
+        const verb = collective[2].toLowerCase();
+        const { ask } = await import("../domain/ask.mjs");
+        const union = new Map();
+        for (const member of members) {
+          const r = ask(graph, `what does ${member.label} ${verb}`);
+          for (const hit of r?.tmct_ask?.matches ?? []) if (hit?.id) union.set(hit.id, hit.label ?? hit.id);
+        }
+        const memberList = joinList(members.map((mm) => mm.label).sort());
+        const labels = [...union.values()].sort();
+        const text = labels.length
+          ? `the ${stem} here are ${memberList} — together they ${verb}: ${joinList(labels)}.`
+          : `the ${stem} here are ${memberList} — none of them has ${verb} edges in the index.`;
+        note(trace, `goal: read a forward relation over a module GROUP (${members.length} members), unioned with the set disclosed`);
+        note(trace, `lane: COLLECTIVE_FORWARD_RE — "${stem}" resolved to ${members.length} modules; answered the union, never a silent single best-match`);
+        const turn = plainTurn(query, text, { via: "composed", miss: !labels.length, focus });
+        turn.detail = { traversal: `${verb} edges unioned over ${memberList}`, matches: [...union.keys()].map((id) => graph.byId?.get?.(id)).filter(Boolean) };
+        return turn;
+      }
+    }
+  }
+  // MOVE HISTORY — "where did X move to": the index records current
+  // locations, not moves, so the premise is denied by name and the current
+  // location answers beside it (stating the location alone read as silently
+  // confirming a move nobody recorded).
+  {
+    const moved = graph ? String(query).trim().match(MOVE_HISTORY_RE) : null;
+    if (moved) {
+      const term = moved[1].trim().replace(/^the\s+/i, "");
+      const ent = await resolveEntity(graph, term);
+      if (ent) {
+        let located = "";
+        try {
+          const { ask } = await import("../domain/ask.mjs");
+          const r = ask(graph, `where is ${ent.label} defined`);
+          if (r?.content && !r?.tmct_ask?.miss) located = ` Right now, ${r.content}`;
+        } catch { /* the premise note stands alone */ }
+        note(trace, "goal: recover a move history the index does not record (premise denied, current location cited)");
+        note(trace, "lane: MOVE_HISTORY_RE — no move data exists; the current location answers with the premise named");
+        return plainTurn(query, `this index records current locations only, so I can't confirm ${ent.label} moved anywhere.${located}`, {
+          via: "composed", miss: false, focus,
+        });
+      }
+    }
+  }
+  // DECISION RECALL — "remind me what we decided about X" reaches the
+  // session-recall surface (the folded transcript blocks); with nothing
+  // relevant folded it misses honestly by name. Never the definition locator
+  // ("decided" is not "defined").
+  {
+    const decision = memoryDir ? String(query).trim().match(DECISION_RECALL_RE) : null;
+    if (decision) {
+      const term = decision[1].trim();
+      const recalled = await recallFromBlocks(memoryDir, `what did we decide about ${term}`, graph);
+      note(trace, "goal: recall a decision from the conversation record (session-recall surface)");
+      note(trace, `lane: DECISION_RECALL_RE — routed to the folded-session recall surface, ${recalled ? "a relevant block answered" : "nothing relevant folded (honest miss)"}`);
+      return plainTurn(query, recalled
+        ?? `I don't have a recorded decision about "${term}" — I keep facts and session transcripts, and nothing folded mentions deciding on it. "what did i ask before" lists the last session's questions.`, {
+        via: recalled ? "recall" : "miss", miss: !recalled, focus,
+      });
+    }
+  }
   // W2: the explicit recall forms are answered from memory's folded blocks, never
   // the graph. Gated on memoryDir — a bare runTurn (no session shell) stays pure.
   if (memoryDir && RECALL_ASK_RE.test(String(query).trim())) {
@@ -9936,10 +10400,13 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // on that first turn, so the test is noCodeGraph, not `!graph`: an empty
     // graph is as unusable as an absent one, and reporting its emptiness to
     // someone asking about a dog answers a question they never asked.
+    // The exit named is the one this session can actually take: a SEEDED
+    // vocabulary session points at a vocabulary shape (code-question
+    // examples are the wrong audience here), an unseeded one at the seed/
+    // teach pair — vocabHint already carries exactly that split.
     answer = (!graph || noCodeGraph(graph)) && (!config || e?.emptyGraph || /^cannot read graph artifact\b/.test(thrown))
-      ? "I can't answer that as a code question — no code graph is loaded in this session. "
-        + "I can still remember and answer taught facts (try \"every disk is a game piece\"), "
-        + "or run `tmct init` in a repo to index one."
+      ? `I can't answer that as a code question — no code graph is loaded in this session. ${vocabHint
+        || "I can still remember and answer taught facts (try \"every bug is an issue\"), or run `tmct init` in a repo to index one."}`
       : thrown;
     note(trace, `intermediate: the ask engine threw — ${thrown}`);
   }
@@ -10266,6 +10733,16 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   const gateQuery = normalizeQuery(String(query));
   const bareWhatisShape = BARE_WHATIS_RE.test(gateQuery);
   const isAdjectiveShape = IS_ADJECTIVE_YESNO_RE.test(gateQuery);
+  // A BARE NOUN on its own ("dog", "teh dog" after the typo repair) is the
+  // shortest vocabulary opener there is — it answers exactly as "what is a
+  // dog" does, gated on a REAL fact hit like every divert in this family, so
+  // chatter with no facts behind it still falls to the ordinary card. Read
+  // off the raw line (typos repaired), NOT the filler-stripped gateQuery: a
+  // request with filler around a noun ("jokes please") is a different speech
+  // act than a bare noun, and stripping must not manufacture one.
+  const bareNounMatch = correctMisspellings(String(query).trim()).replace(/[?.!]+\s*$/, "").trim()
+    .match(/^(?:the\s+|a\s+|an\s+)?([a-z][a-z-]*)$/i);
+  const bareNounShape = !!bareNounMatch;
   // `isBareCamelCaseMetaQuestion` ORs in alongside isConversationalCandidate
   // for THIS lane only — a bare "what is TaskController" (CamelCase compound,
   // no article) is otherwise excluded solely because isConversational()'s
@@ -10288,10 +10765,17 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   const capabilityAskShape = CAN_ASK_RE.test(gateQuery) || WHAT_CAN_DO_RE.test(gateQuery)
     || DO_VERB_ASK_RE.test(gateQuery) || WHICH_KIND_CAN_RE.test(gateQuery) || WHAT_CAN_VERB_RE.test(gateQuery);
   let bareMetaHit = null;
-  if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape || reversePredicateShape || capabilityAskShape)) {
+  if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape || reversePredicateShape || capabilityAskShape || bareNounShape)) {
     if (memoryDir) {
-      bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle, cache, newFocus?.label))
-        ?? (await factReadBack(memoryDir, gateQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
+      // The bare noun asks its own "what is a X" — the readers never see the
+      // single word, so the vocabulary route is the constructed question's.
+      const bareNoun = bareNounShape ? singularizeSurface(bareNounMatch[1].toLowerCase()) : null;
+      const factQuery = bareNounShape && !bareWhatisShape
+        ? `what is ${indefiniteArticleFor(bareNoun)} ${bareNoun}`
+        : gateQuery;
+      bareMetaHit = (await factAnswer(memoryDir, factQuery, envelope, miss, biasByBundle, cache, newFocus?.label))
+        ?? (await factReadBack(memoryDir, factQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
+      if (bareNounShape && !bareWhatisShape && bareMetaHit?.miss) bareMetaHit = null;
       // An honest-miss return never diverts the gate — EXCEPT the capability
       // family's can't-confirm, which names the subject's real capabilities
       // and a round-trip teach hint: strictly more useful than the
@@ -10302,14 +10786,14 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // hit" treatment — curatedDefinitionAnswer otherwise only ever runs once
       // the article makes T5's structural parse succeed.
       if (!bareMetaHit) {
-        const def = await curatedDefinitionAnswer(gateQuery, envelope, { memoryDir, lexicon });
+        const def = await curatedDefinitionAnswer(factQuery, envelope, { memoryDir, lexicon });
         if (def) bareMetaHit = { text: def.text, replace: true };
       }
       // The reference pack's bare-form fallback, beside the curated one and
       // under the IDENTICAL clean-miss gate the articled hook (4h) applies —
       // "what is otter" reaches the pack exactly as "what is an otter" does.
       if (!bareMetaHit) {
-        const refTerm = metaTermOf(gateQuery, envelope);
+        const refTerm = metaTermOf(factQuery, envelope);
         const ref = refTerm ? await referencePackMissAnswer(refTerm, { graph, memoryDir, lexicon, env, cache }) : null;
         if (ref) bareMetaHit = { text: ref.text, replace: true, reference: ref };
       }
@@ -10395,6 +10879,20 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     via = "template"; handled = true;
     note(trace, "lane: (2) COLD PRONOUN — a subject pronoun with no antecedent bound and no focus standing; named the pronoun instead of the orientation card");
     note(trace, "goal: resolve a pronoun to a subject (nothing named yet)");
+  } else if (isConversationalCandidate && planHolder?.state?.game) {
+    // MID-GAME: a short line that parsed as nothing ("you said lower", "is it
+    // warm in here") stays INSIDE the game frame with a nudge naming the
+    // state — the identity card answers a question nobody asked, and it used
+    // to front exactly these turns. Real asides ("what is a dog") still
+    // route out above; only the would-be blurb is replaced.
+    const game = planHolder.state.game;
+    answer = game.mode === "guesser"
+      ? `we're mid-game — I'm guessing your number (currently between ${game.lo} and ${game.hi}; my guess: ${game.guess}). Say higher, lower, or correct — or "I give up" to stop.`
+      : `we're mid-game — you're guessing my number between ${game.lo0} and ${game.hi0}${game.lastHint ? ` (my last hint: ${game.lastHint} than your ${game.lastGuess})` : ""}. Guess a number — or "I give up" to stop.`;
+    via = "game"; handled = true;
+    dialogueLaneOverride = "game-inform";
+    note(trace, "lane: (2) MID-GAME NUDGE — an unparsed short turn stayed inside the live game frame instead of the identity card");
+    note(trace, "goal: keep the running guess-the-number game on track");
   } else if (isConversationalCandidate) {
     // A conversational miss (a greeting, "what can you do", a very short non-code
     // line) gets the friendly orientation (module-aware: empty → --repo/tmct init).
@@ -10566,7 +11064,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // (4) #2 TEACH lane — a teach-shaped would-miss nothing above answered: route to
   // memory, or say what CAN be remembered (LOUD), never the wall / a silent drop.
   if (miss && recordMiss && via === "composed") {
-    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache });
+    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache, planHolder });
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
       if (!taught.miss) dialogueLaneOverride = "teach";
@@ -10636,7 +11134,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   if (miss && recordMiss && via === "composed") {
     const described = await describeWrapperAnswer(query, { config, source, focus: newFocus, graph, tel });
     if (described) {
-      answer = described.text; via = "describe"; recordMiss = false;
+      answer = described.text; via = described.miss ? "miss" : "describe"; recordMiss = !!described.miss;
       note(trace, "lane: (4d) DESCRIBE-WRAPPER RESCUE — a polite wrapper around \"describe/tell me about <symbol>\" resolved via /describe, tried last after every other lane declined");
       note(trace, "goal: get a symbol's definition/kind/relations (phrased conversationally)");
       // Carry the resolved entity forward as the new focus, same class-gated
@@ -10739,7 +11237,13 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // miss re-offers the tailored hint instead of droning.
   if (miss && recordMiss && via === "composed" && WALL_MISS_RE.test(answer)) {
     const repeat = last?.answer && WALL_MISS_RE.test(String(last.answer));
-    answer = repeat ? WALL_REPEAT_ONELINER : shortMissHint(query);
+    // A GRAPH-LESS session's wall must not hand a vocabulary question a list
+    // of import/calls shapes — that guidance is aimed at an audience that
+    // isn't in the room. Offer what THIS session can answer instead.
+    answer = repeat ? WALL_REPEAT_ONELINER
+      : (noCodeGraph(graph) && vocabHint
+        ? `I couldn't read that as a question I can answer. ${vocabHint} Type /help for all query shapes.`
+        : shortMissHint(query));
     via = "miss";
     note(trace, `lane: (5) SHORT TAILORED MISS — every lane above declined; ${repeat ? "REPEAT collapsed to one-liner (wall kindness)" : "the full grammar wall was shortened + tailored to the query's keywords"}`);
   }
@@ -11212,7 +11716,8 @@ function sentenceTeachesAlone(sentence, parseAce, lex) {
   if (!s || s.includes("?")) return false;
   const parse = parseAce(s, lex);
   if (parse && parse.triples?.length && !parse.residue?.length) return true;
-  return DECLARATIVE_KIND_OF_RE.test(s) || COMPARATIVE_TEACH_RE.test(s) || matchesGeneralVerbTeachFrame(s);
+  return DECLARATIVE_KIND_OF_RE.test(s) || COMPARATIVE_TEACH_RE.test(s)
+    || RENDERS_AS_TEACH_RE.test(s) || matchesGeneralVerbTeachFrame(s);
 }
 
 /** Does every sentence of a multi-sentence line teach on its own? Then the line
@@ -11233,6 +11738,10 @@ async function everySentenceTeaches(sentences, lexicon) {
 }
 
 async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, cache = null }) {
+  // A trailing "?" marks a question, and a question never writes — the ACE
+  // fragment happily parses "dog have tail?" as the declarative it is not,
+  // which stored a Fact at teach trust over a FLOW-0 vocabulary question.
+  if (/\?\s*$/.test(String(line).trim())) return null;
   try {
     const { parseAce, parseAceAmbiguous } = await import("../domain/grammar/ace.mjs");
     // A session handle carries its own loaded lexicon (createSession loads it once);
@@ -11259,6 +11768,18 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
     if (!parse || !parse.triples?.length || parse.residue?.length) return null;
     const { assertSentence } = await import("../domain/grammar/assert.mjs");
     const { normFactTerm, appendFact } = await import("../adapters/memory/core.mjs");
+    // A REFLEXIVE disjointness ("no dog is a dog") is a self-contradiction,
+    // not a fact — the same refusal the teach lane's negative-universal frame
+    // gives the out-of-lexicon spelling, so the two surfaces can't disagree.
+    const reflexiveDisjoint = parse.triples.find(
+      (t) => t.predicate === "owl:disjointWith" && normFactTerm(t.subject) === normFactTerm(t.object),
+    );
+    if (reflexiveDisjoint) {
+      const term = normFactTerm(reflexiveDisjoint.subject);
+      return plainTurn(line,
+        `I can't store "no ${term} is a ${term}" — every ${term} is a ${term} by definition, so that exclusion contradicts itself. Nothing was stored.`,
+        { command: "assert", via: "teach-miss", miss: true, focus });
+    }
     const ts = new Date().toISOString();
     const res = await assertSentence(memoryDir, line, {
       lexicon: lex,
@@ -11426,7 +11947,7 @@ function morePage(query, { last, focus }) {
 // the generic parse, which reads these phrasings as something else entirely.
 // A term that mints no concept — unknown, or with no synonym/related facts —
 // misses honestly, naming the term, never a guessed neighbour.
-const SKOS_SYNONYM_RE = /^(?:another\s+word\s+for|other\s+words\s+for|synonyms?\s+(?:of|for)|what\s+is\s+a\s+synonym\s+(?:of|for))\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
+const SKOS_SYNONYM_RE = /^(?:(?:what\s+is|whats)\s+another\s+word\s+for|(?:got\s+|are\s+there\s+)?any\s+(?:other\s+)?words?\s+like|(?:other\s+)?words\s+like|another\s+word\s+for|other\s+words\s+for|synonyms?\s+(?:of|for)|what\s+is\s+a\s+synonym\s+(?:of|for))\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
 const SKOS_RELATED_RE = /^(?:what\s+is\s+related\s+to|what\s+relates\s+to|what\s+words\s+are\s+related\s+to)\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
 
 /** The SKOS-view answer for a synonym/related question, or null when the
@@ -11493,6 +12014,12 @@ const GUESSER_OPEN_LEAD_RE = /^(?:i\s*(?:'m|am)\s+thinking\s+of\s+a\s+number|gue
 const THINKER_OPEN_LEAD_RE = /^(?:think\s+of\s+a\s+number)\b(.*)$/i;
 const GUESSER_OPEN_TAIL_RE = /^[\s,.!?—-]*(?:and\s+)?(?:you\s+)?(?:can\s+|have\s+to\s+|try\s+to\s+)?(?:guess(?:\s+it|\s+what\s+it\s+is)?)?[\s,.!?—-]*$/i;
 const THINKER_OPEN_TAIL_RE = /^[\s,.!?—-]*(?:and\s+)?(?:i\s*(?:'ll|\s+will)\s+(?:try\s+to\s+)?guess(?:\s+it)?|i\s+guess)?[\s,.!?—-]*$/i;
+// The INVITATION family — "let's play guess the number", "wanna play a
+// guessing game?": an invitation names the game without saying who holds the
+// secret, and the canonical guess-the-number reading is that the inviter
+// GUESSES — so it opens thinker mode (tmct commits the secret).
+const INVITATION_OPEN_LEAD_RE = /^(?:let'?s\s+play|wanna\s+play|want\s+to\s+play|can\s+we\s+play|shall\s+we\s+play|do\s+you\s+want\s+to\s+play|will\s+you\s+play|play)\s+(?:a\s+)?(?:game\s+of\s+)?(?:guess[- ]the[- ]number|number[- ]guessing(?:\s+game)?|guessing\s+game)\b(.*)$/i;
+const INVITATION_OPEN_TAIL_RE = /^[\s,.!?—-]*(?:with\s+me|together)?[\s,.!?—-]*$/i;
 
 /** An opening move — { mode, bounds } — or null. */
 function matchGameOpening(line) {
@@ -11505,6 +12032,10 @@ function matchGameOpening(line) {
   if (thinker && THINKER_OPEN_TAIL_RE.test(thinker[1].replace(GAME_BOUNDS_CLAUSE_RE, " "))) {
     return { mode: "thinker", bounds: parseGameBounds(l) };
   }
+  const invite = l.match(INVITATION_OPEN_LEAD_RE);
+  if (invite && INVITATION_OPEN_TAIL_RE.test(invite[1].replace(GAME_BOUNDS_CLAUSE_RE, " "))) {
+    return { mode: "thinker", bounds: parseGameBounds(l) };
+  }
   return null;
 }
 
@@ -11632,6 +12163,9 @@ function guessNumberTurn(line, { planHolder, env }) {
     return null;
   }
   if (!opening) return null;
+  if (state?.adventure) {
+    return { text: 'we\'re mid-adventure — say "stop playing" to end it before a number game.', lane: "game-inform", note: "GAME — an opening arrived mid-adventure; the slot holds one thing at a time" };
+  }
   const planActive = state && !state.done
     && ((Array.isArray(state.goals) && state.goals.length) || (Array.isArray(state.actions) && state.actions.length));
   if (planActive) {
@@ -11707,6 +12241,41 @@ function rewriteVocabOpener(line) {
   return null;
 }
 
+/** The ESL missing-"does" yes/no — "dog have tail?": subject + bare
+ *  have/has + object, question mark REQUIRED (the "?" is the whole signal;
+ *  without it the line is a declarative and belongs to the teach path).
+ *  Rewritten to the do-support form the possession readers already answer, so
+ *  the question is ANSWERED as the yes/no it is rather than merely refused at
+ *  the write boundary. Single/two-token sides, mirroring the teach shapes'
+ *  own subject width; articles tolerated on the object. */
+const ESL_MISSING_DOES_RE = /^([\w-]+(?:\s+[\w-]+)?)\s+(?:has|have)\s+(?:an?\s+|the\s+)?([\w-]+(?:\s+[\w-]+)?)\s*\?+$/i;
+function rewriteEslMissingDoes(line) {
+  const m = String(line || "").trim().match(ESL_MISSING_DOES_RE);
+  if (!m) return null;
+  if (QUESTION_LEAD_RE.test(m[1])) return null; // already do-supported ("does dog have tail?")
+  return `does ${m[1].trim()} have ${m[2].trim()}`;
+}
+
+/** The NEGATIVE-POLARITY opener — "I don't suppose X imports anything": a
+ *  politeness implicature meaning the question underneath. The one wrapper
+ *  the desire/wrapper stripper family didn't peel; unpeeled it reads as a
+ *  first-person declarative and lands on the pronoun-subject lecture. The
+ *  anything-form folds straight to the open question; an interrogative-led
+ *  remainder unwraps to itself; anything else stays untouched (never a
+ *  guessed reading). */
+const NEG_POLARITY_OPENER_RE = /^i\s+(?:do\s+not|don'?t)\s+suppose\s+(?:that\s+)?(.+?)[?.!\s]*$/i;
+function rewriteNegativePolarityOpener(line) {
+  const m = String(line || "").trim().match(NEG_POLARITY_OPENER_RE);
+  if (!m) return null;
+  const rest = m[1].trim();
+  const anyForm = rest.match(/^(.+?)\s+([a-z]+)s\s+(?:anything|something)(?:\s+else)?$/i);
+  if (anyForm && VERB_TO_KIND[`${anyForm[2].toLowerCase()}s`]) {
+    return `what does ${anyForm[1].trim()} ${anyForm[2].toLowerCase()}`;
+  }
+  if (QUESTION_LEAD_RE.test(rest)) return rest;
+  return null;
+}
+
 /** A DISCONTIGUOUS verb frame, "SUBJECT uses OBJECT as its/a base(class)" —
  *  "uses" is split from its own qualifier ("as its base") around the object,
  *  so no contiguous phrase-table entry could ever register it, and "uses"
@@ -11845,7 +12414,13 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // The pronoun lead's own guard only spares the BARE "what is it", so this
   // shape has to stop existing before that match runs at all.
   const cleftRewrite = reverseCleftRewrite(frameLine);
-  const cleftLine = cleftRewrite || frameLine;
+  // The ESL missing-"does" yes/no ("dog have tail?") — rewritten to the
+  // do-support form here, once, before any dispatch lane sees it, so the
+  // question is answered by the possession readers instead of walling (the
+  // write boundary's own "?" gates already refuse to store it).
+  const eslRewrite = rewriteEslMissingDoes(cleftRewrite || frameLine)
+    || rewriteNegativePolarityOpener(cleftRewrite || frameLine);
+  const cleftLine = eslRewrite || cleftRewrite || frameLine;
   // VOCABULARY pronoun antecedent — "what is a dog" then "can it bark". The
   // code-graph focus mechanism only ever binds {id,label} GRAPH entities, so
   // in a vocabulary conversation "it" resolved to nothing and the question
@@ -11883,10 +12458,16 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     // indirect-request wrapper stripped and/or the discontiguous-frame
     // rewrite applied) — restore the ORIGINAL raw `line` into record.query
     // and the logged transcript echo here, once, centrally.
-    if (indirectMatch || baseFrameRewrite || vocabAntecedent) {
+    if (indirectMatch || baseFrameRewrite || vocabAntecedent || eslRewrite) {
       if (finished.record) finished.record.query = line;
       if (Array.isArray(finished.logLines) && finished.logLines.length > 1) finished.logLines[1] = `> ${line}`;
     }
+    // The VERBATIM user line rides every turn record as `input`, beside
+    // whatever `query` the dispatch path recorded — the session history must
+    // be able to quote the user exactly, and bench session-mode matching
+    // needs the pre-rewrite turn. Additive: `query` keeps its existing
+    // fidelity rules unchanged.
+    if (finished.record && finished.record.type === "turn") finished.record.input = line;
     // runAsk's own effectiveQuery (set only when discourseRewrite substituted
     // a new subject and produced a genuine non-miss answer) takes over as the
     // continuation base for the NEXT turn's own discourseRewrite.
@@ -11938,12 +12519,37 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     }
   }
 
+  // THE ADVENTURE — world-loading openers ("play ashcombe hall", "start the
+  // adventure"), the stop command, and (once a world is live) the game's own
+  // turns. Ordered AFTER the guess-number lane so that lane keeps every
+  // guessing-game opener it already owns, and before the conversational
+  // layer for the same reason the game lane is: an opening line would
+  // otherwise read as a declarative or an orientation ask.
+  {
+    const advTurn = await adventureTurn(workingLine, {
+      planHolder, memoryDir, sessionId, env, lexicon, graph, cache: factRowsCache, isPlanFrameLine,
+    });
+    if (advTurn) {
+      note(trace, `lane: ${advTurn.note}`);
+      if (advTurn.goal) note(trace, `goal: ${advTurn.goal}`);
+      const result = plainTurn(workingLine, advTurn.text, { via: "game", focus });
+      if (advTurn.goal) result.goal = advTurn.goal;
+      result.lane = advTurn.lane;
+      const rec = withLast(result, advTurn.goal ?? "play the adventure");
+      rec.planState = planHolder.state;
+      return rec;
+    }
+  }
+
   // Conversational layer next (greetings, thanks, help, bye, why/say-more) — these
   // resolve no entity and carry their own preserved `last`. Bypasses withLast (a
   // conversational turn is never finish()'d / never becomes a new `last`), so the
   // narrate block is applied directly here instead.
   const convo = vocabAntecedent ? null : conversationalTurn(workingLine, ctx);
-  if (convo) return withNarration(convo, trace, "casual/social — no graph intent");
+  if (convo) {
+    if (convo.record && convo.record.type === "turn") convo.record.input = line; // verbatim, same as withLast
+    return withNarration(convo, trace, "casual/social — no graph intent");
+  }
 
   // PLAN NEXT — "next"/"continue" with an ACTIVE plan executes the plan's
   // next move as a snapshot write. Checked BEFORE the MORE_RE pager because
@@ -11969,7 +12575,10 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // code-graph miss. Returns null with no plan/board standing, so nothing
   // changes for a cold session — an honest miss still stands.
   if (memoryDir) {
-    const follow = await planFollowUpAnswer(workingLine, { memoryDir, planHolder });
+    const follow = await planFollowUpAnswer(workingLine, {
+      memoryDir, planHolder,
+      pendingPager: !!(Array.isArray(last?.detail?.pending?.items) && last.detail.pending.items.length),
+    });
     if (follow) {
       note(trace, `goal: ${follow.deduced}`);
       note(trace, `lane: ${follow.note}`);