@polycode-projects/the-mechanical-code-talker 1.11.0 → 1.11.6

package/src/chat.mjs

@@ -11,8 +11,9 @@
 // structured sidecar (.tmct/sessions/session-<uuidv7>.jsonl, sessions.mjs) and
 // a `Session` individual upserted into graph.json per turn.
 //
-// runTurn(input, …) is a PURE function so tests exercise it directly; every
-// ask.mjs import is LAZY and failure-tolerated, so a turn never crashes.
+// runTurn(input, …) is a PURE function so tests exercise it directly; the ask
+// ENGINE is imported lazily and failure-tolerated, so a turn never crashes
+// (the one static ask.mjs import, classDisplayName, is a pure formatter).
 // createSession(…) is the SESSION SINK every shell shares (runChat's readline
 // loop, src/tui/app.mjs's Ink shell).
 
@@ -26,6 +27,7 @@ import { dispatchTool, loadGraph } from "./server.mjs";
 import { loadConfig, DEFAULT_GRAPH_REL } from "./config.mjs";
 import { resolveRuntimeConfig } from "./cli-args.mjs";
 import { parseEntities, edgesOfKind, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "./codegraph.mjs";
+import { classDisplayName } from "./ask.mjs";
 import { SESSIONS_DIR_REL, appendSessionToGraph } from "./sessions.mjs";
 import { uuidv7 } from "./uuid.mjs";
 import { createTelemetry } from "./telemetry.mjs";
@@ -33,6 +35,7 @@ import * as defaultSource from "./source.mjs";
 import { loadTemplates, render as renderTemplate } from "./corpus/templates.mjs";
 import { resolveExtensions, mergedLexiconExtra } from "./extensions.mjs";
 import { rankByBiasThenTrust } from "./memory/bias.mjs";
+import { HAS_A_PREDICATE } from "./memory/core.mjs";
 import { finish, beginsWithVowelSound, grammarRules } from "./finish.mjs";
 import { splitSentences } from "./sentences.mjs";
 import {
@@ -102,6 +105,10 @@ const GOAL_BY_KIND = {
 };
 const goalNoun = (entityType) => (entityType ? `${String(entityType).toLowerCase()}(s)` : "entities");
 
+/** The goal wording for a taught subject/verb/object lookup — shared by
+ *  runAsk's fact-lane goal revision and withDeducedGoal's fact-reader field. */
+const TAUGHT_FACT_LOOKUP_GOAL = "look up a taught fact about a subject/verb/object";
+
 /** Deduce a one-line goal statement from the ask engine's parsed AST — either
  *  the plain-clause form ({shape,kind,entityType,object[,subject]}) or the
  *  compositional form ({node:...}, ask.mjs's §compositional grammar). Returns
@@ -1464,7 +1471,7 @@ function moduleOverviewText(graph, ind) {
   parts.push(testedBy.length
     ? `covered by ${testedBy.length} test module${testedBy.length === 1 ? "" : "s"}`
     : "no recorded tests");
-  const cls = (ind.class || "entity").toLowerCase();
+  const cls = classDisplayName(ind.class || "entity");
   const pointer = pickPhrase("full-breakdown", ind.id, "for the full breakdown");
   return `${ind.label} is a ${cls} — ${parts.join("; ")}. `
     + `/describe ${ind.label} ${pointer}.`;
@@ -1533,7 +1540,7 @@ const WALL_MISS_ANYWHERE_RE = /couldn't parse this as a graph question\. Try:/;
 // assert/memory path; when it can't be stored, say what CAN be remembered
 // instead of the grammar wall or a silent data loss.
 const TEACH_RE = /^(?:please\s+)?(?:i\s+(?:want|wanted)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+)?(?:remember|note|keep in mind|jot down|for the record|fyi|learn)\b(?:\s+(?:this|that|also))?[:,]?\s*(?:that\s+)?(.+?)[.?!]*$/i;
-const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+(?: [\w-]+)? (?:is|are) (?:a |an )?[\w-]+$/i;
+const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+(?: [\w-]+)? (?:is|are) (?:a |an )?[\w-]+(?: too)?$/i;
 /** "X is <comparative> than Y" — the comparative teach/ask surface. The
  *  comparative slot is closed by SHAPE (-er word, better/worse, or a
  *  more/less + adjective pair), never a hand-list of adjectives. */
@@ -1601,12 +1608,9 @@ const HAS_PROPERTY_PREDICATE = "mgx:hasProperty";
 // "some/a few Xs are Ys" shape) stay obviously in that same family rather than
 // re-typing the CURIE string at each call site.
 const SUBCLASS_PREDICATE = "rdfs:subClassOf";
-// Bug 3 (2026-07-09): the SAME "has a" predicate ConceptNet's own /r/HasA
-// facts already use (FACT_PREDICATE_PHRASES, conceptnet-map.toml) — named
-// here too so generalVerbTeach's "has"/"have" special case (below) stays
-// obviously in that same family, interoperable with corpus HasA data on the
-// read side, rather than minting a redundant mgx:has.
-const HAS_A_PREDICATE = "mgx:hasA";
+// HAS_A_PREDICATE (imported from memory/core.mjs, the canonical home) keeps
+// generalVerbTeach's "has"/"have" special case in the same family ConceptNet's
+// /r/HasA corpus facts already use, rather than minting a redundant mgx:has.
 
 // mgx:sourceType's own closed kind set (memory/core.mjs) splits "the operator
 // said it" across two tags depending which lane wrote it (ace: -> "operator",
@@ -1679,6 +1683,46 @@ const OWNS_PASSIVE_TEACH_RE = /^(.+?)\s+(?:is|are|was|were)\s+owned\s+by\s+([A-Z
 const RELATION_FACT_TEACH_RE =
   /^([\w'-]+(?:\s+[A-Z][\w'-]*)?)\s+(?:is|are|was|were)\s+the\s+([a-z][\w-]*)\s+of\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[.!?]*$/i;
 
+/** The GENITIVE surfaces of the same relational fact — "ahab is john's
+ *  father" and "john's father is ahab" both state exactly what "ahab is the
+ *  father of john" states, so both store through the identical
+ *  generalVerbPredicate mint (subject=ahab, relation=father, object=john).
+ *  Same 1-2-token name captures as RELATION_FACT_TEACH_RE; the role slot is
+ *  the same lowercase bare noun. The possessive's own token deliberately
+ *  excludes apostrophes ([\w-]+, not [\w'-]+) so the 's split is unambiguous. */
+const GENITIVE_RELATION_TEACH_RE =
+  /^([\w-]+(?:\s+[A-Z][\w-]*)?)\s+(?:is|was)\s+([\w-]+(?:\s+[A-Z][\w-]*)?)'s\s+([a-z][\w-]*)[.!?]*$/i;
+const GENITIVE_RELATION_TEACH_REV_RE =
+  /^([\w-]+(?:\s+[A-Z][\w-]*)?)'s\s+([a-z][\w-]*)\s+(?:is|was)\s+([\w-]+(?:\s+[A-Z][\w-]*)?)[.!?]*$/i;
+
+/** The VERB-INFLECTED surface of the same relational fact — "ahab fathered
+ *  john" states what "ahab is the father of john" states, so it stores
+ *  through the identical generalVerbPredicate mint. Same 1-2-token name
+ *  captures as RELATION_FACT_TEACH_RE on both sides; the verb slot requires
+ *  a literal "-ed" tail, so a present-tense "john likes mary" never matches
+ *  (that bare shape stays wrapper-required — see the nudge in runAsk). The
+ *  regex is only the SHAPE trigger: matchRelationalVerbTeach (below) adds
+ *  the determiner/closed-class/POS guards that keep "the build failed
+ *  yesterday" and "john failed spectacularly" out. */
+const RELATION_VERB_TEACH_RE =
+  /^([\w'-]+(?:\s+[A-Z][\w'-]*)?)\s+([a-z][\w-]*ed)\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[.!?]*$/i;
+
+/** Closed past-tense strip: "<base>ed" (fathered → father), the doubled-
+ *  consonant form (hopped → hop), and the -ied fold (carried → carry).
+ *  Returns null when the word doesn't carry a strippable "-ed" tail at all.
+ *  Deliberately naive (same accepted trade as singularizeSurface) — callers
+ *  prefer wink's lemma when it's available and only lean on this strip as
+ *  the shape check / fallback. */
+function pastVerbBase(verb) {
+  const v = String(verb || "").toLowerCase();
+  const m = v.match(/^([a-z][a-z-]*)ed$/);
+  if (!m || m[1].length < 2) return null;
+  const stem = m[1];
+  if (/([b-df-hj-np-tv-z])\1$/.test(stem)) return stem.slice(0, -1);
+  if (/[^aeiou]i$/.test(stem)) return `${stem.slice(0, -1)}y`;
+  return stem;
+}
+
 /** "every/a/an/the <N1> has a/an <N2> method" — the HAS-A-METHOD teach
  *  declarative: a possession-of-capability claim about a class/entity's
  *  method ("every Component has a render method", "a Widget has a render
@@ -1762,7 +1806,7 @@ const RECURSIVE_RULE_TEACH_RE =
 
 /** ACTION-RULE TEACH FRAMES — a world-mutating action taught one sentence at
  *  a time, each sentence its own Rule individual (kind action-signature /
- *  action-precond / action-effect) sharing one rule name ("<verb> <prep>",
+ *  action-precond / action-effect / action-constraint) sharing one rule name ("<verb> <prep>",
  *  e.g. "move onto"). src/domain.mjs collects the family by name
  *  (findRulesByName) and grounds it over class members at plan time; nothing
  *  in the teach lane executes an action. Predicate slot values are stored
@@ -1770,13 +1814,28 @@ const RECURSIVE_RULE_TEACH_RE =
  *  values; readers re-attach it. The class/role words are single tokens, the
  *  preposition set is PREP_SRC, the comparative slot is COMPARATIVE_SRC. */
 const ACTION_SIGNATURE_TEACH_RE = new RegExp(
-  `^you\\s+can\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+  `^you\\s+(?:can|may)\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+// The passive voicing of the same signature ("a disk can be moved onto a
+// peg"): class first, participle verb. Minted through the same actionLemma
+// authority so both voicings land on one rule name.
+const ACTION_SIGNATURE_PASSIVE_RE = new RegExp(
+  `^an?\\s+([a-z][\\w-]*)\\s+(?:can|may)\\s+be\\s+([a-z]+)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)[.!?]*$`, "i");
 const ACTION_PRECOND_NOTHING_RE = new RegExp(
   `^to\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s*,?\\s*nothing\\s+may\\s+([a-z]+)\\s+(${PREP_SRC})\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
 const ACTION_PRECOND_COMPARATIVE_RE = new RegExp(
   `^to\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s*,?\\s*the\\s+([a-z][\\w-]*)\\s+must\\s+be\\s+(${COMPARATIVE_SRC})\\s+than\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
 const ACTION_EFFECT_TEACH_RE = new RegExp(
-  `^([a-z]+ing)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s+makes\\s+the\\s+([a-z][\\w-]*)\\s+([a-z]+)\\s+(${PREP_SRC})\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+  `^([a-z]+ing)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s+makes\\s+(?:it|the\\s+([a-z][\\w-]*))\\s+([a-z]+)\\s+(${PREP_SRC})\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+/** "to ferry a passenger onto a bank, the wolf may not be with the goat
+ *  without the farmer" — the co-location CONSTRAINT sentence (kind
+ *  action-constraint): after a move, <left> and <right> may not share a
+ *  position unless <guard> is there too. All three trailing words name a
+ *  class whose sole member src/domain.mjs binds at plan time. Disjoint from
+ *  the two precondition frames above by anchor phrase alone ("may not be
+ *  with … without", never "nothing may" or "must be … than") — PREP_SRC has
+ *  no "without", so the preposition captures can't collide either. */
+const ACTION_CONSTRAINT_TEACH_RE = new RegExp(
+  `^to\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s*,?\\s*the\\s+([a-z][\\w-]*)\\s+may\\s+not\\s+be\\s+with\\s+the\\s+([a-z][\\w-]*)\\s+without\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
 /** "a disk renders as a block" — the render-template binding, an ordinary
  *  Fact on the curated mgx:rendersAs predicate (camelCase, so the
  *  general-verb preposition fold can never suffix it). */
@@ -1836,6 +1895,12 @@ async function bareTaxonomyTeach(line, { memoryDir, sessionId }) {
 // not a Rule — goals accumulate on the session's planState slot.
 const GOAL_TEACH_RE = new RegExp(
   `^the\\s+goal\\s+is\\s+that\\s+(?:(every|each|all)\\s+)?([\\w-]+)\\s+([a-z]+s)\\s+(${PREP_SRC})\\s+([\\w-]+)[.!?]*$`, "i");
+// The infinitive-complement voicings of the same goal ("the goal is for every
+// disk to rest on peg-b", "i want every disk to rest on peg-b") — same
+// captures, verb already in base form. The confirmation restates the that-form
+// so the normalization is disclosed.
+const GOAL_TEACH_INFINITIVE_RE = new RegExp(
+  `^(?:the\\s+goal\\s+is\\s+for|i\\s+want)\\s+(?:(every|each|all)\\s+)?([\\w-]+)\\s+to\\s+([a-z]+)\\s+(${PREP_SRC})\\s+([\\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 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;
@@ -2476,6 +2541,93 @@ async function subjectIsNounOrPropn(word) {
   }
 }
 
+/** Recognize "<Name> <verb>ed <Name>" ("ahab fathered john") as a relational
+ *  teach, or null. RELATION_VERB_TEACH_RE gives the shape; this adds the
+ *  guards that keep non-relational pasts out:
+ *    - neither side may lead with a determiner ("the build failed yesterday")
+ *      or a closed-class word;
+ *    - the verb may not be a closed-class or structural word;
+ *    - both name heads must POS-tag NOUN/PROPN (the same wink adapter
+ *      subjectIsNounOrPropn uses — "john failed spectacularly" tags its tail
+ *      ADV and declines). No wink → no signal, never a store;
+ *    - wink's lemma must actually DIFFER from the typed verb — a base-form
+ *      "-eed" word ("breed", "exceed") is not an inflected past at all, and
+ *      lemma-vs-strip disagreement resolves toward the lemma so the minted
+ *      predicate matches what the wrapped "remember that ahab fathered john"
+ *      path (generalVerbTeach) would mint.
+ *  Returns { subject, verb, base, object }; `base` is what the caller mints
+ *  through generalVerbPredicate. */
+async function matchRelationalVerbTeach(text) {
+  const line = String(text || "").trim();
+  const m = line.match(RELATION_VERB_TEACH_RE);
+  if (!m) return null;
+  const [, subjectRaw, verbRaw, objectRaw] = m;
+  const verb = verbRaw.toLowerCase();
+  const strip = pastVerbBase(verb);
+  if (!strip) return null;
+  if (GENERAL_VERB_NOT_A_VERB_RE.test(verb) || STRUCT_WORDS.has(verb)) return null;
+  const subjWords = subjectRaw.split(/\s+/);
+  const objWords = objectRaw.split(/\s+/);
+  for (const head of [subjWords[0], objWords[0]]) {
+    if (GENERAL_VERB_DETERMINER_RE.test(head) || GENERAL_VERB_NOT_A_VERB_RE.test(head)) return null;
+  }
+  try {
+    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const adapter = nlpAdapter();
+    if (!adapter) return null;
+    const tags = adapter.posTags([...subjWords, verbRaw, ...objWords]);
+    const nameTag = (t) => t === "NOUN" || t === "PROPN";
+    if (!nameTag(tags[0]) || !nameTag(tags[subjWords.length + 1])) return null;
+  } catch {
+    return null;
+  }
+  let base = strip;
+  try {
+    const { proseLemma } = await import("./prose-nlp.mjs");
+    const lemma = proseLemma();
+    if (lemma) {
+      const l = lemma(verb);
+      if (l === verb) return null; // wink says this is already a base form, not a past
+      if (l) base = l;
+    }
+  } catch { /* no lemmatizer — the closed strip stands */ }
+  return { subject: subjectRaw.trim(), verb, base, object: objectRaw.trim() };
+}
+
+/** The bare "<name> <verb>s <name>" nudge text ("john likes mary"), or null.
+ *  The bare form stays wrapper-required — the imperative-lookalike problem in
+ *  subjectIsNounOrPropn's docblock is only half the story at exactly three
+ *  words, where the conversational catch-all otherwise answers with the
+ *  orientation card. This recognizes the shape ONLY well enough to point at
+ *  the wrapped form that does store; it never stores anything itself. Closed
+ *  the same way matchRelationalVerbTeach is: no determiner/closed-class
+ *  heads, no structural/discourse verb, subject POS-tags NOUN/PROPN, object
+ *  tags NOUN/PROPN/ADJ (wink tags bare lowercase names like "mary" ADJ;
+ *  a genuine adverb tail — "dog barks loudly" — still declines). */
+async function bareTeachWrapperNudgeText(text) {
+  const line = String(text || "").trim().replace(/[.!?]+\s*$/, "");
+  const m = line.match(/^([\w'-]+)\s+([a-z][\w-]*s)\s+([\w'-]+)$/i);
+  if (!m) return null;
+  const [, subj, verbRaw, obj] = m;
+  const verb = verbRaw.toLowerCase();
+  if (/^(?:is|was|does)$/.test(verb)) return null;
+  if (GENERAL_VERB_NOT_A_VERB_RE.test(verb) || STRUCT_WORDS.has(verb) || HABITUAL_VERB_EXCLUDE.has(verb)) return null;
+  for (const head of [subj, obj]) {
+    if (GENERAL_VERB_DETERMINER_RE.test(head) || GENERAL_VERB_NOT_A_VERB_RE.test(head)) return null;
+  }
+  try {
+    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const adapter = nlpAdapter();
+    if (!adapter) return null;
+    const tags = adapter.posTags([subj, verbRaw, obj]);
+    if (tags[0] !== "NOUN" && tags[0] !== "PROPN") return null;
+    if (tags[2] !== "NOUN" && tags[2] !== "PROPN" && tags[2] !== "ADJ") return null;
+  } catch {
+    return null;
+  }
+  return `I don't store a bare "${line}" on its own — to store that, say: "remember that ${line}".`;
+}
+
 // ---- General verb-to-predicate DIRECT-QUESTION retrieval: "does margo eat
 // ribs" / "what does margo eat" against a fact taught via generalVerbTeach.
 // Wired into factReadBack, gated on an already-true `miss` so a real graph
@@ -2518,8 +2670,85 @@ function assertCandidates(payload) {
   const p = String(payload).trim();
   const out = [p];
   if (!/^(?:every|each|all|a|an)\b/i.test(p)) out.push(`every ${p}`);
+  // "dogs are animals" — the bare-plural surface of the membership shape the
+  // grammar already owns as "every dog is an animal". Purely additive and
+  // inherently safe: the rewritten candidate still has to parse against the
+  // closed lexicon, so a false singular ("redis" → "redi") never stores. A
+  // trailing "too" is tolerated — it adds discourse flavor, not content.
+  const plural = p.match(/^(?:all\s+|every\s+|each\s+)?([\w-]+)\s+are\s+([\w-]+?)(?:\s+too)?[.!?]*$/i);
+  if (plural) {
+    const subject = singularizeSurface(plural[1].toLowerCase());
+    const object = singularizeSurface(plural[2].toLowerCase());
+    if (subject !== plural[1].toLowerCase() || object !== plural[2].toLowerCase()) {
+      const articleRule = grammarRules().find((r) => r.kind === "article");
+      const article = articleRule && beginsWithVowelSound(object, articleRule) ? "an" : "a";
+      out.push(`every ${subject} is ${article} ${object}`);
+    }
+  }
+  // HABITUAL → CAPABILITY: "dogs bark" / "a dog barks" are the habitual
+  // surfaces of the capability teach the lane already owns as "a dog can
+  // bark" (the same reading the seed corpus itself uses: dog /r/CapableOf
+  // bark). Same safety story as the plural rewrite above — the candidate
+  // still has to ground through the teach path (this rewrite, or teachLane's
+  // grounded-subject direct write), so a subject grounded nowhere
+  // ("penguins swim" with no prior grounding) stays an honest decline.
+  const habitual = matchBareHabitualTeach(p);
+  if (habitual) {
+    const articleRule = grammarRules().find((r) => r.kind === "article");
+    const article = articleRule && beginsWithVowelSound(habitual.subject, articleRule) ? "an" : "a";
+    out.push(`${article} ${habitual.subject} can ${habitual.verb}`);
+  }
   return [...new Set(out)];
 }
+
+/** The two bare HABITUAL teach surfaces, recognized as one shape:
+ *  "dogs bark" (plural subject + base verb) and "a dog barks" (articled
+ *  singular + 3sg verb), both meaning the capability fact "a dog can
+ *  bark". Returns {subject, verb} folded to the singular/base forms, or
+ *  null. Deliberately closed: structural verbs (imports/calls/tests …)
+ *  are excluded so a truncated code query never reads as a capability
+ *  claim, and the plural surface's verb must be a BASE form (no
+ *  plural-looking "s" tail — "dogs animals" is not a habitual sentence;
+ *  "pass"/"miss"-style "ss" verbs stay eligible). */
+/** Words that sit in the habitual shapes' verb slot without being verbs —
+ *  politeness/discourse tails ("jokes please", "dogs too") that must stay
+ *  with the conversational lane. */
+const HABITUAL_VERB_EXCLUDE = new Set([
+  "please", "thanks", "kindly", "anyway", "though", "indeed", "maybe",
+  "perhaps", "still", "too", "also", "instead", "now", "then", "here", "there",
+]);
+function matchBareHabitualTeach(text) {
+  const t = String(text || "").trim();
+  const plural = t.match(/^(?:all\s+|every\s+)?([\w-]+s)\s+([a-z][\w-]*)[.!?]*$/i);
+  if (plural && !STRUCT_WORDS.has(plural[2].toLowerCase()) && !HABITUAL_VERB_EXCLUDE.has(plural[2].toLowerCase()) && !/[^s]s$/i.test(plural[2])) {
+    const subject = singularizeSurface(plural[1].toLowerCase());
+    if (subject !== plural[1].toLowerCase()) return { subject, verb: plural[2].toLowerCase() };
+  }
+  const singular = t.match(/^an?\s+([\w-]+)\s+([a-z][\w-]*s)[.!?]*$/i);
+  if (singular && !STRUCT_WORDS.has(singular[2].toLowerCase()) && !HABITUAL_VERB_EXCLUDE.has(singular[2].toLowerCase())) {
+    const verb = singularizeSurface(singular[2].toLowerCase());
+    if (verb !== singular[2].toLowerCase()) return { subject: singular[1].toLowerCase(), verb };
+  }
+  return null;
+}
+/** The EXPLICIT capability surface — "a wren can sing" / "penguins can swim":
+ *  the same {subject, verb} reading matchBareHabitualTeach folds its two
+ *  habitual surfaces onto, for the sentence that says "can" outright. The ACE
+ *  grammar already owns this shape for closed-lexicon words; recognizing it
+ *  here lets the teach lane's grounded-subject direct write catch a subject
+ *  grounded only by a prior taught fact. Same closed verb-slot exclusions as
+ *  the habitual shapes; a question lead ("can a wren sing") never reaches
+ *  this — every call site is already QUESTION_LEAD-gated. */
+function matchBareCanTeach(text) {
+  const m = String(text || "").trim().match(/^(?:an?\s+|every\s+|all\s+)?([\w-]+)\s+can\s+([a-z][\w-]*)[.!?]*$/i);
+  if (!m) return null;
+  const subject = m[1].toLowerCase();
+  const verb = m[2].toLowerCase();
+  if (STRUCT_WORDS.has(verb) || HABITUAL_VERB_EXCLUDE.has(verb) || GENERAL_VERB_NOT_A_VERB_RE.test(verb)) return null;
+  if (GENERAL_VERB_DETERMINER_RE.test(subject) || GENERAL_VERB_NOT_A_VERB_RE.test(subject)) return null;
+  return { subject, verb };
+}
+
 /** The "every X is a Y" rewrite of a declarative, for the "did you mean …"
  *  hint. Real a/an agreement (never a hardcoded "a", which is ungrammatical
  *  for a vowel-initial Y — "every monkey is a animal") reuses finish.mjs's
@@ -2536,6 +2765,21 @@ function teachSuggestion(payload) {
   return `every ${subject} is ${article} ${object}`;
 }
 
+/** 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
+ *  phrasing that actually works, never guess" discipline for the capability
+ *  shape, which has no is/are payload for that hint to match. The suggested
+ *  grounding sentence uses the same GENERIC_ANCHOR_NOUNS root that hint
+ *  suggests, so it round-trips through the ordinary teach cascade as-is. */
+function habitualGroundingHintText(line, habitual) {
+  const articleRule = grammarRules().find((r) => r.kind === "article");
+  const article = articleRule && beginsWithVowelSound(habitual.subject, articleRule) ? "an" : "a";
+  return `I don't know "${habitual.subject}" yet, so I can't store "${line}" as a capability fact. `
+    + `Ground it first — say "every ${habitual.subject} is a thing" — then say "${line}" again `
+    + `and I'll remember that ${article} ${habitual.subject} can ${habitual.verb}.`;
+}
+
 /** PRONOUN-SUBJECT GUARD: "remember you are a womble" and the literal "every
  *  you is a womble" would otherwise reach teachSuggestion/
  *  unknownSubjectFallback treating "you" like an ordinary unknown common
@@ -2640,6 +2884,70 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const raw = stripKindOf(stripYour(stripPossessiveNamedInstance(rawInput)));
   const wrapped = stripKindOf(stripYour(stripPossessiveNamedInstance(wrappedInput)));
 
+  // CONJUNCTION PRE-PASS — "ahab is male and is the father of john": two
+  // facts about ONE subject stated in one sentence. Split at the top-level
+  // " and <is|are|has|have|can>" seam, re-attach the shared subject to the
+  // second half, and run each half through this same lane in order — two
+  // ordinary teach payloads, no new storage shape. A second clause that
+  // names its OWN subject ("… and the weather is nice") is not a shared-
+  // subject conjunction: the first half still stores, and the reply names
+  // the clause it left alone — never a silent partial store either way.
+  const conjSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
+  if (memoryDir && !QUESTION_LEAD_RE.test(conjSrc) && /\s+and\s+/i.test(conjSrc)
+    && !(await hasMidSentenceInterrogative(conjSrc))) {
+    const rewrap = (half) => (wrapped != null ? `remember that ${half}` : half);
+    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache });
+    const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
+    const shared = conjSrc.match(/^(.+?)\s+and\s+((?:is|are|has|have|can)\b.+)$/i);
+    const sharedSubject = shared ? shared[1].match(/^(.+?)\s+(?:is|are|has|have|can)\b/i)?.[1]?.trim() : null;
+    if (shared && sharedSubject) {
+      const firstHalf = shared[1].trim();
+      const secondHalf = `${sharedSubject} ${shared[2].trim()}`;
+      const first = await recurse(firstHalf);
+      const second = await recurse(secondHalf);
+      const firstOk = !!first && !first.miss;
+      const secondOk = !!second && !second.miss;
+      if (firstOk && secondOk) {
+        return {
+          text: `noted — remembered both: ${stripNoted(first.text)}; and ${stripNoted(second.text)}`,
+          via: "assert", miss: false,
+        };
+      }
+      if (firstOk || secondOk) {
+        const ok = firstOk ? first : second;
+        const badHalf = firstOk ? secondHalf : firstHalf;
+        const bad = firstOk ? second : first;
+        return {
+          text: `noted — remembered: ${stripNoted(ok.text)}. The other half ("${badHalf}") I couldn't store`
+            + `${bad ? ` — ${stripNoted(bad.text)}` : ", it isn't a fact shape I recognize."}`,
+          via: "assert", miss: false,
+        };
+      }
+      if (first || second) {
+        return {
+          text: `I couldn't store either half of that. "${firstHalf}": ${first ? stripNoted(first.text) : "not a fact shape I recognize."} `
+            + `"${secondHalf}": ${second ? stripNoted(second.text) : "not a fact shape I recognize."}`,
+          via: "teach-miss", miss: true,
+        };
+      }
+      // neither half even recognized — fall through to the ordinary cascade
+    } else if (!shared) {
+      const ownSubject = conjSrc.match(
+        /^(.+?\s+(?:is|are|has|have|can)\s+.+?)\s+and\s+((?:(?:the|a|an|every|each|all|some|my|your|their|his|her|its)\s+)?[\w'-]+(?:\s+[\w'-]+)?\s+(?:is|are|has|have|can)\b.+)$/i,
+      );
+      if (ownSubject) {
+        const first = await recurse(ownSubject[1].trim());
+        if (first && !first.miss) {
+          return {
+            text: `${first.text} — the second part ("${ownSubject[2].trim()}") names its own subject, so I didn't store it; teach it as its own sentence if you meant it.`,
+            via: "assert", miss: false,
+          };
+        }
+        // the first half didn't store — fall through to the ordinary cascade
+      }
+    }
+  }
+
   // PRONOUN-SUBJECT GUARD — tried against BOTH surfaces (bare and remember-
   // wrapped; trailing punctuation stripped the same way the OWNS/SOME_A_FEW
   // lanes below do) before anything else in this function, so a pronoun
@@ -2776,6 +3084,40 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     if (stored) return stored;
   }
 
+  // GENITIVE RELATIONAL FACT — "ahab is john's father" / "john's father is
+  // ahab": the two possessive surfaces of the relational fact just above,
+  // stored through the SAME predicate mint so every read-back ("who is the
+  // father of john") answers all three phrasings identically. Same gating.
+  const genitive = ownSrc.match(GENITIVE_RELATION_TEACH_RE);
+  if (genitive && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: genitive[1], predicate: await generalVerbPredicate(genitive[3]), object: genitive[2],
+    });
+    if (stored) return stored;
+  }
+  const genitiveRev = ownSrc.match(GENITIVE_RELATION_TEACH_REV_RE);
+  if (genitiveRev && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: genitiveRev[3], predicate: await generalVerbPredicate(genitiveRev[2]), object: genitiveRev[1],
+    });
+    if (stored) return stored;
+  }
+
+  // VERB-INFLECTED RELATIONAL FACT — "ahab fathered john": the past-tense
+  // verb surface of the relational fact above, minted through the SAME
+  // generalVerbPredicate so "who is the father of john" reads every phrasing
+  // back identically. matchRelationalVerbTeach carries the closed guards
+  // (name-shaped sides, POS-confirmed nouns, a lemma-confirmed inflected
+  // past) that keep "the build failed" an honest non-match.
+  const relVerb = memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion
+    ? await matchRelationalVerbTeach(ownSrc) : null;
+  if (relVerb) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: relVerb.subject, predicate: await generalVerbPredicate(relVerb.base), object: relVerb.object,
+    });
+    if (stored) return stored;
+  }
+
   // HAS-A-METHOD TEACH — "every/a/an/the <N1> has a/an <N2> method": a
   // possession-of-capability claim, stored as an ordinary Fact via the SAME
   // HAS_A_PREDICATE generalVerbTeach's own
@@ -2875,7 +3217,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
   }
 
-  // ACTION-RULE TEACH — the four action frames plus the render binding (see
+  // ACTION-RULE TEACH — the five action frames plus the render binding (see
   // the ACTION_*_TEACH_RE docblock). Each sentence stores its own Rule
   // individual under a shared "<verb> <prep>" name. A role word that names
   // neither the taught subject class nor the literal "target" is an honest
@@ -2911,6 +3253,32 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
   }
 
+  const actionSigPassive = ownSrc.match(ACTION_SIGNATURE_PASSIVE_RE);
+  if (actionSigPassive && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const participle = actionSigPassive[2].toLowerCase();
+    const verb = await actionLemma(participle);
+    // Same honesty rule as the effect frame's gerund: an unreduced participle
+    // would mint a name no other rule sentence can share.
+    if (verb !== participle && participle.startsWith(verb.slice(0, Math.min(3, verb.length)))) {
+      try {
+        const prep = actionSigPassive[3].toLowerCase();
+        const { appendRule, RULE_KIND_ACTION_SIGNATURE } = await import("./memory/core.mjs");
+        const { id } = await appendRule(memoryDir, {
+          name: `${verb} ${prep}`,
+          kind: RULE_KIND_ACTION_SIGNATURE,
+          slots: { subjectClass: actionSigPassive[1], targetClass: actionSigPassive[4] },
+          provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+        });
+        if (id) {
+          return {
+            text: `noted — remembered: you can ${verb} a ${actionSigPassive[1].toLowerCase()} ${prep} a ${actionSigPassive[4].toLowerCase()}`,
+            via: "assert", miss: false,
+          };
+        }
+      } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+    }
+  }
+
   const precondNothing = ownSrc.match(ACTION_PRECOND_NOTHING_RE);
   if (precondNothing && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const role = actionRoleFor(precondNothing[7], precondNothing[2]);
@@ -2984,6 +3352,31 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
   }
 
+  const actionConstraint = ownSrc.match(ACTION_CONSTRAINT_TEACH_RE);
+  if (actionConstraint && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    try {
+      const verb = await actionLemma(actionConstraint[1]);
+      const prep = actionConstraint[3].toLowerCase();
+      const { appendRule, RULE_KIND_ACTION_CONSTRAINT } = await import("./memory/core.mjs");
+      const { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_CONSTRAINT,
+        slots: {
+          left: actionConstraint[5].toLowerCase(),
+          right: actionConstraint[6].toLowerCase(),
+          guard: actionConstraint[7].toLowerCase(),
+        },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: to ${verb} ${prep}, the ${actionConstraint[5].toLowerCase()} may not be with the ${actionConstraint[6].toLowerCase()} without the ${actionConstraint[7].toLowerCase()}`,
+          via: "assert", miss: false,
+        };
+      }
+    } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+  }
+
   const actionEffect = ownSrc.match(ACTION_EFFECT_TEACH_RE);
   if (actionEffect && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const gerund = actionEffect[1].toLowerCase();
@@ -2997,11 +3390,22 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
         via: "teach-miss", miss: true,
       };
     }
-    const subjectRole = actionRoleFor(actionEffect[5], actionEffect[2]);
+    // "makes IT rest on the target" leaves the role capture empty — the
+    // pronoun can only mean the thing being moved, so it reads as the
+    // subject-class word.
+    const subjectWord = actionEffect[5] ?? actionEffect[2];
+    const namedSubjectRole = actionRoleFor(subjectWord, actionEffect[2]);
+    // A subject word naming neither the subject class nor "target" is
+    // CLASS-BOUND: a companion that travels with every move ("ferrying a
+    // passenger onto a bank makes the FARMER stand on the target"). Stored as
+    // the bare class word; compileDomain (src/domain.mjs) requires the class
+    // to have exactly one member at plan time, so a typo'd word fails loudly
+    // there rather than silently minting a role here.
+    const subjectRole = namedSubjectRole ?? subjectWord.toLowerCase();
     const objectRole = actionRoleFor(actionEffect[8], actionEffect[2]);
-    if (!subjectRole || !objectRole || subjectRole === objectRole) {
+    if (!objectRole || subjectRole === objectRole) {
       return {
-        text: `I can't place "${!subjectRole ? actionEffect[5] : actionEffect[8]}" in that rule — the effect must relate the ${actionEffect[2]} and the target, once each (e.g. "makes the ${actionEffect[2]} rest on the target").`,
+        text: `I can't place "${actionEffect[8]}" in that rule — the effect must end at the ${actionEffect[2]} or the target (e.g. "makes the ${actionEffect[2]} rest on the target").`,
         via: "teach-miss", miss: true,
       };
     }
@@ -3021,7 +3425,8 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       });
       if (id) {
         return {
-          text: `noted — remembered: ${gerund} a ${actionEffect[2].toLowerCase()} ${prep} a ${actionEffect[4].toLowerCase()} makes the ${actionEffect[5].toLowerCase()} ${actionEffect[6].toLowerCase()} ${actionEffect[7].toLowerCase()} the ${actionEffect[8].toLowerCase()}`,
+          text: `noted — remembered: ${gerund} a ${actionEffect[2].toLowerCase()} ${prep} a ${actionEffect[4].toLowerCase()} makes the ${subjectWord.toLowerCase()} ${actionEffect[6].toLowerCase()} ${actionEffect[7].toLowerCase()} the ${actionEffect[8].toLowerCase()}`
+            + (namedSubjectRole ? "" : ` (the ${subjectRole} rides along on every ${verb} move — its class must have exactly one member when we plan)`),
           via: "assert", miss: false,
         };
       }
@@ -3125,6 +3530,24 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // the structural grammar's own typo-tolerant retry to answer for real.
     const subjectWord = 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
+      // spelling the grounding fact and every query-side variant fold use —
+      // instead of letting the general-verb mint below reify the plural
+      // verbatim (a fact "can a wren hum" could never read back). An
+      // ungrounded singular falls through unchanged.
+      const canShape = matchBareCanTeach(raw);
+      const canSingular = canShape ? singularizeSurface(canShape.subject) : null;
+      if (canShape && canSingular !== canShape.subject) {
+        let canLex = lexicon;
+        if (!canLex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); canLex = loadLexicon(); }
+        if (await isGroundedTerm(canSingular, canLex, memoryDir, cache)) {
+          const stored = await teachFact(memoryDir, sessionId, {
+            subject: canSingular, predicate: await generalVerbPredicate("can"), object: canShape.verb,
+          });
+          if (stored) return stored;
+        }
+      }
       const gv = await generalVerbTeach(raw);
       if (gv) {
         const stored = await teachFact(memoryDir, sessionId, gv);
@@ -3135,7 +3558,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
 
   let payload = null;
   if (wrapped && /\b(?:is|are)\b/i.test(wrapped)) payload = wrapped;
-  else if ((BARE_DECLARATIVE_RE.test(raw) || COMPARATIVE_TEACH_RE.test(raw)) && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
+  else if ((BARE_DECLARATIVE_RE.test(raw) || COMPARATIVE_TEACH_RE.test(raw) || matchBareHabitualTeach(raw) || matchBareCanTeach(raw)) && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
   if (!payload) {
     // "remember margo eats ribs", re-escaping here through a combination
     // that mechanism's own deliberate subject-shape restriction doesn't
@@ -3174,6 +3597,31 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       const stored = await assertTurn(cand, { memoryDir, sessionId, focus: null, lexicon, cache });
       if (stored) return { text: stored.answer, via: "assert", miss: false };
     }
+    // CAPABILITY over a GROUNDED subject — "penguins swim" (habitual) or "a
+    // penguin can swim" (explicit) after "every penguin is a thing". The ACE
+    // candidates above only parse closed-lexicon words, so a subject grounded
+    // by a PRIOR taught fact (or an anchor root) still fell through to the
+    // generic decline. Same closed shapes, same capability predicate the ACE
+    // path itself stores. The subject's naive singular is tried too, so the
+    // explicit plural surface ("penguins can swim") reaches the same stored
+    // spelling the grounding fact used.
+    const habitualTeach = matchBareHabitualTeach(payload) || matchBareCanTeach(payload);
+    if (habitualTeach) {
+      let habLex = lexicon;
+      if (!habLex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); habLex = loadLexicon(); }
+      // The singular is preferred so an explicit plural surface ("penguins
+      // can swim") stores under the same spelling the grounding fact (and
+      // every query-side variant fold) uses; a proper noun that only looks
+      // plural ("redis") falls back to its own spelling.
+      for (const subj of new Set([singularizeSurface(habitualTeach.subject), habitualTeach.subject])) {
+        if (await isGroundedTerm(subj, habLex, memoryDir, cache)) {
+          const stored = await teachFact(memoryDir, sessionId, {
+            subject: subj, predicate: await generalVerbPredicate("can"), object: habitualTeach.verb,
+          });
+          if (stored) return stored;
+        }
+      }
+    }
     // The real ACE grammar just declined (unknown words / not the membership
     // shape) — try the narrow unknown-SUBJECT direct-write fallback before
     // falling to the honest-miss cascade. Covers BOTH the bare and the
@@ -4347,6 +4795,19 @@ const RELATION_FACT_YESNO_RE =
 const RELATION_WHO_ASK_RE =
   /^(?:who|what)\s+(?:is|are)\s+(?:the|an?)\s+([a-z][\w-]*)\s+of\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[?.!\s]*$/i;
 
+/** "who is john's father" — the GENITIVE surface of RELATION_WHO_ASK_RE.
+ *  A pure rewrite onto that shape (the matchWhyIsa approach): returns a
+ *  match-shaped array with the same slot order RELATION_WHO_ASK_RE produces
+ *  ([1]=relation, [2]=object), so the dispatch block below serves both
+ *  surfaces with no second lane. The possessive token excludes apostrophes
+ *  ([\w-]+) so the 's split is unambiguous. */
+const GENITIVE_WHO_ASK_RE =
+  /^(?:who|what)\s+(?:is|are|was|were)\s+([\w-]+(?:\s+[A-Z][\w-]*)?)'s\s+([a-z][\w-]*)[?.!\s]*$/i;
+function matchGenitiveWhoAsk(q) {
+  const g = String(q).match(GENITIVE_WHO_ASK_RE);
+  return g ? [g[0], g[2], g[1]] : null;
+}
+
 /** "list the descendants of ahab" — the REACHABILITY-SET list query: a
  *  genuine KIND-CHANGE from RELATION_FACT_YESNO_RE just above — every entity
  *  reachable from the named start entity through a taught `recursive` Rule,
@@ -4443,6 +4904,66 @@ const WHAT_HAS_RE = /^what\s+has\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
 // — actively misleading for a pure vocabulary query.
 const WHAT_USED_FOR_RE = /^what\s+(?:(?:can\s+be|is)\s+used\s+for|is\s+for)\s+(.+?)[?.!\s]*$/i;
 
+/** "where is disk-1[ now]" — the bare where question about a TAUGHT individual.
+ *  The term capture is lazy so an optional trailing "now" stays out of it; any
+ *  other tail ("where is X defined") lands in the capture, finds no locative
+ *  fact subject named that, and falls through to the code-graph where lane
+ *  unchanged. Consumed by factAnswer's (a-pre4) reader. */
+const WHERE_IS_FACT_RE = /^where(?:'s|\s+is|\s+are)\s+(.+?)(?:\s+now)?\s*[?.!]*$/i;
+/** The closed locative tail of a folded prepositional-verb predicate
+ *  (mgx:rest-on, mgx:stand-on, mgx:sit-in, …) — what makes a taught fact a
+ *  LOCATION answer rather than any arbitrary relation. */
+const LOCATIVE_FACT_PREDICATE_RE = /^mgx:[a-z]+-(?:on|in|at|inside|under|below|above|near|beside|behind|by)$/;
+
+// CAN_ASK_RE's remaining paraphrase-ladder siblings, all over the same
+// mgx:capableOf facts:
+//  - DO_VERB_ASK_RE: the do-support yes/no ("do birds fly", "does a dog
+//    bark") plus its quantified form ("do all birds fly" — answered
+//    generically, never universally: the facts are generic, and claiming
+//    "all" from them would overclaim). Requires a SINGLE trailing verb
+//    word, so it stays disjoint from DOES_HAVE_ASK_RE (" have " in the
+//    middle) and the derived FORWARD_YESNO_MARKERS readers (verb phrase
+//    + object after it).
+//  - WHAT_CAN_VERB_RE: the reverse-by-verb open list ("what can fly") —
+//    the capability mirror of WHAT_USED_FOR_RE just above. "be …" tails
+//    are excluded (WHAT_USED_FOR_RE's own "what can be used for" lead);
+//    "… do" tails belong to WHAT_CAN_DO_RE and are guarded at the call
+//    site.
+//  - WHICH_KIND_CAN_RE: the kind-restricted form ("which animals can
+//    fly") — reverse-by-verb filtered to subjects the memory can tie to
+//    the named kind via a direct isa-family fact.
+const DO_VERB_ASK_RE = /^(?:do|does)\s+(all\s+|every\s+)?(?:an?\s+|the\s+)?([\w'-]+(?:\s+[\w'-]+)*?)\s+([a-z-]+)[?.!\s]*$/i;
+const WHAT_CAN_VERB_RE = /^what\s+can\s+(?!be\s)(.+?)[?.!\s]*$/i;
+const WHICH_KIND_CAN_RE = /^(?:which|what)\s+([\w'-]+(?:\s+[\w'-]+)*?)\s+can\s+(.+?)[?.!\s]*$/i;
+
+/** SUPERLATIVE over TAUGHT COMPARATIVES — "which disk is smallest" / "what is
+ *  the smallest disk" answered from the mgx:<comparative>-than facts the
+ *  comparative teach frame mints ("disk-1 is smaller than disk-2"). The
+ *  superlative slot is closed by SHAPE, the same discipline as
+ *  COMPARATIVE_SRC: an -est word, best/worst, or a most/least + adjective
+ *  pair — never a hand-list of adjectives. Entirely fact-side: the
+ *  code-graph superlative lane (parseSuperlative's entity-kind metrics) is a
+ *  different question over different data and is untouched — this reader
+ *  only ever answers when taught comparative pairs for the named kind exist. */
+const SUPERLATIVE_WORD_SRC = "(?:most|least)\\s+[a-z][\\w-]*|[a-z][\\w-]*est|best|worst";
+const WHICH_KIND_SUPERLATIVE_RE = new RegExp(`^which\\s+([\\w'-]+)\\s+(?:is|are)\\s+(?:the\\s+)?(${SUPERLATIVE_WORD_SRC})[?.!\\s]*$`, "i");
+const WHAT_IS_SUPERLATIVE_KIND_RE = new RegExp(`^what(?:'s|s|\\s+is)\\s+the\\s+(${SUPERLATIVE_WORD_SRC})\\s+([\\w'-]+)[?.!\\s]*$`, "i");
+
+/** Map a superlative surface onto the comparative base its taught facts were
+ *  minted under: <adj>est → <adj>er (the shared stem keeps a doubled
+ *  consonant intact: biggest → bigger), best → better, worst → worse,
+ *  "most X" → "more X", "least X" → "less X". Returns null for a word that
+ *  only LOOKS superlative ("honest" maps to no comparative anyone teaches —
+ *  the resulting predicate simply never has facts). */
+function comparativeOfSuperlative(superlative) {
+  const s = String(superlative || "").toLowerCase().trim().replace(/\s+/g, " ");
+  if (s === "best") return "better";
+  if (s === "worst") return "worse";
+  const graded = s.match(/^(most|least)\s+([a-z][\w-]*)$/);
+  if (graded) return `${graded[1] === "most" ? "more" : "less"} ${graded[2]}`;
+  return /[a-z]est$/.test(s) && s.length > 4 ? `${s.slice(0, -3)}er` : null;
+}
+
 // The SAME gap as mgx:usedFor above is systemic — "what causes fire", "what is
 // made of wood" would otherwise fall through to the same misleading
 // code-graph miss. DERIVES a reverse-by-object regex for every
@@ -4542,8 +5063,41 @@ function uniqueFacts(rows) {
  *  (via factRows/memoryFacts below), and loadMemory's own Backend-B branch
  *  returns the handle's `payload` directly with ZERO fs calls — so a caller
  *  that hands this a handle already carrying the embedded page's full graph
- *  gets a pure, disk-free traversal, no bundle-time module shimming needed. */
+ *  gets a pure, disk-free traversal, no bundle-time module shimming needed.
+ *  Every return additionally carries the additive `goal` field when one is
+ *  deducible (withDeducedGoal, below) — the ledger page's chat dock renders
+ *  it as its own "Goal (inferred)" line; every other consumer reads named
+ *  fields and is unaffected. */
 export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}, cache = null) {
+  return withDeducedGoal(await factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle, cache), envelope, query);
+}
+
+/** Attach the additive `goal` field to a fact reader's return: the same
+ *  table-driven deduction runAsk applies (deduceGoalFromParsed over the parsed
+ *  AST, plus the general-verb revision), extended to the bare-question shapes
+ *  the readers recognize with no envelope at all — the ledger page's chat dock
+ *  calls them with `envelope: null`, so there is no AST to deduce from.
+ *  Existing phrasing only, never free text; a goal-less shape passes through
+ *  without the field, so the dock (like chat) renders no line for it. */
+function withDeducedGoal(res, envelope, query) {
+  if (!res || res.goal !== undefined) return res;
+  const q = String(query || "").trim();
+  let goal = deduceGoalFromParsed(envelope?.parsed);
+  if (!goal && res.generalVerbQuery) goal = TAUGHT_FACT_LOOKUP_GOAL;
+  if (!goal) {
+    const yesNo = q.match(RELATION_FACT_YESNO_RE);
+    const whoAsk = yesNo ? null : (q.match(RELATION_WHO_ASK_RE) || matchGenitiveWhoAsk(q));
+    const role = yesNo ? yesNo[2] : whoAsk ? whoAsk[1] : null;
+    if (role && !ISA_IDIOM_ROLE_WORDS.has(role.toLowerCase())) goal = TAUGHT_FACT_LOOKUP_GOAL;
+  }
+  if (!goal) {
+    const whatIs = q.match(BARE_WHATIS_RE);
+    if (whatIs) goal = deduceGoalFromParsed({ shape: "meta", object: whatIs[1] });
+  }
+  return goal ? { ...res, goal } : res;
+}
+
+async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle = {}, cache = null) {
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const q = String(query).trim();
@@ -4594,6 +5148,98 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
     return { text: shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
   }
 
+  // (a-pre3) SUPERLATIVE over TAUGHT COMPARATIVES — "which disk is smallest" /
+  // "what is the smallest disk" resolved from mgx:<comparative>-than facts.
+  // Checked BEFORE (a) for the same reason as (a-pre)/(a-pre2): the "what is
+  // the …" surface would otherwise be swallowed as one literal meta term.
+  // Answers ONLY when the taught pairs for the named kind form a single
+  // unambiguous total chain; a partial order (two heads nothing compares) or
+  // a contradiction loop is an honest can't-order decline that names the gap.
+  // No taught pairs at all → falls through untouched, so the code-graph
+  // superlative lane and the ordinary miss messaging keep their turns.
+  const whichSup = q.match(WHICH_KIND_SUPERLATIVE_RE);
+  const whatSup = whichSup ? null : q.match(WHAT_IS_SUPERLATIVE_KIND_RE);
+  const supKindRaw = whichSup ? whichSup[1] : whatSup?.[2];
+  const supWord = whichSup ? whichSup[2] : whatSup?.[1];
+  const supCompBase = supKindRaw && supWord ? comparativeOfSuperlative(supWord) : null;
+  if (supCompBase) {
+    const supPredicate = `mgx:${supCompBase.replace(/\s+/g, "-")}-than`;
+    const rows = await factRows(memoryDir, cache);
+    const kindVariants = factTermVariants(normFactTerm, supKindRaw);
+    const kindSingular = [...kindVariants].sort((a, b) => a.length - b.length)[0];
+    const memberOfKind = (node) => kindVariants.has(node)
+      || node.startsWith(`${kindSingular}-`) || node.startsWith(`${kindSingular} `)
+      || rows.some((g) => ISA_PREDICATES.has(g.predicate) && g.subject === node && kindVariants.has(g.object));
+    const pairs = uniqueFacts(rows.filter((f) => f.predicate === supPredicate && isOperatorTaught(f)))
+      .filter((f) => f.subject !== f.object && memberOfKind(f.subject) && memberOfKind(f.object));
+    if (pairs.length) {
+      const nodes = new Set();
+      const inDeg = new Map();
+      for (const f of pairs) {
+        nodes.add(f.subject); nodes.add(f.object);
+        inDeg.set(f.object, (inDeg.get(f.object) || 0) + 1);
+        if (!inDeg.has(f.subject)) inDeg.set(f.subject, inDeg.get(f.subject) || 0);
+      }
+      // A unique topological order IS the single unambiguous total chain:
+      // exactly one zero-in-degree node must exist at every step, and each
+      // step's winner is then directly compared to the next (a unique order
+      // forces the consecutive edge). Two candidates at any step = a pair
+      // nothing compares; no candidate = the taught facts loop.
+      const remaining = new Map(inDeg);
+      const order = [];
+      let declined = null;
+      while (remaining.size) {
+        const sources = [...remaining.keys()].filter((n) => remaining.get(n) === 0);
+        if (sources.length !== 1) {
+          declined = sources.length === 0
+            ? {
+              text: `I can't order the ${kindSingular}s — the "${supCompBase} than" facts I have loop back on themselves, so no ${supWord} exists. /memory to inspect them.`,
+              replace: true, miss: true,
+            }
+            : {
+              text: `I can't pick the ${supWord} ${kindSingular} from what I know — nothing compares ${sources[0]} and ${sources[1]}. Teach me, e.g. "${sources[0]} is ${supCompBase} than ${sources[1]}".`,
+              replace: true, miss: true,
+            };
+          break;
+        }
+        const head = sources[0];
+        order.push(head);
+        remaining.delete(head);
+        for (const f of pairs) {
+          if (f.subject === head && remaining.has(f.object)) remaining.set(f.object, remaining.get(f.object) - 1);
+        }
+      }
+      if (declined) return declined;
+      const steps = order.slice(0, -1).map((n, i) => pairs.find((f) => f.subject === n && f.object === order[i + 1]));
+      if (steps.every(Boolean)) {
+        const cite = steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${g.provenance})` : ""}`).join("; ");
+        return { text: `${order[0]} — ${cite}; so ${order[0]} is the ${supWord} ${kindSingular}`, replace: true };
+      }
+    }
+  }
+
+  // (a-pre4) "where is disk-1" over TAUGHT LOCATIVE FACTS — the where shape
+  // belongs to the code graph (shape=where, "where is X defined"), so a taught
+  // individual with a location fact ("disk-1 rests on peg-a") otherwise dies on
+  // the "no module matching" miss. Miss-gated AND hit-gated: consulted only
+  // after the code lane already missed, and takes over only when a locative
+  // fact row for that exact subject exists — a real module answer, and every
+  // no-fact miss, is untouched.
+  const whereQ = miss ? q.match(WHERE_IS_FACT_RE) : null;
+  if (whereQ) {
+    const variants = factTermVariants(normFactTerm, whereQ[1]);
+    const hits = (await factRows(memoryDir, cache))
+      .filter((f) => LOCATIVE_FACT_PREDICATE_RE.test(f.predicate) && variants.has(f.subject));
+    if (hits.length) {
+      const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
+      const lines = ranked.map(renderFactLine);
+      const shown = lines.slice(0, FACT_ANSWER_CAP);
+      const rest = lines.slice(FACT_ANSWER_CAP);
+      const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+      return { text: shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
+    }
+  }
+
   // (a) meta-shaped questions ("what is a module", "what does cache mean") — the
   // parsed object term, matched against fact SUBJECTS; consulted for hits (append
   // alongside the schema-docs answer) and misses (facts answer alone) alike.
@@ -4622,6 +5268,17 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
     // tail, verbatim.
     if (m) metaTerm = stripTrailingScopeFiller(m[1]);
   }
+  // An ambiguous parse tie ({ambiguousParse}) reaches this lane with
+  // envelope.parsed nulled and miss=false, so NEITHER branch above arms —
+  // but when one tied reading is META and memory holds facts for its term
+  // ("what is a test drive": meta "test drive" vs tests "drive"), those
+  // facts belong under the disambiguation. Without this, the meta branch's
+  // graph-only "isn't a term in this graph's own vocabulary" line is the
+  // last word on a term the user has explicitly taught.
+  if (!metaTerm && envelope?.ambiguous && Array.isArray(envelope.candidateParses)) {
+    const metaCand = envelope.candidateParses.find((c) => c?.shape === "meta" && c.object);
+    if (metaCand) metaTerm = stripTrailingScopeFiller(String(metaCand.object));
+  }
   if (metaTerm) {
     // "what is a tree used for" parses (grammar.mjs T5) to the
     // WHOLE tail "tree used for" as one literal term — split off a trailing
@@ -4754,8 +5411,11 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
     const knownCan = facts.filter((f) => f.predicate === "mgx:capableOf" && subj.has(f.subject));
     if (knownCan.length) {
       const shown = knownCan.slice(0, 3).map(renderFactLine).join("; ");
+      // The teach hint names the subject as the GRAPH stores it (singular),
+      // not as the user typed it — 'teach me: "a birds can swim"' is a
+      // garbled hint that can't round-trip.
       return {
-        text: `I can't confirm that — nothing I remember says ${can[1]} can ${can[2]}. I do know: ${shown}. If it's true, teach me: "a ${can[1]} can ${can[2]}".`,
+        text: `I can't confirm that — nothing I remember says ${can[1]} can ${can[2]}. I do know: ${shown}. If it's true, teach me: "a ${knownCan[0].subject} can ${can[2]}".`,
         replace: true,
         miss: true,
       };
@@ -4779,6 +5439,42 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
     return null;
   }
 
+  // (b2c) "do birds fly" — the do-support surface of (b2), same capableOf
+  // lookup. The quantified form ("do all birds fly") is answered generically
+  // and says so: the stored facts are generic, and a bare "yes" would claim
+  // universality the memory can't support. NEVER returns null on a non-match
+  // (falls through instead): the shape is looser than (b2)'s, so a do-lead
+  // question some later reader owns must keep its turn. The can't-confirm
+  // branch is additionally miss-gated for the same reason.
+  const doAsk = q.match(DO_VERB_ASK_RE);
+  if (doAsk) {
+    const facts = await memoryFacts(memoryDir);
+    const universal = !!doAsk[1];
+    const subj = factTermVariants(normFactTerm, doAsk[2]);
+    const obj = factTermVariants(normFactTerm, doAsk[3]);
+    const hit = facts.find(
+      (f) => f.predicate === "mgx:capableOf" && subj.has(f.subject) && obj.has(f.object),
+    );
+    if (hit && universal) {
+      return {
+        text: `I can't speak for all ${doAsk[2]} — what I remember is generic, not universal. I do know: ${renderFactLine(hit)}.`,
+        replace: true,
+      };
+    }
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    if (miss) {
+      const knownCan = facts.filter((f) => f.predicate === "mgx:capableOf" && subj.has(f.subject));
+      if (knownCan.length) {
+        const shown = knownCan.slice(0, 3).map(renderFactLine).join("; ");
+        return {
+          text: `I can't confirm that — nothing I remember says ${doAsk[2]} can ${doAsk[3]}. I do know: ${shown}. If it's true, teach me: "a ${knownCan[0].subject} can ${doAsk[3]}".`,
+          replace: true,
+          miss: true,
+        };
+      }
+    }
+  }
+
   // (b3) "what can a dog do" — every remembered mgx:capableOf fact for the
   // subject, open-list. Reuses the meta-lane's subject-hits/rank/render/
   // paginate recipe (lane (a) above) verbatim, with the predicate hardcoded.
@@ -4795,6 +5491,75 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
     return { text: shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
   }
 
+  // (b3b) "which animals can fly" — reverse-by-verb over mgx:capableOf,
+  // restricted to subjects an isa-family chain ties to the named kind within
+  // a bounded hop budget (findIsaChain, the same rooted proof search the
+  // is-a ladder's live chase uses; maxHops matches its enlarged-tree budget),
+  // so "every sparrow is a bird" + "bird is a kind of animal" surfaces
+  // sparrow under "which animals…". A chain longer than one hop is cited on
+  // the answer line. When capable subjects exist but NONE provably belongs
+  // to the kind, the answer says so and still lists them — honest about the
+  // missing link instead of a silent empty. Only takes over on real
+  // capability hits; otherwise falls through (never returns null: "which X
+  // can Y" phrasings this reader doesn't own must keep their turn).
+  const whichCan = q.match(WHICH_KIND_CAN_RE);
+  if (whichCan) {
+    const kindVariants = factTermVariants(normFactTerm, whichCan[1]);
+    const verbVariants = factTermVariants(normFactTerm, whichCan[2]);
+    const facts = await factRows(memoryDir, cache);
+    const capable = uniqueFacts(facts.filter((f) => f.predicate === "mgx:capableOf" && verbVariants.has(f.object)));
+    if (capable.length) {
+      const { findIsaChain, SUBCLASS_PREDICATE: SC_PRED, TYPE_PREDICATE: TYPE_PRED } = await import("./syllogise.mjs");
+      const subClassRows = facts.filter((f) => f.predicate === SC_PRED);
+      const typeRows = facts.filter((f) => f.predicate === TYPE_PRED);
+      const subClassEdges = subClassRows.map((f) => [f.subject, f.object]);
+      const typeEdges = typeRows.map((f) => [f.subject, f.object]);
+      const rowForStep = (step) => (step.predicate === SC_PRED ? subClassRows : typeRows)
+        .find((g) => g.subject === step.subject && g.object === step.object);
+      const chainBySubject = new Map();
+      const inKind = capable.filter((f) => {
+        if (kindVariants.has(f.subject)) return true;
+        if (!chainBySubject.has(f.subject)) {
+          chainBySubject.set(f.subject, findIsaChain(f.subject, kindVariants, typeEdges, subClassEdges, { maxHops: 3 }));
+        }
+        return !!chainBySubject.get(f.subject);
+      });
+      const ranked = rankByBiasThenTrust(inKind.length ? inKind : capable, biasByBundle);
+      const lines = ranked.map((f) => {
+        const chain = inKind.length ? chainBySubject.get(f.subject) : null;
+        if (!chain || chain.length < 2) return renderFactLine(f);
+        const steps = chain.map(rowForStep);
+        if (!steps.every(Boolean)) return renderFactLine(f);
+        const cite = steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${g.provenance})` : ""}`).join("; ");
+        return `${renderFactLine(f)} — via: ${cite}`;
+      });
+      const shown = lines.slice(0, FACT_ANSWER_CAP);
+      const rest = lines.slice(FACT_ANSWER_CAP);
+      const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+      const preamble = inKind.length ? "" : `nothing I remember ties these to "${whichCan[1]}", but:\n`;
+      return { text: preamble + shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
+    }
+  }
+
+  // (b3c) "what can fly" — the unrestricted reverse-by-verb sibling of (b3b):
+  // every capableOf fact whose OBJECT matches. The "… do" tail is (b3)'s
+  // shape, guarded out so a zero-hit "what can a cat do" never gets misread
+  // here as a hunt for the capability "a cat do". Same fall-through
+  // discipline as (b3b).
+  const canVerb = q.match(WHAT_CAN_VERB_RE);
+  if (canVerb && canVerb[1].trim().split(/\s+/).at(-1)?.toLowerCase() !== "do") {
+    const verbVariants = factTermVariants(normFactTerm, canVerb[1]);
+    const hits = (await factRows(memoryDir, cache)).filter((f) => f.predicate === "mgx:capableOf" && verbVariants.has(f.object));
+    if (hits.length) {
+      const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
+      const lines = ranked.map(renderFactLine);
+      const shown = lines.slice(0, FACT_ANSWER_CAP);
+      const rest = lines.slice(FACT_ANSWER_CAP);
+      const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+      return { text: shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
+    }
+  }
+
   // (b4) "what has a wheel" — the REVERSE-by-OBJECT mirror of every other
   // reader in this cascade: filters factRows on mgx:hasA where the OBJECT
   // (not subject) matches, so every subject sharing that object surfaces
@@ -5280,8 +6045,14 @@ function inheritsChain(graph, startId) {
  *    (c) REVERSE membership — "what is a Y" reports Y's members (object-side), and
  *        "what kind of thing is an X" reports X's own type (subject-side first).
  *  Miss-only and run AFTER factAnswer returns null, so it never shadows the
- *  subject-side answer or a schema hit. Returns { text, replace:true } or null. */
+ *  subject-side answer or a schema hit. Returns { text, replace:true } or null,
+ *  plus factAnswer's same additive `goal` field when one is deducible
+ *  (withDeducedGoal). */
 export async function factReadBack(memoryDir, query, envelope, miss, graph = null, focusLabel = null, biasByBundle = {}, cache = null) {
+  return withDeducedGoal(await factReadBackReaders(memoryDir, query, envelope, miss, graph, focusLabel, biasByBundle, cache), envelope, query);
+}
+
+async function factReadBackReaders(memoryDir, query, envelope, miss, graph = null, focusLabel = null, biasByBundle = {}, cache = null) {
   if (!miss) return null;
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
@@ -5531,7 +6302,7 @@ export async function factReadBack(memoryDir, query, envelope, miss, graph = nul
   // sharing it with (a0): RELATION_WHO_ASK_RE and RELATION_FACT_YESNO_RE never
   // both match the same query (one starts with "who", the other with
   // "is/are/was/were"), so the two blocks never run in the same call.
-  const whoAsk = qHedge.match(RELATION_WHO_ASK_RE);
+  const whoAsk = qHedge.match(RELATION_WHO_ASK_RE) || matchGenitiveWhoAsk(qHedge);
   if (whoAsk) {
     const relationName = whoAsk[1].trim().toLowerCase();
     const rawObject = whoAsk[2].trim();
@@ -7145,7 +7916,7 @@ async function compareAnswer(query, { graph, config, source }) {
   const cmp = renderCompare(g, indA, indB);
   if (!cmp) {
     return {
-      text: `I can only compare two entities of the SAME kind right now — "${indA.label}" is a ${indA.class || "Entity"} and "${indB.label}" is a ${indB.class || "Entity"}.`,
+      text: `I can only compare two entities of the SAME kind right now — "${indA.label}" is a ${classDisplayName(indA.class || "Entity")} and "${indB.label}" is a ${classDisplayName(indB.class || "Entity")}.`,
       ents: [indA, indB],
     };
   }
@@ -7353,7 +8124,8 @@ function actionLabel(name, subject, target) {
 async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", }) {
   const q = String(query).trim();
 
-  const goalMatch = q.match(GOAL_TEACH_RE);
+  const thatGoal = q.match(GOAL_TEACH_RE);
+  const goalMatch = thatGoal || q.match(GOAL_TEACH_INFINITIVE_RE);
   if (goalMatch) {
     const { normFactTerm } = await import("./memory/core.mjs");
     const verb = await verbLemma(goalMatch[3]);
@@ -7369,7 +8141,11 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
       predicate: `${verb}-${goalMatch[4].toLowerCase()}`,
       object: normFactTerm(goalMatch[5]),
     };
-    const tail = q.replace(/^the\s+goal\s+is\s+that\s+/i, "").replace(/[.!?]+$/, "");
+    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;
     planHolder.state = {
       goals: [...(prev?.goals ?? []), spec],
@@ -7614,8 +8390,19 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     answer = content;
     if (envJson) { try { envelope = JSON.parse(envJson); } catch { envelope = null; } }
   } catch (e) {
-    answer = String(e?.message || e);
-    note(trace, `intermediate: the ask engine threw — ${answer}`);
+    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))
+      ? "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."
+      : thrown;
+    note(trace, `intermediate: the ask engine threw — ${thrown}`);
   }
   // NARRATE: the direct parse/traversal receipt, straight off ask()'s own
   // envelope, with zero extra instrumentation of ask.mjs: `parsed` is the
@@ -7781,6 +8568,11 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         deduced = planLane.deduced;
         note(trace, `goal: ${deduced} (revised — the plan lane answered)`);
       }
+      // Same rule as the teach lane below: a canonical whose verb only
+      // matched through the fuzzy repair tier ("rests" read as "tests")
+      // misdescribes a plan-lane turn, so it's dropped; an exact parse keeps
+      // its receipt.
+      if (envelope?.parsed?.fuzzyVerb) canonical = null;
       note(trace, `lane: (1p) PLAN — ${planLane.note}`);
     }
   }
@@ -7815,6 +8607,67 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // STACCATO_PRONOUN_RE-no-focus branch ALWAYS returns a tailored nudge for
   // this exact shape, never null.
   const isStaccatoPronounNoFocus = STACCATO_PRONOUN_RE.test(String(query).trim()) && !focus?.label;
+  // A bare plural-membership declarative ("dogs are animals" — exactly 3
+  // words) needs the SAME deferral: it's an unambiguous TEACH shape (lane 4),
+  // but isConversational's ≤3-word catch-all claims it first. Gated on BOTH
+  // sides singularizing to KNOWN lexicon nouns, so real chatter ("these are
+  // yours") stays with the orientation card.
+  let isPluralMembershipTeach = false;
+  // A bare habitual naming a subject grounded NOWHERE ("penguins swim", no
+  // prior grounding) gets an honest grounding hint instead of the
+  // orientation card — computed here, rendered inside the conversational
+  // branch below so a turn something real answers never shows it.
+  let habitualGroundingHint = null;
+  // "ahab fathered john" — a bare verb-inflected relational teach (exactly
+  // the shape teachLane's own frame stores) needs the SAME deferral, or the
+  // ≤3-word catch-all claims it first. "john likes mary" (present tense)
+  // stays wrapper-required BY DESIGN — it gets a nudge at the wrapped form,
+  // never a store.
+  let isBareRelationalVerbTeach = false;
+  let bareTeachWrapperNudge = null;
+  {
+    const bareLine = String(query).trim();
+    const pm = bareLine.match(/^([\w-]+)\s+are\s+([\w-]+)[.!?]*$/i);
+    const habitual = pm || QUESTION_LEAD_RE.test(bareLine)
+      ? null : (matchBareHabitualTeach(bareLine) || matchBareCanTeach(bareLine));
+    if (pm || habitual) {
+      try {
+        const { loadLexicon, lookupNoun } = await import("./grammar/lexicon.mjs");
+        const lex = loadLexicon();
+        if (pm) {
+          const s = singularizeSurface(pm[1].toLowerCase());
+          const o = singularizeSurface(pm[2].toLowerCase());
+          isPluralMembershipTeach = s !== pm[1].toLowerCase() && !!lookupNoun(lex, s) && !!lookupNoun(lex, o);
+        } else {
+          // The bare habitual/capability siblings ("dogs bark", "a dog
+          // barks", "wrens can sing") — same deferral, same known-subject
+          // gate, so real chatter never diverts. The naive singular is tried
+          // too: matchBareCanTeach keeps the surface plural ("wrens"), but
+          // the grounding fact was stored under the singular.
+          const subjects = [...new Set([habitual.subject, singularizeSurface(habitual.subject)])];
+          isPluralMembershipTeach = subjects.some((s) => !!lookupNoun(lex, s));
+          if (!isPluralMembershipTeach && memoryDir) {
+            let grounded = false;
+            for (const s of subjects) grounded = grounded || (await isGroundedByFact(s, memoryDir, cache));
+            if (grounded) {
+              // Grounded by a prior taught fact — defer the same way; the
+              // teach lane's grounded-subject direct write stores it.
+              isPluralMembershipTeach = true;
+            } else {
+              habitualGroundingHint = habitualGroundingHintText(
+                bareLine.replace(/[.!?]+\s*$/, ""),
+                { subject: subjects[subjects.length - 1], verb: habitual.verb },
+              );
+            }
+          }
+        }
+      } catch { /* lexicon unavailable — leave false, the ordinary path decides */ }
+    } else if (memoryDir && !QUESTION_LEAD_RE.test(bareLine)
+      && bareLine.replace(/[.!?]+\s*$/, "").split(/\s+/).filter(Boolean).length <= 3) {
+      if (await matchRelationalVerbTeach(bareLine)) isBareRelationalVerbTeach = true;
+      else bareTeachWrapperNudge = await bareTeachWrapperNudgeText(bareLine);
+    }
+  }
   // A vague relation touch ("what about cochange", "tell me about cochange",
   // the staccato chain continuation "and cochange?") whose relation word has NO
   // bare single-word VERB_TO_KIND form of its own needs the SAME deferral as
@@ -7842,7 +8695,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       } catch { /* leave false — the ordinary path decides */ }
     }
   }
-  const conversationalCandidateBaseGate = !handled && miss && !envelope?.parsed && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus;
+  const conversationalCandidateBaseGate = !handled && miss && !envelope?.parsed && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus && !isPluralMembershipTeach && !isBareRelationalVerbTeach;
   // A turn whose pronoun was bound to a vocabulary antecedent is PROVABLY a
   // fact question ("can it bark" → "can dog bark") — never conversational,
   // however short. Without this, the substituted 3-worder still trips
@@ -7878,12 +8731,23 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // gets a turn.
   const reversePredicateShape = WHAT_USED_FOR_RE.test(gateQuery)
     || REVERSE_PREDICATE_MARKERS.some(({ re }) => re.test(gateQuery));
+  // The capability family's SHORTEST members ("can birds fly", "do birds
+  // fly", "what can bark" — all three words) trip isConversational()'s
+  // word-count catch-all before factAnswer's capability readers ever run;
+  // same divert-only-on-a-real-hit treatment as the reverse predicates
+  // above.
+  const capabilityAskShape = CAN_ASK_RE.test(gateQuery) || WHAT_CAN_DO_RE.test(gateQuery)
+    || DO_VERB_ASK_RE.test(gateQuery) || WHICH_KIND_CAN_RE.test(gateQuery) || WHAT_CAN_VERB_RE.test(gateQuery);
   let bareMetaHit = null;
-  if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape || reversePredicateShape)) {
+  if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape || reversePredicateShape || capabilityAskShape)) {
     if (memoryDir) {
       bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle, cache))
         ?? (await factReadBack(memoryDir, gateQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
-      if (bareMetaHit?.miss) bareMetaHit = null; // an honest-miss return never diverts the gate
+      // An honest-miss return never diverts the gate — EXCEPT the capability
+      // family's can't-confirm, which names the subject's real capabilities
+      // and a round-trip teach hint: strictly more useful than the
+      // orientation card this gate would otherwise fall to.
+      if (bareMetaHit?.miss && !capabilityAskShape) bareMetaHit = null;
       // A bare "what is X" with NO taught fact but a KNOWN curated corpus term
       // ("what is cache", no article) needs the same "only diverts on a REAL
       // hit" treatment — curatedDefinitionAnswer otherwise only ever runs once
@@ -7920,10 +8784,30 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   }
   if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
-    via = "fact"; recordMiss = false; handled = true;
+    // Same discipline as lane (3): a fact-lane return flagged `miss` is an
+    // honest miss in better words — the turn record keeps miss=true and via
+    // stays untouched.
+    if (!bareMetaHit.miss) { via = "fact"; recordMiss = false; }
+    handled = true;
     if (bareMetaHit.pending) factPending = bareMetaHit.pending;
     note(trace, "lane: (2b) BARE META FACT — \"what is X\" (no article) / \"is X <adjective>\" resolved to a remembered fact before the conversational catch-all could claim it");
     note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
+  } else if (isConversationalCandidate && habitualGroundingHint) {
+    // A bare habitual teach ("penguins swim") naming a subject grounded
+    // nowhere: an honest, actionable grounding hint beats the orientation
+    // card — the card answers a question the user never asked.
+    answer = habitualGroundingHint;
+    via = "teach-miss"; handled = true;
+    note(trace, "lane: (2) HABITUAL GROUNDING HINT — a bare habitual teach named an ungrounded subject; pointed at the grounding phrase instead of the orientation card");
+    note(trace, "goal: teach/remember a new capability fact (subject not yet grounded)");
+  } else if (isConversationalCandidate && bareTeachWrapperNudge) {
+    // A bare name-verb-name declarative ("john likes mary"): stays
+    // wrapper-required, so nothing stores — but pointing at the wrapped form
+    // that DOES store beats the orientation card for the same reason.
+    answer = bareTeachWrapperNudge;
+    via = "teach-miss"; handled = true;
+    note(trace, "lane: (2) BARE TEACH NUDGE — a bare name-verb-name declarative stays wrapper-required; suggested the remember-that form");
+    note(trace, "goal: teach/remember a new fact (wrapper required for the bare form)");
   } else if (isConversationalCandidate) {
     // A conversational miss (a greeting, "what can you do", a very short non-code
     // line) gets the friendly orientation (module-aware: empty → --repo/tmct init).
@@ -7950,8 +8834,22 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // reified fact is stronger evidence than a transcript echo. Subject-side facts
     // first (factAnswer), then the reverse-membership read-back (factReadBack) so an
     // asserted "every X is a Y" answers "what is a Y" too.
+    // Raw query first (the long-standing contract), then ONE retry with the
+    // normalized form — gated to the no-envelope bootstrap ONLY: on the FIRST
+    // turn of a graph-less session the ask engine throws before its own
+    // normalize pass runs, so a politeness-wrapped vocabulary question
+    // ("could you tell me what a dog is") reaches this lane still wearing the
+    // wrapper no reader matches. From turn 2 on (envelope present) the
+    // pipeline unwraps it upstream, and an unrestricted retry would let
+    // normalization-mangled text reach readers whose guards were written for
+    // the raw surface (the pronoun-subject identity family).
+    const normalizedForFacts = envelope ? null : normalizeQuery(String(query));
     const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle, cache))
