@polycode-projects/the-mechanical-code-talker 1.10.14 → 1.11.5

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,7 +35,9 @@ 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 {
   VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
   stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS,
@@ -101,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
@@ -1463,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}.`;
@@ -1532,13 +1540,17 @@ 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. */
 const COMPARATIVE_SRC = "(?:[a-z]+er|better|worse|(?:more|less)\\s+[a-z]+)";
 const COMPARATIVE_TEACH_RE = new RegExp(`^(?:the\\s+|an?\\s+)?([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+(?:is|are)\\s+(${COMPARATIVE_SRC})\\s+than\\s+(.+)$`, "i");
 const COMPARATIVE_ASK_RE = new RegExp(`^(?:is|are)\\s+(.+?)\\s+(${COMPARATIVE_SRC})\\s+than\\s+(.+?)[?.!\\s]*$`, "i");
+/** The one closed preposition set shared by every frame that folds a
+ *  preposition into a minted predicate (the general-verb teach/query lanes
+ *  and the action-rule frames) — a single source so the set never forks. */
+const PREP_SRC = "on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside";
 /** Interrogative / auxiliary leads that make an "X is a Y"-shaped line a QUESTION
  *  ("what is a cache", "is a module a component"), never a teach declarative. */
 const QUESTION_LEAD_RE = /^(?:what|who|which|where|when|why|how|is|are|do|does|did|can|could|should|would|will|has|have)\b/i;
@@ -1596,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",
@@ -1674,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
@@ -1755,6 +1804,107 @@ const FILTER_RULE_TEACH_RE =
 const RECURSIVE_RULE_TEACH_RE =
   /^an?\s+([a-z][\w-]*)\s+(?:is|are)\s+an?\s+([a-z][\w-]*),?\s+or\s+an?\s+([a-z][\w-]*)\s+of\s+an?\s+\1[.!?]*$/i;
 
+/** 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 / 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
+ *  BARE ("rest-on") because normFactTerm strips a mgx: prefix from slot
+ *  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|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+(?: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). */
+const RENDERS_AS_TEACH_RE = /^an?\s+([a-z][\w-]*)\s+renders\s+as\s+an?\s+([a-z][\w-]*)[.!?]*$/i;
+// Bare-copula instance membership: the subject MUST contain a hyphen
+// (disk-1, peg-a) — see bareTaxonomyTeach's reasoning.
+const INSTANCE_TYPE_TEACH_RE = /^([a-z][\w]*(?:-[\w]+)+)\s+is\s+an?\s+([a-z][\w-]+)[.!?]*$/i;
+// Bare article-led kind-of taxonomy: "a disk is a kind of game piece".
+const BARE_KINDOF_TEACH_RE = /^an?\s+([a-z][\w-]+)\s+is\s+a\s+kind\s+of\s+(?:an?\s+)?([a-z][\w-]+(?:\s+[a-z][\w-]+)?)([.!?]*)$/i;
+
+/** Verb → lemma via the prose adapter, degrading to the word itself. */
+async function verbLemma(word) {
+  const w = String(word || "").toLowerCase();
+  try {
+    const { proseLemma } = await import("./prose-nlp.mjs");
+    const lemma = proseLemma();
+    return lemma ? lemma(w) : w;
+  } catch { return w; }
+}
+
+/** Pre-ask declarative taxonomy teaches. Checked BEFORE the ask engine: "a
+ *  disk is a kind of game piece." otherwise parses as an inherits QUESTION
+ *  and dies on term resolution, even though an article-led declarative with
+ *  no question lead is a statement. Two closed shapes only:
+ *  - instance membership with a HYPHENATED subject ("disk-1 is a disk") —
+ *    hyphenated/numbered coinages are unambiguous individual names, so this
+ *    stays clear of the plain-word bare "X is a Y" declines the tier-5
+ *    fabrication fixes deliberately preserve;
+ *  - article-led "is a kind of" taxonomy with a multi-word object — the
+ *    infix is unambiguous taxonomy-teach intent and the ACE path can't parse
+ *    the two-word object; single-word objects stay with the ACE path. */
+async function bareTaxonomyTeach(line, { memoryDir, sessionId }) {
+  if (!memoryDir || QUESTION_LEAD_RE.test(line)) return null;
+  const inst = line.match(INSTANCE_TYPE_TEACH_RE);
+  if (inst) {
+    return teachFact(memoryDir, sessionId, {
+      subject: inst[1], predicate: "rdfs:subClassOf", object: inst[2],
+    });
+  }
+  const kindOf = line.match(BARE_KINDOF_TEACH_RE);
+  if (kindOf) {
+    // Defer to the ACE assert path exactly where it succeeds: a single-word
+    // object with no trailing punctuation ("a father is a kind of parent" —
+    // the pinned README transcript's shape, with its richer receipt). The ACE
+    // path dies on multi-word objects and on trailing punctuation (the
+    // period rides into term resolution), so those store here.
+    const singleWordObject = !/\s/.test(kindOf[2]);
+    const noTrailingPunct = kindOf[3] === "";
+    if (singleWordObject && noTrailingPunct) return null;
+    return teachFact(memoryDir, sessionId, {
+      subject: kindOf[1], predicate: "rdfs:subClassOf", object: kindOf[2],
+    });
+  }
+  return null;
+}
+// The plan lane's closed recognizer set. The goal frame is plan-lane state,
+// 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;
+
 /** "<X> is <adjective>" — the property teach payload (wrapper-REQUIRED): a lazy
  *  subject and a single bare complement word. Never matches the "is a <noun>"
  *  membership shape (that stays the ACE grammar's), so "remember that cache is
@@ -2391,13 +2541,100 @@ 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
 // query is never shadowed. Reuses generalVerbTeach's own exclude guards and
 // generalVerbPredicate, plus the SAME adverb-skip, so the two never disagree. ----
 const GENERAL_VERB_YESNO_RE = new RegExp(`^(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[?.!\\s]*$`, "i");
-const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+(?:\\s+(?:on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside))?)[?.!\\s]*$`, "i");
+const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+(?:\\s+(?:${PREP_SRC}))?)[?.!\\s]*$`, "i");
 /** GENERAL_VERB_EXCLUDE_RE was written for generalVerbTeach's fully-conjugated
  *  declarative verb ("X OWNS Y", "X MAINTAINS Y") — but "does/did X <verb> Y"
  *  captures the BARE INFINITIVE after do-support ("does X OWN Y", never "does X
@@ -2413,7 +2650,7 @@ const GENERAL_VERB_QUERY_EXCLUDE_RE = /^(?:be|own|maintain)$/i;
  *  minted predicate: "disk-1 rests on peg-a" stores mgx:rest-on with object
  *  "peg-a", never mgx:rest with the meaning-bearing "on" buried inside the
  *  object where no read-back can match it. */
-const GENERAL_VERB_PREP_RE = /^(on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside)\s+(.+)$/i;
+const GENERAL_VERB_PREP_RE = new RegExp(`^(${PREP_SRC})\\s+(.+)$`, "i");
 /** Fold a leading preposition from `objectRaw` into a minted mgx:<lemma>
  *  predicate. Curated predicates (mgx:hasA, mgx:capableOf — anything not the
  *  plain lowercase mint shape) are never suffixed. Returns {predicate,
@@ -2433,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
@@ -2451,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
@@ -2555,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
@@ -2573,7 +2966,11 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // `are` payload — see the payload-construction block below), which leaves
   // whatever the structural grammar's own honest miss already said standing,
   // rather than overwriting it with a wrong-reason refusal.
-  if (pronounMatch && !(await hasMidSentenceInterrogative(pronounSrc))) {
+  // The action-signature frame is the ONE pronoun-led teach shape ("you can
+  // move a disk onto a peg") — the full-shape test keeps "you can fly"
+  // declining right here.
+  if (pronounMatch && !ACTION_SIGNATURE_TEACH_RE.test(pronounSrc)
+    && !(await hasMidSentenceInterrogative(pronounSrc))) {
     const pronoun = pronounMatch[1];
     return {
       text: `I can't store a fact about "${pronoun}" as a class — pronouns aren't things I can classify. `
@@ -2687,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
@@ -2786,6 +3217,230 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
   }
 
+  // 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
+  // decline that RETURNS here — falling through would hand these shapes to
+  // the general-verb lane below, which would mint a garbage predicate from
+  // them (the silent-garble case this lane exists to prevent).
+  const actionLemma = verbLemma;
+  const actionRoleFor = (word, subjectClass) => {
+    const w = String(word || "").toLowerCase();
+    if (w === "target") return "target";
+    if (w === String(subjectClass || "").toLowerCase()) return "subject";
+    return null;
+  };
+
+  const actionSig = ownSrc.match(ACTION_SIGNATURE_TEACH_RE);
+  if (actionSig && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    try {
+      const verb = await actionLemma(actionSig[1]);
+      const prep = actionSig[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: actionSig[2], targetClass: actionSig[4] },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: you can ${verb} a ${actionSig[2].toLowerCase()} ${prep} a ${actionSig[4].toLowerCase()}`,
+          via: "assert", miss: false,
+        };
+      }
+    } 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]);
+    if (!role) {
+      return {
+        text: `I can't place "${precondNothing[7]}" in that rule — the last word must be "target" or the ${precondNothing[2]} itself (e.g. "nothing may ${precondNothing[5].toLowerCase()} ${precondNothing[6].toLowerCase()} the ${precondNothing[2]}").`,
+        via: "teach-miss", miss: true,
+      };
+    }
+    try {
+      const verb = await actionLemma(precondNothing[1]);
+      const prep = precondNothing[3].toLowerCase();
+      const innerVerb = await actionLemma(precondNothing[5]);
+      const scopeWord = precondNothing[4].toLowerCase();
+      const { appendRule, RULE_KIND_ACTION_PRECOND } = await import("./memory/core.mjs");
+      const { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_PRECOND,
+        slots: {
+          shape: "no-incoming",
+          predicate: `${innerVerb}-${precondNothing[6].toLowerCase()}`,
+          role,
+          scope: scopeWord === "target" ? "any" : scopeWord,
+        },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: to ${verb} ${prep}, nothing may ${precondNothing[5].toLowerCase()} ${precondNothing[6].toLowerCase()} the ${role === "target" ? "target" : precondNothing[2].toLowerCase()}`,
+          via: "assert", miss: false,
+        };
+      }
+    } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+  }
+
+  const precondComp = ownSrc.match(ACTION_PRECOND_COMPARATIVE_RE);
+  if (precondComp && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const role = actionRoleFor(precondComp[5], precondComp[2]);
+    const rightWord = precondComp[7].toLowerCase();
+    const otherOk = role === "subject"
+      ? (rightWord === "target" || rightWord === precondComp[4].toLowerCase())
+      : (role === "target" && rightWord === precondComp[2].toLowerCase());
+    if (!role || !otherOk) {
+      return {
+        text: `I can't place "${!role ? precondComp[5] : precondComp[7]}" in that rule — the compared words must be the ${precondComp[2]} and the target (e.g. "the ${precondComp[2]} must be smaller than the target").`,
+        via: "teach-miss", miss: true,
+      };
+    }
+    try {
+      const verb = await actionLemma(precondComp[1]);
+      const prep = precondComp[3].toLowerCase();
+      const scopeWord = precondComp[4].toLowerCase();
+      const { appendRule, RULE_KIND_ACTION_PRECOND } = await import("./memory/core.mjs");
+      const { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_PRECOND,
+        slots: {
+          shape: "comparator",
+          predicate: `${precondComp[6].toLowerCase().replace(/\s+/g, "-")}-than`,
+          role,
+          scope: scopeWord === "target" ? "any" : scopeWord,
+        },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: to ${verb} ${prep}, the ${precondComp[5].toLowerCase()} must be ${precondComp[6].toLowerCase()} than the ${rightWord}`,
+          via: "assert", miss: false,
+        };
+      }
+    } 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();
+    const verb = await actionLemma(gerund);
+    // An unreduced -ing form would mint a name ("moving onto") that can never
+    // match the signature's ("move onto") — decline rather than store a rule
+    // the interpreter can't collect.
+    if (verb === gerund || !gerund.startsWith(verb.slice(0, Math.min(3, verb.length)))) {
+      return {
+        text: `I can't reduce "${actionEffect[1]}" to its verb right now — the lemmatizer isn't available. Retry later, or teach the other rule sentences first.`,
+        via: "teach-miss", miss: true,
+      };
+    }
+    // "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 (!objectRole || subjectRole === objectRole) {
+      return {
+        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,
+      };
+    }
+    try {
+      const prep = actionEffect[3].toLowerCase();
+      const effVerb = await actionLemma(actionEffect[6]);
+      const { appendRule, RULE_KIND_ACTION_EFFECT } = await import("./memory/core.mjs");
+      const { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_EFFECT,
+        slots: {
+          predicate: `${effVerb}-${actionEffect[7].toLowerCase()}`,
+          subjectRole,
+          objectRole,
+        },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          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,
+        };
+      }
+    } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+  }
+
+  const rendersAs = ownSrc.match(RENDERS_AS_TEACH_RE);
+  if (rendersAs && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: rendersAs[1], predicate: "mgx:rendersAs", object: rendersAs[2],
+    });
+    if (stored) return stored;
+  }
+
   // "some Xs are Ys" / "a few Xs are Ys" — the plural class-
   // membership quantifier shape. ACE has no quantifier-phrase pattern at all
   // (parseAce never even attempts a fit), so this is ALWAYS a direct write,
@@ -2875,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);
@@ -2885,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
@@ -2912,7 +3585,8 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     if (comp) {
       const compPredicate = `mgx:${comp[2].toLowerCase().replace(/\s+/g, "-")}-than`;
       const stored = await teachFact(memoryDir, sessionId, {
-        subject: comp[1].trim(), predicate: compPredicate, object: comp[3].trim(),
+        subject: comp[1].trim(), predicate: compPredicate,
+        object: comp[3].trim().replace(/[.!?]+$/, ""),
       });
       if (stored) return stored;
     }
@@ -2923,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
@@ -3733,6 +4432,7 @@ const FACT_PREDICATE_PHRASES = {
   "mgx:hasLastSubevent": "ends with",
   "mgx:hasPrerequisite": "requires",
   "mgx:ownedBy": "is owned by", // the teach lane's ownership frame ("Priya owns tasks.mjs")
+  "mgx:rendersAs": "renders as", // the render-template binding ("a disk renders as a block")
   "mgx:synonym": "means the same as",
   "mgx:antonym": "is the opposite of",
   "mgx:similarTo": "is similar to",
@@ -4095,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,
@@ -4191,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
@@ -4290,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();
@@ -4342,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.
@@ -4370,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
@@ -4502,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,
       };
@@ -4527,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.
@@ -4543,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
@@ -5028,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. */
-async function factReadBack(memoryDir, query, envelope, miss, graph = null, focusLabel = null, biasByBundle = {}, cache = 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; }
@@ -5279,7 +6302,7 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   // 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();
@@ -6893,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],
     };
   }
@@ -7071,7 +8094,227 @@ async function entityOfKindInText(graph, expectedClass, answerText) {
  *  otherwise the unchanged dispatchTool path (which also yields the no-graph error).
  *  A hit updates the focus to the resolved object. Grammar miss / ToolError → a
  *  normal answer, never a crash. */
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null }) {
+/** Load the taught domain for the plan lane: fact rows + rule rows compiled
+ *  through src/domain.mjs. Fresh-loads memory (never the turn cache) because
+ *  the caller may have just written snapshot rows this same turn. */
+async function loadPlanContext(memoryDir) {
+  const { loadMemory, readFactRows, readRuleRows } = await import("./memory/core.mjs");
+  const { compileDomain, stateFromFacts } = await import("./domain.mjs");
+  const payload = await loadMemory(memoryDir);
+  const factRows = readFactRows(payload);
+  const ruleRows = readRuleRows(payload);
+  const domain = compileDomain(factRows, ruleRows);
+  const state = stateFromFacts(factRows, domain);
+  return { factRows, ruleRows, domain, state };
+}
+
+/** Human label for a grounded action: name "move onto" + disk-1 + peg-c →
+ *  "move disk-1 onto peg-c". */
+function actionLabel(name, subject, target) {
+  const sp = String(name).split(/\s+/);
+  const verb = sp[0] || "move";
+  const prep = sp.slice(1).join(" ") || "onto";
+  return `${verb} ${subject} ${prep} ${target}`;
+}
+
+/** THE PLAN LANE — the closed goal/solve/legal-moves recognizers over the
+ *  taught action rules (PLAN_HANOI's chat surface). Returns
+ *  { text, via, deduced, note, plan? } or null when the query is none of the
+ *  three shapes. Mutates planHolder.state (the session's plan slot). */
+async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", }) {
+  const q = String(query).trim();
+
+  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]);
+    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 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;
+    planHolder.state = {
+      goals: [...(prev?.goals ?? []), spec],
+      goalTexts: [...(prev?.goalTexts ?? []), tail],
+      actions: null, states: null, stepGoals: null, cursor: 0, done: false,
+    };
+    const n = planHolder.state.goals.length;
+    return {
+      text: `noted — the goal is that ${tail}.${n > 1 ? ` (${n} goals held)` : ""} Say "solve it" when the state is taught.`,
+      via: "plan", deduced: "record the goal state for a later plan",
+      note: "GOAL frame — goal spec accumulated on the session plan slot",
+    };
+  }
+
+  const wantsSolve = PLAN_SOLVE_RE.test(q);
+  const wantsLegal = LEGAL_MOVES_RE.test(q);
+  if (!wantsSolve && !wantsLegal) return null;
+
+  let ctx;
+  try {
+    ctx = await loadPlanContext(memoryDir);
+  } catch (err) {
+    return { text: `I can't read the taught domain: ${err?.message ?? err}`, via: "plan", deduced: "plan a move sequence", note: "plan lane — domain load failed" };
+  }
+  const { domain, state, factRows } = ctx;
+  if (!domain.actions.length) {
+    return {
+      text: `no action rules taught yet — teach the game first (e.g. "you can move a disk onto a peg").`,
+      via: "plan", deduced: "plan a move sequence (no action rules yet)", note: "plan lane — honest decline: no action rules",
+    };
+  }
+  if (!state.length) {
+    return {
+      text: `no current state taught yet — state the board first (e.g. "disk-1 rests on peg-a").`,
+      via: "plan", deduced: "plan a move sequence (no state yet)", note: "plan lane — honest decline: empty state",
+    };
+  }
+  const { movesFromRules, stateKeyFor, compileGoal, PlanBudgetError } = await import("./domain.mjs");
+
+  if (wantsLegal) {
+    let moves;
+    try {
+      moves = movesFromRules(state, domain);
+    } catch (err) {
+      if (err instanceof PlanBudgetError) {
+        return { text: `too many possible moves to enumerate here (${err.message}) — narrow the classes involved.`, via: "plan", deduced: "list the legal moves (budget exceeded)", note: "plan lane — budget decline" };
+      }
+      throw err;
+    }
+    if (!moves.length) {
+      return { text: "no legal moves from the current state.", via: "plan", deduced: "list the legal moves (none)", note: "plan lane — legal moves: none" };
+    }
+    const lines = moves.map((m, i) => `  ${i + 1}. ${actionLabel(m.action.name, m.action.subject, m.action.target)}`);
+    return {
+      text: `${moves.length} legal move${moves.length === 1 ? "" : "s"} from here:\n${lines.join("\n")}`,
+      via: "plan", deduced: "list the legal moves from the current state",
+      note: "plan lane — movesFromRules over the current snapshot, one ply, no search",
+    };
+  }
+
+  // "solve it" — the full search.
+  if (!planHolder.state?.goals?.length) {
+    return {
+      text: `no goal set yet — teach one first (e.g. "the goal is that every disk rests on peg-c").`,
+      via: "plan", deduced: "plan a move sequence (no goal yet)", note: "plan lane — honest decline: no goal",
+    };
+  }
+  const goals = planHolder.state.goals;
+  const goalText = planHolder.state.goalTexts.join("; ");
+  let isGoal;
+  try {
+    isGoal = compileGoal(goals, domain);
+  } catch (err) {
+    return { text: `I can't compile that goal: ${err?.message ?? err}`, via: "plan", deduced: "plan a move sequence (uncompilable goal)", note: "plan lane — goal compile decline" };
+  }
+  const { findActionPath } = await import("./planning.mjs");
+  let found;
+  try {
+    found = findActionPath(state, isGoal, (s) => movesFromRules(s, domain), { maxDepth: 300, stateKey: stateKeyFor });
+  } catch (err) {
+    if (err instanceof PlanBudgetError) {
+      return { text: `the search space is too large (${err.message}) — narrow the classes involved.`, via: "plan", deduced: "plan a move sequence (budget exceeded)", note: "plan lane — budget decline" };
+    }
+    throw err;
+  }
+  if (!found) {
+    return {
+      text: `no plan found within 300 moves from the current state to: ${goalText}.`,
+      via: "plan", deduced: "plan a move sequence (no path)", note: "plan lane — honest miss: findActionPath returned null",
+    };
+  }
+  const n = found.actions.length;
+  const actions = found.actions.map((a) => ({
+    name: a.name, subject: a.subject, target: a.target,
+    label: actionLabel(a.name, a.subject, a.target),
+  }));
+  const stepGoals = actions.map((a, i) =>
+    `${a.label} (step ${i + 1} of ${n}, working toward: ${goalText})`);
+  const renderHints = {};
+  const ordering = [];
+  for (const r of factRows) {
+    if (r.predicate === "mgx:rendersAs") renderHints[r.subject] = r.object;
+    else if (/-than$/.test(r.predicate)) ordering.push({ subject: r.subject, predicate: r.predicate, object: r.object });
+  }
+  const plan = {
+    actions, states: found.states, stepGoals,
+    goal: { text: goalText, specs: goals },
+    domain: { classMembers: domain.classMembers, ordering, renderHints },
+  };
+  planHolder.state = {
+    ...planHolder.state, actions, states: found.states, stepGoals, cursor: 0, done: false, goalText,
+  };
+  const ruleNames = [...new Set(domain.actions.map((a) => a.name))].join('", "');
+  const moveLines = actions.map((a, i) => `  ${i + 1}. ${a.label}`);
+  const text = n === 0
+    ? `the goal already holds — nothing to do.`
+    : `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".`;
+  return {
+    text, via: "plan",
+    deduced: `plan a move sequence from the current state to the goal (${n} move${n === 1 ? "" : "s"})`,
+    note: "plan lane — compileDomain + findActionPath over the taught rules; plan held on the session slot",
+    plan,
+  };
+}
+
+/** Execute the active plan's next move: append the successor snapshot's rows
+ *  as @stepK facts, advance the cursor, and on the final step re-read the
+ *  store and confirm the goal from the WRITTEN facts (never assumed). */
+async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
+  const ps = planHolder.state;
+  const k = ps.cursor + 1;
+  const action = ps.actions[ps.cursor];
+  const rows = ps.states[k];
+  const { appendFact, loadMemory, readFactRows } = await import("./memory/core.mjs");
+  for (const row of rows) {
+    await appendFact(memoryDir, {
+      subject: `${row.subject}@step${k}`, predicate: row.predicate, object: row.object,
+      provenance: `plan:${sessionId || "chat"}:step${k}`,
+    });
+  }
+  planHolder.state = { ...ps, cursor: k };
+  const boardLine = rows.map((r) => `${r.subject} ${predicatePhrase(r.predicate)} ${r.object}`).join("; ");
+  if (k < ps.actions.length) {
+    return {
+      text: `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${k}: ${boardLine}`,
+      deduced: ps.stepGoals[k] ? ps.stepGoals[k] : `continue the plan (step ${k + 1} of ${ps.actions.length})`,
+    };
+  }
+  // Final step: confirm the goal against the store, from the written facts.
+  const { compileDomain, stateFromFacts, compileGoal } = await import("./domain.mjs");
+  const { readRuleRows } = await import("./memory/core.mjs");
+  const payload = await loadMemory(memoryDir);
+  const factRows = readFactRows(payload);
+  const domain = compileDomain(factRows, readRuleRows(payload));
+  const finalState = stateFromFacts(factRows, domain);
+  const holds = compileGoal(ps.goals, domain)(finalState);
+  planHolder.state = { ...planHolder.state, done: true };
+  return {
+    text: holds
+      ? `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${k}: ${boardLine}\n\ndone — ${ps.goalText} (checked against board@step${k}'s written facts, not assumed).`
+      : `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${k}: ${boardLine}\n\nBUT the goal does NOT hold against the written facts — the plan or the state drifted; re-teach the state and solve again.`,
+    deduced: holds ? `goal reached — ${ps.goalText} (${k} of ${k} steps)` : "plan finished but the goal check failed",
+  };
+}
+
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
@@ -7147,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
@@ -7300,6 +8554,28 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, `lane: (1) META/SELF — bare self/session question recognized, answered via="${meta.via}"`);
     }
   }
