@polycode-projects/the-mechanical-code-talker 2.5.2 → 2.5.4

package/src/services/chat.mjs

@@ -46,6 +46,10 @@ import { readConstructionFiles } from "../adapters/corpus/construction-banks.mjs
 import { fuzzyMatchInSet, fuzzyBound } from "../domain/interpret/fuzzy.mjs";
 import { loadLexicon, lookupNoun } from "../domain/grammar/lexicon.mjs";
 import { pickPhrase } from "../domain/answer-variants.mjs";
+import { REFERENCE_PACK_NAME, cleanMissReferenceTerm, renderReferenceAnswer, referenceProvenanceTag } from "../domain/reference-pack.mjs";
+import { getReferencePackProvider } from "../adapters/corpus/reference-pack.mjs";
+import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
+import { relatedForTerm } from "../domain/skos-view.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
@@ -149,6 +153,47 @@ function deduceGoalFromParsed(parsed) {
   return "understand a graph relationship";
 }
 
+// ---- dialogue acts (ISO 24617-2): a lookup over the lane decision ----
+// A turn result may carry a `lane` string naming the router lane that
+// answered it; withLast (and conversationalTurn's own mk) resolve it through
+// dialogueActForLane and stamp `record.dialogueAct` — a fixed lookup over a
+// decision already made, never a classifier. The honest miss is the row that
+// must never drift: autoNegative in the autoFeedback dimension, tmct
+// reporting its OWN processing failed, not a task answer.
+
+/** Stamp the record with the lane's dialogue act (a no-op for an unmapped or
+ *  absent lane) and put the label in the narrate trace. */
+function attachDialogueAct(result, trace) {
+  const act = dialogueActForLane(result?.lane);
+  if (act && result?.record) {
+    result.record.dialogueAct = act;
+    note(trace, `dialogue act: ${act.act} (${act.dimension} dimension, ISO 24617-2)`);
+  }
+  return result;
+}
+
+const PROPOSITIONAL_NODES = new Set(["boolean", "qualifier"]);
+const PROPOSITIONAL_LEAD_RE = /^(?:is|are|am|was|were|does|do|did|can|could|will|would|shall|should|has|have|had|must)\b/i;
+const SET_QUESTION_LEAD_RE = /^(?:what|which|who|whose|where|when|why|how|tell|show|list|define|describe|find|count|name)\b/i;
+
+/** The dialogue-act lane for a runAsk turn. A recorded miss is ALWAYS the
+ *  honest-miss lane, whatever the query shape — feedback about tmct's own
+ *  processing. An answered turn is labelled by its question shape (yes/no
+ *  vs set), from the parsed AST when one stood, else the lead word. Null
+ *  when the turn is neither — the record simply carries no act. */
+function askDialogueLane(parsed, query, recordMiss) {
+  if (recordMiss) return "honest-miss";
+  if (parsed) {
+    if (parsed.node) return PROPOSITIONAL_NODES.has(parsed.node) ? "ask-propositional" : "ask-set";
+    if (parsed.shape === "ask") return "ask-propositional";
+    if (parsed.shape) return "ask-set";
+  }
+  const q = String(query).trim();
+  if (PROPOSITIONAL_LEAD_RE.test(q)) return "ask-propositional";
+  if (SET_QUESTION_LEAD_RE.test(q)) return "ask-set";
+  return null;
+}
+
 /** Split the collected trace into buckets by its own leading category tag, so
  *  renderNarration can group like with like while the trace array itself stays
  *  a flat, chronological narrative — no structured side-channel to keep in
@@ -820,7 +865,17 @@ export function renderStats(graph) {
  *  which meant "who are you" always got the "here's what I can query" blurb and
  *  never a self-description — split so each gets the answer it actually asked for. */
 const CAPABILITY_PHRASES = [
-  /^(?:so,?\s+)?what can (?:you|u)(?:\s+(?:actually|really))? do\??$/i, /^(?:so,?\s+)?what do you(?:\s+(?:actually|really))? do\??$/i,
+  // The "so"/"uh"/"well" lead and the "for me"/"then" tail are pure discourse
+  // filler on the same question — tolerated so the casual forms land on the
+  // same orientation answer instead of the parse wall.
+  /^(?:(?:so|uh|um|erm|well|ok|okay),?\s+)*what can (?:you|u)(?:\s+(?:actually|really))? do(?:\s+for\s+(?:me|us))?(?:\s+(?:then|now|today|here))?\??$/i,
+  /^(?:(?:so|uh|um|erm|well|ok|okay),?\s+)*what do you(?:\s+(?:actually|really))? do(?:\s+for\s+(?:me|us))?(?:\s+(?:then|now|today|here))?\??$/i,
+  // "what have you got" / "what do you have" — the overview question in its
+  // casual spelling; without a frame, "got" parsed as a defines object.
+  /^what (?:have|do) (?:you|u) (?:got|have)(?:\s+for\s+me)?(?:\s+(?:here|then|today))?\??$/i,
+  // "tell me about this repo" — the orientation request by name; the
+  // vocabulary touch lane must not read "this repo" as a concept term.
+  /^tell me(?:\s+(?:something|more|a\s+little|a\s+bit))?\s+about (?:this|the|your)\s+(?:app|codebase|repo|repository|project|code)\??$/i,
   // "what can you actually help with" — the natural pivot from small talk
   // into a capability question; not covered by the "do" pair above since
   // neither accepts "help (me)? with" as a synonym tail for "do".
@@ -1434,16 +1489,17 @@ function conversationalTurn(line, ctx) {
   const raw = String(line);
   const q = raw.toLowerCase().replace(/[.!?]+$/, "").replace(/\s+/g, " ").trim();
   const t = (id, slots = {}) => tRender(ctx.templates, id, slots) ?? TEMPLATES_UNAVAILABLE;
-  const mk = (answer, { end = false, miss = false, via = "template" } = {}) => {
+  const mk = (answer, { end = false, miss = false, via = "template", lane = null } = {}) => {
     const ts = new Date().toISOString();
-    return {
+    return attachDialogueAct({
       answer,
       logLines: [ts, `> ${raw}`, answer, ""],
       record: { type: "turn", ts, query: raw, conversational: true, via, resolvedIds: [], answeredIds: [], miss },
       focus: ctx.focus,
       last: ctx.last, // a conversational turn never overwrites the last real answer
+      lane,
       ...(end ? { end: true } : {}),
-    };
+    }, ctx.trace);
   };
   if (foldedBye(q)) {
     note(ctx.trace, "goal: casual/social — ending the session (no graph intent)");
@@ -1465,7 +1521,7 @@ function conversationalTurn(line, ctx) {
     if (signal === "thanks") {
       note(ctx.trace, "goal: casual/social — acknowledgement, no graph intent");
       note(ctx.trace, "lane: conversational — thanks (multi-clause phrase-shape match)");
-      return mk(t(T_THANKS));
+      return mk(t(T_THANKS), { lane: "thanks" });
     }
   }
   if (WHY.has(q)) {
@@ -1494,7 +1550,7 @@ function conversationalTurn(line, ctx) {
       // morning, hello there) keep their wording; only the default greeting swaps.
       const id = (!T_GREETING_BY_PHRASE[greetHit] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[greetHit] || T_GREETING);
       note(ctx.trace, `pattern: template "${id}" (data/templates/responses.jsonl)`);
-      return mk(t(id, { vocabHint: ctx.vocabHint }));
+      return mk(t(id, { vocabHint: ctx.vocabHint }), { lane: "greeting" });
     }
   }
   {
@@ -1503,23 +1559,23 @@ function conversationalTurn(line, ctx) {
       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"})`);
       note(ctx.trace, `pattern: template "${T_THANKS}" (data/templates/responses.jsonl)`);
-      return mk(t(T_THANKS));
+      return mk(t(T_THANKS), { lane: "thanks" });
     }
   }
   if (aiIdentityMatch(raw)) {
     note(ctx.trace, "goal: identity — is tmct an AI/LLM (a very likely first question)");
     note(ctx.trace, "lane: conversational — identity/AI (AI_IDENTITY_PHRASES closed set)");
-    return mk(t(T_IDENTITY_NOT_LLM));
+    return mk(t(T_IDENTITY_NOT_LLM), { lane: "help" });
   }
   if (FEELINGS_PHRASES.some((re) => re.test(raw))) {
     note(ctx.trace, "goal: identity — does tmct have feelings/consciousness (small-talk persona finding)");
     note(ctx.trace, "lane: conversational — identity/feelings (FEELINGS_PHRASES closed set)");
-    return mk(t(T_IDENTITY_NO_FEELINGS));
+    return mk(t(T_IDENTITY_NO_FEELINGS), { lane: "help" });
   }
   if (IDENTITY_PHRASES.some((re) => re.test(raw))) {
     note(ctx.trace, "goal: identity — who/what tmct is, not a capability listing");
     note(ctx.trace, "lane: conversational — identity (IDENTITY_PHRASES closed set)");
-    return mk(t(T_IDENTITY_SELF));
+    return mk(t(T_IDENTITY_SELF), { lane: "help" });
   }
   // CAPABILITY_PHRASES' vague-opener entries are self-contained closed
   // regexes, but a preamble ahead of one ("right, can you walk me through
@@ -1531,7 +1587,7 @@ function conversationalTurn(line, ctx) {
     || CAPABILITY_PHRASES.some((re) => re.test(applyPreambleFrames(raw))) || ORIENT_OPENERS.has(q)) {
     note(ctx.trace, "goal: get oriented — what can tmct answer, how do I start");
     note(ctx.trace, "lane: conversational — help/orientation (CAPABILITY_PHRASES/ORIENT_OPENERS / bare help / ?)");
-    return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint));
+    return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint), { lane: "help" });
   }
   // Fuzzy-typo fallback (A4): every exact/collapsed closed-set lookup above missed —
   // try a bounded edit-distance match against the flattened conversational phrase
@@ -1544,11 +1600,11 @@ function conversationalTurn(line, ctx) {
       note(ctx.trace, `goal: casual/social or orientation — fuzzy-typo match "${raw}" → "${fuzzyHit}"`);
       note(ctx.trace, `lane: conversational — fuzzy typo tolerance (${bucket})`);
       if (bucket === "bye") return mk(t(T_FAREWELL), { end: true });
-      if (bucket === "thanks") return mk(t(T_THANKS));
-      if (bucket === "identity") return mk(t(T_IDENTITY_SELF));
-      if (bucket === "capability") return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint));
+      if (bucket === "thanks") return mk(t(T_THANKS), { lane: "thanks" });
+      if (bucket === "identity") return mk(t(T_IDENTITY_SELF), { lane: "help" });
+      if (bucket === "capability") return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint), { lane: "help" });
       const id = (!T_GREETING_BY_PHRASE[fuzzyHit] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[fuzzyHit] || T_GREETING);
-      return mk(t(id, { vocabHint: ctx.vocabHint }));
+      return mk(t(id, { vocabHint: ctx.vocabHint }), { lane: "greeting" });
     }
   }
   return null;
@@ -2141,7 +2197,17 @@ const PLAN_NEXT_RE = /^(?:next|next\s+move|go\s+on|continue)[.!?\s]*$/i;
 // class term, the preposition and the target — the caller singularizes the
 // term and normalizes "onto"→"on" before the same verbless resolution runs.
 const GOAL_TEACH_IMPERATIVE_RE = new RegExp(
-  `^(?:get|put|place)\\s+(?:(every|each|all|both)\\s+)?(?:the\\s+)?([\\w-]+?)\\s+(${PREP_SRC})\\s+([\\w-]+)[?.!]*$`, "i");
+  `^(?:get|put|place|stack)\\s+(?:(every|each|all|both)\\s+)?(?:the\\s+)?([\\w-]+?)\\s+(${PREP_SRC})\\s+([\\w-]+)[?.!]*$`, "i");
+// The bare-NP voicing of the same goal ("the goal is all disks on peg-c") —
+// no "that", no "for", no verb. Folds into the verbless resolution exactly
+// like the imperative above (same captures, same singularize/prep fold).
+const GOAL_TEACH_NP_RE = new RegExp(
+  `^the\\s+goal\\s+is\\s+(?:(every|each|all|both)\\s+)?(?:the\\s+)?([\\w-]+?)\\s+(${PREP_SRC})\\s+([\\w-]+)[?.!]*$`, "i");
+// A conjunction of goal atoms ("the goal is that disk-1 rests on peg-b and
+// disk-3 rests on peg-c") — each conjunct compiles to its own goal spec.
+const GOAL_TEACH_CONJUNCTION_RE = /^the\s+goal\s+is\s+that\s+(.+?)[.!?]*$/i;
+const GOAL_CONJUNCT_RE = new RegExp(
+  `^(?:(every|each|all)\\s+)?([\\w-]+)\\s+([a-z]+s)\\s+(${PREP_SRC})\\s+([\\w-]+)$`, "i");
 // Plan follow-up questions, answered off the ACTIVE plan state (never invented
 // when no plan stands). "next move"/"continue" EXECUTE (PLAN_NEXT_RE above); these
 // three only REPORT.
