@polycode-projects/the-mechanical-code-talker 2.3.0 → 2.5.0

package/src/services/chat.mjs

@@ -28,11 +28,12 @@ import { loadTemplates, render as renderTemplate } from "../adapters/corpus/temp
 import { rankByBiasThenTrust } from "../domain/memory/bias.mjs";
 import { HAS_A_PREDICATE, loadMemory as loadMemoryStore, normFactPredicate, normFactTerm as normFactTermStatic, readFactRows as readStoredFactRows, readRuleRows as readStoredRuleRows } from "../adapters/memory/core.mjs";
 import {
-  CAPABILITY_REPORT_CAP, NEG_CAPABLE_OF_PREDICATE, capabilityBaseRate, capabilityExtension,
-  isNegatedPredicate, negatedPredicate, positivePredicate, resolveCapabilityPolarity,
+  CAPABILITY_REPORT_CAP, NEG_CAPABLE_OF_PREDICATE, NEG_SUBCLASS_PREDICATE, capabilityBaseRate,
+  capabilityExtension, isNegatedPredicate, negatedPredicate, positivePredicate,
+  resolveCapabilityPolarity,
 } from "../domain/memory/capability.mjs";
 import { finish, beginsWithVowelSound, grammarRules } from "./finish.mjs";
-import { splitSentences } from "./sentences.mjs";
+import { splitSentences, carriesASentenceBoundary } from "./sentences.mjs";
 import {
   VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
   stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS, LIST_TRIGGERS,
@@ -43,6 +44,7 @@ import { setConstructionBanks } from "../domain/interpret/strategies/constructio
 import { nlpAdapter } from "../adapters/ask-nlp.mjs";
 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";
 
 // Composition: the chat surface supplies the domain parser's default lemma/POS
@@ -453,6 +455,37 @@ const IMPLICIT_ANAPHORA_COUNT_RE = /^(?:(?:and|so|then|also)\s+)?how many (?:are
  *  "defines" vs "contains" by the resolved subject's own class. */
 const AMBIGUOUS_HAVE_VERBS = new Set(["have", "has", "holds", "hold"]);
 
+/** Words that can trail a bare count without restricting it: the copula/expletive
+ *  of "are there", the "in total"/"in the graph" locatives, and the "do you know"
+ *  politeness. Anything left after these is stripped is a real restrictor the
+ *  header count cannot evaluate. Mirrors ask.mjs's AGG_TAIL_FILLER plus the
+ *  interrogative scaffolding that only appears on the chat surface. */
+const COUNT_TAIL_FILLER = new Set([
+  "are", "is", "were", "was", "there", "of",
+  "in", "total", "altogether", "overall",
+  "the", "a", "an", "do", "does", "did", "you", "we", "us", "me", "know",
+  "exist", "exists", "existing", "present", "here", "now", "currently",
+  "graph", "index", "codebase", "repo", "repository", "memory",
+  "that", "this", "known", "recorded", "listed", "stored",
+  // trailing discourse particles — "…are there then", "…anyway" — never restrict a count
+  "then", "so", "uh", "um", "er", "eh", "well", "though", "anyway", "anyhow",
+  "again", "really", "actually", "maybe", "perhaps", "just", "simply", "rather", "please",
+]);
+
+/** A count tail past the kind noun carries a real restrictor — one the header
+ *  count cannot evaluate — iff a content word survives the filler strip and the
+ *  tail is not the have-family kept on the bare-count path (AMBIGUOUS_HAVE_VERBS).
+ *  A topical tail ("about tasks", "with tasks", "related to tasks") names nothing
+ *  RESTRICTOR_VERB_RE recognises, so without this it was silently discarded to the
+ *  unqualified total; now it declines to the ask engine's honest miss instead. */
+function countTailIsUnhandledRestrictor(tail) {
+  const words = String(tail).toLowerCase().replace(/[^a-z\s]+/g, " ").split(/\s+/).filter(Boolean);
+  const content = words.filter((w) => !COUNT_TAIL_FILLER.has(w));
+  if (!content.length) return false;
+  if (content.some((w) => AMBIGUOUS_HAVE_VERBS.has(w))) return false;
+  return true;
+}
+
 /** A "how many <kind> …" tail carries a genuine RESTRICTOR clause — not filler — iff
  *  it names a real relation verb (active, from VERB_TO_KIND, or passive-participle,
  *  from PASSIVE_PARTICIPLE_TO_KIND — both ask-vocab.mjs's closed vocabulary, the
@@ -501,7 +534,11 @@ export function answerCount(graph, query) {
   if (!m) return null;
   const noun = m[1].toLowerCase();
   const cls = COUNT_NOUNS[noun];
-  if (cls && RESTRICTOR_VERB_RE.test(String(query).slice(m.index + m[0].length))) return null;
+  if (cls) {
+    const tail = String(query).slice(m.index + m[0].length);
+    if (RESTRICTOR_VERB_RE.test(tail)) return null;
+    if (countTailIsUnhandledRestrictor(tail)) return null;
+  }
   if (!cls) {
     const kinds = countableKinds(graph);
     // When no code graph is loaded, countableKinds(graph) is genuinely
@@ -684,6 +721,29 @@ const MEMORY_COUNT_NOUNS = {
 };
 const MEMORY_CLASS_LABELS = { Fact: ["fact", "facts"], Utterance: ["utterance", "utterances"] };
 
+/** Everything a count question can trail after its counted noun and still mean
+ *  the plain total: "how many facts do you know", "how many facts are there",
+ *  "how many facts in total". A closed table — anything outside it restricts
+ *  the count to something, and this lane says so rather than answering as if
+ *  it were not there. */
+const MEMORY_COUNT_FILLER_TAIL_RE =
+  /^(?:(?:do|d')\s+(?:you|u)\s+(?:know|have|remember)|are\s+there|(?:in\s+)?(?:total|all)|altogether)?[?.!\s]*$/i;
+
+/** "how many facts about horses (are there)" — the one restriction this lane
+ *  reads: facts naming a term on either side of the triple. */
+const MEMORY_COUNT_ABOUT_TAIL_RE =
+  /^about\s+(?:the\s+|an?\s+)?([a-z][\w-]*)\s*(?:are\s+there|do\s+(?:you|u)\s+know)?[?.!\s]*$/i;
+
+/** Count the stored Facts naming `term` as subject or object — the restriction
+ *  "how many facts about horses" asks for. */
+async function memoryFactsAboutCount(memoryDir, term) {
+  const { loadMemory, readFactRows, normFactTerm } = await import("../adapters/memory/core.mjs");
+  const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
+  const wanted = normFactTerm(singularOf(term, loadLexicon(), lookupNoun));
+  const rows = readFactRows(await loadMemory(memoryDir));
+  return rows.filter((r) => normFactTerm(r.subject) === wanted || normFactTerm(r.object) === wanted).length;
+}
+
 /** Recognise a memory-store count question and answer it by loading the memory
  *  graph, or null (→ answerCount / the ask engine own it). Handles "how many facts",
  *  "how many utterances", and the bare "how many do you know" (→ facts). Lazy +
@@ -693,20 +753,41 @@ async function answerMemoryCount(memoryDir, query) {
   if (!memoryDir) return null;
   const q = String(query).toLowerCase();
   let cls = null;
+  let tail = "";
   // the bare "how many do you know" (no explicit noun) defaults to remembered facts
   if (/\bhow many(?:\s+(?:things?|facts?))?\s+(?:do|d'?)\s+(?:you|u)\s+know\b/.test(q)) cls = "Fact";
   if (!cls) {
-    const m = q.match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b/);
-    if (m) cls = MEMORY_COUNT_NOUNS[m[1]] || null;
+    const m = q.match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b(.*)$/);
+    if (m) {
+      cls = MEMORY_COUNT_NOUNS[m[1]] || null;
+      tail = m[2].trim();
+    }
   }
   if (!cls) return null;
+  const [sing, plur] = MEMORY_CLASS_LABELS[cls];
+  const said = (n) => `${n} ${n === 1 ? sing : plur}.`;
+  // A restriction this lane can read: count only the facts naming that term.
+  const about = cls === "Fact" ? tail.match(MEMORY_COUNT_ABOUT_TAIL_RE) : null;
+  if (about) {
+    try {
+      return `${said(await memoryFactsAboutCount(memoryDir, about[1]))} (about "${about[1]}")`;
+    } catch {
+      return null;
+    }
+  }
+  // A tail that restricts the question to something this lane cannot read. The
+  // total is not the answer to it — it is the answer to a shorter question
+  // nobody asked — so name what went unread instead of counting past it.
+  if (tail && !MEMORY_COUNT_FILLER_TAIL_RE.test(tail)) {
+    return `I can count the ${plur} I hold, but not the "${tail}" part of that question — `
+      + `so I won't answer with the plain total, which would be a count of something you didn't ask for. `
+      + `Ask "how many ${plur} do you know" for the total, or "how many ${plur} about <term>" to narrow it.`;
+  }
   let loadMemory;
   try { ({ loadMemory } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   let mem;
   try { mem = await loadMemory(memoryDir); } catch { return null; }
-  const n = (mem.individuals || []).filter((i) => (i.class || "") === cls).length;
-  const [sing, plur] = MEMORY_CLASS_LABELS[cls];
-  return `${n} ${n === 1 ? sing : plur}.`;
+  return said((mem.individuals || []).filter((i) => (i.class || "") === cls).length);
 }
 
 /** `/stats`: a one-screen overview of the graph — class counts, relationship
@@ -1786,8 +1867,8 @@ const OWNS_PASSIVE_TEACH_RE = /^(.+?)\s+(?:is|are|was|were)\s+owned\s+by\s+([A-Z
  *  a NAMED relationship between two entities ("ahab is the father of john"),
  *  grouped here with the other relational/possessive teach shapes above
  *  (ownership) since it's tried on the SAME ownSrc in teachLane, right after
- *  OWNS_PASSIVE_TEACH_RE and before SOME_A_FEW_RE — unconditionally ahead of
- *  generalVerbTeach's own call site. The literal "the" + bare role-noun +
+ *  OWNS_PASSIVE_TEACH_RE — unconditionally ahead of generalVerbTeach's own
+ *  call site. The literal "the" + bare role-noun +
  *  "of" anchor is deliberate: a future composition-rule teach shape ("a
  *  <rule> is a <relation> of a <relation>") uses an INDEFINITE "a"/"an" in
  *  the same slot instead, so the two shapes structurally can never collide —
@@ -2051,9 +2132,32 @@ const GOAL_TEACH_VERBLESS_RE = new RegExp(
 // preposition), so this one reader answers either.
 const ACTION_SIGNATURE_ASK_RE = new RegExp(
   `^(?:can|could)\\s+you\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)[?.!]*$`, "i");
-const PLAN_SOLVE_RE = /^(?:solve\s+it|plan\s+the\s+moves|how\s+do\s+i\s+get(?:\s+from\s+here)?\s+to\s+the\s+goal)[?.!\s]*$/i;
+const PLAN_SOLVE_RE = /^(?:solve\s+it|solve\s+(?:the\s+)?(?:towers?\s+of\s+hanoi|hanoi|puzzle|game|river\s+crossing|this)|plan\s+the\s+moves|how\s+do\s+i\s+get(?:\s+from\s+here)?\s+to\s+the\s+goal)[?.!\s]*$/i;
 const LEGAL_MOVES_RE = /^what\s+moves\s+are\s+legal(?:\s+now)?[?.!\s]*$/i;
 const PLAN_NEXT_RE = /^(?:next|next\s+move|go\s+on|continue)[.!?\s]*$/i;
+// The imperative voicing of a universal goal ("get all the disks onto peg-c"):
+// like the verbless frame it names no board verb, so planLaneAnswer reads that
+// off the taught locative facts. Captures a quantifier, a (possibly plural)
+// 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");
+// 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.
+const PLAN_WHAT_NEXT_RE = /^(?:what(?:'s|\s+is)?|whats)\s+the\s+next\s+move[?.!\s]*$/i;
+const PLAN_MOVE_COUNT_RE = /^how\s+many\s+moves(?:\s+(?:are\s+(?:there|left)|remain(?:ing)?|left|to\s+go|in\s+the\s+plan|total))?[?.!\s]*$/i;
+const PLAN_WHY_MOVE_RE = /^why\s+(?:that|this|the\s+next|the)\s+move[?.!\s]*$/i;
+// Board-state read-backs, answered off the CURRENT board (the latest @stepK
+// snapshot, or the taught board before any step) so a read never contradicts
+// the plan's own board@stepK line. Clearness is derived, never stored: a piece
+// is clear iff nothing rests on it on the current board.
+const IS_CLEAR_RE = /^(?:is|are)\s+([\w-]+)\s+clear[?.!\s]*$/i;
+const BOARD_REVERSE_LOC_RE = new RegExp(
+  `^(?:what|who)\\s+([a-z']+)\\s+(${PREP_SRC})\\s+(.+?)[?.!\\s]*$`, "i");
+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;
 
 /** "<X> is <adjective>" — the property teach payload (wrapper-REQUIRED): a lazy
  *  subject and a single bare complement word. Never matches the "is a <noun>"
@@ -2115,11 +2219,6 @@ function singularizeSurface(word) {
   return w;
 }
 
-/** "some Xs are Ys" / "a few Xs are Ys" — the plural class-membership
- *  quantifier shape. Captures the quantifier word itself (group 1) alongside
- *  the plural subject/object (groups 2/3); singularized before storage/lookup. */
-const SOME_A_FEW_RE = /^(some|a few)\s+([\w-]+)\s+are\s+([\w-]+)$/i;
-
 /** "(every|each|all|a|an )?X is/are (a|an )?Y" — the shape the unknown-subject
  *  fallback recognizes (group 2 = X, group 4 = Y); group 1 (when present)
  *  names the determiner, so the caller can tell a genuine "every" universal
@@ -2295,9 +2394,7 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   if (classify(subjectRaw, lex)) return null;
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
   // Singularize the SUBJECT before storage, but ONLY on a genuinely PLURAL
-  // phrasing ("all men ARE mortal", verb "are") — mirrors SOME_A_FEW_RE's own
-  // singularizeSurface() call (above), which is safe unconditionally there
-  // only because that shape's own regex requires "are" by construction. This
+  // phrasing ("all men ARE mortal", verb "are"). This
   // shape (UNKNOWN_SUBJECT_RE) also matches singular "is" sentences ("redis
   // is a cache"), where singularizing must NEVER run — "redis" naively folds
   // to "redi" under the same naive -s-strip. So "all men are mortal" stores
@@ -2418,7 +2515,7 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon },
   // unknownSubjectFallback itself already declines for it (its own
   // classify(subjectRaw) check reads "men" as the known noun "man") and hands
   // off to this mirror fallback instead. A naive suffix-strip
-  // (singularizeSurface — SOME_A_FEW_RE's own tool, reused as the fallback for
+  // (singularizeSurface, the fallback for
   // a genuinely novel REGULAR plural not in the lexicon, e.g. "zorps") can't
   // undo an IRREGULAR plural like "men" -> "man" — only the lexicon's own
   // noun table (lookupNoun, already resolved by isGroundedTerm/classify to
@@ -3023,6 +3120,42 @@ function teachSuggestion(payload) {
   return `every ${subject} is ${article} ${object}`;
 }
 
+/** "some/a few/several/most/many Xs are Ys" — a claim about SOME members of a
+ *  class. Every teach frame in this lane stores a universal: a subClassOf says
+ *  each member of the subject class counts as the object, which is what makes
+ *  it a premise the syllogiser can chain through. Stored that way, "some men
+ *  are fathers" reads back as a proof that any given man is a father, citing
+ *  the sentence as its warrant.
+ *
+ *  No existential shape exists in this store yet — owl:someValuesFrom is the
+ *  adjacent OWL construct, and reaching it means a rule of its own in
+ *  syllogise.mjs plus a fact shape that carries the restriction. Until one is
+ *  designed, these sentences refuse and name the universal that would work.
+ *  "every"/"each"/"all" ARE universals and teach unchanged. */
+const EXISTENTIAL_CLASS_TEACH_RE = /^(some|a few|several|most|many)\s+([\w-]+)\s+(?:is|are)\s+(?:an?\s+)?([\w-]+)[.!]*$/i;
+
+/** The lexicon's own lemma for a plural, falling back to the naive suffix
+ *  strip — the only source that undoes an irregular plural ("men" -> "man",
+ *  which no suffix rule can reach). */
+const singularOf = (word, lex, lookupNoun) => lookupNoun(lex, word)?.lemma || singularizeSurface(word);
+
+async function existentialTeachRefusal(payload, lexicon) {
+  const sentence = String(payload || "").trim();
+  const m = sentence.match(EXISTENTIAL_CLASS_TEACH_RE);
+  if (!m) return null;
+  const [, quantifier, subject, object] = m;
+  const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
+  const lex = lexicon || loadLexicon();
+  const singularSubject = singularOf(subject, lex, lookupNoun);
+  const universal = teachSuggestion(`${singularSubject} is ${singularOf(object, lex, lookupNoun)}`);
+  return {
+    text: `I can't store "${sentence.replace(/[.!]+$/, "")}" — "${quantifier.toLowerCase()}" claims only some of them, `
+      + "and I store universals, so that isn't a shape I can store yet."
+      + (universal ? ` If you mean it of every ${singularSubject}, say "${universal}".` : ""),
+    via: "teach-miss", miss: true,
+  };
+}
+
 /** The honest decline for a bare habitual teach ("penguins swim") whose
  *  subject is grounded nowhere — neither the static lexicon nor a prior
  *  taught fact. Mirrors ungroundedPairHint's "name the gap, hand over a
@@ -3079,21 +3212,21 @@ const TEACH_PRONOUN_RE = new RegExp(`^(?:every\\s+|each\\s+|all\\s+|some\\s+|a f
  *  when a teach frame offers one. */
 const isTeachPronoun = (s) => TEACH_PRONOUNS.includes(String(s || "").trim().toLowerCase());
 
-/** RETRACTION / NEGATION of an already-taught subClassOf fact: "X is not a Y"
- *  (tolerating the same "kind/type of" infix every other teach shape in this
- *  lane already tolerates — the "is/are" variant, plus the "isn't"/"aren't"
- *  contractions). Deliberately narrow — the SAFEST, most unambiguous negation
- *  phrasing only, matching a scoped 2-token subject (mirrors
- *  UNKNOWN_SUBJECT_RE's own subject width), never a general negation grammar.
- *  See the RETRACTION block's own comment in teachLane (below) for why a
- *  regex match here is only a TRIGGER, never itself proof a fact existed to
- *  retract — retractSubClassOf (src/domain/syllogise.mjs) is the actual authority. */
+/** NEGATION of a subClassOf fact: "X is not a Y" (tolerating the same
+ *  "kind/type of" infix every other teach shape in this lane already tolerates
+ *  — the "is/are" variant, plus the "isn't"/"aren't" contractions).
+ *  Deliberately narrow — the SAFEST, most unambiguous negation phrasing only,
+ *  matching a scoped 2-token subject (mirrors UNKNOWN_SUBJECT_RE's own subject
+ *  width), never a general negation grammar. A match is only a TRIGGER: the
+ *  shape also fits a negated PROPERTY claim ("the logger is not deprecated"),
+ *  so the stored subject⊑object fact is what decides whether there is a
+ *  disagreement to record. */
 const RETRACT_NOT_A_RE = /^(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:(?:is|are)\s+not|isn't|aren't)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
-/** "forget (that) X is a Y" — the second closed retraction phrasing. Never
- *  wrapped by TEACH_RE ("forget" isn't one of its
- *  recognized lead verbs — remember/note/keep in mind/…), so this is matched
- *  against the RAW (unwrapped) sentence, unlike RETRACT_NOT_A_RE above which
- *  is tried against the remember-wrapped surface too. */
+/** "forget (that) X is a Y" — the ONLY phrasing that retracts. Never wrapped
+ *  by TEACH_RE ("forget" isn't one of its recognized lead verbs —
+ *  remember/note/keep in mind/…), so this is matched against the RAW
+ *  (unwrapped) sentence, unlike RETRACT_NOT_A_RE above which is tried against
+ *  the remember-wrapped surface too. */
 const RETRACT_FORGET_RE = /^forget\s+(?:that\s+)?(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
 
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null }) {
@@ -3107,6 +3240,15 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const rawInput = applyPreambleFrames(String(query).trim());
   const m = rawInput.match(TEACH_RE);
   const wrappedInput = m ? m[1].trim() : null;
+  // Refuse an existential BEFORE any frame below can read it as a universal:
+  // every one of them stores "some men are fathers" as a premise meaning every
+  // man, whether it keeps the quantifier as an attribute the reasoner doesn't
+  // consult (the subclass frame) or bakes the word into the subject itself
+  // ("most men is a kind of fathers", the unknown-subject frame).
+  if (memoryDir && !QUESTION_LEAD_RE.test(wrappedInput ?? rawInput)) {
+    const refusal = await existentialTeachRefusal(wrappedInput ?? rawInput, lexicon);
+    if (refusal) return refusal;
+  }
   // "your X is a/an Y" — a plain casual synonym for "a/an X is a
   // Y": no special second-person semantics, so rewrite it to the ordinary
   // indefinite-article determiner UP FRONT, before any downstream regex/ACE
@@ -3265,31 +3407,13 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     };
   }
 
-  // RETRACTION — "X is not a Y" / "forget that X is a Y": wires the
-  // data-layer retraction primitive (retractSubClassOf, src/domain/syllogise.mjs) up
-  // to chat-level phrasing. Tried here, right after the pronoun guard, so a
-  // pronoun subject ("it is not an animal") still falls to that
-  // guard's own decline first (TEACH_PRONOUN_RE matches ANY verb after the
-  // pronoun, including "is not"), never reaching this block.
-  //
-  // TRIGGER, never itself the authority: RETRACT_NOT_A_RE/RETRACT_FORGET_RE
-  // only recognize the SHAPE of a negation/retraction sentence — they say
-  // nothing about whether subject⊑object was ever actually taught.
-  // retractSubClassOf is asked for real and is the only thing that decides:
-  //   - found:true  → a real stored (or entailed) fact existed and was
-  //     retracted (with its dependency-directed cascade) — confirmed here.
-  //   - found:false → subject⊑object was never a stored fact. This is left
-  //     to FALL THROUGH to the rest of teachLane's ordinary cascade below,
-  //     deliberately NOT answered with a bespoke "nothing to forget" message
-  //     — RETRACT_NOT_A_RE's shape also incidentally matches a NEGATED
-  //     PROPERTY claim ("the logger is not deprecated" — never subClassOf-
-  //     shaped at all, a pinned "genuine ceiling" case elsewhere in this
-  //     codebase, test/chatflow-tier5.test.mjs, that must keep its own
-  //     "I couldn't store that —" decline verbatim), so a bare "nothing
-  //     found" here must never claim a specific, possibly-wrong reason —
-  //     falling through preserves whatever honest response that OTHER shape
-  //     already gets, byte-identical, while still fully closing the real gap
-  //     (an already-taught fact's retraction, which now always succeeds).
+  // NEGATION ("X is not a Y") and RETRACTION ("forget that X is a Y"). Two
+  // sentences, two intents, and the split is the point: a negative is a source
+  // DISAGREEING, never an instruction to destroy. Each branch documents itself
+  // below; both are tried here, right after the pronoun guard, so a pronoun
+  // subject ("it is not an animal") still falls to that guard's own decline
+  // first (TEACH_PRONOUN_RE matches ANY verb after the pronoun, including
+  // "is not"), never reaching this block.
   const retractSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
   const retractSrcMidQuestion = memoryDir && !QUESTION_LEAD_RE.test(retractSrc)
     ? await hasMidSentenceInterrogative(retractSrc) : false;
@@ -3302,22 +3426,76 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (retractMatch) {
     const retractSubject = retractMatch[1].trim();
     const retractObject = retractMatch[2].trim();
-    const { retractSubClassOf } = await import("../domain/syllogise.mjs");
-    const { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts } = await import("../adapters/memory/core.mjs");
-    const result = await retractSubClassOf(memoryDir, retractSubject, retractObject, {
-      store: { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts },
-    });
-    if (result.found) {
-      const extra = result.count - 1; // beyond the target fact itself
-      return {
-        text: `noted — forgotten: "${retractSubject} is a kind of ${retractObject}" is no longer stored`
-          + (extra > 0 ? ` (${extra} entailed fact${extra === 1 ? "" : "s"} that depended on it went too)` : "")
-          + (result.truncated ? " — this cascade may not be complete (a lot depended on it); ask again if something still looks stale" : "")
-          + ".",
-        via: "retract", miss: false,
-      };
+
+    // A BARE NEGATIVE IS A CLAIM, NOT AN INSTRUCTION TO DELETE. "john is not a
+    // man" disagrees with a stored fact; it does not ask for it to be
+    // destroyed, and destroying it loses the very disagreement the user came
+    // to record. Both polarities are stored under their own predicate
+    // (memory/capability.mjs: a fact id hashes (subject, predicate, object), so
+    // sharing one predicate would merge them and union their statedBy edges),
+    // and the ask ladder reports the disagreement rather than picking a side.
+    // Only the explicit "forget that X is a Y" verb retracts — see below.
+    //
+    // GATED ON THE POSITIVE EXISTING, and that gate is load-bearing:
+    // RETRACT_NOT_A_RE's shape also incidentally matches a negated PROPERTY
+    // claim ("the logger is not deprecated"), which is never subClassOf-shaped
+    // at all and keeps its own decline verbatim. With no stored subject⊑object
+    // to disagree with, there is nothing here to record, so the sentence falls
+    // through to the ordinary cascade exactly as it always has.
+    if (retractNotMatch) {
+      const { SUBCLASS_PREDICATE } = await import("../domain/syllogise.mjs");
+      const { loadMemory: loadMemForNeg, normFactTerm: normTermForNeg, readFactRows: readRowsForNeg } = await import("../adapters/memory/core.mjs");
+      const negSubject = normTermForNeg(retractSubject);
+      const negObject = normTermForNeg(retractObject);
+      const priorRows = readRowsForNeg(await loadMemForNeg(memoryDir));
+      const positive = priorRows.find((r) => r.subject === negSubject && r.predicate === SUBCLASS_PREDICATE && r.object === negObject);
+      if (positive) {
+        const stored = await teachFact(memoryDir, sessionId, {
+          subject: retractSubject, predicate: NEG_SUBCLASS_PREDICATE, object: retractObject,
+        });
+        if (stored) {
+          return {
+            ...stored,
+            text: `${stored.text} — you told me earlier that ${negSubject} is a kind of ${negObject}, so both are now stored `
+              + `and I'll report the disagreement rather than pick one. `
+              + `To drop the earlier fact instead, say "forget that ${negSubject} is ${indefiniteArticleFor(negObject)} ${negObject}".`,
+          };
+        }
+      }
+      // nothing stored to disagree with — fall through (see the gate above).
+    }
+
+    // RETRACTION — "forget that X is a Y": wires the data-layer retraction
+    // primitive (retractSubClassOf, src/domain/syllogise.mjs) up to chat-level
+    // phrasing.
+    //
+    // TRIGGER, never itself the authority: RETRACT_FORGET_RE only recognizes
+    // the SHAPE of a retraction sentence — it says nothing about whether
+    // subject⊑object was ever actually taught. retractSubClassOf is asked for
+    // real and is the only thing that decides:
+    //   - found:true  → a real stored (or entailed) fact existed and was
+    //     retracted (with its dependency-directed cascade) — confirmed here.
+    //   - found:false → subject⊑object was never a stored fact, and this falls
+    //     through to the rest of teachLane's ordinary cascade below rather than
+    //     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 result = await retractSubClassOf(memoryDir, retractSubject, retractObject, {
+        store: { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts },
+      });
+      if (result.found) {
+        const extra = result.count - 1; // beyond the target fact itself
+        return {
+          text: `noted — forgotten: "${retractSubject} is a kind of ${retractObject}" is no longer stored`
+            + (extra > 0 ? ` (${extra} entailed fact${extra === 1 ? "" : "s"} that depended on it went too)` : "")
+            + (result.truncated ? " — this cascade may not be complete (a lot depended on it); ask again if something still looks stale" : "")
+            + ".",
+          via: "retract", miss: false,
+        };
+      }
+      // found:false — fall through to the rest of the cascade (see docblock above).
     }
-    // found:false — fall through to the rest of the cascade (see docblock above).
   }
 
   // OWNERSHIP — "<Name> owns/maintains <X>", bare or remember-wrapped. The bare
