@polycode-projects/the-mechanical-code-talker 1.5.5 → 1.8.3

package/src/chat.mjs

@@ -37,7 +37,7 @@
 // load-bearing — see its docblock), telemetry, and the close. runChat is the
 // readline shell over it; src/tui/app.mjs is the Ink shell over the same sink.
 
-import { join, dirname } from "node:path";
+import { join, dirname, resolve } from "node:path";
 import { createWriteStream } from "node:fs";
 import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -45,21 +45,23 @@ import { createInterface } from "node:readline/promises";
 import { spawnSync } from "node:child_process";
 import { dispatchTool } from "./server.mjs";
 import { loadConfig, DEFAULT_GRAPH_REL } from "./config.mjs";
+import { resolveRuntimeConfig } from "./cli-args.mjs";
 import { parseEntities, edgesOfKind, renderAuthorCard, renderAuthorTouches, renderCommitAuthor } from "./codegraph.mjs";
 import { SESSIONS_DIR_REL, appendSessionToGraph } from "./sessions.mjs";
 import { uuidv7 } from "./uuid.mjs";
 import { createTelemetry } from "./telemetry.mjs";
 import * as defaultSource from "./source.mjs";
 import { loadTemplates, render as renderTemplate } from "./corpus/templates.mjs";
-import { resolveExtensions, seedActiveCorpusEntries, mergedLexiconExtra } from "./extensions.mjs";
+import { resolveExtensions, mergedLexiconExtra } from "./extensions.mjs";
 import { rankByBiasThenTrust } from "./memory/bias.mjs";
 import { finish, beginsWithVowelSound, grammarRules } from "./finish.mjs";
 import {
   VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
   stripTrailingScopeFiller, stripTrailingDiscourseTag,
 } from "./ask-vocab.mjs";
-import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, normalizeQuery, escapeRegex } from "./interpret/normalize.mjs";
+import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, normalizeQuery, escapeRegex, kindNounAnaphoraHint } from "./interpret/normalize.mjs";
 import { fuzzyMatchInSet, fuzzyBound } from "./interpret/fuzzy.mjs";
+import { pickPhrase } from "./answer-variants.mjs";
 
 // uuidv7 lives in ./uuid.mjs (shared with telemetry + the bench stamp); re-exported
 // here because callers/tests still import it from chat.mjs.
@@ -785,6 +787,38 @@ const AI_IDENTITY_PHRASES = [
   /^do you use ai\??$/i, /^what language model are you( using)?\??$/i,
   /^am i (talking|speaking|chatting) (to|with) a (real )?(person|human|bot|ai)\??$/i,
 ];
+
+/** Split raw turn text into candidate single-sentence clauses on sentence-
+ *  ending punctuation ("?"/"!"/"."), trimmed, empties dropped. BENCHMARK_
+ *  CONVERSATION_1.7.0.md routed backlog C4: AI_IDENTITY_PHRASES' own entries
+ *  are anchored (^...$) against a SINGLE clause, so a two-sentence turn like
+ *  "are you an AI? like chatgpt?" could never match the whole raw string even
+ *  though its first clause alone is an exact "are you an AI" hit. Used ONLY
+ *  by aiIdentityMatch below — every OTHER closed-set match in this file stays
+ *  whole-string, on purpose (this is deliberately narrow to the one family
+ *  that's shown up broken this way, not a general multi-clause rewrite of
+ *  isConversational's whole match cascade). */
+function splitClauses(text) {
+  return String(text).split(/[?!.]+\s*/).map((c) => c.trim()).filter(Boolean);
+}
+
+/** AI_IDENTITY_PHRASES matched against the whole raw turn OR, failing that,
+ *  against any one of its sentence-split clauses (splitClauses, above) — so
+ *  "are you an AI? like chatgpt?" matches on its first clause alone, the same
+ *  way a single-sentence "are you an AI" already did. The whole-string check
+ *  runs first (the common case, no split needed); the clause fallback only
+ *  ever ADDS a match a single-clause turn already had no chance to win to,
+ *  since every phrase is itself a complete anchored sentence — a genuinely
+ *  unrelated longer sentence that merely CONTAINS identity-phrase-shaped
+ *  words won't split into a clause that's ONLY those words, so this can't
+ *  false-positive on it (e.g. "well are you an AI expert on this" has no
+ *  clause boundary carving out "are you an AI" alone). */
+function aiIdentityMatch(raw) {
+  const text = String(raw);
+  if (AI_IDENTITY_PHRASES.some((re) => re.test(text))) return true;
+  return splitClauses(text).some((clause) => AI_IDENTITY_PHRASES.some((re) => re.test(clause)));
+}
+
 /** "Do you have feelings/emotions" — HANDOVER.md 2026-07-10 item 10 (small-talk
  *  persona finding): with no closed-set match, this used to misfire into a
  *  literal module-name lookup for the bare noun ("no module matching 'feelings'
@@ -830,7 +864,7 @@ export function isConversational(query) {
   if (GREET.has(q) || THANKS.has(q) || OK_ACK.has(q)) return true;
   if (CAPABILITY_PHRASES.some((re) => re.test(raw))) return true;
   if (IDENTITY_PHRASES.some((re) => re.test(raw))) return true;
-  if (AI_IDENTITY_PHRASES.some((re) => re.test(raw))) return true;
+  if (aiIdentityMatch(raw)) return true;
   const codeish = looksCodeish(raw, q);
   return q.split(/\s+/).filter(Boolean).length <= 3 && !codeish;
 }
@@ -908,7 +942,7 @@ const GREET = new Set([
   // US
   "hey y'all", "howdy there", "hiya there",
   // formal
-  "good day", "salutations", "good to meet you", "pleased to meet you",
+  "good day", "good day to you", "salutations", "good to meet you", "pleased to meet you",
   // slang
   "yo yo", "ayy", "wassup", "sup fam", "heya", "hiya!",
   // texting abbreviation
@@ -945,7 +979,19 @@ const THANKS = new Set([
 const BYE = new Set([
   "bye", "goodbye", "quit", "exit", "see ya", "see you", "cya", "later", "farewell",
   "peace", "peace out", "im off", "i'm off", "gtg", "gotta go", "catch you later",
-  "good day to you", "farewell then",
+  "farewell then",
+  // "good day to you" deliberately does NOT live here (SKILL_BENCHMARK_
+  // CONVERSATION.md persona-sweep, 2026-07-11, Priority 2 — severe, killed
+  // the whole session): it's the formal-register GREETING §2.2 itself names
+  // ("good day" — down to slang), not a farewell. It used to sit in this set
+  // and won the race against GREET (foldedBye is checked first in
+  // conversationalTurn), so a plain formal "good day to you" silently ended
+  // the session — every turn piped after it was dropped with no log entry, a
+  // worse outcome than any wall. Moved to GREET (above) instead; a genuine
+  // dismissive sign-off ("farewell then", bare "farewell") stays here
+  // unchanged — this is a narrowing of an over-broad match, not a new
+  // farewell phrasing (§5 "farewells stay out of scope" governs ADDING
+  // coverage, not fixing a phrase that was on the wrong list).
 ]);
 /** Elaboration asks → RE-RENDER the last answer verbosely (traversal + matches). */
 const WHY = new Set([
@@ -1041,6 +1087,25 @@ function foldedBye(clause) {
   const folded = clause.match(REPEATED_WORD_RE);
   return !!(folded && closedOrCollapsed(folded[1], BYE, BYE_COLLAPSED));
 }
+/** Closing-filler clauses — the CONTENT half of a farewell/thanks sentence
+ *  ("thanks, that's everything for now") that isn't itself gratitude or bye
+ *  wording, but is unambiguous session-closing small talk, not a real
+ *  question. farewellOrThanksSignal's ≤3-word gate below exists to keep a
+ *  genuine question ("cheers, what does X do") out of this lane; these
+ *  clauses need their own exemption because they naturally run 4-5 words and
+ *  the gate would otherwise reject them. Found live (2026-07-11 playtest
+ *  sprint round 1): "thanks, that's everything for now" hit the raw grammar
+ *  wall as a session's LAST turn, even though a frozen single-turn regression
+ *  test for the same phrase already existed — that test only pinned "doesn't
+ *  match the wall text", which the isolated-turn fallthrough miss happened
+ *  not to, while the SAME routing gap produced the literal wall once real
+ *  session history was involved. The gap was the ≤3-word gate, not the
+ *  closed set — this clause list is the fix, not a new one-off phrase pin. */
+const CLOSING_FILLER_CLAUSES = new Set([
+  "that's everything for now", "that's all for now",
+  "that's everything i needed", "that's all i needed",
+  "that's everything for today", "that's all for today",
+]);
 function farewellOrThanksSignal(raw, q) {
   const words = q.split(/\s+/).filter(Boolean);
   if (words.length < 2 || words.length > 8 || looksCodeish(raw, q)) return null;
@@ -1055,7 +1120,8 @@ function farewellOrThanksSignal(raw, q) {
   // specific (genuine gratitude words rarely lead into an unrelated question),
   // but still gated below: a THANKS-hit only counts when every OTHER clause is
   // itself small-talk-shaped (≤3 words, non-codeish) — the SAME bound
-  // isConversational's own catch-all uses — so "cheers, what does X do" is left
+  // isConversational's own catch-all uses — OR a curated closing-filler clause
+  // (CLOSING_FILLER_CLAUSES, above) — so "cheers, what does X do" is still left
   // to the existing THANKS_PREAMBLE_RE lane, never grabbed here.
   let thanksClauseIdx = -1;
   let byeHit = false;
@@ -1069,6 +1135,7 @@ function farewellOrThanksSignal(raw, q) {
   }
   if (byeHit) return "bye";
   const thanksHit = thanksClauseIdx >= 0 && clauses.every((c, i) => i === thanksClauseIdx
+    || CLOSING_FILLER_CLAUSES.has(c)
     || (c.split(/\s+/).filter(Boolean).length <= 3 && !looksCodeish(c, c.toLowerCase())));
   return thanksHit ? "thanks" : null;
 }
@@ -1227,7 +1294,7 @@ function conversationalTurn(line, ctx) {
       return mk(t(T_THANKS));
     }
   }
-  if (AI_IDENTITY_PHRASES.some((re) => re.test(raw))) {
+  if (aiIdentityMatch(raw)) {
     note(ctx.trace, "goal: identity — is tmct an AI/LLM (a very likely first question)");
     note(ctx.trace, "lane: conversational — identity/AI (AI_IDENTITY_PHRASES closed set)");
     return mk(t(T_IDENTITY_NOT_LLM));
@@ -1361,9 +1428,11 @@ function orientationText(graph, templates, vocabHint) {
   for (const [cls, sing, plur] of [["Module", "module", "modules"], ["Class", "class", "classes"], ["Function", "function", "functions"]]) {
     const n = by(cls); if (n) parts.push(`${n} ${n === 1 ? sing : plur}`);
   }
-  return `This is a tmct code graph — ${(graph.individuals || []).length} entities`
+  const total = (graph.individuals || []).length;
+  const lead = pickPhrase("ask-about-lead", `${total}:${parts.join(",")}`, "Ask about");
+  return `This is a tmct code graph — ${total} entities`
     + `${parts.length ? ` (${parts.join(", ")})` : ""}. `
-    + 'Ask about imports, calls, definitions or history — e.g. "which modules import <name>", "what calls <name>". '
+    + `${lead} imports, calls, definitions or history — e.g. "which modules import <name>", "what calls <name>". `
     + "/stats for the full overview, /help for commands.";
 }
 
@@ -1395,8 +1464,9 @@ function moduleOverviewText(graph, ind) {
     ? `covered by ${testedBy.length} test module${testedBy.length === 1 ? "" : "s"}`
     : "no recorded tests");
   const cls = (ind.class || "entity").toLowerCase();
+  const pointer = pickPhrase("full-breakdown", ind.id, "for the full breakdown");
   return `${ind.label} is a ${cls} — ${parts.join("; ")}. `
-    + `/describe ${ind.label} for the full breakdown.`;
+    + `/describe ${ind.label} ${pointer}.`;
 }
 
 // #1 SHORT, TAILORED MISS — the engine's full grammar cheat-sheet (rephraseHint)
@@ -1474,11 +1544,69 @@ const WALL_MISS_ANYWHERE_RE = /couldn't parse this as a graph question\. Try:/;
 // automatically inherits the correct "teach/remember a new fact" goal line for
 // free (it flows through the SAME teach-lane goal revision, chat.mjs's runTurn
 // cascade — no extra wiring needed for this phrasing).
-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)\b[:,]?\s*(?:that\s+)?(.+?)[.?!]*$/i;
+// BENCHMARK_CONVERSATION_1.7.0.md routed backlog C1 ("please learn this: John
+// is a man" / "please learn also: a man is having two legs"): "learn" joins
+// the verb list, and a new optional filler slot ("this"/"that"/"also")
+// tolerates a word between the verb and the colon/comma lead-in — the verb
+// list alone never covered that shape, so "remember this: X" (not just
+// "learn this: X") is now also recognized, matching the docblock above's own
+// worked "remember that X" case (the pre-existing `(?:that\s+)?` after the
+// lead-in punctuation still covers a lead-in-less "remember that X").
+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-]+ (?:is|are) (?:a |an )?[\w-]+$/i;
 /** 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;
+/** A bare wh-word token, tested one word at a time against `hasMidSentenceInterrogative`'s
+ *  own tokenization below — never re-anchored, so it matches at ANY word position. */
+const MID_SENTENCE_WH_RE = /^(?:which|who|what|where|when|why|how)$/i;
+/** PLAN_CONVERSATION.md Finding 4 fix: QUESTION_LEAD_RE (just above) is anchored
+ *  to the FIRST word, so a wh-word appearing LATER in the sentence ("it uses
+ *  WHICH controller as its base") slips past every teachLane guard that
+ *  reuses it — including TEACH_PRONOUN_RE's own check, which has no
+ *  interrogative guard at all. That let a mid-sentence question either mint a
+ *  GARBAGE fact (a bare sentence with a real subject: "TaskController uses
+ *  which controller as its base" got stored verbatim) or produce a confusing
+ *  pronoun-specific refusal that named the wrong problem (a pronoun subject:
+ *  "it uses which controller as its base" — "it" was never the real issue,
+ *  the mid-sentence question was).
+ *
+ *  Detects a genuine mid-sentence INTERROGATIVE use of a wh-word — never the
+ *  first word, QUESTION_LEAD_RE's own anchored check already owns that case —
+ *  via wink's POS tagger (the SAME optional adapter subjectIsNounOrPropn/
+ *  objectReadsAsNonNoun below already use, ask-nlp.mjs's nlpAdapter):
+ *  whichever wh-word tokens appear after the first word, check whether the
+ *  token immediately BEFORE each is tagged VERB or AUX. A wh-in-situ
+ *  interrogative object/adjunct ("uses WHICH controller", "is used by WHICH
+ *  module") always immediately follows the verb it's an argument of; a
+ *  RELATIVE pronoun introducing a restrictive clause ("the handler WHICH
+ *  processes requests", "a grandparent WHO is male" — see
+ *  test/chat-taught-relations.test.mjs's own "a grandfather is a grandparent
+ *  who is male" teach, confirmed unaffected) always immediately follows the
+ *  NOUN it modifies instead. Checking the preceding tag is a real, if
+ *  imperfect, way to tell the two apart — not meant to be perfect (a first
+ *  increment), just enough to stop teachLane storing or refusing on the wrong
+ *  grounds. No wink installed, or any tagging surprise, degrades to false —
+ *  no signal, never a false positive from a missing adapter — matching
+ *  subjectIsNounOrPropn/objectReadsAsNonNoun's own discipline exactly. */
+async function hasMidSentenceInterrogative(text) {
+  const words = String(text || "").trim().split(/\s+/).filter(Boolean);
+  if (words.length < 2) return false;
+  const whIdx = [];
+  for (let i = 1; i < words.length; i += 1) {
+    if (MID_SENTENCE_WH_RE.test(words[i].replace(/^[.,!?;:'"]+|[.,!?;:'"]+$/g, ""))) whIdx.push(i);
+  }
+  if (!whIdx.length) return false;
+  try {
+    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const adapter = nlpAdapter();
+    if (!adapter) return false; // no wink — no signal, never a false positive
+    const tags = adapter.posTags(words);
+    return whIdx.some((i) => tags[i - 1] === "VERB" || tags[i - 1] === "AUX");
+  } catch {
+    return false;
+  }
+}
 
 // The teach lane's fact predicates (rendered via FACT_PREDICATE_PHRASES).
 const OWNED_BY_PREDICATE = "mgx:ownedBy";
@@ -1955,6 +2083,34 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
  *  or no genuine universal quantifier) falls through as a plain null,
  *  letting the ordinary teachLane cascade (property teach, then the generic
  *  honest-miss text) continue unaffected. */
+/** PLAN_CONVERSATION.md Finding 1 fix: before minting the object as a new
+ *  CLASS, ask wink's POS tagger (the SAME optional adapter subjectIsNounOrPropn,
+ *  above, already uses for this kind of disambiguation, via ask-nlp.mjs's
+ *  posTags) whether the word reads as anything OTHER than a NOUN/PROPN.
+ *  "every Record is persisted" tags "persisted" VERB (a past participle used
+ *  adjectivally); "every cache is bespoke" tags "bespoke" ADJ — both read as a
+ *  property claim about one word, not a brand-new class term, so this
+ *  fallback should decline and let the cascade fall through to
+ *  unknownAdjectiveFallback (below), which mints the SAME word correctly as a
+ *  property instead. A genuinely novel noun ("florble", "zorp") still tags
+ *  NOUN under wink's own out-of-vocabulary default (confirmed live), so this
+ *  never blocks the pre-existing mint-a-new-class behaviour the
+ *  vocabulary-growth feature needs. No wink installed, or any tagging
+ *  surprise, degrades to a null tag treated as "no signal" (never a decline)
+ *  — matching every other optional-adapter path in this file (ask-nlp.mjs's
+ *  own "null on any surprise, never a throw" discipline). */
+async function objectReadsAsNonNoun(word) {
+  try {
+    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const adapter = nlpAdapter();
+    if (!adapter) return false;
+    const [tag] = adapter.posTags([String(word || "")]);
+    if (!tag) return false; // no signal — never block the existing mint on a surprise
+    return tag !== "NOUN" && tag !== "PROPN";
+  } catch {
+    return false;
+  }
+}
 async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon }) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
@@ -1967,6 +2123,7 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon })
   if (!subjectGrounded) return null; // ungrounded subject isn't this fallback's asymmetry — never a guessed mint
   const objectGrounded = await isGroundedTerm(objectRaw, lex, memoryDir);
   if (objectGrounded) return null; // object already known — nothing to mint