@@ -2158,6 +2224,11 @@ const BOARD_REVERSE_LOC_RE = new RegExp(
 const BOARD_FORWARD_LOC_RE = new RegExp(
   `^what\\s+(?:does|do|is)\\s+([\\w-]+)\\s+([a-z]+)(?:\\s+(${PREP_SRC}))?[?.!\\s]*$`, "i");
 const BOARD_WHERE_RE = /^(?:where\s+is|where's)\s+([\w-]+)(?:\s+now)?[?.!\s]*$/i;
+// "where does disk-1 rest?" — the verbed spelling of the same board read;
+// without it the phrasing fell through to the code definition-locator.
+const BOARD_WHERE_DOES_RE = /^where\s+does\s+([\w-]+)\s+([a-z]+)(?:\s+now)?[?.!\s]*$/i;
+// "where is every disk" — the same read over every member of a taught class.
+const BOARD_WHERE_EVERY_RE = /^where\s+(?:is|are)\s+(?:every|each|all(?:\s+the)?)\s+([\w-]+?)[?.!\s]*$/i;
 
 /** "<X> is <adjective>" — the property teach payload (wrapper-REQUIRED): a lazy
  *  subject and a single bare complement word. Never matches the "is a <noun>"
@@ -2693,6 +2764,11 @@ const GENERAL_VERB_DETERMINER_TEACH_RE = new RegExp(
   `^(?:the\\s+|an?\\s+)([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+([a-z]+)\\s+(${PREP_SRC})\\s+(.+?)[.!?]*$`,
   "i",
 );
+/** 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;
 /** 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
@@ -2837,13 +2913,20 @@ async function generalVerbTeach(payload) {
   // with the preposition pinning the verb; a sentence that frame can't pin
   // declines here exactly as it always has.
   if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) {
-    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
-    subjectRaw = det[1];
-    verbRaw = det[2];
-    // hand the preposition back to the shared fold below, so the minted
-    // predicate comes from the one place that mints it
-    objectRaw = `${det[3]} ${det[4]}`;
+    const quantHas = p.match(QUANTIFIED_HAS_TEACH_RE);
+    if (quantHas) {
+      subjectRaw = singularizeSurface(quantHas[1]);
+      verbRaw = "has";
+      objectRaw = quantHas[2];
+    } 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
+      subjectRaw = det[1];
+      verbRaw = det[2];
+      // hand the preposition back to the shared fold below, so the minted
+      // predicate comes from the one place that mints it
+      objectRaw = `${det[3]} ${det[4]}`;
+    }
   }
   const verb = verbRaw.toLowerCase();
   if (GENERAL_VERB_EXCLUDE_RE.test(verb)) return null; // owned by a more specific frame above
@@ -3462,7 +3545,22 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
           };
         }
       }
-      // nothing stored to disagree with — fall through (see the gate above).
+      // Nothing stored to disagree with. The gate above is right to refuse
+      // storing a bare negative with no positive behind it — but a subject
+      // the store has never heard of fell PAST every teach lane onto the
+      // code-question bootstrap message, which reads as a different product.
+      // Decline by name instead, saying what would make the claim usable. A
+      // KNOWN subject still falls through — the property/relation frames
+      // downstream own those sentences.
+      if (!priorRows.some((r) => r.subject === negSubject || r.object === negSubject)) {
+        return {
+          text: `I don't have anything about "${negSubject}" to attach "not ${negObject}" to — a bare negative with no positive to disagree with isn't stored. `
+            + `Teach me "${negSubject} is ${indefiniteArticleFor(negObject)} ${negObject}" first if that's the disagreement you mean, `
+            + `or "no ${negSubject} is a ${negObject}" to store the exclusion outright.`,
+          via: "teach-miss", miss: true,
+        };
+      }
+      // a known subject with no stored positive — fall through (see the gate above).
     }
 
     // RETRACTION — "forget that X is a Y": wires the data-layer retraction
@@ -3480,9 +3578,9 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     //     claiming a specific, possibly-wrong reason.
     if (retractForgetMatch) {
       const { retractSubClassOf } = await import("../domain/syllogise.mjs");
-      const { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts } = await import("../adapters/memory/core.mjs");
+      const { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts, appendFacts: appendFactsForRetract } = await import("../adapters/memory/core.mjs");
       const result = await retractSubClassOf(memoryDir, retractSubject, retractObject, {
-        store: { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts },
+        store: { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts, appendFacts: appendFactsForRetract },
       });
       if (result.found) {
         const extra = result.count - 1; // beyond the target fact itself
@@ -3947,7 +4045,9 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // of THAT subject — the same word generalVerbTeach will store — and leave
     // every other sentence reading its first word exactly as before.
     const detLed = raw.match(GENERAL_VERB_DETERMINER_TEACH_RE);
-    const subjectWord = detLed ? detLed[1].split(/\s+/).pop() : raw.match(/^([\w'-]+)/)?.[1];
+    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))) {
       // A PLURAL explicit-capability surface ("wrens can hum") whose
       // SINGULAR is a grounded term stores under the singular first — the
@@ -4285,15 +4385,48 @@ async function moduleOrientLane(query, { graph }) {
   // rich, module-grain overview with a thin one. Gated on the term looking
   // like a path, so this widens the lane by exactly the shape that was
   // missing and can never claim a vocabulary question.
-  const identity = m ? null : (q.match(MODULE_IDENTITY_RE)?.[1]?.trim() ?? q);
-  const term = m ? m[1].trim() : (identity && MODULE_PATH_RE.test(identity) ? identity : null);
-  if (!term) return null;
-  if (/^(?:it|this|that|they|them)$/i.test(term)) return null;
-  const ent = await resolveEntity(graph, term);
-  if (!ent) return null;
-  const ind = graph.byId?.get?.(ent.id);
-  if (!ind) return null;
-  return { text: moduleOverviewText(graph, ind), via: "meta" };
+  const identityMatch = m ? null : (q.match(MODULE_IDENTITY_RE)?.[1]?.trim() ?? null);
+  const phrase = m ? m[1].trim() : (identityMatch ?? q);
+  if (!phrase) return null;
+  if (/^(?:it|this|that|they|them)$/i.test(phrase)) return null;
+  const bare = phrase.replace(/^(?:the|a|an)\s+/i, "").trim();
+  const phraseWords = bare.split(/\s+/);
+  const pathTail = phraseWords[phraseWords.length - 1];
+  // Only an ANCHORED phrasing (the orient/purpose match, or the "what is X"
+  // identity match) may read a modifier-plus-path-tail phrase — the bare-q
+  // fallback stays gated to a lone path shape, or any sentence that happens
+  // to end in a module path would be claimed here.
+  const tailLooksLikePath = !!(m || identityMatch) && phraseWords.length > 1 && MODULE_PATH_RE.test(pathTail);
+  // The identity phrasing ("what is <term>") only ever claims a path-shaped
+  // term — bare, or with modifier words ahead of a path-shaped tail; the
+  // orient/purpose phrasings carry their own anchors.
+  if (!m && !MODULE_PATH_RE.test(bare) && !tailLooksLikePath) return null;
+  const ent = await resolveEntity(graph, m ? phrase : bare);
+  if (ent) {
+    const ind = graph.byId?.get?.(ent.id);
+    if (!ind) return null;
+    return { text: moduleOverviewText(graph, ind), via: "meta" };
+  }
+  // The stale-modifier residue guard the ask engine's resolver applies,
+  // carried into this lane: modifier words the graph has no reading for never
+  // resolve past silently ("the OLD store.mjs" is not store.mjs — the
+  // modifier may be the question). Decline by name, pointing at the near
+  // match, instead of falling to the bare wall.
+  if (tailLooksLikePath) {
+    const tailEnt = await resolveEntity(graph, pathTail);
+    if (tailEnt) {
+      const residue = phraseWords.slice(0, -1);
+      const quoted = residue.map((w) => `"${w}"`).join(" and ");
+      const names = residue.length === 1 ? "names" : "name";
+      const past = residue.length === 1 ? "it" : "them";
+      return {
+        text: `no module matching "${bare}" found in the index. ${quoted} ${names} nothing here, and reading past ${past} would answer a different question. Did you mean ${tailEnt.label}?`,
+        via: "meta",
+        miss: true,
+      };
+    }
+  }
+  return null;
 }
 
 async function metaLane(query, { graph, memoryDir, last = null, templates = null, vocabHint = null, focus = null }) {
@@ -5042,6 +5175,21 @@ function isaPolarityReply(hit, negHit) {
   return null;
 }
 
+/** The verdict when a would-be "yes" (a stored fact or a proof chain) crosses
+ *  a stored disjointness on the same resolved chain: name both stored facts
+ *  and refuse to conclude. A proof is the strongest honesty claim this file
+ *  makes, and certifying one side of a stored contradiction would launder the
+ *  inconsistency as a derivation — so neither side wins, same discipline as
+ *  isaPolarityReply's both-sides verdict. */
+function isaInconsistencyRefusal(posFact, disjointFact) {
+  const cite = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${f.provenance})` : ""}`;
+  return {
+    text: `you've told me both ${cite(posFact)} and ${cite(disjointFact)} — together those contradict, and I won't derive an answer from an inconsistency. `
+      + `To settle it, say "forget that ${posFact.subject} is ${indefiniteArticleFor(posFact.object)} ${posFact.object}".`,
+    replace: true,
+  };
+}
+
 /** PROOF-CHAIN RECEIPT — "renderable as a chain of thought in words": render
  *  an ordered list of
  *  premise Fact rows as one continuous argument — "cache is a kind of store;
@@ -5142,6 +5290,17 @@ function teachableSubjectOf(subject) {
   }
 }
 
+/** The teach-shaped restatement of a QUANTIFIED-PLURAL subject: "all dogs"
+ *  folds to "a dog", so an offered sentence stays grammatical and teachable —
+ *  echoing the quantifier into a singular frame produced "all dogs is
+ *  mortal". Any other subject keeps teachableSubjectOf's own reading. */
+function suggestibleSubjectPhrase(subject) {
+  const m = String(subject || "").trim().match(/^(?:all|every|each|both|most|some)\s+([\w-]+)$/i);
+  if (!m) return teachableSubjectOf(subject);
+  const singular = teachableSubjectOf(singularizeSurface(m[1]));
+  return `${indefiniteArticleFor(singular)} ${singular}`;
+}
+
 /** A leading universal quantifier, which is scaffolding rather than part of a
  *  name. The teach frames strip exactly these before storing (UNKNOWN_SUBJECT_RE
  *  above carries the same set), so no fact is ever stored under a subject that
@@ -6149,8 +6308,19 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
   if (isa) {
     const subj = factTermVariants(normFactTerm, isa[1]);
     const obj = factTermVariants(normFactTerm, isa[2]);
-    const isaRows = await memoryFacts(memoryDir);
+    const isaRows = await factRows(memoryDir, cache);
     const onTerms = (f) => subj.has(f.subject) && obj.has(f.object);
+    // A TAUGHT disjointness touching either asked term can flip or veto the
+    // verdict — it is the negative side of the polarity when it links the
+    // asked terms directly, and a positive whose ⊑-chain crosses one is a
+    // stored contradiction, not a yes. That reasoning (and its refusal) lives
+    // in the full is-a ladder, so this quick reader stands aside for it
+    // rather than answering a yes it hasn't checked.
+    const { DISJOINT_PREDICATE } = await import("../domain/syllogise.mjs");
+    const touchesAskedTerm = (f) => subj.has(f.subject) || subj.has(f.object) || obj.has(f.subject) || obj.has(f.object);
+    if (isaRows.some((f) => f.predicate === DISJOINT_PREDICATE && isOperatorTaught(f) && touchesAskedTerm(f))) {
+      return null;
+    }
     // A remembered NEGATIVE is read on the same terms as the positive — it
     // carries its own predicate and so never reaches ISA_PREDICATES.
     const reply = isaPolarityReply(
@@ -6193,19 +6363,32 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     return capabilityBaseRateReply(can[1], can[2], facts);
   }
 
-  // (b2b) "does a dog have a tail" — yes iff a remembered mgx:hasA fact says
-  // so: the forward yes/no mirror of WHAT_HAS_RE below, with the same
+  // (b2b) "does a dog have a tail" — yes iff a remembered possession fact
+  // says so: the forward yes/no mirror of WHAT_HAS_RE below, with the same
   // single-hit lookup and "never a guessed no" discipline as CAN_ASK_RE
   // above. Only diverts on a REAL hit, so a code-shaped "does app.mjs have
-  // tests" (no hasA fact) keeps whatever miss text already stands.
+  // tests" (no possession fact) keeps whatever miss text already stands.
+  // Both possession spellings are read (the corpus mints mgx:hasA, the teach
+  // lane tmct:has), and the lookup lifts one taught ⊑-hop so "does rex have
+  // fur" answers through "rex is a kind of dog; dog has fur", citing both.
   const doesHave = q.match(DOES_HAVE_ASK_RE);
   if (doesHave) {
     const subj = factTermVariants(normFactTerm, doesHave[1]);
     const obj = factTermVariants(normFactTerm, doesHave[2]);
-    const hit = (await memoryFacts(memoryDir)).find(
-      (f) => f.predicate === "mgx:hasA" && subj.has(f.subject) && obj.has(f.object),
+    const HAS_PREDICATES = new Set(["mgx:hasA", "tmct:has"]);
+    const facts = await memoryFacts(memoryDir);
+    const hasHit = (subjectSet) => facts.find(
+      (f) => HAS_PREDICATES.has(f.predicate) && subjectSet.has(f.subject) && obj.has(f.object),
     );
+    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));
+      if (lifted) {
+        return { text: `yes — ${renderFactLine(isaStep)}; ${renderFactLine(lifted)}`, replace: true };
+      }
+    }
     return null;
   }
 
@@ -6244,6 +6427,22 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
       }
       const base = capabilityBaseRateReply(doAsk[2], doAsk[3], facts);
       if (base) return base;
+      // A subject NO fact row mentions on either side has nothing to answer
+      // from at all — without this the turn fell through to the
+      // conversational catch-all, which answered a question about penguins
+      // with the identity blurb. Decline by name, with the round-trip teach
+      // hint, and stay a miss. SINGLE-WORD subjects only: a multi-word
+      // capture here is this loose shape misbinding a subject+verb ("does
+      // margo eat ribs" reads [margo eat][ribs]), and a later reader owns
+      // that sentence — the same keep-its-turn rule as the fall-through above.
+      if (!/\s/.test(doAsk[2].trim()) && !facts.some((f) => subj.has(f.subject) || subj.has(f.object))) {
+        const noun = singularizeSurface(teachableSubjectOf(doAsk[2]));
+        return {
+          text: `I can't confirm that — I don't know anything about "${doAsk[2]}" yet. Teach me "a ${noun} can ${doAsk[3]}" (or "a ${noun} cannot ${doAsk[3]}") and I'll remember it.`,
+          replace: true,
+          miss: true,
+        };
+      }
     }
   }
 
@@ -6551,7 +6750,11 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
  *  pipeline even gets a look) would wrongly swallow that idiom as a
  *  vocabulary-term lookup for the literal term "in X". */
 const WHAT_ELSE_IS_RE = /^what\s+else\s+(?:is|are)\s+(?!in\b|inside\b)(?:an?\s+)?(.+?)[?.!\s]*$/i;
-const WHAT_ELSE_ABOUT_RE = /^what\s+else\s+(?:do\s+you\s+know\s+)?about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
+const WHAT_ELSE_ABOUT_RE = /^(?:what|anything)\s+else\s+(?:do\s+you\s+know\s+)?about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
+/** "what else can dogs do" — the capability spelling of the same beyond-the-
+ *  primary-answer question; the subject's remaining facts (capabilities
+ *  included) are the expansion it asks for. */
+const WHAT_ELSE_CAN_DO_RE = /^what\s+else\s+can\s+(?:an?\s+|the\s+)?(.+?)\s+do[?.!\s]*$/i;
 /** The same question with its subject left implicit — "what else", "anything
  *  else", "what else do you know". A reader who has just been told about dogs
  *  and asks "what else" means "what else about dogs"; the subject is carried by
@@ -6581,7 +6784,7 @@ const WHAT_ELSE_BARE_RE = /^(?:(?:and|so|but|ok|okay|now|then)\s+)*(?:what\s+els
 async function whatElseAnswer(memoryDir, query, last) {
   if (!memoryDir) return null;
   const q = String(query).trim();
-  const m = q.match(WHAT_ELSE_IS_RE) || q.match(WHAT_ELSE_ABOUT_RE);
+  const m = q.match(WHAT_ELSE_IS_RE) || q.match(WHAT_ELSE_ABOUT_RE) || q.match(WHAT_ELSE_CAN_DO_RE);
   // A bare "what else" takes its subject from the standing referent — the same
   // last-grounded-answer binding "can it bark" uses.
   const bare = !m && WHAT_ELSE_BARE_RE.test(q);
@@ -7295,18 +7498,76 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     const isaSubject = focusLabel && IS_ADJECTIVE_PRONOUN_RE.test(isaAsk[1].trim())
       ? focusLabel : isaAsk[1];
     const subjCandidates = new Set(factTermVariants(normFactTerm, isaSubject));
+    // REFLEXIVE subsumption — "is a dog a dog" holds by definition (⊑ is
+    // reflexive, whatever the term); without this it fell to the can't-confirm
+    // closer, which then offered to be taught "dog is a kind of dog".
+    if ([...subjCandidates].some((s) => objVariants.has(s))) {
+      const kindEcho = stripTrailingDiscourseTag(isaAsk[2]).trim();
+      return {
+        text: `yes — ${indefiniteArticleFor(kindEcho)} ${kindEcho} is ${indefiniteArticleFor(kindEcho)} ${kindEcho}, trivially: every kind is a kind of itself.`,
+        replace: true,
+      };
+    }
     const noun = await entityClassNoun(graph, isaSubject);
     if (noun) for (const v of factTermVariants(normFactTerm, noun)) subjCandidates.add(v);
+    const {
+      findIsaChain, deriveDisjointViolations,
+      SUBCLASS_PREDICATE: SC_PREDICATE, TYPE_PREDICATE: RDF_TYPE_PREDICATE, DISJOINT_PREDICATE,
+    } = await import("../domain/syllogise.mjs");
+    const isTaught = isOperatorTaught;
+    const chainSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE && isTaught(f));
+    const chainTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE && isTaught(f));
+    const chainSubClassEdges = chainSubClassRows.map((f) => [f.subject, f.object]);
+    const chainTypeEdges = chainTypeRows.map((f) => [f.subject, f.object]);
+    const mixedSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE);
+    const mixedTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE);
+    const mixedTypeEdges = mixedTypeRows.map((f) => [f.subject, f.object]);
+    const mixedSubClassEdges = mixedSubClassRows.map((f) => [f.subject, f.object]);
+    const disjointRows = rows.filter((f) => f.predicate === DISJOINT_PREDICATE && isTaught(f));
+    const disjointEdges = disjointRows.map((f) => [f.subject, f.object]);
+    // CAX-DW GATE, COMPUTED BEFORE ANY "YES" MAY RETURN: every taught
+    // disjointness is lifted through the full ⊑-closure (subclass edges double
+    // as type edges here, because an instance teach like "rex is a dog" stores
+    // rdfs:subClassOf) and held against the asked conclusion. A "yes" whose
+    // resolved chain crosses one of these would certify a stored
+    // contradiction, so the gate runs ahead of the direct-fact verdict and
+    // both proof chases below — never after them, where it can only lose.
+    const disjointGateViolations = disjointRows.length
+      ? deriveDisjointViolations(
+        mixedTypeEdges.concat(mixedSubClassEdges), mixedSubClassEdges, disjointEdges,
+        { budget: 20, focus: new Set([...subjCandidates, ...objVariants]) },
+      )
+      : [];
+    const disjointRefusalFor = (subj) => {
+      const v = disjointGateViolations.find((vv) => vv.subject === subj && objVariants.has(vv.object));
+      if (!v) return null;
+      const posFact = isa
+        .filter((f) => objVariants.has(f.object) && (f.subject === v.viaClass || f.subject === v.subject))
+        .sort(byTrust)[0];
+      const disjointFact = disjointRows.find((f) => (f.subject === v.viaClass && f.object === v.object)
+        || (f.subject === v.object && f.object === v.viaClass));
+      if (!posFact || !disjointFact) return null;
+      return isaInconsistencyRefusal(posFact, disjointFact);
+    };
     const hit = isa
       .filter((f) => subjCandidates.has(f.subject) && objVariants.has(f.object))
       .sort(byTrust)[0];
     // A STORED NEGATIVE ("john is not a man") is a source disagreeing, so it is
     // read on the same terms as the positive rather than losing to it by
-    // default. It carries its own predicate and so never reaches `isa`.
+    // default. It carries its own predicate and so never reaches `isa`. A
+    // taught disjointness directly between the asked terms is the same
+    // disagreement in owl:disjointWith spelling, so it reads as the negative
+    // side on the same terms — ahead of every yes-chase, not after them.
     const negHit = rows
       .filter((f) => f.predicate === NEG_SUBCLASS_PREDICATE && subjCandidates.has(f.subject) && objVariants.has(f.object))
       .sort(byTrust)[0];
-    const polarityReply = isaPolarityReply(hit, negHit);
+    const directDisjoint = disjointRows.find((f) => (subjCandidates.has(f.subject) && objVariants.has(f.object))
+      || (subjCandidates.has(f.object) && objVariants.has(f.subject)));
+    if (hit && !negHit) {
+      const chainRefusal = disjointRefusalFor(hit.subject);
+      if (chainRefusal) return chainRefusal;
+    }
+    const polarityReply = isaPolarityReply(hit, negHit || directDisjoint);
     if (polarityReply) return polarityReply;
     // CLASS↔INSTANCE BRIDGE: when X resolves to a graph entity, its
     // inherits chain's superclass LABELS are subject candidates too — a taught
@@ -7348,17 +7609,13 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     //     technically-true-per-ConceptNet "yes" that has nothing to do with
     //     what the OPERATOR taught; only operator/teach/entailed-sourced isa
     //     facts are chased, matching "TAUGHT" in the gap's own name.
-    const { findIsaChain, SUBCLASS_PREDICATE: SC_PREDICATE, TYPE_PREDICATE: RDF_TYPE_PREDICATE } = await import("../domain/syllogise.mjs");
-    const isTaught = isOperatorTaught;
-    const chainSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE && isTaught(f));
-    const chainTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE && isTaught(f));
-    const chainSubClassEdges = chainSubClassRows.map((f) => [f.subject, f.object]);
-    const chainTypeEdges = chainTypeRows.map((f) => [f.subject, f.object]);
     const factForStep = (step) => (step.predicate === SC_PREDICATE ? chainSubClassRows : chainTypeRows)
       .find((f) => f.subject === step.subject && f.object === step.object);
     for (const subj of subjCandidates) {
       const chain = findIsaChain(subj, objVariants, chainTypeEdges, chainSubClassEdges, { maxHops: 2 });
       if (!chain) continue;
+      const chainRefusal = disjointRefusalFor(subj);
+      if (chainRefusal) return chainRefusal;
       const premises = chain.map(factForStep);
       if (premises.every(Boolean)) return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
     }
@@ -7373,15 +7630,13 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // every premise is cited with its own source, corpus ones included. The
     // shared taught-only rows above stay untouched: the disjoint and
     // someValuesFrom chases keep their original, narrower discipline.
-    const mixedSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE);
-    const mixedTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE);
     const mixedFactForStep = (step) => (step.predicate === SC_PREDICATE ? mixedSubClassRows : mixedTypeRows)
       .find((f) => f.subject === step.subject && f.object === step.object);
-    const mixedTypeEdges = mixedTypeRows.map((f) => [f.subject, f.object]);
-    const mixedSubClassEdges = mixedSubClassRows.map((f) => [f.subject, f.object]);
     for (const subj of subjCandidates) {
       const chain = findIsaChain(subj, objVariants, mixedTypeEdges, mixedSubClassEdges, { maxHops: 2 });
       if (!chain) continue;
+      const chainRefusal = disjointRefusalFor(subj);
+      if (chainRefusal) return chainRefusal;
       const premises = chain.map(mixedFactForStep);
       if (premises.every(Boolean) && premises.some(isTaught)) {
         return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
@@ -7397,8 +7652,6 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // answer "no" from absence-of-membership rather than decline; anything
     // this chase can't connect through a stated disjointness falls through
     // to the honest miss below, never a guessed "no".
-    const { deriveDisjointViolations, DISJOINT_PREDICATE } = await import("../domain/syllogise.mjs");
-    const disjointRows = rows.filter((f) => f.predicate === DISJOINT_PREDICATE && isTaught(f));
     // NEGATED membership — "is a dog not a cat". ISA_ASK_RE captures the
     // subject as "dog not" (the "not" glues onto the subject because the
     // article anchors the kind), so without this the negated question walks
@@ -7437,20 +7690,16 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       };
     }
     if (disjointRows.length) {
-      // A DIRECT taught disjointness between the asked subject and kind is a
-      // provable "no" on its own — deriveDisjointViolations only ever fires
-      // through a taught rdf:type premise, so without this check "no dog is
-      // a cat" followed by "is a dog a cat" fell through to the can't-confirm
-      // closer instead of the honest no.
-      const directDisjoint = disjointRows.find((f) => (subjCandidates.has(f.subject) && objVariants.has(f.object))
-        || (subjCandidates.has(f.object) && objVariants.has(f.subject)));
-      if (directDisjoint) return { text: `no — ${renderFactLine(directDisjoint)}`, replace: true };
-      const disjointEdges = disjointRows.map((f) => [f.subject, f.object]);
-      const violations = deriveDisjointViolations(chainTypeEdges, chainSubClassEdges, disjointEdges, { budget: 10 });
+      // Taught subclass edges double as type edges here, because an instance
+      // teach ("felix is a cat") stores rdfs:subClassOf — without the fold the
+      // instance form of the provable "no" never fired.
+      const violations = deriveDisjointViolations(
+        chainTypeEdges.concat(chainSubClassEdges), chainSubClassEdges, disjointEdges, { budget: 10 },
+      );
       for (const subj of subjCandidates) {
         const v = violations.find((vv) => vv.subject === subj && objVariants.has(vv.object));
         if (!v) continue;
-        const typeFact = chainTypeRows.find((f) => f.subject === v.subject && f.object === v.viaType);
+        const typeFact = chainTypeRows.concat(chainSubClassRows).find((f) => f.subject === v.subject && f.object === v.viaType);
         const disjointFact = disjointRows.find((f) => (f.subject === v.viaClass && f.object === v.object)
           || (f.subject === v.object && f.object === v.viaClass));
         const parts = [typeFact, disjointFact].filter(Boolean).map(renderFactLine);
@@ -7617,6 +7866,20 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         miss: true, // still a MISS in the turn record — honest wording, not an answer
       };
     }
+    // A stored CONVERSE ("every dog is a mammal" asked as "is a mammal a
+    // dog") deserves better than the bare wall: name the direction that IS
+    // known and why it doesn't answer. Still a miss, never a guessed "no" —
+    // some mammals may well be dogs; the store just doesn't say.
+    const converseHit = isa
+      .filter((f) => subjCandidates.has(f.object) && objVariants.has(f.subject))
+      .sort(byTrust)[0];
+    if (converseHit) {
+      return {
+        text: `I can't confirm that — what I know runs the other way: ${renderFactLine(converseHit)}. A kind doesn't reverse. If it's true, teach me: "every ${subjectWord} is a ${kindWord}".`,
+        replace: true,
+        miss: true,
+      };
+    }
     // Subject with NO isa facts: only divert when it's mentioned NOWHERE at
     // all (no fact row on either side, no code entity by id OR class noun) —
     // a subject known via OTHER predicates ("ahab is male") or the code graph
@@ -7945,7 +8208,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       // originally-intended case here) still gets this receipt exactly as
       // before, since envelope.parsed is null for those adjectives.
       if (rows.some(subjectMatch) && !envelope?.parsed) {
-        return { text: `I don't have a fact saying ${teachableSubjectOf(subject)} is ${adjective}.`, replace: true };
+        return { text: `I don't have a fact saying ${suggestibleSubjectPhrase(subject)} is ${adjective}.`, replace: true };
       }
       // Without this, "is the checkout flow
       // deprecated" as a genuinely FIRST-EVER question about a subject tmct
@@ -8282,7 +8545,17 @@ function discourseRewrite(query, last) {
   } else {
     const sm = String(query).match(STACCATO_SWAP_RE);
     const cand = sm?.[1]?.trim();
-    if (!cand || !NAME_TOKEN_RE.test(cand)) return null;
+    if (!cand) return null;
+    // VOCABULARY STACCATO: "tell me about a dog" -> "and a cat". The article
+    // plus a plain word is the gate on the NEW term (a bare "and stuff" never
+    // matches), and the PRIOR turn must itself have been a vocabulary
+    // 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);
+    const prevWasVocab = last?.query
+      && (BARE_WHATIS_RE.test(String(last.query)) || vagueTouchTermOf(String(last.query)));
+    if (articled && prevWasVocab) return `what is a ${singularizeSurface(articled[1])}`;
+    if (!NAME_TOKEN_RE.test(cand)) return null;
     newSubj = cand;
   }
   if (!last?.query) return null;
@@ -8556,6 +8829,46 @@ async function curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon })
   return { text: `${def} (source: corpus/seon)`, term };
 }
 
+// ---- learn-on-miss: the shipped reference pack behind the cleanest miss ----
+
+/** The learn-on-miss gate, shared by the articled miss hook and the bare-form
+ *  fallback so the two can never disagree. Fires only on the CLEANEST miss: a
+ *  definition-shaped term the lexicon knows, resolving to no graph entity and
+ *  no remembered fact — then, and only then, the pack provider is consulted.
+ *  Null means the turn proceeds byte-identically to a pack-less run. */
+async function referencePackMissAnswer(term, { graph, memoryDir, lexicon, env, cache }) {
+  if (!term || !memoryDir) return null;
+  let key = null;
+  try { key = cleanMissReferenceTerm(term, lexicon ?? undefined); } catch { key = null; }
+  if (!key) return null;
+  if (await resolveEntity(graph, term)) return null;
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
+  const variants = factTermVariants(normFactTerm, term);
+  variants.add(key);
+  const rows = await factRows(memoryDir, cache);
+  if (rows.some((f) => variants.has(f.subject) || variants.has(f.object))) return null;
+  let article = null;
+  try { article = await getReferencePackProvider(env).lookup(key); } catch { article = null; }
+  if (!article) return null;
+  return { key, article, text: renderReferenceAnswer(key, article) };
+}
+
+/** Store the article's first-sentence isa as a subClassOf fact carrying
+ *  reference provenance — AFTER the cited answer composed, and failure-
+ *  tolerated: the answer stands whether or not the fact lands. */
+async function appendReferenceIsaFact(memoryDir, key, article, cache) {
+  if (!article?.isa) return;
+  try {
+    const { appendFact } = await import("../adapters/memory/core.mjs");
+    await appendFact(memoryDir, {
+      subject: key, predicate: "rdfs:subClassOf", object: article.isa,
+      provenance: referenceProvenanceTag(article),
+    });
+    if (cache) cache.rows = null;
+  } catch { /* tolerated — the cited answer is already composed */ }
+}
+
 /** The concept term a vague "what is a X" / "tell me about X" / "what does X mean" /
  *  "define X" asks about — metaTermOf's forms plus the "tell me about …" opener that
  *  the graph parser reads as a count. Null when the line isn't such a touch. The
@@ -8598,7 +8911,7 @@ function vagueTouchTermOf(query) {
   q = q.replace(VAGUE_TOUCH_TEL_RE, "tell");
   q = q.replace(VAGUE_TOUCH_ABUT_RE, "about");
   q = applyPreambleFrames(q);
-  const m = q.match(/^(?:kindly\s+)?tell me about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i)
+  const m = q.match(/^(?:kindly\s+)?tell me (?:(?:something|a\s+little|a\s+bit|more)\s+)?about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i)
     || q.match(/^(?:(?:and|so|but|ok|okay|now|then|kindly)\s+)*what about\s+(?:an?\s+|the\s+)?(.+?)(?:\s+then|\s+though)?[?.!\s]*$/i)
     // "explain X" — a bare "explain <term>" is at least as natural a vague touch as "tell
     // me about X", but had no recognized shape at all: normalize.mjs's own
@@ -8687,7 +9000,7 @@ function relationTermOf(query, envelope) {
  *  "tell me" branch and a single external \s+ would double-count the
  *  separator when "about" fires. */
 const DESCRIBE_WRAPPER_RE =
-  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:tell\s+me\s+(?:more\s+)?(?:about\s+)?|describe\s+|what(?:'s|\s+is)?\s+about\s+)(.+?)(?:\s+for\s+me)?(?:\s+please)?\s*\??$/i;
+  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:tell\s+me\s+(?:(?:more|something|a\s+little|a\s+bit)\s+)?(?:about\s+)?|describe\s+|what(?:'s|\s+is)?\s+about\s+)(.+?)(?:\s+for\s+me)?(?:\s+please)?\s*\??$/i;
 
 /** Bare focus pronouns this lane resolves against the STANDING focus —
  *  "describe that" / "tell me about it" after a prior turn set the focus.
@@ -9147,15 +9460,28 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
   // the frame below once the store names the verb — same spec, same
   // confirmation, same fold as its verbed twin.
   let verblessGoal = goalMatch ? null : q.match(GOAL_TEACH_VERBLESS_RE);
-  // The imperative voicing ("get all the disks onto peg-c") folds into the same
-  // verbless resolution: singularize the class term ("disks"→"disk"), read the
+  // A conjunction of goal atoms ("the goal is that disk-1 rests on peg-b and
+  // disk-3 rests on peg-c") — every conjunct must compile, else the single-goal
+  // frames (and their honest declines) keep their turn.
+  let conjunctMatches = null;
+  if (!goalMatch && !verblessGoal) {
+    const conj = q.match(GOAL_TEACH_CONJUNCTION_RE);
+    if (conj && /\s+and\s+/i.test(conj[1])) {
+      const parts = conj[1].split(/\s+and\s+/i).map((p) => p.trim());
+      const matched = parts.map((p) => p.match(GOAL_CONJUNCT_RE));
+      if (parts.length > 1 && matched.every(Boolean)) conjunctMatches = matched;
+    }
+  }
+  // The imperative voicing ("get all the disks onto peg-c") and the bare-NP
+  // voicing ("the goal is all disks on peg-c") fold into the same verbless
+  // resolution: singularize the class term ("disks"→"disk"), read the
   // universal off the quantifier, and normalize the motion preposition to the
   // static one a location fact is stored under ("onto"→"on").
-  if (!goalMatch && !verblessGoal) {
-    const imperative = q.match(GOAL_TEACH_IMPERATIVE_RE);
-    if (imperative) {
-      const prep = { onto: "on", into: "in", upon: "on" }[imperative[3].toLowerCase()] ?? imperative[3].toLowerCase();
-      verblessGoal = [imperative[0], imperative[1] ? "every" : "", singularizeSurface(imperative[2]), prep, imperative[4]];
+  if (!goalMatch && !verblessGoal && !conjunctMatches) {
+    const bare = q.match(GOAL_TEACH_NP_RE) || q.match(GOAL_TEACH_IMPERATIVE_RE);
+    if (bare) {
+      const prep = { onto: "on", into: "in", upon: "on" }[bare[3].toLowerCase()] ?? bare[3].toLowerCase();
+      verblessGoal = [bare[0], bare[1] ? "every" : "", singularizeSurface(bare[2]), prep, bare[4]];
     }
   }
   if (verblessGoal) {
@@ -9178,29 +9504,35 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
     }
     goalMatch = [verblessGoal[0], verblessGoal[1], verblessGoal[2], verbs[0], verblessGoal[3], verblessGoal[4]];
   }
-  if (goalMatch) {
+  if (goalMatch || conjunctMatches) {
     const { normFactTerm } = await import("../adapters/memory/core.mjs");
-    const verb = await verbLemma(goalMatch[3]);
-    if (!verb) {
-      return {
-        text: `I can't reduce "${goalMatch[3]}" to a verb for that goal — try the plain form (e.g. "rests").`,
-        via: "plan", deduced: "record the goal state for a later plan", note: "GOAL frame — verb lemma unavailable, honest decline",
-      };
+    const items = conjunctMatches ?? [goalMatch];
+    const specs = [];
+    const tails = [];
+    for (const m of items) {
+      const verb = await verbLemma(m[3]);
+      if (!verb) {
+        return {
+          text: `I can't reduce "${m[3]}" to a verb for that goal — try the plain form (e.g. "rests").`,
+          via: "plan", deduced: "record the goal state for a later plan", note: "GOAL frame — verb lemma unavailable, honest decline",
+        };
+      }
+      specs.push({
+        universal: !!m[1],
+        term: normFactTerm(m[2]),
+        predicate: `${verb}-${m[4].toLowerCase()}`,
+        object: normFactTerm(m[5]),
+      });
+      // A conjunct restates itself; the that-form keeps its own words; the
+      // infinitive/verbless voicings restate as the that-form, so the goal
+      // check's own "done — …" line and the confirmation read identically.
+      tails.push(conjunctMatches
+        ? `${m[1] ? `${m[1].toLowerCase()} ` : ""}${m[2].toLowerCase()} ${m[3].toLowerCase()} ${m[4].toLowerCase()} ${m[5].toLowerCase()}`
+        : (thatGoal
+          ? 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 spec = {
-      universal: !!goalMatch[1],
-      term: normFactTerm(goalMatch[2]),
-      predicate: `${verb}-${goalMatch[4].toLowerCase()}`,
-      object: normFactTerm(goalMatch[5]),
-    };
-    const tail = thatGoal
-      ? q.replace(/^the\s+goal\s+is\s+that\s+/i, "").replace(/[.!?]+$/, "")
-      // The infinitive voicing restates as the that-form, so the goal check's
-      // own "done — …" line and the confirmation read identically either way.
-      : `${goalMatch[1] ? `${goalMatch[1].toLowerCase()} ` : ""}${goalMatch[2].toLowerCase()} ${verb}s ${goalMatch[4].toLowerCase()} ${goalMatch[5].toLowerCase()}`;
     const prev = planHolder.state && Array.isArray(planHolder.state.goals) && !planHolder.state.done ? planHolder.state : null;
-    const heldGoals = prev?.goals ?? [];
-    const heldTexts = prev?.goalTexts ?? [];
     // 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
@@ -9211,19 +9543,26 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
     // goals and goalTexts move in LOCKSTEP — "solve it" joins goalTexts by
     // index to describe the specs it compiled, so dropping one without the
     // other misaligns the plan's own account of what it is solving for.
-    const alreadyHeld = heldGoals.some((g) => sameGoalSpec(g, spec));
+    let heldGoals = prev?.goals ?? [];
+    let heldTexts = prev?.goalTexts ?? [];
+    let added = 0;
+    for (let i = 0; i < specs.length; i += 1) {
+      if (heldGoals.some((g) => sameGoalSpec(g, specs[i]))) continue;
+      heldGoals = [...heldGoals, specs[i]];
+      heldTexts = [...heldTexts, tails[i]];
+      added += 1;
+    }
     planHolder.state = {
-      goals: alreadyHeld ? heldGoals : [...heldGoals, spec],
-      goalTexts: alreadyHeld ? heldTexts : [...heldTexts, tail],
+      goals: heldGoals, goalTexts: heldTexts,
       actions: null, states: null, stepGoals: null, cursor: 0, done: false,
     };
-    const n = planHolder.state.goals.length;
+    const n = heldGoals.length;
     return {
-      text: `${alreadyHeld ? "already noted" : "noted"} — the goal is that ${tail}.${n > 1 ? ` (${n} goals held)` : ""} Say "solve it" when the state is taught.`,
-      via: "plan", deduced: "record the goal state for a later plan",
-      note: alreadyHeld
-        ? "GOAL frame — the same goal spec was already held, so it folded onto the existing one"
-        : "GOAL frame — goal spec accumulated on the session plan slot",
+      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.`,
+      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 — the same goal spec was already held, so it folded onto the existing one",
     };
   }
 
@@ -9282,6 +9621,24 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
   }
   const goals = planHolder.state.goals;
   const goalText = planHolder.state.goalTexts.join("; ");
+  // A goal naming a term the board and the taught classes have never heard of
+  // ("peg-z") can never be reached — decline by name BEFORE the search, so an
+  // unknown token is a named miss rather than a full-depth search burn.
+  const knownTerms = new Set([
+    ...Object.keys(domain.classMembers || {}),
+    ...Object.values(domain.classMembers || {}).flat(),
+    ...state.flatMap((r) => [r.subject, r.object]),
+  ]);
+  const unknownGoalTerms = [...new Set(goals.flatMap((g) => [g.term, g.object]))]
+    .filter((t) => t && !knownTerms.has(t));
+  if (unknownGoalTerms.length) {
+    const quoted = unknownGoalTerms.map((t) => `"${t}"`).join(" and ");
+    return {
+      text: `I can't plan toward that goal — ${quoted} name${unknownGoalTerms.length === 1 ? "s" : ""} nothing the board or the taught classes know. Teach ${unknownGoalTerms.length === 1 ? "it" : "them"} first (e.g. "${unknownGoalTerms[0]} is a peg").`,
+      via: "plan", deduced: "plan a move sequence (unknown goal term)",
+      note: "plan lane — honest decline: the goal names an untaught term, search never started",
+    };
+  }
   let isGoal;
   try {
     isGoal = compileGoal(goals, domain);
@@ -9327,14 +9684,22 @@ 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.
+  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 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.`
+    : "";
   const text = n === 0
-    ? `the goal already holds — nothing to do.`
+    ? `the goal already holds — nothing to do.${assumptionNote}`
     : `plan found — ${n} move${n === 1 ? "" : "s"} (shortest):\n${moveLines.join("\n")}\n\n` +
       `because — you taught me the "${ruleNames}" rule${domain.actions.length === 1 ? "" : "s"}` +
       `${ordering.length ? ` and ${ordering.length} ordering fact${ordering.length === 1 ? "" : "s"}` : ""}. ` +
-      `Say "next" to make move 1, or ask "what moves are legal now".`;
+      `Say "next" to make move 1, or ask "what moves are legal now".${assumptionNote}`;
   return {
-    text, via: "plan",
+    text, via: "plan", lane: "imperative",
     deduced: `plan a move sequence from the current state to the goal (${n} move${n === 1 ? "" : "s"})`,
     note: "plan lane — compileDomain + findActionPath over the taught rules; plan held on the session slot",
     plan,
@@ -9419,8 +9784,10 @@ async function planFollowUpAnswer(query, { memoryDir, planHolder }) {
   const clear = q.match(IS_CLEAR_RE);
   const rev = clear ? null : q.match(BOARD_REVERSE_LOC_RE);
   const fwd = clear || rev ? null : q.match(BOARD_FORWARD_LOC_RE);
-  const where = clear || rev || fwd ? null : q.match(BOARD_WHERE_RE);
-  if (!clear && !rev && !fwd && !where) return null;
+  const whereEvery = clear || rev || fwd ? null : q.match(BOARD_WHERE_EVERY_RE);
+  const where = clear || rev || fwd || whereEvery ? null
+    : (q.match(BOARD_WHERE_RE) || q.match(BOARD_WHERE_DOES_RE));
+  if (!clear && !rev && !fwd && !where && !whereEvery) return null;
   if (!memoryDir) return null;
 
   let ctx;
@@ -9438,6 +9805,20 @@ async function planFollowUpAnswer(query, { memoryDir, planHolder }) {
       ? { text: `no — ${x} is not clear: ${on.map(factPhrase).join("; ")}.`, deduced: "check whether a board piece is clear", note: "BOARD — clearness derived from the current board (a piece rests on it)" }
       : { text: `yes — ${x} is clear: nothing rests on it on the current board.`, deduced: "check whether a board piece is clear", note: "BOARD — clearness derived from the current board (nothing rests on it)" };
   }
+  if (whereEvery) {
+    const cls = normFactTerm(singularizeSurface(whereEvery[1]));
+    const members = domain.classMembers?.[cls] || [];
+    if (!members.length) return null; // not a taught class — the ordinary readers decide
+    const lines = members.map((mbr) => {
+      const rows = state.filter((r) => r.subject === mbr);
+      return rows.length ? rows.map(factPhrase).join("; ") : `nothing on the current board says where ${mbr} is`;
+    });
+    return {
+      text: lines.join("\n"),
+      deduced: "read the current board (where every member of a class is)",
+      note: "BOARD — forward locative for every member of the taught class",
+    };
+  }
   if (where || fwd) {
     const x = normFactTerm((where ?? fwd)[1]);
     if (!individuals.has(x)) return null;
@@ -9687,6 +10068,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // facts/recall (a fact EXTENDS a non-miss schema hit too — NOT miss-gated),
   // (4) TEACH lane (would-miss), (5) the short tailored miss (would-miss).
   let handled = false;
+  // The dialogue-act lane, when a lane below knows better than the final
+  // question-shape lookup (a plan frame is a request/instruct, a stored
+  // teach is an inform, whatever the surface punctuation looked like).
+  let dialogueLaneOverride = null;
   // (0) "what else is X" — recognized off the RAW query text, before every
   // other lane below (all of which read `envelope`, already relaxed/reparsed
   // by ask()'s noise-strip cascade, which silently drops "else"). via is set
@@ -9710,7 +10095,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   if (miss) {
     const meta = await metaLane(query, { graph, memoryDir, last, templates, vocabHint, focus });
     if (meta) {
-      answer = meta.text; via = meta.via; recordMiss = false; handled = true;
+      // A lane may answer with a better-worded decline (the module-orient
+      // residue guard) — still a miss in the turn record, like the isa
+      // ladder's own closers.
+      answer = meta.text; via = meta.via; recordMiss = meta.miss ?? false; handled = true;
       note(trace, `lane: (1) META/SELF — bare self/session question recognized, answered via="${meta.via}"`);
     }
   }
@@ -9723,6 +10111,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     const planLane = await planLaneAnswer(query, { memoryDir, planHolder, sessionId });
     if (planLane) {
       answer = planLane.text; via = planLane.via; recordMiss = false; handled = true;
+      if (planLane.lane) dialogueLaneOverride = planLane.lane;
       if (planLane.plan) planResult = planLane.plan;
       if (planLane.deduced) {
         deduced = planLane.deduced;
@@ -9916,6 +10305,14 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         const def = await curatedDefinitionAnswer(gateQuery, 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 ref = refTerm ? await referencePackMissAnswer(refTerm, { graph, memoryDir, lexicon, env, cache }) : null;
+        if (ref) bareMetaHit = { text: ref.text, replace: true, reference: ref };
+      }
     }
     // A bare "what is X" naming a REAL code-graph entity (not a taught fact,
     // not a curated corpus term) needs the SAME race fixed too.
@@ -9951,7 +10348,18 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     if (fallback) bareMetaHit = { text: fallback.text, replace: true };
   }
   const coldPronounDecline = focus?.label ? null : coldPronounDeclineText(query);
-  if (bareMetaHit) {
+  if (bareMetaHit?.reference) {
+    // The bare-form reference hit mirrors (4h): the cited answer replaces the
+    // miss, the turn is no longer recorded as one, and the article's isa is
+    // stored after the answer composes.
+    answer = bareMetaHit.text;
+    via = "reference";
+    recordMiss = false;
+    handled = true;
+    note(trace, "lane: (2b) REFERENCE PACK — a bare \"what is X\" clean miss answered from the shipped reference pack, cited");
+    note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${bareMetaHit.reference.article.title}" (revid ${bareMetaHit.reference.article.revid})`);
+    await appendReferenceIsaFact(memoryDir, bareMetaHit.reference.key, bareMetaHit.reference.article, cache);
+  } else if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
     // Same discipline as lane (3): a fact-lane return flagged `miss` is an
     // honest miss in better words — the turn record keeps miss=true and via
@@ -10161,6 +10569,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache });
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
+      if (!taught.miss) dialogueLaneOverride = "teach";
       note(trace, `lane: (4) TEACH — TEACH_RE/OWNS_TEACH_RE/BARE_DECLARATIVE_RE matched, ${taught.miss ? "but the payload could not be stored" : "reified into .tmct/memory"}`);
       // `deduced` was computed straight off envelope.parsed alone, but the
       // structural grammar has no business parsing a teach-shaped sentence at
@@ -10305,6 +10714,24 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, `lane: (4g) FUZZY-VERB DECLINE — "${from}" only became a verb through the edit-distance repair tier ("${to}"), and the two words are different verbs, so the repaired sentence's graph answer is dropped rather than shown as an answer to what was typed`);
     }
   }
+  // (4h) REFERENCE PACK — the cleanest miss consults the shipped reference
+  // pack: a definition-shaped term the lexicon knows, no graph entity, no
+  // remembered fact. A hit answers with the article's summary, always cited;
+  // a null from any gate leaves the turn byte-identical. After the answer
+  // composes, the article's first-sentence isa is stored as a subClassOf fact
+  // with reference provenance, so the NEXT ask answers from memory.
+  if (miss && recordMiss && via === "composed" && memoryDir) {
+    const refTerm = metaTermOf(query, envelope);
+    const ref = refTerm ? await referencePackMissAnswer(refTerm, { graph, memoryDir, lexicon, env, cache }) : null;
+    if (ref) {
+      answer = ref.text;
+      via = "reference";
+      recordMiss = false;
+      note(trace, "lane: (4h) REFERENCE PACK — a clean miss on a lexicon term answered from the shipped reference pack, cited");
+      note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${ref.article.title}" (revid ${ref.article.revid})`);
+      await appendReferenceIsaFact(memoryDir, ref.key, ref.article, cache);
+    }
+  }
   // (5) #1 SHORT TAILORED MISS — replace ONLY the engine's full grammar cheat-sheet
   // wall (WALL_MISS_RE). Receipt-bearing misses keep their specific wording.
   // WALL KINDNESS: a second consecutive wall collapses to a one-liner whose
@@ -10435,7 +10862,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // `goal`: the SAME deduced string the debug trace's own "goal:" line
   // carries. Only runAsk ever sets this field, so the always-on goal line is
   // scoped to real ask-engine turns by construction.
-  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery, goal: deduced, ...(planResult ? { plan: planResult } : {}) };
+  // `lane`: the dialogue-act lane — a lane's own override, else the
+  // question-shape lookup — resolved to an ISO act by runTurn's withLast.
+  const lane = dialogueLaneOverride ?? askDialogueLane(envelope?.parsed, query, recordMiss);
+  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery, goal: deduced, lane, ...(planResult ? { plan: planResult } : {}) };
 }
 
 /** A non-ask, non-dispatch chat turn (count answer, /stats) — the same
@@ -10916,21 +11346,63 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
 const PAGE = 32;
 const MORE_RE = /^(?:more|show more|see more|the rest|next|continue|go on)\b[.!?]*$/i;
 
-/** "what would break if I change X" — the impact closure asked for in the
- *  words people use, rather than as /impact. Sibling of normalize.mjs's
- *  COUNTERFACTUAL_RE ("if X were deleted, what would break"), which states the
- *  same counterfactual in the other clause order and compiles to the reverse
- *  import closure; this shape names a CHANGE rather than a deletion, so it
- *  answers with the impact closure /impact itself renders. The verbs are a
- *  closed set on both sides — no general "any verb in a conditional" fit. */
+/** The impact-intent gate — "what would break if I change X" and its natural
+ *  neighbours, routed to the same /impact closure. Sibling of normalize.mjs's
+ *  COUNTERFACTUAL_RE ("if X were deleted, what would break"), which compiles
+ *  to the reverse import closure; these shapes name a CHANGE rather than a
+ *  deletion, so they answer with the impact closure /impact itself renders.
+ *  The verbs are a closed set on both sides — no general "any verb in a
+ *  conditional" fit. The gate runs ahead of the teach classifier and the
+ *  relaxation cascade, because an interrogative must never reach the write
+ *  boundary ("blast radius of X" was remembered as a fact) and "impact" must
+ *  never be fuzzy-read as "import" (the inverse question). */
+const IMPACT_CHANGE_VERBS = "(?:changed?|modif(?:y|ied)|edits?|edited|touch(?:es|ed)?|updates?|updated|alters?|altered|deletes?|deleted|removes?|removed|drops?|dropped)";
 const IMPACT_PARAPHRASE_RE = new RegExp(
   "^what\\s+(?:would|will|might|could|does|do)?\\s*"
-  + "(?:breaks?|fails?|is\\s+affected|are\\s+affected|gets?\\s+affected|be\\s+affected|is\\s+impacted|be\\s+impacted)"
-  + "\\s+if\\s+(?:i|we|you|one|someone)\\s+"
-  + "(?:changed?|modif(?:y|ied)|edits?|edited|touch(?:es|ed)?|updates?|updated|alters?|altered)"
+  + "(?:breaks?|fails?|happens?|stops?\\s+working|is\\s+affected|are\\s+affected|gets?\\s+affected|be\\s+affected|is\\s+impacted|be\\s+impacted)"
+  + `\\s+if\\s+(?:i|we|you|one|someone)\\s+${IMPACT_CHANGE_VERBS}`
   + "\\s+(?:the\\s+)?(.+?)[?.!\\s]*$",
   "i",
 );
+// The same counterfactual with the clauses reversed — "if I change X what breaks".
+const IMPACT_REVERSED_RE = new RegExp(
+  `^if\\s+(?:i|we|you|one|someone)\\s+${IMPACT_CHANGE_VERBS}`
+  + "\\s+(?:the\\s+)?(.+?),?\\s+what\\s+(?:would\\s+|will\\s+|might\\s+|could\\s+|does\\s+|do\\s+)?"
+  + "(?:breaks?|fails?|happens?|stops?\\s+working|is\\s+affected|are\\s+affected|gets?\\s+affected|be\\s+affected|would\\s+break|will\\s+break)"
+  + "[?.!\\s]*$",
+  "i",
+);
+// The agentless passive — "what is affected by changing X".
+const IMPACT_AFFECTED_BY_RE = new RegExp(
+  "^what\\s+(?:is|are|gets?|would\\s+be|will\\s+be)\\s+(?:affected|impacted|broken)\\s+"
+  + "(?:by|when|if)\\s+(?:i\\s+|we\\s+|you\\s+)?"
+  + "(?:chang(?:e|es|ing)|edit(?:s|ing)?|modif(?:y|ies|ying)|touch(?:es|ing)?|updat(?:e|es|ing)|delet(?:e|es|ing)|remov(?:e|es|ing)|a\\s+change\\s+to)\\s+"
+  + "(?:the\\s+)?(.+?)[?.!\\s]*$",
+  "i",
+);
+// "can I safely delete X" — a change-safety question IS the impact question.
+const IMPACT_SAFE_CHANGE_RE = new RegExp(
+  "^(?:(?:can|could)\\s+(?:i|we|you|one|someone)\\s+safely|is\\s+it\\s+safe\\s+to)\\s+"
+  + "(?:change|edit|modify|touch|update|alter|delete|remove|drop)\\s+"
+  + "(?:the\\s+)?(.+?)[?.!\\s]*$",
+  "i",
+);
+// The NP form — "blast radius of X", "impact of changing X".
+const IMPACT_NOUN_RE = new RegExp(
+  "^(?:what(?:'s|\\s+is)\\s+the\\s+)?(?:blast\\s+radius|impact)\\s+(?:of|for)\\s+"
+  + "(?:chang(?:ing|es)\\s+|editing\\s+|modifying\\s+|touching\\s+|updating\\s+|deleting\\s+|removing\\s+)?"
+  + "(?:the\\s+)?(.+?)[?.!\\s]*$",
+  "i",
+);
+const IMPACT_INTENT_RES = [IMPACT_PARAPHRASE_RE, IMPACT_REVERSED_RE, IMPACT_AFFECTED_BY_RE, IMPACT_SAFE_CHANGE_RE, IMPACT_NOUN_RE];
+/** The impact intent in any of its clause orders -> the subject term, or null. */
+function matchImpactIntent(line) {
+  for (const re of IMPACT_INTENT_RES) {
+    const m = line.match(re);
+    if (m) return m[1].trim();
+  }
+  return null;
+}
 const joinList = (a) => (a.length > 1 ? `${a.slice(0, -1).join(", ")} and ${a[a.length - 1]}` : (a[0] ?? ""));
 
 /** Render the next page of a held remainder (pending: {items:[str], noun}). Returns a
@@ -10947,6 +11419,251 @@ function morePage(query, { last, focus }) {
   return turn;
 }
 
+// ---- the SKOS view: synonym/related-word questions over the store ----
+// "another word for X" / "synonyms of X" / "what is related to X" read the
+// store's mgx:synonym / mgx:relatedTo / mgx:similarTo facts through
+// buildSkosConceptView's minted concepts (relatedForTerm). Routed ahead of
+// 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_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
+ *  line is not one. A matched line always answers — a hit lists the group's
+ *  other labels and the related concepts; anything else is the honest miss. */
+async function skosRelatedAnswer(memoryDir, query, cache) {
+  if (!memoryDir) return null;
+  const q = expandContractions(String(query).trim());
+  const syn = q.match(SKOS_SYNONYM_RE);
+  const rel = syn ? null : q.match(SKOS_RELATED_RE);
+  if (!syn && !rel) return null;
+  const term = (syn ?? rel)[1].trim();
+  let hood = null;
+  try { hood = relatedForTerm(await factRows(memoryDir, cache), term); } catch { hood = null; }
+  const parts = [];
+  if (hood?.synonyms?.length) parts.push(`another word for ${term}: ${joinList(hood.synonyms)}`);
+  const relatedLabels = (hood?.related ?? []).map((c) => c.prefLabel);
+  if (relatedLabels.length) parts.push(`related: ${joinList(relatedLabels)}`);
+  if (!parts.length) {
+    return { term, miss: true, text: `I don't know any synonyms or related words for "${term}" yet.` };
+  }
+  return { term, miss: false, text: `${parts.join("; ")} (source: remembered synonym/related facts, read as SKOS)` };
+}
+
+// ---- guess-the-number: a closed-loop game over hidden state ----
+// Two modes on one mechanism. In GUESSER mode the human holds a secret and
+// tmct searches: a belief interval {lo, hi} narrowed by bisection, one
+// observation ("higher"/"lower"/"correct") folded in per turn. In THINKER
+// mode tmct commits a secret up front and each turn is a stateless
+// comparison against it. The game payload rides the session's plan slot as
+// a tagged sub-object ({ game: {...} }), so a plan frame and a game never
+// share the slot — each declines to start while the other is active.
+
+/** "between A and B" / "up to N" anywhere in an opening line. Loose token
+ *  captures (\S+) so a non-numeric bound is SEEN and declined rather than
+ *  silently defaulted. */
+const GAME_BOUNDS_CLAUSE_RE = /\b(?:between\s+(\S+)\s+and\s+(\S+)|up\s+to\s+(\S+))\b/i;
+const GAME_BOUND_MAX = 1_000_000_000;
+
+/** The bounds an opening line states — { lo, hi } (default 1–100), or
+ *  { problem } naming why the stated range is unplayable. */
+function parseGameBounds(text) {
+  const m = String(text).match(GAME_BOUNDS_CLAUSE_RE);
+  if (!m) return { lo: 1, hi: 100 };
+  const tokens = (m[3] !== undefined ? ["1", m[3]] : [m[1], m[2]])
+    .map((t) => String(t).replace(/[,.?!]+$/, ""));
+  if (!tokens.every((t) => /^-?\d+$/.test(t))) {
+    return { problem: 'I can only play with whole-number bounds — say "between 1 and 100".' };
+  }
+  const lo = Number(tokens[0]);
+  const hi = Number(tokens[1]);
+  if (Math.abs(lo) > GAME_BOUND_MAX || Math.abs(hi) > GAME_BOUND_MAX) {
+    return { problem: `that range is too big for a fair game — keep both bounds within ${GAME_BOUND_MAX.toLocaleString("en-US")}.` };
+  }
+  if (hi < lo) return { problem: `no number is between ${lo} and ${hi} — that range is empty. Put the smaller bound first.` };
+  if (hi === lo) return { problem: `between ${lo} and ${hi} leaves exactly one number, so there is nothing to guess. Pick a wider range.` };
+  return { lo, hi };
+}
+
+// Opening moves, both modes, as closed-set leads + a tail that may only carry
+// the bounds clause and the closing invitation words — any other tail is a
+// real sentence and falls through to the ordinary lanes.
+const GUESSER_OPEN_LEAD_RE = /^(?:i\s*(?:'m|am)\s+thinking\s+of\s+a\s+number|guess\s+my\s+number|guess\s+the\s+number\s+i\s*(?:'m|am)\s+thinking\s+of|guess\s+a\s+number\s+(?:between\s+\S+\s+and\s+\S+\s+|up\s+to\s+\S+\s+)?and\s+i\s*(?:'ll|\s+will)\s+tell\s+you\s+(?:if\s+it\s*(?:'s|\s+is)\s+)?higher\s+or\s+lower)\b(.*)$/i;
+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;
+
+/** An opening move — { mode, bounds } — or null. */
+function matchGameOpening(line) {
+  const l = String(line).trim();
+  const guesser = l.match(GUESSER_OPEN_LEAD_RE);
+  if (guesser && GUESSER_OPEN_TAIL_RE.test(guesser[1].replace(GAME_BOUNDS_CLAUSE_RE, " "))) {
+    return { mode: "guesser", bounds: parseGameBounds(l) };
+  }
+  const thinker = l.match(THINKER_OPEN_LEAD_RE);
+  if (thinker && THINKER_OPEN_TAIL_RE.test(thinker[1].replace(GAME_BOUNDS_CLAUSE_RE, " "))) {
+    return { mode: "thinker", bounds: parseGameBounds(l) };
+  }
+  return null;
+}
+
+// Continuation replies, gated STRICTLY on an active game (the same discipline
+// MORE_RE applies to a held pending remainder): with no game standing none of
+// these are ever consulted, and mid-game any line that matches none of them
+// is an ordinary aside — answered by the normal lanes, game untouched.
+const GAME_STOP_RE = /^(?:ok[,\s]+)?(?:i\s+give\s+up|give\s+up|i\s+quit(?:\s+the\s+game)?|stop\s+(?:the\s+game|playing)|end\s+the\s+game)[.!?\s]*$/i;
+const GAME_REVEAL_RE = /^(?:just\s+tell\s+me|(?:just\s+)?tell\s+me\s+the\s+(?:number|answer)|what(?:'s|\s+is)\s+(?:the|your)\s+(?:secret\s+)?number|reveal\s+(?:it|the\s+number)|show\s+me\s+the\s+number)[.!?\s]*$/i;
+const GAME_OBS_HIGHER_RE = /^(?:no[,\s]+)?(?:higher|too\s+low|too\s+small|bigger|greater|go\s+higher|it(?:'s|\s+is)\s+higher)[.!?\s]*$/i;
+const GAME_OBS_LOWER_RE = /^(?:no[,\s]+)?(?:lower|too\s+high|too\s+big|smaller|less|go\s+lower|it(?:'s|\s+is)\s+lower)[.!?\s]*$/i;
+const GAME_OBS_CORRECT_RE = /^(?:yes|yep|yeah|correct|you\s+got\s+it|you\s+guessed\s+it|that(?:'s|\s+is)\s+it|that(?:'s|\s+is)\s+right|got\s+it|spot\s+on)[.!?\s]*$/i;
+const GAME_GUESS_RE = /^(?:is\s+it\s+)?(-?\d{1,12})\s*\??[.!?\s]*$/;
+const GAME_FALSE_CORRECT_RE = /^(?:but\s+)?you\s+(?:already\s+)?said\s+(?:it\s+was\s+)?(?:correct|right)\b/i;
+
+/** A natural-language plan frame — the shapes planLaneAnswer owns. Mid-game
+ *  these get the one-at-a-time decline instead of clobbering the slot. */
+function isPlanFrameLine(line) {
+  return GOAL_TEACH_RE.test(line) || GOAL_TEACH_INFINITIVE_RE.test(line)
+    || GOAL_TEACH_VERBLESS_RE.test(line) || GOAL_TEACH_NP_RE.test(line)
+    || GOAL_TEACH_IMPERATIVE_RE.test(line) || GOAL_TEACH_CONJUNCTION_RE.test(line)
+    || PLAN_SOLVE_RE.test(line) || LEGAL_MOVES_RE.test(line);
+}
+
+/** The per-turn goal line, table-driven off the live game state. */
+function gameGoal(game) {
+  if (game.mode === "guesser") return `narrow down your number — currently between ${game.lo} and ${game.hi}`;
+  if (!game.lastHint) return "let you find my secret number I've committed to";
+  return `let you find my secret number — said "${game.lastHint}" so it's ${game.lastHint === "higher" ? "above" : "below"} your last guess`;
+}
+
+/** One guesser-mode observation folded into the belief interval, or a
+ *  thinker-mode guess compared against the secret. Mutates planHolder.state
+ *  (the same slot the plan lane owns) and returns { text, goal?, lane, note },
+ *  or null when the line is not a game reply. */
+function gameContinuationAnswer(line, game, planHolder) {
+  const endGame = () => { planHolder.state = null; };
+  if (game.mode === "guesser") {
+    if (GAME_STOP_RE.test(line)) {
+      endGame();
+      return { text: 'OK, stopping — I never found it. Say "guess my number" any time to play again.', lane: "game-inform", note: "GAME — the game ended on request; the belief interval is discarded" };
+    }
+    if (GAME_OBS_CORRECT_RE.test(line)) {
+      const { guess, guesses } = game;
+      endGame();
+      return { text: `Got it — your number is ${guess}, found in ${guesses} guess${guesses === 1 ? "" : "es"}. Want to play again?`, lane: "game-answer", note: "GAME — the guess was confirmed; game over, won" };
+    }
+    const higher = GAME_OBS_HIGHER_RE.test(line);
+    const lower = !higher && GAME_OBS_LOWER_RE.test(line);
+    if (!higher && !lower) return null;
+    const prior = game.guess;
+    const next = { ...game };
+    if (higher) { next.lo = prior + 1; next.loSetBy = { guess: prior }; }
+    else { next.hi = prior - 1; next.hiSetBy = { guess: prior }; }
+    if (next.lo > next.hi) {
+      // The interval is EMPTY: no number satisfies every observation given,
+      // so name the two observations that cannot both hold and stop guessing
+      // — never a fabricated next guess over a premise known to be false.
+      endGame();
+      const earlier = higher
+        ? (game.hiSetBy ? `lower than ${game.hiSetBy.guess}` : `it's between ${game.lo0} and ${game.hi0}`)
+        : (game.loSetBy ? `higher than ${game.loSetBy.guess}` : `it's between ${game.lo0} and ${game.hi0}`);
+      const now = `${higher ? "higher" : "lower"} than ${prior}`;
+      return {
+        text: `That's not possible — you said ${earlier}, and now ${now}, but no number can be both. One of those answers must be wrong. Say "guess my number" to restart.`,
+        lane: "game-answer",
+        note: "GAME — the observations emptied the belief interval; refused to keep guessing under a false premise",
+      };
+    }
+    next.guess = Math.floor((next.lo + next.hi) / 2);
+    next.guesses = game.guesses + 1;
+    planHolder.state = { game: next };
+    return {
+      text: `My guess: ${next.guess}. Say higher, lower, or correct.`,
+      goal: gameGoal(next),
+      lane: "game-inform",
+      note: `GAME — folded "${higher ? "higher" : "lower"}" into the interval and bisected it again`,
+    };
+  }
+  // Thinker mode: tmct holds the ground truth, so every reply is a plain
+  // comparison — and the hint record is authoritative against false claims.
+  if (GAME_STOP_RE.test(line) || GAME_REVEAL_RE.test(line)) {
+    const { secret } = game;
+    endGame();
+    return { text: `The number was ${secret}. Want to play again?`, lane: "game-answer", note: "GAME — revealed the secret on request; game over" };
+  }
+  if (GAME_FALSE_CORRECT_RE.test(line)) {
+    const record = game.lastHint
+      ? `my last hint was "${game.lastHint}", after your guess of ${game.lastGuess}`
+      : "you haven't guessed yet";
+    return { text: `I haven't said "correct" yet — ${record}. Keep guessing.`, goal: gameGoal(game), lane: "game-answer", note: "GAME — rebutted a false \"you said correct\" from the game's own hint record" };
+  }
+  const m = String(line).trim().match(GAME_GUESS_RE);
+  if (!m) return null;
+  const guess = Number.parseInt(m[1], 10);
+  if (guess < game.lo0 || guess > game.hi0) {
+    return { text: `${guess} is outside the ${game.lo0} to ${game.hi0} range we agreed — try a number in range.`, goal: gameGoal(game), lane: "game-answer", note: "GAME — an out-of-range guess; declined rather than comparing outside the agreed bounds" };
+  }
+  const next = { ...game, guesses: game.guesses + 1, lastGuess: guess };
+  if (guess === game.secret) {
+    endGame();
+    return { text: `Correct — you got it in ${next.guesses} guess${next.guesses === 1 ? "" : "es"}! The number was ${guess}. Want to play again?`, lane: "game-answer", note: "GAME — the guess matched the secret; game over, won" };
+  }
+  next.lastHint = guess < game.secret ? "higher" : "lower";
+  planHolder.state = { game: next };
+  return { text: `${next.lastHint} — guess again.`, goal: gameGoal(next), lane: "game-answer", note: `GAME — compared the guess against the committed secret: ${next.lastHint}` };
+}
+
+/** The whole game lane for one turn: continuations first (active game only),
+ *  then opening moves, with the one-at-a-time declines both ways across the
+ *  shared plan slot. Null when the turn is not the game's to answer. */
+function guessNumberTurn(line, { planHolder, env }) {
+  const state = planHolder?.state ?? null;
+  const game = state?.game ?? null;
+  const opening = matchGameOpening(line);
+  if (game) {
+    const continuation = gameContinuationAnswer(line, game, planHolder);
+    if (continuation) return continuation;
+    if (opening) {
+      return { text: `we're already playing — I'm ${game.mode === "guesser" ? "guessing your number" : "holding a secret number"}. Say "I give up" to end this game first.`, lane: "game-inform", note: "GAME — an opening arrived mid-game; declined, the running game stands" };
+    }
+    if (isPlanFrameLine(line)) {
+      return { text: 'a guess-the-number game is active — say "I give up" to end it, then set your goal.', lane: "game-inform", note: "GAME — a plan frame arrived mid-game; the slot holds one thing at a time" };
+    }
+    return null;
+  }
+  if (!opening) return null;
+  const planActive = state && !state.done
+    && ((Array.isArray(state.goals) && state.goals.length) || (Array.isArray(state.actions) && state.actions.length));
+  if (planActive) {
+    return { text: "a plan is in progress — finish it or start a fresh goal before we play guess-the-number.", lane: "game-inform", note: "GAME — an opening arrived while a plan frame is active; the slot holds one thing at a time" };
+  }
+  if (opening.bounds.problem) {
+    return { text: opening.bounds.problem, lane: "game-inform", note: "GAME — the opening stated an unplayable range; declined honestly" };
+  }
+  const { lo, hi } = opening.bounds;
+  if (opening.mode === "guesser") {
+    const guess = Math.floor((lo + hi) / 2);
+    planHolder.state = { game: { mode: "guesser", lo0: lo, hi0: hi, lo, hi, guess, guesses: 1, loSetBy: null, hiSetBy: null } };
+    return {
+      text: `OK — you're thinking of a number between ${lo} and ${hi}; I'll guess it. My guess: ${guess}. Say higher, lower, or correct.`,
+      goal: `narrow down your number — currently between ${lo} and ${hi}`,
+      lane: "game-inform",
+      note: "GAME — guesser mode opened; the belief interval starts at the agreed bounds and the first guess is its midpoint",
+    };
+  }
+  const envSecret = Number.parseInt(String(env?.TMCT_GAME_SECRET ?? ""), 10);
+  const secret = Number.isSafeInteger(envSecret) && envSecret >= lo && envSecret <= hi
+    ? envSecret
+    : lo + Math.floor(Math.random() * (hi - lo + 1));
+  planHolder.state = { game: { mode: "thinker", lo0: lo, hi0: hi, secret, guesses: 0, lastHint: null, lastGuess: null } };
+  return {
+    text: `Done — I've thought of a number between ${lo} and ${hi}. Guess it, and I'll say higher, lower, or correct.`,
+    goal: "let you find my secret number I've committed to",
+    lane: "game-inform",
+    note: "GAME — thinker mode opened; the secret is committed for the whole game",
+  };
+}
+
 // "I want you to search for Widget" / "I'd like you to search for Widget" —
 // a closed-set indirect-request wrapper, checked VERY early. Without this it
 // is mis-swallowed by GENERAL_VERB_TEACH_RE as a bare teach triple (subject
@@ -10956,6 +11673,40 @@ function morePage(query, { last, focus }) {
 // throughout this file, and centralizing it risks double-processing.
 const INDIRECT_REQUEST_RE = /^(?:i\s+(?:want|wanted)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+)\s*(.+)$/i;
 
+// First-person desire openers for a vocabulary question — "i wanna know about
+// a horse", "you tell me about dog", "let me know about a dog" — and the
+// known-kinds enumeration ("what animals do you know", "list the animals you
+// know"). Each rewrites to the canonical question its lane already answers
+// ("tell me about X" / "what is a X"), BEFORE any dispatch lane sees the
+// text: the leading "i" otherwise reads as a teach subject, so a read-only
+// question asserted an intent it doesn't have. Closed set, rewrite-only —
+// same discipline as INDIRECT_REQUEST_RE above.
+const DESIRE_ABOUT_RE = /^i\s+(?:wanna|want\s+to|wanted\s+to|(?:'d\s+|would\s+)?like\s+to|need\s+to)\s+(?:know|learn|hear)\s+(?:(?:more|something)\s+)?about\s+(.+?)[?.!\s]*$/i;
+const TELL_ABOUT_VARIANT_RE = /^(?:you\s+tell\s+me|let\s+me\s+know|fill\s+me\s+in)\s+(?:(?:more|something)\s+)?about\s+(.+?)[?.!\s]*$/i;
+// "facts"/"things"/"stuff" ask for the whole-store recall, not a kind's
+// members — those keep their own lane.
+const KNOWN_KINDS_RE = /^(?:(?:so|uh|um|well|ok|okay),?\s+)*(?:what|which)\s+(?!else\b|all\b|facts?\b|things?\b|stuff\b)([a-z][\w-]*)\s+do\s+(?:you|u)\s+know(?:\s+(?:about|of|so\s+far))?[?.!\s]*$/i;
+const LIST_KNOWN_KINDS_RE = /^list\s+(?:the\s+|all\s+(?:the\s+)?)?(?!facts?\b|things?\b|stuff\b)([a-z][\w-]*)\s+(?:that\s+)?(?:you|u)\s+know(?:\s+(?:about|of))?[?.!\s]*$/i;
+// "if something is a dog then it is a pet" — the universal conditional IS the
+// universal subclass teach in a conditional coat, so it rewrites to the
+// "every X is a Y" surface the teach path already stores (with its quantifier
+// and its own confirmation). Closed to the indefinite-pronoun subject: a
+// conditional over a NAMED subject or an arbitrary property is a rule, not a
+// subclass fact, and stays outside this frame.
+const UNIVERSAL_CONDITIONAL_RE = /^if\s+(?:something|somebody|someone|anything)\s+is\s+an?\s+([\w-]+)\s*,?\s*(?:then\s+)?(?:it|they)\s+(?:is|are)\s+an?\s+([\w-]+)[.!?\s]*$/i;
+function rewriteVocabOpener(line) {
+  let m = line.match(DESIRE_ABOUT_RE) || line.match(TELL_ABOUT_VARIANT_RE);
+  if (m) return `tell me about ${m[1].trim()}`;
+  m = line.match(UNIVERSAL_CONDITIONAL_RE);
+  if (m) return `every ${m[1]} is ${indefiniteArticleFor(m[2])} ${m[2]}`;
+  m = line.match(KNOWN_KINDS_RE) || line.match(LIST_KNOWN_KINDS_RE);
+  if (m) {
+    const noun = teachableSubjectOf(m[1]);
+    return `what is ${indefiniteArticleFor(noun)} ${noun}`;
+  }
+  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"
@@ -11080,7 +11831,8 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the ORIGINAL `line` survives untouched for record.query/logLines fidelity
   // — restored centrally inside withLast (below), once, for every dispatch path.
   const indirectMatch = line.match(INDIRECT_REQUEST_RE);
-  const preRewriteLine = indirectMatch ? indirectMatch[1].trim() : line;
+  const indirectLine = indirectMatch ? indirectMatch[1].trim() : line;
+  const preRewriteLine = rewriteVocabOpener(indirectLine) || indirectLine;
   // rewriteUsesAsBaseFrame's discontiguous-frame rewrite: applied here, once,
   // before ANY dispatch lane sees the text. Null (no-op) for every turn that
   // doesn't match one of the four discontiguous shapes.
@@ -11126,7 +11878,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // what the shell prints. The narrate block is applied AFTER `last` is
   // captured from the PRE-narration finished result.
   const withLast = (result, fallbackGoal = "unclear — no goal signal for this turn type") => {
-    const finished = finish(result, { graph });
+    const finished = attachDialogueAct(finish(result, { graph }), trace);
     // Every dispatch path below built its own record off `workingLine` (the
     // indirect-request wrapper stripped and/or the discontiguous-frame
     // rewrite applied) — restore the ORIGINAL raw `line` into record.query
@@ -11166,6 +11918,26 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   const bareCmd = asBareCommand(workingLine);
   if (bareCmd) return withLast(await runCommand(bareCmd, ctx), "use a specific tool/command directly");
 
+  // GUESS-THE-NUMBER — opening moves, and (with a game standing) the
+  // closed-set continuation replies. Checked before the conversational layer
+  // because the guesser-mode observations ("yes", "got it") share words with
+  // the acknowledgement sets, and before assertTurn/runAsk because an opening
+  // line would otherwise read as a declarative to remember. A mid-game line
+  // matching no game shape returns null here and the game stands untouched.
+  {
+    const gameTurn = guessNumberTurn(workingLine, { planHolder, env });
+    if (gameTurn) {
+      note(trace, `lane: ${gameTurn.note}`);
+      if (gameTurn.goal) note(trace, `goal: ${gameTurn.goal}`);
+      const result = plainTurn(workingLine, gameTurn.text, { via: "game", focus });
+      if (gameTurn.goal) result.goal = gameTurn.goal;
+      result.lane = gameTurn.lane;
+      const rec = withLast(result, gameTurn.goal ?? "play the guessing game");
+      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
@@ -11183,7 +11955,9 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     const step = await executePlanStep(planHolder, { memoryDir, sessionId });
     note(trace, `goal: ${step.deduced}`);
     note(trace, "lane: PLAN NEXT — executed the active plan's next move as an @stepK snapshot write");
-    const rec = withLast(plainTurn(workingLine, step.text, { via: "plan", focus }), step.deduced);
+    const stepTurn = plainTurn(workingLine, step.text, { via: "plan", focus });
+    stepTurn.lane = "imperative";
+    const rec = withLast(stepTurn, step.deduced);
     rec.planState = planHolder.state;
     return rec;
   }
@@ -11214,20 +11988,21 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     return withLast(morePage(workingLine, ctx), "continue viewing a previous long listing");
   }
 
-  // "what would break if I change X" / "what breaks if I touch X" — the impact
+  // "what would break if I change X" / "if I change X what breaks" / "blast
+  // radius of X" / "impact of X" / "can I safely delete X" — the impact
   // closure, in the words people actually ask for it in. With no frame of its
-  // own the line reached the grammar with "break"/"breaks if i" worn away as
-  // filler, and the residue ("break I") read as a subject for the history
-  // lane's `touches` — answering who last touched a file to a question about
-  // what a change to it would reach. /impact's own closure is the answer, and
-  // its wording ("Impact of changing X") already says the change is
-  // hypothetical.
-  const impactParaphrase = workingLine.match(IMPACT_PARAPHRASE_RE);
-  if (impactParaphrase) {
+  // own each of these reached a wrong lane: the forward form's residue
+  // ("break I") read as a subject for the history lane's `touches`, the NP
+  // form fell to the teach lane (a read-only question mutating memory) or to
+  // the fuzzy corrector ("impact" read as "import", the inverse question).
+  // /impact's own closure is the answer, and its wording ("Impact of changing
+  // X") already says the change is hypothetical.
+  const impactSubject = matchImpactIntent(workingLine);
+  if (impactSubject) {
     const impactDeduced = "understand what a change to this module would reach (impact closure)";
     note(trace, `goal: ${impactDeduced}`);
-    note(trace, `lane: IMPACT_PARAPHRASE_RE matched -> /impact ${impactParaphrase[1].trim()}`);
-    return withLast(await runCommand(`/impact ${impactParaphrase[1].trim()}`, ctx), impactDeduced);
+    note(trace, `lane: impact intent matched -> /impact ${impactSubject}`);
+    return withLast(await runCommand(`/impact ${impactSubject}`, ctx), impactDeduced);
   }
 
   // Multi-sentence pre-split — one message carrying several sentences
@@ -11293,6 +12068,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     if (asserted) {
       note(trace, "goal: teach/remember a new fact (declarative ACE sentence)");
       note(trace, "lane: assertTurn — grammar/ace.mjs parseAce matched a full triple with no residue");
+      asserted.lane = "teach";
       return withLast(asserted, "teach/remember a new fact");
     }
     // Bare declarative taxonomy (hyphenated-instance membership, article-led
@@ -11302,7 +12078,26 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     if (taxonomy) {
       note(trace, "goal: teach/remember a new fact (bare declarative taxonomy)");
       note(trace, "lane: bareTaxonomyTeach — hyphenated-instance or article-led kind-of declarative, stored before the ask engine could parse it as a question");
-      return withLast(plainTurn(workingLine, taxonomy.text, { via: taxonomy.via, miss: taxonomy.miss, focus }), "teach/remember a new fact");
+      const taxonomyTurn = plainTurn(workingLine, taxonomy.text, { via: taxonomy.via, miss: taxonomy.miss, focus });
+      if (!taxonomy.miss) taxonomyTurn.lane = "teach";
+      return withLast(taxonomyTurn, "teach/remember a new fact");
+    }
+  }
+  // Synonym/related-word questions read the store through the SKOS view.
+  // Routed before the ask engine: the generic parse reads "another word for
+  // X" as a bare object search and "what is related to X" through
+  // BARE_WHATIS_RE, both wrong lanes for this question.
+  if (memoryDir) {
+    const skos = await skosRelatedAnswer(memoryDir, workingLine, factRowsCache);
+    if (skos) {
+      const goal = `surface the remembered synonym/related-word neighbourhood of "${skos.term}"`;
+      note(trace, `goal: ${goal}`);
+      note(trace, `lane: SKOS VIEW — a synonym/related question ${skos.miss ? "matched but the store holds no such facts (honest miss)" : "answered from the store's relation facts"}`);
+      if (!skos.miss) note(trace, "source: .tmct/memory Facts (mgx:synonym/mgx:relatedTo/mgx:similarTo, read as skos:altLabel/skos:related)");
+      const skosTurn = plainTurn(workingLine, skos.text, { via: skos.miss ? "miss" : "fact", miss: skos.miss, focus });
+      if (!skos.miss) skosTurn.goal = goal;
+      skosTurn.lane = skos.miss ? "honest-miss" : "ask-set";
+      return withLast(skosTurn, goal);
     }
   }
   // MEMORY-STORE counts first ("how many facts / utterances do you know") — the