@@ -3729,59 +3907,6 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     if (stored) return stored;
   }
 
-  // "some Xs are Ys" / "a few Xs are Ys" — the plural class-
-  // membership quantifier shape. ACE has no quantifier-phrase pattern at all
-  // (parseAce never even attempts a fit), so this is ALWAYS a direct write,
-  // never routed through assertTurn below. Wrapper-optional, like the
-  // "every X is a Y" baseline — a plural "some/a few" claim reads as an
-  // ordinary declarative teach the same way "every" always has. The OBJECT
-  // still has to be a known lexicon noun (the same "subject gets the free
-  // pass, object doesn't" discipline as unknownSubjectFallback below) — an
-  // unknown object falls through to the generic honest-miss cascade at the
-  // bottom of this function, same as every other unstorable teach.
-  const someSrc = wrapped ?? raw.replace(/[.!?]+\s*$/, "");
-  // Additive alongside the existing anchored QUESTION_LEAD_RE check — same
-  // discipline as ownSrcMidQuestion above (hasMidSentenceInterrogative's own
-  // docblock, near QUESTION_LEAD_RE, has the full reasoning).
-  const someSrcMidQuestion = memoryDir && !QUESTION_LEAD_RE.test(someSrc) ? await hasMidSentenceInterrogative(someSrc) : false;
-  const someMatch = memoryDir && !QUESTION_LEAD_RE.test(someSrc) && !someSrcMidQuestion ? someSrc.match(SOME_A_FEW_RE) : null;
-  if (someMatch) {
-    const quantifier = someMatch[1].toLowerCase();
-    const subject = singularizeSurface(someMatch[2]);
-    const object = singularizeSurface(someMatch[3]);
-    const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
-    const lex = lexicon || loadLexicon();
-    if (lookupNoun(lex, object)) {
-      const stored = await teachFact(memoryDir, sessionId, {
-        subject, predicate: SUBCLASS_PREDICATE, object, quantifier,
-      });
-      if (stored) return stored;
-    } else {
-      // "remember that some functions are risky" — Y ("risky") is not a
-      // lexicon NOUN, so the subclass path just above correctly declines it
-      // (SOME_A_FEW_RE is subclass-only). Without this guard, the sentence
-      // would fall through to unknownSubjectFallback/TEACH_PROPERTY_RE below,
-      // which DO tolerate a multi-word subject with NO vocabulary check on
-      // the complement at all — silently mis-teaching the LITERAL 2-word
-      // string "some functions" as if it were one proper-noun subject
-      // ("noted — remembered: some functions is risky", the quantifier word
-      // baked wrongly into the subject and a subject/verb agreement error to
-      // boot), a fact "how many functions are risky" could never sensibly
-      // read back either (HOW_MANY_ARE_RE's own reader only ever looks for
-      // the SUBCLASS_PREDICATE shape this path would have stored, not this
-      // one). A quantified PROPERTY claim isn't a supported shape yet (only
-      // a quantified SUBCLASS claim is) — decline honestly here instead of
-      // silently mis-teaching, rather than let a later, less-specific frame
-      // guess a wrong split.
-      return {
-        text: `I can only remember a quantified fact as "${quantifier} ${someMatch[2]} are <a kind of thing>" (like "${quantifier} bugs are issues") — `
-          + `a quantified claim about a PROPERTY ("${quantifier} ${someMatch[2]} are ${object}") isn't a shape I can store yet. `
-          + `I can remember "${someMatch[2]} are ${object}" for one specific ${subject}, though — try naming it directly.`,
-        via: "teach-miss", miss: true,
-      };
-    }
-  }
-
   // GENERAL VERB-TO-PREDICATE TEACH — "remember <Subject> <verb>
   // <Object>" where <verb> is neither is/are (handled below via the ACE/
   // unknown-subject/property paths) nor owns/maintains (handled above).