-      ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
+      ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache))
+      ?? (normalizedForFacts && normalizedForFacts !== String(query).trim()
+        ? (await factAnswer(memoryDir, normalizedForFacts, envelope, miss, biasByBundle, cache))
+          ?? (await factReadBack(memoryDir, normalizedForFacts, envelope, miss, graph, newFocus?.label, biasByBundle, cache))
+        : null);
     if (fact) {
       answer = fact.replace ? fact.text : `${answer}\n${fact.text}`;
       // A fact-lane return flagged `miss` is an HONEST MISS in better words
@@ -7971,7 +8869,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // question ("does margo eat ribs") never parses as a structural graph
       // query at all.
       if (fact.generalVerbQuery) {
-        deduced = "look up a taught fact about a subject/verb/object";
+        deduced = TAUGHT_FACT_LOOKUP_GOAL;
         note(trace, `goal: ${deduced} (revised — a general-verb direct-question fact lookup answered this turn)`);
       }
     } else if (miss) {
@@ -8092,6 +8990,13 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // line instead.
       deduced = "teach/remember a new fact";
       note(trace, `goal: ${deduced} (revised — the teach lane recognized this shape where the raw structural parse never should have)`);
+      // A canonical whose verb only matched through the fuzzy edit-distance
+      // tier ("disk-1 rests on peg-a." read as an ask about "tests") restates
+      // a repair, not the sentence — under a teach confirmation that's
+      // misleading, so it's dropped. An exact-vocabulary parse ("father is a
+      // kind of parent" as inherits) keeps its canonical: it genuinely
+      // restates the relation the teach stored.
+      if (envelope?.parsed?.fuzzyVerb) canonical = null;
     }
   }
   // (4b) #4 AUTHOR lane — "who is <Name>", "what did <Name> touch",