+  if (await objectReadsAsNonNoun(objectRaw)) return null; // reads like an adjective/verb, not a class noun — defer to unknownAdjectiveFallback
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
   return teachFact(memoryDir, sessionId, {
     subject: subjectRaw, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
@@ -2140,6 +2297,46 @@ const GENERAL_VERB_EXCLUDE_RE = /^(?:is|are|am|owns|maintains)$/i;
  *  stands down entirely rather than risk a positional misread of a longer
  *  copula/ownership sentence it was never meant to parse. */
 const GENERAL_VERB_ANYWHERE_EXCLUDE_RE = /\b(?:is|are|am|owns|maintains)\b/i;
+/** SKILL_BENCHMARK_CONVERSATION.md persona-sweep (2026-07-11), Priority 1 —
+ *  confirmed 4x independently across 2 personas: GENERAL_VERB_TEACH_RE's verb
+ *  slot is a bare `[a-z]+` with NO check that the captured word is a real
+ *  verb at all — a closed-class function word (a possessive/personal pronoun,
+ *  a preposition, a subordinating conjunction) sitting in that position reads
+ *  as an ordinary lemma just as happily as a genuine verb does, so
+ *  generalVerbPredicate mints a nonsense mgx:<word> predicate and
+ *  thirdPersonSingularSurface's naive -s/-es/-ies fold renders it as a
+ *  garbled "confirmation" that LOOKS like a successful teach (worse than a
+ *  wall — no error, no nudge). Four live repros, all misreading a closed-
+ *  class second token as the verb: "can you review my code for me" (after
+ *  MODAL_WRAPPER_RE's own preamble strip removes "can you", verb="my" ->
+ *  mgx:my -> "mies"), "impact if i change it??" (verb="if" -> mgx:if ->
+ *  "ifs"), "defs in model.mjs" (verb="in" -> mgx:in -> "ins"). A genuine verb
+ *  ("mentors", "eats", "owns", "needs", "maintains" — every existing teach
+ *  test's verb) is never one of these closed-class words, so this is a pure
+ *  narrowing: it can only turn an already-wrong absorb into an honest
+ *  decline, never break a real teach. Wink-nlp POS tagging was tried first
+ *  and rejected — out of sentence context it tags "my"/"if"/"in" correctly,
+ *  but IN context it also mistags the legit "mentors" (test/chat-teachlane-
+ *  general-verb.test.mjs's own pinned case) as NOUN, so a POS gate would have
+ *  regressed a real teach; a closed list (this project's own stated
+ *  preference for chat-layer fixes — templates over general grammar rules)
+ *  is both more reliable here and, being closed, can never widen recognition
+ *  the way a probabilistic POS heuristic could. */
+const GENERAL_VERB_NOT_A_VERB_RE = new RegExp(
+  "^(?:"
+  // personal/possessive/demonstrative pronouns + determiners (mirrors, and
+  // extends, GENERAL_VERB_DETERMINER_RE's own closed set — that one gates the
+  // SUBJECT slot, this gates the VERB slot)
+  + "i|me|you|he|him|she|her|it|we|us|they|them|my|your|his|its|our|their|mine|yours|hers|ours|theirs"
+  + "|this|that|these|those|a|an|the|every|each|all|some|any|no|both|either|neither"
+  // prepositions
+  + "|in|on|at|to|from|by|with|for|of|about|into|onto|over|under|near|before|after|during|through"
+  + "|up|down|off|out|above|below|between|among|against|without|within|along|across|behind|beyond|upon|toward|towards|per"
+  // conjunctions/subordinators
+  + "|and|but|or|if|because|although|though|while|when|since|unless|until|whether|so|nor|than|as"
+  + ")$",
+  "i",
+);
 
 /** The predicate a general-verb teach payload's VERB maps to. "has"/"have"
  *  special-cases onto the EXISTING mgx:hasA predicate (point 2) — the same
@@ -2182,12 +2379,19 @@ async function generalVerbPredicate(verb) {
  *  the actual write via the shared teachFact. */
 async function generalVerbTeach(payload) {
   const p = String(payload || "").trim();
+  // A genuine declarative assertion never ends in a question mark — "g day
+  // mate, you alright?" (Priority 1, above) reaches this function with no
+  // leading question-word signal left to catch it (it never matched a
+  // wrapper, and QUESTION_LEAD_RE only checks the FIRST word), but the
+  // trailing "?" is still an unambiguous "this is a question" marker.
+  if (/\?\s*$/.test(p)) return null;
   if (GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(p)) return null; // another frame's territory — stand down
   const m = p.match(GENERAL_VERB_TEACH_RE);
   if (!m) return null;
   const [, subjectRaw, verbRaw, objectRaw] = m;
   const verb = verbRaw.toLowerCase();
   if (GENERAL_VERB_EXCLUDE_RE.test(verb)) return null; // owned by a more specific frame above
+  if (GENERAL_VERB_NOT_A_VERB_RE.test(verb)) return null; // a closed-class word can never be the real verb
   if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) return null; // not a bare-name subject
   const subject = subjectRaw.trim();
   const object = objectRaw.replace(/^an?\s+/i, "").trim();
@@ -2346,8 +2550,29 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // a parent", which unknownSubjectFallback already stores as
   // father ⊑ parent today (finding 2: "parent" is already a lexicon noun).
   const stripKindOf = (s) => (s == null ? s : s.replace(/\b(is|are|was|were)\s+(?:an?\s+)?(?:kind|type)\s+of\s+/i, "$1 a "));
-  const raw = stripKindOf(stripYour(rawInput));
-  const wrapped = stripKindOf(stripYour(wrappedInput));
+  // "my <class-noun> <Name> is/are …" (SKILL_BENCHMARK_CONVERSATION.md persona-
+  // sweep, 2026-07-11, Priority 3) — a THIRD natural phrasing of the exact same
+  // "X is a Y" assertion this lane already teaches two other ways ("john is a
+  // man", a bare name; "every cat is an animal", a universal quantifier) — a
+  // possessive intro clause naming an instance by class + given name ("my cat
+  // whiskers", "my dog rex") ahead of the real copula clause. grammar/ace.mjs's
+  // resolveNP only ever fits a 1–2 token noun phrase (its own docblock: "0 or
+  // 3+ tokens: not a fragment NP") — "my cat whiskers" is three content tokens,
+  // so it never reached ANY existing recognizer (ACE, BARE_DECLARATIVE_RE,
+  // TEACH_RE all declined) and hit the plain grammar wall instead of teaching.
+  // Stripping the "my <noun> " lead-in down to the bare <Name> reduces it to
+  // the EXACT shape "john is a man" already teaches correctly — no new storage
+  // path, just one more surface recognized as equivalent to an existing one.
+  // Only a LEADING "my <word> <word> is/are" run is stripped (mirrors
+  // stripYour's own leading-only anchor just above), so this can't misfire on
+  // "my" appearing mid-sentence, and requires a genuine THIRD word before the
+  // copula (never "my cat is fluffy" — a bare possessive property claim, only
+  // two words before "is" — nor "my TaskController is broken", one word),
+  // keeping recognition exactly as closed as the shapes it's equivalent to.
+  const stripPossessiveNamedInstance = (s) =>
+    (s == null ? s : s.replace(/^my\s+[a-z][\w-]*\s+([\w'-]+\s+(?:is|are)\s+.+)$/i, "$1"));
+  const raw = stripKindOf(stripYour(stripPossessiveNamedInstance(rawInput)));
+  const wrapped = stripKindOf(stripYour(stripPossessiveNamedInstance(wrappedInput)));
 
   // PRONOUN-SUBJECT GUARD — tried against BOTH surfaces (bare and remember-
   // wrapped; trailing punctuation stripped the same way the OWNS/SOME_A_FEW
@@ -2357,7 +2582,18 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // docblock above for why.
   const pronounSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
   const pronounMatch = pronounSrc.match(TEACH_PRONOUN_RE);
-  if (pronounMatch) {
+  // Finding 4 fix: a pronoun-led sentence that's ALSO a mid-sentence question
+  // ("it uses which controller as its base") isn't a pronoun-classification
+  // problem at all — "it" was never going to be storable either way, so
+  // naming the pronoun as the reason is misleading. Stand down here (no
+  // interrogative guard existed on this frame before) and let the rest of
+  // this function's cascade run: none of the other frames' shapes fit a
+  // pronoun subject with a non-copula verb, so this falls all the way
+  // through to teachLane's own honest `return null` (no wrapper, no `is`/
+  // `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))) {
     const pronoun = pronounMatch[1];
     return {
       text: `I can't store a fact about "${pronoun}" as a class — pronouns aren't things I can classify. `
@@ -2377,8 +2613,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // is an obviously code-shaped proper name and just as strong a signal that
   // this isn't ordinary prose. Either side capitalized is now enough.
   const ownSrc = wrapped ?? raw.replace(/[.!?]+\s*$/, "");
+  // Finding 4 fix: computed ONCE and reused by every ownSrc-gated frame below
+  // (own/ownPassive/rel/hasMethod/compose2/filterRule/recursiveRule) — same
+  // source string, so one wink pass suffices; see hasMidSentenceInterrogative's
+  // own docblock (near QUESTION_LEAD_RE) for why this is additive alongside
+  // each existing anchored QUESTION_LEAD_RE check, never a replacement for it.
+  const ownSrcMidQuestion = await hasMidSentenceInterrogative(ownSrc);
   const own = ownSrc.match(OWNS_TEACH_RE);
-  if (own && memoryDir && !QUESTION_LEAD_RE.test(ownSrc)
+  if (own && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion
     && (wrapped || /^[A-Z]/.test(own[1]) || /^[A-Z]/.test(own[2]))) {
     const stored = await teachFact(memoryDir, sessionId, {
       subject: own[2], predicate: OWNED_BY_PREDICATE, object: own[1],
@@ -2391,7 +2633,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // (a genuine yes/no QUESTION, handled by factReadBack instead) never lands
   // a bogus fact here.
   const ownPassive = ownSrc.match(OWNS_PASSIVE_TEACH_RE);
-  if (ownPassive && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && (wrapped || /^[A-Z]/.test(ownPassive[2]))) {
+  if (ownPassive && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion && (wrapped || /^[A-Z]/.test(ownPassive[2]))) {
     const stored = await teachFact(memoryDir, sessionId, {
       subject: ownPassive[1], predicate: OWNED_BY_PREDICATE, object: ownPassive[2],
     });
@@ -2407,7 +2649,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // to part of speech, so a role noun like "father" mints mgx:father the same
   // way a general verb would; an ordinary Fact, no new storage shape.
   const rel = ownSrc.match(RELATION_FACT_TEACH_RE);
-  if (rel && memoryDir && !QUESTION_LEAD_RE.test(ownSrc)) {
+  if (rel && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
       subject: rel[1], predicate: await generalVerbPredicate(rel[2]), object: rel[3],
     });
@@ -2427,7 +2669,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // a leading determiner — "every"/"a"/"an"/"the" — before a "has a … method"
   // claim).
   const hasMethod = ownSrc.match(TEACH_HAS_METHOD_RE);
-  if (hasMethod && memoryDir && !QUESTION_LEAD_RE.test(ownSrc)) {
+  if (hasMethod && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
       subject: hasMethod[1], predicate: HAS_A_PREDICATE, object: `${hasMethod[2]} method`,
     });
@@ -2441,7 +2683,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // COMPOSE2_RULE_TEACH_RE's own docblock). The query-side hop-counted chase
   // lives in factReadBack's relational-query dispatcher.
   const compose2 = ownSrc.match(COMPOSE2_RULE_TEACH_RE);
-  if (compose2 && memoryDir && !QUESTION_LEAD_RE.test(ownSrc)) {
+  if (compose2 && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     try {
       const { appendRule, RULE_KIND_COMPOSE2 } = await import("./memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
@@ -2467,7 +2709,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // The query-side generic base-then-property chase lives in factReadBack's
   // relational-query dispatcher (resolveRelation's own "filter" branch).
   const filterRule = ownSrc.match(FILTER_RULE_TEACH_RE);
-  if (filterRule && memoryDir && !QUESTION_LEAD_RE.test(ownSrc)) {
+  if (filterRule && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     try {
       const { appendRule, RULE_KIND_FILTER } = await import("./memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
@@ -2496,7 +2738,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // rule kinds' single-target search) lives in factReadBack's own
   // RECURSIVE_LIST_ASK_RE dispatch, below.
   const recursiveRule = ownSrc.match(RECURSIVE_RULE_TEACH_RE);
-  if (recursiveRule && memoryDir && !QUESTION_LEAD_RE.test(ownSrc)) {
+  if (recursiveRule && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     try {
       const { appendRule, RULE_KIND_RECURSIVE } = await import("./memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
@@ -2525,7 +2767,11 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // unknown object falls through to the generic honest-miss cascade at the
   // bottom of this function, same as every other unstorable teach.
   const someSrc = wrapped ?? raw.replace(/[.!?]+\s*$/, "");
-  const someMatch = memoryDir && !QUESTION_LEAD_RE.test(someSrc) ? someSrc.match(SOME_A_FEW_RE) : null;
+  // Finding 4 fix: additive alongside the existing anchored QUESTION_LEAD_RE
+  // check — same discipline as ownSrcMidQuestion above (hasMidSentenceInterrogative's
+  // own docblock, near QUESTION_LEAD_RE, has the full reasoning).
+  const someSrcMidQuestion = memoryDir && !QUESTION_LEAD_RE.test(someSrc) ? await hasMidSentenceInterrogative(someSrc) : false;
+  const someMatch = memoryDir && !QUESTION_LEAD_RE.test(someSrc) && !someSrcMidQuestion ? someSrc.match(SOME_A_FEW_RE) : null;
   if (someMatch) {
     const quantifier = someMatch[1].toLowerCase();
     const subject = singularizeSurface(someMatch[2]);
@@ -2577,13 +2823,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // miss text at all (the ORIGINAL bug: "remember tony has a hat" never even
   // reached this lane's own honest-miss cascade, landing on the structural
   // grammar's wrong-context wall instead).
-  if (wrapped && memoryDir && !QUESTION_LEAD_RE.test(wrapped)) {
+  if (wrapped && memoryDir && !QUESTION_LEAD_RE.test(wrapped) && !(await hasMidSentenceInterrogative(wrapped))) {
     const gv = await generalVerbTeach(wrapped);
     if (gv) {
       const stored = await teachFact(memoryDir, sessionId, gv);
       if (stored) return stored;
     }
-  } else if (!wrapped && memoryDir && !QUESTION_LEAD_RE.test(correctMisspellings(raw))) {
+  } else if (!wrapped && memoryDir && !QUESTION_LEAD_RE.test(correctMisspellings(raw))
+    && !(await hasMidSentenceInterrogative(correctMisspellings(raw)))) {
     // BARE path (HANDOVER.md 2026-07-10 item 2 fix): "grace mentors alan" — no
     // "remember"/"note" wrapper at all — used to silently reach neither this
     // frame NOR an honest miss, landing on the raw structural wall instead
@@ -2614,7 +2861,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
 
   let payload = null;
   if (wrapped && /\b(?:is|are)\b/i.test(wrapped)) payload = wrapped;
-  else if (BARE_DECLARATIVE_RE.test(raw) && !QUESTION_LEAD_RE.test(raw)) payload = raw;
+  else if (BARE_DECLARATIVE_RE.test(raw) && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
   if (!payload) {
     // Tier-5 playtest fix (cycle 3), found live: "remember that every
     // controller needs review" — a QUANTIFIED subject ("every X", declined
@@ -2815,7 +3062,8 @@ async function memorySummary(memoryDir, graph) {
   }
   const preds = new Set(rows.map((f) => f.predicate).filter(Boolean));
   const n = rows.length;
-  return `I remember ${n} fact${n === 1 ? "" : "s"} across ${preds.size} relation `
+  const span = pickPhrase("facts-across", `${n}:${preds.size}`, "across");
+  return `I remember ${n} fact${n === 1 ? "" : "s"} ${span} ${preds.size} relation `
     + `type${preds.size === 1 ? "" : "s"}. Ask "what do you know about <term>", or /memory to explore.`;
 }
 
@@ -2946,7 +3194,12 @@ async function metaLane(query, { graph, memoryDir, last = null, templates = null
 // an unknown name renders null here and falls through to the ordinary honest miss
 // (never a guess, never a hijacked graph query).
 const AUTHOR_NAME_SRC = "([A-Za-z][\\w'.-]*(?:\\s+[A-Za-z][\\w'.-]*){0,3})";
-const AUTHOR_WHO_IS_RE = new RegExp(`^who\\s+is\\s+${AUTHOR_NAME_SRC}$`, "i");
+// "was" joins "is" (2026-07-11 playtest find): "who was grace hopper" is the same
+// identity-card ask as "who is grace hopper", just past-tense phrasing — the way a
+// curious user actually asks about a person, code author or not. Previously only
+// present tense matched, so "who was <name>" fell all the way to the plain
+// grammar wall even for a name IN the author index.
+const AUTHOR_WHO_IS_RE = new RegExp(`^who\\s+(?:is|was)\\s+${AUTHOR_NAME_SRC}$`, "i");
 const AUTHOR_TOUCHED_RE = new RegExp(
   `^what\\s+(?:did|has)\\s+${AUTHOR_NAME_SRC}\\s+(?:touch(?:ed)?|chang(?:e|ed)|work(?:ed)?\\s+on|commit(?:ted)?)$`, "i");
 // The sha authorship forms — the interpret layer no longer rewrites these (WS2 guard).
@@ -3071,11 +3324,20 @@ function nudgeName(captured, focus) {
  *  for the opinion gate: it must fire BEFORE the short-miss's "is a <thing> a
  *  <kind>" membership hint would (the caller runs this whole step before the
  *  short-miss rewrite). */
-function nudgeAnswer(query, focus) {
+function nudgeAnswer(query, focus, vocabHint = null) {
   const q = String(query).trim().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
   if (PERSONAL_ASSISTANT_NUDGE_RE.test(q)) {
+    // "what is a dog" used to be hardcoded here regardless of session state — a lie
+    // in any UNSEEDED session (no `tmct init`/corpus load ever ran), the exact
+    // "offered example that itself fails" bug class the "vocab-hint is never a lie"
+    // discipline (test/chat-ux.test.mjs) already fixed on the other 5 vocabulary-hint
+    // surfaces (banner, greeting, capability orientation, meta/self, memory summary)
+    // — this out-of-domain nudge was simply never brought into that same discipline.
+    // vocabHint (threaded from runAsk/runTurn's own hasSeededVocabulary check) is
+    // ALREADY the correct session-gated clause: "what is a dog" when seeded, `tmct
+    // init` otherwise — reused verbatim instead of a second, ungated copy.
     return "I don't have access to that — I'm a deterministic code/vocabulary assistant, not a general assistant. "
-      + 'Ask me about code structure ("which modules import <name>") or try "what is a cache".';
+      + `Ask me about code structure ("which modules import <name>"). ${vocabHint || 'Run `tmct init` to seed a starter vocabulary.'}`;
   }
   if (OPINION_NUDGE_RE.test(q)) {
     const name = focus?.label || "<name>";
@@ -3112,7 +3374,12 @@ function nudgeAnswer(query, focus) {
     const name = focus?.label;
     return "I only name the single top (or bottom) match for a metric — no runner-up ranking, no comparing against a number. "
       + (name
-        ? `Ask about a specific module/class/function directly to compare it with ${name} (e.g. "how many imports does <name> have").`
+        // "how many imports does <name> have" used to sit here but never parses — the
+        // count grammar (ask.mjs's parseAggregate) requires a known entity-kind noun
+        // ("modules", "classes", …) right after "how many", and "imports" isn't one; a
+        // relation noun there is always an honest miss, for any <name>. "how many
+        // modules does <name> import" is the real working per-entity count shape.
+        ? `Ask about a specific module/class/function directly to compare it with ${name} (e.g. "how many modules does <name> import").`
         : `Ask a specific ranking directly, e.g. "which module has the most imports".`);
   }
   // A bare STACCATO PRONOUN continuation ("also that one?", "and it") with NO
@@ -3262,12 +3529,6 @@ export function gitToplevel(cwd = process.cwd()) {
   return null;
 }
 
-/** Mirror bin/tmct.mjs's configFor: an explicit repo pins the artifact path; no
- *  repo falls back to the cwd/env-derived default. */
-function configFor(repoPath) {
-  return repoPath ? { graphFile: join(repoPath, DEFAULT_GRAPH_REL) } : loadConfig();
-}
-
 /** Resolve a free-text term to a single graph entity via the ask engine's own
  *  tiered resolver — {id,label} on a UNIQUE hit, null on a miss/ambiguity/no graph.
  *  Lazy + failure-tolerated (see the file docblock): the worst case is a turn that
@@ -3305,9 +3566,11 @@ export async function helpText() {
   let shapes;
   try { const { rephraseHint } = await import("./ask.mjs"); shapes = rephraseHint(); }
   catch {
-    shapes = '"which <functions|classes|modules> <import|call|use|test|touch> <name>", ' +
+    // "touch" dropped from this cross-product for the same reason rephraseHint() drops it
+    // (ask.mjs) — Module/Function/Class is never the subject of a touch edge, only Commit.
+    shapes = '"which <functions|classes|modules> <import|call|use|test> <name>", ' +
       '"what does <name> <import|export>", "what uses <name>", "where is <name> defined", ' +
-      '"when did <name> change"';
+      '"when did <name> change", "which commits touched <name>"';
   }
   return [
     "commands:", ...lines, "",
@@ -3642,6 +3905,21 @@ function factTermVariants(normFactTerm, term) {
   return v;
 }
 
+/** Try `prove(subj, obj)` over every (subject variant × object variant)
+ *  combination, returning the first truthy witness or null — the small
+ *  shared search the two cardinality readers below both need (a taught
+ *  restriction's subject/onClass are singular, but a queried term may be
+ *  spelled slightly differently, e.g. pluralized). */
+function findAcrossVariants(subjVariants, objVariants, prove) {
+  for (const subj of subjVariants) {
+    for (const obj of objVariants) {
+      const w = prove(subj, obj);
+      if (w) return w;
+    }
+  }
+  return null;
+}
+
 /** GENERIC "kind" nouns a taught subject's head word is often built from
  *  ("logger MODULE", "task CONTROLLER") — excluded from the head-word
  *  overlap fallback both KNOW_ABOUT_RE's "what do you know about X" listing
@@ -3835,6 +4113,21 @@ const RECURSIVE_LIST_ASK_RE = /^list\s+(?:the\s+|all\s+)?([a-z][\w-]*)\s+of\s+([
  *  doesn't parse; checked against the isa-family fact predicates only. */
 const ISA_ASK_RE = /^(?:is|are)\s+(?:an?\s+)?(.+?)\s+(?:a\s+kind\s+of|a\s+type\s+of|an?)\s+(.+?)[?.!\s]*$/i;
 const ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
+
+// Live-caught 2026-07-11 (follow-up to the "what is a kind of X" ambiguousParse
+// fix, commit 5c858bf): RELATION_FACT_YESNO_RE/RELATION_WHO_ASK_RE both capture a
+// middle "role" word and treat it as an arbitrary user-taught relation/rule NAME
+// ("is X the father of Y", "who is the capital of Y") — but "kind"/"sort"/"type"/
+// "subclass"/"superclass" are this file's OWN vocabulary for the ISA/inherits
+// relation, never a name a user could have taught a relation under. Left
+// unexcluded, "what is a kind of animal" (once envelope/parse issues that used to
+// mask this were fixed) reached RELATION_WHO_ASK_RE first and produced a false "I
+// don't know a relation or rule called 'kind' yet" — inherits IS known, there's
+// just no fact making anything a kind of that particular object (a case (b5)
+// above already handles correctly, or ELSE whatever answer already stands —
+// a code-graph-specific miss, a relation-force glossary explanation — should be
+// left alone, never overridden by this generic reader).
+const ISA_IDIOM_ROLE_WORDS = new Set(["kind", "sort", "type", "subclass", "superclass"]);
 /** "so john is a man now right?" / "john is a man, right?" — a DECLARATIVE
  *  statement wrapped in a confirmation-check tag ("now right?"/"right?"/
  *  "correct?"), found live (playtest sprint round 1, 2026-07-10) after a
@@ -3861,6 +4154,55 @@ const KNOW_ABOUT_RE = /^(?:what\s+do\s+you\s+know\s+about|what(?:'s|s|\s+is)\s+i
 /** How many facts a single answer lists before the remainder is paged with "more". */
 const FACT_ANSWER_CAP = 32;
 
+/** Finding 5 (PLAN_CONVERSATION.md) — four sibling readers closing the gap left
+ *  by ISA_ASK_RE's own family: forward yes/no and reverse-by-object shapes for
+ *  `mgx:capableOf`, `mgx:hasA`, and the ISA-family predicates. None of these
+ *  four leads ("can"/"could", "what can … do", "what has", "what inherit(s)")
+ *  overlaps KNOW_ABOUT_RE's fixed leads above, or RELATION_FACT_YESNO_RE/
+ *  RELATION_WHO_ASK_RE's required leading "is/are/was/were" (those two live in
+ *  the separate factReadBack, only ever reached via `factAnswer(...) ??
+ *  factReadBack(...)` — never both). */
+const CAN_ASK_RE = /^(?:can|could)\s+(?:an?\s+)?([\w'-]+(?:\s+[\w'-]+)*?)\s+([a-z]+)[?.!\s]*$/i;
+const WHAT_CAN_DO_RE = /^what\s+can\s+(?:an?\s+)?(.+?)\s+do[?.!\s]*$/i;
+const WHAT_HAS_RE = /^what\s+has\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
+// Widened 2026-07-11 (live-caught follow-up to the ambiguousParse fix, commit
+// 5c858bf): on the FIRST turn of a graph-less session, dispatchTool's
+// loadGraph() throws its own documented "the graph is empty... this repo
+// starts with no graph" ToolError (src/server.mjs) — a pre-existing, by-design
+// bootstrap behavior (self-corrects from turn 2 on) — which leaves `envelope`
+// null for the rest of THIS turn's processing. The envelope.parsed branch just
+// below can't help on that turn, so this regex is the ONLY path available —
+// and it used to cover just "what inherits (from) X", never "what is a kind/
+// sort/type of X" or "what is a subclass of X", so those phrasings hit a wrong
+// "I don't know a relation or rule called 'kind'" answer (from a completely
+// different, unrelated reader downstream) specifically on a session's first
+// turn. Widened to match every phrasing ARTICLE_RELATION_CONTINUATIONS'
+// grammar-level fix already handles when envelope.parsed IS available.
+const WHAT_INHERITS_RE = /^what\s+(?:inherits?\s+(?:from\s+)?(?:an?\s+)?|is\s+(?:an?\s+)?(?:kind|sort|type)\s+of\s+|is\s+(?:an?\s+)?subclass\s+of\s+)(.+?)[?.!\s]*$/i;
+/** WHAT_HAS_RE guard: "what has changed (recently)" reads as a temporal/code
+ *  question, not a HasA lookup — checked against the captured phrase's FIRST
+ *  word only (a closed set, not a general heuristic). Verified live: nothing
+ *  today already answers this phrasing (it falls to an unrelated code-graph
+ *  miss), so this is a pure safety guard, not a behavior change. */
+const HAS_TEMPORAL_TAIL = new Set(["changed", "change", "changes", "updated", "modified", "happened", "occurred"]);
+
+/** Local reproduction of ask.mjs's private `uniqueById` dedup idiom (not
+ *  exported, so not importable across modules): collapse exact-repeat
+ *  (subject,predicate,object) triples while keeping every DISTINCT subject —
+ *  more than one subject can share the same object (e.g. car/bicycle/train
+ *  all `mgx:hasA` wheel). */
+function uniqueFacts(rows) {
+  const seen = new Set();
+  const out = [];
+  for (const f of rows) {
+    const key = `${f.subject}|${f.predicate}|${f.object}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(f);
+  }
+  return out;
+}
+
 /** W4 seam: answer (or extend) a vocabulary/definition question from the MEMORY
  *  graph's Facts. Returns { text, replace } — `replace:false` means the engine's
  *  own (schema-docs) answer stands and the fact lines are appended under it —
@@ -3879,7 +4221,17 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
   // OPTIONAL — see that regex's docblock for why this is safe to loosen here
   // even though the structural grammar's T5 keeps the article mandatory).
   let metaTerm = envelope?.parsed?.shape === "meta" ? envelope.parsed.object : null;
-  if (!metaTerm && miss && !envelope?.parsed) {
+  // Exclude "what is a kind/sort/type of X" / "what is a subclass of X" from this
+  // bare catch-all: on the FIRST turn of a graph-less session, dispatchTool's
+  // loadGraph() throws its own documented empty-graph ToolError (a pre-existing,
+  // by-design bootstrap behavior — self-corrects from turn 2 on), which leaves
+  // `envelope` null for the rest of the turn, arming this `!envelope?.parsed`
+  // fallback. Without this guard it greedily swallows the WHOLE "kind of animal"
+  // tail as a literal meta-term to define (mirroring grammar.mjs T5's OWN
+  // ARTICLE_RELATION_CONTINUATIONS guard against the identical over-capture),
+  // returning early and never letting (b5) below — which already handles this
+  // exact shape via WHAT_INHERITS_RE, envelope or no envelope — get a chance.
+  if (!metaTerm && miss && !envelope?.parsed && !WHAT_INHERITS_RE.test(q)) {
     const m = q.match(BARE_WHATIS_RE)
       || q.match(/^what\s+(?:does|do)\s+(.+?)\s+means?[?.!\s]*$/i);
     // Seonix Batch 2 Fix 3: strip a curated trailing scope clause ("… in this
@@ -3939,6 +4291,105 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
     return null; // no remembered fact — the honest miss stands (never a guessed "no")
   }
 
+  // (b2) "can a dog bark" — yes iff a remembered mgx:capableOf fact says so.
+  // Mirrors the ISA_ASK_RE block just above almost verbatim (same memoryFacts
+  // single-hit lookup, same "never a guessed no" discipline).
+  const can = q.match(CAN_ASK_RE);
+  if (can) {
+    const subj = factTermVariants(normFactTerm, can[1]);
+    const obj = factTermVariants(normFactTerm, can[2]);
+    const hit = (await memoryFacts(memoryDir)).find(
+      (f) => f.predicate === "mgx:capableOf" && subj.has(f.subject) && obj.has(f.object),
+    );
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    return null;
+  }
+
+  // (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.
+  const canDo = q.match(WHAT_CAN_DO_RE);
+  if (canDo) {
+    const variants = factTermVariants(normFactTerm, canDo[1]);
+    const hits = (await factRows(memoryDir)).filter((f) => f.predicate === "mgx:capableOf" && variants.has(f.subject));
+    if (!hits.length) return null;
+    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
+  // (e.g. car/bicycle/train all "have" a wheel). Guarded against shadowing
+  // "what has changed(recently)"-shaped inputs, which read as a temporal/
+  // code question, not a HasA lookup — see HAS_TEMPORAL_TAIL's own docblock.
+  const hasQ = q.match(WHAT_HAS_RE);
+  if (hasQ && !HAS_TEMPORAL_TAIL.has(hasQ[1].trim().split(/\s+/)[0]?.toLowerCase())) {
+    const variants = factTermVariants(normFactTerm, hasQ[1]);
+    const hits = (await factRows(memoryDir)).filter((f) => f.predicate === "mgx:hasA" && variants.has(f.object));
+    if (!hits.length) return null;
+    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" } } : {}) };
+  }
+  // hasQ matched but shadowed a temporal-tail phrase ("what has changed…") —
+  // deliberately falls through to the next reader below (never returns here),
+  // leaving whatever already handles that phrasing today untouched.
+
+  // (b5) "what inherits from horse" — the reverse-by-object mirror of (b4),
+  // over the ISA-family predicates instead of mgx:hasA. No temporal-style
+  // guard needed: "inherits" has no competing common-English reading.
+  //
+  // "what is a kind of X" / "what is a subclass of X" (2026-07-11 follow-up,
+  // live-repro: "boney is a dog" -> "what is a dog" -> "what is a kind of
+  // animal" hit a wrong "I don't know a relation or rule called 'kind'"
+  // answer). Fixing the parse-level {ambiguousParse} tie between this and a
+  // spurious "meta" reading (grammar.mjs T5, ARTICLE_RELATION_CONTINUATIONS)
+  // means `envelope.parsed` now cleanly carries {shape:"reverse",
+  // kind:"inherits", object:"animal"} for this phrasing too — but WHAT_INHERITS_RE
+  // is a FIXED regex ("what inherits (from) X") that never matched it, so this
+  // block used to fall through to null and let factReadBack's RELATION_WHO_ASK_RE
+  // misread "kind"/"subclass" as a relation NAME instead. Reading the ALREADY-
+  // PARSED envelope directly (any phrasing the grammar recognizes as this exact
+  // shape, not just WHAT_INHERITS_RE's one hardcoded surface form) fixes this
+  // generally; the regex match is kept as a fallback for a parse the envelope
+  // doesn't carry (e.g. no envelope at all).
+  const inheritsQ = q.match(WHAT_INHERITS_RE);
+  const inheritsObj = (envelope?.parsed?.shape === "reverse" && envelope.parsed.kind === "inherits")
+    ? envelope.parsed.object
+    : inheritsQ?.[1];
+  if (inheritsObj) {
+    const variants = factTermVariants(normFactTerm, inheritsObj);
+    const hits = (await factRows(memoryDir)).filter((f) => ISA_PREDICATES.has(f.predicate) && variants.has(f.object));
+    // Only diverts on a REAL hit — same discipline every other reader in this
+    // cascade follows (CAN_ASK_RE/WHAT_CAN_DO_RE/WHAT_HAS_RE above all `return
+    // null` on zero hits too). A zero-hit case here must NOT invent its own
+    // override text: whatever answer already stands (a code-graph-specific miss
+    // from ask.mjs's own traversal, a glossary/relation-force explanation, or the
+    // generic wall) is left alone. The real fix for the "I don't know a relation
+    // or rule called 'kind' yet" false claim (Live-caught 2026-07-11 follow-up to
+    // the "what is a kind of X" ambiguousParse fix, commit 5c858bf) lives at
+    // RELATION_WHO_ASK_RE's own handler in factReadBack, below — it excludes ISA-
+    // idiom words ("kind"/"sort"/"type"/"subclass"/"superclass") from being
+    // treated as arbitrary unknown relation NAMES, since they're not names a user
+    // could have taught a relation under; they're this file's own vocabulary for
+    // the inherits relation, always "known" by construction.
+    if (!hits.length) return null;
+    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" } } : {}) };
+  }
+
   // (c) "what do you know about caches" — everything remembered that MENTIONS the
   // term (subject or object), capped.
   const know = q.match(KNOW_ABOUT_RE);
@@ -4124,8 +4575,9 @@ async function whatElseAnswer(memoryDir, query, last) {
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const variants = factTermVariants(normFactTerm, term);
   const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject));
+  const picture = pickPhrase("full-picture", term.toLowerCase(), "the full picture");
   const nothingMore = {
-    text: `That's everything I know about "${term}" — /memory to see the full picture.`,
+    text: `That's everything I know about "${term}" — /memory to see ${picture}.`,
     replace: true,
   };
   if (!hits.length) return nothingMore;
@@ -4135,8 +4587,9 @@ async function whatElseAnswer(memoryDir, query, last) {
   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 lead = pickPhrase("beyond-that-lead", term.toLowerCase(), "Beyond that,");
   return {
-    text: `Beyond that, here's what else I know about "${term}":\n${shown.join("\n")}${extra}`,
+    text: `${lead} here's what else I know about "${term}":\n${shown.join("\n")}${extra}`,
     replace: true,
     ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}),
   };
@@ -4183,6 +4636,26 @@ const TOLD_ABOUT_RE = /^what\s+(?:did|have)\s+(?:i|we|you)\s+(?:told|tell|said|s
 /** "what kind of thing is an X" — the subject-side membership phrasing the grammar
  *  doesn't parse: reports X's OWN remembered type (falling back to X's members). */
 const KIND_OF_RE = /^what\s+kind\s+of\s+(?:thing|class|type|category|entity)?\s*(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
+/** "does every <N1> have at least <m> <N2>" — cardinality monotonicity
+ *  (PLAN_INFERENCE_TESTING.md INF-C1, this build): a class's OWN declared
+ *  exactly/min cardinality restriction proves "at least m" for any queried
+ *  m <= n (src/syllogise.mjs's proveCardinalityAtLeast). */
+const CARD_AT_LEAST_ASK_RE = /^does\s+every\s+(.+?)\s+have\s+at\s+least\s+(\d+)\s+(.+?)[?.!\s]*$/i;
+/** "does a/an <N1> have a/an <N2>" — cax-maxc0 (this build): a declared
+ *  max-cardinality-0 restriction proves the class-level "no" directly
+ *  (src/syllogise.mjs's proveMaxCardinalityZeroDenial). Both readers FALL
+ *  THROUGH ON A MISS (no unconditional decline, unlike isaAsk's own closing
+ *  `return null`): "does SUBJ have OBJ" is broad enough to otherwise collide
+ *  with GENERAL_VERB_YESNO_RE below and a pre-existing "3 unclear max0 cases"
+ *  quirk (HANDOVER.md) — a miss here simply lets the query continue to
+ *  whatever would have handled it before this build existed. */
+const CARD_EXISTENCE_ASK_RE = /^does\s+an?\s+(.+?)\s+have\s+an?\s+(.+?)[?.!\s]*$/i;
+/** The 4 pattern-5 cardinality-restriction predicates buildCardinalityRestrictions
+ *  reconstructs from — owl:onProperty (shared scaffolding with someValuesFrom
+ *  restrictions too) is added alongside this set by each reader below, not
+ *  folded into it here, mirroring infbench/grade.mjs's own identically-named
+ *  set + separate owl:onProperty handling. */
+const CARDINALITY_ROW_PREDICATES = new Set(["owl:cardinality", "owl:minCardinality", "owl:maxCardinality", "owl:onClass"]);
 /** "who owns <X>" / "who maintains <X>" — the closed ownership read-back over
  *  the teach lane's mgx:ownedBy facts. */
 const WHO_OWNS_RE = /^who\s+(?:owns|maintains)\s+(.+?)[?.!\s]*$/i;
@@ -4335,6 +4808,31 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const q = String(query).trim();
+  // DIRECT STRUCTURAL CHECK (playtest sprint round 2, this session): "is X a Y"
+  // naming a real code-graph inheritance edge needs NO taught fact at all — the
+  // graph's own `inherits` relation already proves it. Checked here, BEFORE the
+  // `rows.length` bail-out just below, because a pristine graph with ZERO taught
+  // facts returns null from that bail-out and never reaches ISA_ASK_RE's own
+  // taught-fact-only checks further down in this function at all. Found live:
+  // "is TaskController a Controller" (a direct one-hop inherits edge) and "is
+  // Task a Record" both hit the raw grammar wall on a freshly loaded graph with
+  // nothing taught yet — even in the wall's OWN suggested phrasing ("is a
+  // <thing> a <kind>"), and even though "what does Task inherit from" answers
+  // "Record" via the exact same relation. Cheapest and most certain check
+  // available: purely the graph's own relations, no memory/rows dependency,
+  // never a guess.
+  if (graph) {
+    const directIsaAsk = q.match(ISA_ASK_RE);
+    if (directIsaAsk) {
+      const ent = await resolveEntity(graph, directIsaAsk[1]);
+      if (ent) {
+        const directObjVariants = factTermVariants(normFactTerm, stripTrailingDiscourseTag(directIsaAsk[2]));
+        const directSup = inheritsChain(graph, ent.id)
+          .find((sup) => [...factTermVariants(normFactTerm, sup.label)].some((v) => directObjVariants.has(v)));
+        if (directSup) return { text: `yes — the code graph says ${ent.label} inherits ${directSup.label}.`, replace: true };
+      }
+    }
+  }
   // Tier-5 playtest fix (cycle 4), found live: "actually is the store module
   // fragile" WALLED — a leading hedge adverb ("actually"/"really"/"honestly",
   // optionally comma'd) put the sentence one word out of alignment with
@@ -4472,7 +4970,7 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     const subject = IS_ADJECTIVE_PRONOUN_RE.test(rawSubject) ? (focusLabel || null) : rawSubject;
     const relationName = relAsk[2].trim().toLowerCase();
     const object = relAsk[3].trim();
-    if (subject) {
+    if (subject && !ISA_IDIOM_ROLE_WORDS.has(relationName)) {
       const isTaughtRow = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
       const aliasSubClassEdges = rows
         .filter((f) => f.predicate === SUBCLASS_PREDICATE && isTaughtRow(f))
@@ -4572,7 +5070,7 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     const relationName = whoAsk[1].trim().toLowerCase();
     const rawObject = whoAsk[2].trim();
     const object = IS_ADJECTIVE_PRONOUN_RE.test(rawObject) ? (focusLabel || null) : rawObject;
-    if (object) {
+    if (object && !ISA_IDIOM_ROLE_WORDS.has(relationName)) {
       const isTaughtRow = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
       const aliasSubClassEdges = rows
         .filter((f) => f.predicate === SUBCLASS_PREDICATE && isTaughtRow(f))
@@ -4854,7 +5352,10 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     // (owl:onProperty/owl:someValuesFrom) and every property/type premise must
     // all be TAUGHT (never corpus-sourced), same as every other live chase in
     // this block.
-    const { deriveSomeValuesFromApplication, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE } = await import("./syllogise.mjs");
+    const {
+      deriveSomeValuesFromApplication, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE,
+      deriveSomeValuesFromSubsumption, ENTAILED_SCM_SVF_PROVENANCE, SCM_SVF_RULE_CONFIDENCE, entailedTrustFrom,
+    } = await import("./syllogise.mjs");
     const onPropertyRows = rows.filter((f) => f.predicate === ON_PROPERTY_PREDICATE && isTaught(f));
     const someValuesFromRows = rows.filter((f) => f.predicate === SOME_VALUES_FROM_PREDICATE && isTaught(f));
     if (onPropertyRows.length && someValuesFromRows.length) {
@@ -4881,10 +5382,178 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
           replace: true,
         };
       }
+      // LIVE scm-svf1 PROOF CHASE (PLAN_INFERENCE_TESTING.md INF-C1, this
+      // build; W3C OWL 2 RL Table 9's scm-svf1 — confirmed distinct from
+      // scm-svf2, which needs rdfs:subPropertyOf, which the ACE grammar can't
+      // teach at all — see src/syllogise.mjs's own header comment): every
+      // strategy above missed — two INDEPENDENTLY taught someValuesFrom
+      // restrictions sharing the SAME property, whose filler classes are
+      // themselves ⊑-related, license a restriction-to-restriction ⊑ fact
+      // (deriveSomeValuesFromSubsumption). Reuses the SAME restrictionEdges
+      // just built for cls-svf1 above — a SEPARATE findIsaChain call
+      // (maxHops: 3, one hop of headroom over the A2 chase's maxHops: 2)
+      // rather than folding into that earlier call, so INF-A2's pinned
+      // behavior is untouched.
+      const svfSubsumption = restrictionEdges.length > 1
+        ? deriveSomeValuesFromSubsumption(restrictionEdges, chainSubClassEdges, { budget: 10 })
+        : [];
+      if (svfSubsumption.length) {
+        const enlargedSubClassEdges = chainSubClassEdges.concat(svfSubsumption.map((d) => [d.subject, d.object]));
+        // Trust-hook gap fix (this session): the SAME `min(premiseTrusts) x
+        // ruleConfidence` discipline syllogise()'s own batch pass now applies
+        // to scm-svf1 (src/syllogise.mjs), computed here for this LIVE,
+        // read-only chase — each restriction's own onProperty/someValuesFrom
+        // scaffolding trust plus the y1⊑y2 subClassOf premise that licensed
+        // the comparison (always present, mirroring syllogise()'s own
+        // scmSvfDerived mapping). `restrictionByRid` looks a restriction's
+        // OWN (property, target) pair up by id — the same lookup
+        // syllogise()'s batch pass uses.
+        const restrictionByRid = new Map(restrictionEdges.map((r) => [r.restriction, r]));
+        const svfTrustByTriple = new Map();
+        for (const f of rows) svfTrustByTriple.set(`${f.subject}${f.predicate}${f.object}`, f.trust);
+        const svfPremiseTrust = (s, p, o) => svfTrustByTriple.get(`${s}${p}${o}`);
+        const svfTrustOf = new Map(); // "c1\0c2" -> computed trust, for the synthetic row below
+        for (const d of svfSubsumption) {
+          const r1 = restrictionByRid.get(d.subject);
+          const r2 = restrictionByRid.get(d.object);
+          const premiseTrusts = [
+            r1 && svfPremiseTrust(d.subject, ON_PROPERTY_PREDICATE, r1.property),
+            svfPremiseTrust(d.subject, SOME_VALUES_FROM_PREDICATE, d.viaY1),
+            r2 && svfPremiseTrust(d.object, ON_PROPERTY_PREDICATE, r2.property),
+            svfPremiseTrust(d.object, SOME_VALUES_FROM_PREDICATE, d.viaY2),
+            svfPremiseTrust(d.viaY1, SC_PREDICATE, d.viaY2),
+          ].filter((t) => typeof t === "number");
+          const t = entailedTrustFrom(premiseTrusts, SCM_SVF_RULE_CONFIDENCE);
+          if (t !== null) svfTrustOf.set(`${d.subject}${d.object}`, t);
+        }
+        // A derived restriction⊑restriction edge has no underlying stored
+        // Fact row to cite (it's a schema-level conclusion, not a taught
+        // sentence) — falls back to a SYNTHETIC row carrying scm-svf1's own
+        // entailed provenance + its own computed trust, so renderIsaChain's
+        // citation still names the real (low-trust, non-taught) source
+        // honestly, same discipline as every "entailed:*" provenance tag
+        // elsewhere in this file.
+        const factForStepOrSvf = (step) => {
+          if (step.predicate !== SC_PREDICATE) return chainTypeRows.find((f) => f.subject === step.subject && f.object === step.object);
+          const stated = chainSubClassRows.find((f) => f.subject === step.subject && f.object === step.object);
+          if (stated) return stated;
+          const derived = svfSubsumption.find((d) => d.subject === step.subject && d.object === step.object);
+          return derived
+            ? {
+              subject: derived.subject, predicate: SC_PREDICATE, object: derived.object, provenance: ENTAILED_SCM_SVF_PROVENANCE,
+              trust: svfTrustOf.get(`${derived.subject}${derived.object}`),
+            }
+            : undefined;
+        };
+        for (const subj of subjCandidates) {
+          const chain = findIsaChain(subj, objVariants, chainTypeEdges, enlargedSubClassEdges, { maxHops: 3 });
+          if (!chain) continue;
+          const premises = chain.map(factForStepOrSvf);
+          if (premises.every(Boolean)) {
+            // The WHOLE chain's own trust is the weakest link across every step
+            // (each step's own trust, including the synthetic scm-svf1 step's
+            // already-discounted figure computed above) — no further
+            // ruleConfidence discount at this outer level; it is already
+            // baked into whichever step was entailed rather than taught.
+            const chainTrust = entailedTrustFrom(premises.map((p) => p.trust), 1);
+            return { text: `yes — ${renderIsaChain(premises)}`, replace: true, ...(chainTrust !== null ? { trust: chainTrust } : {}) };
+          }
+        }
+      }
     }
     return null; // no remembered fact — the honest miss stands (never a guessed "no")
   }
 
+  // (a1c-i) CARDINALITY MONOTONICITY — "does every X have at least N Y" over
+  // a TAUGHT exactly/min cardinality restriction (PLAN_INFERENCE_TESTING.md
+  // INF-C1, this build; pattern-5, src/grammar/ace.mjs's parseCardinality).
+  // FALLS THROUGH ON A MISS (see CARD_AT_LEAST_ASK_RE's own doc comment) —
+  // never an unconditional decline, unlike isaAsk's own closing `return null`.
+  const cardAtLeast = q.match(CARD_AT_LEAST_ASK_RE);
+  if (cardAtLeast) {
+    const [, subjRaw, mRaw, objRaw] = cardAtLeast;
+    const {
+      SUBCLASS_PREDICATE: CARD_SC_PREDICATE, ON_PROPERTY_PREDICATE: CARD_ON_PROPERTY_PREDICATE,
+      buildCardinalityRestrictions, proveCardinalityAtLeast, CARDINALITY_RULE_CONFIDENCE, entailedTrustFrom,
+    } = await import("./syllogise.mjs");
+    const isTaughtCard = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
+    const cardSubClassEdges = isa.filter((f) => f.predicate === CARD_SC_PREDICATE && isTaughtCard(f)).map((f) => [f.subject, f.object]);
+    const cardRows = rows.filter((f) => (f.predicate === CARD_ON_PROPERTY_PREDICATE || CARDINALITY_ROW_PREDICATES.has(f.predicate)) && isTaughtCard(f));
+    const cardinalityRestrictionEdges = buildCardinalityRestrictions(cardRows);
+    if (cardinalityRestrictionEdges.length) {
+      const subjVariants = factTermVariants(normFactTerm, subjRaw.trim());
+      const objVariants = factTermVariants(normFactTerm, objRaw.trim());
+      const m = Number(mRaw);
+      const witness = findAcrossVariants(subjVariants, objVariants, (s, o) => proveCardinalityAtLeast(cardSubClassEdges, cardinalityRestrictionEdges, s, o, m, {}));
+      if (witness) {
+        const restrictionFact = rows.find((f) => f.predicate === CARD_SC_PREDICATE && f.subject === witness.viaClass && f.object === witness.viaRestriction);
+        const cite = restrictionFact?.provenance ? ` (source: ${restrictionFact.provenance})` : "";
+        const kindWord = witness.kind === "exactly" ? "exactly" : "at least";
+        const plural = (w, n) => `${w}${n === 1 ? "" : "s"}`;
+        // Trust-hook gap fix (this session): premise-derived trust for THIS
+        // rule's answer (src/syllogise.mjs's CARDINALITY_RULE_CONFIDENCE doc
+        // comment explains why there is no persisted Fact for it to attach
+        // to) — the restriction's OWN scaffolding rows (onProperty/kind/
+        // onClass, all keyed to witness.viaRestriction), the declaring
+        // subClassOf edge, and (when this is a ⊑-lift) the one-hop premise
+        // from the actually-queried subject up to viaClass.
+        const cardPremiseTrusts = [
+          restrictionFact?.trust,
+          ...cardRows.filter((f) => f.subject === witness.viaRestriction).map((f) => f.trust),
+          ...(witness.viaClass !== witness.subject
+            ? [isa.find((f) => f.predicate === CARD_SC_PREDICATE && f.subject === witness.subject && f.object === witness.viaClass)?.trust]
+            : []),
+        ].filter((t) => typeof t === "number");
+        const trust = entailedTrustFrom(cardPremiseTrusts, CARDINALITY_RULE_CONFIDENCE);
+        return {
+          text: `yes — every ${witness.viaClass} has ${kindWord} ${witness.n} ${plural(witness.object, witness.n)}${cite}, so at least ${m} follows.`,
+          replace: true,
+          ...(trust !== null ? { trust } : {}),
+        };
+      }
+    }
+    // falls through — no witnessing restriction (or none declared at all)
+  }
+
+  // (a1c-ii) cax-maxc0 — "does a/an X have a/an Y" over a TAUGHT
+  // max-cardinality-0 restriction (PLAN_INFERENCE_TESTING.md INF-C1, this
+  // build). NEVER infers "no" from absence, matching cax-dw's own discipline
+  // above — a miss here FALLS THROUGH too (see CARD_EXISTENCE_ASK_RE's own
+  // doc comment).
+  const cardExistence = q.match(CARD_EXISTENCE_ASK_RE);
+  if (cardExistence) {
+    const [, subjRaw, objRaw] = cardExistence;
+    const {
+      SUBCLASS_PREDICATE: CARD_SC_PREDICATE, ON_PROPERTY_PREDICATE: CARD_ON_PROPERTY_PREDICATE,
+      buildCardinalityRestrictions, proveMaxCardinalityZeroDenial, CAX_MAXC0_RULE_CONFIDENCE, entailedTrustFrom,
+    } = await import("./syllogise.mjs");
+    const isTaughtCard = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
+    const cardSubClassEdges = isa.filter((f) => f.predicate === CARD_SC_PREDICATE && isTaughtCard(f)).map((f) => [f.subject, f.object]);
+    const cardRows = rows.filter((f) => (f.predicate === CARD_ON_PROPERTY_PREDICATE || CARDINALITY_ROW_PREDICATES.has(f.predicate)) && isTaughtCard(f));
+    const cardinalityRestrictionEdges = buildCardinalityRestrictions(cardRows);
+    if (cardinalityRestrictionEdges.length) {
+      const subjVariants = factTermVariants(normFactTerm, subjRaw.trim());
+      const objVariants = factTermVariants(normFactTerm, objRaw.trim());
+      const witness = findAcrossVariants(subjVariants, objVariants, (s, o) => proveMaxCardinalityZeroDenial(cardSubClassEdges, cardinalityRestrictionEdges, s, o, {}));
+      if (witness) {
+        const restrictionFact = rows.find((f) => f.predicate === CARD_SC_PREDICATE && f.subject === witness.viaClass && f.object === witness.viaRestriction);
+        const cite = restrictionFact?.provenance ? ` (source: ${restrictionFact.provenance})` : "";
+        // Trust-hook gap fix (this session) — same discipline as the
+        // cardinality-monotonicity reader just above (see its own comment).
+        const cardPremiseTrusts = [
+          restrictionFact?.trust,
+          ...cardRows.filter((f) => f.subject === witness.viaRestriction).map((f) => f.trust),
+          ...(witness.viaClass !== witness.subject
+            ? [isa.find((f) => f.predicate === CARD_SC_PREDICATE && f.subject === witness.subject && f.object === witness.viaClass)?.trust]
+            : []),
+        ].filter((t) => typeof t === "number");
+        const trust = entailedTrustFrom(cardPremiseTrusts, CAX_MAXC0_RULE_CONFIDENCE);
+        return { text: `no — every ${witness.viaClass} has at most 0 ${witness.object}${cite}.`, replace: true, ...(trust !== null ? { trust } : {}) };
+      }
+    }
+    // falls through — no witnessing restriction (or none declared at all)
+  }
+
   // (a2) OWNERSHIP read-back — "who owns/maintains <X>": the teach lane's
   // mgx:ownedBy facts about X, trust-ranked, each cited (the source receipt
   // stays in the render). No fact → null, the honest miss stands.
@@ -5163,12 +5832,28 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   // it as meta). "what is a Y" reports Y's MEMBERS (object-side); "what kind of
   // thing is an X" reports X's own TYPE (subject-side first), so both directions
   // of a single remembered "X is a kind of Y" are queryable.
+  //
+  // Bug found live this session (PLAN_CONVERSATION.md verification, Finding 1):
+  // this branch exists specifically to catch the bare, no-article "what is X"
+  // shape the grammar's own T5 template DECLINES to parse for a non-ENTITY_TO_TYPE
+  // term (grammar.mjs's own closed-set gate on the bare form) — envelope.parsed
+  // stays null for exactly this case, which is this branch's own trigger
+  // condition. But the regex required a MANDATORY article ("an?" with no "?"),
+  // the opposite of BARE_WHATIS_RE's own already-established "article optional"
+  // convention (chat.mjs:5777, used one function up in this same cascade) — so
+  // this branch could never actually fire for the bare form it exists to catch.
+  // "every cache is a florble" / "what is florble" (no article) and "cheese is
+  // blue" / "what is blue" (no article) both silently fell through to the
+  // generic orientation card as a result, even though "what is a florble"/
+  // "what is a blue" (WITH the article) correctly found the reverse fact.
+  // Matching BARE_WHATIS_RE's own optional-article group fixes this at the
+  // root, for every term alike (not a term/lexicon-specific asymmetry at all).
   let term = envelope?.parsed?.shape === "meta" ? envelope.parsed.object : null;
   let kindOf = false;
   const mk = q.match(KIND_OF_RE);
   if (mk) { term = mk[1]; kindOf = true; }
   else if (!term && !envelope?.parsed) {
-    const m = q.match(/^what\s+(?:is|are)\s+an?\s+(.+?)[?.!\s]*$/i);
+    const m = q.match(/^what\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i);
     if (m) term = m[1];
   }
   if (!term) return null;
@@ -5392,6 +6077,29 @@ function superlativeRepeatRewrite(query, last) {
   return prevQ;
 }
 
+/** EXISTENTIAL "is there anything/something/anyone/anybody that/which/who
+ *  <verb-phrase>" -> "what <verb-phrase>". Round 2 playtest (2026-07-11):
+ *  parseExistence (ask.mjs) correctly DECLINES this shape — "anything" is a
+ *  placeholder, not a real entity-kind noun, so it rightly leaves a relative-
+ *  clause verb-phrase for the relation parsers below. But those parsers then
+ *  treat the ELIDED subject as an ANAPHORA continuation (reusing the standing
+ *  focus) instead of recognizing "anything that <verb> X" as the SAME open
+ *  reverse-lookup "is anything <verb-ing> X" already answers correctly
+ *  ("test/tasks.test.mjs."). Live finding: "is there anything that tests
+ *  Task", asked right after focus had landed on UserController, answered "No
+ *  — no tests edge found from UserController to Task" — a confidently WRONG
+ *  answer (worse than a miss), not the real answer. A closed textual rewrite
+ *  onto the ALREADY-CORRECT "what <verb> X" shape sidesteps the AST-shape
+ *  work entirely: no new capability, just aiming an existing one (the
+ *  reverse-relation lookup "what tests X"/"who calls X") at input that means
+ *  the same thing. Applied UNCONDITIONALLY (no `last` dependency, unlike
+ *  discourseRewrite) — this shape carries its own complete meaning. */
+const EXISTENTIAL_ANYTHING_RE = /^is\s+there\s+(?:anything|something|anyone|anybody)\s+(?:that|which|who)\s+(.+?)\s*\??$/i;
+function existentialAnythingRewrite(query) {
+  const m = EXISTENTIAL_ANYTHING_RE.exec(String(query || "").trim());
+  return m ? `what ${m[1].trim()}` : null;
+}
+
 // ---- curated SEON definitions (corpus/seon/definitions.jsonl) ----
 // A "what is a <term>" for a LEXICON term prefers the curated one-sentence
 // definition — the richer surface form of the same curated SEON knowledge that the
@@ -5798,7 +6506,16 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
   // and broke DESCRIBE_WRAPPER_RE's own anchor. applyPreambleFrames is the same
   // general-purpose, closed, idempotent pass every other lane in this file
   // already runs first.
-  const q = applyPreambleFrames(String(query || "").trim());
+  // BENCHMARK_CONVERSATION_1.7.0.md routed backlog C3 ("wat about store.mjs"):
+  // this lane's own DESCRIBE_WRAPPER_RE anchors on a literal "what about"/
+  // "describe"/"tell me about" — a curated typo of one of those anchor words
+  // ("wat" for "what") never matched, so the whole lane silently declined even
+  // though "wat" is already a curated MISSPELLINGS entry everywhere else.
+  // correctMisspellings runs FIRST, same order chat.mjs's other normalization
+  // call sites use (e.g. the module-orient lane above), so the anchor match
+  // sees the corrected text; a genuinely uncurated typo still declines here,
+  // same honest-miss behavior as before.
+  const q = applyPreambleFrames(correctMisspellings(String(query || "").trim()));
   const m = DESCRIBE_WRAPPER_RE.exec(q) || STACCATO_PRONOUN_RE.exec(q);
   let term = m?.[1]?.trim();
   if (!term) return null;
@@ -5810,6 +6527,14 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
   // branches never leave this residue, so this can only ever help the doubled-
   // verb case, never change a correctly-captured term.
   term = term.replace(/^about\s+/i, "");
+  // Round 1 playtest fix (2026-07-11): a trailing bare discourse tag ("describe
+  // Record then", "tell me about Record then") glued onto the captured term,
+  // same class of bug HANDOVER.md 2026-07-10 item 8 already fixed for the
+  // meta-whatis vocab lane (stripTrailingDiscourseTag, ask-vocab.mjs) — this
+  // lane never got the same treatment, so "Record then" failed to resolve as
+  // any real symbol even though "Record" alone (a real entity just discussed)
+  // resolves cleanly.
+  term = stripTrailingDiscourseTag(term);
   if (DESCRIBE_PRONOUN_RE.test(term)) {
     if (!focus?.label) return null; // no standing focus to resolve against — honest decline
     term = focus.label;
@@ -5831,7 +6556,18 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
   }
   try {
     const text = await dispatchTool("tmct_describe", { symbol: term }, { config, source, tel });
-    return text ? { text } : null;
+    if (!text) return null;
+    // Playtest sprint round 1 (2026-07-11): this rescue resolves and confidently
+    // describes a real entity ("tell me more about Task"), but until now returned
+    // only `text` — the resolved entity never reached the caller, so the session's
+    // focus was never updated. The VERY NEXT natural follow-up ("what calls it",
+    // "where's that defined") then dead-ended on "'it' needs a selected node to
+    // refer to" right after the engine had just named one — the exact anaphora
+    // this project's own playtest discipline requires to carry (SKILL_BENCHMARK_
+    // CONVERSATION.md §1b). Mirrors the object-resolution/superlative-winner focus
+    // updates already done for the ordinary ask() path just above this function.
+    const ent = await resolveEntity(graph, term);
+    return { text, ent };
   } catch {
     return null; // unresolvable term — decline, the ordinary wall stands unchanged
   }
@@ -6025,6 +6761,41 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
   return { text, instances: composed.instances, allIds: composed.allInstanceIds, pending };
 }
 
+/** C2 rescue (BENCHMARK_CONVERSATION_1.7.0.md routed backlog): a matching-kind
+ *  individual explicitly NAMED in `answerText` — the SAME code-ish name tokens
+ *  discourseRewrite already trusts (NAME_TOKEN_RE: a path, a Capitalized
+ *  symbol, or lowerCamelCase), each tried in turn, resolved CLASS-FILTERED
+ *  (resolveObject's own `expectedClass` option — describeGrainRescue, above,
+ *  uses the same convention) so only a genuine same-kind hit counts, never a
+ *  same-text-different-kind coincidence. First unambiguous hit wins; null when
+ *  nothing of that class is named anywhere in the text (graph-less, empty
+ *  text, or no match all decline the same honest way). Used ONLY by runAsk's
+ *  pronoun-resolution kind-mismatch guard, below — never a general "search
+ *  the last answer" utility. */
+async function entityOfKindInText(graph, expectedClass, answerText) {
+  if (!graph || !expectedClass || !answerText) return null;
+  // "g" ONLY, never "gi" — NAME_TOKEN_RE's own case-SENSITIVITY is exactly
+  // what makes it a safe code-ish-token signal (a Capitalized symbol / a
+  // mid-word capital never occurs in plain English, per its own docblock
+  // above); adding "i" here would let ordinary lowercase prose words
+  // ("function", "is", "defined") spuriously match too (found live testing
+  // this fix — a bare lowercase word matched the lowerCamelCase branch under
+  // case-insensitivity, since [A-Z] there also accepts lowercase under /i).
+  const tokens = String(answerText).match(new RegExp(NAME_TOKEN_RE.source, "g")) || [];
+  const seen = new Set();
+  for (const tok of tokens) {
+    const key = tok.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    try {
+      const { resolveObject } = await import("./ask.mjs");
+      const r = resolveObject(graph, tok, { expectedClass });
+      if (r?.match?.id && !r.ambiguous) return { id: r.match.id, label: r.match.label };
+    } catch { /* tolerated — falls through to the next token */ }
+  }
+  return null;
+}
+
 /** A bare question → tmct_ask. When a focus is set AND the graph is in hand we
  *  call ask() directly to thread the focus as contextId (so a pronoun like "it"
  *  resolves to the focus) — building the SAME delimited string dispatchTool emits;
@@ -6047,7 +6818,8 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // The query the ENGINE parses: a "what about X" continuation is rewritten to the
   // prior shape with X swapped in; everything else parses verbatim. The record and
   // transcript keep the user's ACTUAL words (`query`), only the parse target changes.
-  let askQuery = superlativeRepeatRewrite(query, last) ?? discourseRewrite(query, last) ?? query;
+  let askQuery = superlativeRepeatRewrite(query, last) ?? discourseRewrite(query, last)
+    ?? existentialAnythingRewrite(query) ?? query;
   // IMPLICIT ANAPHORIC COUNT (Tier-2 playtest, 5th pass): "how many are tested" /
   // "and how many are tested" drops the "of those/them" a fuller phrasing carries
   // — ask()'s own anaphora node (parseAnaphora) already understands "how many of
@@ -6081,6 +6853,54 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       via: "recall", miss: !summary, focus,
     });
   }
+  // C2 fix (BENCHMARK_CONVERSATION_1.7.0.md routed backlog): an explicit
+  // "this file"/"that module" kind-noun scope signal is collapsed to a bare
+  // pronoun by normalize.mjs's KIND_NOUN_ANAPHORA_RE before ask() ever parses
+  // askQuery — so ask()'s own contextId-based pronoun resolution (just below)
+  // would otherwise silently bind "this"/"that" to the STANDING focus even
+  // when that focus is a narrower, different kind of thing than what was
+  // explicitly named. Repro: "where is it defined" resolves to a FILE and
+  // names it in the answer text; if the standing focus is still a Method,
+  // "what this file is importing" must mean the file just named, not the
+  // Method. Detected here via kindNounAnaphoraHint (a read-only probe of the
+  // SAME askQuery text — normalizeQuery's own collapse inside ask() is
+  // completely untouched) and rescued by swapping the CONTEXTID itself to a
+  // matching-kind individual the immediately PRECEDING turn's own answer
+  // already named — so the traversal ask() computes (not just the focus
+  // carried to the NEXT turn, below) reflects the explicit scope. Only
+  // diverts when the hint actively DISAGREES with the standing focus's real
+  // class; falls back to today's untouched behavior (the stale focus stands,
+  // or an honest miss) when nothing of the expected kind is named in the
+  // preceding answer, so an ordinary "it"/"this" with no kind noun at all is
+  // byte-identical to before this fix.
+  //
+  // Scoped tightly to expectedClass === "Module" ("this file"/"that file"/
+  // "this module"/"that module") ON PURPOSE, not every KIND_NOUN_ANAPHORA_RE
+  // kind: test/chatflow-tier1-single-touch.test.mjs's own T3 case ("which
+  // class contains Task.complete" -> "what else is in that class") pins the
+  // OPPOSITE behavior for "that class" — the standing Method focus (Task.
+  // complete) is deliberately reused there, by design, even though "class"
+  // names a different kind than Method too. "class"/"method"/"function"/
+  // "attribute"/"variable"/"commit" are all colloquially used to mean "the
+  // thing we were just discussing", which may genuinely BE the narrower
+  // standing focus (T3's own case). "file"/"module" is the one kind noun in
+  // this set that's never plausibly the SAME individual as a Method/
+  // Function/Class/Attribute/GlobalVariable focus — it's strictly a
+  // CONTAINER of them — so it alone is safe to treat as an unambiguous
+  // kind-mismatch signal without breaking that pinned case. Widening this
+  // beyond Module would need a real redesign (disambiguating "reuse the
+  // narrower focus" from "switch to the just-named container" in general);
+  // out of scope here — see the routed-backlog report for this session.
+  let effectiveContextId = focus?.id ?? null;
+  let kindRescueEnt = null;
+  if (graph && focus?.id) {
+    const expectedClass = kindNounAnaphoraHint(askQuery);
+    const focusClass = graph?.byId?.get(focus.id)?.class;
+    if (expectedClass === "Module" && focusClass && focusClass !== expectedClass) {
+      kindRescueEnt = await entityOfKindInText(graph, expectedClass, last?.answer);
+      if (kindRescueEnt?.id) effectiveContextId = kindRescueEnt.id;
+    }
+  }
   let answer;
   let envelope = null;
   try {
@@ -6091,7 +6911,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // `prev` for the anaphora node). Builds the SAME delimited envelope dispatchTool
       // emits, so the parse below is identical either way.
       const { ask } = await import("./ask.mjs");
-      const r = ask(graph, askQuery, { contextId: focus?.id ?? null, prev });
+      const r = ask(graph, askQuery, { contextId: effectiveContextId, prev });
       text = `${r.content}${ASK_ENVELOPE_DELIM}${JSON.stringify(r.tmct_ask, null, 2)}`;
     } else {
       text = await dispatchTool("tmct_ask", { query: askQuery }, { config, source, tel });
@@ -6171,7 +6991,21 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // this case (contextId was null); silently adopting a bogus focus as a side
     // effect here would corrupt the NEXT turn's pronoun into a confidently WRONG
     // (not just empty) answer, exactly as the connective leak did.
-    const ent = isPronoun(obj) ? (focus?.id ? focus : null) : await resolveEntity(graph, obj);
+    //
+    // C2 fix (BENCHMARK_CONVERSATION_1.7.0.md routed backlog): the blind
+    // focus-reuse above is exactly right when the pronoun carries no extra
+    // scope signal ("what does it import") — but "this file"/"that module"
+    // EXPLICITLY names a kind, and normalize.mjs's KIND_NOUN_ANAPHORA_RE
+    // already collapses it to the bare pronoun before either parse strategy
+    // ever sees it, discarding that signal. `kindRescueEnt` (computed ABOVE,
+    // before ask() ran, off the SAME askQuery text — see its own docblock)
+    // already carries the matching-kind individual the preceding turn's
+    // answer named, when the hint disagreed with the standing focus's class;
+    // reusing it here (rather than recomputing) keeps the focus this turn
+    // hands to the NEXT turn consistent with the traversal ask() actually
+    // ran. Null when there was no disagreement, or nothing rescuable was
+    // named — today's untouched behavior (reuse the focus / honest miss).
+    const ent = isPronoun(obj) ? (kindRescueEnt || (focus?.id ? focus : null)) : await resolveEntity(graph, obj);
     if (ent) {
       resolvedIds = [ent.id];
       // Class-gate the focus update: a Commit/Session/schema object never displaces a
@@ -6206,6 +7040,15 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   let via = "composed";
   let recordMiss = miss;
   let factPending = null; // a truncated fact listing's held remainder (for "more" paging)
+  // Trust-hook gap fix (this session): scm-svf1/cardinality-monotonicity/
+  // cax-maxc0's LIVE proof chases (factReadBack) have no persisted Fact to
+  // attach trust.mjs's entailed hook to (syllogise.mjs's own
+  // CARDINALITY_RULE_CONFIDENCE/CAX_MAXC0_RULE_CONFIDENCE doc comments explain
+  // why), so they compute `min(premiseTrusts) × ruleConfidence`
+  // (`entailedTrustFrom`) themselves and hand it back on the answer object —
+  // surfaced here onto the turn's own record (`record.entailedTrust` below)
+  // so it is audit-observable from a real chat turn, not silently discarded.
+  let entailedTrust = null;
   // GOAL DEDUCTION: from the parsed AST when one stood (deterministic, table-driven —
   // see deduceGoalFromParsed); a total grammar miss (no parse at all) gets the honest
   // "didn't resolve" goal line verbatim, matching the operator's own wording for that
@@ -6436,6 +7279,24 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       }
     }
   }
+  // (2c) BARE ENTITY NAME, NO VERB AT ALL (persona-sweep 2026-07-11, Priority
+  // 4): "task" / "usercontroller" — a bare, unadorned word naming a REAL
+  // class/function/method/global/attribute, with no "what is"/"describe"
+  // wrapper for bareWhatisShape/isAdjectiveShape (just above) to catch —
+  // isConversational()'s <=3-word catch-all claims it first, same race BUG 2
+  // fixed for "what is john" above, just one layer short of even a bare
+  // "what is". Reuses the SAME metaFallbackEntityAnswer lookup and the SAME
+  // "divert only on a REAL, UNIQUE hit" discipline: it only ever returns
+  // non-null for an EXACT case-insensitive Class/Function/Method/
+  // GlobalVariable/Attribute label match, so an ordinary greeting/small-talk
+  // word that doesn't happen to collide with a real graph entity name is
+  // completely unaffected — this can only ever ADD a real describe-style
+  // answer, never take one away or guess.
+  if (!bareMetaHit && isConversationalCandidate && graph) {
+    const { metaFallbackEntityAnswer } = await import("./ask.mjs");
+    const fallback = metaFallbackEntityAnswer(graph, String(query).trim());
+    if (fallback) bareMetaHit = { text: fallback.text, replace: true };
+  }
   if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
     via = "fact"; recordMiss = false; handled = true;
@@ -6482,6 +7343,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       via = "fact";
       recordMiss = false;
       if (fact.pending) factPending = fact.pending; // a truncated fact list → paginable remainder
+      if (typeof fact.trust === "number") entailedTrust = fact.trust; // scm-svf1/cardinality/cax-maxc0's live-chase trust (see the `entailedTrust` declaration above)
       note(trace, `lane: (3) memory facts — factAnswer/factReadBack matched (memoryDir=${memoryDir})`);
       note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
       // Goal-line fix (item 5 follow-up, this session): mirrors the TEACH lane's
@@ -6660,7 +7522,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // must never become a recallable answer. The opinion gate fires HERE, before the
   // short-miss's "is a <thing> a <kind>" membership hint could claim the line.
   if (miss && recordMiss && via === "composed") {
-    const nudged = nudgeAnswer(query, newFocus);
+    const nudged = nudgeAnswer(query, newFocus, vocabHint);
     if (nudged) {
       answer = nudged; via = "miss";
       note(trace, "lane: (4c) CAPABILITY NUDGE — the question asked tmct to do something outside its scope (opinion/generation/risk-scoring)");
@@ -6683,6 +7545,15 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       answer = described.text; via = "describe"; recordMiss = false;
       note(trace, "lane: (4d) DESCRIBE-WRAPPER RESCUE — a polite wrapper around \"describe/tell me about <symbol>\" resolved via /describe, tried last after every other lane declined");
       note(trace, "goal: get a symbol's definition/kind/relations (phrased conversationally)");
+      // Round 1 playtest fix: carry the resolved entity forward as the new focus,
+      // same class-gated nextFocus() every other resolution path here already uses
+      // — otherwise "what calls it" right after this answer dead-ends on "'it'
+      // needs a selected node to refer to" despite one having just been named.
+      if (described.ent) {
+        resolvedIds = [described.ent.id];
+        newFocus = nextFocus(graph, newFocus, described.ent);
+        note(trace, `result: describe-wrapper resolved "${query}" -> ${described.ent.label} (${described.ent.id}) — becomes the new focus`);
+      }
     }
   }
   // (4e) COMPLETIONS RESCUE (HANDOVER.md 2026-07-10 item 7) — wires src/completions/'s
@@ -6797,7 +7668,20 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // turn "asked about" (the SchemaClass meta-node is documentation, not a code entity),
   // so record + expand them, not the schema match.
   const finalAnsweredIds = conceptInstances ? conceptInstances.map((i) => i.id) : answeredIds;
-  const record = { type: "turn", ts, query, via, resolvedIds, answeredIds: finalAnsweredIds, miss: recordMiss };
+  const record = {
+    type: "turn", ts, query, via, resolvedIds, answeredIds: finalAnsweredIds, miss: recordMiss,
+    // PLAN_BREADTH_FIRST_NLU.md §Track 6 (operator directive): the canonical
+    // restatement of what the request was understood to mean — English gloss +
+    // machine-parsable notation — straight off ask.mjs's own `tmct_ask.canonical`
+    // (canonicalOf(parsed), §1's same `parsed` this whole ask-lane already
+    // carries). `null` only when nothing parsed at all (an honest grammar miss).
+    canonical: envelope?.canonical ?? null,
+    // premise-derived trust for a LIVE-CHASE-ONLY entailment answer (scm-svf1/
+    // cardinality-monotonicity/cax-maxc0 — see the `entailedTrust` declaration
+    // above); omitted entirely when this turn didn't answer via one of those,
+    // so every other turn's record shape stays byte-identical.
+    ...(entailedTrust !== null ? { entailedTrust } : {}),
+  };
   const logLines = [ts, `> ${query}`, answer, ""];
   // `detail` feeds why/say-more's verbose re-render: the traversal receipt + the
   // matched entities the terse render trims (see renderVerbose). `pending` carries a
@@ -6846,12 +7730,20 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
 
 /** A non-ask, non-dispatch chat turn (count answer, /stats) — the same
  *  { answer, logLines, record, focus } shape, recorded like any other turn. */
-function plainTurn(query, answer, { command, via = "composed", miss = false, focus = null } = {}) {
+function plainTurn(query, answer, { command, via = "composed", miss = false, focus = null, canonical = null } = {}) {
   const ts = new Date().toISOString();
   return {
     answer,
     logLines: [ts, `> ${query}`, answer, ""],
-    record: { type: "turn", ts, query, ...(command ? { command } : {}), via, resolvedIds: [], answeredIds: [], miss },
+    record: {
+      type: "turn", ts, query, ...(command ? { command } : {}), via, resolvedIds: [], answeredIds: [], miss,
+      // PLAN_BREADTH_FIRST_NLU.md §Track 6 (operator directive) — see runAsk's own
+      // `record.canonical` for the full doc; `null` here is the honest default for
+      // every non-ask/non-assert lane this shared helper serves (a bare command
+      // confirmation, an orientation card, a count) that hasn't been given a real
+      // structured form to restate yet.
+      canonical,
+    },
     focus,
   };
 }
@@ -7020,18 +7912,67 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
   return mk(answer);
 }
 
+/** Render an ambiguous assertTurn's response — Step 3 of
+ *  PLAN_DID_YOU_SEE_HER_DUCK.md's "handle ambiguity all the way to the
+ *  response": restate the operator's ask as canonical, disambiguated prose
+ *  FIRST, then present EVERY surviving reading's would-be triples, each
+ *  labeled by which token that reading reads as the verb — reusing the same
+ *  "${subject} ${predicate} ${object}" shape assertTurn's own confirmation
+ *  line already uses (below), and the same "this could mean more than one
+ *  thing" wording ask.mjs's OWN disambiguation surface uses for query-side
+ *  ambiguity (renderCore, src/ask.mjs), so the two never disagree in tone.
+ *  Nothing is written to memory here — an ambiguous sentence, unlike a
+ *  resolved one, has no single fact tmct can honestly commit to. */
+function renderAmbiguousAssert(line, ambiguous, normFactTerm) {
+  const options = ambiguous.readings.map((r, idx) => {
+    const shown = r.triples
+      .map((t) => `${normFactTerm(t.subject)} ${t.predicate} ${normFactTerm(t.object)}`)
+      .join("; ");
+    return `${idx + 1}) reading "${r.verbLemma}" as the verb: ${shown}`;
+  });
+  return [
+    `You asked: "${line}" — this could mean more than one thing:`,
+    ...options,
+    "Nothing was remembered yet — reply with the reading you meant (or rephrase) and I'll note it.",
+  ].join("\n");
+}
+
 /** A declarative ACE-grammar sentence → assert into memory + confirm; null on
  *  any grammar miss / residue / import failure so the query engine keeps first
  *  refusal on everything else. Lazy imports + catch-all: the grammar layer can
- *  never crash a turn (chat.mjs ethos). Writes ONLY under memoryDir/.tmct/memory. */
+ *  never crash a turn (chat.mjs ethos). Writes ONLY under memoryDir/.tmct/memory.
+ *
+ *  AMBIGUITY (Step 3, PLAN_DID_YOU_SEE_HER_DUCK.md): checked FIRST, via the
+ *  additive parseAceAmbiguous (grammar/ace.mjs) — a separate, breadth-first
+ *  scan that survives every verb-position split rather than committing to the
+ *  first, pruning only genuine dead ends. It returns null for the
+ *  overwhelming majority of sentences (anything not relation-shaped, or
+ *  relation-shaped with 0-1 surviving readings), so this adds exactly one
+ *  cheap check ahead of the EXISTING, unchanged parseAce path below — every
+ *  single-reading sentence renders byte-identically to before. */
 async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null }) {
   try {
-    const { parseAce } = await import("./grammar/ace.mjs");
+    const { parseAce, parseAceAmbiguous } = await import("./grammar/ace.mjs");
     // A session handle carries its own loaded lexicon (createSession loads it once);
     // a bare runTurn (no handle) lazy-loads the cached core lexicon. The lexicon is
     // immutable, so sharing one reference across concurrent handles is re-entrant.
     let lex = lexicon;
     if (!lex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); lex = loadLexicon(); }
+    const ambiguous = parseAceAmbiguous(line, lex);
+    if (ambiguous) {
+      const { normFactTerm } = await import("./memory/core.mjs");
+      const answer = renderAmbiguousAssert(line, ambiguous, normFactTerm);
+      // Genuinely ambiguous — no single triple was committed, so the canonical
+      // form is every surviving reading's own would-be triple set, same idiom
+      // as ask.mjs's canonicalOf() for a parse-level tie.
+      const canonical = {
+        english: ambiguous.readings.map((r) => `reading "${r.verbLemma}" as the verb`).join(" — or — "),
+        machine: ambiguous.readings.map((r) => r.triples
+          .map((t) => `fact(${JSON.stringify(normFactTerm(t.subject))}, ${JSON.stringify(t.predicate)}, ${JSON.stringify(normFactTerm(t.object))})`)
+          .join(", ")).join(" | "),
+      };
+      return plainTurn(line, answer, { command: "assert", via: "assert", focus, canonical });
+    }
     const parse = parseAce(line, lex);
     if (!parse || !parse.triples?.length || parse.residue?.length) return null;
     const { assertSentence } = await import("./grammar/assert.mjs");
@@ -7070,7 +8011,19 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null })
       .join("; ");
     const n = res.ids.length;
     const answer = `noted — remembered ${n} fact${n === 1 ? "" : "s"}: ${shown}`;
-    return plainTurn(line, answer, { command: "assert", via: "assert", focus });
+    // PLAN_BREADTH_FIRST_NLU.md §Track 6 (operator directive): the canonical
+    // restatement of what was committed — `english` reuses the SAME confirmation
+    // text just shown (already tmct's own preferred subject-predicate-object
+    // phrasing, per normFactTerm), `machine` is the same fact(s) in the compact
+    // notation ask.mjs's canonicalOf() uses for query-side parses, so both lanes
+    // share one consistent syntax.
+    const canonical = {
+      english: shown,
+      machine: res.triples
+        .map((t) => `fact(${JSON.stringify(normFactTerm(t.subject))}, ${JSON.stringify(t.predicate)}, ${JSON.stringify(normFactTerm(t.object))})`)
+        .join(", "),
+    };
+    return plainTurn(line, answer, { command: "assert", via: "assert", focus, canonical });
   } catch {
     return null; // grammar unavailable / write failed — fall through to the engine
   }
@@ -7129,6 +8082,78 @@ function morePage(query, { last, focus }) {
 // gain.
 const INDIRECT_REQUEST_RE = /^(?:i\s+(?:want|wanted)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+)\s*(.+)$/i;
 
+/** PLAN_CONVERSATION.md Finding 4's remaining gap: a DISCONTIGUOUS verb frame,
+ *  "SUBJECT uses OBJECT as its/a base(class)" — "uses" is split from its own
+ *  qualifier ("as its base") around the object, so no CONTIGUOUS phrase table
+ *  entry (VERB_TO_KIND/findPhrase, both ask-vocab.mjs/keywords.mjs, only ever
+ *  match a contiguous run of words) could ever register it. "uses" itself is
+ *  ALSO already claimed by the query-side "uses" UNION (imports+calls+
+ *  callsSymbol, KIND_UNIONS in ask.mjs) — a bare "X uses Y" must keep meaning
+ *  that; only THIS "...as its base"-qualified shape means the single stored
+ *  `inherits` relation (RELATIONS.inherits, ask-vocab.mjs — "Class -> Class:
+ *  subject's declared base resolves to object", the exact same subclassOf
+ *  semantics "is a kind of"/"inherits from" already carry).
+ *
+ *  Fixed here by REWRITING the raw turn text, once, before any dispatch lane
+ *  sees it (same early-rewrite spot as INDIRECT_REQUEST_RE just above) — into
+ *  the equivalent ALREADY-WORKING "is a kind of" surface form, rather than
+ *  inventing a parallel teach/ask mechanism for a brand-new predicate
+ *  vocabulary entry. "is a kind of" is itself one of RELATIONS.inherits.verbs
+ *  (ask-vocab.mjs), and its teach (bare "X is a kind of Y" -> rdfs:subClassOf)
+ *  and ask readbacks (ISA_ASK_RE yes/no; BARE_WHATIS_RE + splitMetaPredicate's
+ *  "what is X a kind of" forward read) are existing, separately-tested
+ *  mechanisms — reusing them end to end means this fix needs no new predicate,
+ *  no new stored fact shape, and no changes to factAnswer's cascade at all.
+ *
+ *  Four shapes recognized (checked in this order — see each RE's own
+ *  anchoring for why order matters: the WH-object and aux-fronted forms must
+ *  win before the bare-declarative TEACH form gets a chance to misread an
+ *  aux-fronted question's leading "does"/"what" as part of the subject):
+ *    1. mid-sentence WH-object ask ("SUBJECT uses which controller as its
+ *       base" / "SUBJECT uses what as its base" — Finding 4's own repro
+ *       shape) -> "what is SUBJECT a kind of";
+ *    2. WH-fronted forward ask ("what does SUBJECT use as its base") ->
+ *       "what is SUBJECT a kind of";
+ *    3. aux-fronted yes/no ask ("does SUBJECT use OBJECT as its base") ->
+ *       "is SUBJECT a kind of OBJECT";
+ *    4. bare declarative teach ("SUBJECT uses OBJECT as its base", never
+ *       ending in "?" — mirrors generalVerbTeach's own question-mark decline
+ *       guard) -> "SUBJECT is a kind of OBJECT".
+ *
+ *  The "as ___" qualifier tolerates the reasonable surface variants named in
+ *  the operator's own worked examples: an optional "its"/"the"/"a"/"an"
+ *  determiner (or none at all), and "base"/"parent"/"base class"/"parent
+ *  class" as the qualifier noun. */
+const BASE_QUALIFIER_SRC = "as\\s+(?:its|the|an?)?\\s*(?:base\\s+class|parent\\s+class|base|parent)";
+const USES_AS_BASE_WH_ASK_RE = new RegExp(
+  `^(.+?)\\s+uses?\\s+(?:which\\s+[\\w'-]+|what)\\s+${BASE_QUALIFIER_SRC}\\s*\\??$`, "i");
+const USES_AS_BASE_WHAT_FRONT_RE = new RegExp(
+  `^what\\s+(?:does|do|did)\\s+(.+?)\\s+uses?\\s+${BASE_QUALIFIER_SRC}\\s*\\??$`, "i");
+const USES_AS_BASE_YESNO_RE = new RegExp(
+  `^(?:does|do|did)\\s+(.+?)\\s+uses?\\s+(.+?)\\s+${BASE_QUALIFIER_SRC}\\s*\\??$`, "i");
+const USES_AS_BASE_TEACH_RE = new RegExp(
+  `^(.+?)\\s+uses?\\s+(.+?)\\s+${BASE_QUALIFIER_SRC}\\s*[.!]*$`, "i");
+
+/** Recognize + rewrite one of the four shapes above, or return null (no
+ *  match — the caller leaves the text untouched, same "honest decline, never
+ *  a guess" discipline as every other frame in this file). Pure text in, text
+ *  out — no grounding/lexicon lookups here, matching every other early-rewrite
+ *  step (INDIRECT_REQUEST_RE, normalize.mjs's own preamble frames). */
+function rewriteUsesAsBaseFrame(text) {
+  const t = String(text || "").trim();
+  if (!t) return null;
+  let m = t.match(USES_AS_BASE_WH_ASK_RE);
+  if (m) return `what is ${m[1].trim()} a kind of`;
+  m = t.match(USES_AS_BASE_WHAT_FRONT_RE);
+  if (m) return `what is ${m[1].trim()} a kind of`;
+  m = t.match(USES_AS_BASE_YESNO_RE);
+  if (m) return `is ${m[1].trim()} a kind of ${m[2].trim()}`;
+  if (/\?\s*$/.test(t)) return null; // an unrecognized question shape — never guessed as a teach
+  m = t.match(USES_AS_BASE_TEACH_RE);
+  if (m) return `${m[1].trim()} is a kind of ${m[2].trim()}`;
+  return 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 = {} } = {}) {
   const line = String(input ?? "").trim();
   // The captured residue is used for RECOGNITION at every dispatch site below
@@ -7136,7 +8161,15 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the ORIGINAL `line` survives untouched for record.query/logLines fidelity
   // — restored centrally inside withLast (below), once, for every dispatch path.
   const indirectMatch = line.match(INDIRECT_REQUEST_RE);
-  const workingLine = indirectMatch ? indirectMatch[1].trim() : line;
+  const preRewriteLine = indirectMatch ? indirectMatch[1].trim() : line;
+  // Finding 4's discontiguous-frame rewrite (rewriteUsesAsBaseFrame, above):
+  // applied here, once, before ANY dispatch lane (bareCmd/conversationalTurn/
+  // assertTurn/runAsk) sees the text — same reasoning as indirectMatch just
+  // above it. `baseFrameRewrite` is null (no-op) for every turn that doesn't
+  // match one of the four discontiguous shapes, so this can only ever ADD a
+  // recognized shape, never change behavior for anything else.
+  const baseFrameRewrite = rewriteUsesAsBaseFrame(preRewriteLine);
+  const workingLine = baseFrameRewrite || preRewriteLine;
   const templates = await chatTemplates(); // failure-tolerated: null degrades, never throws
   // narrate mode: allocate the mutable trace array ONLY when on (`null` when off,
   // matching every OTHER optional collaborator here — templates/memoryDir/lexicon
@@ -7164,10 +8197,11 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   const withLast = (result, fallbackGoal = "unclear — no goal signal for this turn type") => {
     const finished = finish(result, { graph });
     // Bug F point 3 fidelity: every dispatch path below built its own record off
-    // `workingLine` (the indirect-request wrapper stripped, above) — restore the
-    // ORIGINAL raw `line` into record.query and the logged "> …" transcript echo
-    // here, once, centrally, for every path (they all funnel through withLast).
-    if (indirectMatch) {
+    // `workingLine` (the indirect-request wrapper stripped, and/or Finding 4's
+    // discontiguous-frame rewrite applied, above) — restore the ORIGINAL raw
+    // `line` into record.query and the logged "> …" transcript echo here, once,
+    // centrally, for every path (they all funnel through withLast).
+    if (indirectMatch || baseFrameRewrite) {
       if (finished.record) finished.record.query = line;
       if (Array.isArray(finished.logLines) && finished.logLines.length > 1) finished.logLines[1] = `> ${line}`;
     }
@@ -7291,60 +8325,65 @@ export const SEED_PREFER = ["rdfs:subClassOf", "rdf:type", "mgx:usedFor", "mgx:p
  *  corpus seed, so re-runs skip without even reading the slice. */
 export const SEED_MARKER_REL = join(".tmct", "memory", "corpus-seed.json");
 
-/** Seed the starter corpus into <repo>/.tmct/memory once — a loop over every
- *  ACTIVE `corpus`-kind extension entry (src/extensions.mjs's resolveExtensions,
- *  the SAME seam `tmct init`'s seed step and `tmct init --corpus <id>` now
- *  share), in the resolver's FIXED order: seon first, then conceptnet, then any
- *  other active bundle sorted by name. seon runs first so its curated facts win
- *  the content-hash idempotency race — a term the ConceptNet slice also carries
- *  keeps the seon provenance. Idempotent twice over (the marker short-circuits;
- *  seedMemory content-hashes fact ids) and failure-tolerated PER BUNDLE
- *  (seedActiveCorpusEntries): one bad third-party pack degrades to "not seeded"
- *  for that bundle alone (its error is recorded, not silently swallowed) while
- *  every other bundle still lands — never an error before the prompt. Returns
- *  { appended, skipped, total, seon, conceptnet, perBundle } on a fresh seed
- *  (the banner counts stay honest), null when skipped/failed outright. */
-async function seedBootstrapMemory(repo) {
-  const marker = join(repo, SEED_MARKER_REL);
-  try {
-    await readFile(marker, "utf8");
-    return null; // already seeded — the marker is authoritative
-  } catch { /* no marker → first run */ }
+/** Bootstrap <repo> for tmct on a graph-less first run — PLAN_SEED.md §2's
+ *  `createSession`→`initRepo` auto-init CONVERGENCE: this used to run its own
+ *  bespoke seed-only pair (resolveExtensions + seedActiveCorpusEntries)
+ *  directly, writing ONLY the in-memory seed marker — a fresh `import {
+ *  runChat } from '...'; await runChat({repoPath})` on a bare directory got
+ *  seeded facts but no persisted, inspectable `tmct.toml`/`.tmct/init.json`,
+ *  unlike CLI `tmct init`. Now delegates to the FULL `initRepo(repo, {persona:
+ *  PERSONA_PRESETS.human, env})` — the exact same function `tmct init` calls
+ *  — so a library consumer gets the SAME "docker pull" first-run experience:
+ *  real `.tmct/` scaffold, a written `tmct.toml`, `.tmct/init.json`
+ *  provenance, not just a seed marker.
+ *
+ *  Verified NOT to double-scaffold or double-seed: `initRepo` only writes
+ *  `tmct.toml` when absent (or `force`), only writes the seed marker/reseeds
+ *  when the marker is absent, and its own provenance write is a plain
+ *  idempotent overwrite (never destructive) — every one of its own guards
+ *  fires correctly whether IT was the first call ever, or a repeat call after
+ *  a prior CLI `tmct init` (or a prior `createSession` bootstrap) already ran.
+ *  `persona: PERSONA_PRESETS.human` only has any effect on a genuinely FRESH
+ *  write (no existing tmct.toml) — on an already-initialized repo `initRepo`
+ *  reads the EXISTING file back untouched, so this can never override an
+ *  operator's own `--with-persona code`/custom `[extensions]` choice.
+ *
+ *  `entries`/`seedActiveCorpusEntries` are no longer called directly here —
+ *  `initRepo` calls them internally, in the SAME resolver's fixed order
+ *  (seon, conceptnet, then every other active bundle sorted by name).
+ *  Returns `initRepo`'s own `seedResult` ({ appended, skipped, total, seon,
+ *  conceptnet, perBundle }) on a fresh seed (the banner counts stay honest,
+ *  byte-identical shape to before), null when skipped/failed outright — the
+ *  CALLER's contract is unchanged even though the implementation now goes
+ *  through one shared code path instead of two. */
+async function seedBootstrapMemory(repo, env = process.env) {
   try {
-    const { entries } = await resolveExtensions(repo);
-    const { appended, skipped, total, perBundle } = await seedActiveCorpusEntries(repo, entries);
-    const res = {
-      appended, skipped, total, perBundle,
-      // seon/conceptnet stay named fields (not just perBundle lookups) so the
-      // banner's default two-bundle rendering (below) — and any external
-      // reader keyed on `.seon`/`.conceptnet` — stays byte-identical.
-      seon: perBundle.seon?.appended || 0,
-      conceptnet: perBundle.conceptnet?.appended || 0,
-    };
-    await mkdir(dirname(marker), { recursive: true });
-    await writeFile(marker, JSON.stringify({
-      seededAt: new Date().toISOString(),
-      appended: res.appended, skipped: res.skipped, seon: res.seon, conceptnet: res.conceptnet,
-      perBundle,
-    }) + "\n");
-    return res;
+    const { initRepo, PERSONA_PRESETS } = await import("./init.mjs");
+    const result = await initRepo(repo, { persona: PERSONA_PRESETS.human, env });
+    return result.seeded ? result.seedResult : null;
   } catch {
-    return null; // corpus unavailable — bootstrap proceeds unseeded
+    return null; // repo/corpus unavailable — bootstrap proceeds unseeded
   }
 }
 
-/** The seed banner line — byte-identical to before for the default zero-config
- *  seon+conceptnet case; a THIRD (or more) active bundle appends its own
- *  "<n> <bundle-name>" clause rather than changing the base sentence, so a
- *  fresh `TMCT_NO_SEED`-unset run with no tmct.toml renders EXACTLY what
- *  test/wiring-seed.test.mjs's SEED_BANNER_RE already pins. */
+/** The seed banner line — BUNDLE-LIST-DRIVEN (PLAN_SEED.md §2 fix): renders
+ *  every `perBundle` entry that actually appended facts this run, in the
+ *  entries' own fixed order (src/extensions.mjs's resolveExtensions —
+ *  seon, conceptnet, then the rest sorted by name), joined with " + ". No
+ *  bundle is privileged as one of "the first two" any more — with the
+ *  persona flip (seon/conceptnet now opt-in, `human` the new default) the
+ *  old hardcoded "N curated SEON + N ConceptNet" shape would render the
+ *  misleading "seeded 664 starter facts (0 curated SEON + 0 ConceptNet + 664
+ *  human)" for the new default. A single active bundle renders with no
+ *  " + " at all ("seeded 664 starter facts (664 human) — …"), matching the
+ *  common case cleanly. test/wiring-seed.test.mjs's SEED_BANNER_RE is
+ *  relaxed to match this generic form (still asserting the SHAPE, not a
+ *  brittle literal — see that test file's own header comment). */
 function seedBannerLine(seeded) {
-  const extra = Object.entries(seeded.perBundle || {})
-    .filter(([name]) => name !== "seon" && name !== "conceptnet")
+  const clauses = Object.entries(seeded.perBundle || {})
     .filter(([, r]) => r && r.appended > 0)
     .map(([name, r]) => `${r.appended} ${name}`);
-  const extraClause = extra.length ? ` + ${extra.join(" + ")}` : "";
-  return `seeded ${seeded.appended} starter facts (${seeded.seon} curated SEON + ${seeded.conceptnet} ConceptNet${extraClause}) — /memory to inspect`;
+  return `seeded ${seeded.appended} starter facts (${clauses.join(" + ")}) — /memory to inspect`;
 }
 
 /** Whether THIS repo's memory actually carries the corpus seed — the marker is
@@ -7363,15 +8402,16 @@ async function hasSeededVocabulary(repo) {
 /** A "try this" vocabulary-example clause that's PROVABLY correct in the session
  *  it's shown, mirroring the discipline orientationExamples() already applies to
  *  structural examples (never offer an example that isn't confirmed to resolve).
- *  `cache` is confirmed live: present in corpus/seon/definitions.jsonl, backed by
- *  a corpus:seon concept fact, and a recognized lexicon noun — but only actually
- *  answerable once the seed has run. When it hasn't (TMCT_NO_SEED=1,
- *  seed.enabled=false, or corpus load failure), offering it would be a lie worse
- *  than no example — swap to an unconditionally-true pointer instead (the teach
- *  lane and `tmct init` both work with zero preconditions). Computed ONCE per
- *  session (createSession), not per turn.
+ *  `dog` is confirmed live (PLAN_SEED.md's default human-world persona): present
+ *  in corpus/tier2/human.jsonl's human-nature clump, backed by a corpus:human
+ *  concept fact, and a recognized lexicon noun — but only actually answerable
+ *  once the seed has run. When it hasn't (TMCT_NO_SEED=1, seed.enabled=false, or
+ *  corpus load failure), offering it would be a lie worse than no example —
+ *  swap to an unconditionally-true pointer instead (the teach lane and `tmct
+ *  init` both work with zero preconditions). Computed ONCE per session
+ *  (createSession), not per turn.
  *  The unseeded branch's teach clause is a CONCRETE pair too, for the same
- *  reason `cache` is concrete in the seeded branch: playtest found that an
+ *  reason `dog` is concrete in the seeded branch: playtest found that an
  *  abstract "every X is a Y" invites a curious user to fill X/Y with an
  *  intuitive-but-unknown word ("every cache is a thing" — "thing" isn't in
  *  the closed ACE lexicon) and hit the teach-miss dead-end right after being
@@ -7380,7 +8420,7 @@ async function hasSeededVocabulary(repo) {
  *  test/chatflow-tier0.test.mjs), so the offer resolves if copied verbatim. */
 function vocabExampleHint(seeded) {
   return seeded
-    ? 'Try "what is a cache" for general vocabulary.'
+    ? 'Try "what is a dog" for general vocabulary.'
     : 'Run `tmct init` to seed a starter vocabulary, or teach me directly, e.g. "every bug is an issue".';
 }
 
@@ -7428,12 +8468,24 @@ const promptFor = (focus) => (focus ? `tmct(${shortLabel(focus.label)})> ` : PRO
  */
 export async function createSession({
   repoPath,
+  graphPaths,
+  configPath,
   source = defaultSource,
   env = process.env,
   cwd = process.cwd(),
   gitRoot = gitToplevel,
   ephemeral = false,
   narrate = false,
+  // PLAN_SEED.md §6's storage-backend seam: "file" (default, unchanged) keeps
+  // memoryDir a plain repo-path string (Backend A, memory/core.mjs). "memory"
+  // selects Backend B (createInMemoryStore — zero disk I/O, session-scoped, no
+  // module-global state). "sqlite" selects Backend C (createSqliteMemoryStore
+  // — a live node:sqlite connection kept open for the session's lifetime,
+  // lazily imported only when this is actually chosen). TMCT_MEMORY_BACKEND
+  // mirrors the TMCT_EPHEMERAL/TMCT_NARRATE on/off env convention. No CLI flag
+  // wires this yet (bin/tmct.mjs's flag parsing is out of this change's
+  // scope) — a library/test caller sets the option directly for now.
+  memoryBackend = null,
 } = {}) {
   // EPHEMERAL mode (--ephemeral, or TMCT_EPHEMERAL=1): read the target graph but
   // write NOTHING back into it. The shipped examples run this way so a demo never
@@ -7449,27 +8501,59 @@ export async function createSession({
   // (see `turn()` below: a turn result's `narrate` field, when present,
   // updates this closure-private variable). Default OFF, as the operator asked.
   let narrateOn = narrate || /^(1|true|yes)$/i.test(String(env.TMCT_NARRATE || ""));
-  // Graph resolution order for the chat surface (documented; --repo wins):
-  //   1. --repo <path>       → pins <path>/.tmct/graph.json (repo AND graph).
-  //   2. TMCT_GRAPH_FILE env → loads that graph anywhere (loadConfig reads it), so
-  //      `TMCT_GRAPH_FILE=<path> tmct chat` works even inside a git repo — the chat
-  //      surface used to ignore it (only the `cli` tool path honoured it). The repo
-  //      for logs/memory is still the git root / cwd; only the graph file is overridden.
-  //   3. git root            → <root>/.tmct/graph.json (the default target).
-  //   4. cwd                 → <cwd>/.tmct/graph.json (not a git repo).
+  // Graph resolution order for the chat surface (documented; --repo still
+  // wins over TMCT_GRAPH_FILE env — a deliberate, TESTED chat-specific
+  // contract predating this batch: an explicit --repo means "use exactly
+  // this repo's graph", never silently redirected by env. Every other tier
+  // below delegates to the shared resolver, src/cli-args.mjs's
+  // resolveRuntimeConfig:
+  //   0. --graph <path> (repeatable, graphPaths) → the NEW top tier: an explicit
+  //      graph file (or files — multi-graph, see src/graph-merge.mjs), wins
+  //      outright over everything below, including --repo.
+  //   1. --repo <path>       → pins <path>/.tmct/graph.json (repo AND graph);
+  //      tmct.toml's graph_file/graph_files at that repo is now ALSO consulted
+  //      (new — chat used to hardcode the default regardless of tmct.toml),
+  //      but TMCT_GRAPH_FILE env is deliberately excluded from this tier.
+  //   2. TMCT_GRAPH_FILE env → loads that graph anywhere, so
+  //      `TMCT_GRAPH_FILE=<path> tmct chat` works even inside a git repo.
+  //   3. tmct.toml's graph_file/graph_files at the resolved repo root (--config
+  //      <path>, `configPath`, can point this at an alternate location) — NEW.
+  //   4. git root            → <root>/.tmct/graph.json (the default target).
+  //   5. cwd                 → <cwd>/.tmct/graph.json (not a git repo).
   // Default the target to the GIT ROOT, not raw cwd: running from a nested package
   // dir (npm sets cwd there) would otherwise index only that package's ~few modules
   // instead of the whole repo.
   let repo;
   let config;
-  if (repoPath) { repo = repoPath; config = configFor(repoPath); }
-  else {
+  const explicitGraphs = (graphPaths || []).filter(Boolean);
+  if (explicitGraphs.length) {
+    repo = repoPath || gitRoot(cwd) || cwd;
+    const resolvedGraphs = explicitGraphs.map((p) => resolve(cwd, p));
+    config = resolvedGraphs.length > 1
+      ? { graphFile: resolvedGraphs[0], graphFiles: resolvedGraphs }
+      : { graphFile: resolvedGraphs[0] };
+  } else if (repoPath) {
+    repo = repoPath;
+    // env is deliberately withheld from resolveRuntimeConfig here (passed as
+    // {}), so its own env-beats-repo-default tier can never fire — the ONLY
+    // way this differs from the old hardcoded `{graphFile: join(repoPath,
+    // DEFAULT_GRAPH_REL)}` default is that a repo's own tmct.toml
+    // graph_file/graph_files (or an explicit --config override) is now
+    // honored too.
+    const argv = ["--repo", repoPath];
+    if (configPath) argv.push("--config", configPath);
+    ({ config } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
+  } else {
     const root = gitRoot(cwd);
     repo = root || cwd;
     const envGraph = env.TMCT_GRAPH_FILE && String(env.TMCT_GRAPH_FILE).trim();
-    // TMCT_GRAPH_FILE (via loadConfig) overrides the repo-derived default graph path;
-    // otherwise the repo's own .tmct/graph.json is the target.
-    config = envGraph ? loadConfig(env, cwd) : { graphFile: join(repo, DEFAULT_GRAPH_REL) };
+    if (envGraph) {
+      config = loadConfig(env, cwd);
+    } else {
+      const argv = [];
+      if (configPath) argv.push("--config", configPath);
+      ({ config } = await resolveRuntimeConfig({ argv, cwd, env, gitRoot }));
+    }
   }
 
   // Ephemeral: keep config.graphFile pointing at the READ graph, but divert the
@@ -7545,15 +8629,62 @@ export async function createSession({
     catch { /* best-effort — see above */ }
   };
 
+  // PLAN_SEED.md §6's storage-backend seam: `memoryDir` is the opaque token
+  // every memory/core.mjs call in this file threads through unchanged (it
+  // never inspects `dir` itself — that's the whole point of the seam). Backend
+  // A (default, unchanged) keeps it the plain repo string every earlier
+  // version of this function used. Backend B/C swap in a handle instead;
+  // `closeMemoryStore` is a no-op unless Backend C actually opened a
+  // connection (Backend C's node:sqlite import is lazy — it only happens if
+  // this branch is actually taken).
+  const backendChoice = String(memoryBackend || env.TMCT_MEMORY_BACKEND || "").trim().toLowerCase();
+  let memoryDir = repo;
+  let closeMemoryStore = async () => {};
+  if (backendChoice === "memory") {
+    const { createInMemoryStore } = await import("./memory/core.mjs");
+    memoryDir = createInMemoryStore();
+  } else if (backendChoice === "sqlite") {
+    const { createSqliteMemoryStore, closeSqliteMemoryStore } = await import("./memory/core.mjs");
+    const dbPath = join(repo, ".tmct", "memory", "graph.sqlite");
+    await mkdir(dirname(dbPath), { recursive: true });
+    const handle = await createSqliteMemoryStore(dbPath);
+    memoryDir = handle;
+    closeMemoryStore = async () => closeSqliteMemoryStore(handle);
+  }
+
   const empty = graph.individuals.length === 0;
   // W3: FIRST RUN in a graph-less repo seeds a capped ConceptNet slice into
   // .tmct/memory so vocabulary questions ("what is a cache?") have something
   // honest to stand on from turn one. Guarded three ways: only the empty
   // bootstrap (a fixture/provider graph never seeds), only once (the marker),
   // and never when TMCT_NO_SEED=1 opts out.
+  //
+  // Backend B/C follow-ups (documented, not fixed here — out of this change's
+  // scope):
+  //   - seedBootstrapMemory/seedActiveCorpusEntries/hasSeededVocabulary all
+  //     resolve their own marker file + corpus writes directly off the STRING
+  //     `repo` path (extensions.mjs territory, not touched by this seam), so
+  //     they'd seed the on-disk Backend-A file even for a Backend B/C session
+  //     rather than the handle actually in use. Skipping W3 seeding for a
+  //     non-default backend is the honest choice for now.
+  //   - sessions.mjs's OWN per-turn utterance mirror (appendSessionToGraph ->
+  //     recordSessionMemory -> appendUtterances) derives its OWN repoDir from
+  //     config.graphFile independently of this function's `memoryDir`, and
+  //     reads the session LOG/sidecar files by real path — it can't simply be
+  //     handed a Backend B/C handle (that path needs a real directory for the
+  //     log/sidecar reads, not just for the memory write). So a Backend B/C
+  //     session's Utterance/Session individuals (NEVER Facts/Rules — those
+  //     only ever go through THIS function's `memoryDir`, see runTurn's
+  //     options below) still land in an ordinary Backend-A .tmct/memory/
+  //     graph.json, independent of the chosen backend. Teaching that path to
+  //     thread a handle too (and fold.mjs's own direct writeMemoryGraph
+  //     alongside it) is future work for whoever finishes the seeding/persona
+  //     work (PLAN_SEED.md's own §2/§3) — out of this change's scope.
+  //     Taught FACTS themselves are unaffected by this gap: only the
+  //     conversational transcript mirror leaks onto disk, never the facts.
   let seeded = null;
-  if (empty && String(env.TMCT_NO_SEED || "") !== "1") {
-    seeded = await seedBootstrapMemory(repo);
+  if (empty && backendChoice === "" && String(env.TMCT_NO_SEED || "") !== "1") {
+    seeded = await seedBootstrapMemory(repo, env);
   }
   // vocabHint: computed ONCE per session (not per-turn — see runTurn's own
   // per-call fallback for direct/library callers). `seeded` is only truthy when
@@ -7593,7 +8724,7 @@ export async function createSession({
   let closed = false;
 
   return {
-    repo, config, graph, lexicon, memoryDir: repo, moduleCount, version, sessionId,
+    repo, config, graph, lexicon, memoryDir, moduleCount, version, sessionId,
     logFile, sidecarFile, bannerLines, empty, biasByBundle,
     // Mutable between-turn state — read-only to the caller, so a shell can render the
     // prompt/expand-hint without reaching into runTurn's threading.
@@ -7612,7 +8743,7 @@ export async function createSession({
     async turn(line) {
       let result;
       try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir: repo, 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 });
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);
@@ -7645,7 +8776,8 @@ export async function createSession({
     },
 
     /** End-of-session close: end lines in both artifacts, the final graph upsert
-     *  (which also triggers the memory fold), stream flush. Idempotent. */
+     *  (which also triggers the memory fold), stream flush, the Backend C
+     *  connection close (a no-op for Backend A/B). Idempotent. */
     async close() {
       if (closed) return;
       closed = true;
@@ -7655,6 +8787,7 @@ export async function createSession({
       await upsertGraph(endIso);
       await new Promise((resolve) => stream.end(resolve));
       await new Promise((resolve) => sidecar.end(resolve));
+      await closeMemoryStore();
     },
   };
 }
@@ -7669,6 +8802,8 @@ export async function createSession({
  */
 export async function runChat({
   repoPath,
+  graphPaths,
+  configPath,
   input = process.stdin,
   output = process.stdout,
   source = defaultSource,
@@ -7677,6 +8812,7 @@ export async function runChat({
   gitRoot = gitToplevel,
   ephemeral = false,
   narrate = false,
+  memoryBackend = null,
 } = {}) {
   // createSession's first-run seed (~2-3s, corpus/seon + ConceptNet) produces ZERO
   // output until it fully resolves — found live: an operator reported `npm run chat`
@@ -7684,7 +8820,7 @@ export async function runChat({
   // fast subsequent run just flashes it briefly) and removes the "is this even
   // running" uncertainty during the one case that's genuinely slow.
   output.write("tmct — starting…\n");
-  const session = await createSession({ repoPath, source, env, cwd, gitRoot, ephemeral, narrate });
+  const session = await createSession({ repoPath, graphPaths, configPath, source, env, cwd, gitRoot, ephemeral, narrate, memoryBackend });
 
   const dim = (s) => (env.NO_COLOR || !output.isTTY ? s : `\x1b[2m${s}\x1b[0m`);
   for (const line of session.bannerLines) output.write(dim(line) + "\n");