+  // (1p) PLAN — the goal/solve/legal-moves recognizers over taught action
+  // rules. Sits ABOVE the conversational catch-all: "solve it" is three
+  // short words and isConversational() would otherwise claim it into the
+  // orientation card before this lane ever ran.
+  let planResult = null;
+  if (!handled && miss && memoryDir && planHolder) {
+    const planLane = await planLaneAnswer(query, { memoryDir, planHolder, sessionId });
+    if (planLane) {
+      answer = planLane.text; via = planLane.via; recordMiss = false; handled = true;
+      if (planLane.plan) planResult = planLane.plan;
+      if (planLane.deduced) {
+        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}`);
+    }
+  }
   // "what about X" with a genuine PRIOR turn to continue is exempt from the
   // conversational catch-all even when short/non-codeish: isConversational()
   // can't see that discourseRewrite/describeWrapperAnswer haven't had their
@@ -7331,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
@@ -7358,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
@@ -7394,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
@@ -7436,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).
@@ -7466,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
@@ -7487,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) {
@@ -7608,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",
@@ -7833,7 +9222,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // `goal`: the SAME deduced string the debug trace's own "goal:" line
   // carries. Only runAsk ever sets this field, so the always-on goal line is
   // scoped to real ask-engine turns by construction.
-  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery, goal: deduced };
+  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery, goal: deduced, ...(planResult ? { plan: planResult } : {}) };
 }
 
 /** A non-ask, non-dispatch chat turn (count answer, /stats) — the same
@@ -7947,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];
@@ -8255,7 +9650,7 @@ function vocabAntecedentFrom(last) {
   return m ? m[1] : null;
 }
 
-export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null } = {}) {
+export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, _noSplit = false } = {}) {
   const line = String(input ?? "").trim();
   // ONE fresh, empty cache for this turn only — every factRows() reader
   // reached from this call shares it, so the first reader computes
@@ -8297,7 +9692,11 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // vocabHint: createSession computes this ONCE per session; a direct
   // runTurn() caller that doesn't pass one gets it computed here instead.
   const resolvedVocabHint = vocabHint ?? vocabExampleHint(await hasSeededVocabulary(memoryDir));
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent };
+  // The session's in-progress plan rides a mutable holder: the plan lane and
+  // the PLAN NEXT block below write planHolder.state; every other path leaves
+  // it untouched, and the caller re-threads whatever comes back.
+  const planHolder = { state: planState };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last
   // answer" that why/say-more re-renders; a conversational turn does not.
   // Every dispatched turn's result passes through finish() here — the LAST
@@ -8338,6 +9737,21 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   const convo = vocabAntecedent ? null : conversationalTurn(workingLine, ctx);
   if (convo) return withNarration(convo, trace, "casual/social — no graph intent");
 
+  // PLAN NEXT — "next"/"continue" with an ACTIVE plan executes the plan's
+  // next move as a snapshot write. Checked BEFORE the MORE_RE pager because
+  // MORE_RE owns the same words; with no active plan this block never fires
+  // and paging behaves exactly as before.
+  if (memoryDir && PLAN_NEXT_RE.test(workingLine)
+      && planHolder.state && !planHolder.state.done
+      && Array.isArray(planHolder.state.actions) && planHolder.state.cursor < planHolder.state.actions.length) {
+    const step = await executePlanStep(planHolder, { memoryDir, sessionId });
+    note(trace, `goal: ${step.deduced}`);
+    note(trace, "lane: PLAN NEXT — executed the active plan's next move as an @stepK snapshot write");
+    const rec = withLast(plainTurn(workingLine, step.text, { via: "plan", focus }), step.deduced);
+    rec.planState = planHolder.state;
+    return rec;
+  }
+
   // "more" — page the remainder of a previous long listing, if one is held. Gated on
   // an actual pending remainder so a bare "more" with nothing to continue falls through
   // to the ordinary path (an honest miss), never a pretend page.
@@ -8347,6 +9761,39 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     return withLast(morePage(workingLine, ctx), "continue viewing a previous long listing");
   }
 
+  // Multi-sentence PLAN pre-split — one message carrying state sentences plus
+  // a goal/trigger ("disk-1 rests on disk-2. … the goal is that …. solve it.")
+  // runs each sentence as its own nested turn, threading focus/last/planState
+  // through, and answers with the final turn's result behind brief receipts.
+  if (!_noSplit && memoryDir) {
+    const sentences = splitSentences(workingLine);
+    if (sentences.length > 1) {
+      const lastSentence = sentences[sentences.length - 1];
+      if (PLAN_SOLVE_RE.test(lastSentence) || GOAL_TEACH_RE.test(lastSentence) || GOAL_TEACH_INFINITIVE_RE.test(lastSentence) || LEGAL_MOVES_RE.test(lastSentence)) {
+        let f = focus; let l = last; let ps = planHolder.state;
+        const receipts = [];
+        let finalRec = null;
+        for (const sentence of sentences) {
+          const r = await runTurn(sentence, {
+            config, source, graph, focus: f, last: l, memoryDir, sessionId, env, lexicon,
+            narrate: false, vocabHint, tel, biasByBundle, planState: ps, _noSplit: true,
+          });
+          f = r.focus ?? f;
+          l = r.last ?? l;
+          if ("planState" in r) ps = r.planState;
+          finalRec = r;
+          receipts.push(String(r.answer ?? "").split("\n")[0]);
+        }
+        const receiptLines = receipts.slice(0, -1).map((t) => `• ${t}`).join("\n");
+        const combined = { ...finalRec, answer: receiptLines ? `${receiptLines}\n\n${finalRec.answer}` : finalRec.answer };
+        combined.planState = ps;
+        combined.focus = f;
+        combined.last = l;
+        return combined;
+      }
+    }
+  }
+
   if (workingLine.startsWith("/")) return withLast(await runCommand(workingLine, ctx), "use a specific tool/command directly");
   // Declarative ACE sentences ("every module is a artifact") ASSERT into tmct's
   // own memory and confirm — they are statements to remember, not graph queries.
@@ -8359,6 +9806,15 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       note(trace, "lane: assertTurn — grammar/ace.mjs parseAce matched a full triple with no residue");
       return withLast(asserted, "teach/remember a new fact");
     }
+    // Bare declarative taxonomy (hyphenated-instance membership, article-led
+    // kind-of) — see bareTaxonomyTeach. Checked here because the ask engine
+    // would otherwise parse these statements as inherits QUESTIONS.
+    const taxonomy = await bareTaxonomyTeach(workingLine, ctx);
+    if (taxonomy) {
+      note(trace, "goal: teach/remember a new fact (bare declarative taxonomy)");
+      note(trace, "lane: bareTaxonomyTeach — hyphenated-instance or article-led kind-of declarative, stored before the ask engine could parse it as a question");
+      return withLast(plainTurn(workingLine, taxonomy.text, { via: taxonomy.via, miss: taxonomy.miss, focus }), "teach/remember a new fact");
+    }
   }
   // MEMORY-STORE counts first ("how many facts / utterances do you know") — the
   // memory graph owns Facts + Utterances, so these are answerable and consistent
@@ -8415,7 +9871,11 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     note(trace, "lane: answerCount — a header-count aggregate question, answered mechanically off the graph header, never dispatched to the ask engine");
     return withLast(plainTurn(workingLine, count, { via: "count", focus }), "get a count of a graph kind");
   }
-  return withLast(await runAsk(workingLine, ctx), "unclear — no goal signal computed by the ask engine");
+  {
+    const rec = withLast(await runAsk(workingLine, ctx), "unclear — no goal signal computed by the ask engine");
+    rec.planState = planHolder.state;
+    return rec;
+  }
 }
 
 // ---- W3: seedMemory → bootstrap (first run in a graph-less repo) ----
@@ -8728,6 +10188,7 @@ export async function createSession({
   let turns = 0;
   let focus = null; // the current focus entity ({id,label}) — threaded turn to turn
   let last = null;  // the last dispatched answer ({query,answer,detail}) — why/say-more re-renders it
+  let planState = null; // the in-progress plan (goals/moves/cursor) — cleared by completion or a fresh goal, never by an aside
   let closed = false;
 
   return {
@@ -8737,6 +10198,7 @@ export async function createSession({
     // prompt/expand-hint without reaching into runTurn's threading.
     get focus() { return focus; },
     get lastAnswer() { return last; },
+    get planState() { return planState; },
     get turns() { return turns; },
     get narrate() { return narrateOn; },
     promptFor: () => promptFor(focus),
@@ -8748,7 +10210,7 @@ export async function createSession({
     async turn(line) {
       let result;
       try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, vocabHint, tel, biasByBundle });
+        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, vocabHint, tel, biasByBundle, planState });
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);
@@ -8762,6 +10224,7 @@ export async function createSession({
       const { answer, logLines, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate } = result;
       focus = nextFocus;
       last = nextLast;
+      if ("planState" in result) planState = result.planState;
       // /narrate on|off (runCommand) rides the turn RESULT the same way a focus
       // update does — apply it to this handle's session-scoped state.
       if (typeof nextNarrate === "boolean") narrateOn = nextNarrate;
@@ -8777,7 +10240,7 @@ export async function createSession({
       });
       await upsertGraph(record.ts);
       turns += 1;
-      return { answer, end: Boolean(end), prompt: promptFor(focus) };
+      return { answer, end: Boolean(end), prompt: promptFor(focus), plan: result.plan ?? null };
     },
 
     /** End-of-session close: end lines in both artifacts, the final graph upsert