@@ -8431,23 +9336,29 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     if (!argText) return mk("/plan needs a request, e.g. `/plan of the modules impacted by X, which are untested`.", { miss: true });
     if (!graph) return mk("no graph loaded — /plan needs a code graph to plan over.", { miss: true });
     const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("./router/drive.mjs");
-    const planCtx = await buildCapabilityPlanCtx({ config, source, tel, graph });
-    const result = await runCapabilityPlan(argText, declaredCapabilityNames(), planCtx);
-    if (result.refused) {
-      const why = Array.isArray(result.why) ? result.why.join("; ") : result.why;
-      const c1Why = result.c1Why && (Array.isArray(result.c1Why) ? result.c1Why.join("; ") : result.c1Why);
-      note(trace, `result: no plan found — ${why}`);
-      return mk(`no plan found — ${why}${c1Why ? ` (the direct router also declined: ${c1Why})` : ""}`, { miss: true });
-    }
-    note(trace, `result: ${result.driver} — ${result.calls.length} step(s)`);
-    const lines = [`driver: ${result.driver}`, "", "steps:"];
-    result.calls.forEach((c, i) => lines.push(`  ${i + 1}. ${c.name} ${JSON.stringify(c.input || {})}`));
-    if (result.composed !== undefined && result.composed !== null) {
-      lines.push("", `composed answer (${result.composed.length}): ${result.composed.length ? result.composed.join(", ") : "(empty set)"}`);
-    } else if (result.observed) {
-      lines.push("", result.observed);
+    const planCtx = await buildCapabilityPlanCtx({ config, source, tel, graph, memoryDir });
+    try {
+      const result = await runCapabilityPlan(argText, declaredCapabilityNames(), planCtx);
+      if (result.refused) {
+        const why = Array.isArray(result.why) ? result.why.join("; ") : result.why;
+        const c1Why = result.c1Why && (Array.isArray(result.c1Why) ? result.c1Why.join("; ") : result.c1Why);
+        note(trace, `result: no plan found — ${why}`);
+        return mk(`no plan found — ${why}${c1Why ? ` (the direct router also declined: ${c1Why})` : ""}`, { miss: true });
+      }
+      note(trace, `result: ${result.driver} — ${result.calls.length} step(s)`);
+      const lines = [`driver: ${result.driver}`, "", "steps:"];
+      result.calls.forEach((c, i) => lines.push(`  ${i + 1}. ${c.name} ${JSON.stringify(c.input || {})}`));
+      if (result.composed !== undefined && result.composed !== null) {
+        lines.push("", `composed answer (${result.composed.length}): ${result.composed.length ? result.composed.join(", ") : "(empty set)"}`);
+      } else if (result.observed) {
+        lines.push("", result.observed);
+      }
+      return mk(lines.join("\n"));
+    } finally {
+      // The taught registrations are per-ctx; unregister so the next /plan
+      // turn re-reads the store instead of meeting a stale name collision.
+      for (const dispose of planCtx.disposers || []) dispose();
     }
-    return mk(lines.join("\n"));
   }
 
   const spec = COMMANDS[name];
@@ -8858,7 +9769,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     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) || LEGAL_MOVES_RE.test(lastSentence)) {
+      if (PLAN_SOLVE_RE.test(lastSentence) || GOAL_TEACH_RE.test(lastSentence) || GOAL_TEACH_INFINITIVE_RE.test(lastSentence) || LEGAL_MOVES_RE.test(lastSentence)) {
         let f = focus; let l = last; let ps = planHolder.state;
         const receipts = [];
         let finalRec = null;