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

package/src/services/chat.mjs

@@ -820,7 +820,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".
@@ -2141,7 +2151,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 +2178,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 +2718,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 +2867,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 +3499,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 +3532,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 +3999,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 +4339,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 +5129,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 +5244,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 +6262,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 +6317,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 +6381,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 +6704,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 +6738,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 +7452,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 +7563,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 +7584,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 +7606,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 +7644,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 +7820,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 +8162,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 +8499,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;
@@ -8598,7 +8825,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 +8914,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 +9374,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 +9418,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 +9457,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.`,
+      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", 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",
+      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 +9535,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,12 +9598,20 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
   };
   const ruleNames = [...new Set(domain.actions.map((a) => a.name))].join('", "');
   const moveLines = actions.map((a, i) => `  ${i + 1}. ${a.label}`);
+  // A piece the goal reaches for with no taught position is an ASSUMPTION the
+  // plan silently makes (it reads the board as taught, without that piece) —
+  // said out loud with the plan rather than left implicit.
+  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",
     deduced: `plan a move sequence from the current state to the goal (${n} move${n === 1 ? "" : "s"})`,
@@ -9419,8 +9698,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 +9719,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;
@@ -9710,7 +10005,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}"`);
     }
   }
@@ -10519,8 +10817,8 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     return mk(`narrate mode ${next ? "on" : "off"}.`, { narrateNext: next });
   }
 
-  // /memory [verbose] — what tmct remembers, as text (the ROADMAP "Memory
-  // inspection" surface; the same renderer serves the `tmct memory` CLI).
+  // /memory [verbose] — what tmct remembers, as text (the same renderer
+  // serves the `tmct memory` CLI).
   if (name === "memory") {
     note(trace, "goal: inspect tmct's memory store (facts/utterances/sessions)");
     if (!memoryDir) return mk("no memory store here — /memory works inside a repo session.", { miss: true });
@@ -10916,21 +11214,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
@@ -10956,6 +11296,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 +11454,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.
@@ -11214,20 +11589,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