@@ -4099,6 +4224,18 @@ const MODULE_ORIENT_SVO_RE = new RegExp(`^what\\s+(.+?)\\s+does${TRAILING_ADVERB
 // tolerance for the bare "whats" contraction spelling, just below.
 const MODULE_PURPOSE_RE = /^what(?:'s|s|\s+is)\s+(.+?)\s+(?:for|about)\??$/i;
 
+/** A module PATH as a reader types it — "src/core/store.mjs", "app/lib/b.mjs",
+ *  or a bare "store.mjs". Requires a slash or a source-file extension, which is
+ *  what makes the two identity phrasings below safe to claim: no vocabulary
+ *  term can match this shape, so "what is a dog" is untouched. The lane's
+ *  exact-unique resolveEntity gate is still the authority — this only decides
+ *  what is worth ASKING it about. */
+const MODULE_PATH_RE = /^(?:[\w.@~-]+\/)+[\w.@~-]+$|^[\w.@~-]+\.(?:mjs|cjs|js|jsx|ts|tsx|py|java|rb|go|rs|php|cs|kt|swift)$/i;
+/** "what is src/core/store.mjs" — the identity phrasing of the same question
+ *  "what does X do" already answers. Kept distinct from MODULE_PURPOSE_RE
+ *  ("what is X for"), whose trailing "for"/"about" is what anchors it. */
+const MODULE_IDENTITY_RE = /^what(?:'s|s|\s+is)\s+(.+?)$/i;
+
 /** A leading politeness/formal-ESL wrapper this lane's own anchored regexes
  *  otherwise miss entirely: "please explain what does X do"
  *  starts with neither "what"/"whats" (MODULE_ORIENT_RE/MODULE_PURPOSE_RE's own
@@ -4141,8 +4278,16 @@ async function moduleOrientLane(query, { graph }) {
   // regex only adds the "explain [to me]" wrapper on top).
   q = stripFillerWords(applyPreambleFrames(correctMisspellings(q))).replace(MODULE_ORIENT_POLITENESS_RE, "");
   const m = q.match(MODULE_ORIENT_RE) || q.match(MODULE_PURPOSE_RE) || q.match(MODULE_ORIENT_SVO_RE);
-  if (!m) return null;
-  const term = m[1].trim();
+  // "what does src/core/store.mjs do" already reached the overview; the bare
+  // path and "what is <path>" did not, so the same module answered one
+  // phrasing and walled two. Both are claimed here rather than in ask.mjs,
+  // whose Module fallback is absent BY DESIGN — adding it there replaces this
+  // 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;
@@ -4693,6 +4838,7 @@ async function recallFromBlocks(memoryDir, query, graph) {
  *  predicate renders verbatim rather than being guessed around. */
 const FACT_PREDICATE_PHRASES = {
   "rdfs:subClassOf": "is a kind of",
+  "mgxneg:subClassOf": "is not a kind of",
   "rdf:type": "is a",
   "owl:disjointWith": "is not a",
   "mgx:partOf": "is part of",
@@ -4862,6 +5008,40 @@ function renderFactLine(f) {
   return `i learned: ${factPhrase(f)}${cite}`;
 }
 
+/** "a"/"an" for a term, through the SAME grammar-rules.toml "article" rule and
+ *  finish.mjs's beginsWithVowelSound every other agreement site in this file
+ *  uses — never a hardcoded "a", which is ungrammatical for a vowel-initial
+ *  term ("forget that task is a animal"). */
+function indefiniteArticleFor(term) {
+  const articleRule = grammarRules().find((r) => r.kind === "article");
+  return articleRule && beginsWithVowelSound(String(term || ""), articleRule) ? "an" : "a";
+}
+
+/** The verdict on an is-a question, given the best stored fact of each
+ *  polarity. Null when neither is stored, so a caller's own honest miss stands
+ *  — an absent positive is never a "no".
+ *
+ *  BOTH POLARITIES STORED names both sources and picks NOTHING, which is the
+ *  "both" verdict memory/capability.mjs already defines for the capability
+ *  family. Preferring either one would rank a tie-break the reader can't see
+ *  above what they actually said; recency in particular looks like a
+ *  correction and is just as often a second speaker.
+ *
+ *  Shared by the two is-a readers (the memory-facts lane and the full ladder),
+ *  so a disagreement reads identically whichever one answers. */
+function isaPolarityReply(hit, negHit) {
+  if (hit && negHit) {
+    return {
+      text: `you've told me both, and I won't pick between them — ${renderFactLine(hit)}; ${renderFactLine(negHit)}. `
+        + `To settle it, say "forget that ${hit.subject} is ${indefiniteArticleFor(hit.object)} ${hit.object}".`,
+      replace: true,
+    };
+  }
+  if (negHit) return { text: `no — ${renderFactLine(negHit)}`, replace: true };
+  if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+  return null;
+}
+
 /** 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;
@@ -4927,11 +5107,71 @@ async function factRows(memoryDir, cache = null) {
 
 /** Spelling variants a question term is matched under (normFactTerm + a naive
  *  singular): "caches"/"a cache"/"/c/en/cache" all reach the stored "cache". */
+/** The lexicon's declared plural → lemma map ("men"→"man", "people"→"person"),
+ *  loaded once. It carries ONLY the irregulars — a regular plural is recovered
+ *  by the -s/-es fold below, so declaring one would be redundant — which is
+ *  exactly the set that fold cannot reach. Failure-tolerated: a broken lexicon
+ *  degrades to the fold alone, never a crash. */
+let declaredNounPlurals = null;
+function irregularSingularOf(word) {
+  if (!declaredNounPlurals) {
+    try { declaredNounPlurals = loadLexicon().nounPlurals; } catch { declaredNounPlurals = new Map(); }
+  }
+  return declaredNounPlurals.get(word) ?? null;
+}
+
+/** A subject as it should be SPOKEN BACK in an offered teach sentence: the
+ *  lexicon's own lemma for a single known noun, else the reader's words
+ *  untouched.
+ *
+ *  Without it a plural subject was echoed raw into a singular frame —
+ *  "remember that women is mortal" — offering a sentence that is both
+ *  ungrammatical and not the shape the teach path stores. lookupNoun is the
+ *  lemmatizer the teach path already uses, and it is the whole plural detector:
+ *  it folds "women"→woman and "dogs"→dog while leaving "bus" alone, which no
+ *  -s rule written here could do. A multi-word or unknown subject is left
+ *  exactly as typed — "every zibble is mortal" already reads correctly, and
+ *  guessing at a phrase's head would be worse than echoing it. */
+function teachableSubjectOf(subject) {
+  const raw = String(subject || "").trim().toLowerCase();
+  if (!raw || /\s/.test(raw)) return raw;
+  try {
+    return lookupNoun(loadLexicon(), raw)?.lemma || raw;
+  } catch {
+    return raw;
+  }
+}
+
+/** 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
+ *  begins with one — which is what makes stripping it here a lookup fix and not
+ *  a guess. "a"/"an" are deliberately absent: the readers' own regexes already
+ *  take the article. */
+const QUANTIFIER_LEAD_RE = /^(?:every|each|all|any)\s+/i;
+
 function factTermVariants(normFactTerm, term) {
   const t = normFactTerm(term);
-  const v = new Set([t]);
-  if (t.endsWith("es")) v.add(t.slice(0, -2));
-  if (t.endsWith("s")) v.add(t.slice(0, -1));
+  const v = new Set();
+  // The ask frames glue a quantifier onto the subject and looked up "every
+  // man", a name nothing is stored under, while "is a man mortal" answered.
+  // Both spellings fold through the same plural rules below, so "are all men
+  // mortal" reaches "man" the same way "are men mortal" does.
+  const bases = new Set([t]);
+  const unquantified = t.replace(QUANTIFIER_LEAD_RE, "").trim();
+  if (unquantified && unquantified !== t) bases.add(unquantified);
+  for (const base of bases) {
+    v.add(base);
+    if (base.endsWith("es")) v.add(base.slice(0, -2));
+    if (base.endsWith("s")) v.add(base.slice(0, -1));
+    // An IRREGULAR plural is invisible to the fold above: "men" keeps every
+    // letter of "man" in a different order, so a reader asking "do men die"
+    // looked up a subject no fact is stored under while "does a man die"
+    // answered. The teach path stores the singular, so the ask path has to be
+    // able to reach it.
+    const irregular = irregularSingularOf(base);
+    if (irregular) v.add(normFactTerm(irregular));
+  }
   return v;
 }
 
@@ -5128,8 +5368,8 @@ function matchGenitiveWhoAsk(q) {
  *  reachable from the named start entity through a taught `recursive` Rule,
  *  not a single yes/no. `m[1]` = the rule's PLURAL name ("descendants",
  *  singularized via singularizeSurface before the findRuleByName lookup —
- *  the same naive plural fold SOME_A_FEW_RE's own teach-side surface already
- *  uses elsewhere in this file), `m[2]` = the start entity ("ahab"). Dispatch
+ *  the same naive plural fold the teach-side surfaces use elsewhere in this
+ *  file), `m[2]` = the start entity ("ahab"). Dispatch
  *  lives in factReadBack's own (a0.5) block, below — findRuleByName +
  *  findReachableSet (src/domain/planning.mjs), never a yes/no answer. */
 const RECURSIVE_LIST_ASK_RE = /^list\s+(?:the\s+|all\s+)?([a-z][\w-]*)\s+of\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[?.!\s]*$/i;
@@ -5757,13 +5997,23 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
   // bare catch-all: on the FIRST turn of a graph-less session, dispatchTool's
   // loadGraph() throws its own documented empty-graph ToolError (a pre-existing,
   // by-design bootstrap behavior — self-corrects from turn 2 on), which leaves
-  // `envelope` null for the rest of the turn, arming this `!envelope?.parsed`
-  // fallback. Without this guard it greedily swallows the WHOLE "kind of animal"
-  // tail as a literal meta-term to define (mirroring grammar.mjs T5's OWN
-  // ARTICLE_RELATION_CONTINUATIONS guard against the identical over-capture),
-  // returning early and never letting (b5) below — which already handles this
-  // exact shape via WHAT_INHERITS_RE, envelope or no envelope — get a chance.
-  if (!metaTerm && miss && !envelope?.parsed && !WHAT_INHERITS_RE.test(q)) {
+  // `envelope` null for the rest of the turn, arming this
+  // no-parse-to-defer-to fallback. Without this guard it greedily swallows the
+  // WHOLE "kind of animal" tail as a literal meta-term to define (mirroring
+  // grammar.mjs T5's OWN ARTICLE_RELATION_CONTINUATIONS guard against the
+  // identical over-capture), returning early and never letting (b5) below —
+  // which already handles this exact shape via WHAT_INHERITS_RE, envelope or
+  // no envelope — get a chance.
+  //
+  // A parse that MISSED is not a parse to defer to. "what are dogs" is claimed
+  // by the composite lane, which declines it ({node:"miss"}, "'dogs' isn't a
+  // listable kind") and by existing merely blocked the vocabulary reader that
+  // answers the singular. The plural is the whole difference: "what are dog"
+  // always worked. A SUCCESSFUL parse still wins here exactly as before — the
+  // over-capture this guard exists to stop parses fine, so it never reaches
+  // this branch.
+  const parsedOwnsIt = envelope?.parsed && envelope.parsed.node !== "miss";
+  if (!metaTerm && miss && !parsedOwnsIt && !WHAT_INHERITS_RE.test(q)) {
     const m = q.match(BARE_WHATIS_RE)
       || q.match(/^what\s+(?:does|do)\s+(.+?)\s+means?[?.!\s]*$/i);
     // Strip a curated trailing scope clause ("… in this
@@ -5899,11 +6149,15 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
   if (isa) {
     const subj = factTermVariants(normFactTerm, isa[1]);
     const obj = factTermVariants(normFactTerm, isa[2]);
-    const hit = (await memoryFacts(memoryDir)).find(
-      (f) => ISA_PREDICATES.has(f.predicate) && subj.has(f.subject) && obj.has(f.object),
+    const isaRows = await memoryFacts(memoryDir);
+    const onTerms = (f) => subj.has(f.subject) && obj.has(f.object);
+    // 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(
+      isaRows.find((f) => ISA_PREDICATES.has(f.predicate) && onTerms(f)),
+      isaRows.find((f) => f.predicate === NEG_SUBCLASS_PREDICATE && onTerms(f)),
     );
-    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
-    return null; // no remembered fact — the honest miss stands (never a guessed "no")
+    return reply; // no remembered fact — null, so the honest miss stands (never a guessed "no")
   }
 
   // (b2) "can a dog bark" — the polarity of a capability, resolved through the
@@ -6298,6 +6552,13 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
  *  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;
+/** 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
+ *  the conversation, exactly as the pronoun in "can it bark" is. So the term
+ *  comes from the standing referent (vocabAntecedentFrom) and this shape is a
+ *  no-op when nothing is standing. */
+const WHAT_ELSE_BARE_RE = /^(?:(?:and|so|but|ok|okay|now|then)\s+)*(?:what\s+else(?:\s+do\s+you\s+know)?|anything\s+else(?:\s+you\s+know)?|got\s+anything\s+else)[?.!\s]*$/i;
 
 /** "what else is X" — surface remembered facts about X BEYOND the primary
  *  curated (corpus/seon) prose definition, which is itself never a Facts row
@@ -6321,9 +6582,18 @@ 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);
-  if (!m) return null;
-  const term = m[1].trim();
-  if (!term) return null;
+  // 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);
+  const term = (m ? m[1] : (bare ? vocabAntecedentFrom(last) : null) || "").trim();
+  // Asked cold, it names what it cannot resolve rather than introducing the
+  // tool — the same courtesy a cold pronoun already gets. An identity blurb
+  // answers a question nobody asked.
+  if (!term) {
+    return bare
+      ? { text: "Nothing to add yet — there's no subject standing. Ask me about something first, then \"what else\".", replace: true, miss: true }
+      : null;
+  }
   let normFactTerm;
   try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const variants = factTermVariants(normFactTerm, term);
@@ -6510,7 +6780,7 @@ const IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE = /^(?:you|i|they|he|she|we)\b/i;
  *  reaches TEACH_PROPERTY_RE via BARE_DECLARATIVE_RE's single-token-subject
  *  restriction and would fail here). */
 const unknownAdjectiveOffer = (subject, adjective) => ({
-  text: `I don't know anything about "${subject}" yet — teach me directly, e.g. "remember that ${subject.toLowerCase()} is ${adjective}".`,
+  text: `I don't know anything about "${subject}" yet — teach me directly, e.g. "remember that ${teachableSubjectOf(subject)} is ${adjective}".`,
   replace: true,
 });
 /** WHOLE-STORE recall: "what did i tell you [last time]",
@@ -7030,7 +7300,14 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     const hit = isa
       .filter((f) => subjCandidates.has(f.subject) && objVariants.has(f.object))
       .sort(byTrust)[0];
-    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    // 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`.
+    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);
+    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
     // "controller ⊑ handler" composes with a graph "TaskController inherits
@@ -7184,7 +7461,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // missed — check whether X, having taught-P'd something of a taught type
     // (lifted through that type's FULL ⊑-ancestor closure), satisfies a
     // TAUGHT someValuesFrom restriction declared over that SAME (property,
-    // type) pair — the restriction CLASS itself entailed (OWL 2 RL Table 8's
+    // type) pair — the restriction CLASS itself entailed (OWL 2 RL Table 6's
     // cls-svf1), via syllogise.mjs's deriveSomeValuesFromApplication, LIVE and
     // READ-ONLY (same discipline as the cax-dw chase just above: nothing is
     // written; syllogise()'s materializing batch pass is the persisting
@@ -7668,7 +7945,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 ${subject.toLowerCase()} is ${adjective}.`, replace: true };
+        return { text: `I don't have a fact saying ${teachableSubjectOf(subject)} is ${adjective}.`, replace: true };
       }
       // Without this, "is the checkout flow
       // deprecated" as a genuinely FIRST-EVER question about a subject tmct
@@ -8486,11 +8763,31 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
     // updates too — mirrors the focus updates the ordinary ask() path does.
     const ent = await resolveEntity(graph, term);
     return { text, ent };
-  } catch {
+  } catch (e) {
+    // tmct_describe answers a concept from memory/corpus facts whenever the
+    // code map holds nothing for it — but dispatchTool loads the graph BEFORE
+    // the handler runs, so on an empty one the handler never gets to reach its
+    // own fall-through. Reach it here instead: "tell me about a dog" is a
+    // question about a dog, and the code graph's emptiness is no answer to it.
+    if (e?.emptyGraph) return describeFromMemoryFacts(term, config);
     return null; // unresolvable term — decline, the ordinary wall stands unchanged
   }
 }
 
+/** tmct_describe's OWN memory/corpus fall-through (tools/memory-fallthrough.mjs),
+ *  called directly for a session whose code graph is empty. Same rows, same
+ *  renderer, same provenance the handler itself would have cited. */
+async function describeFromMemoryFacts(term, config) {
+  if (!config) return null;
+  try {
+    const { memoryFactRows, renderMemoryDefinition } = await import("../tools/memory-fallthrough.mjs");
+    const text = renderMemoryDefinition(await memoryFactRows(config), term);
+    return text ? { text, ent: null } : null;
+  } catch {
+    return null;
+  }
+}
+
 /** COMPARE — a scoped
  *  v1: "how is X different from Y", "how does X differ from Y", "compare X and
  *  Y"/"compare X with/to Y", "what's the difference between X and Y". Closed
@@ -8849,7 +9146,18 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
   // The verbless voicing carries every capture but the verb, so it folds into
   // the frame below once the store names the verb — same spec, same
   // confirmation, same fold as its verbed twin.
-  const verblessGoal = goalMatch ? null : q.match(GOAL_TEACH_VERBLESS_RE);
+  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
+  // 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 (verblessGoal) {
     const { normFactTerm } = await import("../adapters/memory/core.mjs");
     const { factRows, domain } = await loadPlanContext(memoryDir);
@@ -9073,6 +9381,90 @@ async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
   };
 }
 
+/** Plan follow-up questions ("what is the next move", "how many moves", "why
+ *  that move") answered off the ACTIVE plan, and board-state questions ("is X
+ *  clear", "what rests on X", "where is X") answered off the CURRENT board (the
+ *  latest @stepK snapshot, or the taught board before any step). Returns
+ *  { text, deduced, note } or null — null when the query is neither shape, or
+ *  when no plan/board stands to answer from, so an honest miss stands cold.
+ *  This keeps a read from contradicting the plan's own board@stepK line: after
+ *  "next" moves a piece, "what rests on X" reflects the snapshot, not the stale
+ *  pre-plan facts. Clearness is derived, never stored — a piece is clear iff
+ *  nothing rests on it on the current board. */
+async function planFollowUpAnswer(query, { memoryDir, planHolder }) {
+  const q = String(query).trim();
+  const ps = planHolder?.state;
+  const activePlan = ps && Array.isArray(ps.actions) && ps.actions.length;
+
+  if (PLAN_WHAT_NEXT_RE.test(q)) {
+    if (!activePlan) return null;
+    if (ps.done || ps.cursor >= ps.actions.length) {
+      return { text: `the plan is complete — all ${ps.actions.length} moves are made.`, deduced: "name the next planned move (plan complete)", note: "PLAN FOLLOW-UP — next move: plan already complete" };
+    }
+    return { text: `the next move is move ${ps.cursor + 1} of ${ps.actions.length}: ${ps.actions[ps.cursor].label}. Say "next" to make it.`, deduced: "name the next planned move", note: "PLAN FOLLOW-UP — next move read from the active plan" };
+  }
+  if (PLAN_MOVE_COUNT_RE.test(q)) {
+    if (!activePlan) return null;
+    const total = ps.actions.length;
+    const remaining = Math.max(0, total - ps.cursor);
+    return { text: remaining === total ? `${total} move${total === 1 ? "" : "s"} in the plan.` : `${total} move${total === 1 ? "" : "s"} in the plan, ${remaining} still to make.`, deduced: "count the moves in the active plan", note: "PLAN FOLLOW-UP — move count from the active plan" };
+  }
+  if (PLAN_WHY_MOVE_RE.test(q)) {
+    if (!activePlan) return null;
+    const idx = ps.cursor < ps.actions.length ? ps.cursor : ps.actions.length - 1;
+    const line = ps.stepGoals?.[idx] ?? `${ps.actions[idx].label} (step ${idx + 1} of ${ps.actions.length})`;
+    return { text: `${line} — it is this step's move on the shortest path.`, deduced: "explain the next planned move", note: "PLAN FOLLOW-UP — why-move from the active plan's step goals" };
+  }
+
+  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;
+  if (!memoryDir) return null;
+
+  let ctx;
+  try { ctx = await loadPlanContext(memoryDir); } catch { return null; }
+  const { domain, state } = ctx;
+  if (!domain.actions.length || !state.length) return null; // no board — the honest miss stands
+  const { normFactTerm } = await import("../adapters/memory/core.mjs");
+  const individuals = new Set(Object.values(domain.classMembers || {}).flat());
+
+  if (clear) {
+    const x = normFactTerm(clear[1]);
+    if (!individuals.has(x)) return null;
+    const on = state.filter((r) => r.object === x);
+    return on.length
+      ? { 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 (where || fwd) {
+    const x = normFactTerm((where ?? fwd)[1]);
+    if (!individuals.has(x)) return null;
+    const rows = state.filter((r) => r.subject === x);
+    if (!rows.length) return where
+      ? { text: `nothing on the current board says where ${x} is.`, deduced: "read the current board (where a piece is)", note: "BOARD — forward locative, no row for the piece" }
+      : null; // a verb-specific forward miss falls to the ordinary reader
+    return { text: rows.map(factPhrase).join("; "), deduced: "read the current board (where a piece is)", note: "BOARD — forward locative from the current board" };
+  }
+  // reverse: "what rests on X" / "what is on X"
+  const verb = rev[1].toLowerCase();
+  const prep = rev[2].toLowerCase();
+  const x = normFactTerm(rev[3].replace(/^(?:an?|the)\s+/i, "").trim());
+  if (!individuals.has(x)) return null;
+  const copula = /^(?:is|are|'s)$/.test(verb);
+  let predicate = null;
+  if (!copula) {
+    predicate = await generalVerbPredicate(verb);
+    if (/^mgx:[a-z]+$/.test(predicate)) predicate = `${predicate}-${prep}`;
+  }
+  const hits = state.filter((r) => r.object === x && (copula || r.predicate === predicate));
+  const emptyPhrase = predicate ? predicatePhrase(predicate) : "is on";
+  return hits.length
+    ? { text: hits.map(factPhrase).join("; "), deduced: "read the current board (what rests on a piece)", note: "BOARD — reverse locative from the current board" }
+    : { text: `nothing ${emptyPhrase} ${x} on the current board.`, deduced: "read the current board (what rests on a piece)", note: "BOARD — reverse locative, nothing on the current board" };
+}
+
 async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
@@ -9151,12 +9543,19 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   } catch (e) {
     const thrown = String(e?.message || e);
     // A graph-less session's ask dispatch fails reading the never-configured
-    // graph artifact — an internal error string, not an answer. Swap in an
-    // honest wall; the teach/fact lanes below still get their turn and
-    // replace it whenever they can store or answer instead. A missing config
-    // gets the same wall: with no config at all, no dispatch could ever have
-    // loaded a graph, whatever the internal error spelled.
-    answer = !graph && (!config || /^cannot read graph artifact\b/.test(thrown))
+    // graph artifact, or loads one holding nothing (e.emptyGraph — the first
+    // turn of a fresh session, before the conversation has folded anything in).
+    // Either way it's an internal error string, not an answer. Swap in an
+    // honest wall; the teach/fact/vocabulary lanes below still get their turn
+    // and replace it whenever they can store or answer instead. A missing
+    // config gets the same wall: with no config at all, no dispatch could ever
+    // have loaded a graph, whatever the internal error spelled.
+    //
+    // The session hands this lane a KNOWN-EMPTY graph object rather than null
+    // on that first turn, so the test is noCodeGraph, not `!graph`: an empty
+    // graph is as unusable as an absent one, and reporting its emptiness to
+    // someone asking about a dog answers a question they never asked.
+    answer = (!graph || noCodeGraph(graph)) && (!config || e?.emptyGraph || /^cannot read graph artifact\b/.test(thrown))
       ? "I can't answer that as a code question — no code graph is loaded in this session. "
         + "I can still remember and answer taught facts (try \"every disk is a game piece\"), "
         + "or run `tmct init` in a repo to index one."
@@ -9295,7 +9694,9 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   if (memoryDir) {
     const whatElse = await whatElseAnswer(memoryDir, query, last);
     if (whatElse) {
-      answer = whatElse.text; via = "fact:what-else"; recordMiss = false; handled = true;
+      // A cold "what else" carries miss:true — it resolved no subject, so the
+      // turn is a miss in better words, exactly like the isa ladder's closers.
+      answer = whatElse.text; via = "fact:what-else"; recordMiss = whatElse.miss ?? false; handled = true;
       if (whatElse.pending) factPending = whatElse.pending;
       deduced = "surface additional remembered facts beyond the primary definition";
       note(trace, "lane: (0) WHAT ELSE — \"what else is/about X\" recognized off the raw query, before the relaxation cascade could quietly drop \"else\" and reduce it to a plain \"what is X\"");
@@ -10350,6 +10751,57 @@ function renderAmbiguousAssert(line, ambiguous, normFactTerm) {
  *  committing to the first. Returns null for the overwhelming majority of
  *  sentences, so every single-reading sentence renders byte-identically to
  *  the unchanged parseAce path below. */
+/** Does this sentence match the general-verb teach frame on its own terms —
+ *  reusing generalVerbTeach's OWN closed guards, so the split gate and the lane
+ *  it feeds can never disagree about which sentences that lane accepts. */
+function matchesGeneralVerbTeachFrame(sentence) {
+  if (GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(sentence)) return false;
+  const m = sentence.match(GENERAL_VERB_TEACH_RE);
+  if (!m) return false;
+  const [, subject, verb] = m;
+  return !GENERAL_VERB_EXCLUDE_RE.test(verb)
+    && !GENERAL_VERB_NOT_A_VERB_RE.test(verb)
+    && !GENERAL_VERB_DETERMINER_RE.test(subject)
+    && !GENERAL_VERB_IMPERATIVE_SUBJECT_RE.test(subject);
+}
+
+/** Does this sentence stand alone as a teach — a clean ACE triple, a taxonomy
+ *  declaration, the comparative frame, or the general-verb frame? A question
+ *  never counts.
+ *
+ *  Each entry names a teach lane that accepts the sentence ALONE, so the set
+ *  here has to track that lane list or a line of real teach sentences goes to
+ *  the parser glued together. The comparative was missing, and the cost was on
+ *  a shipped surface: data/games/hanoi-3.txt's own board line
+ *  ("disk-1 is smaller than disk-2. disk-1 is smaller than disk-3.") stored
+ *  NOTHING, so disk-1 could never move and the recipe's promised solution did
+ *  not exist. The sibling lines on either side of it split correctly, which is
+ *  what made it invisible. */
+function sentenceTeachesAlone(sentence, parseAce, lex) {
+  const s = String(sentence).trim();
+  if (!s || s.includes("?")) return false;
+  const parse = parseAce(s, lex);
+  if (parse && parse.triples?.length && !parse.residue?.length) return true;
+  return DECLARATIVE_KIND_OF_RE.test(s) || COMPARATIVE_TEACH_RE.test(s) || matchesGeneralVerbTeachFrame(s);
+}
+
+/** Does every sentence of a multi-sentence line teach on its own? Then the line
+ *  is a teach line, and each sentence belongs in its own turn: handed over
+ *  glued, the first sentence's teach frame captures all the others as its
+ *  object ("disk-1 rests on disk-2. disk-2 rests on disk-3." stores an object of
+ *  "on disk-2. disk-2 rests on disk-3"). Any parse failure answers false and
+ *  leaves the unsplit line to the ordinary lanes. */
+async function everySentenceTeaches(sentences, lexicon) {
+  try {
+    const { parseAce } = await import("../domain/grammar/ace.mjs");
+    let lex = lexicon;
+    if (!lex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); lex = loadLexicon(); }
+    return sentences.every((sentence) => sentenceTeachesAlone(sentence, parseAce, lex));
+  } catch {
+    return false;
+  }
+}
+
 async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, cache = null }) {
   try {
     const { parseAce, parseAceAmbiguous } = await import("../domain/grammar/ace.mjs");
@@ -10463,6 +10915,22 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
 // `pending`, so the remainder is naturally cleared — no stale continuation. ----
 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. */
+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)"
+  + "\\s+(?:the\\s+)?(.+?)[?.!\\s]*$",
+  "i",
+);
 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
@@ -10574,21 +11042,25 @@ function coldPronounDeclineText(query) {
   return `not sure what "${m[2].toLowerCase()}" refers to yet — name the subject directly, e.g. "what is a <name>".`;
 }
 
-/** The subject of the LAST turn's first fact line, for vocabulary pronoun
- *  binding ("what is a dog" → "can it bark"). Fact answers render rigidly —
- *  "<subject> <phrase> <object> (source: …)", optionally behind a "yes — "/
- *  "no — "/"you told me: " prefix — so a 1–2 word leading subject followed
- *  by a phrase-table verb is extractable without any NLP. Anything else
- *  (code answers, walls, conversational text) returns null and no
+/** The subject of the last GROUNDED turn's first fact line, for vocabulary
+ *  pronoun binding ("what is a dog" → "can it bark"). Fact answers render
+ *  rigidly — "<subject> <phrase> <object> (source: …)", optionally behind a
+ *  "yes — "/"no — "/"you told me: " prefix — so a 1–2 word leading subject
+ *  followed by a phrase-table verb is extractable without any NLP. Anything
+ *  else (code answers, walls, conversational text) returns null and no
  *  substitution happens.
  *
+ *  It reads `grounded`, not `answer`, so an intervening miss leaves the
+ *  standing referent alone rather than stranding every pronoun behind it.
+ *
  *  A pronoun never binds. An honest miss opens first-person ("I can't confirm
  *  that — …"), which fits the subject+verb shape exactly, so without the
- *  isTeachPronoun check the miss lends "I" to the next turn and "is it an
- *  animal" is looked up as "is I an animal". A pronoun is no more a fact
- *  subject here than in the teach frames TEACH_PRONOUNS already guards. */
+ *  isTeachPronoun check a miss reaching here would lend "I" to the next turn
+ *  and "is it an animal" would be looked up as "is I an animal". A pronoun is
+ *  no more a fact subject here than in the teach frames TEACH_PRONOUNS already
+ *  guards. */
 function vocabAntecedentFrom(last) {
-  const first = String(last?.answer || "").split("\n")[0]
+  const first = String(last?.grounded || "").split("\n")[0]
     .replace(/^(?:yes|no) — /i, "")
     .replace(/^you told me: /i, "");
   const m = first.match(/^([a-z][\w'-]*(?:\s+[a-z][\w'-]*)?)\s+(?:is|are|has|can|causes|wants|requires|involves|means|begins|ends)\b/i);
@@ -10666,7 +11138,21 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     // runAsk's own effectiveQuery (set only when discourseRewrite substituted
     // a new subject and produced a genuine non-miss answer) takes over as the
     // continuation base for the NEXT turn's own discourseRewrite.
-    const nextLast = { query: finished.effectiveQuery ?? line, answer: finished.answer, detail: finished.detail ?? null };
+    //
+    // `grounded` is the last answer that actually ANSWERED, carried forward
+    // across misses. It is what a pronoun's referent binds to
+    // (vocabAntecedentFrom): a reader's misses come in clusters, and reading
+    // the referent off a wall stranded every pronoun after one stray line.
+    //
+    // `answer` must keep recording the miss regardless — the repeat-shortening
+    // walls compare consecutive answers through it, so a miss that declined to
+    // record itself would make every wall look like a first offence.
+    const nextLast = {
+      query: finished.effectiveQuery ?? line,
+      answer: finished.answer,
+      detail: finished.detail ?? null,
+      grounded: finished.record?.miss ? (last?.grounded ?? null) : finished.answer,
+    };
     // Goal/canonical lines append onto the PRE-narration `finished` result
     // `nextLast` was captured from, so a narrated turn still gets both short
     // lines up top plus the full trace block after.
@@ -10702,6 +11188,23 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     return rec;
   }
 
+  // PLAN FOLLOW-UP + BOARD — "what is the next move", "how many moves", "why
+  // that move" read the active plan; "is X clear", "what rests on X",
+  // "where is X" read the CURRENT board. Placed before answerCount (which owns
+  // "how many …") and the ask engine, so a plan/board answer never loses to a
+  // code-graph miss. Returns null with no plan/board standing, so nothing
+  // changes for a cold session — an honest miss still stands.
+  if (memoryDir) {
+    const follow = await planFollowUpAnswer(workingLine, { memoryDir, planHolder });
+    if (follow) {
+      note(trace, `goal: ${follow.deduced}`);
+      note(trace, `lane: ${follow.note}`);
+      const rec = withLast(plainTurn(workingLine, follow.text, { via: "plan", focus }), follow.deduced);
+      rec.planState = planHolder.state;
+      return rec;
+    }
+  }
+
   // "more" — page the remainder of a previous long listing, if one is held. Gated on
   // an actual pending remainder so a bare "more" with nothing to continue falls through
   // to the ordinary path (an honest miss), never a pretend page.
@@ -10711,16 +11214,37 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     return withLast(morePage(workingLine, ctx), "continue viewing a previous long listing");
   }
 
-  // Multi-sentence PLAN pre-split — one message carrying state sentences plus
-  // a goal/trigger ("disk-1 rests on disk-2. … the goal is that …. solve it.")
-  // runs each sentence as its own nested turn, threading focus/last/planState
-  // through, and answers with the final turn's result behind brief receipts.
-  if (!_noSplit && memoryDir) {
+  // "what would break if I change X" / "what breaks if I touch 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) {
+    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);
+  }
+
+  // Multi-sentence pre-split — one message carrying several sentences
+  // ("disk-1 rests on disk-2. … the goal is that …. solve it.") runs each
+  // sentence as its own nested turn, threading focus/last/planState through,
+  // and answers with the final turn's result behind brief receipts. Fires
+  // when the line ends in a plan trigger, or when every sentence is a
+  // self-contained teach: either way each sentence has a lane of its own, so
+  // none of them reaches the parser glued to its neighbours.
+  if (!_noSplit && memoryDir && carriesASentenceBoundary(workingLine)) {
     const sentences = splitSentences(workingLine);
     if (sentences.length > 1) {
       const lastSentence = sentences[sentences.length - 1];
-      if (PLAN_SOLVE_RE.test(lastSentence) || GOAL_TEACH_RE.test(lastSentence) || GOAL_TEACH_INFINITIVE_RE.test(lastSentence)
-        || GOAL_TEACH_VERBLESS_RE.test(lastSentence) || LEGAL_MOVES_RE.test(lastSentence)) {
+      const endsInPlanTrigger = PLAN_SOLVE_RE.test(lastSentence) || GOAL_TEACH_RE.test(lastSentence)
+        || GOAL_TEACH_INFINITIVE_RE.test(lastSentence) || GOAL_TEACH_VERBLESS_RE.test(lastSentence)
+        || LEGAL_MOVES_RE.test(lastSentence);
+      if (endsInPlanTrigger || await everySentenceTeaches(sentences, lexicon)) {
         let f = focus; let l = last; let ps = planHolder.state;
         const receipts = [];
         let finalRec = null;
@@ -10735,8 +11259,22 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
           finalRec = r;
           receipts.push(String(r.answer ?? "").split("\n")[0]);
         }
-        const receiptLines = receipts.slice(0, -1).map((t) => `• ${t}`).join("\n");
-        const combined = { ...finalRec, answer: receiptLines ? `${receiptLines}\n\n${finalRec.answer}` : finalRec.answer };
+        // When a plan trigger closes the line, the final sentence is the payload
+        // (the plan) and the earlier teaches are brief bulleted receipts. When
+        // every sentence teaches, the final one is a teach too, so it earns a
+        // bullet like its siblings — otherwise it renders unbulleted and trails
+        // a stray "Goal (inferred)" line the bulleted ones already dropped. Its
+        // goal-line tail (everything after the receipt's first line) is kept once.
+        let answer;
+        if (endsInPlanTrigger) {
+          const receiptLines = receipts.slice(0, -1).map((t) => `• ${t}`).join("\n");
+          answer = receiptLines ? `${receiptLines}\n\n${finalRec.answer}` : finalRec.answer;
+        } else {
+          const bullets = receipts.map((t) => `• ${t}`).join("\n");
+          const goalTail = String(finalRec.answer ?? "").split("\n").slice(1).join("\n").trim();
+          answer = goalTail ? `${bullets}\n\n${goalTail}` : bullets;
+        }
+        const combined = { ...finalRec, answer };
         combined.planState = ps;
         combined.focus = f;
         combined.last = l;